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)