def test_mlp(train_set,
valid_set,
test_set,
learning_rate=0.02,
L1_reg=0.00,
L2_reg=0.001,
n_epochs=100,
batch_size=100,
n_input=1030,
n_hidden=30,
n_output=1000):
datasets = load_data(train_set, test_set, valid_set)
train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = datasets[1]
test_set_x, test_set_y = datasets[2]
# compute number of minibatches for training, validation and testing
n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size
n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size
n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
x = T.matrix('x') # the data is presented as rasterized images
y = T.ivector('y') # the labels are presented as 1D vector of
# [int] labels
rng = numpy.random.RandomState(1234)
# construct the MLP class
classifier = MLP(rng=rng,
input=x,
n_in=n_input,
n_hidden=n_hidden,
n_out=n_output)
# start-snippet-4
# the cost we minimize during training is the negative log likelihood of
# the model plus the regularization terms (L1 and L2); cost is expressed
# here symbolically
cost = (classifier.negative_log_likelihood(y) + L1_reg * classifier.L1 +
L2_reg * classifier.L2_sqr)
# end-snippet-4
# compiling a Theano function that computes the mistakes that are made
# by the model on a minibatch
test_model = theano.function(
inputs=[index],
outputs=classifier.predictAll,
givens={
x: test_set_x[index * batch_size:(index + 1) * batch_size],
})
test_model_end = theano.function(inputs=[index],
outputs=classifier.predictAll,
givens={
x: test_set_x[index * batch_size:],
})
validate_model = theano.function(
inputs=[index],
outputs=classifier.errors(y),
givens={
x: valid_set_x[index * batch_size:(index + 1) * batch_size],
y: valid_set_y[index * batch_size:(index + 1) * batch_size]
})
# start-snippet-5
# compute the gradient of cost with respect to theta (sotred in params)
# the resulting gradients will be stored in a list gparams
gparams = [T.grad(cost, param) for param in classifier.params]
# specify how to update the parameters of the model as a list of
# (variable, update expression) pairs
# given two list the zip A = [a1, a2, a3, a4] and B = [b1, b2, b3, b4] of
# same length, zip generates a list C of same size, where each element
# is a pair formed from the two lists :
# C = [(a1, b1), (a2, b2), (a3, b3), (a4, b4)]
updates = [(param, param - learning_rate * gparam)
for param, gparam in zip(classifier.params, gparams)]
# compiling a Theano function `train_model` that returns the cost, but
# in the same time updates the parameter of the model based on the rules
# defined in `updates`
train_model = theano.function(
inputs=[index],
outputs=cost,
updates=updates,
givens={
x: train_set_x[index * batch_size:(index + 1) * batch_size],
y: train_set_y[index * batch_size:(index + 1) * batch_size]
})
# end-snippet-5
###############
# TRAIN MODEL #
###############
print '... training'
# early-stopping parameters
patience = 3000
# look as this many examples regardless
patience_increase = 2 # wait this much longer when a new best is
# found
improvement_threshold = 0.997 # a relative improvement of this much is
# considered significant
validation_frequency = min(n_train_batches, patience / 2)
# go through this many
# minibatche before checking the network
# on the validation set; in this case we
# check every epoch
best_validation_loss = numpy.inf
best_iter = 0
test_score = 0.
start_time = time.clock()
epoch = 0
done_looping = False
while (epoch < n_epochs) and (not done_looping):
epoch = epoch + 1
for minibatch_index in xrange(n_train_batches):
minibatch_avg_cost = train_model(minibatch_index)
# iteration number
iter = (epoch - 1) * n_train_batches + minibatch_index
if (iter + 1) % validation_frequency == 0:
# compute zero-one loss on validation set
validation_losses = [
validate_model(i) for i in xrange(n_valid_batches)
]
this_validation_loss = numpy.mean(validation_losses)
print('epoch %i, minibatch %i/%i, validation error %f %%' %
(epoch, minibatch_index + 1, n_train_batches,
this_validation_loss * 100.))
# if we got the best validation score until now
if this_validation_loss < best_validation_loss:
#improve patience if loss improvement is good enough
if (this_validation_loss <
best_validation_loss * improvement_threshold):
patience = max(patience, iter * patience_increase)
best_validation_loss = this_validation_loss
best_iter = iter
# test it on the test set
'''
if patience <= iter:
done_looping = True
break
'''
model_save = {}
model_save['hidden_W'], model_save[
'hidden_b'] = classifier.hiddenLayer.__getstate__()
model_save['logRegression_W'], model_save[
'logRegression_b'] = classifier.logRegressionLayer.__getstate__()
utils.pickleSave('model', model_save)
pdb.set_trace()
test_out = []
for i in xrange(n_test_batches):
test_out = test_out + test_model(i).tolist()
test_out += test_model_end(n_test_batches).tolist()
end_time = time.clock()
print(('Optimization complete. Best validation score of %f %% '
'obtained at iteration %i') %
(best_validation_loss * 100., best_iter + 1))
return test_out
def main(num_hidden=50,
K=150,
Type=1,
isBinary=0,
classifier='MLP',
CNNfeat='softmax',
L2=0.0005,
C=1):
# Type, a list indicate which we want to use.
dataset = 'coco'
misc = {}
misc['C'] = C
misc['Type'] = Type
misc['IsBinary'] = isBinary
misc['numAnswer'] = K
misc['numHidden'] = num_hidden
misc['vali_size'] = 25000
misc['classifier'] = classifier
misc['CNNfeat'] = CNNfeat
misc['L2'] = L2
L1 = 0
dp = getDataProvider(dataset, misc['IsBinary'])
print 'The K number is %d' % (misc['numAnswer'])
# dp.downloadImage()
# dp.loadCaption()
# get the vocabulary for the answers.
misc['Awordtoix'], misc['Aixtoword'], misc[
'Avocab'] = preProBuildAnswerVocab(dp.iterAnswer('train'),
misc['numAnswer'])
misc['bowAnswerTrain'] = BoWAnswerEncoding(dp.iterAnswer('train'),
misc['Awordtoix'])
misc['bowAnswerTest'] = BoWAnswerEncoding(dp.iterAnswer('test'),
misc['Awordtoix'])
misc['multiAnswerTest'] = BOWMultiAnswerEncoding(
dp.iterMultiAnswer('test'), misc['Awordtoix'])
misc['genCaptionTest'] = BOWMultiAnswerEncoding(dp.iterGenCaption('test'),
misc['Awordtoix'])
misc['answerGroup'] = FindAnswerGroup(dp.iterImgIdQuestion('test'))
if Type == 0:
print '===================================================='
print 'Test on Question, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preQuestion(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec,
misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 1030,
misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 1:
print '===================================================='
print 'Test on QuestionImage, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec, misc = preQuestionImage(dp, misc)
Vocab_save = {}
Vocab_save['Awordtoix'] = misc['Awordtoix']
Vocab_save['Aixtoword'] = misc['Aixtoword']
Vocab_save['Avocab'] = misc['Avocab']
Vocab_save['Qwordtoix0'] = misc['Qwordtoix0']
Vocab_save['Qwordtoix1'] = misc['Qwordtoix1']
Vocab_save['Qwordtoix2'] = misc['Qwordtoix2']
Vocab_save['Qwordtoix3'] = misc['Qwordtoix3']
utils.pickleSave('Vocab', Vocab_save)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec,
misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 2030,
misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 2:
print '===================================================='
print 'Test on Caption, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preCaption(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec,
misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 1000,
misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 3:
print '===================================================='
print 'Test on Image, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preImage(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec,
misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 1000,
misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 4:
print '===================================================='
print 'Test on QuestionCaption, The K number is %d' % (
misc['numAnswer'])
print '===================================================='
trainVec, testVec = preQuestionCaption(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec,
misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 2030,
misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 5:
print '===================================================='
print 'Test on QuestionImageCaption, The K number is %d' % (
misc['numAnswer'])
print '===================================================='
trainVec, testVec = preQuestionCaptionImg(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec,
misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 3030,
misc['numHidden'], 300, misc, L1, L2)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
calAcc(out, misc)
def main(num_hidden=50, K=150, Type=1, isBinary=0, classifier="MLP", CNNfeat="softmax", L2=0.0005, C=1):
# Type, a list indicate which we want to use.
dataset = "coco"
misc = {}
misc["C"] = C
misc["Type"] = Type
misc["IsBinary"] = isBinary
misc["numAnswer"] = K
misc["numHidden"] = num_hidden
misc["vali_size"] = 25000
misc["classifier"] = classifier
misc["CNNfeat"] = CNNfeat
misc["L2"] = L2
L1 = 0
dp = getDataProvider(dataset, misc["IsBinary"])
print "The K number is %d" % (misc["numAnswer"])
# dp.downloadImage()
# dp.loadCaption()
# get the vocabulary for the answers.
misc["Awordtoix"], misc["Aixtoword"], misc["Avocab"] = preProBuildAnswerVocab(
dp.iterAnswer("train"), misc["numAnswer"]
)
misc["bowAnswerTrain"] = BoWAnswerEncoding(dp.iterAnswer("train"), misc["Awordtoix"])
misc["bowAnswerTest"] = BoWAnswerEncoding(dp.iterAnswer("test"), misc["Awordtoix"])
misc["multiAnswerTest"] = BOWMultiAnswerEncoding(dp.iterMultiAnswer("test"), misc["Awordtoix"])
misc["genCaptionTest"] = BOWMultiAnswerEncoding(dp.iterGenCaption("test"), misc["Awordtoix"])
misc["answerGroup"] = FindAnswerGroup(dp.iterImgIdQuestion("test"))
if Type == 0:
print "===================================================="
print "Test on Question, The K number is %d" % (misc["numAnswer"])
print "===================================================="
trainVec, testVec = preQuestion(dp, misc)
if misc["classifier"] == "SVM":
out = SVMtrainModel(trainVec, misc["bowAnswerTrain"], testVec, misc)
else:
out = trainModel(trainVec, misc["bowAnswerTrain"], testVec, 1030, misc["numHidden"], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll("test"), misc)
openAnswerWriteJson(out, dp.iterAll("test"), misc)
if Type == 1:
print "===================================================="
print "Test on QuestionImage, The K number is %d" % (misc["numAnswer"])
print "===================================================="
trainVec, testVec, misc = preQuestionImage(dp, misc)
Vocab_save = {}
Vocab_save["Awordtoix"] = misc["Awordtoix"]
Vocab_save["Aixtoword"] = misc["Aixtoword"]
Vocab_save["Avocab"] = misc["Avocab"]
Vocab_save["Qwordtoix0"] = misc["Qwordtoix0"]
Vocab_save["Qwordtoix1"] = misc["Qwordtoix1"]
Vocab_save["Qwordtoix2"] = misc["Qwordtoix2"]
Vocab_save["Qwordtoix3"] = misc["Qwordtoix3"]
utils.pickleSave("Vocab", Vocab_save)
if misc["classifier"] == "SVM":
out = SVMtrainModel(trainVec, misc["bowAnswerTrain"], testVec, misc)
else:
out = trainModel(trainVec, misc["bowAnswerTrain"], testVec, 2030, misc["numHidden"], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll("test"), misc)
openAnswerWriteJson(out, dp.iterAll("test"), misc)
if Type == 2:
print "===================================================="
print "Test on Caption, The K number is %d" % (misc["numAnswer"])
print "===================================================="
trainVec, testVec = preCaption(dp, misc)
if misc["classifier"] == "SVM":
out = SVMtrainModel(trainVec, misc["bowAnswerTrain"], testVec, misc)
else:
out = trainModel(trainVec, misc["bowAnswerTrain"], testVec, 1000, misc["numHidden"], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll("test"), misc)
openAnswerWriteJson(out, dp.iterAll("test"), misc)
if Type == 3:
print "===================================================="
print "Test on Image, The K number is %d" % (misc["numAnswer"])
print "===================================================="
trainVec, testVec = preImage(dp, misc)
if misc["classifier"] == "SVM":
out = SVMtrainModel(trainVec, misc["bowAnswerTrain"], testVec, misc)
else:
out = trainModel(trainVec, misc["bowAnswerTrain"], testVec, 1000, misc["numHidden"], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll("test"), misc)
openAnswerWriteJson(out, dp.iterAll("test"), misc)
if Type == 4:
print "===================================================="
print "Test on QuestionCaption, The K number is %d" % (misc["numAnswer"])
print "===================================================="
trainVec, testVec = preQuestionCaption(dp, misc)
if misc["classifier"] == "SVM":
out = SVMtrainModel(trainVec, misc["bowAnswerTrain"], testVec, misc)
else:
out = trainModel(trainVec, misc["bowAnswerTrain"], testVec, 2030, misc["numHidden"], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll("test"), misc)
openAnswerWriteJson(out, dp.iterAll("test"), misc)
if Type == 5:
print "===================================================="
print "Test on QuestionImageCaption, The K number is %d" % (misc["numAnswer"])
print "===================================================="
trainVec, testVec = preQuestionCaptionImg(dp, misc)
if misc["classifier"] == "SVM":
out = SVMtrainModel(trainVec, misc["bowAnswerTrain"], testVec, misc)
else:
out = trainModel(trainVec, misc["bowAnswerTrain"], testVec, 3030, misc["numHidden"], 300, misc, L1, L2)
multChoiceWriteJson(out, dp.iterAll("test"), misc)
openAnswerWriteJson(out, dp.iterAll("test"), misc)
calAcc(out, misc)
def test_mlp(train_set, valid_set, test_set, learning_rate=0.02, L1_reg=0.00, L2_reg=0.001, n_epochs=100,
batch_size=100, n_input=1030, n_hidden=30, n_output=1000):
datasets = load_data(train_set, test_set, valid_set)
train_set_x, train_set_y = datasets[0]
valid_set_x, valid_set_y = datasets[1]
test_set_x, test_set_y = datasets[2]
# compute number of minibatches for training, validation and testing
n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size
n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size
n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size
# allocate symbolic variables for the data
index = T.lscalar() # index to a [mini]batch
x = T.matrix('x') # the data is presented as rasterized images
y = T.ivector('y') # the labels are presented as 1D vector of
# [int] labels
rng = numpy.random.RandomState(1234)
# construct the MLP class
classifier = MLP(
rng=rng,
input=x,
n_in=n_input,
n_hidden=n_hidden,
n_out=n_output
)
# start-snippet-4
# the cost we minimize during training is the negative log likelihood of
# the model plus the regularization terms (L1 and L2); cost is expressed
# here symbolically
cost = (
classifier.negative_log_likelihood(y)
+ L1_reg * classifier.L1
+ L2_reg * classifier.L2_sqr
)
# end-snippet-4
# compiling a Theano function that computes the mistakes that are made
# by the model on a minibatch
test_model = theano.function(
inputs=[index],
outputs=classifier.predictAll,
givens={
x: test_set_x[index * batch_size:(index + 1) * batch_size],
}
)
test_model_end = theano.function(
inputs=[index],
outputs=classifier.predictAll,
givens={
x: test_set_x[index * batch_size:],
}
)
validate_model = theano.function(
inputs=[index],
outputs=classifier.errors(y),
givens={
x: valid_set_x[index * batch_size:(index + 1) * batch_size],
y: valid_set_y[index * batch_size:(index + 1) * batch_size]
}
)
# start-snippet-5
# compute the gradient of cost with respect to theta (sotred in params)
# the resulting gradients will be stored in a list gparams
gparams = [T.grad(cost, param) for param in classifier.params]
# specify how to update the parameters of the model as a list of
# (variable, update expression) pairs
# given two list the zip A = [a1, a2, a3, a4] and B = [b1, b2, b3, b4] of
# same length, zip generates a list C of same size, where each element
# is a pair formed from the two lists :
# C = [(a1, b1), (a2, b2), (a3, b3), (a4, b4)]
updates = [
(param, param - learning_rate * gparam)
for param, gparam in zip(classifier.params, gparams)
]
# compiling a Theano function `train_model` that returns the cost, but
# in the same time updates the parameter of the model based on the rules
# defined in `updates`
train_model = theano.function(
inputs=[index],
outputs=cost,
updates=updates,
givens={
x: train_set_x[index * batch_size: (index + 1) * batch_size],
y: train_set_y[index * batch_size: (index + 1) * batch_size]
}
)
# end-snippet-5
# # # # # # # # # # # # # # #
# TRAIN MODEL #
# # # # # # # # # # # # # # #
print '... training'
# early-stopping parameters
patience = 3000
# look as this many examples regardless
patience_increase = 2 # wait this much longer when a new best is
# found
improvement_threshold = 0.997 # a relative improvement of this much is
# considered significant
validation_frequency = min(n_train_batches, patience / 2)
# go through this many
# minibatche before checking the network
# on the validation set; in this case we
# check every epoch
best_validation_loss = numpy.inf
best_iter = 0
# test_score = 0.
# start_time = time.clock()
epoch = 0
done_looping = False
while (epoch < n_epochs) and (not done_looping):
epoch = epoch + 1
for minibatch_index in xrange(n_train_batches):
train_model(minibatch_index)
# iteration number
iter = (epoch - 1) * n_train_batches + minibatch_index
if (iter + 1) % validation_frequency == 0:
# compute zero-one loss on validation set
validation_losses = [validate_model(i) for i
in xrange(n_valid_batches)]
this_validation_loss = numpy.mean(validation_losses)
print(
'epoch %i, minibatch %i/%i, validation error %f %%' %
(
epoch,
minibatch_index + 1,
n_train_batches,
this_validation_loss * 100.
)
)
# if we got the best validation score until now
if this_validation_loss < best_validation_loss:
# improve patience if loss improvement is good enough
if (
this_validation_loss < best_validation_loss *
improvement_threshold
):
patience = max(patience, iter * patience_increase)
best_validation_loss = this_validation_loss
best_iter = iter
# test it on the test set
'''
if patience <= iter:
done_looping = True
break
'''
model_save = {}
model_save['hidden_W'], model_save['hidden_b'] = classifier.hiddenLayer.__getstate__()
model_save['logRegression_W'], model_save['logRegression_b'] = classifier.logRegressionLayer.__getstate__()
utils.pickleSave('model', model_save)
pdb.set_trace()
test_out = []
for i in xrange(n_test_batches):
test_out = test_out + test_model(i).tolist()
test_out += test_model_end(n_test_batches).tolist()
# end_time = time.clock()
print(('Optimization complete. Best validation score of %f %% '
'obtained at iteration %i') %
(best_validation_loss * 100., best_iter + 1))
return test_out
def main(num_hidden=50, K=150, Type=1, isBinary=0, classifier='MLP', CNNfeat='softmax', L2=0.0005, C=1):
# Type, a list indicate which we want to use.
dataset = 'coco'
misc = {}
misc['C'] = C
misc['Type'] = Type
misc['IsBinary'] = isBinary
misc['numAnswer'] = K
misc['numHidden'] = num_hidden
misc['vali_size'] = 25000
misc['classifier'] = classifier
misc['CNNfeat'] = CNNfeat
misc['L2'] = L2
L1 = 0
dp = getDataProvider(dataset, misc['IsBinary'])
print 'The K number is %d' % (misc['numAnswer'])
# dp.downloadImage()
# dp.loadCaption()
# get the vocabulary for the answers.
misc['Awordtoix'], misc['Aixtoword'], misc['Avocab'] = preProBuildAnswerVocab(
dp.iterAnswer('train'), misc['numAnswer'])
misc['bowAnswerTrain'] = BoWAnswerEncoding(dp.iterAnswer('train'), misc['Awordtoix'])
misc['bowAnswerTest'] = BoWAnswerEncoding(dp.iterAnswer('test'), misc['Awordtoix'])
misc['multiAnswerTest'] = BOWMultiAnswerEncoding(dp.iterMultiAnswer('test'), misc['Awordtoix'])
misc['genCaptionTest'] = BOWMultiAnswerEncoding(dp.iterGenCaption('test'), misc['Awordtoix'])
misc['answerGroup'] = FindAnswerGroup(dp.iterImgIdQuestion('test'))
if Type == 0:
print '===================================================='
print 'Test on Question, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preQuestion(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec, misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 1030, misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 1:
print '===================================================='
print 'Test on QuestionImage, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec, misc = preQuestionImage(dp, misc)
Vocab_save = {}
Vocab_save['Awordtoix'] = misc['Awordtoix']
Vocab_save['Aixtoword'] = misc['Aixtoword']
Vocab_save['Avocab'] = misc['Avocab']
Vocab_save['Qwordtoix0'] = misc['Qwordtoix0']
Vocab_save['Qwordtoix1'] = misc['Qwordtoix1']
Vocab_save['Qwordtoix2'] = misc['Qwordtoix2']
Vocab_save['Qwordtoix3'] = misc['Qwordtoix3']
utils.pickleSave('Vocab', Vocab_save)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec, misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 2030, misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 2:
print '===================================================='
print 'Test on Caption, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preCaption(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec, misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 1000, misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 3:
print '===================================================='
print 'Test on Image, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preImage(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec, misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 1000, misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 4:
print '===================================================='
print 'Test on QuestionCaption, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preQuestionCaption(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec, misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 2030, misc['numHidden'], 300, misc, L1, L2)
calAcc(out, misc)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
if Type == 5:
print '===================================================='
print 'Test on QuestionImageCaption, The K number is %d' % (misc['numAnswer'])
print '===================================================='
trainVec, testVec = preQuestionCaptionImg(dp, misc)
if misc['classifier'] == 'SVM':
out = SVMtrainModel(trainVec, misc['bowAnswerTrain'], testVec, misc)
else:
out = trainModel(trainVec, misc['bowAnswerTrain'], testVec, 3030, misc['numHidden'], 300, misc, L1, L2)
multChoiceWriteJson(out, dp.iterAll('test'), misc)
openAnswerWriteJson(out, dp.iterAll('test'), misc)
calAcc(out, misc)
