def __init__(
self,
input_shape,
output_dim,
patience=4,
structure='wide_res_net',
):
self.model = None
if structure == 'wide_res_net':
self.model = WideResNet(input_shape=input_shape,
output_dim=output_dim)
elif structure == 'res_net':
self.model = ResNet(input_shape=input_shape, output_dim=output_dim)
else:
raise Exception('no structure')
self.criterion = tf.keras.losses.CategoricalCrossentropy()
self.optimizer = tf.keras.optimizers.SGD(learning_rate=0.1)
self.train_loss = tf.keras.metrics.Mean()
self.train_acc = tf.keras.metrics.CategoricalAccuracy()
self.val_loss = tf.keras.metrics.Mean()
self.val_acc = tf.keras.metrics.CategoricalAccuracy()
self.history = {
'train_loss': [],
'val_loss': [],
'train_acc': [],
'val_acc': []
}
self.es = {'loss': float('inf'), 'patience': patience, 'step': 0}
self.save_dir = './logs'
if not os.path.exists(self.save_dir):
os.mkdir('logs')
def eval_resnet():
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
sess = tf.Session(config=sess_config)
config = get_config(is_train=True)
mkdir(config.result_dir)
reg = ResNet(sess, config, "DIRNet", is_train=False)
reg.restore(config.ckpt_dir)
dh = DIRNetDatahandler(config=config)
# print(reg.calc_rmse_all(dh.s_data, dh.d_data, config.result_dir + "/",save_images=False))
batch_x, batch_y, batch_labels = dh.sample_pair(config.batch_size)
# prediction = reg.deploy_with_labels(batch_x, batch_y, batch_labels)
# print(str(prediction))
amnt_pics = np.shape(dh.d_data)[0]
acc = 0
prev_x = np.empty(shape=(1, 222, 247))
amnt_eva = np.shape(dh.d_data_eval)[0]
for i in range(amnt_eva):
batch_x, batch_y, batch_labels = dh.get_eval_pair_by_idx(i)
if np.array_equal(prev_x, batch_x):
print('weird')
prev_x = batch_x
# loss = reg.fit((1, batch_x[0], batch_x[1], batch_x[2]),
# (1, batch_y[0], batch_y[1], batch_y[2]))
prediction = reg.deploy_with_labels(batch_x, batch_y, batch_labels)
print(prediction,"::", batch_labels[0])
truth = int(batch_labels[0])
# print("pred {} truth {}".format(prediction, truth))
if prediction == truth:
acc += 1
print("Acc: {0:.4f}".format(acc / amnt_eva))
def main():
global test_csv
# evaluation mode
evalute_filepath = '/root/workspace/depth/sparse-to-dense.pytorch/results/uw_nyu.sparsifier=uar.samples=0.modality=rgb.arch=resnet50.decoder=upproj.criterion=l1.lr=0.01.bs=16.pretrained=True(old)'
best_weights_path = os.path.join(evalute_filepath, 'best_model.pkl')
assert os.path.isfile(best_weights_path), \
"=> no best weights found at '{}'".format(evalute_filepath)
print("=> loading best weights for Model '{}'".format(evalute_filepath))
val_loader = create_data_loaders()
decoder = 'upproj'
model = ResNet(layers=50,
decoder=decoder,
output_size=val_loader.dataset.output_size,
pretrained=False)
model = model.cuda()
model.load_state_dict(torch.load(best_weights_path))
print("=> loaded best weights for Model")
output_directory = os.path.join('results/uw_test', 'uw_test4')
validate(val_loader, model, output_directory=output_directory)
def get_model(opts):
"""
----------------------------------------------------------------------------------------------------------------
Test(id=Baseline.SGD.CosineAnnealingLR.CIFAR10.1000.512.01, loss=1.6240, mA=0.8682)
✡ Test(id=SEBaseline.SGD.CosineAnnealingLR.CIFAR10.1000.512.01, loss=1.6408, mA=0.8717) ✡
----------------------------------------------------------------------------------------------------------------
✡ Test(id=Baseline.SGD.OneCycleLR.CIFAR10.1000.512.01, loss=1.6121, mA=0.8697) ✡
Test(id=SEBaseline.SGD.OneCycleLR.CIFAR10.1000.512.01, loss=1.6210, mA=0.8695)
Test(id=AABaseline.SGD.OneCycleLR.CIFAR10.1000.2048.01, loss=1.6297, mA=0.8625)
TODO Test(id=SASABaseline.AdamW.OneCycleLR.CIFAR10.300.128.001, loss=1.6930, mA=0.8438)
----------------------------------------------------------------------------------------------------------------
Test(id=SimpleResNet56.SGD.CosineAnnealingWarmRestarts.CIFAR10.1000.256.01, loss=1.5356, mA=0.9205)
✡ Test(id=SimpleSEResNet56.SGD.CosineAnnealingWarmRestarts.CIFAR10.1000.256.01, loss=1.5866, mA=0.9238) ✡
----------------------------------------------------------------------------------------------------------------
Test(id=SimpleResNet56.SGD.CosineAnnealingLR.CIFAR10.1000.256.01, loss=1.5238, mA=0.9273)
✡ Test(id=SimpleSEResNet56.SGD.CosineAnnealingLR.CIFAR10.1000.512.01, loss=1.5145, mA=0.9353) ✡
Test(id=SimpleStdAAResNet56.SGD.CosineAnnealingLR.CIFAR10.1000.512.01, loss=1.5243, mA=0.9275)
----------------------------------------------------------------------------------------------------------------
Test(id=SimpleResNet56.SGD.OneCycleLR.CIFAR10.1000.256.01, loss=1.5239, mA=0.9254)
✡ Test(id=SimpleSEResNet56.SGD.OneCycleLR.CIFAR10.1000.512.01, loss=1.5160, mA=0.9356) ✡
Test(id=SimpleOrigAAResNet56.SGD.OneCycleLR.CIFAR10.1000.512.01, loss=1.5261, mA=0.9138)
Test(id=SimpleStdAAResNet56.SGD.OneCycleLR.CIFAR10.1000.512.01, loss=1.5381, mA=0.9265)
Test(id=SimpleSASAResNet56.AdamW.OneCycleLR.CIFAR10.300.256.01, loss=0.8838, mA=0.8457)
----------------------------------------------------------------------------------------------------------------
✡ Test(id=SimpleResNet110.SGD.CosineAnnealingLR.CIFAR10.1000.1024.01, loss=1.5177, mA=0.9336) ✡
Test(id=SimpleSEResNet110.SGD.CosineAnnealingLR.CIFAR10.1000.1024.01, loss=1.5231, mA=0.9319)
----------------------------------------------------------------------------------------------------------------
Test(id=ResNet50.SGD.CosineAnnealingLR.CIFAR10.1000.128.01, loss=1.5777, mA=0.9244)
✡ Test(id=ResNet50.AdamW.OneCycleLR.CIFAR10.300.128.005, loss=1.5237, mA=0.9395) ✡
Test(id=SEResNet50.SGD.CosineAnnealingLR.CIFAR10.1000.128.01, loss=1.5243, mA=0.9156)
Test(id=AAResNet50.SGD.OneCycleLR.CIFAR10.1000.256.01, loss=1.5223, mA=0.9072)
----------------------------------------------------------------------------------------------------------------
"""
return {
'Baseline': lambda: Baseline(opts),
'SEBaseline': lambda: SEBaseline(opts),
'AABaseline': lambda: AABaseline(opts),
'SASABaseline': lambda: SASABaseline(stem=False),
'SASAStemBaseline': lambda: SASABaseline(stem=True),
'SimpleChannelAttnBaseline': lambda: ChannelAttnBaseline(simple=True, mode='none'),
'ComplexChannelAttnBaseline': lambda: ChannelAttnBaseline(simple=False, mode='none'),
'SkipSimpleChannelAttnBaseline': lambda: ChannelAttnBaseline(simple=True, mode='skip'),
'SkipComplexChannelAttnBaseline': lambda: ChannelAttnBaseline(simple=False, mode='skip'),
'ScaleSimpleChannelAttnBaseline': lambda: ChannelAttnBaseline(simple=True, mode='scale'),
'ScaleComplexChannelAttnBaseline': lambda: ChannelAttnBaseline(simple=False, mode='scale'),
'SimpleResNet56': lambda: SimpleResNet(n=9),
'SimpleResNet110': lambda: SimpleResNet(n=18),
'SimpleSEResNet56': lambda: SimpleSEResNet(n=9),
'SimpleSEResNet110': lambda: SimpleSEResNet(n=18),
'SimpleOrigAAResNet56': lambda: SimpleAAResNet(n=9, original=True),
'SimpleStdAAResNet56': lambda: SimpleAAResNet(n=9, original=False),
'SimpleSASAResNet56': lambda: SimpleSASAResNet(n=9, stem=False),
'SimpleStemSASAResNet56': lambda: SimpleSASAResNet(n=9, stem=True),
'ResNet50': lambda: ResNet(sizes=[3, 4, 6, 3]),
'SEResNet50': lambda: SEResNet(sizes=[3, 4, 6, 3]),
'AAResNet50': lambda: AAResNet(sizes=[3, 4, 6, 3]),
'ResNet101': lambda: ResNet(sizes=[3, 4, 23, 3]),
'SEResNet101': lambda: SEResNet(sizes=[3, 4, 23, 3]),
}[opts.model_name]()
def train_ResNet():
sess_config = tf.ConfigProto()
sess_config.gpu_options.allow_growth = True
sess = tf.Session(config=sess_config)
config = get_config(is_train=True)
mkdir(config.tmp_dir)
mkdir(config.ckpt_dir)
reg = ResNet(sess, config, "DIRNet", is_train=True)
# reg.restore(config.ckpt_dir)
dh = DIRNetDatahandler(config=config)
amnt_pics = np.shape(dh.d_data)[0]
for epoch in range(5):
loss_sum = 0
acc = 0
for i in range(amnt_pics - 1):
batch_x, batch_y, batch_labels = dh.get_pair_by_idx(i)
# loss = reg.fit((1, batch_x[0], batch_x[1], batch_x[2]),
# (1, batch_y[0], batch_y[1], batch_y[2]))
loss, prediction = reg.fit(batch_x, batch_y, batch_labels)
loss2, prediction2 = reg.fit(batch_y, batch_x, batch_labels)
loss_sum += (loss + loss2) / 2
prediction = int(prediction[0])
truth = int(batch_labels[0])
# print("pred {} truth {}".format(prediction, truth))
if prediction == truth:
acc += 1
if prediction2[0] == truth:
acc += 1
print("epoch {0}: Loss: {1:.4f} Acc: {2:.4f}".format(
epoch, loss_sum / (amnt_pics * 2), acc / (amnt_pics * 2)))
if (epoch + 1) % 5 == 0:
# if (epoch+1) % config.checkpoint_distance == 0:
# reg.deploy(config.tmp_dir, batch_x, batch_y)
print('saving model...')
# reg.save(config.ckpt_dir)
amnt_pics = np.shape(dh.d_data)[0]
acc = 0
prev_x = np.empty(shape=(1, 222, 247))
amnt_eva = np.shape(dh.d_data_eval)[0]
for i in range(amnt_eva):
batch_x, batch_y, batch_labels = dh.get_eval_pair_by_idx(i)
if np.array_equal(prev_x, batch_x):
print('weird')
prev_x = batch_x
# loss = reg.fit((1, batch_x[0], batch_x[1], batch_x[2]),
# (1, batch_y[0], batch_y[1], batch_y[2]))
prediction = reg.deploy_with_labels(batch_x, batch_y, batch_labels)
print(prediction, "::", batch_labels[0])
truth = int(batch_labels[0])
# print("pred {} truth {}".format(prediction, truth))
if prediction == truth:
acc += 1
print("Acc: {0:.4f}".format(acc / amnt_eva))
def se_resnet34(num_classes=1_000):
"""Constructs a ResNet-34 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(SEBasicBlock, [3, 4, 6, 3], num_classes=num_classes)
model.avgpool = nn.AdaptiveAvgPool2d(1)
return model
def se_resnet152(num_classes=1_000):
"""Constructs a ResNet-152 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(SEBottleneck, [3, 8, 36, 3], num_classes=num_classes)
model.avgpool = nn.AdaptiveAvgPool2d(1)
return model
def main():
args = parser.parse_args()
import torch
from torch.autograd import Variable
mdl = ResNet(50, "deconv3", in_channels=4, image_shape=(192, 256)).cuda()
x = Variable(torch.randn(1, mdl.in_channels, *mdl.image_shape).cuda())
y = mdl(x)
model_graph = torchviz.make_dot(y.mean(), dict(mdl.named_parameters()))
model_graph.format = "svg"
model_graph.render("resnet50.gv", "resnet50_render", view=True)
def main():
global test_csv
# evaluation mode
evalute_filepath = '/root/workspace/depth/sparse-to-dense.pytorch/results/uw_nyu.sparsifier=uar.samples=0.modality=rgb.arch=resnet50.decoder=upproj.criterion=l1.lr=0.01.bs=16.pretrained=True(old)'
best_weights_path = os.path.join(evalute_filepath, 'best_model.pkl')
assert os.path.isfile(best_weights_path), \
"=> no best weights found at '{}'".format(evalute_filepath)
print(
"=> loading best weights for SphereFCRN '{}'".format(evalute_filepath))
val_loader = create_data_loaders()
decoder = 'upproj'
model = ResNet(layers=50,
decoder=decoder,
output_size=val_loader.dataset.output_size,
pretrained=False)
model = model.cuda()
model.load_state_dict(torch.load(best_weights_path))
# model.decoder.apply(weights_init)
print("=> loaded best weights for SphereFCRN")
# print(model)
# create results folder, if not already exists
output_directory = os.path.join('results', 'uw_test5')
if not os.path.exists(output_directory):
os.makedirs(output_directory)
test_csv = os.path.join(output_directory, 'test.csv')
best_txt = os.path.join(output_directory, 'best.txt')
result, img_merge = validate(val_loader, model, write_to_file=True)
# create new csv files
with open(test_csv, 'w') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
with open(best_txt, 'w') as txtfile:
txtfile.write(
"mse={:.3f}\nrmse={:.3f}\nabsrel={:.3f}\nlg10={:.3f}\nmae={:.3f}\ndelta1={:.3f}\nt_gpu={:.4f}\n"
.format(result.mse, result.rmse, result.absrel, result.lg10,
result.mae, result.delta1, result.gpu_time))
if img_merge is not None:
img_filename = output_directory + '/comparison_best.png'
utils.save_image(img_merge, img_filename)
def build_model(config):
if config['model'] == 'MLPProb':
model = MLPProb(config['input_size'])
elif config['model'] == 'MLPLinear':
model = MLPLinear(config['input_size'])
elif config['model'] == 'MLPLinearProb':
model = MLPLinearProb(config['input_size'])
elif config['model'] == 'CNN_MNIST':
model = CNN_MNIST()
elif config['model'] == 'ResNet':
model = ResNet(config['input_size'])
elif config['model'] == 'MLPNet3Layer':
model = MLPNet3Layer(config['input_size'])
elif config['model'] == 'MLPLinear3Layer':
model = MLPLinear3Layer(config['input_size'])
elif config['model'] == 'MLPLinear1Layer':
model = MLPLinear1Layer(config['input_size'])
elif config['model'] == 'MLPNetSigmoid':
model = MLPNetSigmoid(config['input_size'])
else:
model = MLPNet(config['input_size'])
if config['loss_function'] == 'BCE':
loss_function = nn.BCELoss()
else:
loss_function = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=config['lr'])
return model, loss_function, optimizer
def create_model(type, input_size, num_classes):
if type == "resnet":
model = ResNet(num_classes=num_classes)
elif type in ["seresnext50", "seresnext101", "seresnet50", "seresnet101", "seresnet152", "senet154"]:
model = SeNet(type=type, num_classes=num_classes)
elif type == "alexnet":
model = AlexNetWrapper(num_classes=num_classes)
elif type == "nasnet":
model = NasNet(num_classes=num_classes)
elif type == "cnn":
model = SimpleCnn(num_classes=num_classes)
elif type == "residual_cnn":
model = ResidualCnn(num_classes=num_classes)
elif type == "fc_cnn":
model = FcCnn(num_classes=num_classes)
elif type == "hc_fc_cnn":
model = HcFcCnn(num_classes=num_classes)
elif type == "mobilenetv2":
model = MobileNetV2(input_size=input_size, n_class=num_classes)
elif type in ["drn_d_38", "drn_d_54", "drn_d_105"]:
model = Drn(type=type, num_classes=num_classes)
elif type == "seresnext50_cs":
model = SeResNext50Cs(num_classes=num_classes)
elif type == "stack":
model = StackNet(num_classes=num_classes)
else:
raise Exception("Unsupported model type: '{}".format(type))
return nn.DataParallel(model)
def main():
# load table data
df_train = pd.read_csv("../input/train_curated.csv")
df_noisy = pd.read_csv("../input/train_noisy.csv")
df_test = pd.read_csv("../input/sample_submission.csv")
labels = df_test.columns[1:].tolist()
for label in labels:
df_train[label] = df_train['labels'].apply(lambda x: label in x)
df_noisy[label] = df_noisy['labels'].apply(lambda x: label in x)
df_train['path'] = "../input/mel128/train/" + df_train['fname']
df_test['path'] = "../input/mel128/test/" + df_train['fname']
df_noisy['path'] = "../input/mel128/noisy/" + df_noisy['fname']
# fold splitting
folds = list(
KFold(n_splits=NUM_FOLD, shuffle=True,
random_state=SEED).split(np.arange(len(df_train))))
# build model
model = ResNet(NUM_CLASS).cuda()
# set generator
dataset_noisy = MelDataset(df_noisy['path'], df_noisy[labels].values)
noisy_loader = DataLoader(
dataset_noisy,
batch_size=1,
shuffle=False,
num_workers=1,
pin_memory=True,
)
# predict
preds_noisy = np.zeros(
[NUM_FOLD, NUM_EPOCH // NUM_CYCLE,
len(df_noisy), NUM_CLASS], np.float32)
for fold, (ids_train_split, ids_valid_split) in enumerate(folds):
for cycle in range(NUM_EPOCH // NUM_CYCLE):
print("fold: {} cycle: {}, sec: {:.1f}".format(
fold + 1, cycle + 1,
time.time() - starttime))
model.load_state_dict(
torch.load("{}/weight_fold_{}_epoch_{}.pth".format(
LOAD_DIR, fold + 1, NUM_CYCLE * (cycle + 1))))
preds_noisy[fold, cycle] = predict(noisy_loader, model)
np.save("{}/preds_noisy.npy".format(OUTPUT_DIR), preds_noisy)
def load_generator(backbone_data=None,
generator_weights='generator_weights.h5',
backbone_weights='backbone_posttrained_weights.h5',
clear_session=True):
if (clear_session):
keras.backend.clear_session()
backbone = ResNet()
backbone(backbone_data.get_test()[0])
# import pdb; pdb.set_trace() # breakpoint 9e595caa //
generator = ResGen(backbone, 'MnistGenerator')
if (generator_weights):
generator.load_weights(generator_weights)
if (backbone_weights):
backbone.load_weights(backbone_weights)
return generator
def load_classifier(data=None,
classes=10,
classifier_weights='classifier_weights.h5',
backbone_weights='backbone_posttrained_weights.h5',
clear_session=True):
if (clear_session):
keras.backend.clear_session()
backbone = ResNet()
backbone(data.get_test()[0])
classifier = Classifier(backbone, classes)
if (classifier_weights):
classifier.load_weights(classifier_weights)
if (backbone_weights):
backbone.load_weights(backbone_weights)
return classifier
def load_discriminator(data=None,
discriminator_weights=None,
backbone_weights='backbone_posttrained_weights.h5',
clear_session=True):
if (clear_session):
keras.backend.clear_session()
backbone = ResNet()
backbone(data.get_test()[0])
discriminator = Discriminator(backbone)
if (discriminator_weights):
discriminator.load_weights(discriminator_weights)
if (backbone_weights):
backbone.load_weights(backbone_weights)
discriminator(data.get_test()[0])
return discriminator
def get_model(args):
if args.model == 'mlp':
model = MLP(num_classes=args.n_classes)
elif args.model == 'resnet':
model = ResNet(20, num_classes=args.n_classes)
elif args.model == 'densenet':
model = DenseNet(40, num_classes=args.n_classes)
return model
def __init__(self, model,dataset_index=0,video_target = None):
if args.video == None:
self.video_target = video_target
customset_train = CustomDataset(path = args.dataset_path,subset_type="training",dataset_index=dataset_index,video_target = video_target)
customset_test = CustomDataset(path = args.dataset_path,subset_type="testing",dataset_index=dataset_index, video_target = video_target)
self.trainloader = torch.utils.data.DataLoader(dataset=customset_train,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers)
self.testloader = torch.utils.data.DataLoader(dataset=customset_test,batch_size=args.batch_size,shuffle=False,num_workers=args.num_workers)
else:
video_dataset = VideoDataset(video=args.video, batch_size=args.batch_size,
frame_skip=int(args.frame_skip),image_folder=args.extract_frames_path, use_existing=args.use_existing_frames)
self.videoloader = torch.utils.data.DataLoader(dataset=video_dataset, batch_size=1,shuffle=False,num_workers=args.num_workers)
if (model == "alex"):
self.model = AlexNet()
elif (model == "vgg"):
self.model = VGG()
elif (model == "resnet"):
self.model = ResNet()
if args.pretrained_model != None:
if args.pretrained_finetuning == False:
self.model.load_state_dict(torch.load(args.pretrained_model))
else:
print "DEBUG : Make it load only part of the resnet model"
#print(self.model)
#self.model.load_state_dict(torch.load(args.pretrained_model))
#for param in self.model.parameters():
# param.requires_grad = False
self.model.fc = nn.Linear(512, 1000)
#print(self.model)
self.model.load_state_dict(torch.load(args.pretrained_model))
self.model.fc = nn.Linear(512,3)
#print(self.model)
self.model.cuda()
print "Using weight decay: ",args.weight_decay
self.optimizer = optim.SGD(self.model.parameters(), weight_decay=float(args.weight_decay),lr=0.01, momentum=0.9,nesterov=True)
self.criterion = nn.CrossEntropyLoss().cuda()
def __init__(self, model,dataset_index=0, path = None):
self.sampler = self.weighted_sampling(dataset_index=dataset_index,path=path)
customset_train = CustomDatasetViewpoint(path = path,subset_type="training",dataset_index=dataset_index)
customset_test = CustomDatasetViewpoint(path = path,subset_type="testing",dataset_index=dataset_index)
self.trainloader = torch.utils.data.DataLoader(pin_memory=True,dataset=customset_train,sampler=self.sampler,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers)
self.trainloader_acc = torch.utils.data.DataLoader(dataset=customset_train,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers)
self.testloader_acc = torch.utils.data.DataLoader(dataset=customset_test,batch_size=args.batch_size,shuffle=True,num_workers=args.num_workers)
if (model == "alex"):
self.model = AlexNet()
elif (model == "vgg"):
self.model = VGG(num_classes=2)
elif (model == "resnet"):
self.model = ResNet()
if args.pretrained_model != None:
if args.pretrained_same_architecture:
self.model.load_state_dict(torch.load(args.pretrained_model))
else:
if args.arch == "vgg":
self.model.soft = None
classifier = list(self.model.classifier.children())
classifier.pop()
classifier.append(torch.nn.Linear(4096,1000))
new_classifier = torch.nn.Sequential(*classifier)
self.model.classifier = new_classifier
self.model.load_state_dict(torch.load(args.pretrained_model))
classifier = list(self.model.classifier.children())
classifier.pop()
classifier.append(torch.nn.Linear(4096,2))
new_classifier = torch.nn.Sequential(*classifier)
self.model.classifier = new_classifier
self.model.soft = nn.LogSoftmax()
else:
self.model.fc = nn.Linear(512, 1000)
self.model.load_state_dict(torch.load(args.pretrained_model))
self.model.fc = nn.Linear(512,2)
self.optimizer = optim.Adam(self.model.parameters(), weight_decay=float(args.weight_decay), lr=0.0001)
def demo_from_best_model(resnet_layer, pretrained, num_classes, path):
assert resnet_layer == 18 or resnet_layer == 50
net_best = ResNet(layer_num=resnet_layer, pretrained=pretrained, num_classes=num_classes)
net_best = net_best.to(device)
net_best.load_state_dict(torch.load(path))
net_best.eval()
best_acc = save_confusion_matrix(net_best, val_loader, 'backup_demo/cm_best.png')
print('test_best_accuracy = %.2f' % best_acc)
def create_model(type, num_classes):
if type == "cnn":
model = SimpleCnn(num_classes=num_classes)
elif type in ["resnet18", "resnet34", "resnet50"]:
model = ResNet(type=type, num_classes=num_classes)
elif type in ["seresnext50", "senet154"]:
model = SeNet(type=type, num_classes=num_classes)
elif type == "inceptionv2":
model = InceptionV2(num_classes=num_classes)
else:
raise Exception("Unsupported model type: '{}".format(type))
return nn.DataParallel(model)
def init_model(nfm=32,
res_blocks=1,
in_frames=2,
batch_size=2,
epoch_to_load=None):
resnet = ResNet(nfm*2, res_blocks)
if torch.cuda.is_available(): resnet=resnet.cuda()
my_unet = U_Net(nfm, resnet, 1, 1)
discriminator = CNN((in_frames+1)*3, nfm, 512)
if epoch_to_load != None:
my_unet = torch.load('unet_epoch_{}'.format(epoch_to_load))
discriminator = torch.load('D_epoch_{}'.format(epoch_to_load))
if torch.cuda.is_available(): my_unet, discriminator = my_unet.cuda(), discriminator.cuda()
Unet_optim = torch.optim.Adam(my_unet.parameters(), lr=0.002)
D_optim = torch.optim.Adam(discriminator.parameters(), lr=0.002)
return {'Unet': my_unet, 'Discriminator': discriminator, 'Unet_optimizer': Unet_optim, 'Discriminator_optimizer': D_optim}
def test_unet():
data = mnist_data()
backbone = ResNet()
# preds = backbone(data.get_test()[0])
gen = Unet()
# input_shape = gen.get_input_shape()
# print(gen.get_output_shape())
rand_data_shape = (50, 28, 28, 1)
random_noise_data = np.random.normal(size=rand_data_shape)
# import pdb; pdb.set_trace() # breakpoint 7e7a66fc //
preds = gen.predict(random_noise_data)
return True
def train_classifier_depricated(tpu=False):
scope = strategy.scope()
print("Number of accelerators: ", strategy.num_replicas_in_sync)
data = mnist_data()
backbone = ResNet()
discriminator = Discriminator(backbone)
classifier = Classifier(backbone, 10)
preds = classifier.predict(data.get_test()[0])
classifier.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
classifier.summary()
if (tpu):
classifier = convert_model_for_tpu(classifier)
checkpoint = keras.callbacks.ModelCheckpoint(
'./checkpoints/classifier/classifier_{epoch:.2f}.h5',
monitor='val_loss',
verbose=0,
save_best_only=False,
save_weights_only=True)
# classifier.fit(x=x_train,y=y_train,batch_size=6000,epochs=1, validation_data=(x_vali,y_vali),callbacks=[checkpoint])
classifier.fit(x=data.get_n_samples(35)[0],
y=data.get_n_samples(35)[1],
batch_size=6000,
epochs=20,
validation_data=data.get_vali(),
callbacks=[checkpoint])
# import pdb; pdb.set_trace() # breakpoint 396fe169 //
backbone = classifier.get_backbone()
backbone.save_weights('backbone_weights.h5')
return (classifier, x_test)
def test_resgen():
data = mnist_data()
backbone = ResNet()
preds = backbone(data.get_test()[0])
gen = ResGen(backbone)
input_shape = gen.get_input_shape()
print(gen.get_output_shape())
rand_data_shape = ((50, ) + input_shape[1:] + (1, ))
random_noise_data = np.random.normal(size=rand_data_shape)
# import pdb; pdb.set_trace() # breakpoint 7e7a66fc //
preds = gen.predict(random_noise_data)
return True
def main():
params.print_params()
parser = argparse.ArgumentParser()
parser.add_argument('--local_test',
type=str2bool,
default=False,
help='local test verbose')
parser.add_argument('--aug',
type=str2bool,
default=False,
help='source domain id')
args = parser.parse_args()
X_train, Y_train, X_val, Y_val, X_test, Y_test = loadData(
params.data_folder)
print(X_train.shape, Y_train.shape)
print(X_val.shape, Y_val.shape)
print(X_test.shape, Y_test.shape)
model, avg_layer = ResNet(X_train, Y_train, X_test, Y_test, args)
pred = model.predict(X_test)
acc = evaluate(pred, Y_test)
print('\nAccuracy: {:.4f}'.format(acc))
def main():
global test_csv
# evaluation mode
evalute_filepath = '/root/workspace/depth/sparse-to-dense.pytorch/results/uw_nyu.sparsifier=uar.samples=0.modality=rgb.arch=resnet50.decoder=upproj.criterion=l1.lr=0.01.bs=16.pretrained=True(old)'
best_weights_path = os.path.join(evalute_filepath, 'best_model.pkl')
assert os.path.isfile(best_weights_path), \
"=> no best weights found at '{}'".format(evalute_filepath)
print("=> loading best weights for model '{}'".format(evalute_filepath))
val_loader = create_data_loaders()
decoder = 'upproj'
model = ResNet(layers=50,
decoder=decoder,
output_size=val_loader.dataset.output_size,
pretrained=False)
model = model.cuda()
model.load_state_dict(torch.load(best_weights_path))
# model.decoder.apply(weights_init)
print("=> loaded best weights for model")
# create results folder, if not already exists
output_directory = os.path.join('results/uw_test', 'uw_test5')
if not os.path.exists(output_directory):
os.makedirs(output_directory)
best_txt = os.path.join(output_directory, 'best.txt')
result = validate(val_loader, model, output_directory=output_directory)
# create new csv files
with open(best_txt, 'w') as txtfile:
txtfile.write("rmse={:.3f}\nabsrel={:.3f}\ndelta1={:.3f}\n".format(
result[0], result[1], result[2]))
def model_from_dataset(dataset, **kwargs):
if dataset == 'adult':
return FullyConnected(**kwargs)
elif dataset == 'credit':
return FullyConnected(**kwargs)
elif dataset == 'compass':
return FullyConnected(**kwargs)
elif dataset == 'multi_mnist' or dataset == 'multi_fashion_mnist' or dataset == 'multi_fashion':
return MultiLeNet(**kwargs)
elif dataset == 'celeba':
if 'efficientnet' in kwargs['model_name']:
return EfficientNet.from_pretrained(**kwargs)
elif kwargs['model_name'] == 'resnet18':
return ResNet.from_name(**kwargs)
else:
raise ValueError("Unknown model name {}".format(dataset))
def _get_model_archtecture(self):
"""
通过配置文件得到网络的结构
:return:
"""
if self.config['type'] == 'DenseNet':
from models import DenseNet
model_object = DenseNet.DenseNet(self.config['model_config'])
if self.config['type'] == 'ResNet':
from models import ResNet
model_object = ResNet.ResNet(self.config['model_config'])
if self.config['type'] == 'MobilenetV2':
from models import MobileNet
model_object = MobileNet.mobilenetV2(self.config['model_config'])
self.model = model_object.constuct_model()
def main():
args = parse_args()
cfg = cfg_from_file(args.config)
print('using config: {}'.format(args.config))
data_cfg = cfg['data']
datalist = datalist_from_file(data_cfg['datalist_path'])
num_train_files = len(datalist) // 5 * 4
train_dataset = IMetDataset(data_cfg['dataset_path'],
datalist[:num_train_files],
transform=data_cfg['train_transform'])
test_dataset = IMetDataset(data_cfg['dataset_path'],
datalist[num_train_files:],
transform=data_cfg['test_transform'])
train_dataloader = data.DataLoader(train_dataset,
batch_size=data_cfg['batch_size'],
shuffle=True)
test_dataloader = data.DataLoader(test_dataset,
batch_size=data_cfg['batch_size'])
backbone_cfg = cfg['backbone'].copy()
backbone_type = backbone_cfg.pop('type')
if backbone_type == 'ResNet':
backbone = ResNet(**backbone_cfg)
elif backbone_type == 'ResNeXt':
backbone = ResNeXt(**backbone_cfg)
elif backbone_type == 'DenseNet':
backbone = DenseNet(**backbone_cfg)
classifier = Classifier(backbone, backbone.out_feat_dim).cuda()
train_cfg, log_cfg = cfg['train'], cfg['log']
criterion = FocalLoss()
optimizer = torch.optim.SGD(classifier.parameters(),
lr=train_cfg['lr'],
weight_decay=train_cfg['weight_decay'],
momentum=train_cfg['momentum'])
trainer = Trainer(model=classifier,
train_dataloader=train_dataloader,
val_dataloader=test_dataloader,
criterion=criterion,
optimizer=optimizer,
train_cfg=train_cfg,
log_cfg=log_cfg)
trainer.train()
def test_coupled_weights_of_backbone():
"""
This function will fail because there are multiple models defined
in the keras/tensorflow graph which are not used during training.
Returns:
bool -- [description]
"""
data = mnist_data()
backbone = ResNet()
preds = backbone(data.get_test()[0])
gen = ResGen(backbone)
input_shape = gen.get_input_shape()
rand_data_shape = ((50, ) + input_shape[1:] + (1, ))
random_noise_data = np.random.normal(size=rand_data_shape)
discriminator = Discriminator(backbone)
classifier = Classifier(backbone, 10)
discriminator_predicitons_1 = discriminator(data.get_test()[0])
classifier_predicitons_1 = classifier.predict(data.get_test()[0])
generator_predictions_1 = gen.predict(random_noise_data)[0]
classifier.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
classifier.summary()
# classifier.fit(x=x_train,y=y_train,batch_size=6000,epochs=1, validation_data=(x_vali,y_vali),callbacks=[checkpoint])
classifier.fit(x=data.get_n_samples(35)[0],
y=data.get_n_samples(35)[1],
batch_size=6000,
epochs=1,
validation_data=data.get_vali())
discriminator_predicitons_2 = discriminator(data.get_test()[0])
classifier_predicitons_2 = classifier.predict(data.get_test()[0])
generator_predictions_2 = gen.predict(random_noise_data)[0]
discriminator_diff = discriminator_predicitons_1 - discriminator_predicitons_2
classifier_diff = classifier_predicitons_1 - classifier_predicitons_2
generator_diff = generator_predicitons_1 - generator_predicitons_2
return True
