def __init__(self, data, label, partial_loss, is_training): with tf.variable_scope('autoencoder'): #self._autoencoder = bae.BasicAE() self._autoencoder = dcae.DeepCAE( layer_low_bound=-FLAGS.PIXEL_THRESHOLD, layer_up_bound=FLAGS.PIXEL_THRESHOLD) self._autoencoder_prediction = data + self._autoencoder.prediction( data, is_training) with tf.variable_scope('target') as scope: self._target_adv = resnet.resnet18() #self._target_adv = resnet.resnet18() self._target_adv_logits, self._target_adv_prediction = self._target_adv.prediction( self._autoencoder_prediction) self._target_adv_accuracy = self._target_adv.accuracy( self._target_adv_prediction, label) with tf.variable_scope(scope, reuse=True): self._target_attack = resnet.resnet18() self.data_fake = fgm(self._target_attack.prediction, data, label, eps=FLAGS.EPSILON, iters=FLAGS.FGM_ITERS) with tf.variable_scope(scope, reuse=True): self._target_fake = resnet.resnet18() self._target_fake_logits, self._target_fake_prediction = self._target_fake.prediction( self.data_fake) self.label_fake = self.get_label(self._target_fake_prediction) self._target_fake_accuracy = self._target_fake.accuracy( self._target_fake_prediction, label) with tf.variable_scope(scope, reuse=True): self._target = resnet.resnet18() self._target_logits, self._target_prediction = self._target.prediction( data) self._target_accuracy = self._target.accuracy( self._target_prediction, label) self.data = data self.label = label self.partial_loss = partial_loss self.loss_x self.loss_y self.prediction
def __init__(self, num_points = 2048, bottleneck_size = 1024, nb_primitives = 1, pretrained_encoder=False): super(SVR_AtlasNet_SPHERE, self).__init__() self.num_points = num_points self.pretrained_encoder = pretrained_encoder self.bottleneck_size = bottleneck_size self.nb_primitives = nb_primitives self.encoder = resnet.resnet18(pretrained=self.pretrained_encoder, num_classes=1024) self.decoder = nn.ModuleList([PointGenCon(bottleneck_size = 3 +self.bottleneck_size) for i in range(0,self.nb_primitives)])
def build_encoder(self, arch='resnet', weights=''): if arch == 'resnet': net_encoder = ResnetEncoder(resnet.resnet18()) elif arch == 'vgg': net_encoder = VGGEncoder() if len(weights) > 0: net_encoder.load_state_dict( torch.load(weights, map_location=lambda storage, loc: storage)) return net_encoder
def __init__(self, feature_size, n_classes): super(Resnet18, self).__init__() self.feature_extractor = resnet18() self.feature_extractor.fc =\ nn.Linear(self.feature_extractor.fc.in_features, feature_size) self.bn = nn.BatchNorm1d(feature_size, momentum=0.01) self.ReLU = nn.ReLU() self.fc = nn.Linear(feature_size, n_classes, bias=False)
def __init__(self,**kwargs): super(Net, self).__init__(); self.resnet = resnet.resnet18(pretrained=False,input_channel=4,num_classes=312); self.model = nn.Sequential( *block(624,1024,False), *block(1024,256,False), nn.Linear(256,3) ); self._init_layers();
def init_net(self): net_args = { "pretrained": True, "n_input_channels": len(self.kwargs["static"]["imagery_bands"]) } # https://pytorch.org/docs/stable/torchvision/models.html if self.kwargs["net"] == "resnet18": self.model = resnet.resnet18(**net_args) elif self.kwargs["net"] == "resnet34": self.model = resnet.resnet34(**net_args) elif self.kwargs["net"] == "resnet50": self.model = resnet.resnet50(**net_args) elif self.kwargs["net"] == "resnet101": self.model = resnet.resnet101(**net_args) elif self.kwargs["net"] == "resnet152": self.model = resnet.resnet152(**net_args) elif self.kwargs["net"] == "vgg11": self.model = vgg.vgg11(**net_args) elif self.kwargs["net"] == "vgg11_bn": self.model = vgg.vgg11_bn(**net_args) elif self.kwargs["net"] == "vgg13": self.model = vgg.vgg13(**net_args) elif self.kwargs["net"] == "vgg13_bn": self.model = vgg.vgg13_bn(**net_args) elif self.kwargs["net"] == "vgg16": self.model = vgg.vgg16(**net_args) elif self.kwargs["net"] == "vgg16_bn": self.model = vgg.vgg16_bn(**net_args) elif self.kwargs["net"] == "vgg19": self.model = vgg.vgg19(**net_args) elif self.kwargs["net"] == "vgg19_bn": self.model = vgg.vgg19_bn(**net_args) else: raise ValueError("Invalid network specified: {}".format( self.kwargs["net"])) # run type: 1 = fine tune, 2 = fixed feature extractor # - replace run type option with "# of layers to fine tune" if self.kwargs["run_type"] == 2: layer_count = len(list(self.model.parameters())) for layer, param in enumerate(self.model.parameters()): if layer <= layer_count - 5: param.requires_grad = False # Parameters of newly constructed modules have requires_grad=True by default # get existing number for input features # set new number for output features to number of categories being classified # see: https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html if "resnet" in self.kwargs["net"]: num_ftrs = self.model.fc.in_features self.model.fc = nn.Linear(num_ftrs, self.ncats) elif "vgg" in self.kwargs["net"]: num_ftrs = self.model.classifier[6].in_features self.model.classifier[6] = nn.Linear(num_ftrs, self.ncats)
def build_model(self): self.model = resnet18() self.model.build(input_shape=(None, 32, 32, 3)) self.model.summary() self.model.compile( optimizer=tf.keras.optimizers.Adam(self.learning_rate), loss=tf.losses.CategoricalCrossentropy(from_logits=True), metrics=['accuracy'])
def __init__(self, num_points = 2048, bottleneck_size = 512, nb_primitives = 5, pretrained_encoder = False, cuda=True): super(SVR_CurSkeNet, self).__init__() self.usecuda = cuda self.num_points = num_points self.bottleneck_size = bottleneck_size self.nb_primitives = nb_primitives self.pretrained_encoder = pretrained_encoder self.encoder = resnet.resnet18(pretrained=self.pretrained_encoder, num_classes=self.bottleneck_size) self.decoder = nn.ModuleList([PointGenCon(bottleneck_size = 1 +self.bottleneck_size) for i in range(0, self.nb_primitives)])
def main(data_list): with open(data_list, 'r') as f: data = f.readlines() net = resnet18(pretrained=True) for item in data: img1_path, img2_path = item[:-1].split(' ') img1 = cv2.imread(img1_path) img2 = cv2.imread(img2_path) resnet_feature(net, img1, img2) print(img1_path)
def __init__(self, num_classes): super(ResNet_ft, self).__init__() modelPreTrain = resnet.resnet18(pretrained=True) self.model = modelPreTrain modelPreTrain2 = resnet.resnet18(pretrained=True) self.model2 = modelPreTrain2 self.num_classes = num_classes self.conv1 = nn.Conv2d(8, 64, kernel_size=7, stride=1, padding=3, bias=False) self.conv1.weight.data[:, 0:3, :, :] = self.model.conv1.weight.data self.conv1.weight.data[:, 3:6, :, :] = self.model.conv1.weight.data self.conv1.weight.data[:, 6: 8, :, :] = self.model.conv1.weight.data[:, 0: 2, :, :] self.conv2 = nn.Conv2d(10, 64, kernel_size=7, stride=1, padding=3, bias=False) self.conv2.weight.data[:, 0:3, :, :] = self.model.conv1.weight.data self.conv2.weight.data[:, 3:6, :, :] = self.model.conv1.weight.data self.conv2.weight.data[:, 6:9, :, :] = self.model.conv1.weight.data self.conv2.weight.data[:, 9, :, :] = self.model.conv1.weight.data[:, 0, :, :] #self.conv2 = conv3x3(3,16) #self.relu = nn.ReLU(inplace=True) #self.bn1 = nn.BatchNorm2d(3) self.avg_pool = nn.AdaptiveAvgPool2d((1, 1)) self.bn1 = nn.BatchNorm1d(512) self.bn2 = nn.BatchNorm1d(512) #self.classifier1 = nn.Linear(512, num_classes) #self.classifier2 = nn.Linear(512, num_classes) self.classifier1 = AngleLinear(512, self.num_classes) self.classifier2 = AngleLinear(512, self.num_classes)
def __init__(self,gpu=None): super(CascadedNet, self).__init__() self.gpu = gpu self.resnet18 = resnet18() self.m1 = HandNet() self.m2 = HandNet() self.m3 = HandNet() self.m4 = HandNet() self.m5 = HandNet2() self.criterion = nn.MSELoss()
def __init__(self, pretrained=True): super(TrackModel, self).__init__() self.feature_extractor = resnet.resnet18(pretrained=pretrained).cuda() for param in self.feature_extractor.parameters(): param.requires_grad = False self.actor = Actor(state_dim=256, action_space=2).cuda() self.critic = Critic(state_dim=256, action_dim=1).cuda() self.rnn = nn.LSTM(input_size=256, hidden_size=256, num_layers=1).cuda() self.hidden_size = 256 self.fc = nn.Linear(512, 256)
def __init__(self): super().__init__() self.encoder = resnet18() num_classes = 1 self.classifier = nn.Conv2d(512, num_classes, kernel_size=3, padding=1, bias=False) self.input_shape = (800, 800)
def generate_latent_space(dataset_type='fullset'): """ Generates the latent space of CIFAR10 using the last hidden layer of a trained ResNet. Keyword arguments: dataset_type -- Either 'fullset' to generate latent space on full dataset, or 'subset' to generate latent space on subset of 20000 Outputs: Saves resulting latent space as CSV file. """ mean = (0.4914, 0.4822, 0.4465) std = (0.2471, 0.2435, 0.2616) #preprocessing transform = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean, std) ]) if (dataset_type == 'fullset'): train_dataset = dataset_manager.CIFAR10_full(dataset_manager.__file__, transform=transform) elif (dataset_type == 'subset'): train_dataset = dataset_manager.CIFAR10_Subset( dataset_manager.__file__, transform=transform) else: print( "generate_latent_space: dataset type error: You have to choose either 'fullset' or 'subset'." ) return device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') if device == 'cpu': print( "Warning: We did not detect a CUDA core. This could take a while.") net = resnet18(pretrained=True) #transform all datapoints to a latent representation latent_data = [] print("Generating latent space...") with tqdm(total=len(train_dataset)) as pbar: for i in range(len(train_dataset)): datapoint = train_dataset[i][0].reshape(1, 3, 32, 32) latent_data.append(net.encode(datapoint).detach().numpy()[0]) pbar.update(1) filename = 'CIFAR10_latent_data_{}.csv'.format(dataset_type) print("Saving ", filename, "...") latent_data = np.array(latent_data) np.savetxt(filename, latent_data, delimiter=',')
def __init__(self): super(WordDetectorNet, self).__init__() self.backbone = resnet18() self.up1 = UpscaleAndConcatLayer(512, 256, 256) # input//16 self.up2 = UpscaleAndConcatLayer(256, 128, 128) # input//8 self.up3 = UpscaleAndConcatLayer(128, 64, 64) # input//4 self.up4 = UpscaleAndConcatLayer(64, 64, 32) # input//2 self.conv1 = torch.nn.Conv2d(32, MapOrdering.NUM_MAPS, 3, 1, padding=1)
def __init__(self, backbone='resnet18', pretrained_base=True, norm_layer=nn.BatchNorm2d, **kwargs): super(ContextPath, self).__init__() if backbone == 'resnet18': pretrained = resnet18(pretrained=pretrained_base, **kwargs) elif backbone == 'resnet34': pretrained = resnet34(pretrained=pretrained_base, **kwargs) elif backbone == 'resnet50': pretrained = resnet50(pretrained=pretrained_base, **kwargs) else: raise RuntimeError('unknown backbone: {}'.format(backbone)) self.conv1 = pretrained.conv1 self.bn1 = pretrained.bn1 self.relu = pretrained.relu self.maxpool = pretrained.maxpool self.layer1 = pretrained.layer1 self.layer2 = pretrained.layer2 self.layer3 = pretrained.layer3 self.layer4 = pretrained.layer4 inter_channels = 128 if backbone == 'resnet50': in_channels_1 = 2048 in_channels_2 = 1024 else: in_channels_1 = 512 in_channels_2 = 256 self.global_context = _GlobalAvgPooling(in_channels_1, inter_channels, norm_layer) self.arms = nn.ModuleList([ AttentionRefinmentModule(in_channels_1, inter_channels, norm_layer, **kwargs), AttentionRefinmentModule(in_channels_2, inter_channels, norm_layer, **kwargs) ]) self.refines = nn.ModuleList([ _ConvBNReLU(inter_channels, inter_channels, 3, 1, 1, norm_layer=norm_layer), _ConvBNReLU(inter_channels, inter_channels, 3, 1, 1, norm_layer=norm_layer) ])
def __init__(self,action_space=10): super(Model,self).__init__() self.encoder = resnet.resnet18() self.decoder = torch.nn.Sequential( nn.Linear(1000,512), nn.ReLU(), nn.Linear(512,256), nn.ReLU(), nn.Linear(256,action_space) )
def __init__(self, bottleneck_size=1024): super(SVR_TMNet, self).__init__() self.bottleneck_size = bottleneck_size self.encoder = resnet.resnet18(num_classes=self.bottleneck_size) self.decoder = nn.ModuleList( [DeformNet(bottleneck_size=3 + self.bottleneck_size)]) self.decoder2 = nn.ModuleList( [DeformNet(bottleneck_size=3 + self.bottleneck_size)]) self.estimate = Estimator(bottleneck_size=3 + self.bottleneck_size) self.estimate2 = Estimator(bottleneck_size=3 + self.bottleneck_size) self.refine = Refiner(bottleneck_size=3 + self.bottleneck_size)
def __init__(self, pretrained_encoder=False, bottleneck_size = 512): super(ResNetfeat, self).__init__() self.pretrained_encoder = pretrained_encoder self.bottleneck_size = bottleneck_size self.extractor = resnet.resnet18(pretrained=self.pretrained_encoder, num_classes=1024) self.fc1 = nn.Sequential(nn.Linear(1024, self.bottleneck_size), nn.BatchNorm1d(self.bottleneck_size), nn.ReLU()) self.fc2 = nn.Sequential(nn.Linear(1024, self.bottleneck_size), nn.BatchNorm1d(self.bottleneck_size), nn.ReLU())
def __init__(self, pretrained_encoder=False, num_points_line = 2048, num_points_square = 2048, bottleneck_size = 512, nb_primitives_line = 1, nb_primitives_square = 1): super(SVR_CurSur_Joint, self).__init__() self.num_points_line = num_points_line self.num_points_square = num_points_square self.bottleneck_size = bottleneck_size self.nb_primitives_line = nb_primitives_line self.nb_primitives_square = nb_primitives_square self.pretrained_encoder = pretrained_encoder self.encoder = resnet.resnet18(pretrained=self.pretrained_encoder, num_classes=self.bottleneck_size) self.decoder_line = nn.ModuleList([PointGenCon(bottleneck_size = 1 +self.bottleneck_size) for i in range(0,self.nb_primitives_line)]) self.decoder_square = nn.ModuleList([PointGenCon(bottleneck_size = 2 +self.bottleneck_size) for i in range(0,self.nb_primitives_square)])
def __init__(self, n_class): super(ResNetUNet, self).__init__() self.base_model = resnet18(pretrained=True) self.base_layers = list(self.base_model.children()) self.layer0 = nn.Sequential( *self.base_layers[:3]) # size=(N, 64, x.H/2, x.W/2) self.layer0_1x1 = convrelu(64, 64, 1, 0) self.layer1 = nn.Sequential( *self.base_layers[3:5]) # size=(N, 64, x.H/4, x.W/4) self.layer1_1x1 = convrelu(64, 64, 1, 0) self.layer2 = self.base_layers[5] # size=(N, 128, x.H/8, x.W/8) self.layer2_1x1 = convrelu(128, 128, 1, 0) self.layer3 = self.base_layers[6] # size=(N, 256, x.H/16, x.W/16) self.layer3_1x1 = convrelu(256, 256, 1, 0) self.layer4 = self.base_layers[7] # size=(N, 512, x.H/32, x.W/32) self.layer4_1x1 = convrelu(512, 256 + 512, 1, 0) self.layer0_2 = copy.deepcopy(self.layer0) self.layer1_2 = copy.deepcopy(self.layer1) self.layer2_2 = copy.deepcopy(self.layer2) self.layer3_2 = copy.deepcopy(self.layer3) self.layer4_2 = copy.deepcopy(self.layer4) self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) self.upsample_2 = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) self.conv_up3 = convrelu(256 + 512, 128 + 512, 3, 1) self.conv_up2 = convrelu(128 + 512, 64 + 256, 3, 1) self.conv_up1 = convrelu(64 + 256, 64 + 256, 3, 1) self.conv_up0 = convrelu(64 + 256, 64 + 128, 3, 1) self.conv_up3_2 = convrelu(512, 512, 3, 1) self.conv_up2_2 = convrelu(512, 256, 3, 1) self.conv_up1_2 = convrelu(256, 256, 3, 1) self.conv_up0_2 = convrelu(256, 128, 3, 1) self.conv_original_size0 = convrelu(3, 64, 3, 1) self.conv_original_size1 = convrelu(64, 64, 3, 1) self.conv_original_size2 = convrelu(64 + 128, 64, 3, 1) self.conv_original_size0_2 = convrelu(3, 64, 3, 1) self.conv_original_size1_2 = convrelu(64, 64, 3, 1) self.conv_original_size2_2 = convrelu(128, 64, 3, 1) self.conv_last = nn.Conv2d(64, n_class, 1) self.conv_last_2 = nn.Conv2d(64, n_class, 1)
def __init__(self, bottleneck_size=1024, num_points=2500): super(Pretrain, self).__init__() self.bottleneck_size = bottleneck_size self.num_points = num_points self.pc_encoder = nn.Sequential( PointNetfeat(self.num_points, global_feat=True, trans=False), nn.Linear(1024, self.bottleneck_size), nn.BatchNorm1d(self.bottleneck_size), nn.ReLU()) self.encoder = resnet.resnet18(num_classes=self.bottleneck_size) self.decoder = nn.ModuleList( [DeformNet(bottleneck_size=3 + self.bottleneck_size)])
def __init__(self, num_input_channels=3, num_output_channels=1): super().__init__() self.resnet18 = resnet.resnet18(num_input_channels=num_input_channels) self.conv1 = nn.Conv2d(512, 128, kernel_size=1, stride=1) self.bn1 = nn.BatchNorm2d(128) self.conv2 = nn.Conv2d(128, 32, kernel_size=1, stride=1) self.bn2 = nn.BatchNorm2d(32) self.conv3 = nn.Conv2d(32, num_output_channels, kernel_size=1, stride=1)
def load_resnet_transfer(model_path): resnet = resnet18() resnet = resnet.cuda() resnet.load_state_dict(torch.load(model_path)) for name, p in resnet.named_parameters(): if 'fc' not in name: p.requires_grad = False print('freeze:', name) pass print('%s loaded for transfer.' % model_path.split('/')[-1]) return resnet
def Generator(net): if net == 'lenet': return lenet.Feature() if net == 'resnet18': return resnet.resnet18(pretrained=True) if net == 'resnet50': return resnet.resnet50(pretrained=True) if net == 'resnet101': return resnet.resnet101(pretrained=True) if net == 'alexnet': return alexnet.alexnet(pretrained=True)
def __init__(self, voxel_size=32, bottleneck_size=1024, pretrained_encoder=False): #1024 super(SVR_R2N2, self).__init__() self.voxel_size = voxel_size self.bottleneck_size = bottleneck_size self.pretrained_encoder = pretrained_encoder self.encoder = resnet.resnet18(pretrained=self.pretrained_encoder, num_classes=self.bottleneck_size) self.embedding = Embedding(bottleneck_size=self.bottleneck_size) self.decoder = VoxelDecoder()
def __init__(self, num_points=2048, bottleneck_size=1024, pretrained_encoder=False): super(SVR_Baseline, self).__init__() self.num_points = num_points self.bottleneck_size = bottleneck_size self.pretrained_encoder = pretrained_encoder self.encoder = resnet.resnet18(pretrained=self.pretrained_encoder, num_classes=bottleneck_size) self.decoder = PointDecoder(num_points=num_points, bottleneck_size=self.bottleneck_size)
def load_uvc_model(): net = resnet.resnet18() net.avgpool, net.fc = None, None ckpt = torch.load('uvc_checkpoint.pth.tar', map_location='cpu') state_dict = { k.replace('module.gray_encoder.', ''): v for k, v in ckpt['state_dict'].items() if 'gray_encoder' in k } net.load_state_dict(state_dict) return net
def _build_model(self): # Neural Net for Deep-Q learning Model # model = Sequential() # model.add(Dense(128, input_dim=self.state_size, activation='relu')) # model.add(Dense(123, activation='relu')) # model.add(Dense(self.action_size, activation='softmax')) model = resnet.resnet18(self.action_size) model.build(input_shape=(None, 32, 32, 3)) model.compile(loss=self._huber_loss, optimizer=Adam(lr=self.learning_rate)) return model
def main(): # [b,32,32,3]=>[b,1,1,512] model = resnet18() model.build(input_shape=(None, 32, 32, 3)) model.summary() #查看网络的参数 ###这里的代码在写神经网络时候基本可以不用变了### # 确定学习率0.0001 optimizer = optimizers.Adam(lr=1e-3) # 统计acc随着迭代而做出的变化 for epoch in range(200): for step, (x, y) in enumerate(train_db): with tf.GradientTape() as tape: # [b,32,32,3]=>[b,1,1,512] # 送入全连接层 logits = model(x) # 变为one_hot编码模式 y_onehot = tf.one_hot(y, depth=100) # compute loss loss = tf.losses.categorical_crossentropy(y_onehot, logits, from_logits=True) # 计算loss的平均值 loss = tf.reduce_mean(loss) # 对参数进行求导 grads = tape.gradient(loss, model.trainable_variables) # 针对所有的Variable根据给出的学习率进行求导 optimizer.apply_gradients(zip(grads, model.trainable_variables)) # 打印出来loss信息 if step % 100 == 0: print(epoch, step, 'loss:', float(loss)) total_num = 0 total_correct = 0 # 对测试集进行测试,观察正确率 for x, y in test_db: # 将测试集数据喂入已经训练好的神经网络中 logits = model(x) # 选出最有可能的分类 prob = tf.nn.softmax(logits, axis=1) pred = tf.argmax(prob, axis=1) pred = tf.cast(pred, dtype=tf.int32) # 计算准确预测的个数 correct = tf.cast(tf.equal(pred, y), dtype=tf.int32) correct = tf.reduce_sum(correct) # 计算准确率 total_num += x.shape[0] total_correct += int(correct) acc = total_correct / total_num print(epoch, 'acc:', acc)