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)