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)
