import argparse

import json

import time

import datetime

import numpy as np

import random

import code

import socket

import os

import theano

from theano import config

import theano.tensor as tensor

import cPickle as pickle

from imagernn.data_provider import getDataProvider, prepare_data

from imagernn.solver import Solver

from imagernn.imagernn_utils import decodeEvaluator

from imagernn.utils import numpy_floatX, zipp, unzip, preProBuildWordVocab

from collections import defaultdict

def eval_split_theano(split, dp, model, params, misc, gen_fprop, **kwargs):

return average_score# return the perplexity

#######################################################################################################

def main(params):

use_dropout.set_value(1.)

if __name__ == "__main__":

parser = argparse.ArgumentParser()

# global setup settings, and checkpoints

parser.add_argument('--use_theano', dest='use_theano', default=1, help='Should we use thano and gpu!?. Actually dont try with value 0 :-|')

parser.add_argument('-d', '--dataset', dest='dataset', default='coco', help='dataset: flickr8k/flickr30k')

parser.add_argument('-o', '--checkpoint_output_directory', dest='checkpoint_output_directory', type=str, default='cnnCv/', help='output directory to write checkpoints to')

parser.add_argument('--fappend', dest='fappend', type=str, default='baseline', help='append this string to checkpoint filenames')

parser.add_argument('--worker_status_output_directory', dest='worker_status_output_directory', type=str, default='status/', help='directory to write worker status JSON blobs to')

parser.add_argument('--write_checkpoint_ppl_threshold', dest='write_checkpoint_ppl_threshold', type=float, default=-1, help='ppl threshold above which we dont bother writing a checkpoint to save space')

parser.add_argument('--continue_training', dest='checkpoint_file_name', type=str, default=None, help='checkpoint file from which to resume training')

parser.add_argument('--init_from_imagernn', dest='init_from_imagernn', type=str, default=None, help='Gen model cv to initialize word vecs and image emb from')

# Some parameters about image features used

parser.add_argument('--feature_file', dest='feature_file', type=str, default='vgg_feats.mat', help='Which file should we use for read the CNN features')

parser.add_argument('--image_feat_size', dest='image_feat_size', type=int, default=4096, help='size of the input image features')

parser.add_argument('--data_file', dest='data_file', type=str, default='dataset.json', help='Which dataset file shpuld we use')

parser.add_argument('--mat_new_ver', dest='mat_new_ver', type=int, default=-1, help='If the .mat feature files are saved with new version (compressed) set this flag to 1')

parser.add_argument('--fine_tune', dest='fine_tune', type=int, default=0, help='whether to run on one img at at time or batch_size images')

# model parameters

parser.add_argument('--word_encoding_size', dest='word_encoding_size', type=int, default=512, help='size of word encoding')

parser.add_argument('--sent_encoding_size', dest='sent_encoding_size', type=int, default=512, help='size of sentence encoding layer on top of CNN')

parser.add_argument('--max_sent_len', dest='maxlen', type=int, default=15, help='size of sentence encoding layer on top of CNN')

parser.add_argument('--sim_smooth_factor', dest='sim_smooth_factor', type=float, default=1.0, help='smoothing factor in softmax')

parser.add_argument('--eval_model', dest='eval_model', type=str, default='cnn', help='which evaluator model to use type: cnn/lstm_eval')

parser.add_argument('--multimodal_lstm', dest='multimodal_lstm', type=int, default=0, help='If 1, we will feed the image encoding at t=0 to lstm and no other similarity metric is used')

# CNN specific parameters

parser.add_argument('--n_fmaps', dest='n_fmaps_psz', type=int, default=100, help='number of cnn feature maps per filter height')

parser.add_argument('--filter_hs', dest='filter_hs', metavar='N', type=int, nargs='+',default =[3,4,5], help='list fo filter heights to use in CNN')

parser.add_argument('--conv_non_linear', dest='conv_non_linear', type=str, default='relu', help='nonlinearity type: tanh/relu')

