def main():
ttv_info = ttv_yaml_to_dict(THIS_DIR + 'ttv_berlin.yaml')
print("GETTING SPECTORGRAM DATA...")
spectrogram_data = ttv_to_spectrograms(
ttv_info,
normalise_waveform=normalise,
normalise_spectrogram=slice_spectrogram,
cache=THIS_DIR + 'berlin')
emotion = 'happy'
test, train, val = ttv_data = learning.split_ttv(spectrogram_data,
category=emotion)
test['x'] = np.reshape(test['x'], (test['x'].shape[0], ) + (1, ) +
test['x'].shape[1:])
train['x'] = np.reshape(train['x'], (train['x'].shape[0], ) + (1, ) +
train['x'].shape[1:])
val['x'] = np.reshape(val['x'],
(val['x'].shape[0], ) + (1, ) + val['x'].shape[1:])
learning.train(
make_model,
ttv_data,
'model_happy',
path_to_results=THIS_DIR,
generate_callbacks=generate_callbacks,
number_of_epochs=200,
dry_run=False,
end_training=lambda x: x >= 1,
# classification='happy'
# to_terminal=True
# class_weight={0:10, 1:1}
)
def main():
ttv_info = ttv_yaml_to_dict(THIS_DIR + 'ttv_rb.yaml')
print("GETTING SPECTORGRAM DATA...")
spectrogram_data = ttv_to_spectrograms(
ttv_info,
normalise_waveform=normalise,
normalise_spectrogram=slice_spectrogram,
cache=THIS_DIR
)
for emotion in EMOTIONS:
print('TRAINING ON:', emotion)
test, train, val = ttv_data = learning.split_ttv(spectrogram_data, category=emotion)
test['x'] = np.reshape(test['x'], (test['x'].shape[0] ,) + (1,) + test['x'].shape[1:] )
train['x'] = np.reshape(train['x'], (train['x'].shape[0],) + (1,) + train['x'].shape[1:] )
val['x'] = np.reshape(val['x'], (val['x'].shape[0] ,) + (1,) + val['x'].shape[1:] )
learning.train(
make_model,
ttv_data,
'model_' + emotion,
path_to_results=THIS_DIR,
generate_callbacks=generate_callbacks,
number_of_epochs=200,
dry_run=False,
end_training=lambda x: x>=1,
# classification='happy'
# to_terminal=True
class_weight={0:1, 1:100}
)
def main():
ttv_info = ttv_yaml_to_dict(THIS_DIR + '../ttvs/ttv_rb.yaml')
print("GETTING SPECTORGRAM DATA...")
spectrogram_data = ttv_to_spectrograms(
ttv_info,
normalise_waveform=normalise,
normalise_spectrogram=slice_spectrogram,
cache=THIS_DIR
)
test, train, val = ttv_data = learning.split_ttv(spectrogram_data)
# test['x'] = np.reshape(test['x'], (test['x'].shape[0] ,) + (1,) + test['x'].shape[1:] )
# train['x'] = np.reshape(train['x'], (train['x'].shape[0],) + (1,) + train['x'].shape[1:] )
# val['x'] = np.reshape(val['x'], (val['x'].shape[0] ,) + (1,) + val['x'].shape[1:] )
learning.train(
make_model,
ttv_data,
THIS_DIR + 'model',
path_to_results=THIS_DIR,
generate_callbacks=generate_callbacks,
number_of_epochs=200
)
def main():
option = 'n'
print '---------------------------------------------------'
print 'MATHEMATICAL EXPRESSION RECOGNITION AND EVALUATION'
print '---------------------------------------------------'
while option != 'q':
print 'Main Menu (Classifier: ' + svm_nn + ')'
print '(s)Standalone Mode \n(S)Server Mode \n(t)Train \n(g)Generate Training Set \n(e)Test \n(c)Change Classifier \n(q)Quit'
option = str(raw_input('Option: '))
if option == 'q':
break
elif option == 't':
learning.train()
elif option == 'g':
learning.generateTrainingSet()
elif option == 'e':
imageFileName = str(raw_input('Enter image file name : '))
if imageFileName == 'q':
continue
test(imageFileName)
elif option == 's':
print 'Started in Standalone mode'
imageFileName = str(raw_input('Enter image file name : '))
if imageFileName == 'q':
continue
standalone(imageFileName)
elif option == 'S':
server()
elif option == 'c':
changeClassifier()
else:
print 'Please enter a valid option'
def train(self, event):
# Save the new training examples and start trainging
import learning as Ln
import scipy.io as spio
Total = {'X': self.X, 'y': self.y}
spio.savemat('sample.mat', Total)
showinfo(
"Training",
"Press 'OK' to start! \nThere'll be another window appear when finished!\nPLEASE WAIT\n"
)
Ln.train('sample.mat', 'Theta.mat')
showinfo("Training", "Training Finished!")
def train_all_image_in_folder(foldername, status):
#foldername: string, status: one hot [0,1] (yes) or [1,0] (no)
trlabel = []
trfeat = []
#input all image file in folder
for file in os.listdir(foldername):
if file.endswith('.png') or file.endswith('.jpg') or file.endswith(
'.jpeg'):
train_array = convert_to_ndarray(foldername + '/' + file, [56, 56])
trfeat.append(train_array)
trlabel.append(status)
train(trfeat, trlabel)
def main():
ttv_info = ttv_yaml_to_dict(THIS_DIR + 'ttv1.yaml')
print("GETTING WAVEFORM DATA...")
ttv_data = ttv_to_waveforms(ttv_info, normalise=normalise, cache=THIS_DIR + 'ttv1.cache.hdf5')
learning.train(
make_mlp_model,
ttv_data,
'experiment1',
path_to_results='experiments/RAVDESS_MLP',
generate_callbacks=generate_callbacks,
number_of_epochs=2,
# dry_run=True,
to_terminal=True
)
def main(argv=None):
train_sources, train_targets, valid_sources, valid_targets, test_sources, test_targets, \
source_vocab, source_idx2char, target_vocab, target_idx2char = prepare_g2p_data(FLAGS)
expeirment = Experiment(source_vocab, source_idx2char, target_vocab,
target_idx2char, FLAGS, VERSION)
if not FLAGS.eval_only:
train(train_sources, train_targets, valid_sources, valid_targets,
expeirment, "[TR]")
ops.reset_default_graph()
if FLAGS.model_parameter_saving or FLAGS.eval_only:
test(valid_sources, valid_targets, test_sources, test_targets,
expeirment, "[TE]")
def main():
ttv_info = ttv_yaml_to_dict(THIS_DIR + 'ttv1.yaml')
print("GETTING WAVEFORM DATA...")
ttv_data = ttv_to_waveforms(ttv_info,
normalise=normalise,
cache=THIS_DIR + 'ttv1.cache.hdf5')
learning.train(
make_mlp_model,
ttv_data,
'experiment1',
path_to_results='experiments/RAVDESS_MLP',
generate_callbacks=generate_callbacks,
number_of_epochs=2,
# dry_run=True,
to_terminal=True)
def reset(self):
# Replace 'sample.mat' by 'reset.mat' and train again
showinfo(
"Reset",
"Press 'OK' to start! \nThere'll be another window appear when finished!\nPLEASE WAIT\n"
)
import os
from shutil import copy
try:
os.remove('sample.mat')
copy('reset.mat', 'sample.mat')
except:
print "File Error"
showinfo(
"Reset",
"Error while reset!\n(file missing or permission denied)")
return None
import learning as LN
LN.train('sample.mat', 'Theta.mat')
showinfo("Reset", "Reset successfully!")
def main():
ttv_file = 'ttv_bt.yaml'
ttv_info = yaml_to_dict(THIS_DIR + ttv_file)
print("GETTING SPECTORGRAM DATA...")
spectrogram_data = ttv_to_spectrograms(
ttv_info,
normalise_waveform=normalise_waveform,
normalise_spectrogram=slice_spectrogram,
cache=THIS_DIR,
)
test, train, validation = ttv_data = learning.split_ttv(spectrogram_data)
learning.train(make_mlp_model,
ttv_data,
'mlp_spectrogram_' + ttv_file.split('.')[0],
path_to_results=THIS_DIR,
generate_callbacks=generate_callbacks,
number_of_epochs=200,
dry_run=False
# to_terminal=True
)
def main():
ttv_info = ttv_yaml_to_dict(THIS_DIR + '../ttvs/ttv_rb.yaml')
print("GETTING SPECTORGRAM DATA...")
spectrogram_data = ttv_to_spectrograms(
ttv_info,
normalise_waveform=normalise,
normalise_spectrogram=slice_spectrogram,
cache=THIS_DIR)
test, train, val = ttv_data = learning.split_ttv(spectrogram_data)
# test['x'] = np.reshape(test['x'], (test['x'].shape[0] ,) + (1,) + test['x'].shape[1:] )
# train['x'] = np.reshape(train['x'], (train['x'].shape[0],) + (1,) + train['x'].shape[1:] )
# val['x'] = np.reshape(val['x'], (val['x'].shape[0] ,) + (1,) + val['x'].shape[1:] )
learning.train(make_model,
ttv_data,
THIS_DIR + 'model',
path_to_results=THIS_DIR,
generate_callbacks=generate_callbacks,
number_of_epochs=200)
def main():
ttv_info = ttv_yaml_to_dict(THIS_DIR + 'ttv1.yaml')
print("GETTING WAVEFORM DATA...")
ttv_data = ttv_to_waveforms(ttv_info, normalise=normalise, cache=THIS_DIR + 'ttv1.cache.hdf5')
test, train, val = ttv_data
test['x'] = np.reshape(test['x'], test['x'].shape + (1,))
train['x'] = np.reshape(train['x'], train['x'].shape + (1,))
val['x'] = np.reshape(val['x'], val['x'].shape + (1,))
learning.train(
make_mlp_model,
ttv_data,
'1D_CNN_RAVDESS',
path_to_results='experiments/RAVDESS_MLP',
generate_callbacks=generate_callbacks,
number_of_epochs=200,
dry_run=True,
to_terminal=True
)
def main():
ttv_file = 'ttv_bt.yaml'
ttv_info = yaml_to_dict(THIS_DIR + ttv_file)
print("GETTING SPECTORGRAM DATA...")
spectrogram_data = ttv_to_spectrograms(
ttv_info,
normalise_waveform=normalise_waveform,
normalise_spectrogram=slice_spectrogram,
cache=THIS_DIR,
)
test, train, validation = ttv_data = learning.split_ttv(spectrogram_data)
learning.train(
make_mlp_model,
ttv_data,
'mlp_spectrogram_' + ttv_file.split('.')[0],
path_to_results=THIS_DIR,
generate_callbacks=generate_callbacks,
number_of_epochs=200,
dry_run=False
# to_terminal=True
)
def main(_):
assert six.PY3
assert 1 == FLAGS.num_clones
if not FLAGS.dataset_dir:
raise ValueError(
'You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
#######################
# Config model_deploy #
#######################
deploy_config = model_deploy.DeploymentConfig(
num_clones=FLAGS.num_clones,
clone_on_cpu=FLAGS.clone_on_cpu,
replica_id=FLAGS.task,
num_replicas=FLAGS.worker_replicas,
num_ps_tasks=FLAGS.num_ps_tasks)
# Create global_step
with tf.device(deploy_config.variables_device()):
global_step = slim.create_global_step()
######################
# Select the dataset #
######################
dataset = trainset
######################
# Select the network #
######################
network_fn = nets_factory.get_network_fn(
FLAGS.model_name,
num_classes=(dataset.num_classes - FLAGS.labels_offset),
weight_decay=FLAGS.weight_decay,
is_training=True)
#####################################
# Select the preprocessing function #
#####################################
preprocessing_name = FLAGS.preprocessing_name or FLAGS.model_name
image_preprocessing_fn = trainset.get_tf_preprocess_image(
is_training=True)
##############################################################
# Create a dataset provider that loads data from the dataset #
##############################################################
with tf.device(deploy_config.inputs_device()):
assert FLAGS.train_image_size is not None
# assert FLAGS.train_image_size == network_fn.default_image_size
train_image_size = FLAGS.train_image_size or network_fn.default_image_size
####################
# Define the model #
####################
def clone_fn(batch_queue):
"""Allows data parallelism by creating multiple clones of network_fn."""
images = tf.placeholder(tf.float32,
shape=(FLAGS.batch_size, train_image_size,
train_image_size, 3))
labels = tf.placeholder(tf.float32,
shape=(FLAGS.batch_size,
dataset.num_classes))
trainset.set_holders(images, labels)
logits, end_points = network_fn(
tf.concat([
tf.expand_dims(
image_preprocessing_fn(images[i], train_image_size,
train_image_size), 0)
for i in range(FLAGS.batch_size)
], 0))
logits = tf.squeeze(logits)
#############################
# Specify the loss function #
#############################
if 'AuxLogits' in end_points:
slim.losses.softmax_cross_entropy(
end_points['AuxLogits'],
labels,
label_smoothing=FLAGS.label_smoothing,
weights=0.4,
scope='aux_loss')
slim.losses.softmax_cross_entropy(
logits,
labels,
label_smoothing=FLAGS.label_smoothing,
weights=1.0)
return end_points
# Gather initial summaries.
summaries = set(tf.get_collection(tf.GraphKeys.SUMMARIES))
clones = model_deploy.create_clones(deploy_config, clone_fn, [None])
first_clone_scope = deploy_config.clone_scope(0)
# Gather update_ops from the first clone. These contain, for example,
# the updates for the batch_norm variables created by network_fn.
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS,
first_clone_scope)
# Add summaries for end_points.
end_points = clones[0].outputs
for end_point in end_points:
x = end_points[end_point]
# summaries.add(tf.summary.histogram('activations/' + end_point, x))
summaries.add(
tf.summary.scalar('sparsity/' + end_point,
tf.nn.zero_fraction(x)))
# Add summaries for losses.
for loss in tf.get_collection(tf.GraphKeys.LOSSES, first_clone_scope):
summaries.add(tf.summary.scalar('losses/%s' % loss.op.name, loss))
# Add summaries for variables.
# for variable in slim.get_model_variables():
# summaries.add(tf.summary.histogram(variable.op.name, variable))
#################################
# Configure the moving averages #
#################################
if FLAGS.moving_average_decay:
moving_average_variables = slim.get_model_variables()
variable_averages = tf.train.ExponentialMovingAverage(
FLAGS.moving_average_decay, global_step)
else:
moving_average_variables, variable_averages = None, None
#########################################
# Configure the optimization procedure. #
#########################################
with tf.device(deploy_config.optimizer_device()):
learning_rate = _configure_learning_rate(dataset.num_samples,
global_step)
optimizer = _configure_optimizer(learning_rate)
summaries.add(tf.summary.scalar('learning_rate', learning_rate))
if FLAGS.sync_replicas:
# If sync_replicas is enabled, the averaging will be done in the chief
# queue runner.
optimizer = tf.train.SyncReplicasOptimizer(
opt=optimizer,
replicas_to_aggregate=FLAGS.replicas_to_aggregate,
total_num_replicas=FLAGS.worker_replicas,
variable_averages=variable_averages,
variables_to_average=moving_average_variables)
elif FLAGS.moving_average_decay:
# Update ops executed locally by trainer.
update_ops.append(
variable_averages.apply(moving_average_variables))
# Variables to train.
variables_to_train = _get_variables_to_train()
# and returns a train_tensor and summary_op
total_loss, clones_gradients = model_deploy.optimize_clones(
clones, optimizer, var_list=variables_to_train)
# Add total_loss to summary.
summaries.add(tf.summary.scalar('total_loss', total_loss))
# Create gradient updates.
grad_updates = optimizer.apply_gradients(clones_gradients,
global_step=global_step)
update_ops.append(grad_updates)
update_op = tf.group(*update_ops)
with tf.control_dependencies([update_op]):
train_tensor = tf.identity(total_loss, name='train_op')
# Add the summaries from the first clone. These contain the summaries
# created by model_fn and either optimize_clones() or _gather_clone_loss().
summaries |= set(
tf.get_collection(tf.GraphKeys.SUMMARIES, first_clone_scope))
# Merge all summaries together.
summary_op = tf.summary.merge(list(summaries), name='summary_op')
###########################
# Kicks off the training. #
###########################
session_config = tf.ConfigProto()
session_config.gpu_options.per_process_gpu_memory_fraction = FLAGS.per_process_gpu_memory_fraction
learning.train(
train_tensor,
session_config=session_config,
train_step_fn=train_step,
logdir=FLAGS.train_dir,
master=FLAGS.master,
is_chief=(FLAGS.task == 0),
init_fn=_get_init_fn(),
summary_op=summary_op,
number_of_steps=FLAGS.max_number_of_steps,
log_every_n_steps=FLAGS.log_every_n_steps,
save_summaries_secs=FLAGS.save_summaries_secs,
save_interval_secs=FLAGS.save_interval_secs,
sync_optimizer=optimizer if FLAGS.sync_replicas else None)
f'(acc: {accs[best_index]:.3f}) - evaluation: {time_evaluation:.1f} s, '
f'champion evaluation: {time_champion_evaluation:.1f} s')
writer.add_scalar('best/reward', rewards[best_index], generation)
writer.add_scalar('best/acc', accs[best_index], generation)
if generation % 20 == 0:
if 'long_training_reward' not in champion:
# Train champion net for more epochs.
# TODO: Do this more elegantly. Maybe make an additional
# parameter num_epochs_long.
long_params = params.copy()
long_params['num_epochs'] = 10
champion['net'].create_torch_layers(device)
loss, acc = train(champion['net'],
train_dataset,
long_params,
device=device)
champion['long_training_reward'] = -get_performance_value(
loss, period='last_epoch')
champion['long_training_acc'] = get_performance_value(
acc, period='last_epoch')
# Evaluate this long trained net on test set.
loss, acc = test(champion['net'],
test_dataset,
params,
device=device)
champion['test_reward'] = -loss
champion['test_acc'] = acc
# Manually delete weight matrices, so they don't block memory
import torch.optim as optim
from tqdm import tqdm
import os
from model import Siamese, SuperSiamese
from dataset import TrajectoryDataset, SuperTrajectoryDataset
from learning import train, test
from utils import train_test_split
device = torch.device("cuda")
num_drivers = 500
traj_len = 64
super = 8
n_features = 17
test_split = 0.2
batch_size = 500
num_epochs = 500
# dataset = TrajectoryDataset(traj_len = traj_len, num_drivers = num_drivers, device = device)
# model = Siamese(input_size = n_features).to(device)
dataset = SuperTrajectoryDataset(traj_len = traj_len, super = super, num_drivers = num_drivers, device = device)
model = SuperSiamese(input_size = n_features, split = super).to(device)
trainloader, testloader = train_test_split(dataset, test_split, batch_size)
model = train(model, trainloader, testloader, device, num_epochs)
model.save('model.pth')
import numpy as np
import torch
from torch import nn, optim
from torch.utils.data import DataLoader
import utility, learning
#init parser
parser = ArgumentParser(description="Train neural networks on an image dataset!")
parser.add_argument('data_dir', type=str, help="Directory of the images")
parser.add_argument('--save_dir', type=str, default="", help="Directory to save the model (Default: Current Directory)")
parser.add_argument('--arch', type=str, default="vgg19", help="Neural Network Architecture (Default: vgg19)")
parser.add_argument('--learning_rate', type=float, default="0.001", help="Learningrate (Default: 0.001)")
parser.add_argument('--hidden_units', type=int, default="4096", help="Number of hidden units (Default: 4096)")
parser.add_argument('--epochs', type=int, default="3", help="Number of epochs (Default: 3)")
parser.add_argument('--gpu', action='store_true', help="Use GPU for training (Default: False)")
args = parser.parse_args()
#load and transform data
trainloader, validloader, testloader, class_to_idx = utility.load_transform_data(args.data_dir)
#build model, loss function, and optimizer
model = learning.build_model(args.arch, args.hidden_units, len(class_to_idx), args.gpu)
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(), lr = args.learning_rate)
#train model
learning.train(model, criterion, optimizer, trainloader, validloader, args.epochs, args.gpu)
#save checkpoint
learning.save_model(model, args.arch, criterion, args.epochs, args.learning_rate, optimizer, class_to_idx, args.save_dir)
def main(args):
cuda = False
# gpx_pathfindind_cycling
with open(args.path + "files/osmnx_pathfinding_simplified.df",
'rb') as infile:
df_pathfinding = pickle.load(infile)
with open(args.path + "files/gpx_matched_simplified.df", 'rb') as infile:
df_simplified = pickle.load(infile)
with open(args.path + "files/cluster_dbscan_custom.tab", 'rb') as infile:
tab_clusters = pickle.load(infile)
with open(args.path + "files/voxels_pathfinding.dict", 'rb') as infile:
dict_voxels = pickle.load(infile)
df = df_pathfinding
tab_routes_voxels, _ = voxels.create_dict_vox(df, df.iloc[0]["route_num"],
df.iloc[-1]["route_num"])
tab_routes_voxels_int = []
df_voxels = pd.DataFrame()
df_voxels_train = pd.DataFrame()
df_voxels_test = pd.DataFrame()
for i in range(len(tab_routes_voxels)):
nb_vox = 0
tab_routes_voxels_int.append([])
route = tab_routes_voxels[i]
for vox in route:
if (nb_vox % args.voxels_frequency == 0):
vox_str = vox.split(";")
vox_int = [int(vox_str[0]), int(vox_str[1])]
tab_points = voxels.get_voxel_points(vox_int)
#points = tab_points[0][:2]+tab_points[1][:2]+tab_points[2][:2]+tab_points[3][:2]
if vox not in dict_voxels:
points = [-1, i + 1]
else:
points = [dict_voxels[vox]["cluster"], i + 1]
tab_routes_voxels_int[i].append(points)
nb_vox += 1
'''tab_routes_voxels_int[i] = sorted(tab_routes_voxels_int[i], key=lambda k: dict_voxels[str(voxels.find_voxel_int([k[0],k[1]])[0])+";"+str(voxels.find_voxel_int([k[0],k[1]])[1])]["cyclability_coeff"])
if(len(tab_routes_voxels_int[i])>50):
tab_routes_voxels_int[i] = tab_routes_voxels_int[i][:50]
print(len(tab_routes_voxels_int[i]))'''
df_temp = pd.DataFrame(tab_routes_voxels_int[i], dtype=object)
df_temp["route_num"] = i + 1
df_voxels = df_voxels.append(df_temp)
proba_test = random.random()
if (proba_test >= args.percentage_test / 100):
df_voxels_train = df_voxels_train.append(df_temp)
else:
df_voxels_test = df_voxels_test.append(df_temp)
#print(len(df_voxels), len(df_voxels_train), len(df_voxels_test))
df_train = df_voxels_train
df_test = df_voxels_test
if (len(df_test) == 0):
df_test = df_train
size_data = 1
learning_rate = args.lr
fc = NN(size_data, max(tab_clusters) + 1)
rnn = RNN(size_data, max(tab_clusters) + 1)
lstm = RNN_LSTM(size_data,
max(tab_clusters) + 1, args.hidden_size, args.num_layers)
network = lstm
if (cuda):
network = network.cuda()
optimizer = torch.optim.Adam(network.parameters(), lr=learning_rate)
loss = nn.NLLLoss()
tab_loss, tab_predict = learning.train(df_train, tab_clusters, loss,
optimizer, network, size_data, cuda,
args.num_samples, df_test)
g_predict = learning.test(df_test, None, tab_clusters, size_data, cuda)
print("Random:", g_predict * 100, "%")
g_predict = learning.test(df_test, network, tab_clusters, size_data, cuda)
print("Good predict:", g_predict * 100, "%")
if (g_predict > 0.95):
print("Saving network...")
torch.save(network.state_dict(), args.path + "/files/network_temp.pt")
plt.plot(tab_loss)
plt.ylabel('Error')
plt.show()
plt.plot(tab_predict)
plt.ylabel('Prediction')
plt.show()
'''import torch
def main(_):
if not FLAGS.dataset_dir:
raise ValueError(
'You must supply the dataset directory with --dataset_dir')
tf.logging.set_verbosity(tf.logging.INFO)
with tf.Graph().as_default():
######################
# Config model_deploy#
######################
deploy_config = model_deploy.DeploymentConfig(
num_clones=FLAGS.num_clones,
clone_on_cpu=FLAGS.clone_on_cpu,
replica_id=FLAGS.task,
num_replicas=FLAGS.worker_replicas,
num_ps_tasks=FLAGS.num_ps_tasks)
# Create global_step
with tf.device(deploy_config.variables_device()):
global_step = slim.create_global_step()
######################
# Select the dataset #
######################
dataset = dataset_factory.get_dataset(FLAGS.dataset_name,
FLAGS.dataset_split_name,
FLAGS.dataset_dir)
####################
# Select the network #
####################
network_fn = nets_factory.get_network_fn(
FLAGS.model_name,
num_classes=(dataset.num_classes - FLAGS.labels_offset),
weight_decay=FLAGS.weight_decay,
is_training=True)
#####################################
# Select the preprocessing function #
#####################################
preprocessing_name = FLAGS.preprocessing_name or FLAGS.model_name
image_preprocessing_fn = preprocessing_factory.get_preprocessing(
preprocessing_name, is_training=True)
##############################################################
# Create a dataset provider that loads data from the dataset #
##############################################################
with tf.device(deploy_config.inputs_device()):
provider = slim.dataset_data_provider.DatasetDataProvider(
dataset,
num_readers=FLAGS.num_readers,
common_queue_capacity=20 * FLAGS.batch_size,
common_queue_min=10 * FLAGS.batch_size)
[image, label] = provider.get(['image', 'label'])
label -= FLAGS.labels_offset
train_image_size = FLAGS.train_image_size or network_fn.default_image_size
image = image_preprocessing_fn(image, train_image_size,
train_image_size)
images, labels = tf.train.batch(
[image, label],
batch_size=FLAGS.batch_size,
num_threads=FLAGS.num_preprocessing_threads,
capacity=5 * FLAGS.batch_size)
labels = slim.one_hot_encoding(
labels, dataset.num_classes - FLAGS.labels_offset)
batch_queue = slim.prefetch_queue.prefetch_queue(
[images, labels], capacity=2 * deploy_config.num_clones)
####################
# Define the model #
####################
def clone_fn(batch_queue):
"""Allows data parallelism by creating multiple clones of network_fn."""
images, labels = batch_queue.dequeue()
logits, end_points = network_fn(images)
#############################
# Specify the loss function #
############################
accurancy = 0
global logits_global
global labels_global
logits_global = logits
labels_global = labels
if 'AuxLogits' in end_points:
print('auxlogits')
slim.losses.softmax_cross_entropy(
end_points['AuxLogits'],
labels,
label_smoothing=FLAGS.label_smoothing,
weight=0.4,
scope='aux_loss')
slim.losses.softmax_cross_entropy(
logits,
labels,
label_smoothing=FLAGS.label_smoothing,
weight=1.0)
#predictions = tf.argmax(logits, 1)
#accurancy =
return end_points
return end_points
global logits_global
global labels_global
# Gather initial summaries.
summaries = set(tf.get_collection(tf.GraphKeys.SUMMARIES))
clones = model_deploy.create_clones(deploy_config, clone_fn,
[batch_queue])
print(logits_global)
print(labels_global)
predictions = tf.squeeze(tf.argmax(logits_global, 1))
labels = tf.squeeze(tf.argmax(labels_global, 1))
accurancy = 1.0 - slim.metrics.streaming_accuracy(predictions,
labels)[1]
#accurancies = get_loss(batch_queue)
first_clone_scope = deploy_config.clone_scope(0)
# Gather update_ops from the first clone. These contain, for example,
# the updates for the batch_norm variables created by network_fn.
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS,
first_clone_scope)
# Add summaries for end_points.
end_points = clones[0].outputs
for end_point in end_points:
x = end_points[end_point]
summaries.add(tf.histogram_summary('activations/' + end_point, x))
summaries.add(
tf.scalar_summary('sparsity/' + end_point,
tf.nn.zero_fraction(x)))
# Add summaries for losses.
for loss in tf.get_collection(tf.GraphKeys.LOSSES, first_clone_scope):
summaries.add(tf.scalar_summary('losses/%s' % loss.op.name, loss))
# Add summaries for variables.
for variable in slim.get_model_variables():
summaries.add(tf.histogram_summary(variable.op.name, variable))
#################################
# Configure the moving averages #
#################################
if FLAGS.moving_average_decay:
moving_average_variables = slim.get_model_variables()
variable_averages = tf.train.ExponentialMovingAverage(
FLAGS.moving_average_decay, global_step)
else:
moving_average_variables, variable_averages = None, None
#########################################
# Configure the optimization procedure. #
#########################################
with tf.device(deploy_config.optimizer_device()):
learning_rate = _configure_learning_rate(dataset.num_samples,
global_step)
optimizer = _configure_optimizer(learning_rate)
summaries.add(
tf.scalar_summary('learning_rate',
learning_rate,
name='learning_rate'))
if FLAGS.sync_replicas:
# If sync_replicas is enabled, the averaging will be done in the chief
# queue runner.
optimizer = tf.train.SyncReplicasOptimizer(
opt=optimizer,
replicas_to_aggregate=FLAGS.replicas_to_aggregate,
variable_averages=variable_averages,
variables_to_average=moving_average_variables,
replica_id=tf.constant(FLAGS.task, tf.int32, shape=()),
total_num_replicas=FLAGS.worker_replicas)
elif FLAGS.moving_average_decay:
# Update ops executed locally by trainer.
update_ops.append(
variable_averages.apply(moving_average_variables))
# Variables to train.
variables_to_train = _get_variables_to_train()
# and returns a train_tensor and summary_op
total_loss, clones_gradients = model_deploy.optimize_clones(
clones, optimizer, var_list=variables_to_train)
# Add total_loss to summary.
summaries.add(
tf.scalar_summary('total_loss', total_loss, name='total_loss'))
# Create gradient updates.
grad_updates = optimizer.apply_gradients(clones_gradients,
global_step=global_step)
update_ops.append(grad_updates)
update_op = tf.group(*update_ops)
train_tensor = control_flow_ops.with_dependencies([update_op],
total_loss,
name='train_op')
# Add the summaries from the first clone. These contain the summaries
# created by model_fn and either optimize_clones() or _gather_clone_loss().
summaries |= set(
tf.get_collection(tf.GraphKeys.SUMMARIES, first_clone_scope))
# Merge all summaries together.
summary_op = tf.merge_summary(list(summaries), name='summary_op')
###########################
# Kicks off the training. #
###########################
loss = learning.train(
train_tensor,
logdir=FLAGS.train_dir,
master=FLAGS.master,
is_chief=(FLAGS.task == 0),
init_fn=_get_init_fn(),
summary_op=summary_op,
number_of_steps=FLAGS.max_number_of_steps,
log_every_n_steps=FLAGS.log_every_n_steps,
save_summaries_secs=FLAGS.save_summaries_secs,
save_interval_secs=FLAGS.save_interval_secs,
sync_optimizer=optimizer if FLAGS.sync_replicas else None,
accurancies=accurancy)
print('Training loss: ' + str(loss))
def main(argv):
del argv
# Load data.
dataset_tools = import_module('tools.' + FLAGS.dataset)
train_images, train_labels = dataset_tools.get_data('train')
architecture = getattr(semisup.architectures, FLAGS.architecture)
num_labels = dataset_tools.NUM_LABELS
image_shape = dataset_tools.IMAGE_SHAPE
# Sample labeled training subset.
seed = FLAGS.sup_seed if FLAGS.sup_seed != -1 else None
sup_by_label = semisup.sample_by_label(train_images, train_labels,
FLAGS.sup_per_class, num_labels,
seed)
graph = tf.Graph()
with graph.as_default():
with tf.device(tf.train.replica_device_setter(FLAGS.ps_tasks,
merge_devices=True)):
# Set up inputs.
t_sup_images, t_sup_labels = semisup.create_per_class_inputs(
sup_by_label, FLAGS.sup_per_batch)
if FLAGS.remove_classes:
t_sup_images = tf.slice(
t_sup_images, [0, 0, 0, 0],
[FLAGS.sup_per_batch * (
num_labels - FLAGS.remove_classes)] +
image_shape)
# Resize if necessary.
if FLAGS.new_size > 0:
new_shape = [FLAGS.new_size, FLAGS.new_size, image_shape[-1]]
else:
new_shape = None
# Apply augmentation
if FLAGS.augmentation:
# TODO(haeusser) generalize augmentation
def _random_invert(inputs, _):
randu = tf.random_uniform(
shape=[FLAGS.sup_per_batch * num_labels], minval=0.,
maxval=1.,
dtype=tf.float32)
randu = tf.cast(tf.less(randu, 0.5), tf.float32)
randu = tf.expand_dims(randu, 1)
randu = tf.expand_dims(randu, 1)
randu = tf.expand_dims(randu, 1)
inputs = tf.cast(inputs, tf.float32)
return tf.abs(inputs - 255 * randu)
augmentation_function = _random_invert
else:
augmentation_function = None
# Create function that defines the network.
model_function = partial(
architecture,
new_shape=new_shape,
img_shape=image_shape,
augmentation_function=augmentation_function,
batch_norm_decay=FLAGS.batch_norm_decay,
emb_size=FLAGS.emb_size)
# Set up semisup model.
model = semisup.SemisupModel(model_function, num_labels,
image_shape)
# Compute embeddings and logits.
t_sup_emb = model.image_to_embedding(t_sup_images)
t_sup_logit = model.embedding_to_logit(t_sup_emb)
# Add losses.
model.add_logit_loss(t_sup_logit,
t_sup_labels,
weight=FLAGS.logit_weight)
variables_to_train = [v for v in tf.trainable_variables() if v.name.startswith('net/fully_connected')]
for v in variables_to_train:
print(v.name, v.shape)
# Set up learning rate
t_learning_rate = tf.maximum(
tf.train.exponential_decay(
FLAGS.learning_rate,
model.step,
FLAGS.decay_steps,
FLAGS.decay_factor,
staircase=True),
FLAGS.minimum_learning_rate)
total_loss = tf.losses.get_total_loss()
optimizer = tf.train.AdamOptimizer(t_learning_rate)
variables_to_restore = None
restore_ckpt = None
if FLAGS.pretrained:
variables_to_restore = [v for v in tf.trainable_variables()
if not (v.name.startswith('net/fully_connected'))]
restore_ckpt = FLAGS.pretrained
for v in variables_to_restore:
print(v.name)
learning.train(graph, FLAGS.logdir,
total_loss, optimizer,
variables_to_train, model.step,
num_steps=FLAGS.max_steps, log_interval=20,
summary_interval=100, snapshot_interval=5000,
variables_to_restore=variables_to_restore, restore_ckpt=restore_ckpt)
return
# Create training operation and start the actual training loop.
train_op = model.create_train_op(t_learning_rate)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
# config.log_device_placement = True
saver = tf_saver.Saver(max_to_keep=FLAGS.max_checkpoints,
keep_checkpoint_every_n_hours=FLAGS.keep_checkpoint_every_n_hours) # pylint:disable=line-too-long
slim.learning.train(
train_op,
logdir=FLAGS.logdir + '/train',
save_summaries_secs=FLAGS.save_summaries_secs,
save_interval_secs=FLAGS.save_interval_secs,
master=FLAGS.master,
is_chief=(FLAGS.task == 0),
startup_delay_steps=(FLAGS.task * 20),
log_every_n_steps=FLAGS.log_every_n_steps,
session_config=config,
trace_every_n_steps=1000,
saver=saver,
number_of_steps=FLAGS.max_steps,
)
milestones=[31, 40],
gamma=0.1)
else:
print("type:{}".format(val))
scheduler = lr_scheduler.MultiStepLR(optimizer,
milestones=[16, 30],
gamma=0.1)
# training the model
epochs = 30
isckpt = False # if you want to load model params from checkpoint, set it to True
# print parameters
print("{}: {}, gamma: {}, nparts: {}, epochs: {}".format(
optmeth, lr, gamma1, nparts, epochs))
model = learning.train(model,
dataloader,
criterion,
optimizer,
scheduler,
version=version,
epochs=epochs,
dataName=datasetname)
# print("测试集精度-----------------------")
# rsltparams = modellearning2.eval(model=model, dataloader=dataloader['test'])
#### save model
# modelpath = './models'
#modelname = "{}_parts{}-sc{}-{}--SENet50-full-rglz.model".format(datasetname, nparts, gamma1, lr)
#torch.save(model.state_dict(), save_pkl + modelname)
# Option 1: Apply some random mutations to make the network deeper.
num_mutations = 0
for _ in range(num_mutations):
net.mutate()
#net.add_connection()
logging.info(f'Applied {num_mutations} mutations, network now has {net}')
#net.restructure_layers()
#logging.info('Restructured layers')
# Option 2: Manually add a hidden layer with 500 neurons.
# num_hidden = 500
# net.neurons_per_layer.insert(1, list(range(net.num_neurons, net.num_neurons + num_hidden)))
# net.connections = [] # erase any connections between input and output
# for from_neuron in net.neurons_per_layer[0]: # add connections between input and hidden
# for to_neuron in net.neurons_per_layer[1]:
# net.connections.append([from_neuron, to_neuron])
# for from_neuron in net.neurons_per_layer[1]: # add connections between hidden and output
# for to_neuron in net.neurons_per_layer[2]:
# net.connections.append([from_neuron, to_neuron])
# net.num_neurons += num_hidden
# net.reset_weights() # need to call this manually due to manual changes to architecture
# logging.info(f'Added a hidden layer with {num_hidden} neurons, network now has {net}')
net.create_torch_layers(device)
train(net,
train_dataset,
params,
device=device,
verbose=2,
test_dataset=test_dataset)
import matplotlib.pyplot as plt
import tensorflow as tf
from learning import train, evaluate
from utils import show_images, get_config
if __name__ == "__main__":
# reduce_gpu()
config = get_config()
# training
train(g_pretrained=True, n_trainable=1, generic=False, config=config)
# # evaluation
# im_sr, im_hr, _, _ = evaluate(
# 15, landscapes=True, generic=True, land_class=None)
# show_images(im_sr, im_hr)
