def train_model(feature_layers, classification_layers, image_list, nb_epoch, nb_classes, img_rows, img_cols, weights=None):
# Create testset data for cross-val
num_images = len(image_list)
test_size = int(0.2 * num_images)
print("Train size: ", num_images-test_size)
print("Test size: ", test_size)
model = Sequential()
for l in feature_layers + classification_layers:
model.add(l)
if not(weights is None):
model.set_weights(weights)
# let's train the model using SGD + momentum (how original).
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)
print('Using real time data augmentation')
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print('Training...')
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(num_images-test_size)
for X_batch, Y_batch in flow(image_list[0:-test_size]):
X_batch = X_batch.reshape(X_batch.shape[0], 3, img_rows, img_cols)
Y_batch = np_utils.to_categorical(Y_batch, nb_classes)
loss = model.train_on_batch(X_batch, Y_batch)
progbar.add(X_batch.shape[0], values=[('train loss', loss)])
print('Testing...')
# test time!
progbar = generic_utils.Progbar(test_size)
for X_batch, Y_batch in flow(image_list[-test_size:]):
X_batch = X_batch.reshape(X_batch.shape[0], 3, img_rows, img_cols)
Y_batch = np_utils.to_categorical(Y_batch, nb_classes)
score = model.test_on_batch(X_batch, Y_batch)
progbar.add(X_batch.shape[0], values=[('test loss', score)])
return model, model.get_weights()
class LSTM_RNN:
def __init__(self, look_back, dropout_probability = 0.2, init ='he_uniform', loss='mse', optimizer='rmsprop'):
self.rnn = Sequential()
self.look_back = look_back
self.rnn.add(LSTM(10, stateful = True, batch_input_shape=(1, 1, 1), init=init))
self.rnn.add(Dropout(dropout_probability))
self.rnn.add(Dense(1, init=init))
self.rnn.compile(loss=loss, optimizer=optimizer)
def batch_train_test(self, trainX, trainY, testX, testY, nb_epoch=150):
print('Training LSTM-RNN...')
for epoch in range(nb_epoch):
print('Epoch '+ str(epoch+1) +'/{}'.format(nb_epoch))
training_losses = []
testing_losses = []
for i in range(len(trainX)):
y_actual = trainY[i]
for j in range(self.look_back):
training_loss = self.rnn.train_on_batch(np.expand_dims(np.expand_dims(trainX[i][j], axis=1), axis=1),
np.array([y_actual]))
training_losses.append(training_loss)
self.rnn.reset_states()
print('Mean training loss = {}'.format(np.mean(training_losses)))
mean_testing_loss = []
for i in range(len(testX)):
for j in range(self.look_back):
testing_loss = self.rnn.test_on_batch(np.expand_dims(np.expand_dims(testX[i][j], axis=1), axis=1),
np.array([testY[i]]))
testing_losses.append(testing_loss)
self.rnn.reset_states()
for j in range(self.look_back):
y_pred = self.rnn.predict_on_batch(np.expand_dims(np.expand_dims(testX[i][j], axis=1), axis=1))
self.rnn.reset_states()
mean_testing_loss = np.mean(testing_losses)
print('Mean testing loss = {}'.format(mean_testing_loss))
return mean_testing_loss
print('Iteration', iteration)
print("Training")
progbar = generic_utils.Progbar(train_num_samples)
gen = samples_generator(train_sequences, batch_size,
num_samples=train_num_samples)
for X, y in gen:
loss, accuracy = model.train_on_batch(X, y, accuracy=True)
progbar.add(batch_size, values=[("train loss", loss),
("train acc", accuracy)])
print()
print("Validating")
progbar = generic_utils.Progbar(valid_num_samples)
gen = samples_generator(valid_sequences, batch_size,
num_samples=valid_num_samples)
valid_loss = 0
for X, y in gen:
loss, accuracy = model.test_on_batch(X, y, accuracy=True)
progbar.add(batch_size, values=[("valid loss", loss),
("valid acc", accuracy)])
valid_loss += loss
print()
valid_loss /= float(valid_num_samples)
print("Valid Loss: {}, Best Loss: {}".format(valid_loss, best_loss))
if valid_loss < best_loss:
print("Saving model")
save_model(model, "sentence_model")
best_loss = valid_loss
def run():
datadir = "/reg/d/ana01/temp/davidsch/ImgMLearnFull"
h5files = glob(os.path.join(datadir, "amo86815_mlearn-r070*.h5"))
h5files.extend(glob(os.path.join(datadir, "amo86815_mlearn-r071*.h5")))
# h5files = ["/reg/d/ana01/temp/davidsch/ImgMLearnFull/amo86815_mlearn-r071-c0000.h5",
# "/reg/d/ana01/temp/davidsch/ImgMLearnFull/amo86815_mlearn-r071-c0001.h5",
# "/reg/d/ana01/temp/davidsch/ImgMLearnFull/amo86815_mlearn-r071-c0002.h5"]
assert len(h5files)>0
datareader = H5MiniBatchReader(h5files=h5files,
minibatch_size=32,
validation_size=64,
feature_dataset='xtcavimg',
label_dataset='acq.peaksLabel',
return_as_one_hot=True,
feature_preprocess=['log','mean'],
number_of_batches=None,
class_labels_max_imbalance_ratio=1.0,
add_channel_to_2D='channel_row_column',
max_mb_to_preload_all=None,
random_seed=None,
verbose=True)
validation_features, validation_labels = datareader.get_validation_set()
print("starting to build and compile keras/theano model...")
sys.stdout.flush()
t0 = time.time()
model = Sequential()
## layer 1
kern01_W_init = (0.06/2.0)*scipy.stats.truncnorm.rvs(-2.0, 2.0, size=(8,1,8,8)).astype(np.float32)
kern01_B_init = np.zeros(8,dtype=np.float32)
model.add(Convolution2D(8,8,8, border_mode='same', weights=[kern01_W_init, kern01_B_init],
input_shape=datareader.features_placeholder_shape()[1:]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(10,10), strides=(13,13)))
## layer 2
kern02_W_init = (0.06/2.0)*scipy.stats.truncnorm.rvs(-2.0, 2.0, size=(8,8,6,6)).astype(np.float32)
kern02_B_init = np.zeros(8,dtype=np.float32)
model.add(Convolution2D(8,6,6, border_mode='same', weights=[kern02_W_init, kern02_B_init]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(10,10), strides=(13,13)))
model.add(Flatten())
## layer 3
H03_W_init = (0.06/2.0)*scipy.stats.truncnorm.rvs(-2.0, 2.0, size=(96,16)).astype(np.float32)
H03_B_init = np.zeros(16,dtype=np.float32)
model.add(Dense(16, weights=[H03_W_init, H03_B_init]))
model.add(Activation('relu'))
## layer 4
H04_W_init = (0.06/2.0)*scipy.stats.truncnorm.rvs(-2.0, 2.0, size=(16, datareader.num_outputs())).astype(np.float32)
H04_B_init = np.zeros(datareader.num_outputs(),dtype=np.float32)
model.add(Dense(datareader.num_outputs(), weights=[H04_W_init, H04_B_init]))
model.add(Activation('softmax'))
sgd = SGD(lr=0.01, decay=0.0004, momentum=0.96)
model.compile(loss='categorical_crossentropy', optimizer=sgd)
print("building/compiling theano model took %.2f sec" % (time.time()-t0),)
sys.stdout.flush()
for step_number in range(3000):
t0 = time.time()
train_features, train_labels = datareader.get_next_minibatch()
model.train_on_batch(train_features, train_labels)
print("step %3d took %.2f sec." % (step_number, time.time()-t0))
sys.stdout.flush()
print("Starting evaluation.")
t0 = time.time()
loss, validation_accuracy = model.test_on_batch(validation_features, validation_labels, accuracy=True, sample_weight=None)
print("validation accuracy: %.2f%%" % (100.0*validation_accuracy,))
print("evaluation took %.2f sec" % (time.time()-t0,))
model.compile(loss=qri.mae_clip, optimizer=sgd)
# Use early stopping and saving as callbacks
early_stop = EarlyStopping(monitor='val_loss', patience=10)
save_best = ModelCheckpoint("models/%s.mdl" % MDL_NAME, save_best_only=True)
callbacks = [early_stop, save_best]
# Train model
t0 = time.time()
hist = model.fit(train_set[0], train_set[1], validation_data=valid_set,
verbose=2, callbacks=callbacks, nb_epoch=1000, batch_size=20)
time_elapsed = time.time() - t0
# Load best model
model.load_weights("models/%s.mdl" % MDL_NAME)
# Print time elapsed and loss on testing dataset
test_set_loss = model.test_on_batch(test_set[0], test_set[1])
print "\nTime elapsed: %f s" % time_elapsed
print "Testing set loss: %f" % test_set_loss
# Save results
qri.save_results("results/%s.out" % MDL_NAME, time_elapsed, test_set_loss)
qri.save_history("models/%s.hist" % MDL_NAME, hist.history)
# Plot training and validation loss
qri.plot_train_valid_loss(hist.history)
# Make predictions
qri.plot_test_predictions(model, train_set)
inputs /= 255
loss, acc = model.train_on_batch(inputs, targets)
train_loss += loss
train_acc += acc
train_batches += 1
# And a full pass over the validation data:
val_loss = 0
val_acc = 0
val_batches = 0
test_str.reset() # re-start streaming
for inputs, targets, pad in val_str:
if pad: # not full batch
break
inputs /= 255
loss, acc = model.test_on_batch(inputs, targets)
val_loss += loss
val_acc += acc
val_batches += 1
# Then we print the results for this epoch:
print("Epoch {}/{} time {:.3f}s; train loss: {:.6f} acc:{:.6f}; val loss: {:.6f} acc:{:.2f}".format(
epoch + 1, nb_epoch, time.time() - start_time,
train_loss/train_batches, train_acc/train_batches,
val_loss/val_batches, val_acc/val_batches))
# After training, we compute and print the test error:
test_loss = 0
test_acc = 0
test_batches = 0
for inputs, targets, pad in test_str:
class rnnmlp ():
def __init__(self, r=(21, 109), dt=0.3):
self.r=r
self.dt=dt
self.rnnModel = Sequential()
self.maxFeatures=r[1]-r[0] +1
'''
simple RNN model,
'''
def SimpleRNNModel(self, nHidden=120, lr = 0.01):
self.rnnModel.add(SimpleRNN( nHidden, input_shape =( None, self.maxFeatures), activation='sigmoid', return_sequences=True))
self.rnnModel.add(TimeDistributedDense(self.maxFeatures))
self.rnnModel.add(Activation('softmax'))
rmsprop = RMSprop(lr=lr, rho=0.9, epsilon=1e-06)
self.rnnModel.compile(loss='categorical_crossentropy', optimizer=rmsprop)
'''
LSTM model
'''
def LSTMModel(self, nHidden=150, lr = 0.01):
# print('nHidden: %i\tlr: %.3f' % ( nHidden, lr) )
self.rnnModel.add(GRU( nHidden, activation='sigmoid', input_shape =( None, self.maxFeatures), return_sequences=True))
# self.rnnModel.add(LSTM( nHidden, activation='sigmoid', input_shape =( None, nHidden), return_sequences=True))
self.rnnModel.add(TimeDistributedDense(nHidden))
self.rnnModel.add(Activation('relu'))
self.rnnModel.add(TimeDistributedDense(self.maxFeatures))
self.rnnModel.add(Activation('softmax'))
rmsprop = RMSprop(lr=lr, rho=0.9, epsilon=1e-06)
self.rnnModel.compile(loss='categorical_crossentropy', optimizer=rmsprop)
'''
train module :
train model ,
file_name, the name of train or test file
weight_save_file, save the model parameters
'''
def train(self, file_name, weight_save_file, batch_size=1, num_epoch=200):
print('load data ---------------')
file_train=os.path.join(os.path.split(os.path.dirname(__file__))[0],
'data',file_name,'train','*.mid')
dataset = [midiread(f, self.r, self.dt).piano_roll.astype(theano.config.floatX) for f in glob.glob(file_train)]
file_test=os.path.join(os.path.split(os.path.dirname(__file__))[0],
'data',file_name,'test','*.mid')
testdataset = [midiread(f, self.r, self.dt).piano_roll.astype(theano.config.floatX) for f in glob.glob(file_test)]
print('load done --------------')
try:
for epoch in range(num_epoch):
t0 = time.time()
numpy.random.shuffle(dataset)
costs = []
accuracys = []
for s, sequence in enumerate(dataset):
y = numpy.hstack((sequence,numpy.zeros((sequence.shape[0],1)) ))
x = numpy.roll(y, 1, axis=0)
x[0,:]=0
x[0,self.maxFeatures-1]=1
cost, accuracy= self.rnnModel.train_on_batch(numpy.array([x]), numpy.array([y]), accuracy=True)
costs.append(cost)
accuracys.append(accuracy)
print('epoch: %i/%i\tcost: %.5f\taccu: %.5f\ttime: %.4f s' % (epoch+1, num_epoch, numpy.mean(costs), numpy.mean(accuracys),time.time()-t0))
sys.stdout.flush()
test_accu=self.evaluate(testdataset)
print('test_accu: %.5f' % ( numpy.mean(test_accu)) )
self.rnnModel.save_weights(weight_save_file)
except KeyboardInterrupt:
print('interrupt by user !')
'''
evaluate module :
evaluate model with test data, compute cost and accuracy
'''
def evaluate(self, test_dataset):
test_accuracy =[]
for s, sequence in enumerate(test_dataset):
test_y = numpy.hstack((sequence,numpy.zeros((sequence.shape[0],1)) ))
test_x = numpy.roll(test_y, 1, axis=0)
test_x[0,:]=0
test_x[0,self.maxFeatures-1]=1
cost, accu = self.rnnModel.test_on_batch(numpy.array([test_x]),numpy.array([test_y]), accuracy=True)
test_accuracy.append(accu)
return test_accuracy
'''
generate function :
generate music or chord,
init_chord: the first note of the generate sequence
file_name: file to save the sequence of generate notes
LS : if true , add Lsystem , generate chord
if false, no Lsystem, generate music notes
chord_name: chord name under condition of LS = True
chord_file: notes of all kinds of chords, load file
state_file: Lsystem model parameters, load file
n_steps: the length of generate sequence
r: notes which counts
'''
def generate(self, init_chord, file_name, LS=False, chord_name=None, chord_file=None, state_file=None, n_steps=80, r=(21,109)):
if(LS):
Lsystem = LSystem(chord_name, init_chord, chord_file, state_file, r)
init_sequence = numpy.zeros((1, n_steps +1, self.maxFeatures))
init_sequence[:, 0, init_chord-self.r[0]] = 1
for i in numpy.arange(n_steps):
probs = self.rnnModel.predict_proba(init_sequence)[:, i, :]
for j in numpy.arange(len(init_sequence)):
if(LS):
ind = Lsystem.getMaxProbs(probs[j,0:(self.maxFeatures-1)],True)
else:
ind = maxProbs(probs[j,0:(self.maxFeatures-1)])
init_sequence[j, i+1, ind] = 1
generate_sq = [sq[:,0:(self.maxFeatures-1)].nonzero()[1] for sq in init_sequence]
print(generate_sq[0] + self.r[0])
if(LS):
print(Lsystem.cur_chord)
print(Lsystem.cur_state)
print(Lsystem.cur_opes)
midiwrite(file_name, init_sequence[0,:,0:(self.maxFeatures-1)], self.r, self.dt)
extent = (0, self.dt * len(init_sequence[0,:,0:(self.maxFeatures-1)])) + self.r
pylab.figure()
pylab.imshow(init_sequence[0,:,0:(self.maxFeatures-1)].T, origin='lower', aspect='auto',interpolation='nearest', cmap=pylab.cm.gray_r,extent=extent)
pylab.xlabel('time (s)')
pylab.ylabel('MIDI note number')
pylab.title('generated piano-roll')
'''
load module: load model
'''
def loadModel(self, weight_save_file):
self.rnnModel.load_weights(weight_save_file)
horizontal_flip=False, # randomly flip images
vertical_flip=False) # randomly flip images
# compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied)
datagen.fit(X_train)
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print("Training...")
progbar = generic_utils.Progbar(X_train.shape[0])
for X_batch, Y_batch in datagen.flow(X_train, Y_train):
score, acc = model.test_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("train accuracy", acc)])
print("Testing...")
progbar = generic_utils.Progbar(X_test.shape[0])
for X_batch, Y_batch in datagen.flow(X_test, Y_test):
score, acc = model.test_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("test accuracy", acc)])
# test time!
for X_batch, Y_batch in datagen.flow(X_te_orig, np.ones((1,X_te_orig.shape[0])), batch_size = X_te_orig.shape[0]):
y_te = model.predict_classes(X_batch)
save_out(y_te,labels_string,sorted_files_te,submission_fname)
X, y = get_data(files[n:n+batch_size], n)
else:
X, y = get_data(files[n:], n)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
X_train = np.array(X_train)
X_test = np.array(X_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
# convert class vectors to binary class matrices
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
model.train_on_batch(X_train, Y_train)
l, a = model.test_on_batch(X_test, Y_test, accuracy=True)
acc.append(a)
loss.append(l)
print ''
print "Val_loss", (sum(loss) / len(loss))
print "Val_acc", (sum(acc) / len(acc))
# with random batch draws....
# -------
# Epoch 1
# Val_loss 0.889370705837
# Val_acc 0.479363625794
# -------
# Epoch 2
print('-'*40)
print('Epoch', e)
print('-'*40)
print('Training...')
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(X_train.shape[0])
for X_batch, Y_batch in datagen.flow(X_train, Y_train,batch_size=128):
loss = modelCascade.train_on_batch(X_batch, Y_batch,accuracy=True)
progbar.add(X_batch.shape[0], values=[('train loss', loss[0]),('train accuracy',loss[1])])
print('Testing...')
# test time!
accuracyArray = list()
lossArray = list()
progbar = generic_utils.Progbar(X_test.shape[0])
for X_batch, Y_batch in datagen.flow(X_test, Y_test):
score = modelCascade.test_on_batch(X_batch, Y_batch,accuracy=True)
lossArray.append(score[0])
accuracyArray.append(score[1])
progbar.add(X_batch.shape[0], values=[('test loss', score[0]),('test accuracy',score[1])])
lossIteration1.append(np.mean(lossArray))
accuracyIteration1.append(np.mean(accuracyArray))
weightsLayer1 = modelCascade.layers[0].get_weights()
print('SECOND ITERATION STARTING')
#####SECOND ITERATION
#MODEL THAT IS USED TO GENERATE INPUT HAT
modelIH = Sequential()
modelIH.add(Convolution2D(32, 3, 3, border_mode='same',
input_shape=(img_channels, img_rows, img_cols),weights=weightsLayer1))
modelIH.add(Activation('relu'))
def main():
# the data, shuffled and split between tran and test sets
data, labels = load_data(filename)
mat = scipy.io.loadmat(subjectsFilename, mat_dtype=True)
subjNumbers = np.squeeze(mat['subjectNum']) # subject IDs for each trial
# Creating the folds
# kf = StratifiedKFold(np.squeeze(labels), n_folds=ksplit, shuffle=True, random_state=123)
# kf = KFold(labels.shape[0], n_folds=ksplit, shuffle=True, random_state=123)
# fold_pairs = [(tr, ts) for (tr, ts) in kf]
# Leave-Subject-Out cross validation
fold_pairs = []
for i in np.unique(subjNumbers):
ts = subjNumbers == i
tr = np.squeeze(np.nonzero(np.bitwise_not(ts)))
ts = np.squeeze(np.nonzero(ts))
np.random.shuffle(tr) # Shuffle indices
np.random.shuffle(ts)
fold_pairs.append((tr, ts))
validScores, testScores = [], []
for foldNum, fold in enumerate(fold_pairs):
(X_train, y_train), (X_valid, y_valid), (X_test, y_test) = reformatInput(data, labels, fold)
print('X_train shape:', X_train.shape)
print(X_train.shape[0], 'train samples')
print(X_valid.shape[0], 'valid samples')
print(X_test.shape[0], 'test samples')
X_train = X_train.astype("float32", casting='unsafe')
X_valid = X_valid.astype("float32", casting='unsafe')
X_test = X_test.astype("float32", casting='unsafe')
# convert class vectors to binary class matrices
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_valid = np_utils.to_categorical(y_valid, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
# Building the network
model = Sequential()
model.add(Convolution2D(40, 3, 3, border_mode='full',
input_shape=(image_dimensions, shapex, shapey)))
model.add(Activation('relu'))
model.add(Convolution2D(40, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# model.add(Convolution2D(80, 3, 3, border_mode='full'))
# model.add(Activation('relu'))
# model.add(Convolution2D(80, 3, 3))
# model.add(Activation('relu'))
# model.add(MaxPooling2D(pool_size=(2, 2)))
# model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1024))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
# model.add(Convolution2D(nb_filters[0], image_dimensions, nb_conv[0], nb_conv[0], border_mode='full'))
# # model.add(BatchNormalization([nb_filters[0], nb_conv[0], nb_conv[0], image_dimensions]))
# model.add(Activation('relu'))
# model.add(Convolution2D(nb_filters[0], nb_filters[0], nb_conv[0], nb_conv[0]))
# model.add(Activation('relu'))
# model.add(MaxPooling2D(poolsize=(nb_pool[0], nb_pool[0])))
# model.add(Dropout(0.25))
#
# model.add(Convolution2D(nb_filters[1], nb_filters[0], nb_conv[0], nb_conv[0], border_mode='full'))
# model.add(Activation('relu'))
# model.add(Convolution2D(nb_filters[1], nb_filters[1], nb_conv[1], nb_conv[1]))
# model.add(Activation('relu'))
# model.add(MaxPooling2D(poolsize=(nb_pool[1], nb_pool[1])))
# model.add(Dropout(0.25))
#
# model.add(Flatten())
# # the image dimensions are the original dimensions divided by any pooling
# # each pixel has a number of filters, determined by the last Convolution2D layer
# model.add(Dense(nb_filters[-1] * (shapex / nb_pool[0] / nb_pool[1]) * (shapey / nb_pool[0] / nb_pool[1]), 1024))
# # model.add(BatchNormalization([1024]))
# model.add(Activation('relu'))
# model.add(Dropout(0.5))
# model.add(Dense(1024, nb_classes))
# model.add(Activation('softmax'))
# let's train the model using SGD + momentum (how original).
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)
if not data_augmentation:
print("Not using data augmentation or normalization")
X_train = X_train.astype("float32", casting='unsafe')
X_test = X_test.astype("float32", casting='unsafe')
X_train /= 255.
X_test /= 255.
model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=True)
score, accu = model.evaluate(X_test, Y_test, batch_size=batch_size, show_accuracy=True)
print('Test accuracy:', accu)
else:
print("Using real time data augmentation")
# X_train = (X_train - np.mean(X_train, axis=0)) / np.std(X_train.flatten(), axis=0)
# X_valid = (X_valid - np.mean(X_valid, axis=0)) / np.std(X_valid.flatten(), axis=0)
# X_test = (X_test - np.mean(X_test, axis=0)) / np.std(X_test.flatten(), axis=0)
# X_train = (X_train - np.mean(X_train, axis=0))
# X_valid = (X_valid - np.mean(X_train, axis=0))
# X_test = (X_test - np.mean(X_train, axis=0))
# this will do preprocessing and realtime data augmentation
datagen = ImageDataGenerator(
featurewise_center=True, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=0, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=0, # randomly shift images horizontally (fraction of total width)
height_shift_range=0, # randomly shift images vertically (fraction of total height)
horizontal_flip=False, # randomly flip images
vertical_flip=False) # randomly flip images
# compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied)
datagen.fit(X_train)
best_validation_accu = 0
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print("Training...")
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(X_train.shape[0])
for X_batch, Y_batch in datagen.flow(X_train, Y_train, batch_size=batch_size):
score, trainAccu = model.train_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("train accuracy", trainAccu)])
print("Validating...")
# Validation time!
progbar = generic_utils.Progbar(X_valid.shape[0])
epochValidAccu = []
for X_batch, Y_batch in datagen.flow(X_valid, Y_valid, batch_size=batch_size):
score, validAccu = model.test_on_batch(X_batch, Y_batch, accuracy=True)
epochValidAccu.append(validAccu)
progbar.add(X_batch.shape[0], values=[("validation accuracy", validAccu)])
meanValidAccu = np.mean(epochValidAccu)
if meanValidAccu > best_validation_accu:
best_validation_accu = meanValidAccu
best_iter = e
print("Testing...")
# test time!
progbar = generic_utils.Progbar(X_test.shape[0])
epochTestAccu = []
for X_batch, Y_batch in datagen.flow(X_test, Y_test, batch_size=batch_size):
score, testAccu = model.test_on_batch(X_batch, Y_batch, accuracy=True)
epochTestAccu.append(testAccu)
progbar.add(X_batch.shape[0], values=[("test accuracy", testAccu)])
model.save_weights('weigths_{0}'.format(foldNum), overwrite=True)
validScores.append(best_validation_accu)
testScores.append(np.mean(epochTestAccu))
scipy.io.savemat('cnn_results', {'validAccu': validScores, 'testAccu': testScores})
print ('Average valid accuracies: {0}'.format(np.mean(validScores)))
print ('Average test accuracies: {0}'.format(np.mean(testScores)))
print('-'*40)
print('Epoch', e)
print('-'*40)
print("Training...")
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(X_train.shape[0])
for X_batch, Y_batch in datagen.flow(X_train, Y_train):
loss = model.train_on_batch(X_batch, X_batch.reshape(X_batch.shape[0],X_train.shape[2]**2*3))
progbar.add(X_batch.shape[0], values=[("train loss", loss)])
print("Testing...")
# test time!
progbar = generic_utils.Progbar(X_test.shape[0])
for X_batch, Y_batch in datagen.flow(X_test, X_test):
score = model.test_on_batch(X_batch, X_batch.reshape(X_batch.shape[0],X_train.shape[2]**2*3))
progbar.add(X_batch.shape[0], values=[("test loss", score)])
model2 = Sequential()
model2.add(encoder)
codes = []
targets = []
model2.compile(loss = "mean_squared_error", optimizer = "sgd")
for X_batch, Y_batch in datagen.flow(X_train, Y_train):
codes.append(model2.predict(X_batch))
targets.append(np.argmax(Y_batch))
print('stack it...')
codes = np.vstack(codes)
targets = np.vstack(targets)
print(codes.shape,'code shape')
def cnn(**kwargs):
verbose = kwargs.get("verbose", True)
X_train = kwargs["X_train"]
Y_train = kwargs["Y_train"]
X_test = kwargs["X_test"]
Y_test = kwargs["Y_test"]
input_shape = kwargs["input_shape"]
nb_classes = kwargs["nb_classes"]
data_augmentation = kwargs.get("data_augmentation", True)
nb_convo_layers = kwargs["nb_convo_layers"]
nb_filters = kwargs["nb_filters"]
nb_conv = kwargs["nb_conv"]
convo_activations = kwargs["convo_activations"]
maxpools = kwargs["maxpools"]
pool_sizes = kwargs["pool_sizes"]
convo_dropouts = kwargs["convo_dropouts"]
nb_dense_layers = kwargs["nb_dense_layers"]
dense_hidden_neurons = kwargs["dense_hidden_neurons"]
dense_activations = kwargs["dense_activations"]
dense_dropouts = kwargs["dense_dropouts"]
loss = kwargs["loss"]
optimizer = kwargs["optimizer"]
nb_epoch = kwargs["nb_epoch"]
batch_size = kwargs["batch_size"]
model_file = kwargs.get("model_file")
weights_file = kwargs.get("weights_file")
results_file = kwargs.get("results_file")
results = {
"acc": [],
"loss": [],
"val_acc": [],
"val_loss": []
}
# CNN architecture
model = Sequential()
# convolution layers
for i in range(nb_convo_layers):
# convo layer
if i == 0:
model.add(
Convolution2D(
nb_filters[i],
nb_conv[i],
nb_conv[i],
input_shape=input_shape
)
)
else:
model.add(
Convolution2D(
nb_filters[i],
nb_conv[i],
nb_conv[i],
border_mode='valid',
)
)
# activation
if convo_activations[i]:
model.add(Activation(convo_activations[i]))
# max-pooling
if maxpools[i]:
model.add(MaxPooling2D(pool_size=(pool_sizes[i], pool_sizes[i])))
# dropout
if convo_dropouts[i]:
model.add(Dropout(convo_dropouts[i]))
# dense layers
model.add(Flatten())
for i in range(nb_dense_layers):
# dense layer
if (i + 1) == nb_dense_layers:
model.add(Dense(nb_classes))
else:
model.add(Dense(dense_hidden_neurons[i]))
# activation
if dense_activations[i]:
model.add(Activation(dense_activations[i]))
# dropout
if dense_dropouts[i]:
model.add(Dropout(dense_dropouts[i]))
# loss function and optimizer
if verbose:
print("--> compiling CNN")
model.compile(loss=loss, optimizer=optimizer)
# fit model
if verbose:
print("--> fitting CNN")
if data_augmentation is False:
fitlog = model.fit(
X_train,
Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
show_accuracy=True,
verbose=verbose,
validation_data=(X_test, Y_test)
)
results = fitlog.history
else:
# turn on data augmentation
datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=True,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=0,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
vertical_flip=True
)
datagen.fit(X_train)
for e in range(nb_epoch):
if verbose:
print "epoch:", e
tmp_train_acc = []
tmp_train_loss = []
tmp_test_acc = []
tmp_test_loss = []
train_batch_counter = 0
test_batch_counter = 0
for X_batch, Y_batch in datagen.flow(X_train, Y_train, batch_size):
train_loss, train_accuracy = model.train_on_batch(
X_batch,
Y_batch,
accuracy=True
)
tmp_train_acc.append(train_accuracy)
tmp_train_loss.append(train_loss)
train_batch_counter += 1
for X_batch, Y_batch in datagen.flow(X_test, Y_test, batch_size):
valid_loss, valid_accuracy = model.test_on_batch(
X_batch,
Y_batch,
accuracy=True
)
tmp_test_acc.append(valid_accuracy)
tmp_test_loss.append(valid_loss)
test_batch_counter += 1
epoch_train_acc = sum(tmp_train_acc) / float(train_batch_counter)
epoch_train_loss = sum(tmp_train_loss) / float(train_batch_counter)
epoch_test_acc = sum(tmp_test_acc) / float(test_batch_counter)
epoch_test_loss = sum(tmp_test_loss) / float(test_batch_counter)
results["acc"].append(epoch_train_acc)
results["loss"].append(epoch_train_loss)
results["val_acc"].append(epoch_test_acc)
results["val_loss"].append(epoch_test_loss)
if verbose:
print "acc: {0}".format(epoch_train_acc),
print "loss: {0}".format(epoch_train_loss),
print "val_acc: {0}".format(epoch_test_acc),
print "val_loss: {0}".format(epoch_test_loss)
# save model
if model_file:
model_data = model.to_json()
model_file = open(model_file, "w")
model_file.write(json.dumps(model_data))
model_file.close()
# save model weights
if weights_file:
model.save_weights(weights_file, overwrite=True)
# save results
if results_file:
results["nb_epoch"] = nb_epoch
results["batch_size"] = batch_size
rf = open(results_file, "w")
rf.write(json.dumps(results))
rf.close()
# evaluate
score = model.evaluate(
X_test,
Y_test,
show_accuracy=True,
verbose=verbose,
batch_size=batch_size
)
return results, score
def train_whale_data(**kwargs):
print("analyzing whale data")
# seed random
np.random.seed(kwargs["seed"])
# model inputs and parameters
data_augmentation = kwargs.get("data_augmentation", False)
X_train = kwargs["X_train"]
X_test = kwargs["X_test"]
Y_train = kwargs["Y_train"]
Y_test = kwargs["Y_test"]
img_rows = kwargs["img_rows"]
img_cols = kwargs["img_cols"]
nb_filters = kwargs.get("nb_filters", 32)
nb_conv = kwargs.get("nb_conv", 3)
nb_pool = kwargs.get("nb_pool", 2)
batch_size = kwargs["batch_size"]
nb_epoch = kwargs.get("nb_epoch", 12)
nb_classes = kwargs.get("nb_classes", 10)
model_file = kwargs["model_file"]
weights_file = kwargs["weights_file"]
results_file = kwargs["results_file"]
# CNN architecture
print("--> creating CNN network ...")
results = {
"acc": [],
"val_acc": [],
"loss": [],
"val_loss": []
}
model = Sequential()
# layer 1
model.add(
Convolution2D(
nb_filters,
nb_conv,
nb_conv,
input_shape=(1, img_rows, img_cols),
)
)
model.add(Activation('relu'))
model.add(Dropout(0.4))
# layer 2
model.add(
Convolution2D(
nb_filters,
nb_conv,
nb_conv,
input_shape=(1, img_rows, img_cols),
)
)
model.add(Activation('relu'))
model.add(Dropout(0.4))
# layer 3
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
model.add(Dropout(0.4))
# layer 4
model.add(Flatten())
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
# compile, fit and evaluate model
print("--> compiling CNN functions")
model.compile(
loss='categorical_crossentropy',
optimizer='sgd'
)
# fit model
print("--> fitting CNN")
if data_augmentation is False:
print "--> fitting data"
fitlog = model.fit(
X_train,
Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
show_accuracy=True,
verbose=1,
validation_data=(X_test, Y_test)
)
results = fitlog.history
else:
# turn on data augmentation
print "--> augmenting data"
datagen = ImageDataGenerator(
featurewise_center=False,
featurewise_std_normalization=False,
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
)
datagen.fit(X_train)
print "--> fitting data"
for e in range(nb_epoch):
print "epoch:", e
for X_batch, Y_batch in datagen.flow(X_train, Y_train, batch_size):
train_loss, train_accuracy = model.train_on_batch(
X_batch,
Y_batch,
accuracy=True
)
valid_loss, valid_accuracy = model.test_on_batch(
X_test,
Y_test,
accuracy=True
)
results["acc"].append(float(train_accuracy))
results["val_acc"].append(float(valid_accuracy))
results["loss"].append(float(train_loss))
results["val_loss"].append(float(valid_loss))
print "acc: {0}".format(train_accuracy),
print "val_acc: {0}".format(valid_accuracy),
print "acc_loss: {0}".format(train_loss),
print "val_loss: {0}".format(valid_loss)
# save model
model_data = model.to_json()
model_file = open(model_file, "w")
model_file.write(json.dumps(model_data))
model_file.close()
# save model weights
model.save_weights(weights_file, overwrite=True)
# save results
results["nb_epoch"] = nb_epoch
results["batch_size"] = batch_size
rf = open(results_file, "w")
rf.write(json.dumps(results))
rf.close()
for e in range(epoch_num):
print 'Epoch #{}/{}'.format(e+1,epoch_num)
sys.stdout.flush()
shuffle(tr_it)
for u in tqdm(tr_it):
l,a=model.train_on_batch(tr_in[u],tr_out[u])
tr_hist.r.addLA(l,a,tr_out[u].shape[0])
# clear_output()
tr_hist.log()
for u in range(dev_in.shape[0]):
l,a=model.test_on_batch(dev_in[u],dev_out[u])
dev_hist.r.addLA(l,a,dev_out[u].shape[0])
dev_hist.log()
# for u in range(tst_in.shape[0]):
# l,a=model.test_on_batch(tst_in[u],tst_out[u])
# tst_hist.r.addLA(l,a,tst_out[u].shape[0])
# tst_hist.log()
pickle.dump(model, open('models/classifier_enc.pkl','wb'))
pickle.dump(dev_hist, open('models/testHist_enc.pkl','wb'))
pickle.dump(tr_hist, open('models/trainHist_enc.pkl','wb'))
window_size=4, negative_samples=test_labels, sampling_table=None)
tag_couples, labels = sequence.tagged_cbows(seq, test_tag_seq, len(tag_tokenizer.word_index)+1, # replace seq with train_tag_seq
window_size=4, negative_samples=test_labels, sampling_table=None)
couples = np.array(couples, dtype="int32")
tag_couples = np.array(tag_couples, dtype="int32")
labels = np.array(labels)
X_w = np.array(np.split(couples, len(seq)))
X_t = np.array(np.split(tag_couples, len(seq)))
if test_labels ==0 :
# Divide number of examples to rank so that GPU does not cause out of memory error
splitter = get_min_divisor(len(labels))
test_y = np.reshape(np.empty_like(labels, dtype = 'float32'),(labels.shape[0],1))
for j in range(splitter):
test_loss, test_y_block = model.test_on_batch([X_w[:,j*(labels.shape[0]/splitter): (j+1)*(labels.shape[0]/splitter) ,:],
X_t[:,j*(labels.shape[0]/splitter): (j+1)*(labels.shape[0]/splitter) ,:]],
labels[j*(labels.shape[0]/splitter): (j+1)*(labels.shape[0]/splitter)])
test_y[j*(labels.shape[0]/splitter): (j+1)*(labels.shape[0]/splitter)] = test_y_block
else:
test_loss, test_y = model.test_on_batch([X_w, X_t], labels)
lraps.append(label_ranking_average_precision_score(np.reshape(np.array(labels),test_y.shape).T , test_y.T))
mrr, recall, prec = test_utils.print_accuracy_results(np.array(labels) , np.reshape(test_y, np.array(labels).shape))
mrrs.append(mrr)
recalls.append(recall)
precs.append(prec)
losses.append(test_loss)
test_losses.append(test_loss)
if len(losses) % 100 == 0:
progbar.update(i, values=[("loss", np.sum(losses))])
losses = []
'''
i=0
for file in fileList:
print file
print i
x_train,y_train=readPklFile(file)
#print x_train
if x_train.ndim<3:
continue
if(len(x_train)==0):
continue
if i<1800:
model.fit(x_train,y_train,nb_epoch=40,batch_size=32,verbose=1,show_accuracy=True)
else:
classes=model.predict(x_train,batch_size=32,verbose=1)
y_test=Nomalization(classes)
predictEntity.writelines(file+'\n'+"original:\n"+str(y_train)+"\npredict:\n"+str(y_test)+'\n')
loss,acc=model.test_on_batch(x_train,y_train,accuracy=True)
#print loss,acc
#acc= CalculateAcc(y_train,y_test)
FileEntity.writelines(file+'\n'+'loss: '+str(loss)+"\tacc: "+str(acc)+"\n")
#model.evaluate(x_train,y_train,batch_size=32,verbose=1,show_accuracy=True)
i=i+1
FileEntity.close()
predictEntity.close()
print "finish"
#TESTING GOES HERE
print('Testing...')
accuracyArray = list()
lossArray = list()
progbar = generic_utils.Progbar(X_test.shape[0])
j = 0
while(j != sizeTest):
if(j+batch_size >= sizeTest):
batchToTest = model2.predict(X_test[j:sizeTest])
labelOfBatchToTest = Y_test[j:sizeTest,:]
j = sizeTest
else:
batchToTest = model2.predict(X_test[j:j+batch_size])
labelOfBatchToTest = Y_test[j:j+batch_size,:]
j += batch_size
score = model3.test_on_batch(batchToTest, labelOfBatchToTest,accuracy=True)
lossArray.append(score[0])
accuracyArray.append(score[1])
progbar.add(batchToTest.shape[0], values=[('test loss', score[0]),('test accuracy',score[1])])
lossIteration2.append(np.mean(lossArray))
accuracyIteration2.append(np.mean(accuracyArray))
weightsLayer2 = model3.layers[0].get_weights()
print('ITERATION 2 STARTING (FW)')
#PREVIOUS MODEL
model2 = Sequential()
model2.add(Convolution2D(96, nb_conv, nb_conv,
input_shape=(1, img_rows, img_cols),weights=weightsLayer1))
model2.add(Activation('relu'))
print('Loss = {}, Precision = {}, Recall = {}, F1 = {}'.format(avgLoss, con_dict['r'], con_dict['p'], con_dict['f1']))
print("Validating =>")
val_pred_label = []
avgLoss = 0
bar = progressbar.ProgressBar(max_value=len(val_x))
for n_batch, sent in bar(enumerate(val_x)):
label = val_label[n_batch]
label = np.eye(n_classes)[label][np.newaxis,:]
sent = sent[np.newaxis,:]
if sent.shape[1] > 1: #some bug in keras
loss = model.test_on_batch(sent, label)
avgLoss += loss
pred = model.predict_on_batch(sent)
pred = np.argmax(pred,-1)[0]
val_pred_label.append(pred)
avgLoss = avgLoss/n_batch
predword_val = [ list(map(lambda x: idx2la[x], y)) for y in val_pred_label]
con_dict = conlleval(predword_val, groundtruth_val, words_val, 'r.txt')
val_f_scores.append(con_dict['f1'])
print('Loss = {}, Precision = {}, Recall = {}, F1 = {}'.format(avgLoss, con_dict['r'], con_dict['p'], con_dict['f1']))
if con_dict['f1'] > best_val_f1:
X, y = get_data(files[n:n+batch_size], n)
else:
X, y = get_data(files[n:], n)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0) # , random_state=0
X_train = np.array(X_train)
X_test = np.array(X_test)
y_train = np.array(y_train)
y_test = np.array(y_test)
# convert class vectors to binary class matrices
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
model.train_on_batch(X_train, Y_train)
l, a = model.test_on_batch(X_test, Y_test)
acc.append(a)
loss.append(l)
print "Epoch: %s <==> Val_loss: %s <> Val_acc: %s "% ( str(e), str(sum(loss) / len(loss)), str(sum(acc) / len(acc)) )
'''
fill between on open and close included:
Epoch: 0 <==> Val_loss: 1.19601917664 <> Val_acc: 0.491666666667
Epoch: 1 <==> Val_loss: 0.895532437166 <> Val_acc: 0.441666666667
Epoch: 2 <==> Val_loss: 0.89461884896 <> Val_acc: 0.408333333333
Epoch: 3 <==> Val_loss: 0.900162645181 <> Val_acc: 0.433333333333
Epoch: 4 <==> Val_loss: 0.908274920781 <> Val_acc: 0.4
Epoch: 5 <==> Val_loss: 0.906020263831 <> Val_acc: 0.45
Epoch: 6 <==> Val_loss: 0.910774775346 <> Val_acc: 0.475
Epoch: 7 <==> Val_loss: 0.922956418991 <> Val_acc: 0.45
def analyze_whale_data(**kwargs):
print("analyzing whale data")
# seed random
np.random.seed(kwargs["seed"])
# model inputs and parameters
#X_train = kwargs["X_train"]
#X_test = kwargs["X_test"]
#Y_train = kwargs["Y_train"]
#Y_test = kwargs["Y_test"]
X_train=np.load(home+'/gabor/numpyFiles/Training Set.npy')
X_test=np.load(home+'/gabor/numpyFiles/TestSet.npy')
Y_train=np.load(home+'/gabor/numpyFiles/Training Labels.npy')
Y_test=np.load(home+'/gabor/numpyFiles/TestSet Labels.npy')
X_test = X_test.reshape(-1, 1, 30, 96)
Y_test = np_utils.to_categorical(Y_test, 447)
X_train = X_train.reshape(-1, 1, 30, 96)
Y_train = np_utils.to_categorical(Y_train, 447)
img_rows = kwargs["img_rows"]
img_cols = kwargs["img_cols"]
nb_filters = kwargs.get("nb_filters", 32)
nb_conv = kwargs.get("nb_conv", 3)
nb_pool = kwargs.get("nb_pool", 2)
batch_size = kwargs.get("batch_size", 32)
nb_epoch = kwargs.get("nb_epoch", 12)
nb_classes = kwargs.get("nb_classes", 447)
print("X_test.shape == {};".format(X_test.shape))
print("Y_test.shape == {};".format(Y_test.shape))
print("X_test.shape == {};".format(X_train.shape))
print("Y_test.shape == {};".format(Y_train.shape))
# CNN architecture
print("--> creating CNN network ...")
model = Sequential()
# layer 1
model.add(
Convolution2D(
nb_filters,
nb_conv,
nb_conv,
border_mode='full',
input_shape=(1, img_rows, img_cols)
)
)
model.add(Activation('relu'))
# layer 2
model.add(Convolution2D(32, 5, 5, border_mode='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
# layer 3
model.add(Convolution2D(64, 5, 5, border_mode='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
# layer 4
model.add(Convolution2D(128, 3, 3, border_mode='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
# layer 5
model.add(Flatten())
model.add(Dense(1000))
model.add(Activation('relu'))
model.add(Dropout(0.5))
# layer 6
model.add(Dense(1000))
model.add(Activation('relu'))
model.add(Dropout(0.5))
# layer 4
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
# compile, fit and evaluate model
print("--> compiling CNN functions")
model.compile(
loss='categorical_crossentropy',
optimizer='adadelta'
)
print("--> fitting CNN")
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=0, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)
height_shift_range=0.1, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=True) # randomly flip images
datagen.fit(X_train)
loss1 = np.zeros((nb_epoch))
loss1 = loss1.astype(np.float32)
acc1 = np.zeros((nb_epoch))
acc1 = acc1.astype(np.float32)
score1 = np.zeros((nb_epoch))
score1 = score1.astype(np.float32)
test_acc1 = np.zeros((nb_epoch))
test_acc1 = test_acc1.astype(np.float32)
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print("Training...")
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(X_train.shape[0])
for X_batch, Y_batch in datagen.flow(X_train, Y_train):
loss, acc = model.train_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("train loss", loss), ("train accuracy", acc)])
loss1[e] = loss
acc1[e] = acc
print("Testing...")
# test time!
progbar = generic_utils.Progbar(X_test.shape[0])
for X_batch, Y_batch in datagen.flow(X_test, Y_test):
score, test_acc = model.test_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("test loss", score), ("test accuracy", test_acc)])
score1[e] = score
test_acc1[e] = test_acc
print("--> saving CNN")
json_string = model.to_json()
open('my_model_architecture.json', 'w').write(json_string)
model.save_weights('my_model_weights.h5')
return (loss1, acc1, score1, test_acc1)
class Model() :
# mode = 'encode' || 'train'
def __init__(self, mode) :
self.io_dim = Codec.n_chars
with open('config/semantic.json') as file :
semantic_config = json.load(file)
self.feature_dim = semantic_config['vectorDim']
self.seq_len = semantic_config['seqLength']
self.mode = mode
self.model = SeqModel()
self.encoder = SeqContainer()
self.encoder.add(TimeDistributedDense(
input_dim = self.io_dim,
input_length = self.seq_len,
output_dim = self.feature_dim,
activation = 'sigmoid'))
self.encoder.add(GRU(
input_dim = self.feature_dim,
input_length = self.seq_len,
output_dim = self.feature_dim,
activation = 'sigmoid',
inner_activation = 'hard_sigmoid',
truncate_gradient = self.seq_len,
return_sequences = True))
self.encoder.add(GRU(
input_dim = self.feature_dim,
input_length = self.seq_len,
output_dim = self.feature_dim,
activation = 'sigmoid',
inner_activation = 'hard_sigmoid',
truncate_gradient = self.seq_len,
return_sequences = False))
self.model.add(self.encoder)
if mode == 'train' :
self.decoder = SeqContainer()
self.decoder.add(SimpleRNN(
input_dim = self.feature_dim,
input_length = self.seq_len,
output_dim = self.feature_dim,
activation = 'sigmoid',
truncate_gradient = self.seq_len,
return_sequences = True))
self.decoder.add(TimeDistributedDense(
input_dim = self.feature_dim,
input_length = self.seq_len,
output_dim = self.io_dim,
activation = 'sigmoid'))
self.model.add(RepeatVector(self.seq_len, input_shape = (self.feature_dim,)))
self.model.add(self.decoder)
def _load_weights(self, path) :
with h5py.File(path, 'r') as file :
group = file['/weights']
n_layers = group.attrs.get('n_layers')[0]
weights = []
for i in range(n_layers) :
layer_weights = file['/weights/layer_' + str(i)][()]
weights.append(layer_weights)
return weights
def load(self) :
encoder_weights = self._load_weights('data/encoder.hdf5')
self.encoder.set_weights(encoder_weights)
if self.mode == 'train' :
decoder_weights = self._load_weights('data/decoder.hdf5')
self.decoder.set_weights(decoder_weights)
def _save_weights(self, weights, path) :
with h5py.File(path, 'w') as file :
group = file.create_group('weights')
n_layers = len(weights)
group.attrs.create('n_layers', np.array([n_layers]))
for i, layer_weights in enumerate(weights) :
group.create_dataset('layer_' + str(i), data = layer_weights)
def save(self) :
if self.mode != 'train' :
raise Exception('invalid mode')
encoder_weights = self.encoder.get_weights()
decoder_weights = self.decoder.get_weights()
self._save_weights(encoder_weights, 'data/encoder.hdf5')
self._save_weights(decoder_weights, 'data/decoder.hdf5')
def compile(self) :
self.model.compile(loss = 'categorical_crossentropy', optimizer = Adadelta(clipnorm = 1.))
# in_data & out_data numpy bool array of shape (n_sample, seq_len, io_dim)
# return train (loss, accuracy)
def train(self, in_data, out_data) :
if self.mode != 'train' :
raise Exception('invalid mode')
return self.model.train_on_batch(in_data, out_data, accuracy = True)
# in_data & out_data numpy bool array of shape (n_sample, seq_len, io_dim)
# return the evaluation (loss, accuracy)
def evaluate(self, in_data, out_data) :
if self.mode != 'train' :
raise Exception('invalid mode')
return self.model.test_on_batch(in_data, out_data, accuracy = True)
# sequence : numpy bool array of shape (seq_len, io_dim)
# return : numpy float32 array of shape (feature_dim)
def encode(self, sequence) :
if self.mode != 'encode' :
raise Exception('invalid mode')
input_sequences = np.ndarray((1, self.seq_len, self.io_dim), dtype = np.bool)
input_sequences[0] = sequence
return self.model.predict(input_sequences)[0]
print('Test score:', score)
else:
print('Using real time data augmentation')
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print('Training...')
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(num_images-test_size)
for X_batch, Y_batch in flow(image_list[0:-test_size]):
X_batch = X_batch.reshape(X_batch.shape[0], 3, img_rows, img_cols)
Y_batch = np_utils.to_categorical(Y_batch, nb_classes)
loss = model.train_on_batch(X_batch, Y_batch)
progbar.add(X_batch.shape[0], values=[('train loss', loss)])
print('Testing...')
# test time!
progbar = generic_utils.Progbar(test_size)
for X_batch, Y_batch in flow(image_list[-test_size:]):
X_batch = X_batch.reshape(X_batch.shape[0], 3, img_rows, img_cols)
Y_batch = np_utils.to_categorical(Y_batch, nb_classes)
score = model.test_on_batch(X_batch, Y_batch)
progbar.add(X_batch.shape[0], values=[('test loss', score)])
json_string = model.to_json()
open('cnn1_model_architecture.json', 'w').write(json_string)
model.save_weights('cnn1_model_weights.h5')
index += 1
model.save_weights("test_weights.hdf5", overwrite=True)
model.load_weights("test_weights.hdf5")
end = datetime.now()
diff = end - begin
avgSec = diff.total_seconds() / EPOCHS
avgMin = int(avgSec / 60)
avgHour = int(avgMin / 60)
avgDay = int(avgHour / 24)
avgSec -= 60 * avgMin
avgMin -= 60 * avgHour
avgHour -= 24 * avgDay
# loss, acc = model.evaluate(tX, tY, batch_size=BATCH_SIZE, show_accuracy=True)
progbar = generic_utils.Progbar(tX.shape[0])
index = 0
for i in range(len(tX) / BATCH_SIZE):
loss, acc = model.test_on_batch(tX[index : index + BATCH_SIZE], tY[index : index + BATCH_SIZE], accuracy=True)
progbar.add(BATCH_SIZE, values=[("test loss", loss), ("test acc", acc)])
index += BATCH_SIZE
"""
fResult = open('test.txt', 'a+')
fResult.write('Test loss / test accuracy = %.4f / %.4f\n'%(loss, acc))
fResult.write('mode acc / test mode acc = %.4f / %.4f\n'%(accmode, taccmode))
fResult.write('Average learning time = %ddays %d:%d:%d\n\n'%(avgDay, avgHour, avgMin, avgSec))
fResult.close()
"""
def CNN():
input_frames=10
batch_size = 32
nb_classes = 20
nb_epoch = 200
img_rows, img_cols = 224,224
img_channels = 2*input_frames
print 'X_sample: '+str(X_sample.shape)
print 'X_test: '+str(X_test.shape)
print 'Y_test: '+str(Y_test.shape)
print 'Preparing architecture...'
model = Sequential()
model.add(Convolution2D(96, 7, 7, border_mode='same',input_shape=(img_channels, img_rows, img_cols)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(256, 5, 5, border_mode='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(512, 3, 3, border_mode='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(512, 3, 3, border_mode='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(512, 3, 3, border_mode='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(2048))
fc_output=Activation('relu')
model.add(fc_output)
model.add(Dropout(0.5))
model.add(Dense(2048))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
softmax_output=Activation('softmax')
model.add(softmax_output)
print 'Starting with training...'
gc.collect()
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss={'output1':'categorical_crossentropy'}, optimizer=sgd)
print("Using real time data augmentation")
datagen = ImageDataGenerator(
featurewise_center=True, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=True, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=20, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=0.2, # randomly shift images horizontally (fraction of total width)
height_shift_range=0.2, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=True) # randomly flip images
# compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied)
datagen.fit(X_sample)
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print("Training...")
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(X_train.shape[0])
for X_train, Y_train in getTrainData():
for X_batch, Y_batch in datagen.flow(X_train, Y_train, batch_size=batch_size):
loss = model.train_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("train loss", loss[0]),("train accuracy", loss[1])])
fc_output
softmax_output
print('Saving layer representation and saving weights...')
with h5py.File('fc_output.h5', 'w') as hf:
hf.create_dataset('fc_output', data=fc_output)
with h5py.File('softmax_output.h5', 'w') as hf:
hf.create_dataset('softmax_output', data=softmax_output)
model.save_weights('temporal_stream_model.h5')
print("Testing...")
# test time!
progbar = generic_utils.Progbar(X_test.shape[0])
for X_test, Y_test in getTestData():
for X_batch, Y_batch in datagen.flow(X_test, Y_test, batch_size=batch_size):
score = model.test_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("test loss", score[0]),("test accuracy", score[1])])
height_shift_range=0, # randomly shift images vertically (fraction of total height)
horizontal_flip=False, # randomly flip images
vertical_flip=False) # randomly flip images
# compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied)
datagen.fit(X_train)
for e in range(nb_epoch):
print('-'*40)
print('Epoch', e)
print('-'*40)
print("Training...")
# batch train with realtime data augmentation
progbar = generic_utils.Progbar(X_train.shape[0])
for X_batch, Y_batch in datagen.flow(X_train, Y_train, batch_size=batch_size):
score, trainAccu = model.train_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("train accuracy", trainAccu)])
print("Testing...")
# test time!
progbar = generic_utils.Progbar(X_test.shape[0])
for X_batch, Y_batch in datagen.flow(X_test, Y_test, batch_size=batch_size):
score, testAccu = model.test_on_batch(X_batch, Y_batch, accuracy=True)
progbar.add(X_batch.shape[0], values=[("test accuracy", testAccu)])
trainScores.append(trainAccu)
testScores.append(testAccu)
scipy.io.savemat('cnn_results', {'trainAccu': trainScores, 'testAccu': testScores})
print ('Average train accuracies: {0}'.format(np.mean(trainScores)))
print ('Average test accuracies: {0}'.format(np.mean(testScores)))
