def main(): global_config = efficientnet_configs['fanout'] net = EfficientNet(width_coeff=1, depth_coeff=1, dropout=0.2, num_classes=1000, global_config=global_config, out_indices=[2,3,4]) images = torch.rand((2, 3, 512, 512)) test_feature_type(net, images) test_feature_dimensions(net, images) test_feature_info(net, images) print("Model Layer Names") for n, m in net.named_modules(): print(n)
def __init__(self, compound_coef, load_weights=False, use_gpu=config['cuda'], crop_size=config['crop_size']): super(EfficientNet, self).__init__() model = EffNet.from_pretrained(f'efficientnet-b{compound_coef}', load_weights) del model._conv_head del model._bn1 # del model._avg_pooling # del model._dropout update_weight = False for name, param in model.named_parameters( ): # nn.Module有成员函数parameters() if "_blocks.10" in name: update_weight = True elif "_blocks.11" in name: update_weight = False if update_weight is False: param.requires_grad = False in_features = model._blocks_args[-1].output_filters out_features = 128 model._fc = nn.Linear(in_features, out_features) self.model = model self.use_gpu = use_gpu self.crop_size = crop_size
def base_model(images, metadata, fc_size, network_code, dropout_rate, fc_bottleneck=True): is_training = tf.placeholder(tf.bool) # create the base pre-trained model net = images if metadata.get_tensor_size()[-1] != 3: with tf.variable_scope("Preprocessing"): net = tf.layers.conv2d(net, filters=3, kernel_size=[3, 3], padding="SAME") # ** Efficient Net ** base_model = EfficientNet(model_name=network_code, num_classes=256) # use no specific scope net, endpoints = base_model.model(net, True) net = endpoints['global_pool'] # net = tf.layers.flatten(net) net = tf.reduce_mean(net, [1, 2]) if fc_bottleneck: with tf.variable_scope("FullyConnected_base"): # if self.isMultilabel: # net = tf.contrib.layers.fully_connected(net, num_outputs=self.number_of_labels*2) # #net = tf.layers.dropout(net, rate=self.dropout) # net = tf.reshape(net, [-1, self.number_of_labels, 2]) # else: # net = tf.contrib.layers.fully_connected(net, num_outputs=self.number_of_labels) # #net = tf.layers.dropout(net, rate=self.dropout) # net = tf.layers.dropout( # inputs=net, rate=0.3, # training=self.is_training) net = tf.layers.dense(inputs=net, units=fc_size, activation=tf.nn.relu) net = tf.layers.dropout(inputs=net, rate=dropout_rate, training=is_training) return net, is_training
def __init__(self, compound_coef, load_weights=False): super(EfficientNet, self).__init__() model = EffNet.from_pretrained(f'efficientnet-b{compound_coef}', load_weights) del model._conv_head del model._bn1 del model._avg_pooling del model._dropout del model._fc self.model = model
def __init__(self, compound_coef, class_num,load_weights=False): super(EfficientNet, self).__init__() model = EffNet.from_pretrained(f'efficientnet-b{compound_coef}', load_weights, num_classes=class_num) # del model._conv_head # del model._bn1 # del model._avg_pooling # del model._dropout # del model._fc self.model = model
def __init__(self): super().__init__() self.model = EfficientNet.from_pretrained("efficientnet-b1") #self.model = EfficientNet.from_name("efficientnet-b0") #for param in self.model.parameters(): #param.requires_grad = True self.dp1 = nn.Dropout(p=0.4) #self.ln1 = nn.Linear(in_features=1000, out_features=500, bias=True) self.ln1 = nn.Linear(in_features=1000, out_features=1, bias=True)
def __init__(self, compound_coef, load_weights=False, parallel_gpus=None): super(EfficientNet, self).__init__() model = EffNet.from_pretrained(f'efficientnet-b{compound_coef}', load_weights, parallel_gpus=parallel_gpus) del model._conv_head del model._bn1 del model._avg_pooling del model._dropout del model._fc self.model = model self.use_model_parallel = parallel_gpus is not None
def __init__(self, arch, 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 == '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 elif 'efficientnet' in arch: if pretrained: self.base = EfficientNet.from_pretrained(model_name=arch) else: self.base = EfficientNet.from_name(model_name=arch) self.nc = self.base._fc.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 get_trunk(self, architecture): if "efficientnet" in architecture.lower(): self.trunk = EfficientNet.from_pretrained( architecture, num_classes=self.MLP_neurons) elif "resnet" in architecture.lower(): if "18" in architecture.lower(): self.trunk = models.resnet18(pretrained=True) self.trunk.fc = nn.Linear(512, self.MLP_neurons) elif "50" in architecture.lower(): self.trunk = models.resnext50_32x4d(pretrained=True) self.trunk.fc = nn.Linear(2048, self.MLP_neurons) elif "mobilenet" in architecture.lower(): self.trunk = models.mobilenet_v2(pretrained=True) self.trunk.classifier[1] = torch.nn.Linear(1280, self.MLP_neurons)
testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # Model print('==> Building model..') if model == 'DenseNetWide': net = DenseNet(depth=106, k=13, num_classes=10) # 992,841 if model == 'DenseNetDeep': net = DenseNet(depth=117, k=12, num_classes=10) # 932,986 if model == 'EfficientNetB0': net = EfficientNet.from_pretrained('efficientnet-b0', num_classes=10) # 4,020,358 if model == 'EfficientNetB4': net = EfficientNet.from_pretrained('efficientnet-b4', num_classes=10) # 17,566,546 print('Number of parameters: ', count_parameters(net)) net = net.to(device) # Loss and optimizer criterion = nn.CrossEntropyLoss() if fine_tune: lr = args.lr optimizer = optim.SGD( [{ "params": chain(net._conv_stem.parameters(), net._bn0.parameters(), net._blocks.parameters()),
import time import numpy as np from efficientnet import EfficientNet from tinygrad.tensor import Tensor if __name__ == "__main__": Tensor.default_gpu = True model = EfficientNet() BS = 4 img = np.zeros((BS, 3, 224, 224), dtype=np.float32) st = time.time() out = model.forward(Tensor(img)) et = time.time() print("forward %.2f s" % (et - st)) y = np.zeros((BS, 1000), np.float32) y[range(y.shape[0]), Y] = -1000.0 y = Tensor(y) loss = out.logsoftmax().mul(y).mean() st = time.time() loss.backward() et = time.time() print("backward %.2f s" % (et - st))
from sklearn.metrics import accuracy_score, roc_auc_score from tqdm import tqdm import time from PIL import ImageFile ImageFile.LOAD_TRUNCATED_IMAGES = True opt = TestOptions().parse(print_options=False) print("{} from {} model testing on {}".format(opt.arch, opt.source_dataset, opt.target_dataset)) gpu_id = opt.gpu_id os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu_id) use_cuda = torch.cuda.is_available() print("GPU device %d:" % (gpu_id), use_cuda) model = EfficientNet.from_name(opt.arch, num_classes=opt.classes) if opt.resume: pretrained = opt.resume print("=> using pre-trained model '{}'".format(pretrained)) model.load_state_dict(torch.load(pretrained)['state_dict']) model.to('cuda') cudnn.benchmark = True print('Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) criterion = nn.CrossEntropyLoss().cuda() optimizer = optim.SGD(model.parameters(), lr=opt.lr, momentum=opt.momentum)
parser.add_argument('--epochs', default=10, type=int, help="number of epochs") parser.add_argument('--timm', action="store_true", help="Use TIMM implementation") args = parser.parse_args() # Cuda stuff device = 'cuda' if torch.cuda.is_available() else 'cpu' # Load the model if args.timm: import timm model = timm.create_model('efficientnet_b0', pretrained=False) else: model = EfficientNet(Config.B0, num_classes=10) model.to(device) # some data fun transform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ]) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ])
transform=train_transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10(root=root, train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2) model = EfficientNet.from_name('efficientnet-b0', first_stride=False, ktype='oneone', cifar=False) model._fc = nn.Linear(model._fc.in_features, 10) model = nn.DataParallel(model) model.cuda() # checkpoint = torch.load('/home/root1/PycharmProjects/ptt/checkpoint/69/box-can_0_0.8873.torch') # model.load_state_dict(checkpoint['net']) # del checkpoint criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD(model.parameters(), init_lr, momentum=0.9, weight_decay=1e-5) lr_schudule = MultiStepLR(optimizer, lr_step)
def get_efficientunet_b7(out_channels=2, concat_input=True, pretrained=True): encoder = EfficientNet.encoder('efficientnet-b7', pretrained=pretrained) model = EfficientUnet(encoder, out_channels=out_channels, concat_input=concat_input) return model
int(img_preparam[arch][0] / img_preparam[arch][1]), Image.BICUBIC), transforms.CenterCrop(img_preparam[arch][0]), transforms.ToTensor(), normalize ])) valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=128, shuffle=False, num_workers=16, pin_memory=False) num_batches = int( math.ceil(len(valid_loader.dataset) / float(valid_loader.batch_size))) os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3" model = EfficientNet(arch=arch, num_classes=1000).cuda() used_gpus = [idx for idx in range(torch.cuda.device_count())] model = torch.nn.DataParallel(model, device_ids=used_gpus).cuda() checkpoint = torch.load( "/home/liuhuijun/TrainLog/release/imagenet/efficientnet_{}_top1v_86.7.pkl" .format(arch)) pre_weight = checkpoint['model_state'] model_dict = model.state_dict() pretrained_dict = { "module." + k: v for k, v in pre_weight.items() if "module." + k in model_dict } model_dict.update(pretrained_dict) model.load_state_dict(model_dict)
action='store_true', default=False, help='if use the official pretrained model, default is True') opt = parser.parse_args() print(opt) gpus = [opt.gpu] if len(gpus) == 0: device = torch.device('cpu') else: if gpus[0] >= 0: device = torch.device('cuda:%d' % gpus[0]) else: device = torch.device('cpu') if 'efficientnet' in opt.arch: print('efficientnet image size') image_size = EfficientNet.get_image_size(opt.arch) else: print('not efficientnet image size') image_size = opt.imageSize dummy_input = torch.randn(64, 3, 224, 224, device=device) classi_model = cmodel.ClassiModel(opt.arch, gpus=[opt.gpu], num_classes=opt.num_classes, from_pretrained=opt.from_pretrained) if opt.model_url is not None: classi_model.loadmodel(opt.model_url, ifload_fc=True) torch.onnx.export(classi_model, dummy_input, "eff-b4-s-valid-855.onnx", verbose=True)
]) trainset = torchvision.datasets.ImageFolder(root + 'train', transform=train_transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=32) testset = torchvision.datasets.ImageFolder(root + 'val', transform=val_transform) testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=8) model = EfficientNet.from_name('efficientnet-b0') model = nn.DataParallel(model) model.cuda() # checkpoint = torch.load('/home/root1/PycharmProjects/ptt/checkpoint/69/box-can_0_0.8873.torch') # model.load_state_dict(checkpoint['net']) # del checkpoint criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD(model.parameters(), 1e-2, momentum=0.9, weight_decay=1e-5) lr_schudule = ExponentialLR(optimizer, 0.97) def train(train_loader, model, criterion, optimizer):
transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) data_dir = '~/data' trainset = torchvision.datasets.CIFAR10(root=data_dir, train=True, download=False) trainset = MultiTransDataset(trainset, transform_big, transform_small) testset = torchvision.datasets.CIFAR10(root=data_dir, train=False, download=False, transform=transform_test) trainloader = torch.utils.data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, num_workers=2) testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2) classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') net_big = EfficientNet.from_pretrained('efficientnet-b4', num_classes=10).to(device) net_big = torch.nn.DataParallel(net_big) cudnn.benchmark = True checkpoint = torch.load(checkpoint_dir_big) net_big.load_state_dict(checkpoint['net']) net_big.eval() if args.model == 'DenseNetWide': net_small = DenseNet(depth=106, k=13, num_classes=10).to(device) # <1m if args.model == 'DenseNetDeep': net_small = DenseNet(depth=117, k=12, num_classes=10).to(device) # <1m if not os.path.isdir(checkpoint_dir): os.mkdir(checkpoint_dir) log_file_name = os.path.join(checkpoint_dir, 'log.txt') log_file = open(log_file_name, "at")