def main(args): print('\nPreparing {} data'.format(args.dataset)) if args.dataset == 'mnist': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_mnist() elif args.dataset == 'cifar10': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar10() elif args.dataset == 'cifar100': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar100() print('\nConstruction graph') if args.model == 'cnn_1': env = cnn_1(args) elif args.model == 'cnn_2': env = cnn_2(args) elif args.model == 'vgg16': env = vgg16(args) elif args.model == 'vgg19': env = vgg19(args) print('\nInitializing graph') sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) print('\nTraining') name = '{0}_{1}'.format(args.model, args.dataset) train(sess, env, X_train, y_train, X_valid, y_valid, batch_size=args.batch_size, epochs=args.epochs, name=name) print('\nEvaluating on clean data') evaluate(sess, env, X_test, y_test)
def main(opt): if type(opt.seed) is int: torch.manual_seed(opt.seed) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") (x_train, y_train), _ = load_mnist("dataset", training_label=opt.training_label, split_rate=opt.split_rate) train_mnist = SimpleDataset(x_train, y_train, transform=transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]) ])) train_dataloader = DataLoader(train_mnist, batch_size=opt.batch_size, shuffle=True) img_shape = (opt.channels, opt.img_size, opt.img_size) generator = Generator(img_shape, opt.latent_dim) discriminator = Discriminator(img_shape) encoder = Encoder(img_shape) train_encoder_izif(opt, generator, discriminator, encoder, train_dataloader, device)
def train(path_to_datas, save_model_path): # 读取MNIST数据集 train_datas, labels = tools.load_mnist(path_to_datas, 'train') print("The total numbers of datas : ", len(train_datas)) train_labels = np.zeros((labels.shape[0], 10)) train_labels[np.arange(labels.shape[0]), labels.astype('int').reshape(-1)-1] = 1.0 # 设置训练所需的超参数 batch_size = 100 # 训练次数 train_epochs = 10 # 学习率 lr = 0.01 decay = False regularization = False input_features_numbers = train_datas.shape[1] layer_structure = [input_features_numbers, 512, 256, 128, 10] display = True net_name = 'nn' # 定义我们的神经网络分类器 net = NN.MLP(name=net_name, layer_structure=layer_structure, task_model='multi', batch_size=batch_size) # 开始训练 print("---------开始训练---------") net.train(train_datas=train_datas, train_targets=train_labels, train_epoch=train_epochs, lr=lr, lr_decay=decay, loss='BE', regularization=regularization, display=display) # 保存模型 net.save_model(path=save_model_path) # 绘制网络的训练损失和精度 total_net_loss = [net.total_loss] total_net_accuracy = [net.total_accuracy] tools.drawDataCurve(total_net_loss, total_net_accuracy)
def test(path_to_datas, save_model_path): # 读取xlsx文件 test_datas, all_label = tools.load_mnist(path_to_datas, 'test') print("The total numbers of datas : ", len(test_datas)) test_labels = np.zeros((all_label.shape[0], 10)) test_labels[np.arange(all_label.shape[0]), all_label.astype('int').reshape(-1)-1] = 1.0 # 设置训练所需的超参数 batch_size = 100 input_features_numbers = test_datas.shape[1] layer_structure = [input_features_numbers, 512, 256, 128, 10] net_name = 'nn' # 测试代码 print("---------测试---------") # 载入训练好的模型 net = NN.MLP(name=net_name, layer_structure=layer_structure, task_model='multi', batch_size=batch_size, load_model=save_model_path) # 网络进行预测 test_steps = test_datas.shape[0] // batch_size accuracy = 0 for i in range(test_steps): input_data = test_datas[batch_size*i : batch_size*(i+1), :].reshape(batch_size, test_datas.shape[1]) targets = test_labels[batch_size*i : batch_size*(i+1), :].reshape(batch_size, test_labels.shape[1]) pred = net(input_data) # 计算准确率 accuracy += np.sum(np.argmax(pred,1) == np.argmax(targets,1)) / targets.shape[0] print("网络识别的准确率 : ", accuracy / test_steps)
def main(args): print('\nPreparing {} data'.format(args.dataset)) if args.dataset == 'mnist': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_mnist() elif args.dataset == 'cifar10': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar10() elif args.dataset == 'cifar100': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar100() print('\nConstruction graph') if args.model == 'cnn_1': env = cnn_1(args) elif args.model == 'cnn_2': env = cnn_2(args) elif args.model == 'vgg16': env = vgg16(args) elif args.model == 'vgg19': env = vgg19(args) print('\nInitializing graph') sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) print('\nLoading saved model') name = '{0}_{1}'.format(args.model, args.dataset) env.saver.restore(sess, 'models/{0}/{1}'.format(name, name)) print('\nEvaluating on clean data') evaluate(sess, env, X_test, y_test) print('\nExcluding misclassification samples') # mnist 1000 samples -> 0:1010 # cifar10 1000 samples -> 0: (X_test, y_test) = exclude_miss(sess, env, X_test, y_test, 0, 12) evaluate(sess, env, X_test, y_test) print('\nGenerating adversarial data') X_adv = make_adv(args, sess, env, X_test, y_test) print('\nEvaluating on adversarial data') evaluate(sess, env, X_adv, y_test) print('\nResults')
def main(opt): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") _, (x_test, y_test) = load_mnist("dataset", training_label=opt.training_label, split_rate=opt.split_rate) test_mnist = SimpleDataset(x_test, y_test, transform=transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]) ])) test_dataloader = DataLoader(test_mnist, batch_size=1, shuffle=False) generator = Generator(opt) discriminator = Discriminator(opt) encoder = Encoder(opt) test_anomaly_detection(opt, generator, discriminator, encoder, test_dataloader, device)
def main(opt): if type(opt.seed) is int: torch.manual_seed(opt.seed) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") _, (x_test, y_test) = load_mnist("dataset", training_label=opt.training_label, split_rate=opt.split_rate) test_mnist = SimpleDataset(x_test, y_test, transform=transforms.Compose([ transforms.ToPILImage(), transforms.ToTensor(), transforms.Normalize([0.5], [0.5]) ])) test_dataloader = DataLoader(test_mnist, batch_size=opt.n_grid_lines, shuffle=True) generator = Generator(opt) encoder = Encoder(opt) save_compared_images(opt, generator, encoder, test_dataloader, device)
def train(): # use gpu if available device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # dataloader BATCH_SIZE = 128 dt_train, dt_test, train_loader, test_loader = load_mnist( batch_size=BATCH_SIZE) # define autoencoder network N_INP = 28 * 28 ENCODED_SIZE = 32 encoder_net = Autoencoder(N_INP, ENCODED_SIZE).to(device) encoder_optimizer = optim.Adam(encoder_net.parameters()) # define the GMMN NOISE_SIZE = 20 gmm_net = GMMN(NOISE_SIZE, ENCODED_SIZE).to(device) gmmn_optimizer = optim.Adam(gmm_net.parameters(), lr=0.001) AE_PATH = '../models/GMMN/' GMMN_PATH = '../models/GMMN/' def train_autoencoder(): n_epoches_ae = 50 print(f'Training Autoencoder:') for ep in range(n_epoches_ae): avg_loss = 0 for idx, (x, _) in enumerate(train_loader): x = x.view(x.size()[0], -1).to(device) _, decoded = encoder_net(x) loss = torch.sum((x - decoded)**2) encoder_optimizer.zero_grad() loss.backward() encoder_optimizer.step() avg_loss += loss.item() avg_loss /= (idx + 1) print(f'\tEpoch: {ep}, \taverage loss: {avg_loss}') print('\tAutoencoder has been trained!') if AE_PATH: torch.save( encoder_net.state_dict(), AE_PATH + f'encoder_net+{time.strftime("%Y_%m_%d_%H:%M:%S")}.pth') def get_scale_matrix(M, N): s1 = (torch.ones((N, 1)) * 1.0 / N).to(device) s2 = (torch.ones((M, 1)) * -1.0 / M).to(device) return torch.cat((s1, s2), 0) def train_one_step(x, samples, sigma=[1]): samples = samples.to(device) gen_samples = gmm_net(samples) X = torch.cat((gen_samples, x), 0) XX = torch.matmul(X, X.t()) X2 = torch.sum(X * X, 1, keepdim=True) exp = XX - 0.5 * X2 - 0.5 * X2.t() M = gen_samples.size()[0] N = x.size()[0] s = get_scale_matrix(M, N) S = torch.matmul(s, s.t()) loss = 0 for v in sigma: kernel_val = torch.exp(exp / v) loss += torch.sum(S * kernel_val) loss = torch.sqrt(loss) gmmn_optimizer.zero_grad() loss.backward() gmmn_optimizer.step() return loss def train_gmmn(): # training loop n_epoches_gmmn = 100 print(f'Training GMMN:') for ep in range(n_epoches_gmmn): avg_loss = 0 for idx, (data_, _) in enumerate(train_loader): x_ = data_.view(data_.size()[0], -1) with torch.no_grad(): x_ = x_.to(device) encoded_x = encoder_net.encode(x_) # uniform random noise between [-1, 1] random_noise = torch.rand((BATCH_SIZE, NOISE_SIZE)) * 2 - 1 loss = train_one_step(encoded_x, random_noise) avg_loss += loss.item() avg_loss /= (idx + 1) print(f'\tEpoch: {ep}, \taverage loss: {avg_loss}') if PLOT: print( "\t Plotting the real, reconstructed, and generated data..." ) sample_size = 16 real_data = data_[:sample_size] # reconstructed image _, reconstructed_data = encoder_net( real_data.reshape(sample_size, -1)) # plt.imshow(y.detach().squeeze().numpy().reshape(28, 28)) reconstructed_data = reconstructed_data.detach().numpy( ).reshape(sample_size, 28, 28) # fake samples noise_ = torch.tensor(np.random.rand(sample_size, NOISE_SIZE), dtype=torch.float, requires_grad=True) * 2 - 1 encoded_x = gmm_net(noise_) fake_samples = encoder_net.decode(encoded_x) fake_samples = fake_samples.detach().numpy().reshape( sample_size, 28, 28) # print(data_.shape, fake_samples.shape)# !torch.Size([96, 1, 28, 28]) (16, 28, 28) Why 96? # plt.figure(figsize=(11.69, 8.27)) # the size of a A4 paper (in inches). plt.figure( figsize=(12.5, 9.5)) # the size of a A4 paper (in inches). for i in range(sample_size * 3): plt.subplot(6, sample_size // 2, i + 1) # plt.tight_layout() if i < sample_size: # real samples plt.imshow(data_[i][0], cmap="gray", interpolation="none") plt.title(f"O-{i+1}", fontsize=10, color='black') plt.xticks([]) plt.yticks([]) elif sample_size <= i < 2 * sample_size: # reconstructed samples plt.imshow(reconstructed_data[i - sample_size], cmap="gray", interpolation="none") plt.title(f"R-{i-sample_size+1}", fontsize=10, color='blue') plt.xticks([]) plt.yticks([]) else: # fake samples plt.imshow(fake_samples[i - 2 * sample_size], cmap="gray", interpolation="none") plt.title(f"F-{i-sample_size+1}", fontsize=10, color='red') plt.xticks([]) plt.yticks([]) time_now = time.strftime("%Y_%m_%d_%H:%M:%S") plt.savefig( dpi=300, format="png", fname= f"../results/GMMN/mnist/gmmn-real_vs_fake-{time_now}-Epoch-{ep}.png", ) # plt.show() plt.clf() print('\tGMMN trained!') if GMMN_PATH: torch.save( gmm_net.state_dict(), GMMN_PATH + f'gmmn-{time.strftime("%Y_%m_%d_%H:%M:%S")}.pth') train_autoencoder() train_gmmn()
import numpy import pylab from unsupervised.sf import SparseFiltering from tools import load_mnist, scale_features, test_classifier if __name__ == "__main__": numpy.random.seed(0) train_images, T = load_mnist("training", 60000) train_images -= train_images.mean(axis=0) test_images, T2 = load_mnist("testing", 10000) test_images -= train_images.mean(axis=0) print "Dataset loaded" train_filter = train_images[:10000] train_classifier = train_images label_classifier = T n_filters = 196 estimator = SparseFiltering(n_filters=n_filters, maxfun=500, verbose=True) estimator.fit(train_filter) X = estimator.predict(train_classifier) X2 = estimator.predict(test_images) X_mean = X.mean(axis=0) X_std = X.std(axis=0) + 1e-8 X = scale_features(X, X_mean, X_std) X2 = scale_features(X2, X_mean, X_std) print "Transformed datasets" test_classifier(X, label_classifier, X2, T2)
from tools import load_mnist from keras import backend as K from keras.models import Sequential from keras.layers import Dense, Flatten, Dropout from keras.layers import Conv2D, MaxPooling2D from matplotlib import pyplot as plt batch_size = 128 # 一次批处理100个样本 num_classes = 10 # 0-9数字一共10类 epochs = 12 # 对样本循环过10遍 img_rows = img_cols = 28 # 样本的长 color_channels = 1 # 样本的颜色通道 input_shape = (img_rows, img_cols, color_channels) # 样本的输入维度 # 加载数据集 (train_data, train_label), (eval_data, eval_label) = load_mnist('./data') # 重塑成4D train_data = train_data.reshape(train_data.shape[0], img_rows, img_rows, color_channels) eval_data = eval_data.reshape(eval_data.shape[0], img_rows, img_cols, color_channels) # 转换类型 train_data = train_data.astype('float32') eval_data = eval_data.astype('float32') # 归一化 train_data /= 255 eval_data /= 255
def train_GAN(): """Main training function. """ # model_setting(): batch_size = 128 _, _, train_loader, test_loader = load_mnist(batch_size) z_dim = 77 mnist_dim = 28 * 28 gi_sampler = input_sampler() D = Descriminator(mnist_dim, 1) # output the probability. G = Generator(z_dim, mnist_dim) print(D, "\n", G, "\n") n_epochs = 120 criterion = nn.BCELoss() g_lr = 2e-4 # *learning rate should not be too large to void model collapsing. d_lr = 2e-4 # sgd_momentum=0.8 # d_optimizer=optim.SGD(D.parameters(),lr=d_lr,momentum=sgd_momentum) # g_optimizer=optim.SGD(G.parameters(),lr=g_lr,momentum=sgd_momentum) d_optimizer = optim.Adam(D.parameters(), lr=d_lr) g_optimizer = optim.Adam(G.parameters(), lr=g_lr) # training for epoch in range(n_epochs): for batch_idx, (data_, _) in enumerate(train_loader): # * Do not need y here. # data_.max()=1,data_.min()=-1 # Train D d_optimizer.zero_grad() # on real d_real_data = data_.view(-1, mnist_dim) # print(f'real data size: {d_real_data.shape}') d_real_label = torch.ones([d_real_data.shape[0], 1]) # print(f'real data size: {d_real_label.shape}') d_real_decision = D(d_real_data) err_d_real = criterion(d_real_decision, d_real_label) # on fake d_fake_data = G(gi_sampler(batch_size, z_dim)) # !detach? input noise. # print(f'd fake data:{d_fake_data.shape}') d_fake_label = torch.zeros([d_fake_data.shape[0], 1]) d_fake_decision = D(d_fake_data) err_d_fake = criterion(d_fake_decision, d_fake_label) err_d = err_d_real + err_d_fake err_d.backward() d_optimizer.step() # Can also use: (err_real+err_fake).backward(). # Train G on D's response g_optimizer.zero_grad() noise_g = gi_sampler(batch_size, z_dim) g_fake_data = G(noise_g) # *'Train G to pretend it's genuine' (equivalent to the fomula in Goodfellow,2014). g_fake_label = torch.ones([batch_size, 1]) g_fake_decision = D(g_fake_data) err_g = criterion(g_fake_decision, g_fake_label) err_g.backward() g_optimizer.step() # if (epoch % 2 == 0) & (batch_idx % 50 == 0): if (batch_idx % 50 == 0): print(f"Epoch:{epoch}|Batch:{batch_idx}\ \tD (real_err:{shorter(extract(err_d_real)[0])},fake_err:{shorter(extract(err_d_fake)[0])})\ \tG (err:{shorter(extract(err_g)[0])})") # plot some samples # if PLOT & (epoch % 2 == 0): if PLOT: print("\tPlotting the real vs. generated data...") # fake samples sample_size = 16 fake_samples = G(gi_sampler(sample_size, z_dim)).detach().numpy() fake_samples = fake_samples.reshape(sample_size, 28, 28) print(data_.shape, fake_samples.shape ) # !torch.Size([96, 1, 28, 28]) (16, 28, 28) Why 96? plt.figure(figsize=(11.69, 8.27)) # the size of a A4 paper (in inches). for i in range(sample_size * 2): plt.subplot(4, sample_size // 2, i + 1) # plt.tight_layout() if i < sample_size: # real samples plt.imshow(data_[i][0], cmap="gray", interpolation="none") plt.title(f"R-{i+1}", fontsize=12) plt.xticks([]) plt.yticks([]) else: plt.imshow(fake_samples[i - sample_size], cmap="gray", interpolation="none") plt.title(f"F-{i-sample_size+1}", fontsize=12) plt.xticks([]) plt.yticks([]) time_now = time.strftime("%Y_%m_%d_%H:%M:%S") plt.savefig( dpi=300, format="png", fname= f"../results/GANs/mnist/real_vs_fake-{time_now}-Epoch-{epoch}.png", ) # plt.show() plt.clf() if SAVE: torch.save(G.state_dict(), f'../models/GANs/G-{time_now}.pth') torch.save(D.state_dict(), f'../models/GANs/D-{time_now}.pth')
# main.py import sys from os import path sys.path.append(path.dirname(path.dirname(path.abspath(__file__)))) from tools import load_mnist, predict from costFunction import costFunction from train import gradientDescent import numpy as np # load data # set X, Y, Theta X, Y = load_mnist(1000, '../data/') Theta = np.zeros((Y.shape[1], X.shape[1] + 1)) X = np.concatenate((np.ones((X.shape[0], 1)), X), axis=1) print(Theta.shape) # set hyper parameters learningRate = 0.001 numIter = 3000 # set cost function cost = costFunction(X, Y, Theta) print("before : ", cost) # set gradient descent Theta = gradientDescent(X, Y, Theta, learningRate, numIter) cost = costFunction(X, Y, Theta) print("after : ", cost)