def __init__(self,
state_size,
action_size,
hidden_layer=256,
hidden_layer1=256,
w_init=3e-3):
super(Critic, self).__init__()
self.cnn = nn.Sequential(
nn.Conv2d(9, 32, 4, stride=2,
padding=1), # batch_size * 32 * 46 * 46
nn.ReLU(True),
nn.Conv2d(32, 64, 4, stride=2, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(True),
nn.Conv2d(64, 128, 4, stride=2, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(True),
nn.Conv2d(128, 256, 4, stride=2, padding=1),
nn.ReLU(True),
Flatten())
self.linear = nn.Linear(256 * 3 * 3 + action_size, hidden_layer)
self.linear1 = nn.Linear(hidden_layer, hidden_layer1)
self.linear2 = nn.Linear(hidden_layer1, action_size)
self.linear2.weight.data.uniform_(-w_init, w_init)
self.linear2.bias.data.uniform_(-w_init, w_init)
def main():
# model = ResNet18(5).to(device)
# trained_model = resnest50(pretrained=True)
# trained_model =resnet101(pretrained=True)
# print('children', *list(trained_model.children())[:-1])
trained_model = torch.hub.load('zhanghang1989/ResNeSt',
'resnest269',
pretrained=True)
model = nn.Sequential(
*list(trained_model.children())[:-1], # [b, 512, 1, 1] [32,2048]
# list(trained_model.children())[-2].view(32, 2048,1,1),
# nn.BatchNorm2d(2048),
Flatten(), # [b, 512, 1, 1] => [b, 512]
# torch.nn.Dropout(0.3),
# nn.Linear(2048, 1000),
# nn.Dropout(0.1),
# nn.Linear(1000,500),
# nn.Dropout(0.1),
# nn.Linear(500, 1)
# nn.ReLU(inplace=True),
# torch.nn.Dropout(0.5),
# nn.Linear(1024, 1),
# nn.ReLU(inplace=True)
# nn.ReLU6(inplace=True)
nn.Linear(2048, 1),
# nn.Linear(1000, 2000),
# nn.Linear(2000, 1),
# nn.LeakyReLU(inplace=True),
).to(device)
model.load_state_dict(torch.load('best06301936v0.mdl'))
print('loaded from ckpt!')
names, val_y_true, val_preds = evalute(model, val_loader)
# names=list(names)
# val_y_true=list(val_y_true)
# val_preds=list(val_preds)
from pandas.core.frame import DataFrame
c = {
"names": names,
"val_y_true": val_y_true,
"val_preds": val_preds
} # 将列表a，b转换成字典
data = DataFrame(c) # 将字典转换成为数据框
print(data)
# a.to_excel("val_values07011427.xls")
# data.to_excel("val_values07020812.xls")
# data.to_excel("val_values07020812.xls")
# data.to_excel("val_values07021000.xls") #最好的结果
data.to_excel("val_values07061911.xls")
def main():
trained_model = resnest50(pretrained=True)
# # trained_model = resnet18(pretrained=True)
model = nn.Sequential(
*list(trained_model.children())[:-1], # [b, 512, 1, 1]
Flatten(), # [b, 512, 1, 1] => [b, 512]
# nn.Linear(2048, 512),
# nn.Linear(512, 2),
nn.BatchNorm1d(2048, affine=False),
nn.Dropout(0.29),
nn.Linear(2048, 2),
# nn.BatchNorm1d(2048, affine=False),
# nn.Linear(248, 2),
nn.Softmax(dim=1)).to(device)
# model.load_state_dict(torch.load('Resnest50_0205_1112.mdl')) #Resnest50_0205_1112
model.load_state_dict(torch.load('Resnest50_0308.mdl'))
# print("model",model)
# Inhosp_Nos,EXAM_NOs, y_trues,y_probs,y_preds,confusionmatrix=Test(model,val_loader,0.9)
# Inhosp_Nos,EXAM_NOs, y_trues,y_probs,y_preds,confusionmatrix=Train_Test(model,train_loader,0.9)
Inhosp_Nos, EXAM_NOs, y_trues, y_probs, y_preds, confusionmatrix = Test(
model, test_loader, 0.2)
# train_AUC=confusion_matrixes(model,train_loader)
# print("train_AUC=",train_AUC)
AUC = confusion_matrixes(model, test_loader)
print("train_AUC=", AUC)
from pandas.core.frame import DataFrame
c = {
"Inhosp_Nos": Inhosp_Nos,
"EXAM_NOs": EXAM_NOs,
"y_trues": y_trues,
"y_probs": y_probs,
"y_preds": y_preds
} # 将列表a，b转换成字典
data = DataFrame(c) # 将字典转换成为数据框
# data.to_csv("data_train_0214.csv") 使用
# data.to_csv("data_val_0214.csv") # 使用
data.to_csv("data_test_resnest50_2021_0308.csv") # 使用
print("=========文预测结束==============")
print(data)
def discriminator(opts, output_size):
"""
From https://arxiv.org/abs/1511.06434.pdf
"""
model = nn.Sequential(
nn.Conv2d(1, 32, 4, 2, 1), #1
nn.InstanceNorm2d(32),
nn.LeakyReLU(0.2, True),
nn.Dropout3d(opts.dropout),
nn.Conv2d(32, 32, 4, 2, 1), #2
nn.InstanceNorm2d(32),
nn.LeakyReLU(0.2, True),
nn.Dropout3d(opts.dropout),
nn.Conv2d(32, 64, 4, 2, 1), #3
nn.InstanceNorm2d(64),
nn.LeakyReLU(0.2, True),
nn.Dropout3d(opts.dropout),
nn.Conv2d(64, 64, 4, 2, 1), #4
nn.InstanceNorm2d(64),
nn.LeakyReLU(0.2, True),
nn.Dropout3d(opts.dropout),
nn.Conv2d(64, 128, 4, 2, 1), #5
nn.InstanceNorm2d(128),
nn.LeakyReLU(0.2, True),
nn.Dropout3d(opts.dropout),
nn.Conv2d(128, 128, 5,1, 1),
nn.InstanceNorm2d(128),
nn.LeakyReLU(0.2, True),
nn.Dropout3d(opts.dropout),
Flatten(),
nn.Linear(128 * 29, 32 * 29),
nn.LeakyReLU(0.2, True),
nn.Dropout(opts.dropout),
nn.Linear(32 * 29, 16 * 29),
nn.LeakyReLU(0.2, True),
nn.Dropout(opts.dropout),
nn.Linear(16 * 29, output_size),
)
return model
def main():
trained_model = resnest50(pretrained=True)
# # trained_model = resnet18(pretrained=True)
model = nn.Sequential(
*list(trained_model.children())[:-1], # [b, 512, 1, 1]
Flatten(), # [b, 512, 1, 1] => [b, 512]
# nn.Linear(2048, 512),
# nn.Linear(512, 2),
nn.BatchNorm1d(2048, affine=False),
nn.Dropout(0.29),
nn.Linear(2048, 2),
# nn.BatchNorm1d(2048, affine=False),
# nn.Linear(248, 2),
nn.Softmax(dim=1)).to(device)
# model.load_state_dict(torch.load('Resnest50_0205_1112.mdl')) #Resnest50_0205_1112
model.load_state_dict(torch.load('Resnest50_0308.mdl'))
print("*******************计算验证集的混淆矩阵*****************************")
optimal_threshold, point, Inhosp_Nos_val, EXAM_NOs_val, y_trues_val, y_probs_val, preds_need = Val_optimal_threshold(
model, val_loader)
# val_AUC = confusion_matrixes(model, val_loader)
# print("optimal_threshold=",optimal_threshold)
# print("point=", point)
print("验证集样本预测中....")
c = {
"Inhosp_Nos": Inhosp_Nos_val,
"EXAM_NOs": EXAM_NOs_val,
"y_trues": y_trues_val,
"y_probs": y_probs_val,
"y_preds": preds_need
} # 将列表a，b转换成字典
data = DataFrame(c) # 将字典转换成为数据框
data.to_csv("data_val_resnest50_2021_0309.csv") # 使用
print("=========验证集所有样本预测结束==============")
print("*********样本筛选中******************")
###训练集的样本预测开始
Inhosp_Nos_train, EXAM_NOs_train, y_trues_train, y_probs_train, y_preds_train, confusionmatrix_train = Train_Test(
model, train_loader, optimal_threshold)
train_AUC = Train_confusion_matrixes(model, train_loader)
print("train_AUC=", train_AUC)
c = {
"Inhosp_Nos": Inhosp_Nos_train,
"EXAM_NOs": EXAM_NOs_train,
"y_trues": y_trues_train,
"y_probs": y_probs_train,
"y_preds": y_preds_train
} # 将列表a，b转换成字典
data = DataFrame(c) # 将字典转换成为数据框
# data.to_csv("data_train_0214.csv") 使用
# data.to_csv("data_val_0214.csv") # 使用
data.to_csv("data_train_resnest50_2021_0309.csv") # 使用
print("=========训练集所有样本预测结束==============")
print("*********计算测试集的预测结果******************")
Inhosp_Nos_test, EXAM_NOs_test, y_trues_test, y_probs_test, y_preds_test, confusionmatrix_test = Test(
model, test_loader, optimal_threshold)
test_AUC = confusion_matrixes(model, test_loader)
print("test_AUC=", test_AUC)
c = {
"Inhosp_Nos": Inhosp_Nos_test,
"EXAM_NOs": EXAM_NOs_test,
"y_trues": y_trues_test,
"y_probs": y_probs_test,
"y_preds": y_preds_test
} # 将列表a，b转换成字典
data = DataFrame(c) # 将字典转换成为数据框
data.to_csv("data_test_resnest50_2021_0309.csv") # 使用
print("**********End**********")
def main():
# model = ResNet18(5).to(device)
trained_model = resnest50(pretrained=True)
# trained_model =resnet101(pretrained=True)
# print('children', *list(trained_model.children())[:-1])
model = nn.Sequential(*list(trained_model.children())[:-2], # [b, 512, 1, 1] [32,2048]
# list(trained_model.children())[-2].view(32, 2048,1,1),
nn.BatchNorm2d(2048),
Flatten(), # [b, 512, 1, 1] => [b, 512]
# torch.nn.Dropout(0.5),
nn.Linear(2048 * 49, 1),
# nn.ReLU(inplace=True),
# torch.nn.Dropout(0.5),
# nn.Linear(1024, 1),
nn.ReLU(inplace=True)
).to(device)
model.train()
# optimizer = optim.Adam(model.parameters(), lr=lr)
optimizer = optim.Adam(model.parameters(), lr=lr)
# optimizer=optim.SGD(model.parameters(),lr=lr,momentum=0.99,weight_decay=0.01)
# scheduler=torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
# criteon = nn.CrossEopyLoss()
criteon = torch.nn.MSELoss()
# criteon = nn.L1Loss()
# for t in range(200):
# prediction = model(x)
# loss = loss_func(prediction, y)
# optimizer.zero_grad()
# loss.backward()
# optimizer.step()
# if t%5 == 0:
# plt.cla()
# plt.scatter(x.data.numpy(), y.data.numpy()) # 画散点图
# plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=5) # 画拟合曲线
# plt.text(0.5, 0, 'Loss=%.4f' % loss.data[0], fontdict={'size':20,'color':'red'}) # 显示损失数值
# plt.pause(0.1)
# # 如果在脚本中使用ion()命令开启了交互模式，没有使用ioff()关闭的话，则图像会一闪而过，并不会常留。要想防止这种情况，需要在plt.show()之前加上ioff()命令。
# plt.ioff()
# plt.show()
best_loss, best_epoch = 5, 0
global_step = 0
viz.line([1], [-1], win='loss', opts=dict(title='loss'))
viz.line([10], [-1], win='loss_val', opts=dict(title='loss_val'))
# train_loss1=[]
# val_loss1=[]
for epoch in range(epochs):
for step, (x, y) in enumerate(train_loader):
# print("Enter"+str(epoch)+'time'+str(step))
print("Enter: {} step {}".format(epoch, step))
# x: [b, 3, 224, 224], y: [b]
x, y = x.to(device), y.to(device)
model.train()
logits = model(x)
loss = criteon(logits, y)
# train_loss1.append(loss)
# loss = criteon(logits, y)
# loss=F.smooth_l1_loss(logits, y,size_average=False)
optimizer.zero_grad()
loss.backward()
optimizer.step()
viz.line([loss.item()], [global_step], win='loss', update='append')
global_step += 1
if epoch % 1 == 0:
for x, y in val_loader:
x, y = x.to(device), y.to(device)
with torch.no_grad():
logits_val = model(x)
# print('logits_val',logits_val)
# print("y_true",y)
loss_val = criteon(logits_val, y)
# val_loss1.append(loss_val)
# scheduler.step(loss_val)
# r2=r2_score(logits_val, y)
# mean_absolute_error=mean_absolute_error(logits_val, y)
# mean_squared_error=mean_squared_error(logits_val, y)
# print("r2",r2)
# print("mean_absolute_error",mean_absolute_error)
# print("mean_squared_error",mean_squared_error)
# loss_val = criteon(logits_val, y)
# loss_val =F.smooth_l1_loss(logits_val, y,size_average=False)
if loss_val.item() < best_loss:
best_epoch = epoch
best_loss = loss_val
torch.save(model.state_dict(), 'best.mdl')
viz.line([loss_val.item()], [global_step], win='loss_val', update='append')
print('best loss:', best_loss, 'best epoch:', best_epoch)
model.load_state_dict(torch.load('best.mdl'))
print('loaded from ckpt!')
# train_db = Data('./result1', 224, mode='train')
# val_db = Data('./result1', 224, mode='val')
train_loader1 = DataLoader(train_db, batch_size=140, shuffle=True,
num_workers=0)
val_loader1 = DataLoader(val_db, batch_size=60, num_workers=0)
for x, y in train_loader1:
criteon = torch.nn.MSELoss()
x, y = x.to(device), y.to(device)
print(x.shape)
with torch.no_grad():
logits_train = model(x)
# print('logit_train',logits_train)
logits_train = logits_train.squeeze(1)
logits_train = logits_train.cpu().numpy()
y = y.cpu().numpy()
r2 = r2_score(y, logits_train)
print("r2", r2)
mse = mean_squared_error(y, logits_train)
# loss = criteon(y, logits_train)
# print("loss",loss)
print("mse", mse)
print('logits_train', logits_train)
# logits_train=pd.DataFrame(logits_train)
print('train_y', y)
for x, y in val_loader1:
x, y = x.to(device), y.to(device)
print(x.shape)
with torch.no_grad():
logits_val = model(x)
logits_val = logits_val.squeeze(1)
logits_val = logits_val.cpu().numpy()
y = y.cpu().numpy()
r2 = r2_score(y, logits_val)
print("r2", r2)
mse = mean_squared_error(y, logits_val)
print("mse", mse)
print('logits_val', logits_val)
# print('logits_train',logits_train)
# logits_train=pd.DataFrame(logits_train)
print('test_y', y)
def main():
trained_model = resnest50(pretrained=True)
# # trained_model = resnet18(pretrained=True)
model = nn.Sequential(
*list(trained_model.children())[:-1], # [b, 512, 1, 1]
Flatten(), # [b, 512, 1, 1] => [b, 512]
# nn.Linear(2048, 512),
# nn.Linear(512, 2),
nn.BatchNorm1d(2048, affine=False),
nn.Dropout(0.29),
nn.Linear(2048, 2),
# nn.BatchNorm1d(2048, affine=False),
# nn.Linear(248, 2),
nn.Softmax(dim=1)).to(device)
# model.load_state_dict(torch.load('Resnest50_0205_1112.mdl')) #Resnest50_0205_1112
model.load_state_dict(torch.load('Resnest50_0308.mdl'))
thresholds = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
print("*******************计算验证集的混淆矩阵*****************************")
Inhosp_Nos_val, y_trues_val, y_probs_val, y_preds_val = Test(
model, val_loader)
sensitivities = []
specificities = []
for i, item in enumerate(thresholds):
# Yuedens=0
print('第{}th thresholds{}'.format(i, item))
preds = []
for j in y_probs_val:
if j > item:
preds.append(1)
else:
preds.append(0)
confusion_matrix0 = confusion_matrix(y_trues_val, preds)
print(confusion_matrix0)
sensitivity = confusion_matrix0[1, 1] / (confusion_matrix0[1, 0] +
confusion_matrix0[1, 1])
specificity = confusion_matrix0[0, 0] / (confusion_matrix0[0, 0] +
confusion_matrix0[0, 1])
sensitivities.append(sensitivity)
specificities.append(specificity)
sensitivities = np.array(sensitivities)
specificities = np.array(specificities)
optimal_threshold, point = Find_Optimal_Cutoff(sensitivities,
specificities, thresholds)
print('optimal_threshold=', optimal_threshold)
print("point=", point)
preds_val = []
for j in y_probs_val:
if j > optimal_threshold:
preds_val.append(1)
else:
preds_val.append(0)
val_AUC = confusion_matrixes(model, val_loader)
print("val_AUC=", val_AUC)
confusionmatrix_val = confusion_matrix(y_trues_val, preds_val)
print('confusionmatrix_val', confusionmatrix_val)
print("*********计算训练集的混淆矩阵******************")
###训练集的混淆矩阵
Inhosp_Nos_train, y_trues_train, y_probs_train, y_preds_train = Train_Test(
model, train_loader)
preds_train = []
for j in y_probs_train:
if j > optimal_threshold:
preds_train.append(1)
else:
preds_train.append(0)
confusionmatrix_train = confusion_matrix(y_trues_train, preds_train)
print('Confusionmatrix_train', confusionmatrix_train)
train_AUC = Train_confusion_matrixes(model, train_loader)
print("train_AUC=", train_AUC)
print("*********计算测试集的混淆矩阵******************")
test_AUC = confusion_matrixes(model, test_loader)
print("test_AUC=", test_AUC)
###训练集的混淆矩阵
Inhosp_Nos_test, y_trues_test, y_probs_test, y_preds_test = Test(
model, test_loader)
preds_test = []
for j in y_probs_test:
if j > optimal_threshold:
preds_test.append(1)
else:
preds_test.append(0)
confusionmatrix_test = confusion_matrix(y_trues_test, preds_test)
print('confusionmatrix_test', confusionmatrix_test)
def main():
trained_model = resnest50(pretrained=True)
# # trained_model = resnet18(pretrained=True)
model = nn.Sequential(*list(trained_model.children())[:-1], # [b, 512, 1, 1]
Flatten(), # [b, 512, 1, 1] => [b, 512]
# nn.Linear(2048, 512),
# nn.Linear(512, 2),
nn.BatchNorm1d(2048, affine=False),
nn.Dropout(0.29),
nn.Linear(2048, 2),
# nn.BatchNorm1d(2048, affine=False),
# nn.Linear(248, 2),
nn.Softmax(dim=1)
).to(device)
optimizer = optim.Adam(model.parameters(), lr=0.008, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.04,
amsgrad=False)
lr_list = []
for epoch in range(epochs):
if epoch % 1 == 0:
for p in optimizer.param_groups:
p['lr'] *= 0.9
lr_list.append(optimizer.state_dict()['param_groups'][0]['lr'])
#
# scheduler=torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=2,verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08)
# optimizer = optim.Adam(model.parameters(), lr=lr)
criteon = nn.CrossEntropyLoss()
# criteon = nn.BCELoss()
best_acc, best_epoch = 0, 0
global_step = 0
viz.line([0], [-1], win='loss', opts=dict(title='loss'))
viz.line([0], [-1], win='val_acc', opts=dict(title='val_acc'))
train_losses = []
train_accs = []
val_losses = []
val_accs = []
start = time.time()
for epoch in range(epochs):
train_loss = 0.0
for step, (Inhosp_No, EXAM_NO, x, y) in enumerate(train_loader):
# y_trains.extend(y)
print("********Enter {} 的{} step ***********".format(epoch, step))
# x: [b, 3, 224, 224], y: [b]
x, y = x.to(device), y.to(device)
model.train()
logits = model(x)
loss = criteon(logits, y)
# train_losses.append(loss.item())
optimizer.zero_grad()
loss.backward()
optimizer.step()
viz.line([loss.item()], [global_step], win='loss', update='append')
global_step += 1
train_loss += loss.item() * x.size(0)
train_loss = train_loss / len(train_loader.dataset)
train_losses.append(train_loss)
train_acc = evalute(model, train_loader)
train_accs.append(train_acc)
if epoch % 1 == 0:
val_loss = 0.0
for Inhosp_No, EXAM_NO, x, y in val_loader:
# x, y = x.to(device), y.unsqueeze(1).to(device)
x, y = x.to(device), y.to(device)
# ys.extend(y)
with torch.no_grad():
logits_val = model(x)
loss_val = criteon(logits_val, y)
# scheduler.step(loss_val)
# scheduler.step(loss_val)
val_loss += loss_val.item() * x.size(0)
val_loss = val_loss / len(val_loader.dataset)
# scheduler.step(val_loss)
# print("val_loss",val_loss)
val_losses.append(val_loss)
val_acc = evalute(model, val_loader)
val_accs.append(val_acc)
if val_acc > best_acc:
best_epoch = epoch
best_acc = val_acc
torch.save(model.state_dict(), 'Resnest50_0310.mdl')
viz.line([val_acc], [global_step], win='val_acc', update='append')
print("val_losses", val_losses)
print("train_losses", train_losses)
print('best acc:', best_acc, 'best epoch:', best_epoch)
x1 = range(0, epochs)
x2 = range(0, epochs)
y1 = train_accs
# y1 = Accuracy_list
y2 = val_accs
y3 = train_losses
y4 = val_losses
# y2 = Loss_list
plt.subplot(2, 2, 1)
plt.plot(x1, y1, color='lime')
plt.plot(x1, y2, color='r')
# plt.title('Cross_validation curve')
plt.ylabel('Accuracy')
# plt.xlabel('Epochs')
plt.subplot(2, 2, 3)
plt.plot(x2, y3, color='lime')
plt.plot(x2, y4, color='r')
plt.xlabel('Epochs')
plt.ylabel('Cross-Entrotopy Loss')
plt.subplot(2, 2, 4)
plt.plot(range(epochs), lr_list, color='r')
plt.ylabel('lr')
plt.subplot(2, 2, 2)
plt.plot(lr_list, val_losses, color='r')
plt.ylabel('val_losses')
plt.savefig("Resnest50_0310_accuracy_loss.pdf")
plt.savefig("Resnest50_0310_accuracy_loss.svg")
plt.show()
model.load_state_dict(torch.load('Resnest50_0310.mdl'))
print('loaded from ckpt!')
test_acc = evalute(model, test_loader)
print('test acc:', test_acc)
torch.cuda.synchronize()
end = time.time()
GPU_time = end - start
print("GPU_TIME=", GPU_time)
num_params = sum(param.numel() for param in model.parameters())
print('num_params', num_params)
AUC_train = confusion_matrixes(model, train_loader)
print("confusion_train", AUC_train)
AUC_val = confusion_matrixes(model, val_loader)
print("confusion_val", AUC_val)
AUC_test = confusion_matrixes(model, test_loader)
print("confusion_test", AUC_test)
import numpy as np
import argparse
import numpy as np
import matplotlib.pyplot as plt
from resnest.torch import resnest50
# net = resnest50(pretrained=True)
import torch.nn.functional as F
trained_model = torch.hub.load('zhanghang1989/ResNeSt',
'resnest269',
pretrained=True)
model = nn.Sequential(
*list(trained_model.children())[:-1], # [b, 512, 1, 1] [32,2048]
# list(trained_model.children())[-2].view(32, 2048,1,1),
# nn.BatchNorm2d(2048),
Flatten(), # [b, 512, 1, 1] => [b, 512]
# torch.nn.Dropout(0.3),
# nn.Linear(2048, 1000),
# nn.Dropout(0.1),
# nn.Linear(1000,500),
# nn.Dropout(0.1),
# nn.Linear(500, 1)
# nn.ReLU(inplace=True),
# torch.nn.Dropout(0.5),
# nn.Linear(1024, 1),
# nn.ReLU(inplace=True)
# nn.ReLU6(inplace=True)
nn.Linear(2048, 1000),
nn.Linear(1000, 500),
nn.Linear(500, 1)
def main():
# model = ResNet18(5).to(device)
# trained_model = resnet101(pretrained=True)
# # print('children', *list(trained_model.children())[:-1])
#
# model = nn.Sequential(*list(trained_model.children())[:-1], # [b, 512, 1, 1]
# Flatten(), # [b, 512, 1, 1] => [b, 512]
# nn.Linear(2048, 2)
# ).to(device)
trained_model = torch.hub.load('zhanghang1989/ResNeSt',
'resnest269',
pretrained=True)
model = nn.Sequential(
*list(trained_model.children())[:-1], # [b, 512, 1, 1] [32,2048]
# list(trained_model.children())[-2].view(32, 2048,1,1),
# nn.BatchNorm2d(2048),
Flatten(), # [b, 512, 1, 1] => [b, 512]
# torch.nn.Dropout(0.3),
# nn.Linear(2048, 1000),
# nn.Dropout(0.1),
# nn.Linear(1000,500),
# nn.Dropout(0.1),
# nn.Linear(500, 1)
# nn.ReLU(inplace=True),
# torch.nn.Dropout(0.5),
# nn.Linear(1024, 1),
# nn.ReLU(inplace=True)
# nn.ReLU6(inplace=True)
nn.Linear(2048, 2),
# nn.Linear(1000, 2000),
# nn.Linear(2000, 1),
# nn.LeakyReLU(inplace=True),
).to(device)
model.train()
optimizer = optim.Adam(model.parameters(), lr=lr)
criteon = nn.CrossEntropyLoss()
best_acc, best_epoch = 0, 0
global_step = 0
viz.line([0], [-1], win='loss', opts=dict(title='loss'))
viz.line([0], [-1], win='val_acc', opts=dict(title='val_acc'))
for epoch in range(epochs):
for step, (x, y) in enumerate(train_loader):
# print("Enter"+str(epoch)+'time'+str(step))
print("Enter: {} step {}".format(epoch, step))
# x: [b, 3, 224, 224], y: [b]
x, y = x.to(device), y.to(device)
model.train()
logits = model(x)
loss = criteon(logits, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
viz.line([loss.item()], [global_step], win='loss', update='append')
global_step += 1
if epoch % 1 == 0:
val_acc = evalute(model, val_loader)
if val_acc > best_acc:
best_epoch = epoch
best_acc = val_acc
torch.save(model.state_dict(), 'best.mdl')
viz.line([val_acc], [global_step],
win='val_acc',
update='append')
print('best acc:', best_acc, 'best epoch:', best_epoch)
model.load_state_dict(torch.load('best.mdl'))
print('loaded from ckpt!')
test_acc = evalute(model, test_loader)
print('test acc:', test_acc)
confusion, report, AUC = test_confusion(model, test_loader)
print('confusion', confusion)
print('classification_report', report)
print('AUC', AUC)