def __init__(self, name, train_data_dir, test_data_dir):
self.name = name
transform = transforms.ToTensor()
trainset = datasets.ImageFolder(train_data_dir, transform=transform)
self.trainloader = torch.utils.data.DataLoader(
trainset,
batch_size=BATCH_SIZE,
shuffle=True
)
testset = datasets.ImageFolder(test_data_dir, transform=transform)
self.testloader = torch.utils.data.DataLoader(
testset,
batch_size=BATCH_SIZE,
shuffle=False
)
dataset_list = list(self.trainloader)
self.dataset_len = len(dataset_list)
self.net = LeNet().to(device)
self.criterion = nn.CrossEntropyLoss()
def inference(input_x, input_y):
x = input_x
y_ = input_y
global_step = tf.Variable(0, trainable=False)
#regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
le_network = LeNet()
result_train = le_network.network_fn(x, is_training=True)
result_test = le_network.network_fn(x, is_training=False)
#correct_train = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
correct_test = tf.equal(tf.argmax(result_test, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_test, "float"))
# loss, learning rate, moving_average
#variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
#variables_averages_op = variable_averages.apply(tf.trainable_variables())
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=result_train, labels=y_)
cross_entropy_mean = tf.reduce_mean(cross_entropy)
loss = cross_entropy_mean # + tf.add_n(tf.get_collection('losses'))
learning_rate = tf.train.exponential_decay(
cfg.LEARNING_RATE_BASE,
global_step,
mnist.train.num_examples / cfg.BATCH_SIZE, cfg.LEARNING_RATE_DECAY,
staircase=True)
# update_ops & tf.control_dependencies are needed when introducing batch_norm
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
train_op = train_step
return train_op, loss, global_step, accuracy
def main(args):
transform_SVHN = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset_SVHN = torchvision.datasets.SVHN(root=args.dataset_path[0], split='train', download=True, transform=transform_SVHN)
testset_SVHN = torchvision.datasets.SVHN(root=args.dataset_path[0], split='test', download=True, transform=transform_SVHN)
train_labelled_size = int(0.6 * len(trainset_SVHN))
train_unlabelled_size = len(trainset_SVHN) - train_labelled_size
val_size = int(0.2 * len(testset_SVHN))
test_size = len(testset_SVHN) - val_size
trainset_labelled, trainset_unlabelled = torch.utils.data.random_split(trainset_SVHN, [train_labelled_size, train_unlabelled_size])
valset, testset = torch.utils.data.random_split(testset_SVHN, [val_size, test_size])
# Should increase batch size to decrease training time. Batch size for LeNet and VAT datasets can be different, i.e. 32 for LeNet and 128 for VAT
train_labelled_loader = DataLoader(trainset_labelled, batch_size=32, shuffle=True, num_workers=2)
train_unlabelled_loader = DataLoader(trainset_unlabelled, batch_size=32, shuffle=True, num_workers=2)
valloader = DataLoader(valset, batch_size=1, shuffle=True, num_workers=2)
testloader = DataLoader(testset, batch_size=1, shuffle=False, num_workers=2)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Device: " + str(device))
lenet0 = LeNet(device)
lenet0 = lenet0.to(device)
print(lenet0)
criterion = nn.CrossEntropyLoss()
criterion_VAT = VAT(device, eps=args.eps, xi=args.xi, k=args.k, use_entmin=args.use_entmin)
optimizer = optim.Adam(lenet0.parameters(), lr=args.lr) # Should implement lr scheduler.
# optimizer = optim.SGD(lenet0.parameters(), lr=args.lr, momentum=0.9)
if args.eval_only:
loadsave(lenet0, optimizer, "VATcheck", root=args.weights_path[0], mode='load')
else:
supervised_loss, unsupervised_loss = train(lenet0, optimizer, criterion, criterion_VAT, train_labelled_loader, train_unlabelled_loader, valloader, testloader, args.alpha, args.epochs, device, args.weights_path[0])
plt.subplot(2,1,1)
plt.plot(supervised_loss)
plt.title("Supervised loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.grid(True)
plt.subplot(2,1,2)
plt.plot(unsupervised_loss)
plt.title("Unsupervised loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.grid(True)
plt.show()
loadsave(lenet0, optimizer, "VATcheck", root=args.weights_path[0], mode='load')
vat_acc = evaluate_classifier(lenet0, testloader, device)
print("Accuracy of the network on SVHN is %d%%\n" %(vat_acc*100))
barchartplot(lenet0, testloader, device)
def mnist_lenet(input_shape, classes):
model = LeNet(input_shape, classes)
optimizer = keras.optimizers.SGD(lr=0.01)
model.compile(optimizer=optimizer,
loss=keras.losses.categorical_crossentropy,
metrics=['accuracy'])
return model
def _train(self, input_dim, num_classes, params, X_train, y_train, X_valid,
y_valid):
lenet_config = LeNetConfig(input_dim, num_classes, params)
lenet = LeNet(lenet_config)
history, best_valid_loss, best_valid_accuracy = lenet.fit(X_train,
y_train,
X_valid,
y_valid,
debug=False)
return history, best_valid_loss, best_valid_accuracy, lenet
class Client:
def __init__(self, name, train_data_dir, test_data_dir):
self.name = name
transform = transforms.ToTensor()
trainset = datasets.ImageFolder(train_data_dir, transform=transform)
self.trainloader = torch.utils.data.DataLoader(
trainset,
batch_size=BATCH_SIZE,
shuffle=True
)
testset = datasets.ImageFolder(test_data_dir, transform=transform)
self.testloader = torch.utils.data.DataLoader(
testset,
batch_size=BATCH_SIZE,
shuffle=False
)
dataset_list = list(self.trainloader)
self.dataset_len = len(dataset_list)
self.net = LeNet().to(device)
self.criterion = nn.CrossEntropyLoss()
def update(self, net_dict, center_params_dict):
self.net.load_state_dict(net_dict)
for i in range(LOCAL_EPOCH_NUM):
data_iter = iter(self.trainloader)
for b in range(self.dataset_len):
inputs, labels = next(data_iter)
inputs = torch.index_select(inputs, 1, torch.LongTensor([0]))
inputs, labels = inputs.to(device), labels.to(device)
outputs = self.net(inputs)
loss = self.criterion(outputs, labels)
optimizer = optim.SGD(self.net.parameters(), lr=LR, momentum=0.9)
optimizer.zero_grad()
loss.backward()
params_modules = list(self.net.named_parameters())
for params_module in params_modules:
name, params = params_module
params.grad += MU * (params.data - center_params_dict[name])
optimizer.step()
return self.net.state_dict()
def main():
print("\033[37mSanVik2000".center(os.get_terminal_size().columns))
print("\033[37mLibrary of Famous Classification Algorithms".center(
os.get_terminal_size().columns))
print("\033[37mImplemented in PyTorch".center(
os.get_terminal_size().columns))
Print_Line()
print("\033[93mSOFTWARE DETAILS\033[00m".center(
os.get_terminal_size().columns))
print("\033[00m================\033[00m".center(
os.get_terminal_size().columns))
print("Python Version : \033[93m", sys.version)
print("\033[00mPyTorch Verison : \033[93m", torch.__version__)
print("\033[00mPyTorch using Device : \033[93m", device, "\033[00m")
Print_Line()
print(
"Choose from the following models to classify images using the CIFAR-10 Dataset\033[00m"
)
print("*\033[93m 1 \033[00m* LeNet")
print("*\033[93m 2 \033[00m* AlexNet")
print("*\033[93m 3 \033[00m* VGG16")
model = int(input("Enter model choice : "))
if model == 1:
model = LeNet()
model_name = "LeNet"
image_size = 32
if model == 2:
model = AlexNet()
model_name = "AlexNet"
image_size = 256
if model == 3:
model = VGG()
model_name = "VGG16"
image_size = 32
Print_Line()
trainloader, testloader, classes = Prepare_Data(image_size)
model = model.to(device)
Train_Model(model, trainloader, model_name)
Test_Model(model, testloader, model_name)
class Client:
def __init__(self, name, train_data_dir, test_data_dir, pk, sk):
self.name = name
self.pk = pk
self.sk = sk
transform = transforms.ToTensor()
trainset = datasets.ImageFolder(train_data_dir, transform=transform)
self.trainloader = torch.utils.data.DataLoader(trainset,
batch_size=BATCH_SIZE,
shuffle=True)
testset = datasets.ImageFolder(test_data_dir, transform=transform)
self.testloader = torch.utils.data.DataLoader(testset,
batch_size=BATCH_SIZE,
shuffle=False)
dataset_list = list(self.trainloader)
self.dataset_len = len(dataset_list)
self.net = LeNet().to(device)
self.criterion = nn.CrossEntropyLoss()
def get_encrypted_grad(self, client_inputs, client_labels, net_dict):
self.net.load_state_dict(net_dict)
client_outputs = self.net(client_inputs)
client_loss = self.criterion(client_outputs, client_labels)
client_optimizer = optim.SGD(self.net.parameters(),
lr=LR,
momentum=0.9)
client_optimizer.zero_grad()
client_loss.backward()
params_modules = list(self.net.named_parameters())
params_grad_list = []
for params_module in params_modules:
name, params = params_module
params_grad_list.append(copy.deepcopy(params.grad).view(-1))
params_grad = ((torch.cat(params_grad_list, 0) + bound) *
2**prec).long().cuda()
client_encrypted_grad = Enc(self.pk, params_grad)
client_optimizer.zero_grad()
return client_encrypted_grad
def train_student():
ckpt_path = './train_dir/mnist_student.ckpt'
train_data, train_labels, test_data, test_labels = preprocessing()
# student_share = 1000
student_share = FLAGS.stdnt_share
train_data = test_data[:student_share]
# train_labels = test_labels[:student_share]
weightsPath = './weights/LeNet.hdf5'
lenet = LeNet.build(width=28, height=28, depth=1, classes=10)
lenet.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
lenet.load_weights(weightsPath)
train_labels = lenet.predict(train_data)
# print(train_labels[:10])
# x = input()
train_data = train_data.reshape(train_data.shape[0], -1)
test_data = test_data.reshape(test_data.shape[0], -1)
test_data = test_data[student_share:]
test_labels = test_labels[student_share:]
print("data preprocessing done")
assert train_with_noise_ce(train_data, train_labels, ckpt_path)
ckpt_path_final = ckpt_path + '-' + str(FLAGS.max_steps - 1)
logits = softmax_preds(train_data, ckpt_path_final)
accuracy = np.sum(np.argmax(logits, -1) == np.argmax(
train_labels, -1)) / len(train_labels)
print("student's train accuracy is ", accuracy)
logits = softmax_preds(test_data, ckpt_path_final)
accuracy = np.sum(
np.argmax(logits, -1) == np.argmax(test_labels, -1)) / len(test_labels)
print("student's test accuracy is ", accuracy)
return True
def distillation():
'''
distillation of lenet knowledge
'''
train_data, train_labels, test_data, test_labels = preprocessing()
student_share = 1000
train_data = test_data[:student_share]
# train_labels = test_labels[:student_share]
weightsPath = './weights/LeNet.hdf5'
lenet = LeNet.build(width=28, height=28, depth=1, classes=10)
lenet.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
lenet.load_weights(weightsPath)
train_labels = lenet.predict(train_data)
# print(train_labels[:10])
# x = input()
train_data = train_data.reshape(train_data.shape[0], -1)
test_data = test_data.reshape(test_data.shape[0], -1)
test_data = test_data[student_share:]
test_labels = test_labels[student_share:]
op = keras.optimizers.Adam()
model = StudentModel.build(train_data.shape[1], 10)
model.compile(optimizer=op,
loss=lambda y_true, y_pred: loss_fun(y_true, y_pred),
metrics=['accuracy'])
model.fit(train_data, train_labels, batch_size=128, nb_epoch=20, verbose=1)
print("[INFO] evaluating...")
(loss, accuracy) = model.evaluate(test_data,
test_labels,
batch_size=128,
verbose=1)
print("[INFO] accuracy: {:.2f}%".format(accuracy * 100))
class Client:
def __init__(self, name, train_data_dir, test_data_dir):
self.name = name
transform = transforms.ToTensor()
trainset = datasets.ImageFolder(train_data_dir, transform=transform)
self.trainloader = torch.utils.data.DataLoader(trainset,
batch_size=BATCH_SIZE,
shuffle=True)
testset = datasets.ImageFolder(test_data_dir, transform=transform)
self.testloader = torch.utils.data.DataLoader(testset,
batch_size=BATCH_SIZE,
shuffle=False)
dataset_list = list(self.trainloader)
self.dataset_len = len(dataset_list)
self.net = LeNet().to(device)
self.criterion = nn.CrossEntropyLoss()
def get_grad(self, client_inputs, client_labels, net_dict):
self.net.load_state_dict(net_dict)
client_outputs = self.net(client_inputs)
client_loss = self.criterion(client_outputs, client_labels)
client_optimizer = optim.SGD(self.net.parameters(),
lr=LR,
momentum=0.9)
client_optimizer.zero_grad()
client_loss.backward()
client_grad_dict = dict()
params_modules = list(self.net.named_parameters())
for params_module in params_modules:
name, params = params_module
params_grad = copy.deepcopy(params.grad)
client_grad_dict[name] = params_grad
client_optimizer.zero_grad()
return client_grad_dict
def main():
# image shape: N x H x W, pixel [0, 255]
# label shape: N x 10
with np.load(r'mnist.npz', allow_pickle=True) as f:
x_train, y_train = f['x_train'], f['y_train']
x_test, y_test = f['x_test'], f['y_test']
plt.imshow(x_train[59999], cmap='gray')
plt.show()
print(x_train.shape, x_train[0].max(), x_train[0].min()) #(60000, 28, 28) 255 0 5
print(x_test.shape, x_test[0].max(), x_test[0].min()) #(10000, 28, 28) 255 0 7
x_train = normalize_image(x_train)
x_test = normalize_image(x_test)
y_train = one_hot_labels(y_train)
y_test = one_hot_labels(y_test)
net = LeNet()
averagetime, _ = net.fit(x_train, y_train, x_test, y_test, epoches=10, batch_size=16, lr=1e-3)
accuracy = net.evaluate(x_test, labels=y_test)
print("final accuracy {}".format(accuracy))
print(averagetime,'s')
def model_attack(data_local,
data_backdoor,
net_dict,
client_net,
local_epochs=10,
e=0.001,
batch=128,
c=112):
'''
模型攻击
:param data_local: 正常的数据
:param data_backdoor: 后门数据
:param net_dict: 全局网络参数
:param client_net: 本地网络
:param local_epochs: 本地网络迭代次数
:param e: 最大loss，loss低于这个值的时候训练停止
:param batch: 一次输入训练的数据量
:param c: batch里替换的数据数
:return: 训练好的模型X
'''
client_net.load_state_dict(net_dict)
gamma = Num_client / LR
t_net = LeNet()
opt_local = optim.Adam(client_net.parameters(), lr=LR, betas=(0.9, 0.99))
for epoch in range(local_epochs):
if get_loss(client_net, data_backdoor) < e:
break
for start in range(0, len(data_local), batch):
b = [
data_local[0][start:start + batch],
data_local[1][start:start + batch]
]
b = replace(c, b, data_backdoor)
grad = get_client_grad(b[0], b[1], client_net.state_dict(), t_net)
params_modules_attacker = client_net.named_parameters()
for params_module in params_modules_attacker:
(name_attacker, params) = params_module
params.grad = grad[name_attacker]
opt_local.step()
params_modules_attacker = list(client_net.named_parameters())
params_modules_G = list(net.named_parameters())
params_modules_L = {}
for i in range(len(params_modules_attacker)):
params_modules_L[params_modules_attacker[i][0]] = -(
gamma * (params_modules_attacker[i][1] - params_modules_G[i][1]) +
params_modules_G[i][1])
# client_net.load_state_dict(params_modules_L)
return params_modules_L
def main():
# Setting the processing to GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
# Loading Training and Testing Dataset from CIFAR10
batch_size = 128
train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transforms.ToTensor())
train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True)
test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transforms.ToTensor())
test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, shuffle=False)
# Initializing the LeNet Object
net = LeNet().to(device)
# Initializing the Cross Entropy Loss Function
loss_fn = nn.CrossEntropyLoss()
# Initializing the Adam Optimizer
opt = optim.Adam(net.parameters())
start_time = time.time()
# Training the Model
net.fit(train_loader, test_loader, max_epochs=16, opt=opt, loss_fn=loss_fn)
duration = time.time() - start_time
print("Duration of Model: {:.2f} secs".format(duration))
def main(_):
iterations = FLAGS.iterations
lr = FLAGS.lr
batch_size = FLAGS.batch_size
mu = FLAGS.mu
sigma = FLAGS.sigma
lenet_part = LeNet(iterations=iterations, lr=lr, batch_size=batch_size, mu=mu, sigma=sigma)
gd = gif_drawer()
show_all_variables()
run_config = tf.ConfigProto()
run_config.gpu_options.allow_growth=True
with tf.Session(config=run_config) as sess:
mnist = input_data.read_data_sets('./data/mnist',one_hot=True)
sess.run(tf.global_variables_initializer())
test_images = mnist.test.images
test_images = np.reshape(test_images,[-1,28,28,1])
test_images = np.pad(test_images,((0,0),(2,2),(2,2),(0,0)), 'constant')
for ii in range(lenet_part.iterations):
batch_xs, batch_ys = mnist.train.next_batch(lenet_part.batch_size)
batch_xs = np.reshape(batch_xs,[-1,28,28,1])
batch_xs = np.pad(batch_xs, ((0,0),(2,2),(2,2),(0,0)), 'constant')
sess.run(lenet_part.train_op, feed_dict={lenet_part.raw_input_image:batch_xs, lenet_part.raw_input_label: batch_ys})
if ii % 10 == 0:
validation_images, validation_labels = mnist.validation.next_batch(100)
validation_images = np.reshape(validation_images,[-1,28,28,1])
validation_images = np.pad(validation_images,((0,0),(2,2),(2,2),(0,0)), 'constant')
acc, los = sess.run([lenet_part.accuracy, lenet_part.cross_entropy], \
feed_dict={lenet_part.raw_input_image:validation_images,\
lenet_part.raw_input_label:validation_labels})
print("Iteration [%5d/%5d]: accuracy is: %4f loss is: %4f"%(ii,lenet_part.iterations,acc,los))
gd.draw(ii, acc, los)
gd.save('./train.png')
for ii in range(10):
acc = sess.run(lenet_part.accuracy, \
feed_dict={lenet_part.raw_input_image:test_images,\
lenet_part.raw_input_label:mnist.test.labels})
print("Test: accuracy is %4f"%(acc))
def test(model_save_dir, X_test, y_test):
# load the graph structure from the ".meta" file into the current graph.
tf.reset_default_graph()
lenet = LeNet(img_w=32, img_h=32, img_channel=1, n_classes=43)
# load the values of variables.
# values only exist within a session
# evaluate the model
with tf.Session() as sess:
var_list = tf.global_variables()
saver = tf.train.Saver(var_list=var_list)
saver.restore(sess, tf.train.latest_checkpoint('./model/lenet5/'))
feed = {lenet.x: X_test, lenet.labels: y_test}
test_accuracy = sess.run(lenet.accuracy, feed_dict=feed)
print("Test Accuracy = {:.3f}".format(test_accuracy))
def build_lenet():
train_data, train_labels, test_data, test_labels = preprocessing()
train_labels = perturb(train_labels)
print(train_data.shape)
op = keras.optimizers.Adam()
model = LeNet.build(width=28, height=28, depth=1, classes=10)
model.compile(loss='binary_crossentropy',
optimizer=op,
metrics=['accuracy'])
print("[INFO] training...")
model.fit(train_data, train_labels, batch_size=128, nb_epoch=30, verbose=1)
print("[INFO] evaluating...")
(loss, accuracy) = model.evaluate(test_data,
test_labels,
batch_size=128,
verbose=1)
print("[INFO] accuracy: {:.2f}%".format(accuracy * 100))
weightsPath = './weights/LeNet.hdf5'
print("[INFO] dumping weights to file...")
model.save_weights(weightsPath, overwrite=True)
# convert the labels from integers to vectors
trainY = to_categorical(trainY, num_classes=len(labellist))
testY = to_categorical(testY, num_classes=len(labellist))
# construct the image generator for data augmentation
aug = ImageDataGenerator(rotation_range=30,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode="nearest")
# initialize the model
print("[INFO] compiling model...")
model = LeNet.build(width=64, height=64, depth=3, classes=len(labellist))
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
# train the network
print("[INFO] training network...")
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
validation_data=(testX, testY),
steps_per_epoch=len(trainX) // BS,
epochs=EPOCHS,
verbose=1)
# save the model to disk
print("[INFO] serializing network...")
def runCNN(datasets):
lenet = LeNet()
lenet.fit(datasets)
from dataset import train_ds
# Hyper parameters
epoch_num = 300
batch_size = 128
lr = 1e-4 # learning rate
workers = 2 # subprocess number for load the image
weight_decay = 1e-3
train_ds_size = 42000 # the size of your train dataset
# dataset
train_dl = DataLoader(train_ds, batch_size, True, num_workers=workers)
# use cuda if you have GPU
net = LeNet()
net = net.cuda()
# optimizer
opt = torch.optim.Adam(net.parameters(), lr=lr,
weight_decay=weight_decay) # optimizer for network
# loss function
loss_func = nn.CrossEntropyLoss()
# train the network
start = time()
for epoch in range(epoch_num):
for step, (data, target) in enumerate(train_dl, 1):
labels,
test_size=0.25,
random_state=42)
trainY = to_categorical(trainY, num_classes=2) #aqui cambiale a las 26 diego
testY = to_categorical(testY, num_classes=2)
# construct the image generator for data augmentation
aug = ImageDataGenerator(rotation_range=30,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode="nearest")
print("[INFO] compiling model...")
model = LeNet.build(width=28, height=28, depth=3, classes=2)
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model.compile(
loss="binary_crossentropy",
optimizer=opt, #for 2 binary_crossentropy, more categorical_crossentropy
metrics=["accuracy"])
# train the network
print("[INFO] training network...")
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
validation_data=(testX, testY),
steps_per_epoch=len(trainX) // BS,
epochs=EPOCHS,
verbose=1)
# save the model to disk
if __name__ == "__main__":
if args.enable_lat:
real_model_path = args.model_path + "lat_param.pkl"
print('loading the LAT model')
else:
real_model_path = args.model_path + "naive_param.pkl"
print('loading the naive model')
if args.test_flag:
args.enable_lat = False
# switch models
if args.model == 'lenet':
cnn = LeNet(enable_lat=args.enable_lat,
epsilon=args.epsilon,
pro_num=args.pro_num,
batch_size=args.batchsize,
batch_norm=args.batchnorm,
if_dropout=args.dropout)
elif args.model == 'resnet':
cnn = ResNet50(enable_lat=args.enable_lat,
epsilon=args.epsilon,
pro_num=args.pro_num,
batch_size=args.batchsize,
if_dropout=args.dropout)
cnn.apply(conv_init)
elif args.model == 'vgg':
cnn = VGG16(enable_lat=args.enable_lat,
epsilon=args.epsilon,
pro_num=args.pro_num,
batch_size=args.batchsize,
if_dropout=args.dropout)
from LeNet import LeNet
from dataset import test_ds
# Hyper parameters
batch_size = 128
workers = 2 # subprocess number for load the image
module_dir = './modle/net299-329.pth'
pred_label = []
# dataset
test_dl = DataLoader(test_ds, batch_size, num_workers=workers)
# use cuda if you have GPU
net = LeNet().cuda()
net.load_state_dict(torch.load(module_dir))
net.eval()
# 预测结果
for step, data in enumerate(test_dl, 1):
data = data.cuda()
with torch.no_grad():
outputs = net(data)
outputs = torch.max(outputs, 1)[1].data.cpu().numpy().tolist()
pred_label += outputs
# 将预测结果写入到csv文件中
def main():
print("Loading data...\n")
dataset = get_dataset()
(train_X, train_Y), (test_X, test_Y) = process_data(dataset)
# Convert the dataset into torch tensors
train = data_utils.TensorDataset(
torch.tensor(train_X).float(),
torch.tensor(train_Y).long())
test = data_utils.TensorDataset(
torch.tensor(test_X).float(),
torch.tensor(test_Y).long())
train_loader = data_utils.DataLoader(train,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=5,
sampler=None,
pin_memory=False)
test_loader = data_utils.DataLoader(
test, # dataset to load from
batch_size=BATCH_SIZE, # examples per batch (default: 1)
shuffle=False,
sampler=
None, # if a sampling method is specified, `shuffle` must be False
num_workers=5, # subprocesses to use for sampling
pin_memory=False) # whether to return an item pinned to GPU
# Calculate the word-level accuracy on the training and the test ser
default_train_loader = get_default_train_loader()
default_test_loader = get_default_test_loader()
if args.model == "lenet":
print("Running LeNet on OCR")
model = LeNet()
else:
print("Running AlexNet on OCR")
model = AlexNet(num_classes=26)
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.LBFGS(model.parameters(), history_size=5, max_iter=5)
if args.num_epochs is not None:
NUM_EPOCHS = args.num_epochs
else:
NUM_EPOCHS = 100
print("Starting Training...\n")
letter_training_accuracies = []
letter_test_accuracies = []
word_training_accuracies = []
word_test_accuracies = []
for epoch in range(NUM_EPOCHS):
print("Processing epoch {}".format(epoch + 1))
running_loss = 0.0
for i_batch, sample in enumerate(train_loader, 0):
train_X = sample[0]
train_Y = sample[1]
train_X, train_Y = train_X.to(device), train_Y.to(device)
train_Y_labels = torch.max(train_Y, 1)[1]
def closure():
optimizer.zero_grad()
outputs = model(train_X)
outputs.to(device)
tr_loss = criterion(outputs, train_Y_labels)
print('Loss at epoch {}, batch {}: {}'.format(
epoch + 1, i_batch, tr_loss.item()))
tr_loss.backward()
del outputs
return tr_loss
optimizer.step(closure)
del train_X, train_Y, train_Y_labels
# Calculate the letter-level accuracy on the training and the test set
letter_training_accuracy = letter_accuracy(train_loader, model)
letter_test_accuracy = letter_accuracy(test_loader, model)
letter_training_accuracies.append(letter_training_accuracy)
letter_test_accuracies.append(letter_test_accuracy)
word_training_accuracy = word_accuracy(default_train_loader, model)
word_test_accuracy = word_accuracy(default_test_loader, model)
word_training_accuracies.append(word_training_accuracy)
word_test_accuracies.append(word_test_accuracy)
print('\nLetter Training Accuracy on epoch {}: {}'.format(
epoch + 1, letter_training_accuracy))
print('Letter Test Accuracy on epoch {}: {}'.format(
epoch + 1, letter_test_accuracy))
print('Word Training Accuracy on epoch {}: {}'.format(
epoch + 1, word_training_accuracy))
print('Word Training Accuracy on epoch {}: {}\n'.format(
epoch + 1, word_test_accuracy))
final_letter_test_accuracy = letter_accuracy(test_loader, model)
final_word_test_accuracy = word_accuracy(default_test_loader, model)
print("Letter Test accuracy of {} on OCR Data: {}".format(
args.model, final_letter_test_accuracy))
print("Word Test accuracy of {} on OCR Data: {}".format(
args.model, final_word_test_accuracy))
save_accuracies(letter_training_accuracies, letter_test_accuracies,
"letter", args.model, "lbfgs")
save_accuracies(word_training_accuracies, word_test_accuracies, "word",
args.model, "lbfgs")
# Save the model
print("Saving {} model to {}".format(args.model, PATH))
torch.save(model, PATH)
def main():
mlp_hiddens = [1000]
filter_sizes = [(9, 9), (5, 5), (5, 5)]
feature_maps = [80, 50, 20]
pooling_sizes = [(3, 3), (2, 2), (2, 2)]
save_to = "DvC.pkl"
image_size = (128, 128)
output_size = 2
learningRate = 0.1
num_epochs = 300
num_batches = None
if socket.gethostname() == 'tim-X550JX':
host_plot = 'http://*****:*****@ %s' %
('CNN ', datetime.datetime.now(), socket.gethostname()),
channels=[['train_error_rate', 'valid_error_rate'],
['train_total_gradient_norm']],
after_epoch=True,
server_url=host_plot))
model = Model(cost)
main_loop = MainLoop(algorithm,
stream_data_train,
model=model,
extensions=extensions)
main_loop.run()
def run_training(X_train,
y_train,
X_valid,
y_valid,
num_epoch,
batch_size,
learning_rate,
model_save_dir,
restorePath=None):
log_dir = './result'
if not os.path.exists(model_save_dir):
os.makedirs(model_save_dir)
# build LeNet
lenet = LeNet(img_w=32, img_h=32, img_channel=1, n_classes=43)
with tf.name_scope("train"):
train_step = tf.train.AdamOptimizer(learning_rate).minimize(lenet.loss)
num_examples = X_train.shape[0]
print("starts training")
with tf.Session() as sess:
train_writer = tf.summary.FileWriter(log_dir + '/train', sess.graph)
# initialize variables
sess.run(tf.global_variables_initializer())
# Create a saver.
# The tf.train.Saver must be created after the variables that you want to restore (or save).
# Additionally it must be created in the same graph as those variables.
# restore training
if restorePath:
print("restore training")
var_list = tf.global_variables()
saver = tf.train.Saver(var_list=var_list)
saver.restore(sess, tf.train.latest_checkpoint(model_save_dir))
# start a new saver
else:
saver = tf.train.Saver(max_to_keep=1)
# each epoch will shuffle the entire training data
for ep in range(num_epoch):
print("epoch: ", ep)
X_train, y_train = shuffle(X_train, y_train)
# train on each batch
for offset in range(0, num_examples, batch_size):
end = offset + batch_size
batch_x, batch_y = X_train[offset:end], y_train[offset:end]
feed = {lenet.x: batch_x, lenet.labels: batch_y}
_, loss, summary = sess.run(
[train_step, lenet.loss, lenet.merged], feed_dict=feed)
# print("summary", summary)
# print("offset+num_examples*ep", offset+num_examples*ep)
train_writer.add_summary(summary, offset + num_examples * ep)
# test on training data
print("loss=", loss)
# save model
if ep % 10 == 0:
# test on train
feed = {lenet.x: X_valid, lenet.labels: y_valid}
accuracy = sess.run(lenet.accuracy, feed_dict=feed)
print("accuracy = ", accuracy)
# Append the step number to the checkpoint name:
saver.save(sess, model_save_dir + '/my-model', global_step=ep)
x: batch_x,
y: batch_y
})
total_accuracy += (accuracy * len(batch_x))
return total_accuracy / num_examples
EPOCHS = 90
BATCH_SIZE = 1024
x = tf.placeholder(tf.float32, (None, 32, 32, 3))
y = tf.placeholder(tf.int32, (None))
one_hot_y = tf.one_hot(y, 43)
rate = 0.001
logits = LeNet(x)
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits,
labels=one_hot_y)
loss_operation = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate=rate)
training_operation = optimizer.minimize(loss_operation)
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1))
accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver()
### Train the model here.
print('PASS')
with tf.Session() as sess:
print('PASS')
def main(port_data):
mlp_hiddens = [500]
filter_sizes = [(3,3),(3,3)]
feature_maps = [20, 20]
pooling_sizes = [(3,3),(2,2)]
save_to="DvC.pkl"
image_size = (128, 128)
output_size = 2
learningRate=0.1
num_epochs=300
num_batches=None
if socket.gethostname()=='tim-X550JX':host_plot = 'http://*****:*****@ %s' % ('CNN ', datetime.datetime.now(), socket.gethostname()),
channels=[['train_error_rate', 'valid_error_rate'],
['train_total_gradient_norm']], after_epoch=True, server_url=host_plot))
model = Model(cost)
main_loop = MainLoop(
algorithm,
stream_data_train,
model=model,
extensions=extensions)
main_loop.run()
params.grad += MU * (params.data - center_params_dict[name])
optimizer.step()
return self.net.state_dict()
def weight_init(m):
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
net = LeNet().to(device)
net.apply(weight_init)
optimizer_server = optim.SGD(net.parameters(), lr=LR, momentum=0.9)
client_list = []
# train_data_root = '/home/dchen/dataset/MNIST/IID/' + str(CLIENT_NUM) + '/train/'
# test_data_root = '/home/dchen/dataset/MNIST/IID/' + str(CLIENT_NUM) + '/test/'
train_data_root = '/home/dchen/dataset/MNIST/Non-IID1/' + str(CLIENT_NUM) + '/train/'
test_data_root = '/home/dchen/dataset/MNIST/Non-IID1/' + str(CLIENT_NUM) + '/test/'
for i in range(CLIENT_NUM):
client_name = 'client' + str(i)
client_list.append(Client(client_name, train_data_root + client_name + '/', test_data_root + client_name + '/'))
center_params_dict = dict()
def main():
mlp_hiddens = [1000]
filter_sizes = [(9,9),(5,5),(5,5)]
feature_maps = [80, 50, 20]
pooling_sizes = [(3,3),(2,2),(2,2)]
save_to="DvC.pkl"
image_size = (128, 128)
output_size = 2
learningRate=0.1
num_epochs=300
num_batches=None
if socket.gethostname()=='tim-X550JX':host_plot = 'http://*****:*****@ %s' % ('CNN ', datetime.datetime.now(), socket.gethostname()),
channels=[['train_error_rate', 'valid_error_rate'],
['train_total_gradient_norm']], after_epoch=True, server_url=host_plot))
model = Model(cost)
main_loop = MainLoop(
algorithm,
stream_data_train,
model=model,
extensions=extensions)
main_loop.run()
transform=transform)
cifar_test = torchvision.datasets.CIFAR10(root='./data',
train=False,
transform=transform)
print(cifar_train)
trainloader = torch.utils.data.DataLoader(cifar_train,
batch_size=32,
shuffle=True)
testloader = torch.utils.data.DataLoader(cifar_test,
batch_size=32,
shuffle=True)
device = torch.device("cuda:0")
net = LeNet().to(device)
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
print("START")
for epoch in range(50):
loss100 = 0.0
for i, data in enumerate(trainloader):
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
outputs = net(inputs)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
# 网络参数初始化
def weight_init(m):
# 使用isinstance来判断m属于什么类型
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
# torch.manual_seed(7) # 随机种子，是否每次做相同初始化赋值
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
# m中的 weight，bias 其实都是 Variable，为了能学习参数以及后向传播
m.weight.data.fill_(1)
m.bias.data.zero_()
net = LeNet()
attacker_net = LeNet()
# 初始化网络参数
net.apply(weight_init) # apply函数会递归地搜索网络内的所有module并把参数表示的函数应用到所有的module上
attacker_net.apply(weight_init)
# # 提取网络参数
# net_dic = net.state_dict()
# 定义损失函数
criterion = nn.CrossEntropyLoss() # 交叉熵损失函数，通常用于多分类问题上
optimizer_server = optim.Adam(net.parameters(), lr=LR, betas=(0.9, 0.99))
optimizer_backdoor = optim.Adam(attacker_net.parameters(),
lr=LR,
betas=(0.9, 0.99))
# 分配用户参数 send_back()
client_0_net = LeNet()
logprint = LogPrint(log, ExpID)
opt.ExpID = ExpID
opt.CodeID = get_CodeID()
logprint(opt.__dict__)
transform_train = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, ), (1.0, )),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, ), (1.0, )),
])
lenet = LeNet().cuda()
train_set = dset.MNIST(root='./data',
train=True,
download=True,
transform=transform_train)
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=opt.batch_size,
shuffle=True,
num_workers=2)
test_set = dset.MNIST(root='./data',
train=False,
download=True,
transform=transform_test)
test_loader = torch.utils.data.DataLoader(test_set,
