Índice
Alvos e conjuntos de dados
Detecção de anomalias usando o modelo não supervisionado: identificando se uma determinada imagem é semelhante a uma imagem de treinamento
conjunto de dados
dados de treinamento
- 100.000 rostos humanos
- data/traingset.npy: 100.000 imagens em um array numpy com forma (100.000, 64, 64, 3)
● Dados de teste
- Cerca de 10.000 da mesma distribuição com dados de treinamento (rótulo 0)
- Cerca de 10.000 de outra distribuição (anomalias, rótulo 1)
- data/testingset.npy: 19636 imagens em um array numpy com forma (19636, 64, 64, 3)
metodologia
● Treine um autoencoder com pequeno erro de reconstrução.
● Durante a inferência, podemos usar o erro de reconstrução como pontuação de anomalia.
○ A pontuação de anomalia pode ser vista como o grau de anormalidade de uma imagem.
○ Uma imagem de distribuição não vista deve ter um erro de reconstrução maior.
● As pontuações de anomalia são usadas como nossos valores previstos.
Finalmente, o modelo é avaliado usando o ROC AUCscore.
pacote de guia
import random
import numpy as np
import torch
from torch import nn
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler, TensorDataset
import torchvision.transforms as transforms
import torch.nn.functional as F
from torch.autograd import Variable
import torchvision.models as models
from torch.optim import Adam, AdamW
import pandas as pd
import os
from d2l import torch as d2l
def same_seeds(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
same_seeds(48763)módulo de conjunto de dados
A função de transformação aqui normaliza os pixels da imagem de [0, 255] para [-1,0, 1,0].
class CustomTensorDataset(TensorDataset):
"""TensorDataset with support of transforms.
"""
def __init__(self, tensors):
self.tensors = tensors
if tensors.shape[-1] == 3:
self.tensors = tensors.permute(0, 3, 1, 2)
self.transform = transforms.Compose([
transforms.Lambda(lambda x: x.to(torch.float32)),
transforms.Lambda(lambda x: 2. * x/255. - 1.),
])
def __getitem__(self, index):
x = self.tensors[index]
if self.transform:
# mapping images to [-1.0, 1.0]
x = self.transform(x)
return x
def __len__(self):
return len(self.tensors)codificador automático
código original. Eles são rede totalmente conectada, rede convolucional, modelo VAE
class fcn_autoencoder(nn.Module):
def __init__(self):
super(fcn_autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(64 * 64 * 3, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 12),
nn.ReLU(),
nn.Linear(12, 3)
)
self.decoder = nn.Sequential(
nn.Linear(3, 12),
nn.ReLU(),
nn.Linear(12, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128, 64 * 64 * 3),
nn.Tanh()
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
class conv_autoencoder(nn.Module):
def __init__(self):
super(conv_autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(3, 12, 4, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(12, 24, 4, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(24, 48, 4, stride=2, padding=1),
nn.ReLU(),
)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(48, 24, 4, stride=2, padding=1),
nn.ReLU(),
nn.ConvTranspose2d(24, 12, 4, stride=2, padding=1),
nn.ReLU(),
nn.ConvTranspose2d(12, 3, 4, stride=2, padding=1),
nn.Tanh(),
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
class VAE(nn.Module):
def __init__(self):
super(VAE, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(3, 12, 4, stride=2, padding=1),
nn.ReLU(),
nn.Conv2d(12, 24, 4, stride=2, padding=1),
nn.ReLU(),
)
self.enc_out_1 = nn.Sequential(
nn.Conv2d(24, 48, 4, stride=2, padding=1),
nn.ReLU(),
)
self.enc_out_2 = nn.Sequential(
nn.Conv2d(24, 48, 4, stride=2, padding=1),
nn.ReLU(),
)
self.decoder = nn.Sequential(
nn.ConvTranspose2d(48, 24, 4, stride=2, padding=1),
nn.ReLU(),
nn.ConvTranspose2d(24, 12, 4, stride=2, padding=1),
nn.ReLU(),
nn.ConvTranspose2d(12, 3, 4, stride=2, padding=1),
nn.Tanh(),
)
def encode(self, x):
h1 = self.encoder(x)
return self.enc_out_1(h1), self.enc_out_2(h1)
def reparametrize(self, mu, logvar):
std = logvar.mul(0.5).exp_()
if torch.cuda.is_available():
eps = torch.cuda.FloatTensor(std.size()).normal_()
else:
eps = torch.FloatTensor(std.size()).normal_()
eps = Variable(eps)
return eps.mul(std).add_(mu)
def decode(self, z):
return self.decoder(z)
def forward(self, x):
mu, logvar = self.encode(x)
z = self.reparametrize(mu, logvar)
return self.decode(z), mu, logvar
def loss_vae(recon_x, x, mu, logvar, criterion):
"""
recon_x: generating images
x: origin images
mu: latent mean
logvar: latent log variance
"""
mse = criterion(recon_x, x)
KLD_element = mu.pow(2).add_(logvar.exp()).mul_(-1).add_(1).add_(logvar)
KLD = torch.sum(KLD_element).mul_(-0.5)
return mse + KLDtrem
Baixar dados
# load data
train = np.load('../input/ml2022spring-hw8/data/trainingset.npy', allow_pickle=True)
test = np.load('../input/ml2022spring-hw8/data/testingset.npy', allow_pickle=True)
print(train.shape)
print(test.shape)
# Build training dataloader
batch_size = 256
num_workers = 2
x = torch.from_numpy(train)
train_dataset = CustomTensorDataset(x)
train_dataloader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=num_workers, pin_memory=True, drop_last=True)
print('训练集总长度是 {:d}, batch数量是 {:.2f}'.format(len(train_dataset), len(train_dataset)/ batch_size)) função de treinamento
def trainer(model, config, train_dataloader, devices):
best_loss = np.inf
num_epochs = config['num_epochs']
model_type = config['model_type']
# Loss and optimizer
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=config['lr'])
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer,
T_0=config['T_0'], T_mult=config['T_2'], eta_min=config['lr']/config['ratio_min'])
if not os.path.isdir('./' + config['model_path'].split('/')[1]):
os.mkdir('./' + config['model_path'].split('/')[1]) # Create directory of saving models.
model.train()
legend = ['train loss']
animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=legend)
for epoch in range(num_epochs):
tot_loss = 0.0
for data in train_dataloader:
img = data.float().to(devices[0])
if model_type in ['fcn']:
img = img.view(img.shape[0], -1)
output = model(img)
if model_type in ['vae']:
loss = loss_vae(output[0], img, output[1], output[2], criterion)
else:
loss = criterion(output, img)
tot_loss += loss.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
scheduler.step()
mean_loss = tot_loss / len(train_dataloader)
print(epoch, mean_loss)
animator.add(epoch, (mean_loss))
if mean_loss < best_loss:
best_loss = mean_loss
torch.save(model.state_dict(), config['model_path'])trem
devices = d2l.try_all_gpus()
print(f'DEVICE: {devices}')
config = {
"num_epochs": 240,
"lr": 8e-4,
"model_type": 'cnn', # selecting a model type from {'cnn', 'fcn', 'vae', 'resnet'}
"T_0": 2,
"T_2": 2,
'ratio_min': 20
}
config['model_path'] = './models/' + config['model_type']
model_classes = {'fcn': fcn_autoencoder(), 'cnn': cnn_autoencoder(), 'vae': VAE()}
model= model_classes[config['model_type']].to(devices[0])
trainer(model, config, train_dataloader, devices)inferir
train = np.load("../data/ml2022spring-hw8/data/trainingset.npy", allow_pickle=True)
test = np.load('../data/ml2022spring-hw8/data/testingset.npy', allow_pickle=True)
# build testing dataloader
eval_batch_size = 1024
data = torch.tensor(test, dtype=torch.float32)
test_dataset = CustomTensorDataset(data)
test_dataloader = DataLoader(test_dataset, shuffle=False, batch_size=eval_batch_size, num_workers=0, pin_memory=True)
print('测试集总长度是 {:d}, batch数量是 {:.2f}'.format(len(test_dataset), len(test_dataset)/ eval_batch_size))
eval_loss = nn.MSELoss(reduction='none')
# load trained model
model= model_classes[config['model_type']].to(devices[0])
model.load_state_dict(torch.load('cnn'))
model.eval()
# prediction file
out_file = 'prediction-cnn_res.csv'
anomality = []
with torch.no_grad():
for i, data in enumerate(test_dataloader):
img = data.float().to(devices[0])
if config['model_type'] in ['fcn']:
img = img.view(img.shape[0], -1)
output = model(img)
if config['model_type'] in ['vae']:
output = output[0]
elif config['model_type'] in ['fcn']:
loss = eval_loss(output, img).sum(-1)
else:
loss = eval_loss(output, img).sum([1, 2, 3])
anomality.append(loss)
anomality = torch.cat(anomality, axis=0)
anomality = torch.sqrt(anomality).reshape(len(test), 1).cpu().numpy()
df = pd.DataFrame(anomality, columns=['score'])
df.to_csv(out_file, index_label = 'ID')Respostas e Discussões
fcn
modelo raso
Consulte Li Hongyi's 2022 Machine Learning HW8 Analysis_Machine Learning Craftsman's Blog-CSDN Blog , usando uma rede rasa, que é caracterizada por uma primeira camada oculta muito ampla, que pode extrair melhor recursos úteis de amostras. Em seguida, reduza lentamente. A saída do codificador de código original é um vetor tridimensional, que é alterado para 10 dimensões aqui, o que pode expressar melhor a distribuição dos dados da imagem.
class fcn_autoencoder(nn.Module):
def __init__(self):
super(fcn_autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(64 * 64 * 3, 1024),
nn.ReLU(),
nn.Linear(1024, 256),
nn.ReLU(),
nn.Linear(256, 64),
nn.ReLU(),
nn.Linear(64, 10)
)
self.decoder = nn.Sequential(
nn.Linear(10, 64),
nn.ReLU(),
nn.Linear(64, 256),
nn.ReLU(),
nn.Linear(256, 1024),
nn.ReLU(),
nn.Linear(1024, 64 * 64 * 3),
nn.Tanh()
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
O modelo tem 25.739.146 parâmetros e um tamanho de 98,46 MB. Parece muito grande e parece mais rápido de treinar do que a rede profunda e a rede CNN por trás dele. Vários conjuntos de hiperparâmetros são usados para treinamento e, se treinados com cuidado, a pontuação pode ser ainda maior.
1. Usando minhas configurações de parâmetro mais usadas, o processo de treinamento é suave e os resultados são relativamente bons
config = { "num_epochs": 200, "lr": 1e-3, "model_type": 'fcn', "T_0": 2, "T_2": 3, 'ratio_min': 50 }
2. Sinto que a perda cai muito lentamente no final de cada ciclo. Suspeito que a taxa de aprendizado na segunda metade de cada ciclo seja muito pequena, então mudo eta_min de 50 para 10. Parece que o declínio da perda é de fato mais íngreme. No entanto, o resultado final do treino não é tão bom quanto o anterior. A razão pode ser que quando eta_min=50, a taxa de aprendizado no primeiro semestre é alta e a perda cai rapidamente, de modo que o segundo semestre pode continuar aprendendo a um ritmo de aprendizado menor. A razão pela qual as pessoas sentem que a perda no final do ciclo cai muito devagar é porque no começo a perda cai rápido. Por outro lado, quando eta_min=10, a taxa de aprendizado de todo o ciclo é alta, e a diminuição da perda é completada por todo o ciclo, ao contrário de eta_min=50, que é concluída principalmente no início do ciclo.
config = { "num_epochs": 10, "lr": 8e-4, "model_type": 'fcn', "T_0": 2, "T_2": 3, 'ratio_min': 10 }
3. Duração fixa do ciclo. No estágio inicial, a perda cai mais rápido do que nos dois primeiros, provavelmente porque várias rodadas de taxas de aprendizado foram tentadas em um período curto e uma taxa de aprendizado adequada pode ser tentada. No entanto, o declínio subsequente da perda é muito lento, porque a flutuação é muito grande e um grande número de cálculos é usado para reduzir a perda do ponto alto ascendente.
config = { "num_epochs": 360, "lr": 1e-3, "model_type": 'fcn', "T_0": 16, "T_2": 1, 'ratio_min': 50 }
rede profunda
Não é tão profundo. Geralmente, espera-se que a rede seja mais profunda, não mais ampla, então a rede será aprofundada. Existem 13.078.314 parâmetros e o tamanho é de 50,16 MB. Com cerca de metade do tamanho do modelo anterior, o desempenho do modelo é pior: redes rasas podem facilmente exceder 0,76 pontos, mas redes profundas podem exceder apenas ligeiramente 0,75 pontos. Considerando a grande lacuna nos parâmetros do modelo, parece aceitável.
class fcn_autoencoder(nn.Module):
def __init__(self):
super(fcn_autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(64 * 64 * 3, 512),
nn.ReLU(),
nn.Linear(512, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 32),
nn.ReLU(),
nn.Linear(32, 16),
nn.ReLU(),
nn.Linear(16, 10)
)
self.decoder = nn.Sequential(
nn.Linear(10, 16),
nn.ReLU(),
nn.Linear(16, 32),
nn.ReLU(),
nn.Linear(32, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 512),
nn.ReLU(),
nn.Linear(512, 64 * 64 * 3),
nn.Tanh()
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return xVários hiperparâmetros foram usados e os resultados de otimização foram semelhantes.
config = { "num_epochs": 240, "lr": 8e-4, "model_type": 'fcn', "T_0": 16, "T_2": 1, 'ratio_min': 50 }
config = { "num_epochs": 240, "lr": 1e-3, "model_type": 'fcn', "T_0": 2, "T_2": 3, 'ratio_min': 50 }
config = { "num_epochs": 240, "lr": 8e-4, "model_type": 'fcn', "T_0": 2, "T_2": 2, 'ratio_min': 5 }
Basicamente simulando uma taxa fixa de aprendizado. No estágio inicial, a perda cai rapidamente. Nos exemplos anteriores, o uso do agendador foi lento, então você pode tentar usar uma taxa de aprendizado maior no início e, em seguida, usar o agendador quando a perda diminuir lentamente.
config = { "num_epochs": 240, "lr": 8e-4, "model_type": 'fcn', "T_0": 1, "T_2": 1, 'ratio_min': 5 }
Continue a aprofundar a rede e o desempenho do modelo basicamente permanece o mesmo
class fcn_autoencoder(nn.Module):
def __init__(self):
super(fcn_autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(64 * 64 * 3, 512),
nn.ReLU(),
nn.Linear(512, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 32),
nn.ReLU(),
nn.Linear(32, 16),
nn.ReLU(),
nn.Linear(16, 10)
)
self.decoder = nn.Sequential(
nn.Linear(10, 16),
nn.ReLU(),
nn.Linear(16, 32),
nn.ReLU(),
nn.Linear(32, 64),
nn.ReLU(),
nn.Linear(64, 128),
nn.ReLU(),
nn.Linear(128, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 256),
nn.ReLU(),
nn.Linear(256, 512),
nn.ReLU(),
nn.Linear(512, 64 * 64 * 3),
nn.Tanh()
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
cnn
Usando o 2022 Machine Learning HW8 Analysis de Li Hongyi_Machine Learning Craftsman's Blog-CSDN Blog Design. A perda pode ser reduzida para cerca de 0,88 e a pontuação é de cerca de 0,75. Vale ressaltar que o número de parâmetros é 601.885 e o tamanho é de 3,91 MB, quase o mesmo desempenho da rede totalmente conectada com 13.078.314 parâmetros antes, mas o número de parâmetros é apenas um vigésimo deste último. Pode-se ver que a rede CNN está em tarefas de imagem Power on.
class conv_autoencoder(nn.Module):
def __init__(self):
super(conv_autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(3, 24, 4, stride=2, padding=1),
nn.BatchNorm2d(24),
nn.ReLU(),
nn.Conv2d(24, 24, 4, stride=2, padding=1),
nn.BatchNorm2d(24),
nn.ReLU(),
nn.Conv2d(24, 48, 4, stride=2, padding=1),
nn.BatchNorm2d(48),
nn.ReLU(),
nn.Conv2d(48, 96, 4, stride=2, padding=1),
nn.BatchNorm2d(96),
nn.ReLU(),
nn.Flatten(),
nn.Dropout(0.2),
nn.Linear(96*4*4, 128),
nn.BatchNorm1d(128),
nn.Dropout(0.2),
nn.Linear(128, 10),
nn.BatchNorm1d(10),
nn.ReLU()
)
self.decoder = nn.Sequential(
nn.Linear(10, 128),
nn.BatchNorm1d(128),
nn.ReLU(),
nn.Linear(128, 96*4*4),
nn.BatchNorm1d(96*4*4),
nn.ReLU(),
nn.Unflatten(1, (96, 4, 4)),
nn.ConvTranspose2d(96, 48, 4, stride=2, padding=1),
nn.BatchNorm2d(48),
nn.ReLU(),
nn.ConvTranspose2d(48, 24, 4, stride=2, padding=1),
nn.BatchNorm2d(24),
nn.ReLU(),
nn.ConvTranspose2d(24, 12, 4, stride=2, padding=1),
nn.BatchNorm2d(12),
nn.ReLU(),
nn.ConvTranspose2d(12, 3, 4, stride=2, padding=1),
nn.Tanh(),
)
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x A figura abaixo mostra uma taxa de aprendizado fixa sem usar o escalonador.
config = { "num_epochs": 240, "lr": 8e-4, "model_type": 'cnn', # selecionando um tipo de modelo de {'cnn', 'fcn', 'vae', 'resnet'} " T_0 ": 2, "T_2": 2, 'ratio_min': 10 }
Use a função StepLR para ajustar a taxa de aprendizado, lr=5e-3, agendador = maçarico.optim.lr_scheduler.StepLR(otimizador, step_size=6, gama=0,8)
rede residual
A parte do codificador usa completamente a rede resnet18. A parte do decodificador é basicamente uma imagem espelhada da parte do codificador. Existem 14.053.571 parâmetros. Não parece muito e é relativamente lento para treinar.
class Residual_Block(nn.Module):
def __init__(self, ic, oc, stride=1):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(ic, oc, kernel_size=3, padding=1, stride=stride),
nn.BatchNorm2d(oc),
nn.ReLU(inplace=True)
)
self.conv2 = nn.Sequential(
nn.Conv2d(oc, oc, kernel_size=3, padding=1),
nn.BatchNorm2d(oc)
)
self.relu = nn.ReLU(inplace=True)
if stride != 1 or (ic != oc): # 对于resnet18，可以不需要stride != 1这个条件
self.conv3 = nn.Sequential(
nn.Conv2d(ic, oc, kernel_size=1, stride=stride),
nn.BatchNorm2d(oc)
)
else:
self.conv3 = None
def forward(self, X):
Y = self.conv1(X)
Y = self.conv2(Y)
if self.conv3:
X = self.conv3(X)
Y += X
return self.relu(Y)
class ResNet(nn.Module):
def __init__(self, block=Residual_Block, num_layers = [2,2,2,2], num_classes=32):
super().__init__()
self.preconv = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
)
self.layer0 = self.make_residual(block, 64, 64, num_layers[0]) # [1, 64, 16, 16]
self.layer1 = self.make_residual(block, 64, 128, num_layers[1], stride=2) # [1, 128, 8, 8]
self.layer2 = self.make_residual(block, 128, 256, num_layers[2], stride=2) # [1, 256, 4, 4]
self.layer3 = self.make_residual(block, 256, 512, num_layers[3], stride=2) # [1, 512, 2, 2]
self.postliner = nn.Sequential(
nn.AdaptiveAvgPool2d((1,1)),
nn.Flatten(),
nn.Linear(512, num_classes) # [1, num_classes]
)
self.decoder = nn.Sequential(
nn.Linear(num_classes, 512*2*2), # [1, 512*2*2]
# nn.BatchNorm1d(512*2*2),
nn.ReLU(),
nn.Unflatten(1, (512, 2, 2)), # [1, 512, 2, 2]
nn.ConvTranspose2d(512, 256, 4, stride=2, padding=1), # [1, 256, 4, 4]
nn.BatchNorm2d(256),
nn.ReLU(),
nn.ConvTranspose2d(256, 128, 4, stride=2, padding=1), # [1, 128, 8, 8]
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 64, 4, stride=2, padding=1), # [1, 64, 16, 16]
nn.BatchNorm2d(64),
nn.ReLU(),
nn.ConvTranspose2d(64, 32, 4, stride=2, padding=1), # [1, 32, 32, 32]
nn.BatchNorm2d(32),
nn.ReLU(),
nn.ConvTranspose2d(32, 3, 4, stride=2, padding=1), # [1, 3, 64, 64]
nn.Tanh(),
)
def make_residual(self, block, ic, oc, num_layer, stride=1):
layers = []
layers.append(block(ic, oc, stride))
for i in range(1, num_layer):
layers.append(block(oc, oc))
return nn.Sequential(*layers)
def encoder(self, x):
x = self.preconv(x)
x = self.layer0(x) #64*64 --> 32*32
x = self.layer1(x) #32*32 --> 16*16
x = self.layer2(x) #16*16 --> 8*8
x = self.layer3(x) #8*8 --> 4*4
x = self.postliner(x)
return x
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return xconfig = { "num_epochs": 240, "lr": 8e-4, "model_type": 'cnn', # selecionando um tipo de modelo de {'cnn', 'fcn', 'vae', 'resnet'} " T_0 ": 2, "T_2": 2, 'ratio_min': 20 }
Na verdade, continuei a calcular mais abaixo. A perda pode ser reduzida para perto de 0,02, mas a pontuação é de apenas 0,744. Suspeito que a perda durante o processo de treinamento foi calculada incorretamente. Encontrei alguns dados especialmente e os calculei. O perda é realmente muito baixa.
A seguir está a ideia fornecida pelo 2022 Machine Learning HW8 Analysis_Machine Learning Craftsman's Blog-CSDN Blog de Li Hongyi , tornando a rede residual mais rasa e estreita, com uma perda de cerca de 0,04 e uma pontuação de cerca de 0,76. Isso é mais intrigante. A perda da rede fcn é 0,07 e a pontuação é 0,76. Por que a perda da rede residual diminui, mas a pontuação permanece a mesma ou até diminui? Isso significa que a melhoria de desempenho das imagens de restauração do codificador automático nem sempre representa uma melhoria nos recursos de detecção de anomalias? Isso de repente me fez perder a motivação para continuar otimizando.
class Residual_Block(nn.Module):
def __init__(self, ic, oc, stride=1):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(ic, oc, kernel_size=3, stride=stride, padding=1),
nn.BatchNorm2d(oc),
nn.ReLU(inplace=True)
)
self.conv2 = nn.Sequential(
nn.Conv2d(oc, oc, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(oc),
)
self.relu = nn.ReLU(inplace=True)
self.downsample = None
if stride != 1 or (ic != oc):
self.downsample = nn.Sequential(
nn.Conv2d(ic, oc, kernel_size=1, stride=stride),
nn.BatchNorm2d(oc),
)
def forward(self, x):
residual = x
out = self.conv1(x)
out = self.conv2(out)
if self.downsample:
residual = self.downsample(x)
out += residual
return self.relu(out)
class ResNet(nn.Module):
def __init__(self, block=Residual_Block, num_layers=[2, 1, 1, 1]):
super().__init__()
self.preconv = nn.Sequential(
nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
)
self.layer0 = self.make_residual(block, 32, 64, num_layers[0], stride=2)
self.layer1 = self.make_residual(block, 64, 128, num_layers[1], stride=2)
self.layer2 = self.make_residual(block, 128, 128, num_layers[2], stride=2)
self.layer3 = self.make_residual(block, 128, 64, num_layers[3], stride=2)
self.fc = nn.Sequential(
nn.Flatten(),
nn.Dropout(0.2),
nn.Linear(64*4*4, 64),
nn.BatchNorm1d(64)
nn.ReLU(inplace=True),
)
self.decoder = nn.Sequential(
nn.Linear(64, 64*4*4),
nn.BatchNorm1d(64*4*4),
nn.ReLU(),
nn.Unflatten(1, (64, 4, 4)),
nn.ConvTranspose2d(64, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 3, 4, stride=2, padding=1),
nn.Tanh(),
)
def make_residual(self, block, ic, oc, num_layer, stride=1):
layers = []
layers.append(block(ic, oc, stride))
for i in range(1, num_layer):
layers.append(block(oc, oc))
return nn.Sequential(*layers)
def encoder(self, x):
x = self.preconv(x)
x = self.layer0(x) #64*64 --> 32*32
x = self.layer1(x) #32*32 --> 16*16
x = self.layer2(x) #16*16 --> 8*8
x = self.layer3(x) #8*8 --> 4*4
x = self.fc(x)
return x
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
rede auxiliar
Consulte Li Hongyi's 2022 Machine Learning HW8 Analysis_Machine Learning Craftsman's Blog-CSDN Blog , uma rede auxiliar de decodificador adicional é usada. A rede ResNet é consistente com o método de treinamento original. A rede auxiliar é a parte do decodificador da rede ResNet. Eu não não entendo. anote primeiro
função de treinamento
def trainer(model, config, train_dataloader, devices):
best_loss = np.inf
num_epochs = config['num_epochs']
model_type = config['model_type']
# Loss and optimizer
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=config['lr'])
optimizer_a = torch.optim.AdamW(aux.parameters(), lr=config['lr'])
scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer,
T_0=config['T_0'], T_mult=config['T_2'], eta_min=config['lr']/config['ratio_min'])
if not os.path.isdir('./' + config['model_path'].split('/')[1]):
os.mkdir('./' + config['model_path'].split('/')[1]) # Create directory of saving models.
aux.train()
legend = ['train loss']
animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=legend)
for epoch in range(num_epochs):
tot_loss, tot_loss_a = 0.0, 0.0
temperature = epoch // 2 + 1
for data in train_dataloader:
img = data.float().to(devices[0])
if model_type in ['fcn']:
img = img.view(img.shape[0], -1)
# ===================train autoencoder=====================
model.train()
output = model(img)
if model_type in ['vae']:
loss = loss_vae(output[0], img, output[1], output[2], criterion)
else:
loss = criterion(output, img)
tot_loss += loss.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
# ===================train aux===================== 这条线以上部分和以前没有区别
model.eval()
z = model.encoder(img).detach_()
output = output.detach_()
output_a = aux(z)
loss_a = (criterion(output_a, output).mul(temperature).exp())*criterion(output_a, img)
# loss_a = loss_a.mean()
tot_loss_a += loss_a.item()
optimizer_a.zero_grad()
loss_a.backward()
optimizer_a.step()
scheduler.step()
# ===================save_best====================
mean_loss = tot_loss / len(train_dataloader)
print(epoch, mean_loss)
animator.add(epoch, (mean_loss))
if mean_loss < best_loss:
best_loss = mean_loss
torch.save(model.state_dict(), config['model_path'] + 'res')
torch.save(aux.state_dict(), config['model_path'] + 'aux')Redes Residuais e Funções Auxiliares
class Residual_Block(nn.Module):
def __init__(self, ic, oc, stride=1):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(ic, oc, kernel_size=3, stride=stride, padding=1),
nn.BatchNorm2d(oc),
nn.ReLU(inplace=True)
)
self.conv2 = nn.Sequential(
nn.Conv2d(oc, oc, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(oc),
)
self.relu = nn.ReLU(inplace=True)
self.downsample = None
if stride != 1 or (ic != oc):
self.downsample = nn.Sequential(
nn.Conv2d(ic, oc, kernel_size=1, stride=stride),
nn.BatchNorm2d(oc),
)
def forward(self, x):
residual = x
out = self.conv1(x)
out = self.conv2(out)
if self.downsample:
residual = self.downsample(x)
out += residual
return self.relu(out)
class ResNet(nn.Module):
def __init__(self, block=Residual_Block, num_layers=[2, 1, 1, 1]):
super().__init__()
self.preconv = nn.Sequential(
nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
)
self.layer0 = self.make_residual(block, 32, 64, num_layers[0], stride=2)
self.layer1 = self.make_residual(block, 64, 128, num_layers[1], stride=2)
self.layer2 = self.make_residual(block, 128, 128, num_layers[2], stride=2)
self.layer3 = self.make_residual(block, 128, 64, num_layers[3], stride=2)
self.fc = nn.Sequential(
nn.Flatten(),
nn.Dropout(0.2),
nn.Linear(64*4*4, 64),
nn.BatchNorm1d(64),
nn.ReLU(inplace=True),
)
self.decoder = nn.Sequential(
nn.Linear(64, 64*4*4),
nn.BatchNorm1d(64*4*4),
nn.ReLU(),
nn.Unflatten(1, (64, 4, 4)),
nn.ConvTranspose2d(64, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 3, 4, stride=2, padding=1),
nn.Tanh(),
)
def make_residual(self, block, ic, oc, num_layer, stride=1):
layers = []
layers.append(block(ic, oc, stride))
for i in range(1, num_layer):
layers.append(block(oc, oc))
return nn.Sequential(*layers)
def encoder(self, x):
x = self.preconv(x)
x = self.layer0(x) #64*64 --> 32*32
x = self.layer1(x) #32*32 --> 16*16
x = self.layer2(x) #16*16 --> 8*8
x = self.layer3(x) #8*8 --> 4*4
x = self.fc(x)
return x
def forward(self, x):
x = self.encoder(x)
x = self.decoder(x)
return x
# 完全就是把ResNet的decoder部分拿了过来
class Auxiliary(nn.Module):
def __init__(self):
super().__init__()
self.decoder = nn.Sequential(
nn.Linear(64, 64*4*4),
nn.BatchNorm1d(64*4*4),
nn.ReLU(),
nn.Unflatten(1, (64, 4, 4)),
nn.ConvTranspose2d(64, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.ConvTranspose2d(128, 3, 4, stride=2, padding=1),
nn.Tanh(),
)
def forward(self, x):
return self.decoder(x)parâmetros de configuração
devices = d2l.try_all_gpus()
print(f'DEVICE: {devices}')
config = {
"num_epochs": 30,
"lr": 8e-4,
"model_type": 'res', # selecting a model type from {'cnn', 'fcn', 'vae', 'resnet'}
"T_0": 2,
"T_2": 2,
'ratio_min': 20
}
config['model_path'] = './models/' + config['model_type']
model_classes = {'fcn': fcn_autoencoder(), 'cnn': conv_autoencoder(), 'vae': VAE(), 'res':ResNet()}
model= model_classes[config['model_type']].to(devices[0])
# model.load_state_dict(torch.load('./best_model_fcn.pt'))
aux = Auxiliary().to(devices[0])
trainer(model, config, train_dataloader, devices)inferir
eval_batch_size = 1024
# build testing dataloader
data = torch.tensor(test, dtype=torch.float32)
test_dataset = CustomTensorDataset(data)
test_dataloader = DataLoader(test_dataset, shuffle=False, batch_size=eval_batch_size, num_workers=num_workers, pin_memory=True)
print('测试集总长度是 {:d}, batch数量是 {:.2f}'.format(len(test_dataset), len(test_dataset)/ eval_batch_size))
eval_loss = nn.MSELoss(reduction='none')
# load trained model
model= ResNet().to(devices[0])
model.load_state_dict(torch.load(config['model_path'] + 'res'))
aux = Auxiliary().to(devices[0])
aux.load_state_dict(torch.load(config['model_path'] + 'aux'))
model.eval()
# prediction file
out_file = 'prediction.csv'
out_file_a = 'prediction_a.csv'
anomality = []
auxs = []
with torch.no_grad():
for i, data in enumerate(test_dataloader):
img = data.float().to(devices[0])
z = model.encoder(img)
output = model(img)
output, output_a = model.decoder(z), aux(z)
loss = eval_loss(output, img).mean([1, 2, 3])
loss_a = eval_loss(output_a, img).mean([1, 2, 3])
anomality.append(loss)
auxs.append(loss_a)
anomality = torch.cat(anomality, axis=0)
anomality = torch.sqrt(anomality).reshape(len(test), 1).cpu().numpy()
auxs = torch.cat(auxs, axis=0)
auxs = torch.sqrt(auxs).reshape(len(test), 1).cpu().numpy()
df = pd.DataFrame(anomality, columns=['score'])
df.to_csv(out_file, index_label = 'ID')
df_a = pd.DataFrame(auxs, columns=['score'])
df_a.to_csv(out_file_a, index_label = 'ID')
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 4))
plt.subplot(121)
plt.title('reconstrcut error')
plt.hist(df.score)
plt.subplot(122)
plt.title('aux error')
plt.hist(df_a.score)
plt.show()