# LSTM Specific parameters

parser.add_argument('--hidden_size', dest='hidden_size', type=int, default=512, help='size of hidden layer in generator RNNs')

parser.add_argument('--hidden_depth', dest='hidden_depth', type=int, default=1, help='depth of hidden layer in generator RNNs')

# optimization parameters

parser.add_argument('-l', '--learning_rate', dest='learning_rate', type=float, default=1e-3, help='solver learning rate')

parser.add_argument('-c', '--regc', dest='regc', type=float, default=0., help='regularization strength')

parser.add_argument('-b', '--batch_size', dest='batch_size', type=int, default=128, help='batch size')

parser.add_argument('-m', '--max_epochs', dest='max_epochs', type=int, default=10, help='number of epochs to train for')

parser.add_argument('--solver', dest='solver', type=str, default='rmsprop', help='solver type: vanilla/adagrad/adadelta/rmsprop')

parser.add_argument('--lr_decay', dest='lr_decay', type=float, default=1.0, help='decay factor for learning rate, applied every epoch')

parser.add_argument('--lr_decay_st_epoch', dest='lr_decay_st_epoch', type=float, default=100.0, help='from which epoch should the lr decay start')

parser.add_argument('--decay_rate', dest='decay_rate', type=float, default=0.999, help='decay rate for adadelta/rmsprop')

parser.add_argument('--smooth_eps', dest='smooth_eps', type=float, default=1e-8, help='epsilon smoothing for rmsprop/adagrad/adadelta')

parser.add_argument('--grad_clip', dest='grad_clip', type=float, default=0.0, help='clip gradients (normalized by batch size)? elementwise. if positive, at what threshold?')

parser.add_argument('--sample_by_len', dest='sample_by_len', type=int, default=0, help='enable sampling by length of sentece to speed up training')

parser.add_argument('--sim_minibatch', dest='sim_minibatch', type=int, default=0, help='If >0, we will accumulate grads for this many iters before applying update')

# Droput Regularization related

parser.add_argument('--drop_prob_decoder', dest='drop_prob_decoder', type=np.float32, default=0.5, help='what dropout to apply right befor the decoder to an RNN/LSTM')

parser.add_argument('--drop_prob_encoder', dest='drop_prob_encoder', type=np.float32, default=0.5, help='what dropout to apply right after the encoder to an RNN/LSTM')

parser.add_argument('--drop_prob_cnn', dest='drop_prob_cnn', type=np.float32, default=0.5, help='what dropout to apply right before the decoder in an RNN/LSTM')

parser.add_argument('--drop_prob_aux', dest='drop_prob_aux', type=np.float32, default=0.5, help='what dropout to apply for the auxillary inputs to lstm')

# data preprocessing parameters

parser.add_argument('--word_count_threshold', dest='word_count_threshold', type=int, default=5, help='if a word occurs less than this number of times in training data, it is discarded')

# evaluation parameters

parser.add_argument('-p', '--eval_period', dest='eval_period', type=float, default=1.0, help='in units of epochs, how often do we evaluate on val set?')

parser.add_argument('--eval_batch_size', dest='eval_batch_size', type=int, default=100, help='for faster validation performance evaluation, what batch size to use on val img/sentences?')

parser.add_argument('--eval_max_images', dest='eval_max_images', type=int, default=-1, help='for efficiency we can use a smaller number of images to get validation error')

args = parser.parse_args()

params = vars(args) # convert to ordinary dict

if params['checkpoint_file_name'] != None:

checkpoint_init = pickle.load(open(params['checkpoint_file_name'], 'rb'))

model_init_from = checkpoint_init['model']

rg_init = checkpoint_init.get('rgrads',[])

print 'parsed parameters:'

print json.dumps(params, indent = 2)

config.mode = 'FAST_RUN'

#config.profile = True

#config.allow_gc = False

main(params)