def main():
config = configure()
session = tf.Session()
task = tasks.load(config)
channel = channels.load(config)
model = models.load(config)
desc_model = models.desc_im.DescriptionImitationModel()
translator = translators.load(config)
rollout_ph = experience.RolloutPlaceholders(task, config)
replay_ph = experience.ReplayPlaceholders(task, config)
reconst_ph = experience.ReconstructionPlaceholders(task, config)
channel.build(config)
model.build(task, rollout_ph, replay_ph, channel, config)
desc_model.build(task, rollout_ph, replay_ph, channel, config)
translator.build(task, reconst_ph, channel, model, config)
if config.task.train:
trainer.run(task, rollout_ph, replay_ph, reconst_ph, model, desc_model,
translator, session, config)
else:
trainer.load(session, config)
if config.task.lexicon:
lex = lexicographer.run(task, rollout_ph, reconst_ph, model,
desc_model, translator, session, config)
if config.task.visualize:
visualizer.run(lex, task, config)
if config.task.calibrate:
calibrator.run(task, rollout_ph, model, desc_model, lexicographer,
session, config)
if config.task.evaluate:
evaluator.run(task, rollout_ph, replay_ph, reconst_ph, model,
desc_model, lex, session, config)
sem_evaluator.run(task, rollout_ph, reconst_ph, model, desc_model,
translator, lex, session, config)
if config.task.turkify:
turkifier.run(task, rollout_ph, model, lex, session, config)
def test_e2e_local() -> None:
with tempfile.TemporaryDirectory() as temp_dir:
train_data_dir = os.path.join(temp_dir, "datasets", "train")
eval_data_dir = os.path.join(temp_dir, "datasets", "eval")
model_dir = os.path.join(temp_dir, "model")
tensorboard_dir = os.path.join(temp_dir, "tensorboard")
checkpoint_dir = os.path.join(temp_dir, "checkpoints")
# Create the dataset TFRecord files.
create_datasets.run(
raw_data_dir="test_data",
raw_labels_dir="test_data",
train_data_dir=train_data_dir,
eval_data_dir=eval_data_dir,
train_eval_split=[80, 20],
)
assert os.listdir(train_data_dir), "no training files found"
assert os.listdir(eval_data_dir), "no evaluation files found"
# Train the model and save it.
trainer.run(
train_data_dir=train_data_dir,
eval_data_dir=eval_data_dir,
model_dir=model_dir,
tensorboard_dir=tensorboard_dir,
checkpoint_dir=checkpoint_dir,
train_epochs=2,
batch_size=8,
)
assert os.listdir(model_dir), "no model files found"
assert os.listdir(tensorboard_dir), "no tensorboard files found"
assert os.listdir(checkpoint_dir), "no checkpoint files found"
# Load the trained model and make a prediction.
with open("test_data/56980685061237.npz", "rb") as f:
input_data = pd.DataFrame(np.load(f)["x"])
predictions = predict.run(model_dir, input_data.to_dict("list"))
# Check that we get non-empty predictions.
assert "is_fishing" in predictions
assert len(predictions["is_fishing"]) > 0
'predictions': layers_lib.softmax(logits, scope='Predictions'),
}
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
loss = tf.losses.sparse_softmax_cross_entropy(logits=logits, labels=labels)
tf.summary.scalar('loss', loss)
eval_metric_ops = {
'accuracy_val': tf.metrics.accuracy(labels=labels, predictions=predictions['argmax'])
}
if mode == tf.estimator.ModeKeys.EVAL:
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=params['learning_rate'])
extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(extra_update_ops):
train_op = optimizer.minimize(loss=loss, global_step=tf.train.get_global_step())
tf.summary.scalar('accuracy_train', eval_metric_ops['accuracy_val'][1])
tf.summary.histogram('labels', labels)
tf.summary.histogram('predictions', predictions['argmax'])
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)
if __name__ == '__main__':
trainer.run(model_fn=model_fn)
hidden = tf.nn.max_pool(hidden, [1, 3, 3, 1], [1, 2, 2, 1],
padding='SAME')
print hidden.shape
conv21 = tf.nn.conv2d(hidden, W21, [1, 2, 2, 1], padding='SAME')
conv22 = tf.nn.conv2d(hidden, W22, [1, 1, 1, 1], padding='SAME')
conv22 = tf.nn.conv2d(conv22, W222, [1, 1, 1, 1], padding='SAME')
conv22 = tf.nn.conv2d(conv22, W223, [1, 2, 2, 1], padding='SAME')
conv23 = tf.nn.conv2d(hidden, W23, [1, 1, 1, 1], padding='SAME')
conv23 = tf.nn.conv2d(conv23, W232, [1, 1, 1, 1], padding='SAME')
conv23 = tf.nn.conv2d(conv23, W233, [1, 1, 1, 1], padding='SAME')
conv23 = tf.nn.conv2d(conv23, W234, [1, 1, 1, 1], padding='SAME')
conv23 = tf.nn.conv2d(conv23, W235, [1, 2, 2, 1], padding='SAME')
pool2 = tf.nn.max_pool(hidden, [1, 3, 3, 1], [1, 2, 2, 1],
padding='SAME')
conv242 = tf.nn.conv2d(pool2, W242, [1, 1, 1, 1], padding='SAME')
hidden = tf.concat([conv21, conv22, conv23, conv242], axis=3)
hidden = tf.nn.relu(hidden + B2)
print hidden.shape
shape = hidden.get_shape().as_list()
reshape = tf.reshape(hidden,
[shape[0], shape[1] * shape[2] * shape[3]])
hidden = tf.nn.relu(tf.matmul(reshape, W3) + B3)
print hidden.shape
if training:
hidden = tf.nn.dropout(hidden, keep_prob)
return tf.matmul(hidden, W4) + B4
# Test accuracy: 93.2% after 1001 steps
trainer.run(graph, model, num_steps=1001)
# Display metric as title on top of spectrogram
axes[3 * i, 1].set_title('Metric: {:0.3f}'.format(sel_metric[i]),
fontdict={'fontsize': 10},
loc='right')
# Remove axis borders
for i in range(axes.shape[0]):
for j in range(axes.shape[1]):
for spine in axes[i, j].spines.values():
spine.set_visible(False)
plt.tight_layout()
plt.draw()
if args.eval_set is not None:
fig_path = os.path.join(args.save_dir, args.eval_set + '.pdf')
else:
fig_path = os.path.join(args.save_dir, 'visualize.pdf')
plt.savefig(fig_path)
plt.pause(1.0 if args.test else 0.001)
def save_results(self, results, args):
"""Save results to video."""
pass
if __name__ == "__main__":
args = VidTIMITTrainer.parser.parse_args()
trainer = VidTIMITTrainer(args)
trainer.run(args)
print incept.shape
return incept
graph = tf.Graph()
with graph.as_default():
# Model.
def model(data, training=True):
incept1 = model_inception(data, *incept_lst1)
incept2 = model_inception(incept1, *incept_lst2)
#flatten features for fully connected layer
shape = incept2.get_shape().as_list()
flat = tf.reshape(incept2, [-1, shape[1] * shape[2] * shape[3]])
#Fully connected layers
fc1 = tf.nn.relu(tf.matmul(flat, Wfc_1) + Bfc_1)
print fc1.shape
if training:
fc1 = tf.nn.dropout(fc1, keep_prob)
return tf.matmul(fc1, Wfc_2) + Bfc_2
incept_lst1 = create_inception_vars(num_channels, reduce1, map1)
incept_lst2 = create_inception_vars(4 * map1, reduce2, map2)
Wfc_1 = create_weight([image_size * image_size * map2 /4, num_fc1])
Bfc_1 = create_bias([num_fc1])
Wfc_2 = create_weight([num_fc1, num_labels])
Bfc_2 = create_bias([num_labels])
# Test accuracy: 93.2% after 1001 steps
trainer.run(graph, model, num_steps=401, use_previous=1)
default=0.01,
type=float,
help='The lerp rate for diff_avg.')
parser.add_argument('--lerp_lambda',
default=0.,
type=float,
help='Lerp lambda.')
parser.add_argument('--neg_lambda',
default=1.,
type=float,
help='negative samples lambda.')
parser.add_argument('--train_with_vae',
default=False,
type=_str_to_bool,
help='If train diffdim with vae.')
# DimVar-VAE
parser.add_argument(
'--eval_dataset',
default=None,
type=str,
choices=['flatland', 'dsprites', 'teapot', 'teapot_nocolor', 'shapes3d'])
parser.add_argument('--eval_data_path', default=None, type=str)
args = parser.parse_args()
if __name__ == '__main__':
from models.utils import ContextTimer
with ContextTimer('Run'):
run(args)
from trainer import run
# Best Params Linear Runner
training_batch_size = 512
validation_batch_size = 100000
test_batch_size = 10000
epochs = 20
learning_rate = 1e-2
training_show_every = 20
check_validation_every = 40
validation_split = 0.2
model_params = {'model_name': 'linear', 'l2_param': 1e-5}
run(training_batch_size, validation_batch_size, test_batch_size, model_params,
epochs, learning_rate, training_show_every, check_validation_every,
validation_split)
help='GCS storage bucket path where data and models would be stored')
parser_trainer.add_argument(
'--scale_tier',
action='store_const',
const='BASIC_GPU',
help=('The training on Ml Engine will use BASIC_GPU scale_tier. \n'
'Refer the GCP ML-Engine documentation for more info'))
parser_trainer.add_argument(
'--vocab_size',
default=20000,
type=int,
help='Vocabulary Size to create the data records')
parser_trainer.add_argument(
'--region',
default='us-central1',
help='Region where to run training of the model')
args = parser.parse_args()
version = _get_latest_version(args.local_working_dir, args.mode)
if args.mode == 'label':
version += 1
labeller.run(args.data_csv_file, version, args.local_working_dir)
print('\nNew version {} created\n'.format(version))
elif args.mode == 'train':
args.gcs_working_dir = args.gcs_working_dir.rstrip('/')
if args.version:
version = args.version
trainer.run(version, args.local_working_dir, args.vocab_size,
args.gcs_working_dir, args.region, args.scale_tier)
tf.truncated_normal([5, 5, num_channels, depth], stddev=0.1))
B1 = tf.Variable(tf.zeros([depth]))
W2 = tf.Variable(tf.truncated_normal([5, 5, depth, depth], stddev=0.1))
B2 = tf.Variable(tf.constant(1.0, shape=[depth]))
W3 = tf.Variable(
tf.truncated_normal(
[image_size // 4 * image_size // 4 * depth, num_hidden],
stddev=0.1))
B3 = tf.Variable(tf.constant(1.0, shape=[num_hidden]))
W4 = tf.Variable(tf.truncated_normal([num_hidden, num_labels], stddev=0.1))
B4 = tf.Variable(tf.constant(1.0, shape=[num_labels]))
# Model.
def model(data, training=True):
conv = tf.nn.conv2d(data, W1, [1, 2, 2, 1], padding='SAME')
hidden = tf.nn.relu(conv + B1)
print hidden.shape
hidden = tf.nn.max_pool(hidden, [1, 3, 3, 1], [1, 2, 2, 1],
padding='SAME')
print hidden.shape
shape = hidden.get_shape().as_list()
reshape = tf.reshape(hidden,
[shape[0], shape[1] * shape[2] * shape[3]])
hidden = tf.nn.relu(tf.matmul(reshape, W3) + B3)
print hidden.shape
return tf.matmul(hidden, W4) + B4
trainer.run(graph, model)
def main(config):
if not (os.path.exists(rawAudioPath) and os.path.exists(metadataPathTrain) and os.path.exists(metadataPathTest)):
print("The audio data and csv metadata must be located in the following paths:\n"
f"1. {rawAudioPath}\n2. {metadataPathTrain}\n3. {metadataPathTest}")
sys.exit()
config = parseArgs(config)
setSeed(config.randomSeed)
logs = {"epoch": [], "iter": [], "saveStep": config.saveStep, "loggingStep": config.loggingStep}
loadOptimizer = False
if config.pathCheckpoint is not None:
cdata = getCheckpointData(config.pathCheckpoint)
if cdata is not None:
data, logs, locArgs = cdata
print(f"Checkpoint detected at {data}")
loadArgs(config, locArgs, forbiddenAttr={"nGPU", "pathCheckpoint", "maxChunksInMem", "chunkSize"})
config.load, loadOptimizer = [data], True
config.loadCriterion = True
print(f'CONFIG: \n{json.dumps(vars(config), indent=4, sort_keys=True)}')
print('-' * 50)
useGPU = torch.cuda.is_available()
metadata_dir = f'data/musicnet_metadata_train_transcription_{config.labelsBy}_trainsplit.csv' if \
config.transcriptionWindow is not None \
else f'data/musicnet_metadata_train_{config.labelsBy}_trainsplit.csv'
if not os.path.exists(metadata_dir):
# if config.transcriptionWindow is not None:
# musicNetMetadataTrain = pd.read_csv('data/musicnet_metadata_transcript_train_alldata.csv')
# else:
musicNetMetadataTrain = pd.read_csv('data/musicnet_metadata_train.csv', index_col = 'id')
try:
if config.transcriptionWindow is not None:
metadataTrain, metadataVal = train_test_split(musicNetMetadataTrain, test_size=0.1)
# stratify=musicNetMetadataTrain[config.labelsBy])
else:
metadataTrain, metadataVal = train_test_split(musicNetMetadataTrain, test_size=0.1,
stratify=musicNetMetadataTrain[config.labelsBy])
print(metadataTrain.shape, metadataVal.shape)
except ValueError:
for col, count in zip(musicNetMetadataTrain[config.labelsBy].value_counts().index,
musicNetMetadataTrain[config.labelsBy].value_counts().values):
if count == 1:
subDF = musicNetMetadataTrain.loc[musicNetMetadataTrain[config.labelsBy] == col]
musicNetMetadataTrain = musicNetMetadataTrain.append(subDF)
metadataTrain, metadataVal = train_test_split(musicNetMetadataTrain, test_size=0.1,
stratify=musicNetMetadataTrain[config.labelsBy])
if config.transcriptionWindow is not None:
musicNetMetadataTranscript = pd.read_csv('data/musicnet_metadata_transcript_train_alldata.csv')
metadataTrain = musicNetMetadataTranscript[musicNetMetadataTranscript['id'].isin(metadataTrain.index)]
metadataVal = musicNetMetadataTranscript[musicNetMetadataTranscript['id'].isin(metadataVal.index)]
metadataTrain.to_csv(f'data/musicnet_metadata_train_transcription_{config.labelsBy}_trainsplit.csv')
metadataVal.to_csv(f'data/musicnet_metadata_train_transcription_{config.labelsBy}_valsplit.csv')
else:
metadataTrain.to_csv(f'data/musicnet_metadata_train_{config.labelsBy}_trainsplit.csv')
metadataVal.to_csv(f'data/musicnet_metadata_train_{config.labelsBy}_valsplit.csv')
else:
if config.transcriptionWindow is not None:
metadataTrain = pd.read_csv(f'data/musicnet_metadata_train_transcription_{config.labelsBy}_trainsplit.csv')
metadataVal = pd.read_csv(f'data/musicnet_metadata_train_transcription_{config.labelsBy}_valsplit.csv')
else:
metadataTrain = pd.read_csv(f'data/musicnet_metadata_train_{config.labelsBy}_trainsplit.csv', index = 'id')
metadataVal = pd.read_csv(f'data/musicnet_metadata_train_{config.labelsBy}_valsplit.csv', index = 'id')
print("Loading the training dataset")
trainDataset = AudioBatchData(rawAudioPath=rawAudioPath,
metadata=metadataTrain,
sizeWindow=config.sizeWindow,
labelsBy=config.labelsBy,
outputPath='data/musicnet_lousy/train_data/train',
CHUNK_SIZE=config.chunkSize,
NUM_CHUNKS_INMEM=config.maxChunksInMem,
useGPU=useGPU,
transcript_window=config.transcriptionWindow)
print("Training dataset loaded")
print("")
print("Loading the validation dataset")
valDataset = AudioBatchData(rawAudioPath=rawAudioPath,
metadata=metadataVal,
sizeWindow=config.sizeWindow,
labelsBy=config.labelsBy,
outputPath='data/musicnet_lousy/train_data/val',
CHUNK_SIZE=config.chunkSize,
NUM_CHUNKS_INMEM=config.maxChunksInMem,
useGPU=False,
transcript_window=config.transcriptionWindow)
print("Validation dataset loaded")
print("")
if config.load is not None:
cpcModel, config.hiddenGar, config.hiddenEncoder = loadModel(config.load, config)
else:
# Encoder network
encoderNet = CPCEncoder(config.hiddenEncoder, 'layerNorm', sincNet=config.encoderType == 'sinc')
# AR Network
arNet = getAR(config)
cpcModel = CPCModel(encoderNet, arNet)
batchSize = config.batchSize
cpcModel.supervised = config.supervised
# Training criterion
if config.load is not None and config.loadCriterion:
cpcCriterion = loadCriterion(config.load[0], cpcModel.gEncoder.DOWNSAMPLING,
len(metadataTrain[config.labelsBy].unique()))
else:
cpcCriterion = getCriterion(config, cpcModel.gEncoder.DOWNSAMPLING,
len(metadataTrain[config.labelsBy].unique())) # change for transcription labels
if loadOptimizer:
stateDict = torch.load(config.load[0], 'cpu')
cpcCriterion.load_state_dict(stateDict["cpcCriterion"])
if useGPU:
cpcCriterion.cuda()
cpcModel.cuda()
# Optimizer
gParams = list(cpcCriterion.parameters()) + list(cpcModel.parameters())
lr = config.learningRate
optimizer = torch.optim.Adam(gParams, lr=lr, betas=(config.beta1, config.beta2), eps=config.epsilon)
if loadOptimizer:
print("Loading optimizer " + config.load[0])
state_dict = torch.load(config.load[0], 'cpu')
if "optimizer" in state_dict:
optimizer.load_state_dict(state_dict["optimizer"])
# Checkpoint
expDescription = f'{config.samplingType}_'
if config.samplingType == 'samecategory':
expDescription += f'{config.labelsBy}_'
pathCheckpoint = f'logs/{expDescription}{datetime.now().strftime("%d-%m_%H-%M-%S")}'
os.makedirs(pathCheckpoint, exist_ok=True)
pathCheckpoint = os.path.join(pathCheckpoint, "checkpoint")
scheduler = None
if config.schedulerStep > 0:
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
config.schedulerStep,
gamma=0.5)
if config.schedulerRamp is not None:
n_epoch = config.schedulerRamp
print(f"Ramp activated. n_e = {n_epoch}")
scheduler_ramp = torch.optim.lr_scheduler.LambdaLR(optimizer,
lr_lambda=lambda epoch: rampSchedulingFunction(n_epoch,
epoch),
last_epoch=-1)
if scheduler is None:
scheduler = scheduler_ramp
else:
scheduler = SchedulerCombiner([scheduler_ramp, scheduler], [0, config.schedulerRamp])
if scheduler is not None:
for i in range(len(logs["epoch"])):
scheduler.step()
experiment = None
if config.log2Board:
comet_ml.init(project_name="jtm", workspace="tiagocuervo")
if not os.path.exists('.comet.config'):
cometKey = input("Please enter your Comet.ml API key: ")
experiment = comet_ml.Experiment(cometKey)
cometConfigFile = open(".comet.config", "w")
cometConfigFile.write(f"[comet]\napi_key={cometKey}")
cometConfigFile.close()
else:
experiment = comet_ml.Experiment()
experiment.log_parameters(vars(config))
run(trainDataset, valDataset, batchSize, config.samplingType, cpcModel, cpcCriterion, config.nEpoch, optimizer,
scheduler, pathCheckpoint, logs, useGPU, log2Board=config.log2Board, experiment=experiment)
