class FBB():
def __init__(self, use_gpu=False):
self.use_cudnn = use_gpu
def load_data(self, x_train_loc, y_train_loc, x_val_loc, y_val_loc):
self.X_train = np.load(x_train_loc)
self.Y_train = np.load(y_train_loc)
self.val = (np.load(x_val_loc), np.load(y_val_loc))
def define_model(self, hidden_size, test=False):
if test:
input_size = self.X_test[0].shape[1]
else:
input_size = self.X_train.shape[2]
self.model = Sequential()
self.model.add(
TimeDistributed(Dense(hidden_size, activation='sigmoid'),
input_shape=(None, input_size)))
# self.model.add(Masking(input_shape=(None, input_size)))
if self.use_cudnn:
self.model.add(
Bidirectional(CuDNNLSTM(hidden_size, return_sequences=True)))
self.model.add(Bidirectional(CuDNNLSTM(6, return_sequences=True)))
else:
self.model.add(
Bidirectional(LSTM(hidden_size, return_sequences=True),
input_shape=(None, input_size)))
self.model.add(Bidirectional(LSTM(6, return_sequences=True)))
print('compiling')
self.model.compile(loss='mean_squared_error',
optimizer='rmsprop',
metrics=['mse'])
def load_test_data(self, x_test_loc, y_test_loc):
with open(x_test_loc, 'rb') as f:
self.X_test = pickle.load(f)
with open(y_test_loc, 'rb') as f:
self.Y_test = pickle.load(f)
def test_generator(self):
while True:
for x, y in zip(self.X_test, self.Y_test):
yield (x.reshape(1, x.shape[0], x.shape[1]),
y.reshape(1, y.shape[0], y.shape[1]))
def train(self, batch_size, num_epochs):
early_stopping = EarlyStopping(monitor='val_loss', patience=7)
self.model.fit(self.X_train,
self.Y_train,
batch_size=batch_size,
epochs=num_epochs,
validation_data=self.val,
callbacks=[early_stopping])
def test(self):
gen = self.test_generator()
score = self.model.evaluate_generator(gen, steps=len(self.X_test))
print("%s: %.2f%%" % (self.model.metrics_names[1], score[1] * 100))
callbacks = [
TensorBoard(log_dir="logs/{}".format(NAME)),
EarlyStopping(monitor='val_loss',
min_delta=0,
patience=2,
verbose=0,
mode='auto',
baseline=None,
restore_best_weights=False)
]
model.fit_generator(train_generator,
callbacks=callbacks,
steps_per_epoch=TRAIN_STEP,
epochs=EPOCHS,
validation_data=validation_generator,
validation_steps=VALIDATION_STEP)
score = model.evaluate_generator(validation_generator,
VALIDATION_STEP / BATCH_SIZE,
workers=12)
scores = model.predict_generator(validation_generator,
VALIDATION_STEP / BATCH_SIZE,
workers=12)
model.save(FILE_NAME)
with open("logs/mylog.txt", "a") as f:
f.write("\n\n--------" + NAME + "----------\n")
f.write(str(score) + "\n")
look_back = 10
n_features = 2
train_data_gen = TimeseriesGenerator(train,
train,
length=look_back,
sampling_rate=1,
stride=1,
batch_size=3)
test_data_gen = TimeseriesGenerator(test,
test,
length=look_back,
sampling_rate=1,
stride=1,
batch_size=1)
model = Sequential()
model.add(LSTM(25, input_shape=(look_back, n_features)))
model.add(Dense(n_features, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
model.summary()
model.fit_generator(train_data_gen, epochs=100, steps_per_epoch=10)
model.evaluate_generator(test_data_gen)
print()
set_trainable = False
for layer in conv_base.layers:
if layer.name == 'block5_conv1':
set_trainable = True
if set_trainable:
layer.trainable = True
else:
layer.trainable = False
model_2.compile(loss='binary_crossentropy',
optimizer=optimizers.RMSprop(lr=1e-5),
metrics=['acc'])
history = model_2.fit_generator(
train_generator,
steps_per_epoch=100,
epochs=100,
validation_data=validation_generator,
validation_steps=50)
plot_history(history, smooth=True)
test_generator = test_datagen.flow_from_directory(test_dir,
target_size=(150, 150),
batch_size=BATCH_SIZE,
class_mode='binary')
test_loss, test_acc = model_2.evaluate_generator(test_generator, steps=50)
print('test acc:', test_acc)
model = Sequential()
model.add(layers.Conv2D(64, kernel_size=3, activation='relu', input_shape=(img_height,img_width,1)))
model.add(layers.Conv2D(64, kernel_size=1, activation='relu'))
model.add(layers.Conv2D(64, kernel_size=3, activation='relu'))
model.add(layers.MaxPooling2D(pool_size=(2,2),strides = None))
model.add(layers.Conv2D(128, kernel_size=3, activation='relu'))
model.add(layers.MaxPooling2D(pool_size=(2,2),strides = None))
model.add(layers.Conv2D(256, kernel_size=3, activation='relu'))
model.add(layers.MaxPooling2D(pool_size=(2,2),strides = None))
model.add(layers.Flatten())
model.add(layers.Dense(500, activation='relu'))
model.add(Dropout(0.5))
num_classes = train_generator.num_classes
model.add(layers.Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics = ['accuracy'])
model.load_weights('../output/first_try.h5')
model.save('../output/jmatt_best_sketches.h5')
acc = model.evaluate_generator(validation_generator, steps=np.floor(validation_generator.n/batch_size),verbose=1)
print(acc)
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.savefig(output_dir + '/accuracy.png')
plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.savefig(output_dir + '/loss.png')
print("evaluation time")
evaluation = model.evaluate_generator(test_generator,
steps=test_generator.n //
test_generator.batch_size,
verbose=1)
print(evaluation)
with open(output_dir + '/evaluation.txt', 'w') as f:
f.write(str(evaluation[0]) + "\n")
f.write(str(evaluation[1]))
print("prediction time")
test_generator.reset()
pred = model.predict_generator(test_generator,
steps=test_generator.n //
test_generator.batch_size,
verbose=1)
class Model():
def __init__(self,
train_generator,
validation_generator,
test_generator,
epochs=10):
self.train_generator = train_generator
self.validation_generator = validation_generator
self.test_generator = test_generator
self.batch_size = len(train_generator)
self.epochs = epochs
def create_model(self):
input_shape_ = self.train_generator.shape[1:]
self.model = Sequential()
self.model.add(
Conv2D(32, (5, 5),
strides=(1, 1),
padding='same',
input_shape=input_shape_))
self.model.add(Activation('relu'))
#self.model.add(BatchNormalization(axis=chanDim))
self.model.add(Conv2D(32, (5, 5), strides=(2, 2), padding='valid'))
self.model.add(Activation('relu'))
self.model.add(Conv2D(64, (3, 3), strides=(1, 1), padding='valid'))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Activation('relu'))
self.model.add(Conv2D(32, (3, 3), strides=(2, 2), padding='valid'))
self.model.add(Activation('relu'))
self.model.add(Flatten())
self.model.add(Dense(64))
self.model.add(Activation('relu'))
self.model.add(Dense(40))
self.model.add(Dropout(0.5))
self.model.add(Activation('relu'))
self.model.add(Dense(20))
self.model.add(Activation('relu'))
self.model.add(Dense(2))
self.model.add(Activation('softmax'))
self.summery()
opt = SGD(0.01)
self.model.compile(optimizer=opt,
loss=categorical_crossentropy,
metrics=['accuracy'])
def summery(self):
self.model.summary()
def fit(self):
self.model.fit_generator(
generator=self.train_generator,
epochs=self.epochs,
validation_data=self.validation_generator,
use_multiprocessing=True,
workers=4,
callbacks=[checkpoint, reduce_lr, early_stopping])
self.model.save("save")
def evaluate(self):
score, acc = self.model.evaluate_generator(
generator=self.test_generator,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
verbose=0)
print('Test score:', score)
print('Test accuracy:', acc)
class Model:
def __init__(self, dataset, model_path):
self.dataset = dataset
self.model = Sequential()
self.model_path = model_path
def create(self, tile_size: (int, int)):
input_shape = (*tile_size, 3)
model = Sequential()
model.add(Conv2D(filters=32, kernel_size=3, activation='relu',
padding='same', input_shape=input_shape))
# model.add(Conv2D(filters=32, kernel_size=3,
# padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D())
model.add(Conv2D(filters=64, kernel_size=3,
padding='same', activation='relu'))
# model.add(Conv2D(filters=64, kernel_size=3,
# padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D())
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(16, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
self.model = model
def train(self, epochs, verbose=2):
train_datagen = self._get_scaling_generator(self.dataset.X_train,
self.dataset.Y_train)
val_datagen = self._get_scaling_generator(self.dataset.X_test,
self.dataset.Y_test)
train_history = self.model.fit_generator(train_datagen,
epochs=epochs,
validation_data=val_datagen,
verbose=verbose)
fig, axes = plt.subplots(1, 2, sharex='all')
axes[0].plot(train_history.history['loss'])
axes[0].plot(train_history.history['val_loss'])
axes[0].set_ylabel('loss')
axes[1].plot(train_history.history['acc'])
axes[1].plot(train_history.history['val_acc'])
axes[1].set_ylabel('accuracy')
axes[0].legend(['train loss', 'validation loss'], loc='best')
axes[1].legend(['train accuracy', 'validation accuracy'], loc='best')
fig.text(0.5, 0.02, "Number of epochs", horizontalalignment='center')
plt.show()
def evaluate(self):
test_datagen = self._get_scaling_generator(self.dataset.X_test,
self.dataset.Y_test)
outputs = self.model.evaluate_generator(test_datagen)
logger.info("Results: Loss: %.3f, Accuracy: %.3f", *outputs)
def predict(self, verbose=1):
test_datagen = self._get_scaling_generator(self.dataset.X_test, shuffle=False)
results = self.model.predict_generator(test_datagen, verbose=verbose)
return results
def save(self):
model_path = self.model_path
self.model.save(model_path)
def load(self):
model_path = self.model_path
self.model = load_model(model_path)
@staticmethod
def _get_scaling_generator(x, y=None, shuffle=True):
datagen = ImageDataGenerator(rescale=1. / 255)
return datagen.flow(x, y, shuffle=shuffle)
metrics=['accuracy'])
model.summary()
print(train_generator.class_indices, end='\n\n')
early_stopping = tf.keras.callbacks.EarlyStopping(patience=2,
restore_best_weights=True)
model.fit_generator(train_generator,
epochs=7,
verbose=2,
callbacks=[early_stopping],
validation_data=validation_generator)
_, acc = model.evaluate_generator(test_generator)
print('Test Accuracy: %.3f' % (acc * 100))
if model_name:
model.save('models/%.2f_%s' % (acc, model_name))
else:
import time
ts = time.gmtime()
simple_ts = time.strftime("%s", ts)
model.save('models/%.2f_%s.h5' % (acc, simple_ts))
if suspend_on_finished:
import os
os.system("systemctl suspend")
Convolution2D(32,
3,
3,
activation='relu',
input_shape=(IMG_SIZE, IMG_SIZE, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(1, activation='softmax'))
# Print out model definition
model.summary()
plot_model(model, to_file='model.png')
# Prepare the model for training
model.compile(loss='binary_crossentropy', optimizer='adam')
# Train the model
model.fit_generator(generator=trainGen,
epochs=20,
steps_per_epoch=10,
validation_steps=5,
validation_data=valGen)
# Save the model
model.save("model1.h5")
# Evaluate the model
model.evaluate_generator(valGen, steps=5)
model.compile(loss=custom_loss, optimizer='adam')
model.summary()
print("model compiled")
# generators
data_generator = ImageDataGenerator()
train_generator = data_generator.flow_from_directory(
TRAIN_DATASET,
target_size=image_template.shape[0:2],
batch_size=4,
color_mode="rgb")
test_generator = data_generator.flow_from_directory(
TEST_DATASET,
target_size=image_template.shape[0:2],
batch_size=4,
color_mode="rgb")
# fitting
print(len(train_generator))
model.fit_generator(test_generator,
steps_per_epoch=16,
epochs=20,
verbose=1,
callbacks=[tb_call_back])
# Saving the model
model.save_weights('pklot_1.h5')
scores = model.evaluate_generator(train_generator)
print(scores)
target_size=(224, 224),
batch_size=20,
class_mode='categorical')
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["acc"])
history = model.fit_generator(train_generator,
steps_per_epoch=100,
validation_data=validation_generator,
validation_steps=50,
epochs=10)
#model.save("dogCatFineTune.h5")
predictions = model.evaluate_generator(test_generator, steps=34, verbose=0)
print(predictions)
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'b', label='Training acc')
plt.plot(epochs, val_acc, 'r', label='Validation acc')
plt.title('Dog Cat Fine Tune\nTraining and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Dog Cat Fine Tune\nTraining and validation loss')
from keras import Sequential
from keras.layers import Dense
print("Tensorflow version", tf.__version__)
model1 = Sequential()
model1.add(Dense(10, input_shape=(1000,)))
model1.add(Dense(3, activation='relu'))
model1.compile('sgd', 'mse')
def gen():
while True:
yield np.zeros([10, 1000]), np.ones([10, 3])
import os
import psutil
process = psutil.Process(os.getpid())
g = gen()
while True:
print(process.memory_info().rss / float(2 ** 20))
model1.fit_generator(g, 100, 2, use_multiprocessing=True, verbose=0)
model1.evaluate_generator(gen(), 100, use_multiprocessing=True, verbose=0)
batch_size=batch_size,
shuffle=False)
test_generator = TimeseriesGenerator(X_test,
y_test,
length=window_size,
batch_size=1,
shuffle=False)
model = Sequential()
model.add(CuDNNGRU(128, input_shape=(
window_size,
X_train.shape[1],
)))
model.add(Dense(64, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(y_train.shape[1], activation='softmax'))
# Run training
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit_generator(train_generator, epochs=epochs)
print(model.evaluate_generator(test_generator))
y_true = np.argmax(y_test[window_size:], axis=1)
y_pred = np.argmax(model.predict_generator(test_generator), axis=1)
print('Confusion matrix')
print(confusion_matrix(y_true, y_pred))
class myModel(object):
def __init__(self):
self.model = Sequential()
self.model.add(Conv2D(32, (3, 3), input_shape=(100, 100, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(32, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(64, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(64, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Flatten())
self.model.add(Dense(64))
self.model.add(Activation('relu'))
self.model.add(Dropout(0.85))
self.model.add(Dense(2))
self.model.add(Activation('sigmoid'))
def train(self, dataset):
batch_size = dataset.batch_size
nb_epoch = dataset.nb_epoch
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
self.model.fit_generator(
dataset.train_data_generate(),
steps_per_epoch=dataset.total_train // batch_size,
epochs=nb_epoch,
validation_data=dataset.val_data_generate(),
validation_steps=dataset.total_val // batch_size)
def save(self, file_path="model.h5"):
print('Model Saved.')
self.model.save_weights(file_path)
def load(self, file_path="model.h5"):
print('Model Loaded.')
self.model.load_weights(file_path)
def predict(self, image):
# 预测样本分类
img = image.resize((1, IMAGE_SIZE, IMAGE_SIZE, 3))
img = image.astype('float32')
img /= 255
#归一化
result = self.model.predict(img)
print(result)
# 概率
result = self.model.predict_classes(img)
print(result)
# 0/1
return result[0]
def evaluate(self, dataset):
# 测试样本准确率
score = self.model.evaluate_generator(dataset.valid, steps=2)
print("样本准确率%s: %.2f%%" %
(self.model.metrics_names[1], score[1] * 100))
for i in range(test_pred.shape[0]):
for j in range(test_pred.shape[1]):
temp = np.load('data/data_rows_target/' + 'shop_' + str(i) +
'_target' + '.npy')
sum_per_day_y = 0
sum_per_day_pred = 0
for n in range(test_pred.shape[2]):
sum_per_day_y = sum_per_day_y + temp[j, n]
sum_per_day_pred = sum_per_day_pred + test_pred[i, j, n]
test_y_list.append(sum_per_day_y)
test_pred_list.append(sum_per_day_pred)
plot_shop = 25
pyplot.plot(x_labels,
test_y_list[plot_shop * 10:(plot_shop * 10) + 10],
label='target')
pyplot.plot(x_labels,
test_pred_list[plot_shop * 10:(plot_shop * 10) + 10],
label='predicted')
pyplot.xticks(rotation=45)
pyplot.legend()
pyplot.show()
# evaluate model (val generator, steps (batches of samples) to yield from generator before stopping)
score = model.evaluate_generator(validation_generator, 1000, verbose=2)
print(score)
print("--- %s s ---" % (time.time() - start_time))
class CNNmodel7:
def __init__(self, img_size=(256, 256), dump_path='dump/'):
# Random parameters
conv1_filters = np.random.randint(1, 65)
conv2_filters = np.random.randint(1, 65)
conv3_filters = np.random.randint(1, 65)
conv1_kernel = np.random.randint(2, 10)
conv2_kernel = np.random.randint(2, 10)
conv3_kernel = np.random.randint(2, 10)
conv1_strides = np.random.randint(1, conv1_kernel / 2 + 1)
conv2_strides = np.random.randint(1, conv2_kernel / 2 + 1)
conv3_strides = np.random.randint(1, conv3_kernel / 2 + 1)
maxpool1_size = np.random.randint(2, 8)
maxpool2_size = np.random.randint(2, 8)
maxpool3_size = np.random.randint(2, 8)
fc1_units = 2**np.random.randint(6, 11)
fc2_units = 2**np.random.randint(6, 11)
# Model architecture
self.model = Sequential()
self.model.add(
Conv2D(filters=conv1_filters,
kernel_size=(conv1_kernel, conv1_kernel),
strides=(conv1_strides, conv1_strides),
activation='relu',
input_shape=(img_size[0], img_size[1], 3),
name='conv1'))
self.model.add(
MaxPooling2D(pool_size=(maxpool1_size, maxpool1_size),
strides=None,
name='maxpool1'))
self.model.add(
Conv2D(filters=conv2_filters,
kernel_size=(conv2_kernel, conv2_kernel),
strides=(conv2_strides, conv2_strides),
activation='relu',
name='conv2'))
self.model.add(
MaxPooling2D(pool_size=(maxpool2_size, maxpool2_size),
strides=None,
name='maxpool2'))
self.model.add(
Conv2D(filters=conv3_filters,
kernel_size=(conv3_kernel, conv3_kernel),
strides=(conv3_strides, conv3_strides),
activation='relu',
name='conv3'))
self.model.add(
MaxPooling2D(pool_size=(maxpool3_size, maxpool3_size),
strides=None,
name='maxpool3'))
self.model.add(Flatten())
self.model.add(Dense(units=fc1_units, activation='relu', name='fc1'))
self.model.add(Dense(units=fc2_units, activation='relu', name='fc2'))
self.model.add(Dense(units=8, activation='softmax', name='classif'))
# Optimizer
optimizer = Adam()
# Compile
self.model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
# Parameters
self.born_time = time.strftime('%Y%m%d%H%M%S', time.gmtime())
self.identifier = str(hash(str(self.model.get_config())))
self.dump_path = os.path.join(
dump_path,
str(self.born_time) + '_' + self.identifier)
self.input_img_size = img_size
# Print
if not os.path.exists(self.dump_path):
os.makedirs(self.dump_path)
self.model.summary()
print('Current model: ' + self.identifier)
plot_model(self.model,
show_shapes=True,
show_layer_names=True,
to_file=os.path.join(self.dump_path,
self.identifier + '.png'))
def _train_generator(self, path, batch_size):
datagen = ImageDataGenerator(
preprocessing_function=self._preprocess_input,
rotation_range=0,
width_shift_range=0.,
height_shift_range=0.,
shear_range=0.,
zoom_range=0.,
channel_shift_range=0.,
fill_mode='reflect',
cval=0.,
horizontal_flip=False,
vertical_flip=False)
return datagen.flow_from_directory(path,
target_size=self.input_img_size,
batch_size=batch_size,
class_mode='categorical')
def _test_val_generator(self, path, batch_size):
datagen = ImageDataGenerator(
preprocessing_function=self._preprocess_input)
return datagen.flow_from_directory(path,
target_size=self.input_img_size,
batch_size=batch_size,
class_mode='categorical',
shuffle=False)
def fit_directory(self,
path,
batch_size,
epochs,
val_path=None,
save_weights=False):
train_generator = self._train_generator(path, batch_size)
if val_path is None:
validation_generator = None
validation_steps = None
else:
validation_generator = self._test_val_generator(
val_path, batch_size)
validation_steps = validation_generator.samples / batch_size
history = self.model.fit_generator(
train_generator,
steps_per_epoch=train_generator.samples / batch_size,
epochs=epochs,
validation_data=validation_generator,
validation_steps=validation_steps)
utils.plot_history(history,
self.dump_path,
identifier='e' + str(epochs) + '_b' +
str(batch_size))
with open(
os.path.join(
self.dump_path, 'e' + str(epochs) + '_b' +
str(batch_size) + '_history.pklz'), 'wb') as f:
cPickle.dump((history.epoch, history.history, history.params,
history.validation_data, self.model.get_config()), f,
cPickle.HIGHEST_PROTOCOL)
if save_weights:
self.model.save_weights(
os.path.join(
self.dump_path, 'e' + str(epochs) + '_b' +
str(batch_size) + '_weights.h5'))
return history
def evaluate(self, path):
test_generator = self._test_val_generator(path, batch_size=32)
return self.model.evaluate_generator(test_generator)
def _preprocess_input(self, x, dim_ordering='default'):
if dim_ordering == 'default':
dim_ordering = K.image_dim_ordering()
assert dim_ordering in {'tf', 'th'}
mean = [109.07621812, 115.45609435, 114.70990406]
std = [56.91689916, 55.4694083, 59.14847488]
if dim_ordering == 'th':
# Zero-center by mean pixel
x[0, :, :] -= mean[0]
x[1, :, :] -= mean[1]
x[2, :, :] -= mean[2]
# Normalize by std
x[0, :, :] /= std[0]
x[1, :, :] /= std[1]
x[2, :, :] /= std[2]
else:
# Zero-center by mean pixel
x[:, :, 0] -= mean[0]
x[:, :, 1] -= mean[1]
x[:, :, 2] -= mean[2]
# Normalize by std
x[:, :, 0] /= std[0]
x[:, :, 1] /= std[1]
x[:, :, 2] /= std[2]
return x
class ModelSix():
def __init__(self,
x_train_loc,
y_train_loc,
x_val_loc,
y_val_loc,
use_cudnn=False):
with open(x_train_loc, 'rb') as f:
self.X_train = pickle.load(f)
with open(y_train_loc, 'rb') as f:
self.Y_train = pickle.load(f)
with open(x_val_loc, 'rb') as f:
self.X_val = pickle.load(f)
with open(y_val_loc, 'rb') as f:
self.Y_val = pickle.load(f)
self.use_cudnn = use_cudnn
def define_model(self, hidden_size):
input_size = self.X_train[0].shape[1]
self.model = Sequential()
# self.model.add(Masking(input_shape=(None, input_size)))
if self.use_cudnn:
self.model.add(
Bidirectional(CuDNNLSTM(hidden_size, return_sequences=True),
input_shape=(None, input_size)))
self.model.add(
Bidirectional(CuDNNLSTM(hidden_size, return_sequences=True)))
else:
self.model.add(
Bidirectional(LSTM(hidden_size, return_sequences=True),
input_shape=(None, input_size)))
self.model.add(
Bidirectional(LSTM(hidden_size, return_sequences=True)))
self.model.add(TimeDistributed(Dense(12, activation=None)))
print('compiling')
self.model.compile(loss='mean_squared_error',
optimizer='rmsprop',
metrics=['mse'])
def load_model(self, loc_h5):
self.define_model(200)
self.model.load_weights(loc_h5)
#self.model.compile(loss='mean_squared_error', optimizer='rmsprop', metrics=['rmsprop'])
print(self.model.summary())
def load_test_data(self, x_test_loc, y_test_loc):
with open(x_test_loc, 'rb') as f:
self.X_test = pickle.load(f)
with open(y_test_loc, 'rb') as f:
self.Y_test = pickle.load(f)
def data_generator(self, mode):
while True:
if mode == 'train':
for x, y in zip(self.X_train, self.Y_train):
yield (x.reshape(1, x.shape[0], x.shape[1]),
y.reshape(1, y.shape[0], y.shape[1]))
if mode == 'val':
for x, y in zip(self.X_val, self.Y_val):
yield (x.reshape(1, x.shape[0], x.shape[1]),
y.reshape(1, y.shape[0], y.shape[1]))
if mode == 'test':
for x, y in zip(self.X_test, self.Y_test):
yield (x.reshape(1, x.shape[0], x.shape[1]),
y.reshape(1, y.shape[0], y.shape[1]))
def train(self, num_epochs):
train_gen = self.data_generator('train')
val_gen = self.data_generator('val')
self.model.fit_generator(train_gen,
steps_per_epoch=len(self.X_train),
epochs=num_epochs,
validation_data=val_gen,
validation_steps=len(self.X_val))
def test(self):
test_gen = self.data_generator('test')
score = self.model.evaluate_generator(test_gen, steps=len(self.X_test))
print("%s: %.2f%%" % (self.model.metrics_names[1], score[1] * 100))
