def net(model_name, pretrained, is_local, NUM_CLASS):
if model_name == 'resnest50':
if pretrained and not is_local:
model = resnest50(pretrained=True)
else:
model = resnest50(pretrained=False)
elif model_name == 'resnest101':
if pretrained and not is_local:
model = resnest101(pretrained=True)
else:
model = resnest101(pretrained=False)
elif model_name == 'resnest200':
if pretrained and not is_local:
model = resnest200(pretrained=True)
else:
model = resnest200(pretrained=False)
else:
print('Error model name')
if is_local:
model_path = PATH[model_name]
model.load_state_dict(torch.load(model_path), strict=False)
model.fc = nn.Sequential(
nn.Dropout(0.2),
nn.Linear(in_features[model_name], NUM_CLASS)
)
return model
def __init__(self, num_classes, pre_train=True):
super(ResNest_unc, self).__init__()
if pre_train:
original_model = resnest50(pretrained=True)
else:
original_model = resnest50(pretrained=False)
#original_model = load_weights(original_model, '/extracephonline/medai_data_tronbian/eye/resnext50_32x4d-7cdf4587.pth')
self.features = nn.Sequential(*list(original_model.children())[:-2])
self.GlobalAvgPool = nn.AdaptiveAvgPool2d(output_size=(1, 1))
self.classifier = nn.Sequential(nn.Linear(2048, num_classes),
nn.Sigmoid())
self.classifier2 = nn.Linear(2048, num_classes)
def __init__(self, num_classes=24):
super().__init__()
self.net = resnest50(pretrained=True)
# self.net = resnest101(pretrained=True) # larger alternative model
last_layer_in_features = self.net.fc.in_features
self.net.fc = torch.nn.Linear(in_features=last_layer_in_features,
out_features=num_classes)
def __init__(self, arch, norm, pre=False):
super().__init__()
if arch == 'ResX50':
m = ResNet(Bottleneck, [3, 4, 6, 3], groups=32, width_per_group=4)
print('Loaded Model RexNextssl')
elif arch == 'ResS50':
m = resnest50(pretrained=pre)
print('Loaded model ResNest')
blocks = [*m.children()]
enc = blocks[:-2]
self.enc = nn.Sequential(*enc)
C = blocks[-1].in_features
head = [
AdaptiveConcatPool2d(),
Flatten(), #bs x 2*C
nn.Linear(2 * C, 512),
Mish()
]
if norm == 'GN':
head.append(nn.GroupNorm(32, 512))
print('Group Norm')
elif norm == 'BN':
head.append(nn.BatchNorm1d(512))
print('Batch Norm')
else:
print('No Norm')
head.append(nn.Dropout(0.5))
head.append(nn.Linear(512, NUM_CLASSES - 1))
self.head = nn.Sequential(*head)
def __init__(self, nclass, backbone, dilated=True, norm_layer=None, pretrained=True):
super(BaseNet, self).__init__()
self.nclass = nclass
# copying modules from pretrained HRNet+OCR
if backbone == 'resnet50':
self.pretrained = resnet.resnet50(pretrained=False, dilated=dilated, norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnet50-19c8e357.pth"))
elif backbone == 'resnet101':
self.pretrained = resnet.resnet101(pretrained=False, dilated=dilated, norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnet101-5d3b4d8f.pth"))
elif backbone == 'resnet152':
self.pretrained = resnet.resnet152(pretrained=False, dilated=dilated, norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnet152-b121ed2d.pth"))
elif backbone == 'resnext50':
self.pretrained = models.resnext50_32x4d(pretrained=False, progress=True, replace_stride_with_dilation=[0, 1, 1], norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnext50_32x4d-7cdf4587.pth"))
elif backbone == 'resnext101':
self.pretrained = models.resnext101_32x8d(pretrained=False, progress=True, replace_stride_with_dilation=[0, 1, 1], norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnext101_32x8d-8ba56ff5.pth"))
elif backbone == 'resnest50':
self.pretrained = resnest50(pretrained=False, dilated=True, norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnest50-528c19ca.pth"))
elif backbone == 'resnest101':
self.pretrained = resnest101(pretrained=False, dilated=True, norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnest101-22405ba7.pth"))
else:
self.pretrained = models.resnet101(pretrained=False)
def __init__(self, cfg, block):
self.inplanes = 512
super(ResNest, self).__init__()
self.cfg = cfg
net = resnest50(pretrained=True)
self.before_maxpool = nn.Sequential(*list(net.children())[:3])
self.to_layer3 = nn.Sequential(*list(net.children())[4:-4]) #75*75
self.ex_layer000 = self._make_layer(block, 1024, 1, stride=2) #38*38
self.ex_layer00 = self._make_layer(block, 512, 1, stride=2) #19*19
self.ex_layer0 = self._make_layer(block, 512, 1, stride=2) #10*10
self.ex_layer1 = self._make_layer(block, 512, 1, stride=2) #5*5
self.ex_layer2 = self._make_layer(block, 256, 1, stride=2) #3*3
self.ex_layer3 = self._make_layer(block, 128, 1, stride=2)
# kaiming weight normal after default initialization
ttt = 0
for m in self.modules():
ttt += 1 #Control for not initializing the pre-trained parmeters.
if ttt > 114: #198 for 3 pre-layers
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_()
def __init__(self):
super(ResNeSt, self).__init__()
self.resnest50 = resnest50(pretrained=False)
model_state_dict = torch.load(
'E:\cfy\deepLearning\DL_model/resnest50-528c19ca.pth')
self.resnest50.load_state_dict(model_state_dict)
self.ReLU1 = nn.ReLU(inplace=True) # ReLU层必须在__init__中先定义，再在forward中使用
self.fc1 = nn.Linear(in_features=1000, out_features=2)
def build_detection_based_model(model_name,
n_kps=7,
pretrained=True,
n_deconvs=2,
use_depthwise=True):
if model_name == 'efficient_encode':
pre_model = EfficientNet.from_pretrained('efficientnet-b2')
for param in pre_model.parameters():
param.requires_grad = True
model = Efficient_encode(pre_model, n_kps)
return model
elif model_name == 'resnest_encode':
pre_model = resnest50(pretrained=pretrained)
for param in pre_model.parameters():
param.requires_grad = True
model = ResNeSt_encode(pre_model, n_kps)
return model
elif model_name == 'mobile_deconv':
pre_model = mobilenet_v2(pretrained=pretrained)
for param in pre_model.parameters():
param.requires_grad = True
model = MobileNet_deconv(pre_model,
n_deconvs=n_deconvs,
use_depthwise=use_depthwise)
return model
elif model_name == 'shuffle_deconv':
pre_model = shufflenet_v2_x1_0(pretrained=pretrained)
for param in pre_model.parameters():
param.requires_grad = True
model = ShuffleNet_deconv(pre_model,
n_deconvs=n_deconvs,
use_depthwise=use_depthwise)
return model
elif model_name == 'resnest_deconv':
pre_model = resnest50(pretrained=pretrained)
for param in pre_model.parameters():
param.requires_grad = True
model = ResNeSt_deconv(pre_model,
n_deconvs=n_deconvs,
use_depthwise=use_depthwise)
return model
else:
print('Not support this model!')
def __init__(self, backbone="resnest101", norm_layer=nn.BatchNorm2d, pretrained=True):
super(ResNeSt, self).__init__()
if backbone == 'resnest50':
self.pretrained = resnest50(pretrained=False, dilated=True, norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnest50-528c19ca.pth"))
elif backbone == 'resnest101':
self.pretrained = resnest101(pretrained=False, dilated=True, norm_layer=norm_layer)
if pretrained:
self.pretrained.load_state_dict(torch.load("./resnest101-22405ba7.pth"))
def load_net(checkpoint_path, num_classes=397, device=torch.device("cpu")):
net = resnest50(pretrained=False)
net.fc = nn.Linear(net.fc.in_features, num_classes)
dummy_device = torch.device("cpu")
d = torch.load(checkpoint_path, map_location=dummy_device)
for key in list(d.keys()):
d[key.replace("model.", "")] = d.pop(key)
#net.load_state_dict(d['state_dict'])
net.load_state_dict(d)
net = net.to(device)
net = net.eval()
return net
def __init__(self,
in_channels,
pretrained=False,
version='resnet101',
clf=None):
super(ResNet_BB, self).__init__()
version = version.strip()
if version == 'resnet18':
resnet = models.resnet18(pretrained)
elif version == 'resnet34':
resnet = models.resnet34(pretrained)
elif version == 'resnet50':
resnet = models.resnet50(pretrained)
elif version == 'resnet101':
resnet = models.resnet101(pretrained)
elif version == 'resnet152':
resnet = models.resnet152(pretrained)
elif version == 'resnext50_32x4d':
resnet = models.resnext50_32x4d(pretrained)
elif version == 'resnext101_32x8d':
resnet = models.resnext101_32x8d(pretrained)
elif version == 'wide_resnet50_2':
resnet = models.wide_resnet50_2(pretrained)
elif version == 'wide_resnet101_2':
resnet = models.wide_resnet101_2(pretrained)
elif version == 'resnest50':
resnet = resnest50(pretrained)
elif version == 'resnest101':
resnet = resnest101(pretrained)
elif version == 'resnest200':
resnet = resnest200(pretrained)
elif version == 'resnest269':
resnet = resnest269(pretrained)
else:
raise NotImplementedError(
'version {} is not supported as of now'.format(version))
resnet.conv1 = nn.Conv2d(in_channels,
64,
kernel_size=(7, 7),
stride=(2, 2),
padding=(3, 3),
bias=False)
if clf == 'deeplabv3Plus':
return_layers = {'layer4': 'out', 'layer1': 'low_level'}
elif clf == 'PointRend':
return_layers = {'layer4': 'out', 'layer2': 'fine_grained'}
else:
return_layers = {'layer4': 'out'}
self.backbone = IntermediateLayerGetter(resnet, return_layers)
self.out_channels = 2048
self.low_channels = 256
self.fine_grained_channels = 512
def initialize_model(model_name, input_size, num_classes, frozen,
use_pretrained, device):
if model_name == 'customized':
model = Net(input_size, num_classes).to(device)
elif model_name.startswith('resnest'):
from resnest.torch import resnest50
net = resnest50(pretrained=True)
model = net.to(device)
set_parameter_requires_grad(model, frozen=frozen)
model.fc = make_classifier(model.fc.in_features, 512,
num_classes).to(device)
else:
try:
net = getattr(models, model_name)(pretrained=use_pretrained)
except:
print('there is no pre-train model named: %s' % model_name)
print(
'pre-train list can see from https://pytorch.org/docs/stable/torchvision/models.html'
)
raise AttributeError()
model = net.to(device)
set_parameter_requires_grad(model, frozen=frozen)
if model_name.startswith('vgg'):
#model.classifier[6] = nn.Linear(in_features= model.classifier[6].in_features, out_features=num_classes, bias=True).to(device)
model.classifier = make_classifier(model.classifier[0].in_features,
512, num_classes).to(device)
elif model_name.startswith('resnet') or model_name.startswith(
'inception'):
model.fc = make_classifier(model.fc.in_features, 512,
num_classes).to(device)
elif model_name.startswith('densenet'):
model.classifier = make_classifier(model.classifier.in_features,
512, num_classes).to(device)
elif model_name.startswith('mobilenet'):
model.classifier[1] = nn.Linear(
in_features=model.classifier[1].in_features,
out_features=num_classes,
bias=True).to(device)
else:
raise Exception('please update classifier by in network.py!')
return model
def build_detection_based_model(model_name, n_kps=7, pretrained=True):
if model_name == 'efficient':
pre_model = EfficientNet.from_pretrained('efficientnet-b2')
for param in pre_model.parameters():
param.requires_grad = True
model = Efficient_head(pre_model, n_kps)
return model
elif model_name == 'resnest':
pre_model = resnest50(pretrained=pretrained)
for param in pre_model.parameters():
param.requires_grad = True
model = ResNeSt_head(pre_model, n_kps)
return model
else:
print('Not support this model!')
def __init__(self,
num_classes,
M=32,
net='inception_mixed_6e',
pretrained=False):
super(WSDAN, self).__init__()
self.num_classes = num_classes
self.M = M
self.net = net
# Network Initialization
if 'inception' in net:
if net == 'inception_mixed_6e':
self.features = inception_v3(
pretrained=pretrained).get_features_mixed_6e()
self.num_features = 768
elif net == 'inception_mixed_7c':
self.features = inception_v3(
pretrained=pretrained).get_features_mixed_7c()
self.num_features = 2048
else:
raise ValueError('Unsupported net: %s' % net)
elif 'resnest' in net:
self.features = resnest50(pretrained=pretrained)
self.features = torch.nn.Sequential(
*(list(self.features.children())[:-2]))
self.num_features = 2048
else:
raise ValueError('Unsupported net: %s' % net)
# Attention Maps
self.attentions = BasicConv2d(self.num_features, self.M, kernel_size=1)
# Bilinear Attention Pooling
self.bap = BAP(pool='GAP')
# Classification Layer
self.fc = nn.Linear(self.M * self.num_features,
self.num_classes,
bias=False)
logging.info(
'WSDAN: using {} as feature extractor, num_classes: {}, num_attentions: {}'
.format(net, self.num_classes, self.M))
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 build_regression_based_model(model_name, n_kps=7, pretrained=True):
if model_name == 'efficient':
model = EfficientNet.from_pretrained('efficientnet-b2')
for param in model.parameters():
param.requires_grad = True
in_feature = model._fc.in_features
model._fc = nn.Sequential(nn.Linear(in_feature, 2 * n_kps, bias=True),
nn.Sigmoid())
return model
elif model_name == 'resnest':
model = resnest50(pretrained=pretrained)
for param in model.parameters():
param.requires_grad = True
in_feature = model.fc.in_features
model.fc = nn.Sequential(nn.Linear(in_feature, 2 * n_kps, bias=True),
nn.Sigmoid())
return model
else:
print('Not support this model!')
def __init__(self, out_dim, pretrained=True, loss_config={}, args={}):
super(Resnest50, self).__init__()
feat_dim = 512
self.backbone = torch.nn.Sequential(
*list(resnest50(pretrained=pretrained).children())[:-2])
self.args = args
planes = 2048
if self.args.bert:
self.bert = AutoModel.from_pretrained(
f'{root_dir}/bert-base-uncased')
planes += self.bert.config.hidden_size
else:
self.bert = None
if self.args.global_feat:
feat_dim = planes
self.pooling = GeM()
# self.pooling = nn.AdaptiveAvgPool2d(1)
if self.args.freezebn:
print(f'Freeze {freeze_bn(self.backbone)} layers')
if loss_config.loss_type == 'aarc':
self.arc = ArcMarginProduct_subcenter(feat_dim, out_dim)
elif loss_config.loss_type == 'arc':
self.arc = ArcModule(feat_dim,
out_dim,
scale=loss_config.scale,
margin=loss_config.margin)
elif loss_config.loss_type == 'cos':
self.arc = CosModule(feat_dim,
out_dim,
scale=loss_config.scale,
margin=loss_config.margin)
self.to_feat = nn.Linear(planes, feat_dim)
self.bn = nn.BatchNorm1d(feat_dim)
def __init__(self, cfg):
super(resnet_baseline, self).__init__()
self.save_hyperparameters()
self.cfg = self.hparams.cfg # type: ignore
self.lr = self.cfg["train_params"]["learning_rate"] # type: ignore
self.num_modes = self.cfg["train_params"]["num_modes"] # type: ignore
# change input channels number to match the rasterizer's output
num_history_channels = (
self.cfg["model_params"]["history_num_frames"] + 1) * 2
self.num_in_channels = 3 + num_history_channels
self.future_len = cfg["model_params"]["future_num_frames"]
self.model = resnest50(pretrained=True)
self.model.conv1 = nn.Conv2d(
self.num_in_channels,
64,
kernel_size=3,
stride=2,
padding=1,
bias=False,
)
# change output size to (X, Y) * number of future states * num modes
num_targets = 2 * self.cfg["model_params"]["future_num_frames"]
self.num_preds = num_targets * self.num_modes
self.model.fc = nn.Sequential(
nn.Linear(
in_features=2048,
# num of modes * preds + confidence
out_features=self.num_preds + self.num_modes,
), )
# Loss function
self.criterion = pytorch_neg_multi_log_likelihood_batch
def get_resnest(net='resnest50', classes=264, pretrained=True):
if net == 'resnest50':
model = resnest50(pretrained=pretrained)
# https://arxiv.org/pdf/1806.05622.pdf
# we apply N*1 Conv2D (support in the frequency domain) and 1*K avg_pool.
# The benefit of this modification is that the network becomes invariant
# to temporal position but not frequency, which is desirable for speech,
# but not for images.
# Bottleneck-281 [-1, 2048, 7, 18], feature map before avg_pool
del model.avgpool
model.avgpool = nn.Sequential(
nn.BatchNorm2d(2048),
nn.Conv2d(in_channels=2048, out_channels=2048, kernel_size=(7, 1)),
nn.AvgPool2d(kernel_size=(1, 18))
)
del model.fc
model.fc = nn.Sequential(
nn.Linear(2048, 1024), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(1024, 1024), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(1024, classes))
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 __init__(self, num_classes, last_stride, model_path, neck, neck_feat, model_name, pretrain_choice, **kwargs):
super(Baseline, self).__init__()
self.in_planes = 2048
if model_name == 'resnet18':
self.in_planes = 512
self.base = ResNet(last_stride=last_stride,
block=BasicBlock,
layers=[2, 2, 2, 2])
elif model_name == 'resnet34':
self.in_planes = 512
self.base = ResNet(last_stride=last_stride,
block=BasicBlock,
layers=[3, 4, 6, 3])
elif model_name == 'resnet50':
self.base = ResNet(last_stride=last_stride,
block=Bottleneck,
layers=[3, 4, 6, 3])
elif model_name == 'resnest50':
self.base = resnest50(pretrained=True)
elif model_name == 'resnet101':
self.base = ResNet(last_stride=last_stride,
block=Bottleneck,
layers=[3, 4, 23, 3])
elif model_name == 'resnet152':
self.base = ResNet(last_stride=last_stride,
block=Bottleneck,
layers=[3, 8, 36, 3])
elif model_name == 'se_resnet50':
self.base = SENet(block=SEResNetBottleneck,
layers=[3, 4, 6, 3],
groups=1,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnet101':
self.base = SENet(block=SEResNetBottleneck,
layers=[3, 4, 23, 3],
groups=1,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnet152':
self.base = SENet(block=SEResNetBottleneck,
layers=[3, 8, 36, 3],
groups=1,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnext50':
self.base = SENet(block=SEResNeXtBottleneck,
layers=[3, 4, 6, 3],
groups=32,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'se_resnext101':
self.base = SENet(block=SEResNeXtBottleneck,
layers=[3, 4, 23, 3],
groups=32,
reduction=16,
dropout_p=None,
inplanes=64,
input_3x3=False,
downsample_kernel_size=1,
downsample_padding=0,
last_stride=last_stride)
elif model_name == 'senet154':
self.base = SENet(block=SEBottleneck,
layers=[3, 8, 36, 3],
groups=64,
reduction=16,
dropout_p=0.2,
last_stride=last_stride)
elif model_name == 'resnet50_ibn':
self.base = resnet50_ibn_a(last_stride)
if pretrain_choice == 'imagenet':
self.base.load_param(model_path)
print('Loading pretrained ImageNet model......')
self.gap = nn.AdaptiveAvgPool2d(1)
# self.gap = nn.AdaptiveMaxPool2d(1)
self.num_classes = num_classes
self.neck = neck
self.neck_feat = neck_feat
if self.neck == 'no':
self.classifier = nn.Linear(self.in_planes, self.num_classes)
# self.classifier = nn.Linear(self.in_planes, self.num_classes, bias=False) # new add by luo
# self.classifier.apply(weights_init_classifier) # new add by luo
elif self.neck == 'bnneck':
self.bottleneck = nn.BatchNorm1d(self.in_planes)
self.bottleneck.bias.requires_grad_(False) # no shift
self.classifier = nn.Linear(
self.in_planes, self.num_classes, bias=False)
self.bottleneck.apply(weights_init_kaiming)
self.classifier.apply(weights_init_classifier)
def initialize_model(model_name,
num_classes,
feature_extract,
use_pretrained=True):
# 初始化将在此if语句中设置的这些变量。
# 每个变量都是模型特定的。
model_ft = None
input_size = 0
if model_name.split('-')[0] == "resnet":
if model_name.split('-')[1] == "18":
"""
Resnet18
"""
model_ft = models.resnet18(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name.split('-')[1] == "34":
"""
Resnet34
"""
model_ft = models.resnet34(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name.split('-')[1] == "50":
"""
Resnet50
"""
model_ft = models.resnet50(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name.split('-')[1] == "152":
"""
Resnet152
"""
model_ft = models.resnet152(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
else:
print("Invalid resnet model name, exiting...")
exit()
elif model_name == "resnest50":
model_ft = resnest50(pretrained=True)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "resnest101":
model_ft = resnest101(pretrained=True)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
elif model_name == "resnest200":
model_ft = resnest200(pretrained=True)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
elif model_name == "resnest269":
model_ft = resnest269(pretrained=True)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
elif model_name == "alexnet":
""" Alexnet
"""
model_ft = models.alexnet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "vgg":
""" VGG11_bn
"""
model_ft = models.vgg11_bn(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier[6].in_features
model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "squeezenet":
""" Squeezenet
"""
model_ft = models.squeezenet1_0(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
model_ft.classifier[1] = nn.Conv2d(512,
num_classes,
kernel_size=(1, 1),
stride=(1, 1))
model_ft.num_classes = num_classes
input_size = 224
elif model_name == "densenet":
""" Densenet
"""
model_ft = models.densenet161(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft.classifier.in_features
model_ft.classifier = nn.Linear(num_ftrs, num_classes)
input_size = 224
elif model_name == "inception":
""" Inception v3
Be careful, expects (299,299) sized images and has auxiliary output
"""
model_ft = models.inception_v3(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extract)
# 处理辅助网络
num_ftrs = model_ft.AuxLogits.fc.in_features
model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes)
# 处理主要网络
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, num_classes)
input_size = 299
elif model_name.split('-')[0] == "efficientnet":
model_ft = EfficientNet.from_pretrained(model_name)
set_parameter_requires_grad(model_ft, feature_extract)
num_ftrs = model_ft._fc.in_features
model_ft._fc = nn.Sequential(nn.Linear(num_ftrs, 1000, bias=True),
nn.ReLU(), nn.Dropout(p=0.5),
nn.Linear(1000, num_classes, bias=True))
input_size = 299
else:
print("Invalid model name, exiting...")
exit()
return model_ft, input_size
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)
data["duration"] = data["recording_id"].apply(get_duration)
data.head()
data["duration"].hist()
ds = RFCXDataset(data=data, sr=SR, duration=10)
x, y = ds[0]
x.shape, y.shape
TEST_BATCH_SIZE = 40
TEST_NUM_WORKERS = 2
test_data = RFCXDataset(data=data, sr=SR)
test_loader = DataLoader(test_data,
batch_size=TEST_BATCH_SIZE,
num_workers=TEST_NUM_WORKERS)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
net = resnest50(pretrained=False)
net.load_state_dict(
torch.hub.load_state_dict_from_url(
"https://s3.us-west-1.wasabisys.com/resnest/torch/resnest50-528c19ca.pth",
model_dir="./",
progress=True,
check_hash=True))
# net = resnest50(pretrained=True).to(device) # 如果本地没有模型则会下载模型
n_features = net.fc.in_features
net.fc = torch.nn.Linear(n_features, NUM_CLASSES)
net = net.to(device)
net.load_state_dict(torch.load("./rfcx_resnest50.pth",
map_location=device))
net = net.eval()
net
preds = []
train_dataset = RainforestDataset(train_files)
val_dataset = RainforestDataset(val_files)
train_loader = torchdata.DataLoader(
train_dataset,
batch_size=batch_size,
sampler=torchdata.RandomSampler(train_dataset))
val_loader = torchdata.DataLoader(val_dataset,
batch_size=batch_size,
sampler=torchdata.RandomSampler(val_dataset))
# ResNeSt: Split-Attention Networks
# https://arxiv.org/abs/2004.08955
# Significantly outperforms standard Resnet
model = resnest50(pretrained=True)
model.fc = nn.Sequential(nn.Linear(2048, 1024), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(1024, 1024), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(1024, num_birds))
# Picked for this notebook; pick new ones after major changes (such as adding train_fp to train data)
optimizer = torch.optim.SGD(model.parameters(),
lr=0.01,
weight_decay=0.0001,
momentum=0.9)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.4)
# This loss function is not exactly suited for competition metric, which only cares about ranking of predictions
# Exploring different loss fuctions would be a good idea
pos_weights = torch.ones(num_birds)
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)
