def Densenet169(num_classes, test=False):
model = densenet169()
if not test:
if LOCAL_PRETRAINED['densenet169'] == None:
state_dict = load_state_dict_from_url(model_urls['densenet169'],
progress=True)
else:
state_dict = state_dict = torch.load(
LOCAL_PRETRAINED['densenet169'])
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
# print(k) #打印预训练模型的键，发现与网络定义的键有一定的差别，因而需要将键值进行对应的更改，将键值分别对应打印出来就可以看出不同，根据不同进行修改
# torchvision中的网络定义，采用了正则表达式，来更改键值，因为这里简单，没有再去构建正则表达式
# 直接利用if语句筛选不一致的键
### 修正键值的不对应
if k.split('.')[0] == 'features' and (len(k.split('.'))) > 4:
k = k.split('.')[0] + '.' + k.split('.')[1] + '.' + k.split(
'.')[2] + '.' + k.split('.')[-3] + k.split(
'.')[-2] + '.' + k.split('.')[-1]
# print(k)
else:
pass
new_state_dict[k] = v
model.load_state_dict(new_state_dict)
fc_features = model.classifier.in_features
model.classifier = nn.Linear(fc_features, num_classes)
return model
test = models.resnet50(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.resnet101(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.resnet152(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.alexnet(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet121(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet169(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet201(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.densenet201(num_classes=num_classes, pretrained='imagenet')
assert test(inputs).size()[1] == num_classes
print('ok')
test = models.inceptionv3(num_classes=num_classes, pretrained='imagenet')
assert test(torch.rand([2, 3, 299, 299]))[0].size()[1] == num_classes
print('ok')
assert test(torch.rand([2, 3, 299, 299]))[1].size()[1] == num_classes
print('ok')
def train(working_dir, grid_size, learning_rate, batch_size, num_walks,
model_type, fn):
train_props, val_props, test_props = get_props(working_dir,
dtype=np.float32)
means_stds = np.loadtxt(working_dir + "/means_stds.csv",
dtype=np.float32,
delimiter=',')
# filter out redundant qm8 properties
if train_props.shape[1] == 16:
filtered_labels = list(range(0, 8)) + list(range(12, 16))
train_props = train_props[:, filtered_labels]
val_props = val_props[:, filtered_labels]
test_props = test_props[:, filtered_labels]
means_stds = means_stds[:, filtered_labels]
if model_type == "resnet18":
model = ResNet(BasicBlock, [2, 2, 2, 2],
grid_size,
"regression",
feat_nums,
e_sizes,
num_classes=train_props.shape[1])
elif model_type == "resnet34":
model = ResNet(BasicBlock, [3, 4, 6, 3],
grid_size,
"regression",
feat_nums,
e_sizes,
num_classes=train_props.shape[1])
elif model_type == "resnet50":
model = ResNet(Bottleneck, [3, 4, 6, 3],
grid_size,
"regression",
feat_nums,
e_sizes,
num_classes=train_props.shape[1])
elif model_type == "densenet121":
model = densenet121(grid_size,
"regression",
feat_nums,
e_sizes,
num_classes=train_props.shape[1])
elif model_type == "densenet161":
model = densenet161(grid_size,
"regression",
feat_nums,
e_sizes,
num_classes=train_props.shape[1])
elif model_type == "densenet169":
model = densenet169(grid_size,
"regression",
feat_nums,
e_sizes,
num_classes=train_props.shape[1])
elif model_type == "densenet201":
model = densenet201(grid_size,
"regression",
feat_nums,
e_sizes,
num_classes=train_props.shape[1])
else:
print("specify a valid model")
return
model.float()
model.cuda()
loss_function_train = nn.MSELoss(reduction='none')
loss_function_val = nn.L1Loss(reduction='none')
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# if model_type[0] == "r":
# batch_size = 128
# optimizer = torch.optim.SGD(model.parameters(), lr=0.1,
# momentum=0.9, weight_decay=5e-4, nesterov=True)
# elif model_type[0] == "d":
# batch_size = 512
# optimizer = torch.optim.SGD(model.parameters(), lr=0.1,
# momentum=0.9, weight_decay=1e-4, nesterov=True)
# else:
# print("specify a vlid model")
# return
stds = means_stds[1, :]
tl_list = []
vl_list = []
log_file = open(fn + "txt", "w")
log_file.write("start")
log_file.flush()
for file_num in range(num_loads):
if file_num % 20 == 0:
model_file = open("../../scratch/" + fn + ".pkl", "wb")
pickle.dump(model, model_file)
model_file.close()
log_file.write("load: " + str(file_num))
print("load: " + str(file_num))
# Get new random walks
if file_num == 0:
t = time.time()
train_loader, val_loader, test_loader = get_loaders(working_dir, \
file_num, \
grid_size, \
batch_size, \
train_props, \
val_props=val_props, \
test_props=test_props)
print("load time")
print(time.time() - t)
else:
file_num = random.randint(0, num_walks - 1)
t = time.time()
train_loader, _, _ = get_loaders(working_dir, \
file_num, \
grid_size, \
batch_size, \
train_props)
print("load time")
print(time.time() - t)
# Train on set of random walks, can do multiple epochs if desired
for epoch in range(epochs_per_load):
model.train()
t = time.time()
train_loss_list = []
train_mae_loss_list = []
for i, (walks_int, walks_float, props) in enumerate(train_loader):
walks_int = walks_int.cuda()
walks_int = walks_int.long()
walks_float = walks_float.cuda()
walks_float = walks_float.float()
props = props.cuda()
outputs = model(walks_int, walks_float)
# Individual losses for each item
loss_mae = torch.mean(loss_function_val(props, outputs), 0)
train_mae_loss_list.append(loss_mae.cpu().detach().numpy())
loss = torch.mean(loss_function_train(props, outputs), 0)
train_loss_list.append(loss.cpu().detach().numpy())
# Loss converted to single value for backpropagation
loss = torch.sum(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
model.eval()
val_loss_list = []
with torch.no_grad():
for i, (walks_int, walks_float,
props) in enumerate(val_loader):
walks_int = walks_int.cuda()
walks_int = walks_int.long()
walks_float = walks_float.cuda()
walks_float = walks_float.float()
props = props.cuda()
outputs = model(walks_int, walks_float)
# Individual losses for each item
loss = loss_function_val(props, outputs)
val_loss_list.append(loss.cpu().detach().numpy())
# ith row of this array is the losses for each label in batch i
train_loss_arr = np.array(train_loss_list)
train_mae_arr = np.array(train_mae_loss_list)
log_file.write("training mse loss\n")
log_file.write(str(np.mean(train_loss_arr)) + "\n")
log_file.write("training mae loss\n")
log_file.write(str(np.mean(train_mae_arr)) + "\n")
print("training mse loss")
print(str(np.mean(train_loss_arr)))
print("training mae loss")
print(str(np.mean(train_mae_arr)))
val_loss_arr = np.concatenate(val_loss_list, 0)
val_loss = np.mean(val_loss_arr, 0)
log_file.write("val loss\n")
log_file.write(str(np.mean(val_loss_arr)) + "\n")
print("val loss")
print(str(np.mean(val_loss_arr)))
# Unnormalized loss is for comparison to papers
tnl = np.mean(train_mae_arr, 0)
log_file.write("train normalized losses\n")
log_file.write(" ".join(list(map(str, tnl))) + "\n")
print("train normalized losses")
print(" ".join(list(map(str, tnl))))
log_file.write("val normalized losses\n")
log_file.write(" ".join(list(map(str, val_loss))) + "\n")
print("val normalized losses")
print(" ".join(list(map(str, val_loss))))
tunl = stds * tnl
log_file.write("train unnormalized losses\n")
log_file.write(" ".join(list(map(str, tunl))) + "\n")
print("train unnormalized losses")
print(" ".join(list(map(str, tunl))))
vunl = stds * val_loss
log_file.write("val unnormalized losses\n")
log_file.write(" ".join(list(map(str, vunl))) + "\n")
log_file.write("\n")
print("val unnormalized losses")
print(" ".join(list(map(str, vunl))))
print("\n")
print("time")
print(time.time() - t)
file_num += 1
log_file.flush()
log_file.close()
return model