Debido al poder de Bert, su clasificación de texto ha logrado muy buenos resultados. Mejorar la solidez del modelo a través del entrenamiento adversario es una dirección de investigación muy significativa. Lo siguiente se discutirá con usted a través del combate de código real. Entrenamiento adversario en el campo de clasificación de texto de Bert aplicaciones
Tabla de contenido
1. La clasificación de texto Bert agrega perturbaciones a input_ids
2. La clasificación de texto Bert agrega perturbaciones a la incrustación
5. Métodos de defensa contra muestras antagónicas
1. La clasificación de texto Bert agrega perturbaciones a input_ids
Python implementa el aprendizaje contradictorio basado en la clasificación de texto bert. Podemos usar la biblioteca PyTorch y Transformers para implementar la clasificación de texto basada en el modelo BERT y aplicar el aprendizaje contradictorio durante el entrenamiento para mejorar la solidez del modelo.
Primero, necesitamos instalar las bibliotecas necesarias:
pip install torch transformers -i https://pypi.tuna.tsinghua.edu.cn/simple
A continuación, escribamos código para implementar un modelo de clasificación de texto basado en BERT:
import torch
import torch.nn as nn
from transformers import BertModel, BertTokenizer
class BertForTextClassification(nn.Module):
def __init__(self, bert_model_path, num_classes):
super().__init__()
self.bert_model = BertModel.from_pretrained(bert_model_path)
self.dropout = nn.Dropout(0.1)
self.classifier = nn.Linear(self.bert_model.config.hidden_size, num_classes)
def forward(self, input_ids, attention_mask):
outputs = self.bert_model(input_ids, attention_mask=attention_mask)
pooled_output = outputs[1]
pooled_output = self.dropout(pooled_output)
logits = self.classifier(pooled_output)
return logits
Este modelo utiliza un modelo BERT preentrenado como extractor de características y agrega una capa lineal para la clasificación. También utilizamos la deserción para reducir el sobreajuste.
A continuación, necesitamos definir las funciones de formación y evaluación:
def train(model, train_dataloader, optimizer, criterion, epsilon):
model.train()
total_loss, total_correct = 0., 0.
for batch in train_dataloader:
batch = tuple(t.to(device) for t in batch)
input_ids, attention_mask, labels = batch
# adversarial training
if epsilon:
delta = torch.zeros_like(input_ids).uniform_(-epsilon, epsilon)
delta = delta.to(device)
output = model(input_ids + delta, attention_mask=attention_mask)
else:
output = model(input_ids, attention_mask=attention_mask)
loss = criterion(output, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
_, predicted = torch.max(output.data, 1)
total_correct += (predicted == labels).sum().item()
return total_loss / len(train_dataloader), total_correct / len(train_dataloader.dataset)
def evaluate(model, test_dataloader):
model.eval()
total_loss, total_correct = 0., 0.
with torch.no_grad():
for batch in test_dataloader:
batch = tuple(t.to(device) for t in batch)
input_ids, attention_mask, labels = batch
output = model(input_ids, attention_mask=attention_mask)
loss = criterion(output, labels)
total_loss += loss.item()
_, predicted = torch.max(output.data, 1)
total_correct += (predicted == labels).sum().item()
return total_loss / len(test_dataloader), total_correct / len(test_dataloader.dataset)
Las funciones de las funciones anteriores train se utilizan para entrenar el modelo y respaldar el entrenamiento adversario. epsilon El parámetro controla el tamaño de los ejemplos contradictorios. Si epsilones 0, se utiliza el método de entrenamiento estándar; si epsilones mayor que 0, se agrega una pequeña perturbación a cada muestra para obtener una muestra contradictoria. evaluatefunción para evaluar el rendimiento del modelo en los datos de prueba.
Finalmente, podemos escribir la función principal para cargar el conjunto de datos y comenzar a entrenar el modelo:
def load_data():
# your code to load dataset here
pass
if __name__ == '__main__':
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
bert_model_path = 'bert-base-uncased'
num_classes = 2
epsilon = 0.0 # set to non-zero value for adversarial training
# load data
train_dataloader, test_dataloader = load_data()
# create model, optimizer, loss function
model = BertForTextClassification(bert_model_path, num_classes)
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=5e-5)
criterion = nn.CrossEntropyLoss()
# train and evaluate the model
for epoch in range(10):
train_loss, train_acc = train(model, train_dataloader, optimizer, criterion, epsilon=epsilon)
test_loss, test_acc = evaluate(model, test_dataloader)
print(f"Epoch {epoch+1} - Train Loss: {train_loss:.4f} - Train Acc: {train_acc:.4f} - Test Loss: {test_loss:.4f} - Test Acc: {test_acc:.4f}")
load_data El usuario debe implementar las funciones en el código anterior para cargar y procesar el conjunto de datos requerido. En este ejemplo, usamos el conjunto de datos de clasificación de texto BERT basado en Google, que incluye una tarea de clasificación binaria.
2. La clasificación de texto Bert agrega perturbaciones a la incrustación
Python implementa el aprendizaje contradictorio basado en la clasificación de texto de bert para agregar perturbaciones a la incrustación. Basado en el ejemplo implementado por PyTorch y la biblioteca Transformers, este ejemplo usa muestras contradictorias para el entrenamiento a fin de mejorar la solidez del modelo.
En este ejemplo, usaremos FGSM para perturbar los vectores de incrustación para generar muestras de texto antagónicas. FGSM es una técnica de ataque de adversario simple pero efectiva, y su idea básica es usar el cálculo de gradiente para perturbar el modelo de modo que pueda producir resultados de predicción erróneos.
Aquí está el código de ejemplo:
import torch
import torch.nn.functional as F
from transformers import BertForSequenceClassification, BertTokenizer
# 加载BERT模型和Tokenizer
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
# 定义对抗性扰动函数
def fgsm_attack(embeddings, gradient, epsilon):
# 计算扰动的符号
sign_gradient = gradient.sign()
# 计算embedding的对抗性扰动
perturbed_embeddings = embeddings + epsilon*sign_gradient
# 将扰动后的embedding截断在[-1, 1]之间
perturbed_embeddings = torch.clamp(perturbed_embeddings, min=-1, max=1)
return perturbed_embeddings
# 训练模型
def train(model, optimizer, train_loader, epsilon):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
data = data.to(device)
target = target.to(device)
# 对输入的embedding添加对抗性扰动
embeddings = model.bert.embeddings.word_embeddings(data)
embeddings.requires_grad = True
output = model(inputs_embeds=embeddings, attention_mask=(data>0).to(data.device))
loss = F.cross_entropy(output.logits, target)
loss.backward()
# 生成对抗性样本
gradient = embeddings.grad.data
perturbed_embeddings = fgsm_attack(embeddings.data, gradient, epsilon)
# 重新计算模型输出
adv_logits = model(inputs_embeds=perturbed_embeddings, attention_mask=(data>0).to(data.device)).logits
# 计算对抗性训练损失
adv_loss = F.cross_entropy(adv_logits, target)
total_loss = loss + adv_loss
total_loss.backward()
optimizer.step()
# 测试模型
def test(model, test_loader):
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
data = data.to(device)
target = target.to(device)
output = model(data, attention_mask=(data>0).to(data.device))
test_loss += F.cross_entropy(output.logits, target, reduction='sum').item()
pred = output.logits.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
accuracy = 100. * correct / len(test_loader.dataset)
print('Average loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)'.format(
test_loss, correct, len(test_loader.dataset), accuracy))
# 加载数据
def load_data():
# 加载数据集
# TODO: 根据您的数据集实现此函数
pass
# 定义超参数
batch_size = 32
learning_rate = 5e-5
epochs = 10
epsilon = 0.1
# 加载数据
train_loader, test_loader = load_data()
# 将模型和数据加载到GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
# 定义优化器
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# 训练模型
for epoch in range(epochs):
print("Epoch:", epoch+1)
train(model, optimizer, train_loader, epsilon)
test(model, test_loader)
load_data Se requieren funciones de sustitución para implementar su propio conjunto de datos y ajustar los hiperparámetros según sea necesario. Además, para usar este código, debe usar las bibliotecas PyTorch y Transformers (la biblioteca de procesamiento de lenguaje natural del equipo Hugging Face).
3. Bert implementa la clasificación de texto y usa FGSM para agregar perturbaciones a la incrustación
Python implementa el aprendizaje contradictorio basado en la clasificación de texto chino bert que utiliza la perturbación agregada a la incrustación para mejorar la precisión de la clasificación de texto chino
Clasificación de texto chino utilizando el modelo Bert preentrenado de PyTorch y entrenamiento con ejemplos contradictorios para mejorar la solidez del modelo.
El aprendizaje adversarial se divide principalmente en los siguientes tres pasos:
- Genere muestras antagónicas: use el algoritmo FGSM para perturbar la incrustación del texto para generar muestras antagónicas de texto.
- Calcule la pérdida contradictoria: use las muestras contradictorias y las muestras normales para clasificar y calcular la función de pérdida.
- Actualizar parámetros del modelo: actualice los parámetros del modelo de acuerdo con los valores de pérdida de las muestras antagónicas y normales.
El siguiente es el código de implementación completo, solo necesita modificar load_data el código en la función de acuerdo con su propio conjunto de datos.
import torch
import torch.nn as nn
from transformers import BertTokenizer, BertModel
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
# 加载预训练Bert模型和tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
model = BertModel.from_pretrained('bert-base-chinese').to(device)
# 分类模型
class BertClassifier(nn.Module):
def __init__(self, num_classes):
super(BertClassifier, self).__init__()
self.bert = BertModel.from_pretrained('bert-base-chinese')
self.fc = nn.Linear(768, num_classes)
def forward(self, input_ids, attention_mask):
outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
pooled_output = outputs[1]
out = self.fc(pooled_output)
return out
# 定义对抗扰动攻击函数
def fgsm_attack(embeds, grad, epsilon=0.3):
sign_grad = grad.sign()
perturb = epsilon * sign_grad
perturb_embeds = embeds + perturb
return perturb_embeds
# 加载数据集
def load_data(file_path):
# 在此处实现加载数据集的代码
return train_data, valid_data, test_data
# 训练模型
def train_model(model, criterion, optimizer, scheduler, train_data, valid_data, num_epochs=10):
best_acc = 0.0
for epoch in range(num_epochs):
model.train()
running_loss = 0.0
correct = 0
total = 0
for data in train_data:
texts, labels = data.text, data.label
input_ids = []
attention_masks = []
for text in texts:
encoded_dict = tokenizer.encode_plus(
text, # 文本数据
add_special_tokens = True, # 添加 '[CLS]' 和 '[SEP]'
max_length = 128, # 设置最大长度
pad_to_max_length = True, # 使用padding
return_attention_mask = True, # 返回attention mask
return_tensors = 'pt', # 返回PyTorch张量格式的输出
)
input_ids.append(encoded_dict['input_ids'])
attention_masks.append(encoded_dict['attention_mask'])
# 将列表转换为张量形式
input_ids = torch.cat(input_ids, dim=0).to(device)
attention_masks = torch.cat(attention_masks, dim=0).to(device)
labels = labels.to(device)
optimizer.zero_grad()
# 对抗性样本训练
input_ids.requires_grad_()
attention_masks.requires_grad_()
output = model(input_ids, attention_masks)
loss = criterion(output, labels)
loss.backward()
grad = input_ids.grad.data
perturb_input_ids = fgsm_attack(input_ids, grad, epsilon=0.3)
perturb_output = model(perturb_input_ids, attention_masks)
perturb_loss = criterion(perturb_output, labels)
adv_loss = 0.5 * loss + 0.5 * perturb_loss
_, predicted = torch.max(output.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
adv_loss.backward()
optimizer.step()
running_loss += adv_loss.item()
scheduler.step()
# 在验证集上计算准确率
model.eval()
valid_loss = 0.0
valid_correct = 0
valid_total = 0
with torch.no_grad():
for data in valid_data:
texts, labels = data.text, data.label
input_ids = []
attention_masks = []
for text in texts:
encoded_dict = tokenizer.encode_plus(
text, # 文本数据
add_special_tokens = True, # 添加 '[CLS]' 和 '[SEP]'
max_length = 128, # 设置最大长度
pad_to_max_length = True, # 使用padding
return_attention_mask = True, # 返回attention mask
return_tensors = 'pt', # 返回PyTorch张量格式的输出
)
input_ids.append(encoded_dict['input_ids'])
attention_masks.append(encoded_dict['attention_mask'])
# 将列表转换为张量形式
input_ids = torch.cat(input_ids, dim=0).to(device)
attention_masks = torch.cat(attention_masks, dim=0).to(device)
labels = labels.to(device)
output = model(input_ids, attention_masks)
loss = criterion(output, labels)
valid_loss += loss.item()
_, predicted = torch.max(output.data, 1)
valid_total += labels.size(0)
valid_correct += (predicted == labels).sum().item()
epoch_loss = running_loss / len(train_data)
epoch_acc = correct / total
valid_loss = valid_loss / len(valid_data)
valid_acc = valid_correct / valid_total
print('Epoch [{}/{}], train_loss: {:.4f}, train_acc: {:.4f}, valid_loss: {:.4f}, valid_acc: {:.4f}'.format(epoch+1, num_epochs, epoch_loss, epoch_acc, valid_loss, valid_acc))
if valid_acc > best_acc:
best_acc = valid_acc
return model
# 加载数据
train_data, valid_data, test_data = load_data('./data/train.csv')
# 设置超参数
num_classes = 2
learning_rate = 2e-5
num_epochs = 10
batch_size = 32
# 构造Bert分类器模型
classifier = BertClassifier(num_classes).to(device)
# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(params=classifier.parameters(), lr=learning_rate)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.1)
# 训练模型
trained_model = train_model(classifier, criterion, optimizer, scheduler, train_data, valid_data, num_epochs=num_epochs)
# 在测试集上进行测试
test_loss = 0.0
test_correct = 0
test_total = 0
with torch.no_grad():
for data in test_data:
texts, labels = data.text, data.label
input_ids = []
attention_masks = []
for text in texts:
encoded_dict = tokenizer.encode_plus(
text, # 文本数据
add_special_tokens = True, # 添加 '[CLS]' 和 '[SEP]'
max_length = 128, # 设置最大长度
pad_to_max_length = True, # 使用padding
return_attention_mask = True, # 返回attention mask
return_tensors = 'pt', # 返回PyTorch张量格式的输出
)
input_ids.append(encoded_dict['input_ids'])
attention_masks.append(encoded_dict['attention_mask'])
# 将列表转换为张量形式
input_ids = torch.cat(input_ids, dim=0).to(device)
attention_masks = torch.cat(attention_masks, dim=0).to(device)
labels = labels.to(device)
output = trained_model(input_ids, attention_masks)
loss = criterion(output, labels)
test_loss += loss.item()
_, predicted = torch.max(output.data, 1)
test_total += labels.size(0)
test_correct += (predicted == labels).sum().item()
test_loss = test_loss / len(test_data)
test_acc = test_correct / test_total
print('Test_loss: {:.4f}, Test_acc: {:.4f}'.format(test_loss, test_acc))
Cabe señalar que este ejemplo solo considera el ataque a muestras normales. En aplicaciones prácticas, también se debe considerar la defensa contra ejemplos adversarios. Si necesita obtener más información sobre los métodos de defensa contra adversarios, puede consultar la defensa contra adversarios GitHub - Trusted-AI/adversarial-robustness-toolbox: Adversarial Robustness Toolbox (ART) - Biblioteca de Python para seguridad de aprendizaje automático - Evasión, envenenamiento, extracción, inferencia - Equipos rojo y azul
4. La clasificación de texto Bert agrega perturbación a la incrustación y considera la defensa contra muestras
Python implementa el aprendizaje contradictorio basado en la clasificación de texto chino bert que agrega perturbación a la incrustación, mejora la precisión de la clasificación de texto chino y tiene en cuenta la defensa de las muestras contradictorias
import random
import jieba
import torch
import torch.nn as nn
from transformers import BertTokenizer, BertModel
from torch.utils.data import Dataset, DataLoader
from torch.optim import Adam
from torch.nn.utils.rnn import pad_sequence
from torch.utils.tensorboard import SummaryWriter
# 设定随机种子
random.seed(42)
torch.manual_seed(42)
# BERT模型和tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
bert_model = BertModel.from_pretrained('bert-base-chinese')
# 自定义的中文文本分类器
class TextClassifier(nn.Module):
def __init__(self, bert_model, num_classes):
super(TextClassifier, self).__init__()
self.bert = bert_model
self.fc = nn.Linear(768, num_classes)
def forward(self, input_ids, attention_mask):
outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
pooled_output = outputs[1]
logits = self.fc(pooled_output)
return logits
# 加载数据集函数
def load_data(file_path):
data = []
with open(file_path, encoding='utf-8') as f:
for line in f:
text, label = line.strip().split('\t')
label = int(label)
seg_list = jieba.cut(text)
text = ' '.join(seg_list)
data.append((text, label))
return data
# 构建dataset和dataloader
class TextDataset(Dataset):
def __init__(self, data, tokenizer):
self.sentences = [item[0] for item in data]
self.labels = [item[1] for item in data]
self.tokenizer = tokenizer
def __len__(self):
return len(self.sentences)
def __getitem__(self, index):
sentence = self.sentences[index]
label = self.labels[index]
encoded_dict = self.tokenizer.encode_plus(
sentence, # 输入文本
add_special_tokens = True, # 添加 '[CLS]' 和 '[SEP]'
max_length = 32, # 填充 & 截断长度
pad_to_max_length = True,
return_attention_mask = True, # 返回 attention mask
return_tensors = 'pt', # 返回 pytorch tensor
)
input_ids = encoded_dict['input_ids'][0]
attention_mask = encoded_dict['attention_mask'][0]
return input_ids, attention_mask, label
def collate_fn(batch):
# 按输入文本长度排序，pad_sequence所需要的batch需要排序后的
batch.sort(key=lambda x: len(x[0]), reverse=True)
input_ids, attention_masks, labels = zip(*batch)
input_ids = pad_sequence(input_ids, batch_first=True)
attention_masks = pad_sequence(attention_masks, batch_first=True)
return input_ids, attention_masks, torch.tensor(labels)
def train(model, train_loader, optimizer, criterion, num_epochs):
writer = SummaryWriter()
global_step = 0
for epoch in range(num_epochs):
total_loss = 0
for i, (input_ids, attention_mask, labels) in enumerate(train_loader):
print(input_ids.shape)
optimizer.zero_grad()
logits = model(input_ids, attention_mask)
loss = criterion(logits, labels)
total_loss += loss.item()
loss.backward()
# 对embedding向量进行扰动
epsilon = 0.5
step_size = 0.05
perturbation = torch.zeros_like(input_ids).uniform_(-epsilon, epsilon)
perturbation.requires_grad_()
logits_perturbed = model(input_ids+perturbation, attention_mask)
loss_perturbed = criterion(logits_perturbed, labels)
loss_perturbed.backward()
perturbation = step_size * perturbation.grad
with torch.no_grad():
input_ids = input_ids+perturbation
input_ids.clamp_(0, tokenizer.vocab_size-1)
optimizer.step()
global_step += 1
if global_step % 10 == 0:
writer.add_scalar('training_loss', loss.item(), global_step)
avg_loss = total_loss / len(train_loader)
print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch + 1, num_epochs, avg_loss))
writer.close()
def test(model, test_loader):
total = 0
correct = 0
with torch.no_grad():
for input_ids, attention_mask, labels in test_loader:
logits = model(input_ids, attention_mask)
predicted = torch.argmax(logits, dim=1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = correct / total
print('Accuracy on test set: {:.4f}'.format(accuracy))
def main():
train_data = load_data('train.txt')
test_data = load_data('test.txt')
train_dataset = TextDataset(train_data, tokenizer)
test_dataset = TextDataset(test_data, tokenizer)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, collate_fn=collate_fn)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, collate_fn=collate_fn)
num_classes = 10
model = TextClassifier(bert_model, num_classes)
optimizer = Adam(model.parameters(), lr=2e-5)
criterion = nn.CrossEntropyLoss()
num_epochs = 3
train(model, train_loader, optimizer, criterion, num_epochs)
test(model, test_loader)
if __name__ == '__main__':
main()
En nuestro ejemplo, el método FGSM se usa para agregar una perturbación contradictoria. Durante el proceso de entrenamiento, en cada muestra de cada lote, usamos para perturbation.requires_grad_()crear una perturbación que mantiene el vector de incrustación sin cambios. Cuando el gradiente se actualice en el siguiente paso, invierta La propagación no solo considera la pérdida del modelo, sino también la pérdida de la perturbación, luego utiliza perturbation = step_size * perturbation.gradla perturbación de actualización y finalmente usa input_ids.clamp_(0, tokenizer.vocab_size-1)la garantía de que los ejemplos contradictorios generados siguen siendo datos de entrada textuales válidos. Con respecto a la defensa de ejemplos contradictorios, los métodos de defensa comunes incluyen la fusión de modelos, la amplificación de datos y otros métodos.
5. Métodos de defensa contra muestras antagónicas
Hay muchas formas de defenderse contra ejemplos adversarios, los siguientes son algunos métodos comúnmente utilizados:
Entrenamiento contradictorio: el entrenamiento contradictorio es para mejorar la solidez del modelo agregando muestras adversarias a los datos de entrenamiento durante el proceso de entrenamiento. Específicamente, el entrenamiento contradictorio incluye dos pasos: generar muestras contradictorias y usar muestras contradictorias para el entrenamiento. Al generar ejemplos contradictorios, podemos usar métodos como FGSM y PGD. Cuando entrenamos con ejemplos contradictorios, mezclamos los ejemplos contradictorios con los ejemplos originales y luego usamos los ejemplos mixtos para entrenar el modelo. Esto puede hacer que el modelo sea más robusto frente a los ataques de ejemplos adversarios.
Compresión del modelo: la compresión del modelo es para mejorar la solidez del modelo al reducir la complejidad del modelo. Específicamente, la compresión del modelo consta de dos pasos: poda y cuantificación del modelo. Al podar el modelo, podemos reducir la complejidad del modelo eliminando algunas neuronas o capas redundantes. Al cuantificar, podemos convertir los parámetros de coma flotante del modelo en parámetros enteros, lo que reduce el espacio de almacenamiento y la complejidad computacional del modelo. Esto puede hacer que el modelo sea más simple y resistente a los ataques de ejemplos adversarios.
Defensa de aleatoriedad: La defensa de aleatorización es para mejorar la solidez del modelo introduciendo algo de aleatoriedad en el modelo. Específicamente, la defensa de la aleatorización consta de dos pasos: aleatorización de entrada y aleatorización de modelo. Cuando ingresamos la aleatorización, podemos hacer algo de aleatorización en los datos de entrada, como agregar algo de ruido, perturbación o rotación, etc. Al aleatorizar el modelo, podemos introducir algo de aleatoriedad en el modelo, como el uso de núcleos de convolución aleatorios en capas convolucionales, conexiones aleatorias en capas totalmente conectadas, etc. Esto puede hacer que el modelo sea más difícil de atacar y puede resistir el ataque de ejemplos adversarios.
Model Ensemble: Model Ensemble es para mejorar la robustez de un modelo mediante la combinación de varios modelos. Específicamente, el conjunto de modelos consta de dos pasos: entrenar múltiples modelos y combinar múltiples modelos. Al entrenar varios modelos, podemos entrenar varios modelos con diferentes inicializaciones, diferentes hiperparámetros o diferentes datos de entrenamiento. Al combinar varios modelos, podemos usar métodos como la votación, el promedio ponderado o la fusión de modelos para combinar varios modelos. Esto hace que el modelo sea más robusto frente a los ataques de ejemplos adversarios.
Estos métodos se pueden utilizar para defenderse de muestras antagónicas y mejorar el rendimiento general del modelo. Sin embargo, debe tenerse en cuenta que cada método tiene sus ventajas y desventajas, y la elección específica debe sopesarse de acuerdo con los requisitos y los escenarios de aplicación específicos.