model = Sequential()
model.add(
Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(48, 48, 1)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(7, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.0001, decay=1e-6),
metrics=['accuracy'])
model_info = model.fit_generator(train_generator,
steps_per_epoch=num_train // batch_size,
epochs=num_epoch,
validation_data=validation_generator,
validation_steps=num_val // batch_size)
plot_model_history(model_info)
model.save_weights('model.h5')
def fitting(self):
timesteps = self.lags # tiempo
features = 1 # features or chanels (Volume)
num_classes = 3 # 3 for categorical
#data = np.random.random((1000, dim_row, dim_col))
#clas = np.random.randint(3, size=(1000, 1))
##print(clas)
#clas = to_categorical(clas)
##print(clas)
data = self.X_train
data_test = self.X_test
print(data)
data = data.values.reshape(len(data), timesteps, 1)
data_test = data_test.values.reshape(len(data_test), timesteps, 1)
print(data)
clas = self.y_train
clas_test = self.y_test
clas = to_categorical(clas)
clas_test = to_categorical(clas_test)
cat0 = self.y_train.tolist().count(0)
cat1 = self.y_train.tolist().count(1)
cat2 = self.y_train.tolist().count(2)
print("may: ", cat1, " ", "menor: ", cat2, " ", "neutro: ", cat0)
n_samples_0 = cat0
n_samples_1 = (cat1 + cat2) / 2.0
n_samples_2 = (cat1 + cat2) / 2.0
class_weight = {
0: 1.0,
1: n_samples_0 / n_samples_1,
2: n_samples_0 / n_samples_2
}
def class_1_accuracy(y_true, y_pred):
# cojido de: http://www.deepideas.net/unbalanced-classes-machine-learning/
class_id_true = K.argmax(y_true, axis=-1)
class_id_preds = K.argmax(y_pred, axis=-1)
accuracy_mask = K.cast(K.equal(class_id_preds, 1), 'int32')
class_acc_tensor = K.cast(K.equal(class_id_true, class_id_preds),
'int32') * accuracy_mask
class_acc = K.sum(class_acc_tensor) / K.maximum(
K.sum(accuracy_mask), 1)
return class_acc
class SecondOpinion(Callback):
def __init__(self, model, x_test, y_test, N):
self.model = model
self.x_test = x_test
self.y_test = y_test
self.N = N
self.epoch = 1
def on_epoch_end(self, epoch, logs={}):
if self.epoch % self.N == 0:
y_pred = self.model.predict(self.x_test)
pred_T = 0
pred_F = 0
for i in range(len(y_pred)):
if np.argmax(y_pred[i]) == 1 and np.argmax(
self.y_test[i]) == 1:
pred_T += 1
if np.argmax(y_pred[i]) == 1 and np.argmax(
self.y_test[i]) != 1:
pred_F += 1
if np.argmax(y_pred[i]) == 2 and np.argmax(
self.y_test[i]) == 2:
pred_T += 1
if np.argmax(y_pred[i]) == 2 and np.argmax(
self.y_test[i]) != 2:
pred_F += 1
if pred_T + pred_F > 0:
Pr_pos = pred_T / (pred_T + pred_F)
print("Yoe: epoch, Probabilidad tot: ", self.epoch,
Pr_pos)
print("Yoe: epoch, Cantidad total pred: ", self.epoch,
pred_T + pred_F)
else:
print("Yoe Probabilidad pos: 0")
self.epoch += 1
#################################################################################################################
model = Sequential()
if self.nConv == 0:
model.add(
LSTM(units=self.lstm_nodes,
return_sequences=True,
activation='tanh',
input_shape=(timesteps, features)))
for i in range(self.nLSTM - 2):
model.add(
LSTM(units=self.lstm_nodes,
return_sequences=True,
activation='tanh'))
model.add(LSTM(units=self.lstm_nodes, activation='tanh'))
model.add(Dropout(0.5))
model.add(
Dense(num_classes, activation='softmax')
) # the dimension of index one will be considered to be the temporal dimension
#model.add(Activation('sigmoid')) # for loss = 'binary_crossentropy'
# haciendo x: x[:, -1, :], la segunda dimension desaparece quedando solo
# los ULTIMOS elementos (-1) de dicha dimension:
# Try this to see:
# data = np.random.random((5, 3, 4))
# print(data)
# print(data[:, -1, :])
# model.add(Lambda(lambda x: x[:, -1, :], output_shape = [output_dim]))
print(model.summary())
tensorboard_active = False
val_loss = False
second_opinion = True
callbacks = []
if tensorboard_active:
callbacks.append(
TensorBoard(log_dir=self.putmodel + "Tensor_board_data",
histogram_freq=0,
write_graph=True,
write_images=True))
if val_loss:
callbacks.append(EarlyStopping(monitor='val_loss', patience=5))
if second_opinion:
callbacks.append(SecondOpinion(model, data_test, clas_test, 10))
#model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = ['categorical_accuracy'])
#model.compile(loss = 'binary_crossentropy', optimizer=Adam(lr=self.learning), metrics = ['categorical_accuracy'])
model.compile(loss='categorical_crossentropy',
optimizer='Adam',
metrics=[class_1_accuracy])
model.fit(x=data,
y=clas,
batch_size=self.batch_size,
epochs=800,
verbose=2,
callbacks=callbacks,
class_weight=class_weight)
#validation_data=(data_test, clas_test))
#####################################################################################################################
# serialize model to YAML
model_yaml = model.to_yaml()
with open("model.yaml", "w") as yaml_file:
yaml_file.write(model_yaml)
# serialize weights to HDF5
model.save_weights("model.h5")
print("Saved model to disk")
# # load YAML and create model
# yaml_file = open('model.yaml', 'r')
# loaded_model_yaml = yaml_file.read()
# yaml_file.close()
# loaded_model = model_from_yaml(loaded_model_yaml)
# # load weights into new model
# loaded_model.load_weights("model.h5")
# print("Loaded model from disk")
# loaded_model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy])
#
print("Computing prediction ...")
y_pred = model.predict_proba(data_test)
model.reset_states()
print("Computing train evaluation ...")
score_train = model.evaluate(data, clas, verbose=2)
print('Train loss:', score_train[0])
print('Train accuracy:', score_train[1])
model.reset_states()
# score_train_loaded = loaded_model.evaluate(data, clas, verbose=2)
# loaded_model.reset_states()
# print('Train loss loaded:', score_train[0])
# print('Train accuracy loaded:', score_train[1])
print("Computing test evaluation ...")
score_test = model.evaluate(data_test, clas_test, verbose=2)
print('Test loss:', score_test[0])
print('Test accuracy:', score_test[1])
model.reset_states()
# score_test_loaded = loaded_model.evaluate(data_test, clas_test, verbose=2)
# loaded_model.reset_states()
# print('Test loss loaded:', score_test[0])
# print('Test accuracy loaded:', score_test[1])
pred_T = 0
pred_F = 0
for i in range(len(y_pred)):
if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) == 1:
pred_T += 1
if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) != 1:
pred_F += 1
if np.argmax(y_pred[i]) == 2 and np.argmax(clas_test[i]) == 2:
pred_T += 1
if np.argmax(y_pred[i]) == 2 and np.argmax(clas_test[i]) != 2:
pred_F += 1
if pred_T + pred_F > 0:
Pr_pos = pred_T / (pred_T + pred_F)
print("Yoe Probabilidad tot: ", Pr_pos)
print("Cantidad total pred: ", pred_T + pred_F)
else:
print("Yoe Probabilidad pos: 0")
history = DataFrame([[
self.skip, self.nConv, self.nLSTM, self.learning, self.batch_size,
self.conv_nodes, self.lstm_nodes, score_train[0], score_train[1],
score_test[0], score_test[1]
]],
columns=('Skip', 'cConv', 'nLSTM', 'learning',
'batch_size', 'conv_nodes', 'lstm_nodes',
'loss_train', 'acc_train', 'loss_test',
'acc_test'))
self.history = self.history.append(history)
# fit model
model.fit(X_, Y, epochs=30)
#==================================================================================
# Saving model
# %cd /content/sample_data
model_json = model.to_json()
json_file = open("modelDENSE.json", "w")
json_file.write(model_json)
json_file.close()
model.save_weights("modelDENSE.h5")
print("Model saved to disk")
# # load json and create model
# json_file = open('modelDENSE.json', 'r')
# loaded_model_json = json_file.read()
# json_file.close()
# loaded_model = model_from_json(loaded_model_json)
# # load weights into new model
# loaded_model.load_weights("modelDENSE.h5")
# print("Loaded model from disk")
#
# model = loaded_model
# Print model
plot_model(model, to_file='modelDENSE.png')
class DNN_Model(Common_Model):
'''
__init__(): 初始化神经网络
输入:
input_shape: 特征维度
num_classes(int): 标签种类数量
'''
def __init__(self, input_shape, num_classes, **params):
super(DNN_Model, self).__init__(**params)
self.input_shape = input_shape
self.model = Sequential()
self.make_model()
self.model.add(Dense(num_classes, activation='softmax'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print(self.model.summary(), file=sys.stderr)
'''
save_model(): 将模型权重以 model_name.h5 和 model_name.json 命名存储在 /Models 目录下
'''
def save_model(self, model_name):
h5_save_path = 'Models/' + model_name + '.h5'
self.model.save_weights(h5_save_path)
save_json_path = 'Models/' + model_name + '.json'
with open(save_json_path, "w") as json_file:
json_file.write(self.model.to_json())
'''
train(): 在给定训练集上训练模型
输入:
x_train (numpy.ndarray): 训练集样本
y_train (numpy.ndarray): 训练集标签
x_val (numpy.ndarray): 测试集样本
y_val (numpy.ndarray): 测试集标签
n_epochs (int): epoch数
'''
def train(self, x_train, y_train, x_val=None, y_val=None, n_epochs=50):
acc = []
loss = []
val_acc = []
val_loss = []
if x_val is None or y_val is None:
x_val, y_val = x_train, y_train
for i in range(n_epochs):
# 每个epoch都随机排列训练数据
p = np.random.permutation(len(x_train))
x_train = x_train[p]
y_train = y_train[p]
history = self.model.fit(x_train, y_train, batch_size=32, epochs=1)
# 训练集上的损失率和准确率
acc.append(history.history['acc'])
loss.append(history.history['loss'])
# 验证集上的损失率和准确率
val_loss_single, val_acc_single = self.model.evaluate(x_val, y_val)
val_acc.append(val_acc_single)
val_loss.append(val_loss_single)
plotCurve(acc, val_acc, 'LSTM Accuracy', 'acc')
plotCurve(loss, val_loss, 'LSTM Loss', 'loss')
self.trained = True
'''
predict(): 识别音频的情感
输入:
samples: 需要识别的音频特征
输出:
list: 识别结果
'''
def predict(self, sample):
# 没有训练和加载过模型
if not self.trained:
sys.stderr.write("No Model.")
sys.exit(-1)
return np.argmax(self.model.predict(sample), axis=1)
def make_model(self):
raise NotImplementedError()
print('\ntrain loss: ', loss)
print('\ntrain accuracy: ', accuracy)
from sklearn import metrics
y_pred = model.predict(X_train)
print(y_pred)
fpr, tpr, thresholds = metrics.roc_curve(y_train, y_pred, pos_label=1)
metrics.auc(fpr, tpr)
print('\ntrain AUC: ', metrics.auc(fpr, tpr))
loss, accuracy = model.evaluate(X_test, y_test, batch_size=batch_size)
yaml_string = model.to_yaml()
with open('DNN.yml', 'w') as outfile:
outfile.write(yaml.dump(yaml_string, default_flow_style=True))
model.save_weights('DNN.h5')
print('\ntest loss: ', loss)
print('\ntest accuracy: ', accuracy)
print(y_pred)
from sklearn import metrics
y_pred = model.predict(X_test)
fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred, pos_label=1)
metrics.auc(fpr, tpr)
print('\ntest AUC: ', metrics.auc(fpr, tpr))
plt.title('Receiver Operating Characteristic DNN')
plt.plot(fpr, tpr, 'b', label='AUC = %0.2f' % metrics.auc(fpr, tpr))
class LSTMAutoencoder:
EPOCHS = 100
MIN_EPOCHS = 1
BATCH_SIZE = 64
VALIDATION_SPLIT = 0.05
EWMA_WINDOW_SIZE = 120
EWMA_ALPHA = 1 - np.exp(-np.log(2) / EWMA_WINDOW_SIZE)
def __init__(self,
signals_count: int,
models_dir: str = '',
tensorboard_dir: str = '') -> None:
self._signals_count = signals_count
self._models_dir = models_dir or os.path.join(PROJECT_PATH, 'models')
self._tensorboard_dir = tensorboard_dir
self._model = Sequential([
LSTM(units=64, activation='relu', input_shape=(signals_count, 1)),
RepeatVector(signals_count),
LSTM(units=64, activation='relu', return_sequences=True),
TimeDistributed(Dense(1)),
])
def train(self,
signals_group: SignalsGroup,
clipnorm: float = 0.) -> History:
if len(signals_group.signals_data) != self._signals_count:
raise ValueError(
f'Модель может обработать строго {self._signals_count} сигналов'
)
print(f'Обучение LSTM-автокодировщика для группы сигналов '
f'"{signals_group.name}" {signals_group.signals}...')
x_train = np.column_stack([
self._preprocess(signal)
for signal in signals_group.signals_data.values()
])
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1],
1)) # samples, sample_len, features
optimizer = optimizers.Adam(clipnorm=clipnorm)
self._model.compile(optimizer=optimizer, loss='mse')
callbacks = [
EarlyStopping('val_loss', patience=self.MIN_EPOCHS,
min_delta=0.05),
]
if self._tensorboard_dir:
os.makedirs(os.path.dirname(self._tensorboard_dir), exist_ok=True)
callbacks.append(
TensorBoard(
log_dir=self._get_tensorboard_logs_dir(signals_group.name),
batch_size=self.BATCH_SIZE,
histogram_freq=0,
write_graph=True,
write_grads=True,
write_images=True,
))
history = self._model.fit(
x_train,
x_train,
batch_size=self.BATCH_SIZE,
epochs=self.EPOCHS,
validation_split=self.VALIDATION_SPLIT,
shuffle=True,
callbacks=callbacks,
)
models_path = self._get_model_path(signals_group.name)
os.makedirs(os.path.dirname(models_path), exist_ok=True)
self._model.save_weights(models_path)
print(f'Модель сохранена в "{models_path}"')
return history
def analyze(self, signals_group: SignalsGroup) -> AutoencoderResult:
if len(signals_group.signals) != self._signals_count:
raise ValueError(
f'Модель может обработать строго {self._signals_count} сигналов'
)
model_path = self._get_model_path(signals_group.name)
if not os.path.exists(model_path):
raise FileNotFoundError(
f'Модель для группы сигналов {signals_group.name} не найдена. Выполните обучение'
)
self._model.load_weights(model_path)
data = np.array([
self._preprocess(signal)
for signal in signals_group.signals_data.values()
])
data_stacked = np.column_stack(data)
# samples, sample_len, features
data_reshaped = data_stacked.reshape(data_stacked.shape[0],
data_stacked.shape[1], 1)
decoded_data_reshaped = self._model.predict(data_reshaped,
batch_size=self.BATCH_SIZE)
decoded_data = decoded_data_reshaped.reshape(data_stacked.shape)
decoded_data = np.column_stack(decoded_data)
mse = np.sum([
squared_error(predictions, targets)
for predictions, targets in zip(decoded_data, data)
],
axis=0)
ewma_mse = ewma(mse,
window=self.EWMA_WINDOW_SIZE,
alpha=self.EWMA_ALPHA)
return AutoencoderResult(
signals=data,
decoded_signals=decoded_data,
mse=mse,
ewma_mse=ewma_mse,
)
def plot_model(self,
img_path: str,
show_shapes=True,
show_layer_names=True) -> None:
plot_model(
self._model,
to_file=img_path,
show_shapes=show_shapes,
show_layer_names=show_layer_names,
)
@staticmethod
def _preprocess(data: np.ndarray) -> np.ndarray:
return z_normalization(fill_zeros_with_previous(data))
def _get_model_path(self, group_name: str) -> str:
return os.path.join(self._models_dir, 'autoencoder',
f'{group_name}.h5')
def _get_tensorboard_logs_dir(self, group_name: str) -> str:
return os.path.join(self._tensorboard_dir, 'autoencoder', group_name)
X_test = sequence.pad_sequences(X_test, maxlen = 500)
from keras import Sequential
from keras.layers import Embedding, LSTM, Dense, Dropout, Bidirectional
model = Sequential()
model.add(Embedding(num_words, 32, input_length = 500))
model.add(LSTM(units = 100))
model.add(Dense(1, activation = 'sigmoid'))
model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics=['accuracy'])
model.fit(X_train, y_train, batch_size = 64, epochs = 6)
model_json = model.to_json()
with open("Model_Save/model_json", "w") as json_file:
json_file.write(model_json)
model.save_weights("Model_Save/model.h5")
if __name__ == '__main__':
print(model.summary())
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))
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)
class QReplayDoubleAugmPrior5fan(AbstractModel):
""" Prediction model which uses Q-learning and a neural network which replays past moves.
The network learns by replaying a batch of training moves. The training algorithm ensures that
the game is started from every possible cell. Training ends after a fixed number of games, or
earlier if a stopping criterion is reached (here: a 100% win rate).
:param class Maze game: Maze game object.
"""
def __init__(self, game, **kwargs):
super().__init__(game, **kwargs)
self.game = game
self.state_size = (5 + 2, )
if kwargs.get("load", False) is False:
self.model = Sequential()
self.model.add(
Dense(game.maze.size,
input_shape=self.state_size,
activation="relu"))
self.model.add(Dense(game.maze.size, activation="relu"))
self.model.add(Dense(len(actions)))
else:
self.load(self.name)
self.model.compile(optimizer="adam", loss="mse")
self.target_model = Sequential()
self.target_model.add(
Dense(game.maze.size,
input_shape=self.state_size,
activation="relu"))
self.target_model.add(Dense(game.maze.size, activation="relu"))
self.target_model.add(Dense(len(actions)))
self.target_model.compile(optimizer="adam", loss="mse")
def save(self, filename):
with open(filename + ".json", "w") as outfile:
outfile.write(self.model.to_json())
self.model.save_weights(filename + ".h5", overwrite=True)
def load(self, filename):
with open(filename + ".json", "r") as infile:
self.model = model_from_json(infile.read())
self.model.load_weights(filename + ".h5")
def train(self, stop_at_convergence=False, **kwargs):
""" Hyperparameters:
:keyword float discount: (gamma) preference for future rewards (0 = not at all, 1 = only)
:keyword float exploration_rate: (epsilon) 0 = preference for exploring (0 = not at all, 1 = only)
:keyword float exploration_decay: exploration rate reduction after each random step (<= 1, 1 = no at all)
:keyword int episodes: number of training games to play
:keyword int sample_size: number of samples to replay for training
:return int, datetime: number of training episodes, total time spent
"""
max_memory = kwargs.get("max_memory", 1000)
discount = kwargs.get("discount", 0.90)
exploration_rate = kwargs.get("exploration_rate", 0.10)
exploration_decay = kwargs.get(
"exploration_decay",
0.995) # % reduction per step = 100 - exploration decay
episodes = kwargs.get("episodes", 10000)
batch_size = kwargs.get("sample_size", 32)
experience = ExperienceReplay(self.model,
self.target_model,
discount=discount,
max_memory=max_memory)
self.experience = experience
# variables for reporting purposes
cumulative_reward = 0
cumulative_reward_history = []
win_history = []
start_list = list() # starting cells not yet used for training
start_time = datetime.now()
for episode in range(1, episodes + 1):
if not start_list:
start_list = self.environment.empty.copy()
start_cell = random.choice(start_list)
start_list.remove(start_cell)
state = self.environment.reset(start_cell)
actions_counter = 0
loss = 0.0
self.game.old_action = (0, 0)
while True:
if np.random.random() < exploration_rate:
c_state = state[0][0]
r_state = state[0][1]
c_target, r_target = self.environment.exit
delta_r = r_target - r_state
delta_c = c_target - c_state
delta = np.abs(delta_r) + np.abs(delta_c)
delta_r_percent = np.abs(delta_r) / delta * 100
delta_c_percent = np.abs(delta_c) / delta * 100
move = tuple(np.sign([delta_c, delta_r]))
actions_list = self.environment.actions.copy()
actions_list.remove(move)
if np.sum(np.abs(move)) == len(move): #diagonal movement
move_c = (move[0], 0)
move_r = (0, move[1])
actions_list.remove(move_c)
actions_list.remove(move_r)
if np.abs(delta_r - delta_c) < 20:
action_d_pool = [move] * 20
action_r_pool = [move_r] * 15
action_c_pool = [move_c] * 15
actions_pool = np.concatenate(
(action_d_pool, action_c_pool, action_r_pool))
for i in range(len(actions_list)):
actions_pool = np.concatenate(
(actions_pool, [actions_list[i]] * 9))
else:
action_d_pool = [move] * 10
action_r_pool = [move_r] * int(
np.round(delta_r_percent * 35))
action_c_pool = [move_c] * int(
np.round(delta_c_percent * 35))
actions_pool = np.concatenate(
(action_d_pool, action_c_pool, action_r_pool))
for i in range(len(actions_list)):
actions_pool = np.concatenate(
(actions_pool, [actions_list[i]] * 9))
else:
action_move_pool = [move] * 25
actions_pool = action_move_pool
for i in range(len(actions_list)):
actions_pool = np.concatenate(
(actions_pool, [actions_list[i]] * 11))
action = tuple(random.choice(actions_pool))
#action = random.choice(self.environment.actions)
action_index = [actions[action][1]]
else:
# q = experience.predict(state)
# action = random.choice(np.nonzero(q == np.max(q))[0])
action, action_index = self.predict(state)
next_state, reward, status = self.environment.step(action)
state_augm = self.state_creator(state)
next_state_augm = self.state_creator(next_state)
cumulative_reward += reward
experience.remember(state_augm, action_index, reward,
next_state_augm, status)
if status in ("win",
"lose"): # terminal state reached, stop episode
break
if experience.buffer.size() > 2 * batch_size:
inputs, targets = experience.get_samples(
sample_size=batch_size)
self.model.fit(inputs,
targets,
epochs=1,
batch_size=16,
verbose=0)
if actions_counter % 10 == 0:
experience.target_train()
actions_counter += 1
loss += self.model.evaluate(inputs, targets, verbose=0)
state = next_state
self.environment.render_q(self)
cumulative_reward_history.append(cumulative_reward)
logging.info(
"episode: {:d}/{:d} | status: {:4s} | loss: {:.4f} | e: {:.5f}"
.format(episode, episodes, status, loss, exploration_rate))
if episode % 500 == -1:
# check if the current model wins from all starting cells
# can only do this if there is a finite number of starting states
w_all, win_rate = self.environment.win_all(self)
win_history.append((episode, win_rate))
if w_all is True and stop_at_convergence is True:
logging.info("won from all start cells, stop learning")
break
exploration_rate *= exploration_decay # explore less as training progresses
self.save(self.name) # Save trained models weights and architecture
now = datetime.now()
time_elapsed = now - start_time
self.time = now.timestamp() - start_time.timestamp()
logging.info("episodes: {:d} | time spent: {}".format(
episode, time_elapsed))
return cumulative_reward_history, win_history, episode, datetime.now(
) - start_time
def q(self, state):
""" Get q values for all actions for a certain state. """
state = self.state_creator(state)
return self.model.predict(state)[0]
def predict(self, state):
""" Policy: choose the action with the highest value from the Q-table.
Random choice if multiple actions have the same (max) value.
:param np.ndarray state: Game state.
:return int: Chosen action.
"""
q = self.q(state)
logging.debug("q[] = {}".format(q))
actions_index = np.nonzero(
q == np.max(q))[0] # get index of the action(s) with the max value
return self.environment.actions[random.choice(
actions_index)], actions_index
def state_creator(self, state):
state_augm = np.zeros((1, self.state_size[0]))
cols = state[0][0]
rows = state[0][1]
flags = dict()
obst = dict()
delta_x = self.game.exit_cell[0] - cols
delta_y = self.game.exit_cell[1] - rows
rays = list(actions.keys())
move = tuple(np.sign((-delta_x, -delta_y))) #move to remove (1 of 3)
if (cols, rows) not in [self.game.exit_cell]:
if np.sum(np.abs(move)) == 2:
move_l = (move[0], 0)
move_r = (0, move[0])
elif np.sum(np.abs(move)) == 1:
if move[0] == 0:
move_l = (-1, move[1])
move_r = (1, move[1])
if move[1] == 0:
move_l = (move[0], -1)
move_r = (move[0], 1)
rays.remove(move)
rays.remove(move_l)
rays.remove(move_r)
for action in rays:
for i_dist in range(1, self.game.maze.shape[0] + 1):
cell = (cols + i_dist * action[0],
rows + i_dist * action[1])
if flags.get(action, 0) == 0 and (
cell in self.game.walls or
(cell in self.game.cells
and self.game.maze[cell[::-1]] == 1)):
obst[action] = i_dist - 1
flags[action] = 1
target_delta_col = self.game.exit_cell[0] - cols
target_delta_row = self.game.exit_cell[1] - rows
state_augm = np.array([[
*tuple(obst.values()) + (target_delta_col, target_delta_row)
]])
else:
state_augm = np.array([[*(0, 0, 0, 0, 0, 0, 0)]])
return state_augm
class QReplayNetworkModel(AbstractModel):
""" Prediction model which uses Q-learning and a neural network which replays past experiences.
The network learns by replaying a batches of training games. The training algorithm ensures that
the game is started from every possible cell. Training ends after a fixed number of games, or
earlier if a stopping criterion is reached (here: a 100% win rate).
:param class Maze game: Maze game object.
"""
def __init__(self, game, **kwargs):
super().__init__(game, **kwargs)
if kwargs.get("load", False) is False:
self.model = Sequential()
self.model.add(
Dense(game.maze.size,
input_shape=(game.maze.size, ),
activation="relu"))
self.model.add(Dense(game.maze.size, activation="relu"))
self.model.add(Dense(len(actions), activation="linear"))
else:
self.load(self.name)
self.model.compile(optimizer="adam", loss="mse")
def save(self, filename):
with open(filename + ".json", "w") as outfile:
outfile.write(self.model.to_json())
self.model.save_weights(filename + ".h5", overwrite=True)
def load(self, filename):
with open(filename + ".json", "r") as infile:
self.model = model_from_json(infile.read())
self.model.load_weights(filename + ".h5")
def train(self, **kwargs):
""" Hyperparameters:
:keyword float discount: (gamma) preference for future rewards (0 = not at all, 1 = only)
:keyword float exploration_rate: (epsilon) 0 = preference for exploring (0 = not at all, 1 = only)
:keyword int episodes: number of training games to play
:keyword int sample_size: number of samples to replay for training
:return int, datetime: number of training episodes, total time spent
"""
discount = kwargs.get("discount", 0.90)
exploration_rate = kwargs.get("exploration_rate", 0.10)
episodes = kwargs.get("episodes", 10000)
sample_size = kwargs.get("sample_size", 32)
experience = ExperienceReplay(self.model, discount=discount)
wins = 0
hist = []
start_list = list() # starting cells not yet used for training
start_time = datetime.now()
for episode in range(1, episodes):
if not start_list:
start_list = self.environment.empty.copy()
start_cell = random.choice(start_list)
start_list.remove(start_cell)
state = self.environment.reset(start_cell)
loss = 0.0
while True:
if np.random.random() < exploration_rate:
action = random.choice(self.environment.actions)
else:
q = experience.predict(state)
mv = np.amax(q)
actions = np.nonzero(q == mv)[0]
action = random.choice(actions)
next_state, reward, status = self.environment.step(action)
experience.remember(
[state, action, reward, next_state, status])
if status in ("win",
"lose"): # terminal state reached, stop episode
if status == "win":
wins += 1
break
inputs, targets = experience.get_samples(
sample_size=sample_size)
self.model.fit(inputs,
targets,
epochs=4,
batch_size=16,
verbose=0)
loss += self.model.evaluate(inputs, targets, verbose=0)
state = next_state
logging.info(
"episode: {:d}/{:d} | status: {:4s} | loss: {:.4f} | total wins: {:d} | e: {:.5f}"
.format(episode, episodes, status, loss, wins,
exploration_rate))
if episode % 5 == 0:
# check if the current model wins from all starting cells
# can only do this if there is a finite number of starting states
w_all, win_rate = self.environment.win_all(self)
hist.append(win_rate)
if w_all is True:
logging.info("won from all start cells, stop learning")
break
self.save(self.name) # Save trained models weights and architecture
logging.info("episodes: {:d} | time spent: {}".format(
episode,
datetime.now() - start_time))
return hist, episode, datetime.now() - start_time
def predict(self, state):
""" Policy: choose the action with the highest Q from the Q-table. Random choice if there are multiple actions
with an equal max Q.
:param np.array state: Game state.
:return int: Chosen action.
"""
q = self.model.predict(state)
mv = np.amax(q[0]) # determine max Q
actions = np.nonzero(
q[0] == mv)[0] # extract (index of) action(s) with the max Q
return random.choice(actions)
class Agent:
def __init__(self, color, eps, df, alpha):
self.color = color
self.eps = eps
self.discount_factor = df
self.alpha = alpha
self.state_value = {}
self.game_states = []
self.nnInp = set()
self.rating = 1600
self.nnModel = 0
self.initNNModel()
def initNNModel(self):
if not os.path.isfile("nn_%s_weights.h5" % (str(self.color))):
print("Creating h5 Weight File.")
self.nnModel = Sequential()
self.nnModel.add(Dense(32, activation="tanh", input_dim=42))
self.nnModel.add(Dense(32, activation="tanh"))
self.nnModel.add(Dense(7, activation="sigmoid"))
self.nnModel.save_weights("nn_%s_weights.h5" % (str(self.color)))
def train(self):
print("Start Training for Model %s." % (str(self.color)))
X, Y = self.getNNInput()
print("Shape for input and labels:", X.shape, Y.shape)
self.nnModel.load_weights("nn_%s_weights.h5" % (str(self.color)))
sgd = optimizers.SGD(lr=0.5, clipnorm=1.)
self.nnModel.compile(loss="mse", optimizer=sgd, metrics=["accuracy"])
self.nnModel.fit(X, Y, epochs=100)
self.nnModel.save_weights("nn_%s_weights.h5" % (str(self.color)))
print("Training complete....Model For %s Saved" % (str(self.color)))
def getBestMoveNN(self, board):
inp = []
inp.append(self.serialize(self.getHash(board.board)))
wm = board.checkForWinningMove(self.color)
if wm > -1:
return wm
self.nnModel.load_weights("nn_%s_weights.h5" % (str(self.color)))
m = self.nnModel.predict(np.array(inp))
# print(m)
for i in range(7):
if board.cols[i] == -1:
m[0][i] = 0
res = np.where(m[0] == max(m[0]))
return res[0][rd.randint(0, len(res) - 1)]
def getBoardFromHash(self, h):
board = np.zeros((6, 7))
k = 0
hToNum = {"_": 0, "R": 2, "Y": 1}
for i in range(6):
for j in range(7):
board[i][j] = hToNum[h[k]]
k += 1
return board
def setEpsilon(self, eps):
self.eps = eps
def serialize(self, state):
arr = []
hToNum = {"_": 0, "R": 2, "Y": 1}
for i in state:
arr.append(hToNum[i])
return arr
def getNNInput(self):
labels = []
inp = []
for i in self.nnInp:
arr = self.serialize(i)
inp.append(arr)
board = self.getBoardFromHash(i)
labels.append(self.getNextStateVals(board))
return np.array(inp), np.array(labels)
def calculateExpectedScore(self, oppRating):
return 1 / (1 + (10**((oppRating - self.rating) / 400)))
def calculateRating(self, oppRating, res):
self.rating = self.rating + (
16 * (res - self.calculateExpectedScore(oppRating)))
def getMaxFromRes(self, boardHash):
return max(
self.nnModel.predict(np.array([self.serialize(boardHash)]))[0])
def getReward(self, reward):
tot_reward = reward
for i in range(len(self.game_states) - 1, -1, -1):
if self.state_value.get(self.game_states[i]) is None:
self.state_value[self.game_states[i]] = 0.5
if i == len(self.game_states) - 1:
self.state_value[self.game_states[i]] = tot_reward
continue
self.state_value[self.game_states[i]] += (
(self.alpha *
(tot_reward - self.state_value[self.game_states[i]])) *
self.discount_factor)
tot_reward = self.state_value[self.game_states[i]]
def resetState(self):
self.game_states = []
def decayEps(self, dec):
self.eps = self.eps * dec
def getRandomMove(self, board):
while True:
colR = rd.randint(0, 6)
if board.cols[colR] == -1:
continue
return colR
def getBestMove(self, board):
maxv = -1
moves = []
for i in range(7):
if board.cols[i] != -1:
bcopy = board.board.copy()
bcopy[board.cols[i]][i] = self.color
if board.checkWinVirtual(bcopy, board.cols[i], i):
return i
h = self.getHash(bcopy)
if self.state_value.get(h):
val = self.state_value[h]
if val > maxv:
maxv = val
moves = []
moves.append(i)
elif val == maxv:
moves.append(i)
else:
val = 0.5
if val > maxv:
maxv = val
moves = []
moves.append(i)
elif val == maxv:
moves.append(i)
if len(moves) == 1:
return moves[0]
else:
return moves[rd.randint(0, len(moves) - 1)]
def getNextStateVals(self, board):
vals = [0, 0, 0, 0, 0, 0, 0]
max_ = -10000
max_ind = []
for i in range(7):
if board[0][i] == 0:
bcopy = board.copy()
k = 5
while True:
if bcopy[k][i] == 0:
break
k = k - 1
bcopy[k][i] = self.color
b = c4Board()
if b.checkWinVirtual(bcopy, k, i):
vals[i] = 1
return vals
h = self.getHash(bcopy)
if self.state_value.get(h):
val = self.state_value[h]
if max_ < val:
max_ = val
max_ind = [i]
elif max_ == val:
max_ind.append(i)
else:
val = 0.5
if max_ < val:
max_ = val
max_ind = [i]
elif max_ == val:
max_ind.append(i)
if len(max_ind) == 1:
vals[max_ind[0]] = 1
else:
vals[max_ind[rd.randint(0, len(max_ind) - 1)]] = 1
return vals
def getHash(self, board): #get hash of current board
h = ""
nToHash = {0: "_", 2: "R", 1: "Y"}
for i in range(6):
for j in range(7):
h = h + nToHash[board[i][j]]
return h
class DNN_Model(Common_Model):
'''
input:
input_shape
num_classes(int)
'''
def __init__(self, input_shape, num_classes, **params):
super(DNN_Model, self).__init__(**params)
self.input_shape = input_shape
self.model = Sequential()
self.make_model()
self.model.add(Dense(num_classes, activation='softmax'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print(self.model.summary(), file=sys.stderr)
'''
save_model(): save as h5 and json
'''
def save_model(self, model_name):
h5_save_path = 'Models/' + model_name + '.h5'
self.model.save_weights(h5_save_path)
save_json_path = 'Models/' + model_name + '.json'
with open(save_json_path, "w") as json_file:
json_file.write(self.model.to_json())
def train(self, x_train, y_train, x_val=None, y_val=None, n_epochs=50):
acc = []
loss = []
val_acc = []
val_loss = []
if x_val is None or y_val is None:
x_val, y_val = x_train, y_train
for i in range(n_epochs):
p = np.random.permutation(len(x_train))
x_train = x_train[p]
y_train = y_train[p]
history = self.model.fit(x_train, y_train, batch_size=32, epochs=1)
acc.append(history.history['acc'])
loss.append(history.history['loss'])
val_loss_single, val_acc_single = self.model.evaluate(x_val, y_val)
val_acc.append(val_acc_single)
val_loss.append(val_loss_single)
plotCurve(acc, val_acc, 'LSTM Accuracy', 'acc')
plotCurve(loss, val_loss, 'LSTM Loss', 'loss')
self.trained = True
def predict(self, sample):
if not self.trained:
sys.stderr.write("No Model.")
sys.exit(-1)
return np.argmax(self.model.predict(sample), axis=1)
def make_model(self):
raise NotImplementedError()
class LSTM_NER():
def __init__(self):
self.MAX_SEQUENCE_LENGTH = 2000
self.EMBEDDING_DIM = 300
self.MAX_NB_WORDS = 20000
pass
def build_tensor(self,
sequences,
numrecs,
word2index,
maxlen,
makecategorical=False,
num_classes=0,
is_label=False):
data = np.empty((numrecs, ), dtype=list)
label_index = {'O': 0}
label_set = [
"B-geo", "B-gpe", "B-per", "I-geo", "B-org", "I-org", "B-tim",
"B-art", "I-art", "I-per", "I-gpe", "I-tim", "B-nat", "B-eve",
"I-eve", "I-nat"
]
for lbl in label_set:
label_index[lbl] = len(label_index)
lb = LabelBinarizer()
lb.fit(list(label_index.values()))
i = 0
plabels = []
for sent in tqdm.tqdm(sequences, desc='Building tensor'):
wids = []
pl = []
for word, label in sent:
if is_label == False:
# wids.append(word2index[word])
if word in word2index:
wids.append(word2index[word])
# print(word2index[word])
else:
wids.append(word2index['the'])
else:
pl.append(label_index[label])
plabels.append(pl)
if not is_label:
data[i] = wids
#print(data[i])
i += 1
# if makecategorical and is_label:
# pdata = sequence.pa100d_sequences(data,maxlen=maxlen)
# return pdata
if is_label:
plabels = sequence.pad_sequences(plabels, maxlen=maxlen)
print(plabels.shape)
pdata = np.array([lb.transform(l) for l in plabels])
else:
pdata = sequence.pad_sequences(data, maxlen=maxlen)
return pdata
#return data
def createModel(self, text):
self.embeddings_index = {}
f = open(os.path.join(GLOVE_DIR, 'glove.6B.300d.txt'))
for line in f:
values = line.split()
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
self.embeddings_index[word] = coefs
f.close()
print('Found %s word vectors.' % len(self.embeddings_index))
tokenizer = Tokenizer(num_words=self.MAX_NB_WORDS, lower=False)
tokenizer.fit_on_texts(text)
#sequences = tokenizer.texts_to_sequences(text)
self.word_index = tokenizer.word_index
self.embedding_matrix = np.zeros(
(len(self.word_index) + 1, self.EMBEDDING_DIM))
print(self.embedding_matrix.shape)
for word, i in self.word_index.items():
embedding_vector = self.embeddings_index.get(word)
if embedding_vector is not None:
# words not found in embedding index will be all-zeros.
self.embedding_matrix[i] = embedding_vector
#print(word_index)
self.embedding_layer = Embedding(len(self.word_index) + 1,
self.EMBEDDING_DIM,
weights=[self.embedding_matrix],
input_length=70,
trainable=False)
self.model = Sequential()
self.model.add(self.embedding_layer)
self.model.add(
Bidirectional(
LSTM(500,
dropout=0.2,
recurrent_dropout=0.4,
return_sequences=True))
) #{'sum', 'mul', 'concat', 'ave', None}
# self.model.add(TimeDistributed(Bidirectional(LSTM(60, dropout=0.2, recurrent_dropout=0.5, return_sequences=True))))
#self.model.add(TimeDistributed(Dense(50, activation='relu')))
self.model.add(TimeDistributed(Dense(
17,
activation='softmax'))) # a dense layer as suggested by neuralNer
#crf = CRF(17, sparse_target=True)
#self.model.add(crf)
#self.model.compile(loss=crf_loss, optimizer='adam', metrics=[crf_viterbi_accuracy])
self.model.compile(loss="categorical_crossentropy",
optimizer='rmsprop',
metrics=['accuracy'])
self.model.summary()
pass
def load_GLoVe_embeddings(self, GLOVE_DIR, text):
pass
def train(self):
self.model.fit(self.X_train,
self.Y_train,
epochs=1,
validation_split=0.1,
batch_size=16)
pass
def test_model(self):
Y_pred = self.model.predict(self.X_test)
print(Y_pred)
from sklearn import metrics
Y_testing = []
labels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
for i in range(0, len(self.Y_test)):
for j in range(0, len(self.Y_test[i])):
for k in range(0, len(self.Y_test[i][j])):
if self.Y_test[i][j][k] == 1:
Y_testing.append(k)
Y_pred_F = []
for i in range(0, len(Y_pred)):
for j in range(0, len(Y_pred[i])):
max_k = 0
max_k_val = 0
for k in range(0, len(Y_pred[i][j])):
if Y_pred[i][j][k] > max_k_val:
max_k_val = Y_pred[i][j][k]
max_k = k
Y_pred_F.append(max_k)
Y_test_F = []
for i in range(0, len(self.Y_test)):
for j in range(0, len(self.Y_test[i])):
max_k = 0
max_k_val = 0
for k in range(0, len(self.Y_test[i][j])):
if self.Y_test[i][j][k] > max_k_val:
max_k_val = self.Y_test[i][j][k]
max_k = k
Y_test_F.append(max_k)
print(metrics.classification_report(Y_test_F, Y_pred_F, labels))
def save_mode(self):
self.model.save_weights("../Models/" + "model.h5")
model_json = self.model.to_json()
with open("../Models/" + "model.json", "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
self.model.save_weights("../Models/" + "model.h5")
print("Saved model to disk")
pass
def fitting(self):
dim_row = self.lags # tiempo
dim_col = 1 # features or chanels (Volume)
output_dim = 3 # 3 for categorical
#data = np.random.random((1000, dim_row, dim_col))
#clas = np.random.randint(3, size=(1000, 1))
##print(clas)
#clas = to_categorical(clas)
##print(clas)
data = self.X_train
data_test = self.X_test
data = data.values.reshape(-1, dim_row, dim_col)
data_test = data_test.values.reshape(-1, dim_row, dim_col)
clas = self.y_train
clas_test = self.y_test
clas = to_categorical(clas)
clas_test = to_categorical(clas_test)
cat0 = self.y_train.tolist().count(0)
cat1 = self.y_train.tolist().count(1)
cat2 = self.y_train.tolist().count(2)
print("may: ", cat1, " ", "menor: ", cat2, " ", "neutro: ", cat0)
n_samples_0 = cat0
n_samples_1 = (cat1 + cat2)/2.0
n_samples_2 = (cat1 + cat2)/2.0
class_weight={
0: 1.0/n_samples_0,
1: 1.0/n_samples_1,
2: 1.0/n_samples_2}
def class_1_accuracy(y_true, y_pred):
# cojido de: http://www.deepideas.net/unbalanced-classes-machine-learning/
class_id_true = K.argmax(y_true, axis=-1)
class_id_preds = K.argmax(y_pred, axis=-1)
accuracy_mask = K.cast(K.equal(class_id_preds, 1), 'int32')
class_acc_tensor = K.cast(K.equal(class_id_true, class_id_preds), 'int32') * accuracy_mask
class_acc = K.sum(class_acc_tensor) / K.maximum(K.sum(accuracy_mask), 1)
return class_acc
#################################################################################################################
model = Sequential()
# model.add(Reshape(input_shape=(dim_row, dim_col), target_shape=(dim_row, dim_col, 1)))
if self.nConv > 0:
#model.add(Reshape((dim_row, dim_col, 1)))
model.add(Reshape(input_shape=(dim_row, dim_col), target_shape=(dim_row, dim_col, 1)))
for i in range(self.nConv):
model.add(Convolution2D(self.conv_nodes, kernel_size = (self.kernel_size, 1), padding = 'same', kernel_regularizer = regularizers.l2(0.01)))
model.add(Activation('relu'))
model.add(Reshape(target_shape=(dim_row, self.conv_nodes * dim_col)))
# Como nuestro output tiene una sola dimension no es necesario "return_sequences='True'"
# y tampoco es necesario usar TimeDistributed
if self.nConv == 0:
model.add(LSTM(units=self.lstm_nodes, return_sequences='True', activation='tanh', input_shape=(dim_row, dim_col)))
for i in range(self.nLSTM - 1):
model.add(LSTM(units=self.lstm_nodes, return_sequences='True', activation='tanh'))
model.add(Dropout(0.5))
model.add(TimeDistributed(Dense(units = output_dim))) # the dimension of index one will be considered to be the temporal dimension
model.add(Activation('softmax')) # for loss = 'categorical_crossentropy'
#model.add(Activation('sigmoid')) # for loss = 'binary_crossentropy'
# haciendo x: x[:, -1, :], la segunda dimension desaparece quedando solo
# los ULTIMOS elementos (-1) de dicha dimension:
# Try this to see:
# data = np.random.random((5, 3, 4))
# print(data)
# print(data[:, -1, :])
model.add(Lambda(lambda x: x[:, -1, :], output_shape = [output_dim]))
print(model.summary())
tensorboard_active = True
callbacks = []
if tensorboard_active:
callbacks.append(TensorBoard(
log_dir=self.putmodel + "Tensor_board_data",
histogram_freq=0,
write_graph=True,
write_images=True))
#model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = ['categorical_accuracy'])
#model.compile(loss = 'binary_crossentropy', optimizer=Adam(lr=self.learning), metrics = ['categorical_accuracy'])
model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy])
# tensorboard = TensorBoard(log_dir=self.putmodel + "Tensor_board_data",
# write_graph=True, write_images=True, histogram_freq=1)
#tensorboard = TensorBoard(log_dir="/Users/yoelvisorozco/Library/Mobile Documents/com~apple~CloudDocs/TestTF/yoe",
# write_graph=True, write_images=True, histogram_freq=0)
model.fit(x=data,
y=clas,
batch_size=self.batch_size, epochs=10, verbose=1,
callbacks = callbacks,
class_weight = class_weight)
# callbacks=[tensorboard])
#####################################################################################################################
# serialize model to YAML
model_yaml = model.to_yaml()
with open("model.yaml", "w") as yaml_file:
yaml_file.write(model_yaml)
# serialize weights to HDF5
model.save_weights("model.h5")
print("Saved model to disk")
# load YAML and create model
yaml_file = open('model.yaml', 'r')
loaded_model_yaml = yaml_file.read()
yaml_file.close()
loaded_model = model_from_yaml(loaded_model_yaml)
# load weights into new model
loaded_model.load_weights("model.h5")
print("Loaded model from disk")
loaded_model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy])
y_pred = loaded_model.predict_proba(data_test)
loaded_model.reset_states()
score_train = model.evaluate(data, clas)
model.reset_states()
score_train_loaded = loaded_model.evaluate(data, clas)
loaded_model.reset_states()
score_test = model.evaluate(data_test, clas_test)
model.reset_states()
score_test_loaded = loaded_model.evaluate(data_test, clas_test)
loaded_model.reset_states()
pred_T = 0
pred_F = 0
for i in range(len(y_pred)):
if np.argmax(y_pred[i]) == 1 and self.y_test[i] == 1:
pred_T += 1
# print(y_pred[i])
if np.argmax(y_pred[i]) == 1 and self.y_test[i] == 0:
pred_F += 1
if pred_T + pred_F > 0:
Pr_pos = pred_T/(pred_T + pred_F)
print("Yoe Probabilidad pos: ", Pr_pos)
else:
print("Yoe Probabilidad pos: 0")
history = DataFrame([[self.skip, self.nConv, self.nLSTM,
self.learning, self.batch_size,
self.conv_nodes, self.lstm_nodes,
score_train[0], score_train[1],
score_test[0], score_test[1]]], columns = ('Skip', 'cConv', 'nLSTM', 'learning',
'batch_size', 'conv_nodes', 'lstm_nodes',
'loss_train', 'acc_train', 'loss_test', 'acc_test'))
self.history = self.history.append(history)
# self.print_to_disk(self.putmodel + "Tune.txt",
# "Skip_" + str(self.skip) +
# " cConv_" + str(self.nConv) +
# " nLSTM_" + str(self.nLSTM) +
# " learning_" + str(self.learning) +
# " batch_size_" + str(self.batch_size) +
# " conv_nodes_" + str(self.conv_nodes) +
# " lstm_nodes_" + str(self.lstm_nodes) +
# " --> loss_train: " + str(score_train[0]) + " acc_train: " + str(score_train[1]) +
# " loss_test: " + str(score_test[0]) + " acc_test: " + str(score_test[1]) + "\n")
print('Train loss:', score_train[0])
print('Train accuracy:', score_train[1])
print('Train loss loaded:', score_train_loaded[0])
print('Train accuracy loaded:', score_train_loaded[1])
print('Test loss:', score_test[0])
print('Test accuracy:', score_test[1])
print('Test loss loaded:', score_test_loaded[0])
print('Test accuracy loaded:', score_test_loaded[1])
def NewModel():
#Array of classes
#(0,1,2,3,4,5,6,7,8,9,10)
Y_labels = []
#random seed
#collect data
#load into python
#pre-process
#names -> dictionary
#value -> numbers
# Pre processing done in GetDeck
#X_train = X_train[:250]
print(X_train.shape)
#print(X_train)
#match decks to their training data speed e.g.house party - 5 speed
#matched via dictionary labels
#pad dataset (should be fine since all 60 cards
#each add adds a layer (just doing Dense because it's like my brain haha)
#X_trainShape = numpy.reshape(X_train,(60,8))
print('done')
kfold = KFold(n_splits=num_folds, shuffle=True)
fold_no = 1
for train, test in kfold.split(X_train,Y_train):
model = Sequential()
model.add(Dense(300,input_dim=(60*522),name="Input_Layer",activation="sigmoid"))
model.add(Dense(250,name="Hidden"))
model.add(Dense(180,name="Hidden2"))
model.add(Dense(100,name="Hidden3", activity_regularizer=regularizers.l1(0.001)))
model.add(Dense(2,name="Output",activation="softmax"))
model.summary()
#to_cat serialises classification ( e.g. "on" values)
#sequential model
print('starting stuff')
#model.add function
#train_test_split to do training sets test/train ratio of 10-20/80-90
print(X_train.shape)
model.compile(loss="categorical_crossentropy",optimizer="adam",metrics=["accuracy"])
model.fit(X_train[train],Y_train[train],epochs=100,batch_size=150,verbose=2)
scores = model.evaluate(X_train[test],Y_train[test],batch_size=150,verbose=0)
print("Accuracy: %.2f%%" % scores[1]*100,flush=True)
fold_no = fold_no + 1
models.append(model)
mScores.append(scores[1])
#model.compile
#loss e.g. rms
#optimiser
#metrics
#model.fit (verbose = 2) for less warnings
bestIndex = 0
currIndex = 0
for s in mScores:
if mScores[currIndex] > mScores[bestIndex]:
bestIndex = currIndex
currIndex += 1
model = models[bestIndex]
model.fit(X_train,Y_train,epochs=50,batch_size=128,verbose=2)
scores = model.evaluate(X_train,Y_train,batch_size=128,verbose=0)
print("Accuracy: %.2f%%" % scores[1]*100,flush=True)
#eval model
#model.evaluate
#xtest, ytest, batch size, verbose 2
#print them out
print(mScores)
print(mScores[bestIndex])
print(scores[1])
#save model somewhere model = JSON h5 = weights
model_json = model.to_json()
with open("model.json",'w') as json_file:
json_file.write(model_json)
model.save_weights('model.h5')
print('SAVED MODEL')
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))
# evaluating our model on the test sets
score, acc = model.evaluate(x_test, y_test, batch_size=batch_size)
print('Test score:', score)
print('Test accuracy:', acc)
# serialize model to JSON
model_json = model.to_json()
with open("one_kernel_CNN_LSTM_model.json", "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("one_kernel_CNN_LSTM_weights.h5")
print("Saved model to disk")
# creating the prediction on test set csv file
keras_prediction(
model_path="one_kernel_CNN_LSTM_model.json",
weights_path="one_kernel_CNN_LSTM_weights.h5",
ids_test_path="../../data/our_trained_wordvectors/ids_test_sg_6.npy",
csv_file_name="one_kernel_cnn_lstm_prediction.csv")
# From here, we save our metrics results for the comparison with plots
val_acc_epochs = history.epocs_val_acc
np.save("val_acc_one_kernel_CNN_LSTM.npy", val_acc_epochs)
val_loss_epochs = history.epocs_val_loss
np.save("val_loss_one_kernel_CNN_LSTM.npy", val_loss_epochs)
class ANN96_1:
# global constant
xcols = 6 # last_week_t, last_week_t-1, yesterday_t, yesterday_t-1
norm1 = [0, 1, 2, 3] # list of load normalization
def __init__(self): # construction function
# build model
self.model = Sequential()
self.model.add(
Dense(8, input_shape=(ANN96_1.xcols, ), activation='relu'))
self.model.add(Dense(1, activation=None))
self.model.summary()
# loss = mean squared error
sgd = optimizers.SGD(lr=0.05)
self.model.compile(optimizer=sgd, loss='mse', metrics=['mse'])
# load data
self.load = np.load('load.npy')
# and is_weekend_one_hot (1:weekday, 0:weekend) for yesterday, today
self.loadmax = self.load.max() # max load ever
load0 = self.load[self.load > 0] # delete the 0s
self.loadmin = load0.min() # min load ever (not 0)
self.nepoch = 100 # default training epochs
# def ANNmodel(self): # ANN model structure for all 96 classifiers
# # 2 layers dense network
# self.model = Sequential()
# self.model.add(Dense(8, input_shape=(ANN96.xcols,), activation='relu'))
# self.model.add(Dense(1, activation=None))
# self.model.summary()
# # loss = mean squared error
# sgd = optimizers.SGD(lr=0.5)
# self.model.compile(optimizer=sgd, loss='mse', metrics=['mse'])
def setEpochs(self, Nepoch): # set training epochs
self.nepoch = Nepoch
# def load_data(self):
# self.load = np.load('load.npy')
# # and is_weekend_one_hot (1:weekday, 0:weekend) for yesterday, today
# self.loadmax = self.load.max() # max load ever
# load0 = self.load[self.load>0] # delete the 0s
# self.loadmin = load0.min() # min load ever (not 0)
def train(self, n): # use 0~n-1 date for training
start_time = time.time()
for j in range(96):
x = np.zeros((1, ANN96_1.xcols), dtype=np.float) # train data
y = list() # train label
index = list(
) # original date index, for Mon/Tues recognition in sample_weight
if j == 0:
# prepare data
for i in range(8, n - 1):
xt = np.zeros((1, ANN96_1.xcols), dtype=np.float)
if self.load[i-7, j]!=0 and self.load[i-8, 95]!=0 and \
self.load[i-1, j]!=0 and self.load[i-2, 95]!=0 \
and self.load[i, j]!=0:
xt[0, 0] = self.load[i - 7, j]
xt[0, 1] = self.load[i - 8, 95]
xt[0, 2] = self.load[i - 1, j]
xt[0, 3] = self.load[i - 2, 95]
if (i - 1) % 7 == 3 or (i - 1) % 7 == 4:
xt[0, 4] = 0
else:
xt[0, 4] = 1
if i % 7 == 3 or i % 5 == 4:
xt[0, 5] = 0
else:
xt[0, 5] = 1
if x[0, 0] == 0:
x = xt
else:
x = np.concatenate((x, xt), axis=0)
y.append(self.load[i, j])
index.append(i)
else:
for i in range(7, n - 1):
xt = np.zeros((1, ANN96_1.xcols),
dtype=np.float) # temporary variable
if self.load[i-7, j]!=0 and self.load[i-7, j-1]!=0 \
and self.load[i-1, j]!=0 and self.load[i-1, j-1]!=0 \
and self.load[i, j]!=0:
xt[0, 0] = self.load[i - 7, j]
xt[0, 1] = self.load[i - 7, j - 1]
xt[0, 2] = self.load[i - 1, j]
xt[0, 3] = self.load[i - 1, j - 1]
if (i - 1) % 7 == 3 or (i - 1) % 7 == 4:
xt[0, 4] = 0
else:
xt[0, 4] = 1
if i % 7 == 3 or i % 5 == 4:
xt[0, 5] = 0
else:
xt[0, 5] = 1
if x[0, 0] == 0:
x = xt
else:
x = np.concatenate((x, xt), axis=0)
y.append(self.load[i, j])
index.append(i)
# training
# normalization
nsample = x.shape[0] # number of training samples
for i in range(nsample):
for k in ANN96_1.norm1:
x[i, k] = (x[i, k] - self.loadmin)\
/ (self.loadmax - self.loadmin)
y = (y - self.loadmin) / (self.loadmax - self.loadmin)
# sample weight:
# 1. the closer the date, the larger the weight in loss function
# 2. the weight of Monday and Tuesday (days to be predicted) sample is amplified
sw = np.zeros((nsample, ))
for i in range(nsample):
sw[i] = 0.998**(nsample - i)
if index[i] % 7 == 5 or index[i] % 7 == 6: # Mon or Tues
sw[i] = sw[i] * 2
elif index[i] % 7 == 3 or index[i] % 7 == 4: # delete weekend
sw[i] = 0
# train
if j == 0: # j=0, nepoch *= 10
history = self.model.fit\
(x, y, batch_size=32, epochs=10*self.nepoch, \
sample_weight=sw, verbose=0)
else:
history = self.model.fit\
(x, y, batch_size=32, epochs=self.nepoch,sample_weight=sw, verbose=1)
# verbose=0, not to show training details
# save model
self.model.save_weights(
os.path.join('new_weights', str(j)) + '.h5')
# evaluate model by mse
mse = history.history['mean_squared_error']
last_mse = mse[len(mse) - 1]
print(str(j) + '/96: ' + str(last_mse))
end_time = time.time()
use_time = np.ceil((end_time - start_time) / 60)
print(str(use_time) + ' min used in trainng process')
def predict(self, n): # predict the nth date
neural = np.zeros((96, ))
xp = np.zeros((1, ANN96_1.xcols), dtype=np.float) # predict data
prediction = 0
for j in range(96):
if j == 0:
xp[0, 0] = self.load[n - 7, j]
xp[0, 1] = self.load[n - 8, 95]
xp[0, 2] = self.load[n - 1, j]
xp[0, 3] = self.load[n - 2, 95]
if (n - 1) % 7 == 3 or (n - 1) % 7 == 4:
xp[0, 4] = 0
else:
xp[0, 4] = 1
if n % 7 == 3 or n % 7 == 4:
xp[0, 5] = 0
else:
xp[0, 5] = 1
for k in ANN96_1.norm1:
xp[0, k] = (xp[0, k] - self.loadmin)\
/ (self.loadmax - self.loadmin)
else:
xp[0, 0] = self.load[n - 7, j]
xp[0, 1] = self.load[n - 7, j - 1]
xp[0, 2] = self.load[n - 1, j]
xp[0, 3] = self.load[n - 1, j - 1]
if (n - 1) % 7 == 3 or (n - 1) % 7 == 4:
xp[0, 4] = 0
else:
xp[0, 4] = 1
if n % 7 == 3 or n % 7 == 4:
xp[0, 5] = 0
else:
xp[0, 5] = 1
for k in ANN96_1.norm1:
xp[0, k] = (xp[0, k] - self.loadmin)\
/ (self.loadmax - self.loadmin)
# predict
self.model.load_weights(os.path.join('new_weights',
str(j) + '.h5'))
prediction = self.model.predict(xp)
prediction = \
(self.loadmax - self.loadmin) * prediction + self.loadmin
neural[j] = prediction
return neural
else:
encoder.add(autoencoder.layers[0])
for i in range(1, n_hidden_layers + 1):
encoder.add(autoencoder.layers[2 * i])
### Create and save low-dimensional representations of training data ###
lowd_train = encoder.predict(x_train_scaled)
np.save(path + "LowD_Train.npy", lowd_train)
### Save autoencoder ###
model_json_1 = autoencoder.to_json()
with open(path + "Autoencoder.json", "w") as json_file:
json_file.write(model_json_1)
# serialize weights to HDF5
autoencoder.save_weights(path + "Autoencoder.h5")
### Save encoder ###
model_json_2 = encoder.to_json()
with open(path + "Encoder.json", "w") as json_file:
json_file.write(model_json_2)
# serialize weights to HDF5
encoder.save_weights(path + "Encoder.h5")
### Plot loss ###
plt.figure(1)
plt.plot(autoencoder.history.history['val_loss'])
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.savefig(path + "Autoencoder_Train.png")
testLabels = tempMatrix[:, 0]
testData = testData.reshape(testData.shape[0], testData.shape[1], 1)
scores = myModel.evaluate(x=testData, y=testLabels)
print(scores)
print("The accuracy for file {0} is {1}".format(f, scores[1] * 100))
'''
# test the model
NPYfiles = os.listdir(testDIR)
for f in NPYfiles:
tempFile = testDIR + '/' + f
tempMatrix = np.load(tempFile)
print("The shape of {0} is {1}.".format(f, tempMatrix.shape))
x_test = tempMatrix[:,1:]
y_test = tempMatrix[:,0]
y_test_binary = keras.utils.to_categorical(y_test, num_classes)
print("y_test_binary is {}.".format(y_test_binary))
x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], 1)
print("The shape of x_test is {}.".format(x_test.shape))
myPrediction = myModel.predict_classes(x_test)
print(myPrediction)
'''
# Save the trained model
myModel_json = myModel.to_json()
with open(modelDIR + '/' + modelFILE, 'w') as json_file:
json_file.write(myModel_json)
myModel.save_weights(modelDIR + '/' + weightFILE)
print("The trained model has been saved.")
print("Time point 3 is " + str(time.time() - startTime))
from keras import Sequential
from keras.layers import Dense, Dropout
from sklearn.metrics import confusion_matrix, accuracy_score
previsores = pd.read_csv('entradas-breast.csv')
classe = pd.read_csv('saidas-breast.csv')
classificador = Sequential()
classificador.add(
Dense(units=8,
activation='relu',
kernel_initializer='normal',
input_dim=30))
classificador.add(Dropout(0.2))
classificador.add(
Dense(units=8, activation='relu', kernel_initializer='normal'))
classificador.add(Dropout(0.2))
classificador.add(Dense(units=1, activation='sigmoid'))
classificador.compile(optimizer='adam', loss='binary_crossentropy', metrics = \
['binary_accuracy'])
classificador.fit(previsores, classe, batch_size=10, epochs=100)
classificador_json = classificador.to_json()
with open('classificador_breast.json', 'w') as json_file:
json_file.write(classificador_json)
classificador.save_weights('classificador_breast.h5')
class DNN_Model(Common_Model):
'''
__init__(): 初始化神经网络
输入:
input_shape: 特征维度
num_classes(int): 标签种类数量
lr(float): 学习率
'''
def __init__(self, input_shape, num_classes, lr, **params):
super(DNN_Model, self).__init__()
self.input_shape = input_shape
self.model = Sequential()
self.make_model(**params)
self.model.add(Dense(num_classes, activation = 'softmax'))
optimzer = keras.optimizers.Adam(lr = lr)
self.model.compile(loss = 'categorical_crossentropy', optimizer = optimzer, metrics = ['accuracy'])
print(self.model.summary(), file = sys.stderr)
'''
save_model(): 将模型存储在 config.checkpoint_path 路径下
输入:
config(Class)
'''
def save_model(self, config):
h5_save_path = os.path.join(config.checkpoint_path, config.checkpoint_name + '.h5')
self.model.save_weights(h5_save_path)
save_json_path = os.path.join(config.checkpoint_path, config.checkpoint_name + '.json')
with open(save_json_path, "w") as json_file:
json_file.write(self.model.to_json())
def reshape_input(self):
NotImplementedError()
'''
train(): 在给定训练集上训练模型
输入:
x_train(numpy.ndarray): 训练集样本
y_train(numpy.ndarray): 训练集标签
x_val(numpy.ndarray): 测试集样本
y_val(numpy.ndarray): 测试集标签
batch_size(int): 批大小
n_epochs(int): epoch 数
'''
def train(self, x_train, y_train, x_val = None, y_val = None,
batch_size = 32, n_epochs = 50):
if x_val is None or y_val is None:
x_val, y_val = x_train, y_train
x_train, x_val = self.reshape_input(x_train), self.reshape_input(x_val)
history = self.model.fit(
x_train, y_train,
batch_size = batch_size,
epochs = n_epochs,
shuffle = True, # 每个 epoch 开始前随机排列训练数据
validation_data = (x_val, y_val)
)
# 训练集上的损失和准确率
acc = history.history['acc']
loss = history.history['loss']
# 验证集上的损失和准确率
val_acc = history.history['val_acc']
val_loss = history.history['val_loss']
plotCurve(acc, val_acc, 'Accuracy', 'acc')
plotCurve(loss, val_loss, 'Loss', 'loss')
self.trained = True
'''
predict(): 识别音频的情感
输入:
samples: 需要识别的音频特征
输出:
list: 识别结果
'''
def predict(self, sample):
sample = self.reshape_input(sample)
# 没有训练和加载过模型
if not self.trained:
sys.stderr.write("No Model.")
sys.exit(-1)
return np.argmax(self.model.predict(sample), axis=1)
def make_model(self):
raise NotImplementedError()
class LSTMPredictor:
LOOKBACK_SEQUENCE_LENGTH = 16
PREDICTED_SEQUENCE_LENGTH = 4
EPOCHS = 100
MIN_EPOCHS = 1
MIN_DELTA = 0.002
BATCH_SIZE = 100
VALIDATION_SPLIT = 0.05
def __init__(self, models_dir: str = '', tensorboard_dir: str = '') -> None:
self._models_dir = models_dir or os.path.join(PROJECT_PATH, 'models')
self._tensorboard_dir = tensorboard_dir
self._model = Sequential([
LSTM(
input_shape=(self.LOOKBACK_SEQUENCE_LENGTH, 1),
units=32,
return_sequences=True,
),
Activation('relu'),
LSTM(
units=32,
),
Activation('relu'),
Dense(units=self.PREDICTED_SEQUENCE_LENGTH),
])
def train(self, signal_name: str, normal_data: np.ndarray) -> History:
print(f'Обучение LSTM-предиктора для сигнала "{signal_name}"...')
x_train, y_train = self._create_subsequences(self._preprocess(normal_data))
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1)) # samples, sample_len, features
self._model.compile(optimizer='adam', loss='mse')
callbacks = [
EarlyStopping('val_loss', patience=self.MIN_EPOCHS, min_delta=self.MIN_DELTA),
]
if self._tensorboard_dir:
os.makedirs(self._tensorboard_dir, exist_ok=True)
callbacks.append(
TensorBoard(
log_dir=self._get_tensorboard_logs_dir(signal_name),
batch_size=self.BATCH_SIZE,
histogram_freq=0,
write_graph=True,
write_grads=True,
write_images=True,
))
history = self._model.fit(
x_train, y_train,
batch_size=self.BATCH_SIZE,
epochs=self.EPOCHS,
validation_split=self.VALIDATION_SPLIT,
shuffle=True,
callbacks=callbacks,
)
models_path = self._get_model_path(signal_name)
os.makedirs(os.path.dirname(models_path), exist_ok=True)
self._model.save_weights(models_path)
print(f'Модель сохранена в "{models_path}"')
return history
def analyze(self, signal: Signals) -> PredictorResult:
assert len(signal) == 1, 'Allowed to analyze only 1 singal'
signal_name, data = next(iter(signal.items()))
model_path = self._get_model_path(signal_name)
if not os.path.exists(model_path):
raise FileNotFoundError(f'Model for {signal_name} is not found. Please train')
self._model.load_weights(model_path)
data = self._preprocess(data)
subsequences, next_values = self._create_subsequences(data)
subsequences = np.reshape(subsequences, (subsequences.shape[0], subsequences.shape[1], 1))
predicted_next_values = self._model.predict(subsequences, batch_size=self.BATCH_SIZE)
errors = next_values - predicted_next_values
error_mean, error_cov = calculate_covariance_matrix(errors)
return PredictorResult(
signal=signal_name,
data=data,
predicted_data=predicted_next_values,
mahalanobis_distance=np.array([
mahalanobis_distance(e_vec, error_mean, error_cov)
for e_vec in errors
])
)
def plot_model(self, img_path: str, show_shapes=True, show_layer_names=True) -> None:
plot_model(
self._model,
to_file=img_path,
show_shapes=show_shapes,
show_layer_names=show_layer_names,
)
def _get_model_path(self, signal_name: str) -> str:
return os.path.join(self._models_dir, 'predictor', f'{signal_name}.h5')
def _get_tensorboard_logs_dir(self, signal_name: str) -> str:
return os.path.join(self._tensorboard_dir, 'predictor', signal_name)
@staticmethod
def _preprocess(data: np.ndarray) -> np.ndarray:
return z_normalization(fill_zeros_with_previous(data))
@staticmethod
def _create_subsequences(
series: np.ndarray,
previous_count: int = LOOKBACK_SEQUENCE_LENGTH,
next_count: int = PREDICTED_SEQUENCE_LENGTH,
) -> Tuple[np.ndarray, np.ndarray]:
assert previous_count > next_count
previous_values, next_values = [], []
for i in range(previous_count, len(series) - next_count):
previous_values.append(series[i - previous_count:i])
next_values.append(series[i:i + next_count])
return np.array(previous_values), np.array(next_values)
def main():
first_stage_network_depths = ((('Dense', {
'units': 128,
'activation': 'relu'
}), ('Dropout', {
'rate': 0.4
}), ('Dense', {
'units': 64,
'activation': 'relu'
}), ('Dense', {
'units': 1,
'activation': 'sigmoid'
})), )
first_stage_data = BacteriaAndVirusKMers(
fp=
'/home/jklynch/host/project/viral-learning/data/perm_training_testing.h5',
training_sample_count=100000,
development_sample_count=1000,
half_batch_size=50)
first_stage_model_name, first_stage_model = build_model(
model=Sequential(),
input_dim=first_stage_data.get_input_dim(),
layers=first_stage_network_depths[0])
first_stage_model_name = 'first_stage_' + first_stage_model_name
training_metrics_df, dev_metrics_df = train_and_evaluate(
model=first_stage_model,
model_name=first_stage_model_name,
training_epochs=5,
the_data=first_stage_data)
pprint(first_stage_model.get_config())
# store the model
with open(first_stage_model_name + '.json', 'wt') as model_json:
model_json.write(first_stage_model.to_json())
first_stage_model.save_weights(filepath=first_stage_model_name + '.h5',
overwrite=True)
second_stage_model = Sequential()
second_stage_model.add(first_stage_model.get_layer(index=0))
second_stage_model.add(first_stage_model.get_layer(index=1))
second_stage_model.add(first_stage_model.get_layer(index=2))
second_stage_layers = (
(
#('Dense', {'units': 64, 'activation': 'relu'}),
('Dense', {
'units': 1,
'activation': 'sigmoid'
}), ), )
second_stage_model_name, second_stage_model = build_model(
model=second_stage_model, layers=second_stage_layers[0])
second_stage_model_name = 'second_stage_' + second_stage_model_name
second_stage_data = BacteriaAndVirusGenomeKMers(
fp=
'/home/jklynch/host/project/viral-learning/data/riveal_refseq_prok_phage_500pb_kmers8.h5',
pb=500,
k=8,
training_sample_count=100000,
development_sample_count=1000,
half_batch_size=50)
pprint(second_stage_model.get_config())
genomic_training_metrics_df, genomic_dev_metrics_df = train_and_evaluate(
model=second_stage_model,
model_name=second_stage_model_name,
training_epochs=5,
the_data=second_stage_data)
# store the model
with open(second_stage_model_name + '.json', 'wt') as model_json:
model_json.write(second_stage_model.to_json())
second_stage_model.save_weights(filepath=second_stage_model_name + '.h5',
overwrite=True)
class LSTM():
def __init__(self, input_shape=(None, LATENT_DIM + NB_ACTIONS)):
self.input_shape = input_shape
self._build()
def _build(self):
self.model = Sequential()
# Only one lstm layer
# The output needs to be the same size as the LATENT_DIM because the LSTM predict the future latent vector
self.model.add(
layers.LSTM(units=LATENT_DIM,
input_shape=self.input_shape,
activation='sigmoid',
kernel_initializer='random_normal'))
self.model.add(BatchNormalization())
self.model.compile(loss='mse', optimizer='adam')
def train(self, X_train, Y_train, X_test, Y_test, epochs=200):
print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
print(Y_test.shape)
self.model.fit(x=X_train,
y=Y_train,
epochs=epochs,
validation_data=(X_test, Y_test),
batch_size=SEQ_LENGTH,
verbose=2,
shuffle=False)
def save(self, path):
self.model.save(path)
def save_weights(self, file_path):
self.model.save_weights(filepath=file_path)
def load_weights(self, file_path):
self.model.load_weights(filepath=file_path)
'''
We load the trained model of the LSTM in order to play inside it.
Its output is connected to its input so it generates continuously new latent vectors.
The actions of the player are also given to the input layer.
'''
def play_in_dream(self, start_image, decoder):
latent_image = start_image
while True:
# Player's actions
actions = [[0, 0, 0, 0]]
# We check wich keys are pressed
try:
if keyboard.is_pressed('up'):
actions[0][Actions.JUMP] = 1
print('UP')
if keyboard.is_pressed('left'):
actions[0][Actions.LEFT] = 1
print('LEFT')
if keyboard.is_pressed('right'):
actions[0][Actions.RIGHT] = 1
print('RIGHT')
if keyboard.is_pressed('down'):
actions[0][Actions.DOWN] = 1
print('DOWN')
if keyboard.is_pressed('escape'):
print("exit")
sys.exit(1)
except Exception as e:
print(e)
break
# latent vector + actions are given to the input layer of the LSTM
lstm_input = np.concatenate((latent_image, actions), axis=1)
lstm_input = np.reshape(lstm_input,
(1, 1, LATENT_DIM + NB_ACTIONS))
# Futur latent vector is predicted
latent_image = self.model.predict(lstm_input)
# We pass the latent vector through the decoder to see the corresponding image
reconstructed_image = decoder.predict(latent_image)
reconstructed_image = reconstructed_image.reshape(IMG_SHAPE)
plt.clf()
plt.imshow(reconstructed_image, vmin=0, vmax=1)
# Necessary to display something on screen
plt.pause(0.0000001)
class CNNmodel3:
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)
conv1_kernel = np.random.randint(2, 10)
conv2_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)
maxpool1_size = np.random.randint(2, 10)
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(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 Sentiment(object):
def __init__(self, data_directory, model_directory, filename,
pickle_directory, output_directory, max_length, batch_size,
epochs):
self.data_directory = data_directory
self.model_directory = model_directory
self.filename = filename
self.pickle_directory = Path(pickle_directory)
self.output_directory = output_directory
self.max_length = max_length
self.batch_size = batch_size
self.epochs = epochs
def load_data(self):
logger.debug(
f'Load the data {self.filename} from data directory {self.data_directory}'
)
data = pd.read_csv(self.data_directory / self.filename)
indx = data[(data.stars != 5) & (data.stars != 1)].index
data = data.drop(indx)
self.data_sentiment = data.reset_index(drop=True)
def data_prep(self):
logger.debug(
'Split the comments into sentences and obtain the vocabulary')
all_words = []
toxic_sentences = []
attitude_list = []
sentences_list = []
for i in range(len(self.data_sentiment.index)):
sentences = re.split(
r'[.!]', self.data_sentiment['text'][i].replace('\n', ''))
if self.data_sentiment['stars'][i] == 1:
attitude = 0
elif self.data_sentiment['stars'][i] == 5:
attitude = 1
for sentence in sentences:
words = list(preprocessing.tokenize(sentence))
if len(words) >= 3:
all_words += words
confid_score = sonar.ping(
text=sentence)['classes'][1]['confidence']
if confid_score > 0.8:
toxic_sentences.append(sentence)
attitude_list.append(attitude)
sentences_list.append(sentence)
self.all_words = all_words
self.toxic_sentences = toxic_sentences
self.attitude_list = attitude_list
self.sentences_list = sentences_list
def words_encoder(self):
logger.debug('Encoding the vocabulary')
self.encoder = LabelEncoder()
self.encoder.fit(self.all_words)
label_encoder_dict = defaultdict(LabelEncoder)
for key, encoder in label_encoder_dict.items():
classes = np.array(self.encoder.classes_).tolist()
bisect.insort_left(classes, 'UNK')
self.encoder.classes_ = classes
self.vocab_size = len(self.encoder.classes_)
def encoder_transform(self):
logger.debug('Transfer the words to the coders')
X_sentiment = []
for sentence in self.sentences_list:
words = list(preprocessing.tokenize(sentence))
if len(words) >= 3:
try:
words = words[:self.max_length]
except:
pass
words_idx = np.array(self.encoder.transform(words))
arr = np.full(self.max_length, 0)
arr[:len(words)] = words_idx
X_sentiment.append(arr)
self.X_sentiment = np.array(X_sentiment)
self.X_sentiment_label = np.array(self.attitude_list)
def create_dict(self):
self.encoder_dict = {
'encoder': self.encoder,
'X_sentiment': self.X_sentiment,
'X_sentiment_label': self.X_sentiment_label,
'toxic_sentences': self.toxic_sentences
}
def save_pickle(self):
logger.debug('Save the pickle file')
with open(self.pickle_directory / 'encoder_senti.pickle',
'wb') as handle:
pickle.dump(self.encoder_dict,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
def load_pickle(self):
logger.debug('Load the pickle file')
with open(self.pickle_directory / 'encoder_senti.pickle',
'rb') as handle:
x = pickle.load(handle)
return x
def train(self):
logger.debug(
f'Building the neural network with epochs as {self.epochs} and batch size as {self.batch_size}'
)
encoder_dict = self.load_pickle()
encoder = encoder_dict['encoder']
X_sentiment = encoder_dict['X_sentiment']
X_sentiment_label = encoder_dict['X_sentiment_label']
self.model_sentiment = Sequential()
self.model_sentiment.add(Embedding(self.vocab_size, 100))
self.model_sentiment.add(
Bidirectional(LSTM(50, dropout=0.5, recurrent_dropout=0.5)))
self.model_sentiment.add(Dense(1, activation='sigmoid'))
self.model_sentiment.compile(optimizer=Adam(lr=1e-4),
loss='binary_crossentropy',
metrics=['accuracy', f1_score, auc])
self.history_sentiment = self.model_sentiment.fit(
X_sentiment,
X_sentiment_label,
validation_split=0.1,
callbacks=[earlyStopping],
epochs=self.epochs,
batch_size=self.batch_size,
class_weight='auto')
def save_model(self):
logger.debug(f'Save the model in {self.model_directory}')
model_json = self.model_sentiment.to_json()
with open(self.model_directory / 'sentiment_model.json',
'w') as json_file:
json_file.write(model_json)
self.model_sentiment.save_weights(self.model_directory /
'sentiment_model.h5')
def load_model(self):
logger.debug(f'Load the model from {self.model_directory}')
json_file = open(self.model_directory / 'sentiment_model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
with CustomObjectScope({'GlorotUniform': glorot_uniform()}):
self.loaded_model_sentiment = model_from_json(loaded_model_json)
self.loaded_model_sentiment.load_weights(self.model_directory /
'sentiment_model.h5')
return self.loaded_model_sentiment
def metric_graph(self):
history_dict = self.history_sentiment.history
acc = history_dict['acc']
val_acc = history_dict['val_acc']
loss = history_dict['loss']
val_loss = history_dict['val_loss']
f1_score = history_dict['f1_score']
val_f1_score = history_dict['val_f1_score']
auc = history_dict['auc']
val_auc = history_dict['val_auc']
epochs = range(1, len(acc) + 1)
train_set = ['acc', 'loss', 'f1_score', 'auc']
val_set = ['val_acc', 'val_loss', 'val_f1_score', 'val_auc']
for i in range(len(train_set)):
logger.debug(f'Generate the figures for {train_set[i]}')
fig = matplotlib.pyplot.figure()
matplotlib.pyplot.title(f'Training and validation {train_set[i]}')
matplotlib.pyplot.xlabel('epochs')
matplotlib.pyplot.ylabel(f'{train_set[i]}')
matplotlib.pyplot.plot(epochs,
train_set[i],
'r',
label=f'{train_set[i]}')
matplotlib.pyplot.plot(epochs,
val_set[i],
'b',
label=f'{val_set[i]}')
matplotlib.pyplot.legend()
fig.savefig(self.output_directory /
f'sentiment_{train_set[i]}.png')
class DNN(Model):
"""
This class is parent class for all Deep neural network models. Any class
inheriting this class should implement `make_default_model` method which
creates a model with a set of hyper parameters.
"""
def __init__(self, input_shape, num_classes, **params):
"""
Constructor to initialize the deep neural network model. Takes the input
shape and number of classes and other parameters required for the
abstract class `Model` as parameters.
Args:
input_shape (tuple): shape of the input
num_classes (int): number of different classes ( labels ) in the data.
**params: Additional parameters required by the underlying abstract
class `Model`.
"""
super(DNN, self).__init__(**params)
self.input_shape = input_shape
self.model = Sequential()
self.make_default_model()
self.model.add(Dense(num_classes, activation='softmax'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print(self.model.summary(), file=sys.stderr)
self.save_path = self.save_path or self.name + '_best_model.h5'
def load_model(self, to_load):
"""
Load the model weights from the given path.
Args:
to_load (str): path to the saved model file in h5 format.
"""
try:
self.model.load_weights(to_load)
except:
sys.stderr.write("Invalid saved file provided")
sys.exit(-1)
def save_model(self):
"""
Save the model weights to `save_path` provided while creating the model.
"""
self.model.save_weights(self.save_path)
def train(self, x_train, y_train, x_val=None, y_val=None, n_epochs=50):
"""
Train the model on the given training data.
Args:
x_train (numpy.ndarray): samples of training data.
y_train (numpy.ndarray): labels for training data.
x_val (numpy.ndarray): Optional, samples in the validation data.
y_val (numpy.ndarray): Optional, labels of the validation data.
n_epochs (int): Number of epochs to be trained.
"""
best_acc = 0
if x_val is None or y_val is None:
x_val, y_val = x_train, y_train
for i in range(n_epochs):
# Shuffle the data for each epoch in unison inspired
# from https://stackoverflow.com/a/4602224
p = np.random.permutation(len(x_train))
x_train = x_train[p]
y_train = y_train[p]
self.model.fit(x_train, y_train, batch_size=32, epochs=1)
loss, acc = self.model.evaluate(x_val, y_val)
if acc > best_acc:
best_acc = acc
self.trained = True
def predict_one(self, sample):
print("predicting one")
if not self.trained:
sys.stderr.write(
"Model should be trained or loaded before doing predict\n")
sys.exit(-1)
prediction = np.argmax(self.model.predict(np.array([sample])))
return class_labels[prediction]
def make_default_model(self) -> None:
"""
Make the model with default hyper parameters
"""
# This has to be implemented by child classes. The reason is that the
# hyper parameters depends on the model.
raise NotImplementedError()
model_cnn.add(Dropout(0.15))
model_cnn.add(Conv2D(128, (3,3), activation = 'relu'))
# model_cnn.add(Conv2D(128, (3,3), activation = 'relu'))
model_cnn.add(MaxPooling2D(pool_size=(2,2)))
model_cnn.add(Conv2D(128, (3,3), activation = 'relu'))
model_cnn.add(Flatten())
model_cnn.add(Dense(128, activation="sigmoid"))
model_cnn.add(Dropout(0.3))
model_cnn.add(Dense(128, activation='relu'))
model_cnn.add(Dense(num_classes, activation='softmax'))
model_cnn.compile(loss=keras.losses.categorical_crossentropy,
optimizer='adam',
metrics=['accuracy'])
model_cnn.fit(X_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1)
# model_cnn.summary()
print(datetime.datetime.now())
# save model face recognition
model_cnn.save('./keras_cnn_model_file/model_keras1.h5')
model_cnn.save_weights('./keras_cnn_model_file//model_keras_weights1.h5')
print(model_cnn.evaluate(X_test,y_test))
class DNN_Model(Common_Model):
'''
__init__(): 初始化神经网络
输入:
input_shape(tuple): 张量形状
num_classes(int): 标签种类数量
'''
def __init__(self, input_shape, num_classes, **params):
super(DNN_Model, self).__init__(**params)
self.input_shape = input_shape
self.model = Sequential()
self.make_model()
self.model.add(Dense(num_classes, activation = 'softmax'))
self.model.compile(loss = 'binary_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
print(self.model.summary(), file = sys.stderr)
'''
save_model(): 将模型权重以 model_name.h5 和 model_name.json 命名存储在 /Models 目录下
'''
def save_model(self, model_name):
h5_save_path = 'Models/' + model_name + '.h5'
self.model.save_weights(h5_save_path)
save_json_path = 'Models/' + model_name + '.json'
with open(save_json_path, "w") as json_file:
json_file.write(self.model.to_json())
'''
train(): 在给定训练集上训练模型
输入:
x_train (numpy.ndarray): 训练集样本
y_train (numpy.ndarray): 训练集标签
x_val (numpy.ndarray): 测试集样本
y_val (numpy.ndarray): 测试集标签
n_epochs (int): epoch数
'''
def train(self, x_train, y_train, x_val = None, y_val = None, n_epochs = 50):
best_acc = 0
if x_val is None or y_val is None:
x_val, y_val = x_train, y_train
for i in range(n_epochs):
# 每个epoch都随机排列训练数据
p = np.random.permutation(len(x_train))
x_train = x_train[p]
y_train = y_train[p]
self.model.fit(x_train, y_train, batch_size = 32, epochs = 1)
# 训练过程的损失率变化图
# 计算损失率和准确率
loss, acc = self.model.evaluate(x_val, y_val)
if acc > best_acc:
best_acc = acc
self.trained = True
'''
recognize_one(): 识别某个音频的情感
输入:
sample: 要预测的样本
输出:
预测结果，置信概率(int, numpy.ndarray)
'''
def recognize_one(self, sample):
# 没有训练和加载过模型
if not self.trained:
sys.stderr.write("No Model.")
sys.exit(-1)
return np.argmax(self.model.predict(np.array([sample]))), self.model.predict(np.array([sample]))[0]
def make_model(self):
raise NotImplementedError()
class Model(MNIST_data):
def __init__(self, dataset, name_json, name_weights, vers=1, params=None):
super().__init__(dataset)
self.name_json = name_json
self.name_weights = name_weights
self.vers = vers
if params:
self.params = params
self.batch_size = params['batch_size']
else:
self.batch_size = 64
def CNN_model(self):
if self.vers == 1:
self.model = Sequential()
self.model.add(Conv2D(64, (3, 3), input_shape=(28, 28, 1)))
self.model.add(Activation('relu'))
self.model.add(MaxPool2D(pool_size=(2, 2)))
self.model.add(Dropout(0.2))
self.model.add(Conv2D(64, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPool2D(pool_size=(2, 2)))
self.model.add(Dropout(0.2))
self.model.add(Flatten())
self.model.add(Dense(64))
#optional Dense layer
#self.model.add(Activation('relu'))
self.model.add(Dense(10))
self.model.add(Activation('softmax'))
self.model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
elif self.vers == 2:
params = self.params
dropout_num = params['dropout']
dense_neuron = params['dense_neuron']
self.model = Sequential()
self.model.add(Conv2D(64, (3, 3), input_shape=(28, 28, 1)))
self.model.add(Activation(params['activation']))
self.model.add(MaxPool2D(pool_size=(2, 2)))
self.model.add(Dropout(dropout_num))
self.model.add(Conv2D(64, (3, 3), input_shape=(28, 28, 1)))
self.model.add(Activation(params['activation']))
self.model.add(MaxPool2D(pool_size=(2, 2)))
self.model.add(Dropout(dropout_num))
self.model.add(Flatten())
self.model.add(Dense(dense_neuron))
self.model.add(Activation(params['activation']))
self.model.add(Dense(10))
self.model.add(Activation('softmax'))
self.model.compile(loss='categorical_crossentropy',
optimizer=params['optimizer'],
metrics=['accuracy'])
def fit_train(self):
self.model.fit(x=self.train_X,
y=self.train_Y,
epochs=10,
batch_size=self.batch_size)
def save_classifier(self):
save_model = self.model.to_json()
with open(self.name_json, 'w') as json_file:
json_file.write(save_model)
self.model.save_weights(self.name_weights)
print("Successfully saved the CNN model")
def load_classifier(self):
with open(self.name_json, 'r') as json_file:
saved_model = json_file.read()
self.model = keras.models.model_from_json(saved_model)
self.model.load_weights(self.name_weights)
self.model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
def running_classifier(self):
if os.path.isfile(self.name_json) and os.path.isfile(
self.name_weights):
self.load_classifier()
else:
self.CNN_model()
self.fit_train()
self.save_classifier()
def evaluate_model(self):
test_loss, test_acc = self.model.evaluate(self.test_X, self.test_Y)
return (test_loss, test_acc)
def predict(self):
prediction = self.model.predict(self.test_X)
print(np.argmax(np.round(prediction[0])))
