def __init__(self, num_class):
super(multiscale_se_resnext_cat, self).__init__()
self.base_model1 = se_resnext50_32x4d(9, None)
self.base_model2 = se_resnext50_32x4d(9, None)
self.dropout = nn.Dropout(0.5)
self.classifier = nn.Linear(4096, 1024)
def load_se_resnet50(pretrained_path=None):
model = se_resnext50_32x4d()
# load_from_path(pretrained_path, model)
return model
def __init__(self, num_classes=3, num_filters=32,
pretrained=True, is_deconv=True):
super().__init__()
self.num_classes = num_classes
pretrain = 'imagenet' if pretrained is True else None
self.encoder = se_resnext50_32x4d(num_classes=1000, pretrained=pretrain)
bottom_channel_nr = 2048
self.conv1 = self.encoder.layer0
#self.se_e1 = SCSEBlock(64)
self.conv2 = self.encoder.layer1
#self.se_e2 = SCSEBlock(64 * 4)
self.conv3 = self.encoder.layer2
#self.se_e3 = SCSEBlock(128 * 4)
self.conv4 = self.encoder.layer3
#self.se_e4 = SCSEBlock(256 * 4)
self.conv5 = self.encoder.layer4
#self.se_e5 = SCSEBlock(512 * 4)
self.center = DecoderCenter(bottom_channel_nr, num_filters * 8 *2, num_filters * 8, False)
self.dec5 = DecoderBlockV(bottom_channel_nr + num_filters * 8, num_filters * 8 * 2, num_filters * 2, is_deconv)
#self.se_d5 = SCSEBlock(num_filters * 2)
self.dec4 = DecoderBlockV(bottom_channel_nr // 2 + num_filters * 2, num_filters * 8, num_filters * 2, is_deconv)
#self.se_d4 = SCSEBlock(num_filters * 2)
self.dec3 = DecoderBlockV(bottom_channel_nr // 4 + num_filters * 2, num_filters * 4, num_filters * 2, is_deconv)
#self.se_d3 = SCSEBlock(num_filters * 2)
self.dec2 = DecoderBlockV(bottom_channel_nr // 8 + num_filters * 2, num_filters * 2, num_filters * 2, is_deconv)
#self.se_d2 = SCSEBlock(num_filters * 2)
self.dec1 = DecoderBlockV(num_filters * 2, num_filters, num_filters * 2, is_deconv)
#self.se_d1 = SCSEBlock(num_filters * 2)
self.dec0 = ConvRelu(num_filters * 10, num_filters * 2)
self.final = nn.Conv2d(num_filters * 2, num_classes, kernel_size=1)
def main():
model = se_resnext50_32x4d()
num_ftrs = model.last_linear.in_features
model.last_linear = nn.Linear(num_ftrs, len(class_names))
for param in model.parameters():
param.requires_grad = False
for param in model.layer3.parameters():
param.requires_grad = True
for param in model.layer4.parameters():
param.requires_grad = True
for param in model.last_linear.parameters():
param.requires_grad = True
criterion = nn.CrossEntropyLoss()
if use_gpu:
cudnn.benchmark = True
cudnn.deterministic = True
criterion = criterion.cuda()
model = model.cuda()
model = torch.nn.DataParallel(model, device_ids=range(torch.cuda.device_count()))
optimizer_ft = optim.SGD([p for p in model.parameters() if p.requires_grad],
lr=0.01, momentum=0.9, weight_decay=5e-5)
rop_lr_scheduler = lr_scheduler.ReduceLROnPlateau(optimizer_ft, factor=0.5)
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
train_model(model, criterion, optimizer_ft, rop_lr_scheduler, num_epochs=100)
def main():
args = get_parse()
catalyst.utils.set_global_seed(args.seed)
catalyst.utils.prepare_cudnn(deterministic=True)
print('Make Data set data frame')
df, class_names = make_df(data_root=args.data_rootdir)
num_class = len(class_names)
print('Get data loaders')
loaders = get_train_valid_loaders(
df=df,
test_size=0.2,
random_state=args.seed,
data_root=args.data_rootdir,
num_class=num_class,
batch_size=args.batch_size,
num_workers=args.num_workers,
img_size=args.img_size
)
print('Make model')
if args.frn:
model = se_resnext50_32x4d_frn(pretrained=None)
model.last_linear = nn.Linear(512 * 16, num_class)
else:
model = se_resnext50_32x4d()
model.last_linear = nn.Linear(512 * 16, num_class)
print('Get optimizer and scheduler')
# learning rate for FRN is very very sensitive !!!
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=3e-5 if args.frn else 3e-4)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer=optimizer,
T_max=args.num_epochs,
eta_min=1e-6 if args.frn else 1e-5,
last_epoch=-1
)
log_base = './output/cls'
dir_name = f'seresnext50{"_frn" if args.frn else ""}_bs_{args.batch_size}_fp16_{args.fp16}'
print('Start training...')
runner = SupervisedRunner(device=catalyst.utils.get_device())
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
scheduler=scheduler,
loaders=loaders,
logdir=os.path.join(log_base, dir_name),
callbacks=get_callbacks(num_classes=num_class),
num_epochs=args.num_epochs,
main_metric="accuracy01",
minimize_metric=False,
fp16=dict(opt_level="O1") if args.fp16 else None,
verbose=False
)
def test_clsmodel():
# Base Model
model = se_resnext50_32x4d(pretrained=None)
model.last_linear = torch.nn.Linear(512 * 16, 2)
summary(model, (3, 256, 256), batch_size=2)
# Use FRN Model
model = se_resnext50_32x4d_frn(pretrained=None)
model.last_linear = torch.nn.Linear(512 * 16, 2)
summary(model, (3, 256, 256), batch_size=2)
def __init__(self, backbone1, backbone2, drop, pretrained=True):
super(MultiModalNet, self).__init__()
self.visit_model = DPN26()
if backbone1 == 'se_resnext101_32x4d':
self.img_encoder = se_resnext101_32x4d(9, None)
self.img_fc = nn.Linear(2048, 256)
elif backbone1 == 'se_resnext50_32x4d':
self.img_encoder = se_resnext50_32x4d(9, None)
print(
"load pretrained model from /home/zxw/2019BaiduXJTU/se_resnext50_32x4d-a260b3a4.pth"
)
state_dict = torch.load(
'/home/zxw/2019BaiduXJTU/se_resnext50_32x4d-a260b3a4.pth')
state_dict.pop('last_linear.bias')
state_dict.pop('last_linear.weight')
self.img_encoder.load_state_dict(state_dict, strict=False)
self.img_fc = nn.Linear(2048, 256)
elif backbone1 == 'se_resnext26_32x4d':
self.img_encoder = se_resnext26_32x4d(9, None)
self.img_fc = nn.Linear(2048, 256)
elif backbone1 == 'multiscale_se_resnext':
self.img_encoder = multiscale_se_resnext(9)
self.img_fc = nn.Linear(2048, 256)
elif backbone1 == 'multiscale_se_resnext_cat':
self.img_encoder = multiscale_se_resnext(9)
self.img_fc = nn.Linear(1024, 256)
elif backbone1 == 'multiscale_se_resnext_HR':
self.img_encoder = multiscale_se_resnext_HR(9)
self.img_fc = nn.Linear(2048, 256)
elif backbone1 == 'se_resnet50':
self.img_encoder = se_resnet50(9, None)
print(
"load pretrained model from /home/zxw/2019BaiduXJTU/se_resnet50-ce0d4300.pth"
)
state_dict = torch.load(
'/home/zxw/2019BaiduXJTU/se_resnet50-ce0d4300.pth')
state_dict.pop('last_linear.bias')
state_dict.pop('last_linear.weight')
self.img_encoder.load_state_dict(state_dict, strict=False)
self.img_fc = nn.Linear(2048, 256)
self.dropout = nn.Dropout(0.5)
self.cls = nn.Linear(512, 9)
def __init__(self, num_classes=1):
super(model50A_slim_DeepSupervion, self).__init__()
self.num_classes = num_classes
self.encoder = se_resnext50_32x4d()
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Sequential(self.encoder.layer0.conv1,
self.encoder.layer0.bn1,
self.encoder.layer0.relu1)
self.conv2 = self.encoder.layer1
self.conv3 = self.encoder.layer2
self.conv4 = self.encoder.layer3
self.conv5 = self.encoder.layer4
self.center_global_pool = nn.AdaptiveAvgPool2d([1, 1])
self.center_conv1x1 = nn.Conv2d(512 * 4, 64, kernel_size=1)
self.center_fc = nn.Linear(64, 2)
self.center = nn.Sequential(
nn.Conv2d(512 * 4, 512, kernel_size=3, padding=1),
nn.BatchNorm2d(512), nn.ReLU(inplace=True),
nn.Conv2d(512, 256, kernel_size=3, padding=1), nn.BatchNorm2d(256),
nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2))
self.dec5_1x1 = nn.Sequential(nn.Conv2d(512 * 4, 512, kernel_size=1),
nn.BatchNorm2d(512),
nn.ReLU(inplace=True))
self.decoder5 = Decoder_bottleneck(256 + 512, 512, 64)
self.dec4_1x1 = nn.Sequential(nn.Conv2d(256 * 4, 256, kernel_size=1),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True))
self.decoder4 = Decoder_bottleneck(64 + 256, 256, 64)
self.dec3_1x1 = nn.Sequential(nn.Conv2d(128 * 4, 128, kernel_size=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True))
self.decoder3 = Decoder_bottleneck(64 + 128, 128, 64)
self.dec2_1x1 = nn.Sequential(nn.Conv2d(64 * 4, 64, kernel_size=1),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True))
self.decoder2 = Decoder_bottleneck(64 + 64, 64, 64)
self.decoder1 = Decoder_bottleneck(64, 32, 64)
self.logits_no_empty = nn.Sequential(
nn.Conv2d(320, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True), nn.Conv2d(64, 1, kernel_size=1, padding=0))
self.logits_final = nn.Sequential(
nn.Conv2d(320 + 64, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True), nn.Conv2d(64, 1, kernel_size=1, padding=0))
def __init__(self, weights_path, device, n_classes=2, save=None):
super().__init__()
self.model = se_resnext50_32x4d(pretrained=None)
self.model.load_state_dict(
torch.load(weights_path, map_location=device))
if save is not None:
torch.save(self.model.state_dict(), save)
self.model.avg_pool = nn.AdaptiveAvgPool2d(1)
self.model.last_linear = nn.Linear(self.model.last_linear.in_features,
n_classes)
def __init__(self,
num_classes=5,
num_filters=32,
cls_only=False,
is_deconv=False):
super().__init__()
self.num_classes = num_classes
self.pool = nn.MaxPool2d(2, 2)
self.encoder = se_resnext50_32x4d()
self.relu = nn.ReLU(inplace=True)
self.conv1 = self.encoder.layer0
self.conv2 = self.encoder.layer1
self.conv3 = self.encoder.layer2
self.conv4 = self.encoder.layer3
self.conv5 = self.encoder.layer4
self.cls_only = cls_only
self.classifer = nn.Sequential(
se_resnext50_32x4d().layer4,
nn.Conv2d(2048, 2, 1, stride=1, padding=1, bias=True),
GlobalAvgPool2d())
self.center = DecoderBlockBN(2048, num_filters * 8 * 2,
num_filters * 8, is_deconv)
self.dec5 = DecoderBlockBN(2048 + num_filters * 8, num_filters * 8 * 2,
num_filters * 8, is_deconv)
self.dec4 = DecoderBlockBN(1024 + num_filters * 8, num_filters * 8 * 2,
num_filters * 8, is_deconv)
self.dec3 = DecoderBlockBN(512 + num_filters * 8, num_filters * 4 * 2,
num_filters * 2, is_deconv)
self.dec2 = DecoderBlockBN(256 + num_filters * 2, num_filters * 2 * 2,
num_filters * 2 * 2, is_deconv)
self.dec1 = DecoderBlockBN(num_filters * 2 * 2, num_filters * 2 * 2,
num_filters, is_deconv)
self.dec0 = ConvReluBn(num_filters, num_filters)
self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
self.drop = nn.Dropout2d(0.3)
def __init__(self, arch, num_classes=1, pretrained=True):
super().__init__()
# load EfficientNet
if arch == 'se_resnext50_32x4d':
if pretrained:
self.base = se_resnext50_32x4d()
else:
self.base = se_resnext50_32x4d(pretrained=None)
self.nc = self.base.last_linear.in_features
elif arch == 'se_resnext101_32x4d':
if pretrained:
self.base = se_resnext101_32x4d()
else:
self.base = se_resnext101_32x4d(pretrained=None)
self.nc = self.base.last_linear.in_features
elif arch == 'inceptionv4':
if pretrained:
self.base = inceptionv4()
else:
self.base = inceptionv4(pretrained=None)
self.nc = self.base.last_linear.in_features
elif arch == 'inceptionresnetv2':
if pretrained:
self.base = inceptionresnetv2()
else:
self.base = inceptionresnetv2(pretrained=None)
self.nc = self.base.last_linear.in_features
self.logit = nn.Sequential(AdaptiveConcatPool2d(1), Flatten(),
nn.BatchNorm1d(2 * self.nc),
nn.Dropout(0.5),
nn.Linear(2 * self.nc, 512), Mish(),
nn.BatchNorm1d(512), nn.Dropout(0.5),
nn.Linear(512, 1))
def __init__(self, num_class, pretrain=True):
super(multiscale_se_resnext_HR, self).__init__()
self.base_model = se_resnext50_32x4d(9, None)
if pretrain == True:
print(
"load model from /home/zxw/2019BaiduXJTU/se_resnext50_32x4d-a260b3a4.pth"
)
state_dict = torch.load(
'/home/zxw/2019BaiduXJTU/se_resnext50_32x4d-a260b3a4.pth')
state_dict.pop('last_linear.bias')
state_dict.pop('last_linear.weight')
self.base_model.load_state_dict(state_dict, strict=False)
self.avgpool = nn.AdaptiveAvgPool2d(output_size=1)
def __init__(self, num_classes=1):
super(model50A_DeepSupervion, self).__init__()
self.num_classes = num_classes
self.encoder = se_resnext50_32x4d()
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Sequential(self.encoder.layer0.conv1,
self.encoder.layer0.bn1,
self.encoder.layer0.relu1)
self.conv2 = self.encoder.layer1
self.conv3 = self.encoder.layer2
self.conv4 = self.encoder.layer3
self.conv5 = self.encoder.layer4
self.center_global_pool = nn.AdaptiveAvgPool2d([1,1])
self.center_conv1x1 = nn.Conv2d(512*4, 64, kernel_size=1)
self.center_fc = nn.Linear(64, 2)
self.center = nn.Sequential(nn.Conv2d(512*4, 512, kernel_size=3,padding=1),
nn.BatchNorm2d(512),
nn.ReLU(inplace=True),
nn.Conv2d(512, 256, kernel_size=3, padding=1),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2,stride=2))
self.decoder5 = Decoder(256 + 512*4, 512, 64)
self.decoder4 = Decoder(64 + 256*4, 256, 64)
self.decoder3 = Decoder(64 + 128*4, 128, 64)
self.decoder2 = Decoder(64 + 64*4, 64, 64)
self.decoder1 = Decoder(64, 32, 64)
self.logits_no_empty = nn.Sequential(nn.Conv2d(320, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(64, 1, kernel_size=1, padding=0))
self.logits_final = nn.Sequential(nn.Conv2d(320+64, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(64, 1, kernel_size=1, padding=0))
def create_model(config: Any, pretrained: bool) -> Any:
dropout = config.model.dropout
# support the deprecated model
if config.version == '2b_se_resnext50':
model = se_resnext50_32x4d(
pretrained='imagenet' if pretrained else None)
model.avg_pool = nn.AdaptiveAvgPool2d(1)
model.last_linear = nn.Linear(model.last_linear.in_features,
config.model.num_classes)
model = torch.nn.DataParallel(model)
return model
if not IN_KERNEL:
model = get_model(config.model.arch, pretrained=pretrained)
else:
model = get_model(config.model.arch,
pretrained=pretrained,
root='../input/pytorchcv-models/')
if config.model.arch == 'xception':
model.features[-1].pool = nn.AdaptiveAvgPool2d(1)
else:
model.features[-1] = nn.AdaptiveAvgPool2d(1)
if config.model.arch == 'pnasnet5large':
if dropout == 0.0:
model.output = nn.Linear(model.output[-1].in_features,
config.model.num_classes)
else:
model.output = nn.Sequential(
nn.Dropout(dropout),
nn.Linear(model.output[-1].in_features,
config.model.num_classes))
elif config.model.arch == 'xception':
if dropout < 0.1:
model.output = nn.Linear(2048, config.model.num_classes)
else:
model.output = nn.Sequential(
nn.Dropout(dropout), nn.Linear(2048, config.model.num_classes))
elif config.model.arch.startswith('inception'):
if dropout < 0.1:
model.output = nn.Linear(model.output[-1].in_features,
config.model.num_classes)
else:
model.output = nn.Sequential(
nn.Dropout(dropout),
nn.Linear(model.output[-1].in_features,
config.model.num_classes))
else:
if dropout < 0.1:
model.output = nn.Linear(model.output.in_features,
config.model.num_classes)
else:
model.output = nn.Sequential(
nn.Dropout(dropout),
nn.Linear(model.output.in_features, config.model.num_classes))
model = torch.nn.DataParallel(model)
return model
def initialize_model(model_name,
embedding_dim,
feature_extracting,
use_pretrained=True):
if model_name == "densenet161":
model_ft = models.densenet161(pretrained=use_pretrained,
memory_efficient=True)
set_parameter_requires_grad(model_ft, feature_extracting)
#print(model_ft)
num_features = model_ft.classifier.in_features
print(num_features)
#print(embedding_dim)
model_ft.classifier = nn.Linear(num_features, embedding_dim)
#print(model_ft)
if model_name == "densenet169":
model_ft = models.densenet161(pretrained=use_pretrained,
memory_efficient=True)
set_parameter_requires_grad(model_ft, feature_extracting)
#print(model_ft)
num_features = model_ft.classifier.in_features
print(num_features)
#print(embedding_dim)
model_ft.classifier = nn.Linear(num_features, embedding_dim)
#print(model_ft)
if model_name == "densenet121":
model_ft = models.densenet121(pretrained=use_pretrained,
memory_efficient=True)
set_parameter_requires_grad(model_ft, feature_extracting)
#print(model_ft)
num_features = model_ft.classifier.in_features
print(num_features)
#print(embedding_dim)
model_ft.classifier = nn.Linear(num_features, embedding_dim)
#print(model_ft)
if model_name == "densenet201":
model_ft = models.densenet201(pretrained=use_pretrained,
memory_efficient=True)
set_parameter_requires_grad(model_ft, feature_extracting)
#print(model_ft)
num_features = model_ft.classifier.in_features
print(num_features)
#print(embedding_dim)
model_ft.classifier = nn.Linear(num_features, embedding_dim)
#print(model_ft)
elif model_name == "resnet101":
model_ft = models.resnet101(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extracting)
num_features = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_features, embedding_dim)
print(model_ft)
elif model_name == "resnet34":
model_ft = models.resnet34(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extracting)
num_features = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_features, embedding_dim)
print(model_ft)
elif model_name == "adl_resnet50":
model_ft = adl_resnet50(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extracting)
num_features = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_features, embedding_dim)
print(model_ft)
elif model_name == "inceptionv3":
model_ft = models.inception_v3(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extracting)
num_features = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_features, embedding_dim)
elif model_name == "seresnext":
model_ft = se_resnext101_32x4d(num_classes=1000)
set_parameter_requires_grad(model_ft, feature_extracting)
num_features = model_ft.last_linear.in_features
model_ft.last_linear = nn.Linear(num_features, embedding_dim)
elif model_name == "seresnext50":
model_ft = se_resnext50_32x4d(num_classes=1000)
set_parameter_requires_grad(model_ft, feature_extracting)
num_features = model_ft.last_linear.in_features
model_ft.last_linear = nn.Linear(num_features, embedding_dim)
elif model_name == "googlenet":
model_ft = models.googlenet(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extracting)
#print(model_ft)
num_features = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_features, embedding_dim)
elif model_name == "mobilenet2":
model_ft = models.MobileNetV2(pretrained=use_pretrained)
set_parameter_requires_grad(model_ft, feature_extracting)
num_features = model_ft.classifier[1].in_features
model_ft.classifier[1] = nn.Linear(num_features, embedding_dim)
print(model_ft)
elif model_name == "mnasnet":
model_ft = mnasnet1_0(pretrained=use_pretrained)
#model_ft = MnasNet()
set_parameter_requires_grad(model_ft, feature_extracting)
print(model_ft.classifier[0])
print(model_ft.classifier[1])
num_features = model_ft.classifier[1].in_features
print(num_features)
print(embedding_dim)
#model_ft.classifier[0] = nn.Dropout(p=0.2, inplace=False)
model_ft.classifier[1] = nn.Linear(num_features, embedding_dim)
print(model_ft)
elif model_name == "adl_googlenet":
model_ft = GoogLeNet()
set_parameter_requires_grad(model_ft, feature_extracting)
print(model_ft)
num_features = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_features, embedding_dim)
else:
raise ValueError
return model_ft
import torchvision.datasets as datasets
from tensorboardX import SummaryWriter
DATA_DIR = "/home/krf/dataset/BALL/"
traindir = DATA_DIR + "train"
valdir = DATA_DIR + "val"
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
BATCH_SIZE = 32
WORKERS = 4
START = 0
EPOCHS = 700
PRINT_FREQ = 10
# In[31]:
model = senet.se_resnext50_32x4d(num_classes=2)
#通过随机变化来进行数据增强
train_tf = TransformImage(model,
random_crop=True,
random_hflip=True,
random_vflip=True,
random_rotate=True,
preserve_aspect_ratio=True)
train_loader = torch.utils.data.DataLoader(
# datasets.ImageFolder(traindir, transforms.Compose([
# # transforms.RandomSizedCrop(max(model.input_size)),
# transforms.RandomHorizontalFlip(),
# transforms.ToTensor(),
# normalize,
# ])),
datasets.ImageFolder(traindir, train_tf),