def resnet152(pretrained=False):
"""Constructs a ResNet-152 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(Bottleneck, [3, 8, 36, 3])
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
return model
def resnet34(pretrained=False):
"""Constructs a ResNet-34 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(BasicBlock, [3, 4, 6, 3])
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
return model
def MODEL(model_name, weight_decay, image, label, trainable, is_training):
end_points = ResNet.model(image,
trainable=trainable,
is_training=is_training)
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(label, end_points['Logits']))
accuracy = tf.reduce_mean(
tf.cast(
tf.equal(tf.argmax(label, 1), tf.argmax(end_points['Logits'], 1)),
tf.float32))
tf.compat.v1.summary.scalar('loss', loss)
return end_points, loss, accuracy
def load_model(args, num_class, trained_param=None):
if 'ResNet' in args.arch:
arch = int(args.arch.split('-')[1])
model = ResNet.Model(num_layers=arch,
num_class=num_class,
name='ResNet',
trainable=True)
if trained_param is not None:
with open(trained_param, 'rb') as f:
trained = pickle.load(f)
n = 0
for k in model.Layers.keys():
layer = model.Layers[k]
if 'conv' in k or 'fc' in k:
kernel = trained[layer.name + '/kernel:0']
layer.kernel_initializer = tf.constant_initializer(kernel)
n += 1
if layer.use_biases:
layer.biases_initializer = tf.constant_initializer(
trained[layer.name + '/biases:0'])
n += 1
layer.num_outputs = kernel.shape[-1]
elif 'bn' in k:
moving_mean = trained[layer.name + '/moving_mean:0']
moving_variance = trained[layer.name + '/moving_variance:0']
param_initializers = {
'moving_mean': tf.constant_initializer(moving_mean),
'moving_variance': tf.constant_initializer(moving_variance)
}
n += 2
if layer.scale:
param_initializers['gamma'] = tf.constant_initializer(
trained[layer.name + '/gamma:0'])
n += 1
if layer.center:
param_initializers['beta'] = tf.constant_initializer(
trained[layer.name + '/beta:0'])
n += 1
layer.param_initializers = param_initializers
print(n, 'params loaded')
return model
args.input_size = list(train_images.shape[1:])
if 'WResNet' in args.arch:
arch = [int(a) for a in args.arch.split('-')[1:]]
model = WResNet.Model(architecture=arch,
num_class=np.max(train_labels) + 1,
name='Student',
trainable=True)
elif 'VGG' in args.arch:
model = VGG.Model(num_class=np.max(train_labels) + 1,
name='Student',
trainable=True)
elif 'ResNet' in args.arch:
arch = int(args.arch.split('-')[1])
model = ResNet.Model(num_layers=arch,
num_class=np.max(train_labels) + 1,
name='Student',
trainable=True)
elif 'Mobilev2' in args.arch:
model = Mobilev2.Model(num_class=np.max(train_labels) + 1,
width_mul=1.0 if args.slimmable else 1.0,
name='Student',
trainable=True)
model(np.zeros([1] + args.input_size, dtype=np.float32), training=False)
cardinality = tf.data.experimental.cardinality(datasets['train']).numpy()
if args.decay_points is None:
LR = tf.keras.optimizers.schedules.ExponentialDecay(args.learning_rate,
cardinality,
args.decay_rate,
staircase=True)
def run_experiment(args):
train_distortion, val_distortion = None, None
if args.distortion:
train_distortion = Distorter(loc=0,
sd=args.distortion_sd,
seed=args.seed)
val_distortion = Distorter(loc=0,
sd=args.distortion_sd,
seed=args.seed + 1)
train_params = dict(
distortion=train_distortion,
variable_binning=args.variable_binning,
start=args.start,
varying_start_value=args.varying_start_value,
n_agents=args.n_agents,
timesteps=args.timesteps,
compute_fiv=args.compute_frequency_increment_values,
)
train_loader = DataLoader(
train_params,
batch_size=args.batch_size,
seed=args.seed,
distortion=args.distortion,
n_sims=args.n_sims,
train=True,
n_workers=args.n_workers,
normalize_samples=args.normalize_samples,
)
val_params = dict(
distortion=val_distortion,
variable_binning=args.variable_binning,
start=args.start,
varying_start_value=args.varying_start_value,
n_agents=args.n_agents,
timesteps=args.timesteps,
compute_fiv=args.compute_frequency_increment_values,
)
val_loader = DataLoader(
val_params,
batch_size=args.batch_size,
seed=args.seed + 1,
distortion=args.distortion,
n_sims=int(args.val_size * args.n_sims),
train=False,
n_workers=args.n_workers,
normalize_samples=args.normalize_samples,
)
if args.cuda and torch.cuda.is_available():
device = torch.device("cuda")
print("Using GPU")
else:
device = torch.device("cpu")
if args.model == "FCN":
model = FCN(1, 1)
elif args.model == "LSTMFCN":
model = LSTMFCN(args.hidden_size, 1, args.num_layers, 1, args.dropout,
args.rnn_dropout, args.bidirectional)
elif args.model == "INCEPTION":
model = InceptionTime(1, 1)
else:
model = ResNet(1)
model = model.to(device)
trainer = Trainer(model, train_loader, val_loader, device=device)
trainer.fit(args.n_epochs,
learning_rate=args.learning_rate,
lr_patience=args.learning_rate_patience,
early_stop_patience=args.early_stop_patience,
evaluation_maximum=args.evaluation_maximum)
run_id = str(uuid.uuid1())[:8] if args.outfile is None else args.outfile
trainer.model.eval()
trainer.save_model(run_id)
if args.test:
print("Evaluating the model...")
if args.test_samples is not None:
print("Using precomputed test-samples...")
else:
print("Generating test samples...")
test_samples = args.test_samples if args.test_samples is not None else generate_test_samples(
args.timesteps, args.n_agents, args.n_workers)
nn_results = test_model(model,
test_samples,
args.timesteps,
args.n_agents,
device=device,
normalize_samples=args.normalize_samples)
nn_scores = evaluate_results(nn_results, prefix="NN_")
return run_id, nn_results, nn_scores