def all_nets(snapshot_dir, deployfile):
for fname in sorted(os.listdir(snapshot_dir),
key=lambda x: int(x.rsplit(".", 1)[0].rsplit("_", 1)[1])):
if fname.endswith(".caffemodel"):
name, ext = fname.rsplit(".", 1)
prefix, niters = name.rsplit("_", 1)
niters = int(niters)
yield niters, get_net(os.path.join(snapshot_dir, fname),
deployfile)
def get_deepTrunk_net(args, device, lossFn, evalFn, input_size, input_channel, n_class, trunk_net=None):
if trunk_net is None:
if args.net != "None":
trunk_net = get_net(device, args.dataset, args.net, input_size, input_channel, n_class,
load_model=args.load_trunk_model)
specNet = MyDeepTrunkNet(device, args, args.dataset, trunk_net, input_size, input_channel, n_class,
args.n_branches, args.gate_type, args.branch_nets, args.gate_nets, evalFn, lossFn)
specNet.add_cnets(device, lossFn, evalFn, args.n_rand_proj)
return specNet
def build_model(self):
self.net, self.dual_net = get_net(bn_type="dual_bn")
self.model = self.net(self.input_size, self.hidden_size,
self.num_classes).to(self.device)
self.dual_model = self.dual_net(self.hidden_size).to(self.device)
self.criterion = nn.CrossEntropyLoss()
self.optimizer_nn = torch.optim.Adam(self.model.parameters(),
lr=self.learning_rate)
self.optimizer_dual = torch.optim.Adam(self.dual_model.parameters(),
lr=self.learning_rate * 10)
def get_net_by_bn(self):
net = get_net(bn_type="torch_bn") #net_class
return net
X = T.tensor4() Z = T.tensor4() ny = 10 discrim_opt = OrderedDict() discrim_opt['input'] = (3, 32, 32) discrim_opt['conv_relu_1'] = (128, 5, 5) discrim_opt['pool_1'] = 2 discrim_opt['conv_relu_2'] = (128, 5, 5) discrim_opt['pool_2'] = 2 discrim_opt['dense_relu'] = (1024,) discrim_opt['dense_sigmoid'] = (128,) print 'disciminator configuration' print discrim_opt.keys() discrim_net, discrim_NET = get_net(X, discrim_opt) cond_opt = OrderedDict() cond_opt['input'] = (3, 32, 32) cond_opt['noise'] = 0.1 cond_opt['conv_batchnorm_relu_1_1'] = (96, 3, 3) cond_opt['conv_batchnorm_relu_1_2'] = (96, 3, 3) cond_opt['conv_batchnorm_relu_1_3'] = (96, 3, 3) cond_opt['pool_1'] = 2 cond_opt['dropout_1'] = 0.5 cond_opt['conv_batchnorm_relu_2_1'] = (192, 3, 3) cond_opt['conv_batchnorm_relu_2_2'] = (192, 3, 3) cond_opt['conv_batchnorm_relu_2_3'] = (192, 3, 3) cond_opt['pool_2'] = 2 cond_opt['dropout_2'] = 0.5 cond_opt['conv_batchnorm_relu_3_1'] = (192, 3, 3)
def __init__(self, cmd, modelfile, deployfile, *args, **kwargs):
super(NetVisualizer, self).__init__(cmd, *args, **kwargs)
self.net = get_net(modelfile, deployfile)
help="query strategy")
args = parser.parse_args()
pprint(vars(args))
print()
# fix random seed
np.random.seed(args.seed)
torch.manual_seed(args.seed)
torch.backends.cudnn.enabled = False
# device
use_cuda = torch.cuda.is_available()
device = torch.device("cuda" if use_cuda else "cpu")
dataset = get_dataset(args.dataset_name) # load dataset
net = get_net(args.dataset_name, device) # load network
strategy = get_strategy(args.strategy_name)(dataset, net) # load strategy
# start experiment
dataset.initialize_labels(args.n_init_labeled)
print(f"number of labeled pool: {args.n_init_labeled}")
print(f"number of unlabeled pool: {dataset.n_pool-args.n_init_labeled}")
print(f"number of testing pool: {dataset.n_test}")
print()
# round 0 accuracy
print("Round 0")
strategy.train()
preds = strategy.predict(dataset.get_test_data())
print(f"Round 0 testing accuracy: {dataset.cal_test_acc(preds)}")
self.poly.xy = xy
progress = self.valfmt % (int(discrete_val), int(max_val))
self.valtext.set_text(progress)
if self.drawon:
self.ax.figure.canvas.draw()
self.val = val
if not self.eventson:
return
for cid, func in self.observers.items():
func(discrete_val)
def update_val_external(self, val, max_val):
self.set_val(val, max_val)
net = get_net()
net.eval()
data_set = get_test_set()
tsDataloader = DataLoader(data_set,
batch_size=len(data_set),
shuffle=True,
num_workers=8,
collate_fn=data_set.collate_fn)
len_pred = int(args.time_pred / args.dt)
lossVals = torch.zeros(len_pred).to(args.device)
counts = torch.zeros(len_pred).to(args.device)
delta = 0.3
def copy(self):
w = self.get_net_w()
net = get_net()
net.load_state_dict(w)
return DataProvider(net, self.dataloader)
import os
import cv2
from config import CHECKPOINT_PATH
from config import CLASSES
from utils import get_device
from utils import get_net
from utils import get_result
if __name__ == '__main__':
device = get_device()
num_classes = len(CLASSES)
net = get_net('mobilenet_v2', 'val', device, num_classes=num_classes,
checkpoint_path=CHECKPOINT_PATH)
# cap = cv2.VideoCapture(0)
cap = cv2.VideoCapture(os.path.join('videos', 'video_01.mp4'))
while True:
_, frame = cap.read()
result = get_result(frame, CLASSES, net, device)
print(f'Result: {result}')
# Display the resulting frame
cv2.imshow('frame', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
def __init__(self, device, args, dataset, trunk_net, input_size, input_channel, n_class, n_branches, gate_type,
branch_net_names, gate_net_names, evalFn, lossFn):
super(MyDeepTrunkNet, self).__init__()
self.dataset = dataset
self.input_size = input_size
self.input_channel = input_channel
self.n_class = n_class
self.gate_type = gate_type
self.n_branches = n_branches
self.trunk_net = trunk_net
self.evalFn = evalFn
self.lossFn = lossFn
assert gate_type in ["entropy", "net"], f"Unknown gate mode: {gate_type:s}"
self.exit_ids = [-1] + list(range(n_branches))
self.threshold = {exit_idx: args.gate_threshold for exit_idx in self.exit_ids[1:]}
self.gate_nets = {}
self.branch_nets = {}
if len(branch_net_names) != n_branches:
print("Number of branches does not match branch net names")
branch_net_names = n_branches * branch_net_names[0:1]
if gate_net_names is None:
gate_net_names = branch_net_names
elif len(gate_net_names) != n_branches:
print("Number of branches does not match gate net names")
gate_net_names = n_branches * gate_net_names[0:1]
if args.load_branch_model is not None and len(args.load_branch_model) != n_branches:
args.load_branch_model = n_branches * args.load_branch_model[0:1]
if args.load_gate_model is not None and len(args.load_gate_model) != n_branches:
args.load_gate_model = n_branches * args.load_gate_model[0:1]
for i, branch_net_name in zip(range(n_branches), branch_net_names):
exit_idx = self.exit_ids[i+1]
self.branch_nets[exit_idx] = get_net(device, dataset, branch_net_name, input_size, input_channel, n_class,
load_model=None if args.load_branch_model is None else args.load_branch_model[i],
net_dim=args.cert_net_dim)
if gate_type == "net":
self.gate_nets[exit_idx] = get_net(device, dataset, gate_net_names[i], input_size, input_channel, 1,
load_model=None if args.load_gate_model is None else args.load_gate_model[i],
net_dim=args.cert_net_dim)
else:
self.gate_nets[exit_idx] = SeqNet(Sequential(*[*self.branch_nets[exit_idx].blocks, Entropy(n_class, low_mem=True, neg=True)]))
self.gate_nets[exit_idx].determine_dims(torch.randn((2, input_channel, input_size, input_size), dtype=torch.float).to(device))
init_slopes(self.gate_nets[exit_idx], device, trainable=False)
self.add_module("gateNet_{}".format(exit_idx), self.gate_nets[exit_idx])
self.add_module("branchNet_{}".format(exit_idx), self.branch_nets[exit_idx])
if args.load_model is not None:
old_state = self.state_dict()
load_state = torch.load(args.load_model)
if args.cert_net_dim is not None and not ("gateNet_0.blocks.layers.1.mean" in load_state.keys()): # Only change keys if loading from a non mixed resolution to mixed resolution
new_dict = {}
for k in load_state.keys():
if k.startswith("trunk"):
new_k = k
else:
k_match = re.match("(^.*\.layers\.)([0-9]+)(\..*$)", k)
new_k = "%s%d%s" % (k_match.group(1), int(k_match.group(2)) + 1, k_match.group(3))
new_dict[new_k] = load_state[k]
load_state.update(new_dict)
# LiRPA requires parameters to have zero batch dimension. This makes old models compatible
for k, v in load_state.items():
if k.endswith("mean") or k.endswith("sigma"):
if k in old_state:
load_state.update({k: v.reshape(old_state[k].shape)})
old_state.update({k:v.view(old_state[k].shape) for k,v in load_state.items() if
k in old_state and (
(k.startswith("trunk") and args.load_trunk_model is None)
or (k.startswith("gate") and args.load_gate_model is None)
or (k.startswith("branch") and args.load_branch_model is None))})
missing_keys, extra_keys = self.load_state_dict(old_state, strict=False)
assert len([x for x in missing_keys if "gateNet" in x or "branchNet" in x]) == 0
print("Whole model loaded from %s" % args.load_model)
## Trunk and branch nets have to be loaded after the whole model
if args.load_trunk_model is not None:
load_net_state(self.trunk_net, args.load_trunk_model)
if (args.load_model is not None or args.load_gate_model is not None) and args.gate_feature_extraction is not None:
for i, net in enumerate(self.gate_nets.values()):
extraction_layer = [ii for ii in range(len(net.blocks)) if isinstance(net.blocks[ii],Linear)]
extraction_layer = extraction_layer[-min(len(extraction_layer),args.gate_feature_extraction)]
net.freeze(extraction_layer-1)
self.trunk_cnet = None
self.gate_cnets = {k: None for k in self.gate_nets.keys()}
self.branch_cnets = {k: None for k in self.branch_nets.keys()}
def ScoreAverage(dps):
"""非树状聚合方式（即一起聚合） 计算SV方式：平均outputs在测试集上精度"""
shapleyValue = ShapleyValue()
tp = ThirdParty()
db = DataBuyer(get_net())
'''dps = []
for i in range(params.provider_num):
net = get_net()
dataloader = get_data_loader(i)
dps.append(DataProvider(net, dataloader))
print('读取模型完成')'''
# 随机聚合顺序
'''order_rand = random_order(params.provider_num)
print('聚合顺序', order_rand)
'''
# 构成树节点 放入tree_list
tree_list = []
for i in range(params.provider_num):
tree_list.append(Tree(i, dps[i]))
# 先在本地数据集上训练至收敛----------------
# '''
for i in range(params.provider_num):
print("客户端", i, "预训练")
for j in range(params.local_time):
tree_list[i].provider.train()
# '''
# 计算SV-------------------
print('开始计算SV')
shapleyValue.v_way = 'score_avg' # 计算v的方式fedavg和score_avg
SVs = shapleyValue.cal_SV_all(tree_list)
print("算得各个SV值：")
for i in range(params.provider_num):
tree_list[i].sv = SVs[i]
print(SVs[i])
# 找出SV>0的聚合-----------------
positive_list = []
for i in range(params.provider_num):
if SVs[i] > 0:
print(i, "SV>0并加入")
positive_list.append(tree_list[i])
net, acc = fedavg(positive_list, 100)
print("聚合后精度", acc)
# 写入txt
txt_dir = params.dataset_division_testno + '/22.txt'
write_txt(tree_list, 0, acc, txt_dir)
# 把v_all写入txt
v_all = shapleyValue.v_all
print(v_all)
npy_dir = params.dataset_division_testno + '/ScoreAverage_v_all_2.npy'
write_npy_v_all(v_all, npy_dir)
def Original(dps):
"""原本聚合方式：FedAvg +计算SV"""
shapleyValue = ShapleyValue()
db = DataBuyer(get_net())
'''dps = []
for i in range(params.provider_num):
net = get_net()
dataloader = get_data_loader(i)
dps.append(DataProvider(net, dataloader))'''
# 构成树节点 放入tree_list
tree_list = []
for i in range(params.provider_num):
tree_list.append(Tree(i, dps[i]))
# 预训练
# _, p_fed = fedavg(tree_list)
num_node = len(tree_list)
# 先在本地数据集上训练至收敛----------------
# '''
for i in range(params.provider_num):
print("客户端", i, "预训练")
for j in range(params.local_time):
tree_list[i].provider.train()
# '''
#
print('开始计算SV')
shapleyValue.v_way = 'fedavg' # 计算v的方式fedavg和score_avg
SVs = shapleyValue.cal_SV_all(tree_list)
# 所有聚合后pab
v_all = shapleyValue.v_all
for i in range(num_node):
tree_list[i].sv = SVs[i]
print(SVs[i])
# 最后剩一个节点为根
root = tree_list[0]
root.B = db.B
# 根据树分配B
all_B(root)
# 根节点精确度
p_root = shapleyValue.root_p
# SV写入txt
txt_dir = params.dataset_division_testno + '/21.txt'
write_txt(tree_list, 0, p_root, txt_dir)
# 把v_all写入txt
v_all = shapleyValue.v_all
print(v_all)
npy_dir = params.dataset_division_testno + '/Original_v_all_2.npy'
write_npy_v_all(v_all, npy_dir)
# 第三方解密，发送结果给DP、DB
return tree_list
def CollaborativeModelling(_tree_list=None):
"""树状聚合方式 +计算SV"""
shapleyValue = ShapleyValue()
tp = ThirdParty()
db = DataBuyer(get_net())
dps = []
for i in range(params.provider_num):
net = get_net()
dataloader = get_data_loader(i)
dps.append(DataProvider(net, dataloader))
print('读取模型完成')
# 随机聚合顺序
'''order_rand = random_order(params.provider_num)
print('聚合顺序', order_rand)
'''
# 构成树节点 放入tree_list
tree_list = []
if _tree_list is not None:
for i in range(params.provider_num):
tree_list.append(_tree_list[i])
else:
for i in range(params.provider_num):
tree_list.append(Tree(i, dps[i]))
"""# 第三方生成密匙，传给DP、DB
public_key, private_key = tp.generate_key()
# DP加密model，发给DB
for i in range(params.provider_num):
dps[i].enctypt()
# 聚合前先FedAvg p_fed为fedavg的精度
_, p_fed = fedavg(tree_list)
"""
# 开始多次FedAvg、聚合
last_node = tree_list[0] # 上一次最优节点
next_node_no = 1 # 接下来要聚合的开始节点编号
node_K_list = [last_node]
while next_node_no < params.provider_num:
# print('len(node_K_list[0].children)', len(node_K_list[0].children))
# 要聚合的K个节点
num = 0
while num < params.K - 1 and next_node_no < params.provider_num:
node_K_list.append(tree_list[next_node_no])
next_node_no += 1
num += 1
# K个provider聚合 可能不足K个
num_node = len(node_K_list)
# DB计算特征函数v，发送给第三方
print('开始计算SV')
SVs = shapleyValue.cal_SV_all(node_K_list)
for i in range(num_node):
node_K_list[i].sv = SVs[i]
print(SVs[i])
# 判断是否聚合
num_aggregation = 0
for i in range(num_node):
if node_K_list[i].if_aggregation():
num_aggregation += 1
if num_aggregation == num_node: # 全部同意聚合
# 用聚合的模型建树
net = shapleyValue.root_net
# 暂时用第一个孩子的dataloader做聚合节点的dataloader
p = DataProvider(net,
dataloader=get_data_loader(node_K_list[0].p_no))
node = Tree(node_K_list[0].p_no, p)
for i in range(num_node):
node.children.append(node_K_list[i])
# 记录上一次聚合的节点
node_K_list = [node]
else:
# 选出SV最大的节点做根
max_node = node_K_list[0]
max_sv = node_K_list[0].sv
for i in range(1, num_node):
if node_K_list[i].sv > max_sv:
max_node = node_K_list[i]
max_sv = node_K_list[i].sv
# 记录上一次最优的节点
node_K_list = [max_node]
# 最后剩一个节点为根
root = node_K_list[0]
root.B = db.B
# 根据树分配B
all_B(root)
# 根节点精确度
p_root = shapleyValue.root_p
# 写入txt
txt_dir = params.dataset_division_testno + '/10.txt'
write_txt(tree_list, 0, p_root, txt_dir)
def run(args=None):
device = 'cuda' if torch.cuda.is_available() and (
not args.no_cuda) else 'cpu'
num_train, train_loader, test_loader, input_size, input_channel, n_class = get_loaders(
args)
lossFn = nn.CrossEntropyLoss(reduction='none')
evalFn = lambda x: torch.max(x, dim=1)[1]
net = get_net(device,
args.dataset,
args.net,
input_size,
input_channel,
n_class,
load_model=args.load_model,
net_dim=args.cert_net_dim
) #, feature_extract=args.core_feature_extract)
timestamp = int(time.time())
model_signature = '%s/%s/%d/%s_%.5f/%d' % (args.dataset, args.exp_name,
args.exp_id, args.net,
args.train_eps, timestamp)
model_dir = args.root_dir + 'models_new/%s' % (model_signature)
args.model_dir = model_dir
count_vars(args, net)
if not os.path.exists(model_dir):
os.makedirs(model_dir)
if isinstance(net, UpscaleNet):
relaxed_net = None
relu_ids = None
else:
relaxed_net = RelaxedNetwork(net.blocks, args.n_rand_proj).to(device)
relu_ids = relaxed_net.get_relu_ids()
if "nat" in args.train_mode:
cnet = CombinedNetwork(net,
relaxed_net,
lossFn=lossFn,
evalFn=evalFn,
device=device,
no_r_net=True).to(device)
else:
dummy_input = torch.rand((1, ) + net.dims[0],
device=device,
dtype=torch.float32)
cnet = CombinedNetwork(net,
relaxed_net,
lossFn=lossFn,
evalFn=evalFn,
device=device,
dummy_input=dummy_input).to(device)
n_epochs, test_nat_loss, test_nat_acc, test_adv_loss, test_adv_acc = args.n_epochs, None, None, None, None
if 'train' in args.train_mode:
tb_writer = SummaryWriter(model_dir)
stats = Statistics(len(train_loader), tb_writer, model_dir)
args_file = os.path.join(model_dir, 'args.json')
with open(args_file, 'w') as fou:
json.dump(vars(args), fou, indent=4)
write_config(args, os.path.join(model_dir, 'run_config.txt'))
eps = 0
epoch = 0
lr = args.lr
n_epochs = args.n_epochs
if "COLT" in args.train_mode:
relu_stable = args.relu_stable
# if args.layers is None:
# args.layers = [-2, -1] + relu_ids
layers = get_layers(args.train_mode,
cnet,
n_attack_layers=args.n_attack_layers,
protected_layers=args.protected_layers)
elif "adv" in args.train_mode:
relu_stable = None
layers = [-1, -1]
args.mix = False
elif "natural" in args.train_mode:
relu_stable = None
layers = [-2, -2]
args.nat_factor = 1
args.mix = False
elif "diffAI" in args.train_mode:
relu_stable = None
layers = [-2, -2]
else:
assert False, "Unknown train mode %s" % args.train_mode
print('Saving model to:', model_dir)
print('Training layers: ', layers)
for j in range(len(layers) - 1):
opt, lr_scheduler = get_opt(cnet.net,
args.opt,
lr,
args.lr_step,
args.lr_factor,
args.n_epochs,
train_loader,
args.lr_sched,
fixup="fixup" in args.net)
curr_layer_idx = layers[j + 1]
eps_old = eps
eps = get_scaled_eps(args, layers, relu_ids, curr_layer_idx, j)
kappa_sched = Scheduler(0.0 if args.mix else 1.0, 1.0,
num_train * args.mix_epochs, 0)
beta_sched = Scheduler(
args.beta_start if args.mix else args.beta_end, args.beta_end,
args.train_batch * len(train_loader) * args.mix_epochs, 0)
eps_sched = Scheduler(eps_old if args.anneal else eps, eps,
num_train * args.anneal_epochs, 0)
layer_dir = '{}/{}'.format(model_dir, curr_layer_idx)
if not os.path.exists(layer_dir):
os.makedirs(layer_dir)
print('\nnew train phase: eps={:.5f}, lr={:.2e}, curr_layer={}\n'.
format(eps, lr, curr_layer_idx))
for curr_epoch in range(n_epochs):
train(device,
epoch,
args,
j + 1,
layers,
cnet,
eps_sched,
kappa_sched,
opt,
train_loader,
lr_scheduler,
relu_ids,
stats,
relu_stable,
relu_stable_protected=args.relu_stable_protected,
beta_sched=beta_sched)
if isinstance(lr_scheduler, optim.lr_scheduler.StepLR
) and curr_epoch >= args.mix_epochs:
lr_scheduler.step()
if (epoch + 1) % args.test_freq == 0:
with torch.no_grad():
test_nat_loss, test_nat_acc, test_adv_loss, test_adv_acc = test(
device,
args,
cnet,
test_loader if args.test_set == "test" else
train_loader, [curr_layer_idx],
stats=stats,
log_ind=(epoch + 1) % n_epochs == 0)
if (epoch + 1) % args.test_freq == 0 or (epoch +
1) % n_epochs == 0:
torch.save(
net.state_dict(),
os.path.join(layer_dir, 'net_%d.pt' % (epoch + 1)))
torch.save(
opt.state_dict(),
os.path.join(layer_dir, 'opt_%d.pt' % (epoch + 1)))
stats.update_tb(epoch)
epoch += 1
relu_stable = None if relu_stable is None else relu_stable * args.relu_stable_layer_dec
lr = lr * args.lr_layer_dec
if args.cert:
with torch.no_grad():
diffAI_cert(
device,
args,
cnet,
test_loader if args.test_set == "test" else train_loader,
stats=stats,
log_ind=True,
epoch=epoch,
domains=args.cert_domain)
elif args.train_mode == 'print':
print('printing network to:', args.out_net_file)
dummy_input = torch.randn(1,
input_channel,
input_size,
input_size,
device='cuda')
net.skip_norm = True
torch.onnx.export(net, dummy_input, args.out_net_file, verbose=True)
elif args.train_mode == 'test':
with torch.no_grad():
test(device,
args,
cnet,
test_loader if args.test_set == "test" else train_loader,
[-1],
log_ind=True)
elif args.train_mode == "cert":
tb_writer = SummaryWriter(model_dir)
stats = Statistics(len(train_loader), tb_writer, model_dir)
args_file = os.path.join(model_dir, 'args.json')
with open(args_file, 'w') as fou:
json.dump(vars(args), fou, indent=4)
write_config(args, os.path.join(model_dir, 'run_config.txt'))
print('Saving results to:', model_dir)
with torch.no_grad():
diffAI_cert(
device,
args,
cnet,
test_loader if args.test_set == "test" else train_loader,
stats=stats,
log_ind=True,
domains=args.cert_domain)
exit(0)
else:
assert False, 'Unknown mode: {}!'.format(args.train_mode)
return test_nat_loss, test_nat_acc, test_adv_loss, test_adv_acc
checkpoint_path = os.path.join('checkpoint', 'checkpoint.pth')
checkpoint_dir = os.path.dirname(checkpoint_path)
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
# torch.multiprocessing.freeze_support()
dataset_path = os.path.join('data', 'cat_vs_dog', 'train')
dataset_size, class_names, class_to_idx = get_metadata(dataset_path)
# TensorBoard setup
log_path = os.path.join('runs', 'experiment_1')
if os.path.exists(log_path):
shutil.rmtree(log_path)
writer = SummaryWriter(log_path)
train_loader = get_data_loader(dataset_path,
batch_size=HyperParams['batch_size'])
# eval_loader = get_data_loader(dataset_path, batch_size=dataset_size)
eval_loader = None
num_classes = len(class_names)
model = get_net(classes=num_classes)
model = main(model,
checkpoint_path,
HyperParams['input_size'],
train_loader,
eval_loader,
writer=writer,
epochs=HyperParams['epochs'])
writer.close()
def get_net_by_bn(self):
net = get_net(bn_type="no") #net_class
return net
def __init__(self):
self.net = get_net()
# self.lr = params.learning_rate # 学习率
self.w = {} # 累计网络权重
self.client_num = 0 # 累计网络权重时，客户端的数据量累计
def creat_model():
for i in range(params.provider_num):
save_provider_model(i, get_net())
from utils import get_metadata
from utils import get_net
from utils import get_prediction_class
from utils import preprocess_image
if __name__ == '__main__':
device = get_device()
# Training dataset metadata
_, class_names, class_to_idx = get_metadata(sys.argv[1])
num_classes = len(class_names)
idx_to_class = {value: key for key, value in class_to_idx.items()}
# Data preparation
image = Image.open(sys.argv[2])
# Net initialization
net = get_net(classes=num_classes)
checkpoint_dict = torch.load(os.path.join('checkpoint', 'checkpoint.pth'),
map_location=device)
net.load_state_dict(checkpoint_dict['model_state_dict'])
net.eval()
net.to(device)
# Prediction
image_tensor = preprocess_image(image, mode='val')
image_tensor = image_tensor.to(device)
prediction = net(image_tensor)
result = get_prediction_class(prediction, idx_to_class)
print(f'Result: {result}')
X = T.tensor4() Z = T.tensor4() ny = 10 discrim_opt = OrderedDict() discrim_opt['input'] = (1, 28, 28) discrim_opt['conv_relu_1'] = (64, 5, 5) discrim_opt['pool_1'] = 2 discrim_opt['conv_relu_2'] = (64, 5, 5) discrim_opt['pool_2'] = 2 discrim_opt['dense_relu'] = (1024, ) discrim_opt['dense_sigmoid'] = (128, ) print 'disciminator configuration' print discrim_opt.keys() discrim_net, discrim_NET = get_net(X, discrim_opt) cond_opt = OrderedDict() cond_opt['input'] = (1, 28, 28) cond_opt['noise'] = 0.1 cond_opt['conv_batchnorm_relu_1'] = (64, 3, 3) cond_opt['conv_batchnorm_relu_2'] = (64, 3, 3) cond_opt['pool_1'] = 2 cond_opt['dropout_1'] = 0.5 cond_opt['conv_batchnorm_relu_3'] = (64, 3, 3) cond_opt['conv_batchnorm_relu_4'] = (64, 3, 3) cond_opt['pool_2'] = 2 cond_opt['dropout_2'] = 0.5 cond_opt['conv_batchnorm_relu_5'] = (64, 3, 3) cond_opt['conv_batchnorm_relu_6'] = (64, 3, 3) cond_opt['pool_3'] = -1
print(f'Training complete in {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s')
print(f'Best val Acc: {best_acc:4f}')
# load best net weights
net.load_state_dict(best_net_wts)
return net
if __name__ == '__main__':
checkpoint_path = os.path.join('checkpoint', 'checkpoint.pth')
checkpoint_dir = os.path.dirname(checkpoint_path)
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
# TensorBoard setup
log_path = os.path.join('runs', 'experiment_1')
if os.path.exists(log_path):
shutil.rmtree(log_path)
writer = SummaryWriter(log_path)
data_loaders = {x: get_data_loader(os.path.join(DATASET_PATH, x), batch_size=BATCH_SIZE, mode=x)
for x in ['train', 'val']}
device = get_device()
num_classes = len(CLASSES)
model = get_net(model_name='mobilenet_v2', mode='train', device=device,
pretrained=True, num_classes=num_classes)
model = main(model, device, checkpoint_path, data_loaders, writer=writer, epochs=EPOCHS)
writer.close()
