import numpy as np
import lasagne
import theano
import sys
import cPickle as pickle
save_detector = False
print('saving detector')
model_dir = 'results/models/'
model_file = model_dir + 'test_set_norfolk.mod'
print(model_file)
mod = pickle.load(open(model_file))
weights = get_all_param_values(mod.model.network['prob'])
np.save(model_file[:-4], weights)
print('weights shape', len(weights))
# save detection params
mod_params = {
'win_size': 0,
'chunk_size': 0,
'max_freq': 0,
'min_freq': 0,
'mean_log_mag': 0,
'slice_scale': 0,
'overlap': 0,
'crop_spec': False,
'denoise': False,
'smooth_spec': False,
train_loss = batch_iterator_train(X_train, y_train, BATCHSIZE, train_fn)
train_eval.append(train_loss)
valid_loss, acc_v = batch_iterator_valid(X_test, y_test, BATCHSIZE, valid_fn)
valid_eval.append(valid_loss)
valid_acc.append(acc_v)
ratio = train_loss / valid_loss
end = time.time() - start
# print training details
print 'iter:', epoch, '| TL:', np.round(train_loss,decimals=3), '| VL:', np.round(valid_loss,decimals=3), '| Vacc:', np.round(acc_v,decimals=3), '| Ratio:', np.round(ratio,decimals=2), '| Time:', np.round(end,decimals=1)
if acc_v > best_acc:
best_acc = acc_v
best_params = helper.get_all_param_values(output_layer)
except KeyboardInterrupt:
pass
print "Final Acc:", best_acc
# save weights
f = gzip.open('data/weights/%s_best.pklz'%experiment_label, 'wb')
pickle.dump(best_params, f)
f.close()
last_params = helper.get_all_param_values(output_layer)
f = gzip.open('data/weights/%s_last.pklz'%experiment_label, 'wb')
pickle.dump(last_params, f)
f.close()
valid_eval.append(valid_loss)
valid_acc.append(1.0 - acc_v)
ratio = train_loss / valid_loss
end = time.time() - start
# print training details
print 'iter:', epoch, '| TL:', np.round(
train_loss, decimals=3), '| VL:', np.round(
valid_loss, decimals=3), '| Vacc:', np.round(
acc_v, decimals=3), '| Ratio:', np.round(
ratio, decimals=2), '| Time:', np.round(end,
decimals=1)
if acc_v > best_acc:
best_acc = acc_v
best_params = helper.get_all_param_values(output_layer)
except KeyboardInterrupt:
pass
print "Final Acc:", best_acc
# save weights
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('data/weights/bottleneck_resnet.pklz', 'wb')
pickle.dump(best_params, f)
f.close()
# plot loss and accuracy
train_eval = np.array(train_eval)
valid_acc = np.array(valid_acc)
def main():
# load the training and validation data sets
# labels=int(0.7*image.all_count)
X = T.tensor4()
# set up theano functions to generate output by feeding data through network
output_layer_softmax , output_layer_triplet= lasagne_model()
output_train = lasagne.layers.ReshapeLayer(output_layer_triplet,(-1,3,[1]))
output_0= lasagne.layers.helper.get_output(lasagne.layers.SliceLayer(output_train,0,1),X)
output_1= lasagne.layers.helper.get_output(lasagne.layers.SliceLayer(output_train,1,1),X)
output_2= lasagne.layers.helper.get_output(lasagne.layers.SliceLayer(output_train,2,1),X)
output= lasagne.layers.helper.get_output(output_layer_softmax,X)
# set up the loss that we aim to minimize
eps=1e-10
dis_pos=T.sqrt(T.sum(T.square(T.sub(output_0,output_1)),1)+eps)
dis_neg=T.sqrt(T.sum(T.square(T.sub(output_0,output_2)),1)+eps)
dis=(dis_pos-dis_neg+alpha)
# dis=(dis_pos-dis_neg)
loss_train = T.mean((dis)*(dis>0))
# loss_train = T.sum(T.nnet.relu(dis))
# loss_train = T.mean(dis)
# prediction functions for classifications
pred = T.argmax(output, axis=1)
# get parameters from network and set up sgd with nesterov momentum to update parameters
params = lasagne.layers.get_all_params(output_layer_triplet,trainable=True)
#params = params[-4:]#TODO: !!!!!!!!!!!!!!!!!!!
grad=T.grad(loss_train,params)
# updates = nesterov_momentum(loss_train, params, learning_rate=0.03, momentum=0.9)
updates =lasagne.updates.rmsprop(loss_train, params, learning_rate=0.0002)
# updates =lasagne.updates.get_or_compute_grads(loss_train, params)
# set up training and prediction functions
train = theano.function(inputs=[X], outputs=[loss_train,pred,dis,dis_pos,dis_neg], updates=updates, allow_input_downcast=True)
if load_params:
pre_params=pickle.load(gzip.open(load_params))
lasagne.layers.set_all_param_values(output_layer_softmax,pre_params)
print 'load Success.'
for i in range(4500):
aver_loss=0
for idx_batch in range (num_batches):
train_X=np.zeros([BATCHSIZE,3,PIXELS,PIXELS])
for iii in range(BATCHSIZE):
label=random.choice(train_files)
num_slots=random.randint(1,5)
im_aim_list=random.sample(np.load(train_load_path+label),num_slots)
tmp_sum=0
for iidx,shot in enumerate(im_aim_list):
tmp_sum+=shot
im_aim=tmp_sum/float(num_slots)
# im_aim=tmp_sum
im_aim_list=random.sample(np.load(train_load_path+label),num_slots)
tmp_sum=0
for iidx,shot in enumerate(im_aim_list):
tmp_sum+=shot
im_pos=tmp_sum/float(num_slots)
# im_pos=tmp_sum
while True:
label_neg=random.choice(train_files)
if label!=label_neg:
im_neg_list=random.sample(np.load(train_load_path+label_neg),num_slots)
tmp_sum=0
for iidx,shot in enumerate(im_neg_list):
tmp_sum+=shot
im_neg=tmp_sum/float(num_slots)
# im_neg=tmp_sum
break
train_X[iii,0]=im_aim
train_X[iii,1]=im_pos
train_X[iii,2]=im_neg
train_X=train_X.reshape(BATCHSIZE*3,1,PIXELS,PIXELS)
xx_batch = np.float32(train_X)
# print xx_batch.shape
# yy_batch = np.float32(train_y[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE])
train_loss ,pred ,dis ,dis1,dis2= train(xx_batch)
aver_loss+=train_loss
# count=np.count_nonzero(np.int32(pred ==np.argmax(yy_batch,axis=1)))
if idx_batch%3==0:
print i,idx_batch,'| Tloss:', train_loss,pred,'\ndis_pos:{}\ndis_neg:{}\ndis:{}'.format(dis1[:20],dis2[:20],dis[:20])
# print pred
# print np.argmax(yy_batch,axis=1)
print "time:",time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# save weights
if i%1==0:
aver_loss=aver_loss/num_batches
all_params = helper.get_all_param_values(output_layer_softmax)
f = gzip.open('speech_params/speech_{}_batchnorm_12345aver_{}_triplet_{}.pklz'.format(aver_loss,alpha,time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())), 'wb')
pickle.dump(all_params, f)
f.close()
def main():
# load the training and validation data sets
train_X, test_X, train_y, test_y = load_data_cv('data/train.csv')
X = T.ftensor4()
Y = T.fmatrix()
# set up theano functions to generate output by feeding data through network
output_layer = lasagne_model()
output_train = lasagne.layers.get_output(output_layer, X)
output_valid = lasagne.layers.get_output(output_layer, X, deterministic=True)
# set up the loss that we aim to minimize
loss_train = T.mean(T.nnet.categorical_crossentropy(output_train, Y))
loss_valid = T.mean(T.nnet.categorical_crossentropy(output_valid, Y))
# prediction functions for classifications
pred = T.argmax(output_train, axis=1)
pred_valid = T.argmax(output_valid, axis=1)
# get parameters from network and set up sgd with nesterov momentum to update parameters
params = lasagne.layers.get_all_params(output_layer)
updates = nesterov_momentum(loss_train, params, learning_rate=0.003, momentum=0.9)
# set up training and prediction functions
train = theano.function(inputs=[X, Y], outputs=loss_train, updates=updates, allow_input_downcast=True)
valid = theano.function(inputs=[X, Y], outputs=loss_valid, allow_input_downcast=True)
predict_valid = theano.function(inputs=[X], outputs=pred_valid, allow_input_downcast=True)
# loop over training functions for however many iterations, print information while training
train_eval = []
valid_eval = []
valid_acc = []
try:
for i in range(45):
train_loss = batch_iterator(train_X, train_y, BATCHSIZE, train)
train_eval.append(train_loss)
valid_loss = valid(test_X, test_y)
valid_eval.append(valid_loss)
acc = np.mean(np.argmax(test_y, axis=1) == predict_valid(test_X))
valid_acc.append(acc)
print 'iter:', i, '| Tloss:', train_loss, '| Vloss:', valid_loss, '| valid acc:', acc
except KeyboardInterrupt:
pass
# save weights
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('data/weights.pklz', 'wb')
pickle.dump(all_params, f)
f.close()
# plot loss and accuracy
train_eval = np.array(train_eval)
valid_eval = np.array(valid_eval)
valid_acc = np.array(valid_acc)
sns.set_style("whitegrid")
pyplot.plot(train_eval, linewidth = 3, label = 'train loss')
pyplot.plot(valid_eval, linewidth = 3, label = 'valid loss')
pyplot.legend(loc = 2)
pyplot.twinx()
pyplot.plot(valid_acc, linewidth = 3, label = 'valid accuracy', color = 'r')
pyplot.grid()
pyplot.ylim([.9,1])
pyplot.legend(loc = 1)
pyplot.savefig('data/training_plot.png')
def main():
# load the training and validation data sets
labels=int(0.7*image.all_count)
data=image.ddd
train_X=np.zeros([size,1,PIXELS,PIXELS])
train_y=np.zeros([size,labels])
for i in range(size):
label=random.sample(range(labels),1)[0]
train_X[i,0]=0.01*random.sample(data[label],1)[0]
train_y[i]=label_binarize([label],range(labels))[0]
X = T.tensor4()
Y = T.matrix()
# set up theano functions to generate output by feeding data through network
output_layer = lasagne_model()
output_train = lasagne.layers.get_output(output_layer, X)
output_valid = lasagne.layers.get_output(output_layer, X, deterministic=True)
# set up the loss that we aim to minimize
loss_train = T.mean(T.nnet.categorical_crossentropy(output_train, Y))
loss_valid = T.mean(T.nnet.categorical_crossentropy(output_valid, Y))
# prediction functions for classifications
pred = T.argmax(output_train, axis=1)
pred_valid = T.argmax(output_valid, axis=1)
# get parameters from network and set up sgd with nesterov momentum to update parameters
params = lasagne.layers.get_all_params(output_layer)
updates = nesterov_momentum(loss_train, params, learning_rate=0.03, momentum=0.9)
# updates =lasagne.updates.adagrad(loss_train, params, learning_rate=0.003)
# set up training and prediction functions
train = theano.function(inputs=[X, Y], outputs=[loss_train,pred_valid], updates=updates, allow_input_downcast=True)
valid = theano.function(inputs=[X, Y], outputs=loss_valid, allow_input_downcast=True)
predict_valid = theano.function(inputs=[X], outputs=pred_valid, allow_input_downcast=True)
# loop over training functions for however many iterations, print information while training
train_eval = []
valid_eval = []
valid_acc = []
for i in range(450):
batch_total_number = len(train_X) / BATCHSIZE
for idx_batch in range (batch_total_number):
xx_batch = np.float32(train_X[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE])
yy_batch = np.float32(train_y[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE])
train_loss ,pred = train(xx_batch,yy_batch)
print i,idx_batch,'| Tloss:', train_loss,'| Count:',np.count_nonzero(np.int32(pred ==np.argmax(yy_batch,axis=1)))
print pred
print np.argmax(yy_batch,axis=1)
acc=0
for j in range(batch_total_number):
x_batch = np.float32(train_X[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE])
y_batch = np.float32(train_y[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE])
pred = predict_valid(x_batch)
acc += np.count_nonzero(np.int32(pred ==np.argmax(y_batch,axis=1)))
acc=float(acc)/(BATCHSIZE*batch_total_number)
print 'iter:', i,idx_batch, '| Tloss:', train_loss,'|Acc:',acc
# save weights
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('params/weights.pklz', 'wb')
pickle.dump(all_params, f)
f.close()
#########################################################
cost_eval_valid_lst = np.array(cost_eval_valid_lst)
cost_eval_valid_mean = cost_eval_valid_lst.mean()
logger.info("Epoch {} Acc Train = {}, Acc Test = {}".format(
epoch, conf_train.accuracy(), conf_valid.accuracy()))
logger.info(
"Epoch {} cost_train_mean = {}, cost_eval_train_mean = {}, cost_eval_valid_mean = {}"
.format(epoch, cost_train_mean, cost_eval_train_mean,
cost_eval_valid_mean))
if conf_valid.accuracy() > best_valid:
best_valid = conf_valid.accuracy()
best_params = helper.get_all_param_values(net['prob'])
print 'get the current best_params'
look_count = LOOK_AHEAD
# save weights
outfile_model = Dir_features + '/outfile_model/' + "R3DCNN.pkl"
# print 'type(best_params):', type(best_params)
# print 'len(best_params):', len(best_params)
# print best_params
f = open(outfile_model, 'wb')
pickle.dump(best_params, f)
f.close()
else:
look_count -= 1
def main():
# load the training and validation data sets
# labels=int(0.7*speech.all_count)
global valid_best
data=speech.data_dict
labels=data.keys()
# assert (PIXELS,PIXELS)==speechSize
train_X=np.zeros([num_speechs,1,speechSize[0],speechSize[1]])
train_y=np.zeros([num_speechs,len(labels)])
i=0
for label in (data.keys()):
for im in data[label]:
train_X[i,0]=im
train_y[i]=label_binarize([label],labels)[0]
i+=1
if i>=num_speechs:
break
if i%500==0:
print 'idx of speechs:',i
if i>=num_speechs:
break
zipp=zip(train_X,train_y)
random.shuffle(zipp)
xx=np.array([one[0] for one in zipp])
yy=np.array([one[1] for one in zipp])
del train_X,train_y
train_X=xx[:size]
train_y=yy[:size]
valid_X=xx[size:]
valid_y=yy[size:]
del xx,yy
print 'Shuffle finish. Begin to build model.'
X = T.tensor4()
Y = T.matrix()
# set up theano functions to generate output by feeding data through network
output_layer = lasagne_model()
output_train = lasagne.layers.get_output(output_layer, X)
output_valid = lasagne.layers.get_output(output_layer, X, deterministic=True)
# set up the loss that we aim to minimize
loss_train = T.mean(T.nnet.categorical_crossentropy(output_train, Y))
loss_valid = T.mean(T.nnet.categorical_crossentropy(output_valid, Y))
# prediction functions for classifications
pred = T.argmax(output_train, axis=1)
pred_valid = T.argmax(output_valid, axis=1)
# get parameters from network and set up sgd with nesterov momentum to update parameters
params = lasagne.layers.get_all_params(output_layer,trainable=True)
updates = nesterov_momentum(loss_train, params, learning_rate=0.003, momentum=0.9)
# updates =lasagne.updates.sgd(loss_train, params, learning_rate=0.01)
# set up training and prediction functions
train = theano.function(inputs=[X, Y], outputs=[loss_train,pred], updates=updates, allow_input_downcast=True)
valid = theano.function(inputs=[X, Y], outputs=[loss_valid,pred_valid], allow_input_downcast=True)
# predict_valid = theano.function(inputs=[X], outputs=[pred_valid], allow_input_downcast=True)
# loop over training functions for however many iterations, print information while training
train_eval = []
valid_eval = []
valid_acc = []
for i in range(450):
batch_total_number = len(train_X) / BATCHSIZE
for idx_batch in range (batch_total_number):
xx_batch = np.float32(train_X[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE])
yy_batch = np.float32(train_y[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE])
train_loss ,pred = train(xx_batch,yy_batch)
count=np.count_nonzero(np.int32(pred ==np.argmax(yy_batch,axis=1)))
print i,idx_batch,'| Tloss:', train_loss,'| Count:',count,'| Acc:',float(count)/(BATCHSIZE)
print pred
print np.argmax(yy_batch,axis=1)
print "time:",time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
if 1 and idx_batch%15==0:
acc=0
valid_batch_number=len(valid_X)/BATCHSIZE
for j in tqdm(range(valid_batch_number)):
x_batch = np.float32(valid_X[j* BATCHSIZE:(j+ 1) * BATCHSIZE])
y_batch = np.float32(valid_y[j* BATCHSIZE:(j+ 1) * BATCHSIZE])
print len(x_batch),len(y_batch)
valid_loss,pred = valid(x_batch,y_batch)
# pred = predict_valid(x_batch)[0]
acc += np.count_nonzero(np.int32(pred ==np.argmax(y_batch,axis=1)))
acc=float(acc)/(valid_batch_number*BATCHSIZE)
print 'iter:', i,idx_batch, '| Vloss:',valid_loss,'|Acc:',acc
if acc>valid_best:
print 'new valid_best:',valid_best,'-->',acc
valid_best=acc
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('speech_params/validbest_cnn_allbatchnorm_{}_{}_{}.pklz'.format(i,valid_best,time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())), 'wb')
pickle.dump(all_params, f)
f.close()
# save weights
if i%5:
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('speech_params/validbest_cnn_allbatchnorm_{}_{}_{}.pklz'.format(i,acc,time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())), 'wb')
pickle.dump(all_params, f)
f.close()
def main():
# load the training and validation data sets
train_X, test_X, train_y, test_y = load_data_cv('data/train.csv')
X = T.ftensor4()
Y = T.fmatrix()
# set up theano functions to generate output by feeding data through network
output_layer = lasagne_model()
output_train = lasagne.layers.get_output(output_layer, X)
output_valid = lasagne.layers.get_output(output_layer,
X,
deterministic=True)
# set up the loss that we aim to minimize
loss_train = T.mean(T.nnet.categorical_crossentropy(output_train, Y))
loss_valid = T.mean(T.nnet.categorical_crossentropy(output_valid, Y))
# prediction functions for classifications
pred = T.argmax(output_train, axis=1)
pred_valid = T.argmax(output_valid, axis=1)
# get parameters from network and set up sgd with nesterov momentum to update parameters
params = lasagne.layers.get_all_params(output_layer)
updates = nesterov_momentum(loss_train,
params,
learning_rate=0.003,
momentum=0.9)
# set up training and prediction functions
train = theano.function(inputs=[X, Y],
outputs=loss_train,
updates=updates,
allow_input_downcast=True)
valid = theano.function(inputs=[X, Y],
outputs=loss_valid,
allow_input_downcast=True)
predict_valid = theano.function(inputs=[X],
outputs=pred_valid,
allow_input_downcast=True)
# loop over training functions for however many iterations, print information while training
train_eval = []
valid_eval = []
valid_acc = []
try:
for i in range(45):
train_loss = batch_iterator(train_X, train_y, BATCHSIZE, train)
train_eval.append(train_loss)
valid_loss = valid(test_X, test_y)
valid_eval.append(valid_loss)
acc = np.mean(np.argmax(test_y, axis=1) == predict_valid(test_X))
valid_acc.append(acc)
print 'iter:', i, '| Tloss:', train_loss, '| Vloss:', valid_loss, '| valid acc:', acc
except KeyboardInterrupt:
pass
# save weights
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('data/weights.pklz', 'wb')
pickle.dump(all_params, f)
f.close()
# plot loss and accuracy
train_eval = np.array(train_eval)
valid_eval = np.array(valid_eval)
valid_acc = np.array(valid_acc)
sns.set_style("whitegrid")
pyplot.plot(train_eval, linewidth=3, label='train loss')
pyplot.plot(valid_eval, linewidth=3, label='valid loss')
pyplot.legend(loc=2)
pyplot.twinx()
pyplot.plot(valid_acc, linewidth=3, label='valid accuracy', color='r')
pyplot.grid()
pyplot.ylim([.9, 1])
pyplot.legend(loc=1)
pyplot.savefig('data/training_plot.png')
loss = loss + l2_penalty
params = get_all_params(l_y, trainable=True)
updates = adam(loss, params, learning_rate=learning_rate)
meta_data["num_param"] = lasagne.layers.count_params(l_y)
print "number of parameters: ", meta_data["num_param"]
print "... compiling"
train_fn = theano.function(inputs=[X, y], outputs=loss, updates=updates)
val_fn = theano.function(inputs=[X, y], outputs=[loss, accuracy])
op_fn = theano.function([X], outputs=prediction_clean)
print "... loading dataset"
if meta_data["dataset"] == 'omniglot':
worker = OmniglotOS(image_size=image_size, batch_size=batch_size)
elif meta_data["dataset"] == 'lfw':
worker = LFWVerif(image_size=image_size, batch_size=batch_size)
meta_data, best_params = train(train_fn, val_fn, worker, meta_data, \
get_params=lambda: helper.get_all_param_values(l_y))
if meta_data["testing"]:
print "... testing"
helper.set_all_param_values(l_y, best_params)
meta_data = test(val_fn, worker, meta_data)
serialize(params, expt_name + '.params')
serialize(meta_data, expt_name + '.mtd')
serialize(op_fn, expt_name + '.opf')
embedding_fn = create_embedder_fn(glimpses)
X = T.matrix("embedding")
y = T.imatrix("target")
l_in = InputLayer(shape=(None, 512), input_var=X)
l_y = DenseLayer(l_in, 1, nonlinearity=sigmoid)
prediction = get_output(l_y)
loss = T.mean(binary_crossentropy(prediction, y))
accuracy = T.mean(binary_accuracy(prediction, y))
params = get_all_params(l_y)
updates = adam(loss, params, learning_rate=1e-3)
train_fn = theano.function([X, y], outputs=loss, updates=updates)
val_fn = theano.function([X, y], outputs=[loss, accuracy])
for i in range(250):
X_train, y_train = worker.fetch_batch('train')
train_fn(embedding_fn(X_train), y_train)
X_train, y_train = worker.fetch_batch('train')
train_loss = train_fn(embedding_fn(X_train), y_train)
val_loss, val_acc = val_fn(embedding_fn(X_test), y_test)
print "number of glimpses per image: ", glimpses
print "\ttraining performance:"
print "\t\t loss:", train_loss
print "\ttesting performance:"
print "\t\t loss:", val_loss
print "\t\t accuracy:", val_acc
params = helper.get_all_param_values(l_y)
serialize(params, str(glimpses) + 'glimpses' + '.params')
def main():
# load the training and validation data sets
# labels=int(0.7*speech.all_count)
global valid_best
X = T.tensor4()
Y = T.matrix()
# set up theano functions to generate output by feeding data through network
output_layer,hidden_layer = lasagne_model()
output_train = lasagne.layers.get_output(output_layer, X)
output_valid = lasagne.layers.get_output(output_layer, X, deterministic=True)
# set up the loss that we aim to minimize
loss_train = T.mean(T.nnet.categorical_crossentropy(output_train, Y))
loss_valid = T.mean(T.nnet.categorical_crossentropy(output_valid, Y))
# prediction functions for classifications
pred = T.argmax(output_train, axis=1)
pred_valid = T.argmax(output_valid, axis=1)
# get parameters from network and set up sgd with nesterov momentum to update parameters
params = lasagne.layers.get_all_params(output_layer,trainable=True)
print params
updates = nesterov_momentum(loss_train, params, learning_rate=0.2, momentum=0.9)
# updates =lasagne.updates.sgd(loss_train, params, learning_rate=0.1)
# set up training and prediction functions
train = theano.function(inputs=[X, Y], outputs=[loss_train,pred], updates=updates, allow_input_downcast=True)
valid = theano.function(inputs=[X, Y], outputs=[loss_valid,pred_valid], allow_input_downcast=True)
# predict_valid = theano.function(inputs=[X], outputs=[pred_valid], allow_input_downcast=True)
# loop over training functions for however many iterations, print information while training
train_eval = []
valid_eval = []
valid_acc = []
if 0:
# pre_params = 'speech_params/validbest_cnn_spkall_22_0.95458984375_2017-06-24 00:50:39.pklz'
pre_params='speech_params/validbest_cnn_fisher_0_idxbatch20000_0.65625_2017-08-17 16:14:04.pklz' # 1 shot: 99.0 2000多次
load_params = pickle.load(gzip.open(pre_params))
# load_params=load_params[:-2]
lasagne.layers.set_all_param_values(output_layer,load_params)
print 'load params: ', pre_params,'\n'
for i in range(450):
train_list,valid_list=get_data(train_files,num_speechs,size,valid_size)
batch_total_number = size / BATCHSIZE
if 1:
valid_list_limit=3000
valid_list=valid_list[:valid_list_limit]
print 'batch_total_number:',batch_total_number
train_acc_aver=0.0
for idx_batch in range (batch_total_number):
batch_list = train_list[idx_batch * BATCHSIZE:(idx_batch + 1) * BATCHSIZE]
xx_batch=np.zeros((BATCHSIZE,1,speechSize[0],speechSize[1]))
yy_batch=np.zeros((BATCHSIZE,num_labels_train))
for ind,one_name in enumerate(batch_list):
aim_file_name,aim_idx=one_name.split('.')
aim_file_name+='.npy'
aim_file_name_full=train_load_path+aim_file_name
xx_batch[ind,0]=np.load(aim_file_name_full)[int(aim_idx)]
yy_batch[ind]=label_binarize([train_files.index(aim_file_name)],range(num_labels_train))[0]
train_loss ,pred = train(xx_batch,yy_batch)
count=np.count_nonzero(np.int32(pred ==np.argmax(yy_batch,axis=1)))
train_acc = float(count) / (BATCHSIZE)
print i,idx_batch,'| Tloss:', train_loss,'| Count:',count,'| Acc:',train_acc
print pred
print np.argmax(yy_batch,axis=1)
print "time:",time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
train_acc_aver += train_acc
# raise EOFError
if train_acc>0.9 and idx_batch%1000==0 and idx_batch>=0:
acc=0
valid_batch_number=len(valid_list)/BATCHSIZE
for j in tqdm(range(valid_batch_number)):
batch_list = valid_list[j * BATCHSIZE:(j + 1) * BATCHSIZE]
x_batch=np.zeros((BATCHSIZE,1,speechSize[0],speechSize[1]))
y_batch=np.zeros((BATCHSIZE,num_labels_train))
for ind,one_name in enumerate(batch_list):
aim_file_name,aim_idx=one_name.split('.')
aim_file_name+='.npy'
aim_file_name_full=train_load_path+aim_file_name
x_batch[ind,0]=np.load(aim_file_name_full)[int(aim_idx)]
y_batch[ind]=label_binarize([train_files.index(aim_file_name)],range(num_labels_train))[0]
valid_loss,pred = valid(x_batch,y_batch)
acc += np.count_nonzero(np.int32(pred ==np.argmax(y_batch,axis=1)))
acc=float(acc)/(valid_batch_number*BATCHSIZE)
print 'iter:', i,idx_batch, '| Vloss:',valid_loss,'|Acc:',acc
if acc>valid_best:
print 'new valid_best:',valid_best,'-->',acc
valid_best=acc
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('speech_params/validbest_cnn_fisher_{}_validacc{}_{}.pklz'.format(i,valid_best,time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())), 'wb')
pickle.dump(all_params, f)
f.close()
if idx_batch%3000==0 and idx_batch>0:
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('speech_params/validbest_cnn_fisher_{}_idxbatch{}_{}.pklz'.format(i,idx_batch,time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())), 'wb')
pickle.dump(all_params, f)
f.close()
# save weights
if i%1==0:
all_params = helper.get_all_param_values(output_layer)
f = gzip.open('speech_params/validbest_cnn_fisher_averacc{}_{}_{}.pklz'.format(i,train_acc_aver/batch_total_number,time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())), 'wb')
pickle.dump(all_params, f)
f.close()
