def lstm(): in_out_neurons = 1 n_hidden = 200 model = Sequential() model.add( LSTM(n_hidden, batch_input_shape=(None, time_step, in_out_neurons))) model.add(Dense(in_out_neurons)) model.add(Activation("linear")) optimizer = Adam(lr=0.006) model.compile(loss="mean_squared_error", optimizer=optimizer) early_stopping = EarlyStopping(monitor='val_loss', mode='auto', patience=20) model.fit(train_x, train_y, batch_size=300, epochs=5, validation_split=0.1, callbacks=[early_stopping]) model_json = model.to_json() with open(path + "lstm_model.json", "w") as json_file: json_file.write(model_json) model.save_weights(path + "lstm_model.h5") print("=====Saved model Ok======")
def lstm_model(model_name, train=False): if train: # define model model = Sequential() model.add(LSTM(50, activation='relu', input_shape=(n_steps, n_features))) model.add(Dense(1)) model.compile(optimizer='adam', loss='mse', metrics=[r2_keras]) # fit model model.fit(X_train, y_train[:, 0], epochs=60, verbose=0) # Save model model_json = model.to_json() with open("%s_model.json" % model_name, "w") as json_file: json_file.write(model_json) model.save_weights("%s_model.h5" % model_name) print("Saving %s model to disk .." % model_name) else: json_file = open('%s_model.json' % model_name, 'r') loaded_model_json = json_file.read() json_file.close() model = model_from_json(loaded_model_json) model.load_weights('%s_model.h5' % model_name) print('loaded model from disk') model.compile(optimizer='adam', loss='mse', metrics=[r2_keras]) return model
def train(self): print("===============Training Model===============") self.__prepare() model = Sequential() model.add( LSTM(self.n_hidden, batch_input_shape=(None, time_step, self.in_out_neurons))) model.add(Dense(self.in_out_neurons)) model.add(Activation("linear")) optimizer = Adam(lr=self.lr) model.compile(loss="mean_squared_error", optimizer=optimizer) early_stopping = EarlyStopping(monitor='val_loss', mode='auto', patience=20) model.fit(self.train_x, self.train_y, batch_size=300, epochs=self.epoch, validation_split=0.1, callbacks=[early_stopping]) model_json = model.to_json() with open(self.model_path + "lstm_model.json", "w") as json_file: json_file.write(model_json) model.save_weights("lstm_model.h5") self.model = model
class DNN_Model(Common_Model): 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) 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): print("NUMBER OF EPOCH :", i) # epoch (randomize training data) 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) # accuracy, loss acc.append(history.history['acc']) loss.append(history.history['loss']) # validation: accuracy, 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()
def build_model(): ##model building model = Sequential() #convolutional layer with rectified linear unit activation model.add( layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) #32 convolution filters used each of size 3x3 #again model.add(layers.Conv2D(64, (3, 3), activation='relu')) #64 convolution filters used each of size 3x3 #choose the best features via pooling model.add(layers.MaxPooling2D(pool_size=(2, 2))) #randomly turn neurons on and off to improve convergence model.add(layers.Dropout(0.25)) #flatten since too many dimensions, we only want a classification output model.add(layers.Flatten()) #fully connected to get all relevant data model.add(layers.Dense(128, activation='relu')) #one more dropout for convergence' sake :) model.add(layers.Dropout(0.5)) #output a softmax to squash the matrix into output probabilities model.add(layers.Dense(num_category, activation='softmax')) #Adaptive learning rate (adaDelta) is a popular form of gradient descent rivaled only by adam and adagrad #categorical ce since we have multiple classes (10) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) batch_size = 128 num_epoch = 10 #model training model_log = model.fit(X_train, y_train, batch_size=batch_size, epochs=num_epoch, verbose=1, validation_data=(X_test, y_test)) score = model.evaluate(X_test, y_test, verbose=0) print('Test loss:', score[0]) #Test loss: 0.0296396646054 print('Test accuracy:', score[1]) #Test accuracy: 0.9904 #Save the model # serialize model to JSON model_digit_json = model.to_json() with open("model_digit.json", "w") as json_file: json_file.write(model_digit_json) # serialize weights to HDF5 model.save_weights("model_digit.h5") print("Saved model to disk")
def keras_model(force=False, verbose=False): """ Método para retornar um modelo iterativo do Keras. Se um modelo já existir, carregará os pesos e retornará um objeto de modelo iterativo. Caso não exista um modelo, um será gerado. :param force: se deve ou não forçar a geração de um modelo fresco :param verbose: quando o verbose estiver ligado durante a criação de um modelo, mostrará a precisão do mesmo :return: modelo iterativo do keras """ from keras import Sequential from keras.layers import Dense model_path = module_path + "/data/kerasdump.data" weights_path = module_path + "/data/kerasweights.h5" if Path(model_path).is_file() and force is False: from keras.models import model_from_json clear_session() loaded_model = model_from_json(open(model_path, 'r').read()) loaded_model.load_weights(weights_path) loaded_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return loaded_model else: clear_session() dataset = pandas.read_csv(module_path + "/data/dataset.csv", names=headers) # Separar dados de validação, e dados de treino array = dataset.values # Dados X = array[:, 0:(len(headers) - 1)] # Dados Y = array[:, (len(headers) - 1)] # Resultados numpy.random.seed(491826658) model = Sequential() model.add(Dense(52, input_dim=(len(headers) - 1), activation='relu')) model.add(Dense(29, activation='relu')) model.add(Dense(17, activation='relu')) model.add(Dense(5, activation='relu')) model.add(Dense(2, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compile model model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X, Y, epochs=150, batch_size=10, verbose=0, shuffle=True) if verbose: print(evaluate(model, X, Y)) model_json = model.to_json() with open(model_path, "w") as json_file: json_file.write(model_json) model.save_weights(weights_path) return model
def keras_model(self, force=False, verbose=False, final=False): """ Método para retornar um modelo iterativo do Keras. Se um modelo já existir, carregará os pesos e retornará um objeto de modelo iterativo. Caso não exista um modelo, um será gerado. :param final: Se deve utilizar todos os dados (True) do dataset ou dividi-lo (False) :param verbose: quando o verbose estiver ligado durante a criação de um modelo, mostrará a precisão do mesmo :param force: se deve ou não forçar a geração de um modelo fresco :return: modelo iterativo do keras """ from keras import Sequential from keras.layers import Dense model_path = self.MODULE_PATH + "/data/model.data" weights_path = self.MODULE_PATH + "/data/weights.h5" if Path(model_path).is_file() and force is False: from keras.models import model_from_json clear_session() loaded_model = model_from_json(open(model_path, 'r').read()) loaded_model.load_weights(weights_path) loaded_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return loaded_model else: clear_session() model = Sequential() model.add(Dense(30, input_dim=(len(self.HEADERS) - 1), activation='relu')) model.add(Dense(51, activation='relu')) model.add(Dense(36, activation='relu')) model.add(Dense(10, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compile model model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) model_json = model.to_json() from sklearn import model_selection X_train, X_validation, Y_train, Y_validation = \ model_selection.train_test_split(self.X, self.Y, test_size=self.validation_size) if not final: model.fit(X_train, Y_train, epochs=150, batch_size=20, verbose=0, shuffle=True) else: model.fit(self.X, self.Y, epochs=150, batch_size=20, verbose=0, shuffle=True) if verbose: if not final: print(self.evaluate(model, evaluate_x=X_validation, evaluate_y=Y_validation)) else: print(self.evaluate(model, evaluate_x=self.X, evaluate_y=self.Y)) with open(model_path, "w") as json_file: json_file.write(model_json) model.save_weights(weights_path) return model
def learn_and_fit(self, learning_rate=0.001, epochs=200): for i in range(1, self.unique_classes_count + 1): print("Learning model " + str(i)) # Loading the data X = np.array(pd.read_csv("model/x" + str(i) + ".csv", delimiter=";"), dtype=int) Y = np.array(pd.read_csv("model/y" + str(i) + ".csv", delimiter=";"), dtype=int) # Defining checkpoints mc = ModelCheckpoint("networks/class" + str(i) + '.h5', save_best_only=True, verbose=1, mode='min') # Defining model model = Sequential() model.add( Dense(int(X.shape[1] / 2), input_dim=X.shape[1], activation='relu')) model.add( Dense(int(X.shape[1] / 2), input_dim=X.shape[1], activation='relu')) model.add(Dense(Y.shape[1], activation='sigmoid')) model.compile(loss='mean_squared_error', optimizer='adam', metrics=['acc']) model.fit(X, Y, epochs=epochs, callbacks=[mc]) # Saving model to array model.save_weights("networks/class" + str(i) + '.h5') model_json = model.to_json() with open("networks/class" + str(i) + '.json', "w") as json_file: json_file.write(model_json) # self.models.append(model) self.learned = True
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 = config.checkpoint_path + config.checkpoint_name + '.h5' self.model.save_weights(h5_save_path) save_json_path = 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()
np.random.seed(10) myModel = Sequential() myModel.add(Dense(units=64, input_dim=39, activation='relu')) myModel.add(Dense(units=8, activation='relu')) myModel.add(Dense(1, activation='sigmoid')) myModel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) myModel.fit(x=trainDATA, y=trainLABLE, epochs=numOfEpoch, batch_size=64) # Save the trained model myModel_json = myModel.to_json() with open(jsonModelFILE, 'w') as json_file: json_file.write(myModel_json) myModel.save_weights(weightModelFILE) print("The trained model has been saved.") print("Start testing!") print("Time point 3 is " + str(time.time() - startTime)) # Load the trained model # Load the model with open(jsonModelFILE) as modelFile: model_json = modelFile.read() myModel = model_from_json(model_json) myModel.load_weights(weightModelFILE)
class Model: def __init__(self, use_glove=False): self.use_glove = use_glove self.model = None self.max_len = 15 self.embedding_size = 300 self.vocabulary_size = 10000 self.tokenizer = Tokenizer(num_words=self.vocabulary_size) self.log_dir = pathlib.Path('.log') / get_timestamp() self.log_dir.mkdir(parents=True, exist_ok=True) def build_model(self, embedding_initializer): self.model = Sequential() self.model.add(Embedding( input_dim=self.vocabulary_size, output_dim=self.embedding_size, input_length=self.max_len, embeddings_initializer=embedding_initializer if embedding_initializer is not None else 'uniform', trainable=embedding_initializer is None )) self.model.add(LSTM(32, return_sequences=True, dropout=0.3, kernel_regularizer=l2(0.001))) self.model.add(LSTM(32, dropout=0.3, kernel_regularizer=l2(0.001))) self.model.add(Dense(32, activation='relu', kernel_regularizer=l2(0.001))) self.model.add(Dense(1, activation='sigmoid')) def train(self, X_train, Y_train, X_val, Y_val, batch_size=32, epochs=10): self.tokenizer.fit_on_texts(X_train) # pickle word dictionary for later use with open('./checkpoints/tokenizer.pickle', 'wb') as handle: pickle.dump(self.tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL) encoded_train_titles = self.tokenizer.texts_to_sequences(X_train) encoded_val_titles = self.tokenizer.texts_to_sequences(X_val) X_train = encoded_train_titles X_val = encoded_val_titles X_train = pad_sequences(X_train, maxlen=self.max_len, value=0) X_val = pad_sequences(X_val, maxlen=self.max_len, value=0) word_index = self.tokenizer.word_index self.build_model(embedding_initializer=self.load_glove_embeddings(word_index) if self.use_glove else None) # ('Y_train mean:', np.mean(Y_train)) # print('Y_val mean:', np.mean(Y_val)) optimizer = Adam() callbacks = None if len(X_val) > 0: callbacks = [ keras.callbacks.EarlyStopping( monitor='val_acc', mode='max', verbose=1, patience=15, ), keras.callbacks.ModelCheckpoint( str(self.log_dir / 'best_model.hdf5'), monitor='val_acc', verbose=1, save_best_only=True, mode='max' ) ] self.model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) self.model.fit(X_train, Y_train, validation_data=(X_val, Y_val), batch_size=batch_size, epochs=epochs, callbacks=callbacks, verbose=0) self.model.save('./checkpoints/model') with (self.log_dir / 'arch.json').open('w') as handle: handle.write(self.model.to_json()) # scores = self.model.evaluate(X_val, Y_val, verbose=0) # print('val accuracy:', scores[1]) def load_glove_embeddings(self, word_index): print('Loading embeddings.') embeddings_index = {} embeddings_path = './data/glove.6B/glove.6B.' + str(self.embedding_size) + 'd.txt' if not pathlib.Path(embeddings_path).exists(): raise FileNotFoundError( 'Download glove embeddings from http://nlp.stanford.edu/data/glove.6B.zip (822 MB file) and unzzip\n' + 'Linux command:\n\n\t wget http://nlp.stanford.edu/data/glove.6B.zip; unzip glove.6B.zip' ) f = open(embeddings_path, encoding='utf-8') for line in f: values = line.split() word = values[0] coefs = np.asarray(values[1:], dtype='float32') embeddings_index[word] = coefs f.close() num_words = min(len(word_index), self.vocabulary_size) embedding_matrix = np.zeros((num_words + 1, self.embedding_size)) for word, i in word_index.items(): embedding_vector = embeddings_index.get(word) if embedding_vector is not None: # words not found in embedding index will be all-zeros. embedding_matrix[i] = embedding_vector print('Embeddings loaded.') return Constant(embedding_matrix) def load_model(self, path, dict_path): self.model = load_model(path) with open(dict_path, 'rb') as handle: self.tokenizer = pickle.load(handle) def classify(self, input): X = self.tokenizer.texts_to_sequences(input) X = pad_sequences(X, maxlen=self.max_len, value=0) return self.model.predict(X) def predict_classes(self, input): X = self.tokenizer.texts_to_sequences(input) X = pad_sequences(X, maxlen=self.max_len, value=0) return self.model.predict_classes(X)
class RNNKerasModelImpl(Model): MODEL_FILENAME = "model.json" def _restore_model(self, path): with open(os.path.join(path, RNNKerasModelImpl.MODEL_FILENAME)) as f: self.model = keras.models.model_from_json(f.read()) self.model.load_weights( os.path.join( path, "{}_{}.h5".format(Model.WEIGHTS_DEFAULT_FILENAME, Model.WEIGHTS_DEFAULT_ID))) self._update_output_size() keras.utils.print_summary(self.model) def _init_new_model(self, input_embedding_size, output_size): self.model = Sequential() self.model.add( Bidirectional(LSTM(self.model_config.rnn_size, return_sequences=True), input_shape=(self.model_config.sequence_length, input_embedding_size))) self.model.add(Reshape((-1, ))) self.model.add(Dense(output_size)) self.model.add(Activation('softmax')) opt = RMSprop(lr=0.001, decay=0.) self.model.compile(loss='categorical_crossentropy', optimizer=opt) self._update_output_size() keras.utils.print_summary(self.model) def __init__(self) -> None: super().__init__() self.model = None self.output_size = None def _update_output_size(self): self.output_size = self.model.layers[-1].output_shape[-1] def get_log_callback(self): pass def classify(self, frames): classes = self.model.predict(frames, batch_size=frames.shape[0]) return np.argmax(classes, 1) def train(self, x_batch, y_batch): y_batch = to_categorical(y_batch, self.output_size) return self.model.train_on_batch(x_batch, y_batch) def _save_model(self, config_dir): with open(os.path.join(config_dir, RNNKerasModelImpl.MODEL_FILENAME), "w") as f: f.write(self.model.to_json()) self.save_weights(config_dir, Model.WEIGHTS_DEFAULT_ID) def save_weights(self, config_dir, id=None) -> str: file_name = Model.WEIGHTS_DEFAULT_FILENAME if id is not None: file_name = "{}_{}".format(file_name, id) self.model.save_weights( os.path.join(config_dir, "{}.h5".format(file_name))) return file_name
class Player: """Mandatory class with the player methods""" def __init__(self, name='DQN', load_model=None, env=None): """Initiaization of an agent""" self.equity_alive = 0 self.actions = [] self.last_action_in_stage = '' self.temp_stack = [] self.name = name self.autoplay = True self.dqn = None self.model = None self.env = env if load_model: self.load(load_model) def initiate_agent(self, env): """initiate a deep Q agent""" tf.compat.v1.disable_eager_execution() self.env = env nb_actions = self.env.action_space.n self.model = Sequential() self.model.add( Dense(512, activation='relu', input_shape=env.observation_space)) self.model.add(Dropout(0.2)) self.model.add(Dense(512, activation='relu')) self.model.add(Dropout(0.2)) self.model.add(Dense(512, activation='relu')) self.model.add(Dropout(0.2)) self.model.add(Dense(nb_actions, activation='linear')) # Finally, we configure and compile our agent. You can use every built-in Keras optimizer and # even the metrics! memory = SequentialMemory(limit=memory_limit, window_length=window_length) policy = TrumpPolicy() class CustomProcessor(Processor): """The agent and the environment""" def process_state_batch(self, batch): """ Given a state batch, I want to remove the second dimension, because it's useless and prevents me from feeding the tensor into my CNN """ return np.squeeze(batch, axis=1) def process_info(self, info): processed_info = info['player_data'] if 'stack' in processed_info: processed_info = {'x': 1} return processed_info nb_actions = env.action_space.n self.dqn = DQNAgent(model=self.model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=nb_steps_warmup, target_model_update=1e-2, policy=policy, processor=CustomProcessor(), batch_size=batch_size, train_interval=train_interval, enable_double_dqn=enable_double_dqn) self.dqn.compile(tf.optimizers.Adam(lr=1e-3), metrics=['mae']) def start_step_policy(self, observation): """Custom policy for random decisions for warm up.""" log.info("Random action") _ = observation action = self.env.action_space.sample() return action def train(self, env_name): """Train a model""" # initiate training loop timestr = time.strftime("%Y%m%d-%H%M%S") + "_" + str(env_name) tensorboard = TensorBoard(log_dir='./Graph/{}'.format(timestr), histogram_freq=0, write_graph=True, write_images=False) self.dqn.fit(self.env, nb_max_start_steps=nb_max_start_steps, nb_steps=nb_steps, visualize=False, verbose=2, start_step_policy=self.start_step_policy, callbacks=[tensorboard]) # Save the architecture dqn_json = self.model.to_json() with open("dqn_in_json.json", "w") as json_file: json.dump(dqn_json, json_file) # After training is done, we save the final weights. self.dqn.save_weights('dqn_{}_weights.h5'.format(env_name), overwrite=True) # Finally, evaluate our algorithm for 5 episodes. self.dqn.test(self.env, nb_episodes=5, visualize=False) def load(self, env_name): """Load a model""" # Load the architecture with open('dqn_in_json.json', 'r') as architecture_json: dqn_json = json.load(architecture_json) self.model = model_from_json(dqn_json) self.model.load_weights('dqn_{}_weights.h5'.format(env_name)) def play(self, nb_episodes=5, render=False): """Let the agent play""" memory = SequentialMemory(limit=memory_limit, window_length=window_length) policy = TrumpPolicy() class CustomProcessor(Processor): """The agent and the environment""" def process_state_batch(self, batch): """ Given a state batch, I want to remove the second dimension, because it's useless and prevents me from feeding the tensor into my CNN """ return np.squeeze(batch, axis=1) def process_info(self, info): processed_info = info['player_data'] if 'stack' in processed_info: processed_info = {'x': 1} return processed_info nb_actions = self.env.action_space.n self.dqn = DQNAgent(model=self.model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=nb_steps_warmup, target_model_update=1e-2, policy=policy, processor=CustomProcessor(), batch_size=batch_size, train_interval=train_interval, enable_double_dqn=enable_double_dqn) self.dqn.compile(tf.optimizers.Adam(lr=1e-3), metrics=['mae']) self.dqn.test(self.env, nb_episodes=nb_episodes, visualize=render) def action(self, action_space, observation, info): # pylint: disable=no-self-use """Mandatory method that calculates the move based on the observation array and the action space.""" _ = observation # not using the observation for random decision _ = info this_player_action_space = { Action.FOLD, Action.CHECK, Action.CALL, Action.RAISE_POT, Action.RAISE_HALF_POT, Action.RAISE_2POT } _ = this_player_action_space.intersection(set(action_space)) action = None return action
def main(): training_images = load_data(train_data) tr_img_data = np.array([i[0] for i in training_images]).reshape(-1, 64, 64, 1) tr_lbl_data = np.array([i[1] for i in training_images]) model = Sequential() model.add(InputLayer(input_shape=[64, 64, 1])) model.add( Conv2D(filters=4, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add( Conv2D(filters=8, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add( Conv2D(filters=10, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add( Conv2D(filters=20, kernel_size=5, strides=1, padding='same', activation='relu')) model.add(MaxPool2D(pool_size=5, padding='same')) model.add(Dropout(rate=0.25)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dropout(rate=0.5)) model.add(Dense(2, activation='softmax')) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) datagen = preprocessing.image.ImageDataGenerator(rotation_range=10, width_shift_range=0.2, height_shift_range=0.2, zoom_range=0.2, shear_range=0.2) model.fit_generator(datagen.flow(tr_img_data, tr_lbl_data, batch_size=256), epochs=500) model.summary() # Save the weights model.save_weights('trained_model/model_weights.h5') # Save the model architecture with open('trained_model/model_architecture.json', 'w') as f: f.write(model.to_json()) test()
model.add(Conv1D(filters = 128, kernel_size = Ckernel_size, strides=Cstrides, padding=padding)) model.add(BatchNormalization()) model.add(Activation(activation = acti)) model.add(MaxPooling1D(pool_size=Ppool_size*2, strides=Pstrides*2, padding=padding)) model.add(Flatten()) model.add(Dense(1024)) model.add(Dense(y_train.shape[1], activation='softmax')) #compile model model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) #save model to json file model_json = model.to_json() with open("model/model_json.json", "w") as json_file: json_file.write(model_json) #callback funtion tensorboard = TensorBoard('tensorboard/log_model_{}'.format(int(time.time())), write_graph=True , write_images=True) checkpointer = ModelCheckpoint("./model/weights_best.h5", monitor='val_acc', verbose=1, save_best_only=True, mode='auto') print('===================================================') print('Start trainning CNN model') print('Run "tensorboard --logdir tensorboard" to view logs') print('===================================================') #fit model.fit(x_train, y_train, batch_size=32, epochs=50, verbose=1, validation_split = 0.2, callbacks= [tensorboard,checkpointer])
class QReplayNetworkModel(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). """ default_check_convergence_every = 200 # by default check for convergence every # episodes def __init__(self, game, **kwargs): """ Create a new prediction model for 'game'. :param class Maze game: maze game object :param kwargs: model dependent init parameters """ super().__init__(game, **kwargs) if kwargs.get("load", False) is False: self.model = Sequential() self.model.add( Dense(game.maze.size, input_shape=(2, ), activation="relu")) self.model.add(Dense(game.maze.size, activation="relu")) self.model.add(Dense(len(game.actions))) 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, stop_at_convergence=False, **kwargs): """ Train the model. :param stop_at_convergence: stop training as soon as convergence is reached 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 """ 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 = max(kwargs.get("episodes", 1000), 1) sample_size = kwargs.get("sample_size", 32) check_convergence_every = kwargs.get( "check_convergence_every", self.default_check_convergence_every) experience = ExperienceReplay(self.model, discount=discount) # 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() # training starts here 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)""" start_cell = (1, 1) 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) # action = random.choice(np.nonzero(q == np.max(q))[0]) action = self.predict(state) next_state, reward, status = self.environment.step(action) cumulative_reward += reward experience.remember( [state, action, reward, next_state, status]) if status in ( Status.WIN, Status.LOSE): # terminal state reached, stop episode 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 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.name, loss, exploration_rate)) if episode % check_convergence_every == 0: # check if the current model does win from all starting cells # only possible if there is a finite number of starting states w_all, win_rate = self.environment.check_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 logging.info("episodes: {:d} | time spent: {}".format( episode, datetime.now() - start_time)) 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. """ if type(state) == tuple: state = np.array(state, ndmin=2) 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: selected action """ q = self.q(state) logging.debug("q[] = {}".format(q)) actions = np.nonzero( q == np.max(q))[0] # get index of the action(s) with the max value return random.choice(actions)
# Encoder lstm_autoencoder.add( LSTM(32, activation='relu', input_shape=(timesteps, n_features), return_sequences=True)) lstm_autoencoder.add(LSTM(16, activation='relu', return_sequences=False)) lstm_autoencoder.add(RepeatVector(timesteps)) # Decoder lstm_autoencoder.add(LSTM(16, activation='relu', return_sequences=True)) lstm_autoencoder.add(LSTM(32, activation='relu', return_sequences=True)) lstm_autoencoder.add(TimeDistributed(Dense(n_features))) lstm_autoencoder.summary() with open('checkpoints/model.json', 'w') as f: f.write(lstm_autoencoder.to_json()) adam = optimizers.Adam(lr) lstm_autoencoder.compile(metrics=['accuracy'], loss='mse', optimizer='adam') cp = ModelCheckpoint("checkpoints/weights.h5", save_best_only=True) tb = TensorBoard() es = EarlyStopping(patience=patience) history = lstm_autoencoder.fit(X_train_y0_scaled, X_train_y0_scaled, epochs=epochs, batch_size=batch, validation_data=(X_valid_y0_scaled, X_valid_y0_scaled), verbose=2,
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(3,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')
def build_model(): model = Sequential() model.add( Conv2D(filters=32, kernel_size=(3, 3), activation="relu", padding="same", input_shape=(256, 256, 1))) model.add( Conv2D(filters=32, kernel_size=(3, 3), activation="relu", padding="same")) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(rate=0.25)) model.add( Conv2D(filters=64, kernel_size=(3, 3), activation="relu", padding="same")) model.add( Conv2D(filters=64, kernel_size=(3, 3), activation="relu", padding="same")) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(rate=0.25)) model.add(Flatten()) model.add(Dense(1024, activation="relu")) model.add(BatchNormalization()) model.add(Dropout(rate=0.4)) model.add(Dense(6, activation="softmax")) gen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) train_batches = gen.flow_from_directory("runes/mutated", model.input_shape[1:3], color_mode="grayscale", shuffle=True, seed=1, batch_size=16) valid_batches = gen.flow_from_directory("runes/validation", model.input_shape[1:3], color_mode="grayscale", shuffle=True, seed=1, batch_size=16) test_batches = gen.flow_from_directory("runes/testing", model.input_shape[1:3], shuffle=False, color_mode="grayscale", batch_size=8) model.compile(Adam(lr=0.001), loss="categorical_crossentropy", metrics=["accuracy"]) history1 = model.fit_generator(train_batches, steps_per_epoch=163, epochs=5, validation_data=valid_batches, validation_steps=624) p = model.predict_generator(test_batches, verbose=True) # recall_score(pre["label"], pre["pre"]) #roc_auc_score(pre["label"], pre[1]) #true_positive_rate, false_positive_rate, threshold = roc_curve(pre["label"], pre[1]) # roc = DataFrame([true_positive_rate, false_positive_rate]).T # roc.plot(x=0,y=1) plt.plot(history1.history['accuracy']) plt.plot(history1.history['val_accuracy']) plt.axhline(0, color="black") plt.axvline(0, color="black") plt.title('Model Accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Training set', 'Validation set'], loc='upper left') plt.show() plt.plot(history1.history['val_loss']) plt.plot(history1.history['loss']) plt.axhline(0, color="black") plt.axvline(0, color="black") plt.title('Model Loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Training set', 'Test set'], loc='upper left') plt.show() model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) model.save_weights_only = False model.save_weights("keras_model.h5")
def main(stock, r=0.1, s=0.1): result_dir = 'res_mlp_pca' data_length = 24000 svm_gdf_res = gdf_pca.SvmGdfResults( stock, r=r, s=s, data_length=data_length, gdf_filename_pattern='gdf_{}_r{}_s{}_K50') feature_name = 'pca_n_gdf_que' n = svm_gdf_res.get_pca(feature_name).n_components hidden_layer_sizes = [(n, ), (n, n), (2 * n, n), (2 * n, 2 * n), (n, 2 * n), (n, n, n)] weights = svm_gdf_res.get_classes_weights() epochs = 10 batch_size = 300 filename = os.path.join( result_dir, 'mlp_pca_gdf_{}_len{}_r{}_s{}.csv'.format(stock, data_length, r, s)) if os.path.exists(filename): print(f'Exists {filename}') return filename_partial = os.path.join( result_dir, 'mlp_pca_gdf_{}_len{}_r{}_s{}.csv_partial'.format( stock, data_length, r, s)) df_partial = pd.DataFrame() if os.path.exists(filename_partial): print(f'Reading partial file {filename_partial}') df_partial = pd.read_csv(filename_partial) for hidden_layer_size in hidden_layer_sizes: for learning_rate in [0.001 ]: #[0.00001, 0.0001, 0.001, 0.01, 0.1, 1.0]: if np.any(df_partial): print(filename_partial) row = df_partial[df_partial['hidden_layer_sizes'] == hidden_layer_size] if np.any(row) and len(row) >= 1: print(row) row = df_partial[ df_partial['hidden_layer_sizes'] == hidden_layer_size][ df_partial['learning_rate'] == learning_rate] print(row) if np.any(row): print( f'Read result for hidden layer {hidden_layer_size} lr {learning_rate} in {filename_partial}' ) continue print( f'Training {stock} {r} {s} {hidden_layer_size} {learning_rate}' ) solver = optimizers.Adam(lr=learning_rate) model = Sequential() if isinstance(hidden_layer_size, int): model.add(Dense(hidden_layer_size)) else: for h in hidden_layer_size: model.add(Dense(h)) model.add(Dense(1, activation='sigmoid')) plot_name = f'plot_mlp/{stock}_mlp_pca_n_r{r}_s{s}' score = svm_gdf_res.train_mlp(model, feature_name=feature_name, method='mlp', fit_kwargs={ 'epochs': epochs, 'batch_size': batch_size, 'verbose': 0, 'shuffle': False }, compile_kwargs={ 'loss': 'binary_crossentropy', 'optimizer': solver, 'metrics': [auc_roc, 'acc'] }, plot_name=plot_name, class_weight=weights) score = { **score, 'r': r, 's': s, 'arch': model.to_json(), 'epochs': epochs, 'batch_size': batch_size } score = { 'solver': solver, 'hidden_layer_sizes': hidden_layer_size, 'learning_rate': learning_rate, **score } df_partial = df_partial.append(pd.DataFrame([score]), ignore_index=True) df_partial.index = list((range(len(df_partial)))) # df_partial.drop(columns=[[c for c in df_partial.columns if 'Unnamed' in c]], inplace=True) df_partial.to_csv(filename_partial) df_partial.to_csv(filename) return True
X_test = X_test.reshape(-1,96,96) print("X_test", X_test.shape) model = Sequential() # x = (7049,96,96) # y = (7049,30) model.add(Flatten(input_shape= (96,96))) model.add(Dense(128,activation = "relu")) model.add(Dropout(0.1)) model.add(Dense(64,activation = "relu")) model.add(Dense(30)) model.compile(optimizer = 'adam', loss = 'mse', metrics = ['mae','accuracy']) model.fit(X_train,y_train,epochs = 50, batch_size = 128,validation_split = 0.2) model.save('model.h5') json_string = model.to_json() model = model_from_json(json_string) model.load_weights('model.h5',by_name = True) model.load_model('model.h5') def loaded_model(): model = load_model('model.h5') return model def show_results(images_index): pred = model.predict(X_test[images_index:(images_index+1)]) show_images(X_test[images_index], pred[0]) show_images(3)
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(100, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))) self.model.add(Bidirectional(LSTM(20, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))) self.model.add(TimeDistributed(Dense(17, activation='softmax'))) 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=150,validation_split=0.1,batch_size=128) pass def test_model(self): Y_pred = self.model.predict(self.X_test) 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)): #Y_t_one = [] 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_testing.append(Y_t_one) Y_pred_F = [] for i in range(0,len(Y_pred)): #Y_pred_one = [] 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_pred_F.append(Y_pred_one) print(metrics.classification_report(Y_testing, Y_pred_F,labels)) def save_mode(self): self.model.save_weights("model.h5") model_json = self.model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 self.model.save_weights("model.h5") print("Saved model to disk") pass
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()
class Mediapipe_Detector(): def __init__(self, X_train, Y_train, X_test, Y_test): # Importing package for training and running models self.path = data_set_path self.classifier = None self.X_train = X_train self.Y_train = Y_train self.X_test = X_test self.Y_test = Y_test def label_encoder(self): encoder = LabelEncoder() encoder.fit(self.Y_train) Y_train_encoded = encoder.transform(self.Y_train) self.Y_train = np_utils.to_categorical(Y_train_encoded) encoder.fit(self.Y_test) Y_test_encoded = encoder.transform(self.Y_test) self.Y_test = np_utils.to_categorical(Y_test_encoded) def train(self): # if os.path.exists(model_weight_name) and os.path.exists(model_structure_name): # # Loading the model ####################################### # json_file = open(model_structure_name, 'r') # classifier_json = json_file.read() # json_file.close() # self.classifier = model_from_json(classifier_json) # self.classifier.load_weights(model_weight_name) # else: # # # Building the dense layer model ####################################### # # self.classifier = Sequential() # # self.classifier.add(Dense(20, activation='relu', # # kernel_initializer='random_normal', # # input_dim=10)) # # # self.classifier.add(Conv1D(100, 2, 2, activation='relu', # # # kernel_initializer='relu')) # # self.classifier.add(Dense(12, activation='relu', # # kernel_initializer='random_normal')) # # self.classifier.add(Dense(10, activation='relu', # # kernel_initializer='random_normal')) # Building the CNN layer model ######################## self.classifier = Sequential() self.classifier.add( Conv1D(1000, 2, strides=2, padding='valid', activation='relu', use_bias=True, kernel_initializer='random_normal', input_shape=(15, 1), name='convolution_1d_layer_1')) self.classifier.add( Conv1D(1000, 5, padding='valid', activation='relu', use_bias=True, kernel_initializer='random_normal', name='convolution_1d_layer_2')) self.classifier.add(Flatten(name='reshape_layer')) self.classifier.add( Dense( 100, kernel_initializer='random_normal', # bias_initializer=' random_normal', use_bias=True, name='full_connect_layer_1', activation='softmax')) # self.classifier.add(Dropout(0.5)) self.classifier.add( Dense( 10, kernel_initializer='random_normal', # bias_initializer=' random_normal', use_bias=True, name='full_connect_layer_2', activation='softmax')) self.classifier.compile( optimizer=Adam(adam_lr), # loss='binary_crossentropy', loss='categorical_crossentropy', metrics=['accuracy']) # Record acc on the log ################################# losshistory = LossHistory() # Saving the model if the validation loss decresed checkpointer = ModelCheckpoint(filepath=model_weight_name, verbose=1, save_best_only=True) # Fitting/training the model ############################## self.label_encoder() print(self.Y_train) # just for test self.classifier.fit(self.X_train, self.Y_train, epochs=2000, validation_data=(self.X_test, self.Y_test), callbacks=[checkpointer, losshistory], batch_size=80) # Reporting loss history ################################## print(losshistory.losses) # Serializing model to JSON ############################## classifier_json = self.classifier.to_json() with open(model_structure_name, 'w') as json_file: json_file.write(classifier_json)
class Training(): def __init__(self, name_pickle): dataset = pd.read_pickle(name_pickle) data = pd.DataFrame(dataset) self.data = data.sample(frac=1) def split_data(self, nb_features=54): '''Split dataset into training and testing data Input: dataset, number of features to take into account ''' # Creating input features and target variables X = self.data.iloc[:, :nb_features] y = self.data.iloc[:, -1] self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=0.2, shuffle=True) # Create pickle file with the input matrix with open('data_test.pkl', 'wb') as f: pickle.dump([self.X_test, self.y_test] , f, 2) def buildDNN(self, hidden_layers=2): '''Building the architecture of the network (perceptron) Input: number of hidden layers ''' self.classifier = Sequential() # First Layer self.classifier.add(Dense(54, kernel_regularizer=l2(0.0001), bias_regularizer=l2(0.0007), activation='tanh', kernel_constraint=unit_norm(), kernel_initializer='random_normal', input_dim=54)) self.classifier.add(Dropout(0.8)) # Hidden Layer(s) for nbLayer in range(hidden_layers - 1): self.classifier.add(Dense(54, kernel_regularizer=l2(0.0001), bias_regularizer=l2(0.0007), activation='tanh', kernel_initializer='random_normal')) self.classifier.add(Dropout(0.8)) # Output Layer self.classifier.add(Dense(1, activation='sigmoid', kernel_initializer='random_normal')) #try: #load weights # self.classifier.load_weights("weights.best.hdf5") #except e: # pass # Optimizer adam = optimizers.Adam(lr=0.001) # Compiling the neural network self.classifier.compile(optimizer=adam, loss='binary_crossentropy', metrics =['accuracy']) def train(self, epochNb=1000): '''Train the network Input: Number of epochs Output: Save a json and h5 file with the weights ''' logdir = "tensorboard/keras_model/" + datetime.now().strftime("%Y%m%d-%H%M%S") tensorboard_callback = TensorBoard(log_dir=logdir) # checkpoint filepath="weights.best.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min') callbacks_list = [checkpoint] # Fitting the data to the training dataset self.history = self.classifier.fit(self.X_train, self.y_train, validation_split=0.20, callbacks=callbacks_list, batch_size=32, epochs=epochNb) # Save model as json file model_json = self.classifier.to_json() with open("model.json", "w") as f: f.write(model_json) f.close() # serialize weights to HDF5 self.classifier.save_weights("model.h5") print("\nModel train and saved as 'model.json' and 'model.h5'") def plot_acc(self, all=None): '''Plot of the accuracy after training ''' # summarize history for accuracy plt.plot(self.history.history['acc']) plt.plot(self.history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') if not all: plt.show() def plot_loss(self): '''Plot of the loss after training ''' # summarize history for loss plt.plot(self.history.history['loss']) plt.plot(self.history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper left') plt.show() def plot_all(self): '''Plot of the accuracy and loss (combination of plot_loss and plot_acc) after training ''' plt.figure() plt.subplot(1,2,1) self.plot_acc(True) plt.subplot(1,2,2) self.plot_loss()
class QReplayNetworkModel(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, env, **kwargs): super().__init__(env, **kwargs) if kwargs.get("load", False) is False: self.model = Sequential() print(env.maze.size) self.model.add( Dense(env.maze.size, input_shape=(2, ), activation="relu")) self.model.add(Dense(env.maze.size, activation="relu")) self.model.add(Dense(len(actions))) 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, stop_at_convergence=False, **kwargs): 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) sample_size = kwargs.get("sample_size", 32) experience = ExperienceReplay(discount=discount) # variables for reporting purposes cumulative_reward = 0 cumulative_reward_history = [] win_history = 0 start_list = list() # starting cells not yet used for training start_time = datetime.now() for episode in range(1, episodes + 1): state = self.environment.reset() loss = 0.0 while True: if np.random.random() < exploration_rate: action = random.choice(self.environment.actions) else: print(state) action = self.predict(state) print(state) next_state, reward, status = self.environment.act(action) cumulative_reward += reward experience.remember( [state, action, reward, next_state, status]) if status in ("win", "lose"): # terminal state reached, stop episode if status == "win": win_history += 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 # 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 % 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) # 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 logging.info("episodes: {:d} | time spent: {}".format( episode, datetime.now() - start_time)) 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. """ 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. """ print("asdasd") q = self.q(state) print("asdasd") logging.debug("q[] = {}".format(q)) actions = np.nonzero( q == np.max(q))[0] # get index of the action(s) with the max value return random.choice(actions)
class NER_BiLSTM_Glove_i2b2(object): """Class that implements and performs named entity recognition using BiLSTM neural network architecture. The architecture uses GloVe embeddings trained on common crawl dataset. Then the algorithm is trained on i2b2 2014 dataset. """ def __init__(self): """Implementation of initialization""" # load json and create model self.model = None if os.path.exists('Models/BiLSTM_Glove_de_identification_model.json'): json_file = open( 'Models/BiLSTM_Glove_de_identification_model.json', 'r') loaded_model_json = json_file.read() json_file.close() self.model = model_from_json(loaded_model_json) self.GLOVE_DIR = "Resources/" if os.path.isdir(self.GLOVE_DIR) == False or os.path.isfile( self.GLOVE_DIR + "glove.840B.300d.txt") == False: if os.path.exists(self.GLOVE_DIR) == False: os.mkdir(self.GLOVE_DIR) print('Beginning file download with urllib2...') url = 'http://nlp.stanford.edu/data/glove.840B.300d.zip' urllib.request.urlretrieve(url, self.GLOVE_DIR + 'glove.840B.300d.zip') with ZipFile(self.GLOVE_DIR + 'glove.840B.300d.zip', 'r') as zipObj: # Extract all the contents of zip file in current directory zipObj.extractall(self.GLOVE_DIR) os.remove(self.GLOVE_DIR + "glove.840B.300d.zip") # load weights into new model self.model.load_weights( "Models/BiLSTM_Glove_de_identification_model.h5") print("Loaded model from disk") self.model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) self.word_index = pickle.load(open("Models/word_index.pkl", "rb")) self.MAX_SEQUENCE_LENGTH = 200 self.EMBEDDING_DIM = 300 self.MAX_NB_WORDS = 2200000 def build_tensor2(self, sequences, numrecs, word2index, maxlen, makecategorical=False, num_classes=0, is_label=False): """ Function to create tensors out of sequences :param sequences: Sequences of words :param numrecs: size of the tensor :param word2index: mapping between words and its numerical representation (index). Loaded from file :param maxlen: Maximal lenght of the sequence :param makecategorical: Not used :param num_classes: Not used :param is_label: Not used, leave default for action performing :return: """ data = np.empty((numrecs, ), dtype=list) label_index = {'O': 0} label_set = [ "DATE", "LOCATION", "NAME", "ID", "AGE", "CONTACT", "PROFESSION", "PHI" ] 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(sequences, desc='Building tensor'): wids = [] pl = [] for word, label in sent: if is_label == False: if word in word2index: wids.append(word2index[word]) else: wids.append(word2index['the']) else: pl.append(label_index[label]) plabels.append(pl) if not is_label: data[i] = wids i += 1 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 def build_tensor(self, sequences, numrecs, word2index, maxlen, makecategorical=False, num_classes=0, is_label=False): """ Function to create tensors out of sequences :param sequences: Sequences of words :param numrecs: size of the tensor :param word2index: mapping between words and its numerical representation (index). Loaded from file :param maxlen: Maximal lenght of the sequence :param makecategorical: Not used :param num_classes: Not used :param is_label: Not used, leave default for action performing :return: """ data = np.empty((numrecs, ), dtype=list) label_index = {'O': 0} label_set = [ "DATE", "LOCATION", "NAME", "ID", "AGE", "CONTACT", "PROFESSION", "PHI" ] 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(sequences, desc='Building tensor'): wids = [] pl = [] for word in sent: if is_label == False: if word[0] in word2index: wids.append(word2index[word[0]]) else: wids.append(word2index['the']) plabels.append(pl) if not is_label: data[i] = wids i += 1 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 def transform(self, sequence): X = self.build_tensor(sequence, len(sequence), self.word_index, 70) Y = self.build_tensor(sequence, len(sequence), self.word_index, 70, True, 9, True) def perform_NER(self, text): """ Function that perform BiLSTM-based NER :param text: Text that should be analyzed and tagged :return: returns sequence of sequences with labels """ sequences = tokenize_fa([text]) word_sequences = [] X_test = [] tokens = [] for seq in sequences: features_seq = [] sentence = [] for i in range(0, len(seq)): features_seq.append(seq[i][0]) tokens.append(seq[i][0]) sentence.append(seq[i][0]) X_test.append(sentence) word_sequences.append(sentence) tensor = self.build_tensor(sequences, len(sequences), self.word_index, 70) predictions = self.model.predict(tensor) Y_pred_F = [] for i in range(0, len(predictions)): seq = [] for j in range(0, len(predictions[i])): max_k = 0 max_k_val = 0 max_str = "" for k in range(0, len(predictions[i][j])): if predictions[i][j][k] > max_k_val: max_k_val = predictions[i][j][k] max_k = k if max_k == 0: max_str = "O" elif max_k == 1: max_str = "DATE" elif max_k == 2: max_str = "LOCATION" elif max_k == 3: max_str = "NAME" elif max_k == 4: max_str = "ID" elif max_k == 5: max_str = "AGE" elif max_k == 6: max_str = "CONTACT" elif max_k == 7: max_str = "PROFESSION" elif max_k == 8: max_str = "PHI" seq.append(max_str) Y_pred_F.append(seq) final_sequences = [] for j in range(0, len(Y_pred_F)): sentence = [] for i in range( len(Y_pred_F[j]) - len(sequences[j]), len(Y_pred_F[j])): sentence.append( (sequences[j][i - (len(Y_pred_F[j]) - len(sequences[j]))][0], Y_pred_F[j][i])) final_sequences.append(sentence) return final_sequences def createModel(self, text, GLOVE_DIR): self.embeddings_index = {} if os.path.isdir(GLOVE_DIR) == False or os.path.isfile( GLOVE_DIR + "glove.840B.300d.txt") == False: print('Beginning GloVe file download with urllib2...') url = 'http://nlp.stanford.edu/data/glove.840B.300d.zip' if os.path.exists(self.GLOVE_DIR) == False: os.mkdir(self.GLOVE_DIR) urllib.request.urlretrieve(url, self.GLOVE_DIR + 'glove.840B.300d.zip') with ZipFile(self.GLOVE_DIR + 'glove.840B.300d.zip', 'r') as zipObj: # Extract all the contents of zip file in current directory zipObj.extractall(GLOVE_DIR) os.remove(self.GLOVE_DIR + "glove.840B.300d.zip") f = open(os.path.join(GLOVE_DIR, 'glove.840B.300d.txt'), encoding='utf') for line in f: values = line.split() word = ''.join(values[:-300]) coefs = np.asarray(values[-300:], 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) self.word_index = tokenizer.word_index pickle.dump(self.word_index, open("word_index.pkl", 'wb')) 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 self.embedding_layer = Embedding(len(self.word_index) + 1, self.EMBEDDING_DIM, weights=[self.embedding_matrix], input_length=70, trainable=True) self.model = Sequential() self.model.add(self.embedding_layer) self.model.add( Bidirectional( LSTM(150, dropout=0.3, recurrent_dropout=0.6, return_sequences=True)) ) #{'sum', 'mul', 'concat', 'ave', None} self.model.add( Bidirectional( LSTM(60, dropout=0.2, recurrent_dropout=0.5, return_sequences=True))) self.model.add(TimeDistributed(Dense( 9, activation='softmax'))) # a dense layer as suggested by neuralNer self.model.compile(loss="categorical_crossentropy", optimizer='rmsprop', metrics=['accuracy']) self.model.summary() pass def transform_sequences(self, token_sequences): text = [] for ts in token_sequences: for t in ts: text.append(t[0]) self.createModel(text, self.GLOVE_DIR) X = self.build_tensor2(token_sequences, len(token_sequences), self.word_index, 70) Y = self.build_tensor2(token_sequences, len(token_sequences), self.word_index, 70, True, 9, True) return X, Y def learn(self, X, Y, epochs=1): self.model.fit(X, Y, epochs=epochs, validation_split=0.1, batch_size=64) def evaluate(self, X, Y): Y_pred = self.model.predict(X) from sklearn import metrics labels = [1, 2, 3, 4, 5, 6, 7, 8, 9] 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(Y)): for j in range(0, len(Y[i])): max_k = 0 max_k_val = 0 for k in range(0, len(Y[i][j])): if Y[i][j][k] > max_k_val: max_k_val = Y[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(self, model_path): # serialize model to JSON model_json = self.model.to_json() with open("Models\\" + model_path + ".json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 self.model.model.save_weights("Models\\" + model_path + ".h5") print("Saved model to disk")
# plotting the metrics fig = plt.figure() plt.subplot(2, 1, 1) plt.plot(model_log.history['acc']) plt.plot(model_log.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='lower right') plt.subplot(2, 1, 2) plt.plot(model_log.history['loss']) plt.plot(model_log.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'test'], loc='upper right') plt.tight_layout() fig #Save the model # serialize model to JSON model_digit_json = model.to_json() with open("model_digit.json", "w") as json_file: json_file.write(model_digit_json) # serialize weights to HDF5 model.save_weights("model_digit.h5") print("Saved model to disk")
class QReplayDoublePrior(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 = (2, ) if kwargs.get("load", False) is False: print(len(self.environment.empty)) self.model = Sequential() self.model.add( Dense(len(self.environment.empty) * 4, input_shape=self.state_size, activation="relu")) self.model.add( Dense(len(self.environment.empty) * 2, 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(len(self.environment.empty) * 4, input_shape=self.state_size, activation="relu")) self.target_model.add( Dense(len(self.environment.empty) * 2, 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 experience.maze = self.game.maze experience.cells = self.game.cells experience.exit_cell = self.game.exit_cell experience.state_size = self.state_size experience.walls = self.game.walls # 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] * 15 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) cumulative_reward += reward experience.remember(state, action_index, reward, next_state, 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 % 5 == 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. """ 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
eval_model=classifier.evaluate(X_train, y_train) print("\n\t eval_model=",eval_model) y_pred=classifier.predict(X_test) #print("\n\t y_test=",type(y_test),"\t y_pred=",type(y_pred)) y_pred =(y_pred>0.5) #y_pred=pd.Series(y_pred) ''' saving model ''' model_json=classifier.to_json() with open("/home/kapitsa/PycharmProjects/upwork/models//model.json","w") as json_file: json_file.write(model_json) classifier.save_weights("/home/kapitsa/PycharmProjects/upwork/models//model.h5") ''' ''' from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) print(cm) print("2.cm=",cm)