def __init__(self,
layers=50,
bins=(1, 2, 3, 6),
classes=2,
dropout=0.1,
zoom_factor=8,
use_ppm=True,
is_training=True,
criterion=nn.BCELoss()
): #criterion=nn.CrossEntropyLoss(ignore_index=255)):
super(PSPNet, self).__init__()
assert layers in [50, 101, 152]
assert 2048 % len(bins) == 0
assert classes > 1
assert zoom_factor in [1, 2, 4, 8]
self.criterion = criterion
self.classes = classes
self.use_ppm = use_ppm
self.zoom_factor = zoom_factor
self.is_training = is_training
if layers == 50:
resnet = ResNet.resnet50()
elif layers == 101:
resnet = ResNet.resnet101()
elif layers == 152:
resnet = ResNet.resnet152()
self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu,
resnet.conv2, resnet.bn2, resnet.relu,
resnet.conv3, resnet.bn3, resnet.relu,
resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
fea_dim = 2048
if self.use_ppm:
self.ppm = PyramidPoolingModule(fea_dim, int(fea_dim / len(bins)),
bins)
fea_dim *= 2
self.cls = nn.Sequential(
nn.Conv2d(fea_dim, 512, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(512), nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout), nn.Conv2d(512,
self.classes,
kernel_size=1))
if self.training:
self.aux = nn.Sequential(
nn.Conv2d(1024, 256, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(256), nn.ReLU(inplace=True),
nn.Dropout2d(p=dropout),
nn.Conv2d(256, self.classes, kernel_size=1))
def load_or_create_neural_net():
file_path = './best_model_resnet.pth'
if os.path.exists(file_path):
print('loading already trained model')
best_player_so_far = ResNet.resnet18()
best_player_so_far.load_state_dict(torch.load(file_path))
else:
print('Trained model doesnt exist. Starting from scratch.')
best_player_so_far = ResNet.resnet18()
best_player_so_far.eval()
return best_player_so_far
def get_resnet_model(resnet_type=152):
"""
A function that returns the required pre-trained resnet model
:param resnet_number: the resnet type
:return: the pre-trained model
"""
if resnet_type == 18:
return ResNet.resnet18(pretrained=True, progress=True)
elif resnet_type == 50:
return ResNet.wide_resnet50_2(pretrained=True, progress=True)
elif resnet_type == 101:
return ResNet.resnet101(pretrained=True, progress=True)
else: #152
return ResNet.resnet152(pretrained=True, progress=True)
def __init__(self, segment_classes, level_classes, img_scale):
super(MDP_Net, self).__init__()
resnet = ResNet.resnet18()
self.segment_classes = segment_classes
self.level_classes = level_classes
# for param in resnet.parameters():
# param.requires_grad = False
self.layer0 = torch.nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
plane = resnet.fc.in_features
self.deconv1 = resnet_deconv(inplanes=plane,
layers=[2, 2, 2, 2],
out_classes=segment_classes,
init_scale=img_scale)
self.deconv2 = resnet_deconv(inplanes=plane,
layers=[2, 2, 2, 2],
out_classes=1,
init_scale=img_scale)
self.conv = torch.nn.Conv2d(in_channels=segment_classes + 1,
kernel_size=3,
out_channels=level_classes,
padding=1)
self.droutput1 = torch.nn.Dropout(p=0.8)
self.droutput2 = torch.nn.Dropout(p=0.8)
# self.sigmoid1 = torch.nn.Sigmoid()
self.sigmoid2 = torch.nn.Sigmoid()
def RetNet_Vision_Simple(inputs, keep_prob, seq_len, scope=None, reuse=None):
with tf.variable_scope(scope, 'Vision', [inputs], reuse=reuse):
seq_net = []
for idx in range(seq_len):
net = ResNet.inference(inputs[:,idx+1:LEFT_CONTEXT+idx+1,:,:,:],VISION_FEATURE_SIZE,keep_prob)
seq_net.append(net)
return tf.stack(seq_net, axis=1)
def __init__(self, pretrained=True, **kwargs):
super(UNetResNet34, self).__init__(**kwargs)
self.resnet = ResNet.resnet34(pretrained=pretrained)
self.conv1 = nn.Sequential(
self.resnet.conv1,
self.resnet.bn1,
self.resnet.relu,
) # 64
self.encoder1 = self.resnet.layer1 # 64
self.encoder2 = self.resnet.layer2 # 128
self.encoder3 = self.resnet.layer3 # 256
self.encoder4 = self.resnet.layer4 # 512
self.center = nn.Sequential(
nn.MaxPool2d(kernel_size=2, stride=2),
ConvBn2d(512, 1024, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
ConvBn2d(1024, 1024, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
)
self.decoder5 = Decoder(512 + 512, 512, 512, convT_channels=1024)
self.decoder4 = Decoder(256 + 256, 256, 256, convT_channels=512)
self.decoder3 = Decoder(128 + 128, 128, 128, convT_channels=256)
self.decoder2 = Decoder(64 + 64, 64, 64, convT_channels=128)
self.decoder1 = Decoder(32 + 64, 64, 32, convT_channels=64)
self.logit = nn.Sequential(
nn.Conv2d(32, 32, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(32, 1, kernel_size=1, padding=0),
)
def set_data(self):
self.initialized = False
mnist = input_data.read_data_sets("MNIST_data", reshape=False)
self.x_train, self.y_train = mnist.train.images, mnist.train.labels
self.x_validation, self.y_validation = mnist.validation.images, mnist.validation.labels
self.x_test, self.y_test = mnist.test.images, mnist.test.labels
assert len(self.x_train) == len(self.y_train)
assert len(self.x_validation) == len(self.y_validation)
assert len(self.x_test) == len(self.y_test)
self.image_batch.append(None)
self.image_batch += self.x_train[0].shape
with tf.variable_scope(self.variable_scope_base):
self.x_tensor = tf.placeholder(tf.float32, self.image_batch)
self.y_tensor = tf.placeholder(tf.int32)
self.y_one_hot_tensor = tf.one_hot(indices=tf.cast(
self.y_tensor, tf.int32),
depth=10)
resnet = ResNet.ResNet(self.resnet_size)
if resnet.build_resnet(self.x_tensor):
self.resnet = resnet.get_resnet()
else:
return
self.initialized = True
def set_model(self, N = 3, num_features = 2, num_classes = 2, func_f = torch.tanh, func_c =F.softmax, weights = None, bias = None, gpu=False, choice = None, gamma = 0.01):
"""
allows the user to set the model choices defaults to resnet
'a' - antisymmetric resnet
'v' - verlet integration
'l' - leapfrog integration
"""
self.choice = choice
#choosing model
if choice == None:
choice = self.choice
#choose resnet
if choice == 'a':
print("a")
self.model = anti.AntiSymResNet(self.device,N, num_features, num_classes, func_f, func_c, weights, bias, gamma, gpu)
elif choice == 'v':
print("v")
self.model = ver.Verlet(self.device,N, num_features, num_classes, func_f, func_c, weights, bias, gpu)
elif choice == 'l':
print("l")
self.model = lp.Leapfrog(self.device,N, num_features, num_classes, func_f, func_c, weights, bias, gpu)
else:
print("r")
self.model = res.ResNet(self.device,N, num_features, num_classes, func_f, func_c, weights, bias, gpu)
#set parameters to gpu
if gpu == True:
self.model.to(self.device)
def Predict():
NameList,LabelList=get_img_list()
ImageData=load_all_image(img_path,NameList, HEIGHT, WIDTH, CHANNELS)#加载所有图片到内存里面
num_train_image = len(NameList)#记录了所有图片数量
sess=tf.Session()
images = tf.placeholder(tf.float32, shape = [None, HEIGHT, WIDTH,CHANNELS])
labels = tf.placeholder(tf.float32, shape=[None, 1])
# 建立网络模型
resnet_model = resnet.ResNet(ResNet_npy_path = model_path)
resnet_model.build(images, 1)
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())#初始化所有参数
saver.restore(sess, model_path)
print("begin predicting!")
record=[]
index=0
minibatches = random_mini_batches(num_train_image, 1, random=False)
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = get_minibatch(minibatch, LabelList, HEIGHT, WIDTH, CHANNELS, 1,ImageData)
resnet_model.set_is_training(False)
recordprob= sess.run(resnet_model.prob, feed_dict={images: minibatch_X})
print("这是一个批次！")
for onerecord in recordprob:
print("imgname:", NameList[index], '----------possiblity:',onerecord[0])
saveonerecord = [str(NameList[index]), onerecord[0]]
index = index + 1
record.append(saveonerecord)
print("predicting over！")
analysis(record, 'predict的验证结果.csv')
return record
def main():
args = get_args()
root_dir = args.root_dir
imgs = list(os.walk(root_dir))[0][2]
save_dir = args.save_dir
num_classes = 100 # CIFAR100
model = ResNet.resnet(arch='resnet50', pretrained=False, num_classes=num_classes,
use_att=args.use_att, att_mode=args.att_mode)
#model = nn.DataParallel(model)
#print(model)
if args.resume:
if os.path.isfile(args.resume):
print(f'=> loading checkpoint {args.resume}')
checkpoint = torch.load(args.resume)
best_acc5 = checkpoint['best_acc5']
model.load_state_dict(checkpoint['state_dict'], strict=False)
print(f"=> loaded checkpoint {args.resume} (epoch {checkpoint['epoch']})")
print(f'=> best accuracy {best_acc5}')
else:
print(f'=> no checkpoint found at {args.resume}')
model_dict = get_model_dict(model, args.type)
normalizer = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
for img_name in imgs:
img_path = os.path.join(root_dir, img_name)
pil_img = PIL.Image.open(img_path)
torch_img = torch.from_numpy(np.asarray(pil_img))
torch_img = torch_img.permute(2, 0, 1).unsqueeze(0)
torch_img = torch_img.float().div(255)
torch_img = F.interpolate(torch_img, size=(224, 224), mode='bilinear', align_corners=False)
normalized_torch_img = normalizer(torch_img)
gradcam = GradCAM(model_dict, True)
gradcam_pp = GradCAMpp(model_dict, True)
mask, _ = gradcam(normalized_torch_img)
heatmap, result = visualize_cam(mask, torch_img)
mask_pp, _ = gradcam_pp(normalized_torch_img)
heatmap_pp, result_pp = visualize_cam(mask_pp, torch_img)
images = torch.stack([torch_img.squeeze().cpu(), heatmap, heatmap_pp, result, result_pp], 0)
images = make_grid(images, nrow=1)
if args.use_att:
save_dir = os.path.join(args.save_dir, 'att')
else:
save_dir = os.path.join(args.save_dir, 'no_att')
os.makedirs(save_dir, exist_ok=True)
output_name = img_name
output_path = os.path.join(save_dir, output_name)
save_image(images, output_path)
def __init__(self, pretrained=True, activation='relu', **kwargs):
super(RefineNetResNet34, self).__init__(**kwargs)
if activation == 'relu':
self.activation = nn.ReLU(inplace=True)
elif activation == 'elu':
self.activation = ELU_1(inplace=True)
self.resnet = ResNet.resnet34(pretrained=pretrained,
activation=self.activation)
self.conv1 = nn.Sequential(
self.resnet.conv1,
self.resnet.bn1,
self.resnet.activation,
) # 64
self.encoder1 = self.resnet.layer1 # 64
self.encoder2 = self.resnet.layer2 # 128
self.encoder3 = self.resnet.layer3 # 256
self.encoder4 = self.resnet.layer4 # 512
self.refine4 = RefineNetBlock(512, 512, skip_in=None, pool_mode='avg')
self.refine3 = RefineNetBlock(256, 256, skip_in=512, pool_mode='avg')
self.refine2 = RefineNetBlock(128, 128, skip_in=256, pool_mode='avg')
self.refine1 = RefineNetBlock(64, 64, skip_in=128, pool_mode='avg')
self.refine0 = RefineNetBlock(64, 32, skip_in=64, pool_mode='avg')
self.logit = nn.Sequential(
ResidualConvUnit(32),
ResidualConvUnit(32),
nn.Conv2d(32, 1, kernel_size=1, padding=0),
)
def __init__(self, num_classes, loss={'softmax,metric'}):
super(PCB, self).__init__()
class_num = num_classes
self.part = 4 # We cut the pool5 to 6 parts
model_ft = torchvision.models.resnet50(pretrained=False)
self.model = model_ft
self.avgpool = nn.AdaptiveAvgPool2d((self.part, 1))
self.dropout = nn.Dropout(p=0.5)
# remove the final downsample
self.model.layer4[0].downsample[0].stride = (1, 1)
self.model.layer4[0].conv2.stride = (1, 1)
# define 6 classifiers
for i in range(self.part):
name = 'classifier' + str(i)
setattr(
self, name,
ClassBlock(2048,
class_num,
droprate=0.5,
relu=False,
bnorm=True,
num_bottleneck=256))
#全局特征分类器
self.globePool = nn.AdaptiveAvgPool2d((1, 1))
self.classifier_globe = ClassBlock(2048, class_num, 0.5)
# 第二层特征分类器
self.classifier_21 = ClassBlock(2048, class_num, 0.5)
self.classifier_22 = ClassBlock(2048, class_num, 0.5)
self.SA1 = at.SpatialAttn()
def chooseModel(dataset,
device,
N,
func_f,
func_c,
gpu,
choice,
last=True,
conv=False,
first=True,
in_chns=1,
n_filters=6):
last = True
num_features, num_classes, in_channels = dataloader.getDims(dataset)
weights, bias = None, None
if choice == 'v':
print("v")
model = ver.Verlet(device, N, num_features, num_classes, func_f,
func_c, weights, bias, gpu, last, conv, first,
in_channels, n_filters)
else:
print("r")
model = res.ResNet(device, N, num_features, num_classes, func_f,
func_c, weights, bias, gpu, last, conv, first,
in_channels, n_filters)
return model
def __init__(self):
super(YOLOV0, self).__init__()
resnet = ResNet.resnet18(pretrained=True)
self.conv1 = resnet.conv1
self.bn1 = resnet.bn1
self.relu = resnet.relu
self.maxpool = resnet.maxpool
self.layer1 = resnet.layer1
self.layer2 = resnet.layer2
self.layer3 = resnet.layer3
self.layer4 = resnet.layer4
self.avgpool = nn.AdaptiveAvgPool2d((14, 14))
# 决策层：检测层
self.detector = nn.Sequential(
nn.Linear(512 * 14 * 14, 4096),
nn.ReLU(True),
nn.Dropout(),
# nn.Linear(4096,1470),
nn.Linear(4096, 24 * 14 * 14),
)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight,
mode='fan_out',
nonlinearity='relu')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 1)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.constant_(m.bias, 0)
def resnetTrain():
############################################################################
# use ResNet to training data
############################################################################
# Network architecture params
net_architecture_params = {
'num_classes': 2,
'num_filters': 128, #128
'num_blocks': 3,
'num_sub_blocks': 2,
'use_max_pool': True,
'input_shape': (256, 256, 3)
}
data_source_path = "D:/kaggle/detection/train_transform_256_2"
mymodel = ResNet.ResNetModel(data_source_path, training_params,
net_architecture_params)
mymodel.modelDefinition()
mymodel.modelSaveInfo('resnet_model.h5')
mymodel.modelTrain()
mymodel.loadSavedModel()
evaluation = mymodel.modelEvaluate()
evaluation_s = mymodel.modelEvaluate(saved_model=True)
mymodel.modelReset()
return evaluation, evaluation_s
def ValidRed2D(testloader, Bone, Network, path):
dice_value = []
if Network == 'UNet':
net = UNet().to(device)
elif Network == 'ResNet':
net = ResNet(BasicBlock, [3, 4, 6]).to(device)
net.load_state_dict(torch.load(path))
for i, data in enumerate(testloader, 0):
inputs, labels = data
inputs = inputs.to(device)
labels = labels.to(device)
outputs = net(inputs)
dice = 0.0
pr = labels[0].cpu().detach().numpy()
gt = outputs[0].cpu().detach().numpy()
gt[0, :, :][gt[0, :, :] <= 0.5] = 0
gt[0, :, :][gt[0, :, :] > 0.5] = 1
dice = dice + np.abs(
computeQualityMeasures(pr[0, :, :].flatten(),
gt[0, :, :].flatten()))
if (i == 1600):
plt.figure()
plt.imshow(inputs[0, 0, :, :].cpu().detach().numpy(),
cmap=plt.cm.gray,
interpolation="nearest",
vmin=-3,
vmax=2)
plt.imshow(outputs[0, 0, :, :].cpu().detach().numpy(),
'OrRd',
interpolation='none',
alpha=0.4)
plt.savefig(os.path.join(
ResultsDirectory, Bone, 'Images',
'patches_' + Network + '_' + Bone + str(i) + '.png'),
dpi=150)
plt.figure()
plt.imshow(inputs[0, 0, :, :].cpu().detach().numpy(),
cmap=plt.cm.gray,
interpolation="nearest",
vmin=-3,
vmax=2)
plt.imshow(labels[0, 0, :, :].cpu().detach().numpy(),
'OrRd',
interpolation='none',
alpha=0.4)
plt.savefig(os.path.join(
ResultsDirectory, Bone, 'Images',
'patches_Truth_' + Network + '_' + Bone + str(i) + '.png'),
dpi=150)
dice_value.append(dice)
np.savetxt(os.path.join(ResultsDirectory, Bone, 'DICE_test.txt'),
dice_value)
print('Standard Deviation:' + str(statistics.stdev(dice_value)))
print('Mean:' + str(statistics.mean(dice_value)))
def test_task1(root_path):
'''
:param root_path: root path of test data, e.g. ./dataset/task1/test/
:return results: a dict of classification results
results = {'audio_0000.pkl': 1, ‘audio_0001’: 3, ...}
class number:
‘061_foam_brick’: 0
'green_basketball': 1
'salt_cylinder': 2
'shiny_toy_gun': 3
'stanley_screwdriver': 4
'strawberry': 5
'toothpaste_box': 6
'toy_elephant': 7
'whiteboard_spray': 8
'yellow_block': 9
'''
results = dict()
os.chdir(os.path.split(os.path.realpath(__file__))[0])
audio_transforms = transforms.Compose([transforms.ToTensor()])
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
label_list = [9, 2, 3, 8, 7, 6, 5, 0, 4, 1]
model = ResNet.resnet18(num_classes=10)
model = model.to(device)
model = torch.nn.DataParallel(model)
model.load_state_dict(torch.load('./model/resnet18.pth'))
model.eval()
for sample in os.listdir(root_path):
data = np.load(os.path.join(root_path, sample),
allow_pickle=True)['audio']
for i in range(4):
S = librosa.resample(data[:, i], orig_sr=44100, target_sr=11000)
S = np.abs(librosa.stft(S[5650:-5650], n_fft=510, hop_length=128))
S = np.log10(S + 0.0000001)
S = np.clip(S, -5, 5)
S -= np.min(S)
S = 255 * (S / np.max(S))
if S.shape[-1] != 256:
S = np.pad(S, ((0, 0), (int(np.ceil((256 - S.shape[-1]) / 2)),
int(np.floor(
(256 - S.shape[-1]) / 2)))))
if i == 0:
feature = np.uint8(S)[:, :, np.newaxis]
else:
feature = np.concatenate(
(np.uint8(S)[:, :, np.newaxis], feature), axis=-1)
X = audio_transforms(feature)
X = X.to(device)
y_hat = torch.softmax(model(X.unsqueeze(0)),
dim=-1).argmax(dim=1).cpu().item()
results[sample] = label_list[y_hat]
return results
def pre(vir_path):
checkpoint = t.load('./checkpoint3', map_location=t.device('cpu'))
transforms = T.Compose([T.Resize((100, 100)), T.Grayscale(), T.ToTensor()])
model = ResNet(ResidualBlock)
model.load_state_dict(checkpoint['model_state_dict'])
model.eval()
img = transforms(Image.open(vir_path))
img = t.unsqueeze(img, dim=0)
if t.cuda.is_available():
model = model.cuda()
img = img.cuda()
output = model(img)
_, pred = t.max(output.data, 1)
num = pred.item()
char = list(char_dict.keys())[list(char_dict.values()).index(num)]
print(
'\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n您输入的汉字是：{}'
.format(char))
if char not in ass_dict.keys():
print('我脑袋小，这个字还暂时没有联想到后面是什么……嘻嘻')
else:
print('联想：{}'.format(ass_dict[char]))
def net_from_type_string(net_type, num_classes):
if net_type == 'alexnet':
return AlexNet(num_classes)
elif net_type == 'vgg16':
return AlexNet(num_classes)
elif net_type == 'resnet':
return ResNet.make_resnet(50, num_classes)
print('error: unkown net type')
return None
def __init__(self, num_classes=31):
super(DeepMEDA, self).__init__()
self.feature_layers = ResNet.resnet50(True)
self.mmd_marginal = mmd.MMD_loss()
if bottle_neck:
self.bottle = nn.Linear(2048, 256)
self.cls_fc = nn.Linear(256, num_classes)
else:
self.cls_fc = nn.Linear(2048, num_classes)
def ValidRed3D(testloader, Bone, Network, path, sujet):
volume3D_terrain = []
volume3D_exp = []
if Network == 'UNet':
net = UNet().to(device)
elif Network == 'ResNet':
net = ResNet(BasicBlock, [3, 4, 6]).to(device)
net.load_state_dict(torch.load(path))
for i, data in enumerate(testloader, 0):
inputs, labels = data
inputs = inputs.to(device)
labels = labels.to(device)
outputs = net(inputs)
gt = outputs[0].cpu().detach().numpy()
gt[0, :, :][gt[0, :, :] <= 0.5] = 0
gt[0, :, :][gt[0, :, :] > 0.5] = 1
volume3D_terrain.append(labels[0, 0].cpu().detach().numpy())
volume3D_exp.append(gt[0])
if i == 30:
plt.figure()
plt.imshow(inputs[0, 0, :, :].cpu().detach().numpy(),
'gray',
interpolation='none')
plt.imshow(outputs[0, 0, :, :].cpu().detach().numpy(),
'OrRd',
interpolation='none',
alpha=0.6)
plt.savefig(os.path.join(
ResultsDirectory, Bone, 'Images',
'2DSlices_' + Network + '_' + Bone + sujet + str(i) + '.png'),
dpi=150)
plt.figure()
plt.imshow(inputs[0, 0, :, :].cpu().detach().numpy(),
'gray',
interpolation='none')
plt.imshow(labels[0, 0, :, :].cpu().detach().numpy(),
'OrRd',
interpolation='none',
alpha=0.6)
plt.savefig(os.path.join(
ResultsDirectory, Bone, 'Images', '2DSlices_Truth_' + Network +
'_' + Bone + sujet + str(i) + '.png'),
dpi=150)
volume3D_terrain = np.array(volume3D_terrain)
volume3D_exp = np.array(volume3D_exp)
dice = np.abs(
computeQualityMeasures(volume3D_terrain.flatten(),
volume3D_exp.flatten()))
print('dice:' + str(dice))
def test_resnet(inputs: tp.Numpy.Placeholder(
(64, 3, 26, 110, 110))) -> Tuple[tp.Numpy, tp.Numpy]:
resnet2d = getresnet.getResnet()
layer = resnet2d[0]
c3d_idx = [[], [0, 2], [0, 2, 4], []]
nl_idx = [[], [1, 3], [1, 3, 5], []]
y, f = ResNet.ResNet503D(10, AP3D.APP3DC, c3d_idx,
nl_idx).build_network(inputs)
return (y, f)
def __init__(self, num_classes=31, bottle_neck=True):
super(DSAN, self).__init__()
self.feature_layers = ResNet.resnet50(True)
self.lmmd_loss = lmmd.LMMD_loss(class_num=num_classes)
self.bottle_neck = bottle_neck
if bottle_neck:
self.bottle = nn.Linear(2048, 256)
self.cls_fc = nn.Linear(256, num_classes)
else:
self.cls_fc = nn.Linear(2048, num_classes)
def load_model(name='alexnet'):
if name == 'alexnet':
model = AlexNet.AlexNetFc(pretrained=False, num_classes=31)
# torch.nn.init.xavier_uniform_(model.nfc.weight)
# torch.nn.init.constant_(model.nfc.bias, 0.1)
elif name == 'resnet':
model = resnet.myresnet(pretrained=False, num_classes=31)
# torch.nn.init.xavier_uniform_(model.nfc.weight.data)
# torch.nn.init.constant_(model.nfc.bias.data, 0.01)
return model
def load_or_create_neural_net():
file_path = './best_model_resnet.pth'
best_player_so_far = ResNet.resnet18()
if os.path.exists(file_path):
print('loading already trained model')
best_player_so_far.load_state_dict(torch.load(file_path))
best_player_so_far.eval()
return best_player_so_far
def load_or_create_neural_net():
if config.net == 'resnet':
file_path = './best_model_resnet.pth'
elif config.net == 'densenet':
file_path = './best_model_densenet.pth'
else:
print(
'Neural Net type not understood. Chose between resnet or densenet in config.py'
)
raise ValueError
if config.net == 'resnet':
if os.path.exists(file_path):
print('loading already trained model')
time.sleep(0.3)
best_player_so_far = ResNet.resnet18()
best_player_so_far.load_state_dict(torch.load(file_path))
best_player_so_far.eval()
else:
print('Trained model doesnt exist. Starting from scratch.')
time.sleep(0.3)
best_player_so_far = ResNet.resnet18()
best_player_so_far.eval()
if config.net == 'densenet':
if os.path.exists(file_path):
print('loading already trained model')
time.sleep(0.3)
best_player_so_far = ResNet.densenet()
best_player_so_far.load_state_dict(torch.load(file_path))
best_player_so_far.eval()
else:
print('Trained model doesnt exist. Starting from scratch.')
time.sleep(0.3)
best_player_so_far = ResNet.densenet()
best_player_so_far.eval()
return best_player_so_far
def load_model(name='alexnet'):
if name == 'alexnet':
model = AlexNet.AlexNetFc(pretrained=True, num_classes=31)
# torch.nn.init.xavier_uniform_(model.nfc.weight)
# torch.nn.init.constant_(model.nfc.bias, 0.1)
elif name == 'resnet':
model = resnet.myresnet(pretrained=True, num_classes=31)
# torch.nn.init.xavier_uniform_(model.nfc.weight.data)
# torch.nn.init.constant_(model.nfc.bias.data, 0.01)
return model
def Objectinfer(inferprogram, exe, ActionGather, boundGather, colorbackground,
colorbackgroundnow):
infer_result = []
for i in range(len(ActionGather)):
if ActionGather[i] == 1:
processer.Objectsave(colorbackgroundnow, boundGather[i], i)
elif ActionGather[i] == -1:
processer.Objectsave(colorbackground, boundGather[i], i)
for i in range(len(ActionGather)):
infer_result.append(model.infer(inferprogram, exe, str(i) + ".jpg"))
return infer_result
def __init__(self, pretrained=True, **kwargs):
super(UNetResNet50_SE, self).__init__(**kwargs)
self.resnet = ResNet.resnet50(pretrained=pretrained)
self.conv1 = nn.Sequential(
self.resnet.conv1,
self.resnet.bn1,
self.resnet.relu,
) # 64
self.encoder1 = nn.Sequential(self.resnet.layer1,
scSqueezeExcitationGate(256)) # 256
self.encoder2 = nn.Sequential(self.resnet.layer2,
scSqueezeExcitationGate(512)) # 512
self.encoder3 = nn.Sequential(self.resnet.layer3,
scSqueezeExcitationGate(1024)) # 1024
self.encoder4 = nn.Sequential(self.resnet.layer4,
scSqueezeExcitationGate(2048)) # 2048
self.center = nn.Sequential(
nn.MaxPool2d(kernel_size=2, stride=2),
ConvBn2d(2048, 1024, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
ConvBn2d(1024, 1024, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
)
self.decoder5 = Decoder(512 + 1024 * 2,
512,
512,
convT_channels=1024,
SE=True)
self.decoder4 = Decoder(256 + 512 * 2,
256,
256,
convT_channels=512,
SE=True)
self.decoder3 = Decoder(128 + 256 * 2,
128,
128,
convT_channels=256,
SE=True)
self.decoder2 = Decoder(64 + 128 * 2,
64,
64,
convT_channels=128,
SE=True)
self.decoder1 = Decoder(32 + 64, 64, 32, convT_channels=64, SE=True)
self.logit = nn.Sequential(
nn.Conv2d(32, 32, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(32, 1, kernel_size=1, padding=0),
)
def run(self):
wx.CallAfter(pub.sendMessage,
"report101",
message="Prediction process started. \nLoading........"
) # Sending report to the Text Box
import ResNet
result = ResNet.predict(
self.path, self.model_path, self.index_file_path,
self.main_ui) # This calls the ResNet Prediction Class
wx.CallAfter(pub.sendMessage, "report101",
message=result) # # Sending report to the Text Box
def load_student_rnn(num_classes):
student = ResNet.WideResNet(
depth=config.student_rnn['depth'],
num_classes=num_classes,
widen_factor=config.student_rnn['widen_factor'],
input_features=config.student_rnn['input_features'],
output_features=config.student_rnn['output_features'],
dropRate=config.student_rnn['dropRate'],
strides=config.student_rnn['strides'])
return student
