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()
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
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
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) elif args.model == 'alexnet': cnn = AlexNet(enable_lat=args.enable_lat, epsilon=args.epsilon, pro_num=args.pro_num, batch_size=args.batchsize, if_dropout=args.dropout) cnn.cuda() if os.path.exists(real_model_path): cnn.load_state_dict(torch.load(real_model_path)) print('load model.') else: print("load failed.") if args.test_flag: test_op(cnn) else: train_op(cnn)
for t in range(ROUND_NUM): client_net_dict_list = [] net_dict = net.state_dict() for i in range(CLIENT_NUM): client_net_dict_list.append(client_list[i].update(net_dict, center_params_dict)) client_average_net_dict = client_net_dict_list[0] for key in client_average_net_dict: for i in range(1, CLIENT_NUM): client_average_net_dict[key] += client_net_dict_list[i][key] for key in client_net_dict_list[0]: client_average_net_dict[key] /= CLIENT_NUM net.load_state_dict(client_average_net_dict) for key in center_params_dict: tmp_params = center_params_dict[key] for i in range(CLIENT_NUM): center_params_dict[key] += LR * MU * (client_net_dict_list[i][key] - tmp_params) with torch.no_grad(): ''' # test per client for i in range(CLIENT_NUM): correct = 0 total = 0 for data in client_list[i].testloader: images, labels = data images = torch.index_select(images, 1, torch.LongTensor([0]))
lenet.eval() train_accuracy = accuracy(train_loader, lenet) test_accuracy = accuracy(test_loader, lenet) lenet.train() if (test_accuracy >= best_result): best_result = test_accuracy torch.save(lenet.state_dict(), os.path.join(opt.path, 'lenet_best.pt')) logprint( 'Epoch [%d], Loss: %.4f, KL: %.4f, Train accuracy: %.4f, Test accuracy: %.4f, Best: %.4f' % (e, running_loss / num_batch, running_klloss / num_batch, train_accuracy, test_accuracy, best_result)) lenet_path = os.path.join(opt.path, "lenet_best.pt") lenet_best = LeNet().cuda() lenet_best.load_state_dict(torch.load(lenet_path)) baseline_acc = accuracy(test_loader, lenet_best) logprint("loaded pretrained model. baseline acc = %.4f" % baseline_acc) lenet_sbp = LeNet_SBP() sbp_parameters = [ { 'params': lenet_sbp.conv1.weight }, { 'params': lenet_sbp.conv2.weight }, { 'params': lenet_sbp.fc1.weight }, {
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文件中 with open('pred.csv', 'w') as file:
import numpy import os import sys path = os.path.abspath(os.path.dirname(sys.argv[0])) transform = transforms.Compose([ transforms.Resize((32, 32)), #模型的输入是32*32 transforms.ToTensor(), #转化为tensor才可以 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') net = LeNet() net.cuda() net.load_state_dict(torch.load(path + './result/Lenet.pth')) image = Image.open(path + './img/2.png') image = transform(image) # [C, H, W] channel hight width image = torch.unsqueeze( image, dim=0) # [N, C, H, W] 再加一个维度 变成batch channel hight width image = image.cuda() with torch.no_grad(): outputs = net(image) outputs = outputs.cpu() #需要把CUDA格式转化为CPU格式才能训练和预测 predict = torch.max(outputs, dim=1)[1] print(classes[int(predict)])
from LeNet import LeNet import torch import torch.nn as nn import torch.nn.functional as F Training = False Testing = True loadState = True TrainingData = np.array(pd.read_csv("mnist_train.csv"))[0:50000, :] ValidationData = np.array(pd.read_csv("mnist_train.csv"))[50000:,:] TestingData = np.array(pd.read_csv("mnist_test.csv")) model = LeNet() if loadState: model.load_state_dict(torch.load("bestState.pth")) optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9) loss_fn = nn.CrossEntropyLoss() if Training: while model.EpochRunner: trainloader = torch.utils.data.DataLoader(TrainingData, batch_size=250, shuffle=True, num_workers=8) for batch in trainloader: optimizer.zero_grad() batchLabel = batch[:,0] batchData = batch[:,1:].reshape(250,1,28,28).float() y_pred = model.forward(batchData) loss = loss_fn(y_pred, batchLabel)
# [71, 12], [76, 12], [85, 12], [90, 12], [99, 12], [104, 12] digits = [[8, 12], [12, 12], [21, 12], [26, 12], [35, 12], [40, 12], [44, 12], [49, 12], [71, 12], [76, 12], [85, 12], [90, 12], [99, 12], [104, 12]] # [x_min, y_min, x_max, y_max] digit_areas = [] for d in digits: digit_areas.append([d[0], d[1], d[0] + d_w, d[1] + d_h]) ret, img = cap.read() if ret: cv2.imwrite('images/img.png', img) model = LeNet() model.load_state_dict(torch.load('lenet.pt', map_location='cpu')) model = model.eval() k = 0 while True: ret, img = cap.read() if ret: if k % 30 == 0: # os.system(f'mkdir ./digits2_raw/{k}') for idx, d in enumerate(digit_areas): # img = cv2.rectangle(img, (d[0], d[1]), (d[2], d[3]), (255, 255, 255), 1) tmp = img[d[1]:d[3], d[0]:d[2]] tmp = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)
model = LeNet() xentropy = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=hp.lr, momentum=0.9) # check the latest checkpoint to resume training ckpt_path = latest_ckpt(hp.ckpt) if ckpt_path is None: logging.info("Initializing from scratch") epoch_start = 1 else: # resume training logging.info("Loading the latest checkpoint") ckpt = torch.load(ckpt_path) model.load_state_dict(ckpt['model_state_dict']) epoch_start = ckpt['epoch_start'] model.train() # Load model to device logging.info("# Load model to %s" % (DEVICE)) model = model.to(DEVICE) # training logging.info("# Start training") start_time = time.time() for epoch in range(epoch_start, hp.epochs + 1): num_batch = math.floor(len(train_set) / hp.batch_size) for i, data in enumerate(train_loader, 0): # data comes in the form of [src, target] src, target = data[0].to(DEVICE), data[1].to(DEVICE)