def __init__(self, game: GridGame): super().__init__(game) # game params self.board_height = game.board_height self.board_width = game.board_width example_board = game.create_board() self.action_size = len(game.get_valid_moves(example_board)) self.epochs_completed = 0 self.epochs_to_train = 100 args = Namespace(lr=0.001, dropout=0.3, epochs=10, batch_size=64, num_channels=512) self.checkpoint_name = 'random weights' self.args = args num_channels = 512 kernel_size = [3, 3] dropout = 0.3 model = Sequential() # regularizer = regularizers.l2(0.00006) regularizer = regularizers.l2(0.0001) model.add(Conv2D(num_channels, kernel_size, padding='same', activation='relu', input_shape=(self.board_height, self.board_width, 1), activity_regularizer=regularizer)) model.add(Conv2D(num_channels, kernel_size, padding='same', activation='relu', activity_regularizer=regularizer)) model.add(Conv2D(num_channels, kernel_size, activation='relu', activity_regularizer=regularizer)) model.add(Conv2D(num_channels, kernel_size, activation='relu', activity_regularizer=regularizer)) model.add(Dropout(dropout)) model.add(Dropout(dropout)) model.add(Flatten()) model.add(Dense(self.action_size + 1)) model.compile('adam', 'mean_squared_error') self.model = model
batch_size=batch_size) model = Sequential() model.add( SeparableConv1D(30, kernel_size_first_layer, input_shape=(peek_interval_days, 1), activation="relu")) model.add(AveragePooling1D()) model.add(SeparableConv1D(10, kernel_size_second_layer, activation="relu")) model.add(AveragePooling1D()) model.add(SeparableConv1D(3, kernel_size_third_layer, activation="relu")) model.add(GlobalAveragePooling1D()) model.add(Dense(1, activation="sigmoid")) model.compile(optimizer=Adam(), loss="binary_crossentropy", metrics=["accuracy"]) model.build() model.summary() history = model.fit_generator( train_generator, epochs=1, validation_data=validation_generator, class_weight={ 0: 0.5, # false 1: 0.5 # true }, callbacks=[EarlyStopping(monitor="val_loss", patience=5)]) def plot_history(history):
#Custom loss function def my_cat_crossentropy(target,output,from_logits=False,axis=-1): return tf.nn.softmax_cross_entropy_with_logits_v2(labels=target,logits=output) my_batch_size = 20 #Model defintion: my_model = Sequential() my_model.add(Dense(15, input_dim=30, kernel_initializer='glorot_normal')) my_model.add(Dropout(0.1)) my_model.add(Dense(2, kernel_initializer='glorot_normal',kernel_regularizer=tf.keras.regularizers.l2(l=0.01))) #Training model using multi-stage optimiser: #Stage 1 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.005,beta1=0.85,beta2=0.95), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=100, verbose=VERBOSE, shuffle=True) #Stage 2 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.001,beta1=0.9,beta2=0.99), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=150, verbose=VERBOSE, shuffle=True)# new #Stage 3 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.0005,beta1=0.9,beta2=0.99), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=200, verbose=VERBOSE, shuffle=True)# new #Stage 4 my_model.compile(optimizer=tf.train.AdamOptimizer(learning_rate=0.0001,beta1=0.9,beta2=0.99), loss=my_cat_crossentropy, metrics=['accuracy']) my_model.fit(x=X_train, y=Y_train, batch_size=my_batch_size, epochs=250, verbose=VERBOSE, shuffle=True)# new #Evaluate model on training data
end = n_samples batch_xs = nextBatch(train_x[start:end, :], n_outputs) batch_ys = np.reshape(train_y[start:end], (int(batch_size / n_outputs), n_outputs)) yield batch_xs, batch_ys start = datetime.datetime.now() config = tf.ConfigProto() config.gpu_options.allow_growth = True session = tf.Session(config=config) KTF.set_session(session) # mlp.compile(optimizer=Adam(learning_rate=lr), mlp.compile(optimizer=Adam(lr=lr), loss=my_loss, metrics=[my_metric], ) # file_name_trained = '/home/yezhizi/Documents/TianchiMetro/code/ckpt/lr: 0.0001-batch_size: 93312-l2_param: 0.01-dropout: 0.8-training_epochs: 10000-n_inputs: 239-n_outputs: 3-n_hidden: []-n_mlp: [400, 400, 400]-n_samples2146176-weights[10000, 100, 1]/mlp-ep7600-loss88.766-val_loss98.917-lr: 0.0001-batch_size: 93312-l2_param: 0.01-dropout: 0.8-training_epochs: 10000-n_inputs: 239-n_outputs: 3-n_hidden: []-n_mlp: [400, 400, 400]-n_samples2146176-weights[10000, 100, 1].h5' # mlp.load_weights(file_name_trained) if mode == constants.TRAIN: steps_per_epoch = int(np.ceil(n_samples / batch_size)) check_point = ModelCheckpoint(file_name, monitor='val_my_metric', verbose=0, save_best_only=True, save_weights_only=False, mode='auto', period=1) tensor_board = TensorBoard(log_dir='logs/' + file_name[:-3] + '/', histogram_freq=0, write_graph=True, write_images=False) result = mlp.fit_generator(generator=generator(steps_per_epoch), steps_per_epoch=steps_per_epoch,
)) model.add(Conv2D(64, 3, strides=2, padding='same', activation='relu')) model.add(MaxPooling2D(2, 2, 'same')) model.add(Conv2D(128, 3, strides=2, padding='same', activation='relu')) model.add(MaxPooling2D(2, 2, 'same')) #把第二个池化层的输出扁平化为1维 model.add(Flatten()) model.add(Dense(1024, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(10, activation='softmax')) # 定义优化器 sgd = SGD(lr=0.01) # 定义优化器,loss function,训练过程中计算准确率 model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) model.fit(x_train_data, y_train_data, batch_size=64, epochs=100) # 评估模型 loss, accuracy = model.evaluate(x_test_data, y_test_data) model_path = "./weights/mnist_cnn.h5" model.save(model_path, include_optimizer=False, save_format='h5') print('test loss', loss) print('test accuracy', accuracy)
model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.43404126142165134)) model.add(Flatten()) model.add(Dense(256, activation='sigmoid')) model.add(Dropout(0.6975075528853121)) model.add(Dense(2, activation='softmax')) model.summary() # Model compilation and training model.compile(loss='categorical_crossentropy', optimizer="adam", metrics=["accuracy"]) hist = model.fit(X_train, y_train, epochs=7, batch_size=256, shuffle=True, validation_data=(X_test, y_test)) # Illustration of loss per epoch plt.plot(hist.history['loss']) plt.plot(hist.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'Val'], loc='upper right') plt.show() # Illustration of accuracy per epoch plt.plot(hist.history['accuracy'])
"""### Applying CNN""" from tensorflow.python.keras.layers import Dense from tensorflow.python.keras import Sequential from tensorflow.python.keras.optimizers import Adam model = Sequential([ Dense(16, input_shape=(46, ), activation='relu'), Dense(32, activation='relu'), Dense(3, activation='softmax') ]) model.summary() model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, batch_size=10, epochs=15) y_pred = model.predict_classes(x_val) y_pred np.array(list(y_val['relevance'])) from sklearn.metrics import accuracy_score accuracy_score(np.array(list(y_val['relevance'])), y_pred) y_pred_test = model.predict_classes(x_test)
from tensorflow.python.keras.layers import Dense # 1.load training/test data dataset = np.loadtxt('./dataset/pimaindians-diabetes.csv', delimiter=',') x = np.array(dataset[:, 0:8]) t = np.array(dataset[:, 8]) # print(x.shape, t.shape) # 2. model frame config model = Sequential() model.add(Dense(50, input_dim=x.shape[1], activation='relu')) model.add(Dense(1, activation='sigmoid')) # 3. model fitting config model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # 4. model fitting history = model.fit(x, t, epochs=200, batch_size=10) # 5. result loss = history.history['loss'] result = model.evaluate(x, t, verbose=0) print(f'\n(Loss, Accuracy)=({result[0], result[1]})') # 6. predict data = np.array([[13, 106, 72, 54, 0, 36.6, 0.178, 45]]) predict = model.predict(data) percentage = float(predict[0] * 100) print(f'\n당뇨 발병 확률:{percentage:.2f}%')
class RegressionSeries: def readcsv(self, path): df = pd.read_csv(path, sep=';', parse_dates={'dt': ['Date', 'Time']}, infer_datetime_format=True, low_memory=False, index_col='dt') return df def data_collection(self, df): active_values = [] start_index = [] end_index = [] rows = df.shape[0] for i in range(rows): val = df.iloc[i, 0] if val == '?' or val == 'nan': if len(active_values) - 60 >= 0: start_index.append(i - 60) end_index.append(i - 1) else: start_index.append(0) if i == 0: end_index.append(0) else: end_index.append(i - 1) else: active_values.append(val) return active_values, start_index, end_index def prepare_data(self, active_values): training = [] labels = [] for i in range(len(active_values)): # print(i) if i + 60 < len(active_values): arr = active_values[i:i + 60] # print(len(arr)) training.append(arr) labels.append(active_values[i + 60]) else: break #print("trainging= ", len(training)) training = np.asarray(training) #print("trining np = ", training.shape) labels = np.array(labels) return training, labels def train(self, train_data, labels): train_set = train_data train_labels = labels # print(train_set.shape) # print(train_labels.shape) # print(type(train_set[0])) self.model = Sequential() self.model.add(Dense(100, activation="tanh", input_dim=60)) self.model.add(Dense(70, activation="relu")) self.model.add(Dense(30, activation="relu")) self.model.add(Dense(1)) self.model.compile(optimizer="adam", loss="mse", metrics=['mse', 'mae', 'mape']) self.model.fit(train_set, train_labels, epochs=20, batch_size=1000) def predict_values(self, start_index, end_index, active_values): preds = [] for i in range(len(start_index)): # print(i) x = active_values[start_index[i]:end_index[i] + 1] x = np.array(x) x = x.reshape((1, 60)) val = self.model.predict(x) preds.append(val) return preds
for layer in vgg16_model.layers[:-1]: model.add(layer) # Freezes the weights and other trainable parameters in each layer. # They will not be updated when we pass in our images of cats and dogs. for layer in model.layers: layer.trainable = False # add a layer of 2 outputs model.add(Dense(2, activation='softmax')) # print model model.summary() # Same compile as in original model model.compile(optimizer=Adam(learning_rate=.0001), loss='categorical_crossentropy', metrics=['accuracy']) # Learning on 40 images -> 4 steps and 10 images per step model.fit_generator(generator=train_batches, steps_per_epoch=4, validation_data=valid_batches, validation_steps=4, epochs=5, verbose=2) test_imgs, test_labels = next(test_batches) test_labels = test_labels[:,0] # Taking one batch so will be 10 images predictions = model.predict_generator(generator=test_batches, steps=1, verbose=0) print(np.round(predictions[:,0])) cm = confusion_matrix(y_true=test_labels, y_pred=np.round(predictions[:,0])) print('Configuration matrix') print(cm)
x_data = np.array(x_data) y_data = np.array(y_data) print(x_data.shape) # if x_data.shape[0] > y_data.shape[0]: # x_data = x_data[:y_data.shape[0] - x_data.shape[0]] split = int(y_data.shape[0] * 0.8) x_train, x_test = x_data[:split], x_data[split:] y_train, y_test = y_data[:split], y_data[split:] model = Sequential() model.add(GRU(128, kernel_regularizer=regularizers.l2(0.001))) model.add(Dense(128, activation='relu')) model.add(Dropout(0.1)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer="adam", loss="binary_crossentropy", metrics=['binary_accuracy']) # accuracy,mse,binary_crossentropy history = model.fit(x_train, y_train, epochs=10, verbose=2) y_pred = model.predict(x_test) model.evaluate(x_test, y_test) last_data = np.expand_dims(x_test[-1], axis=0) print(model.predict(last_data)) # print("test AUC", round(roc_auc_score(y_test, y_pred), 4))
train = train.map(preprocess_data).batch(BATCH_SIZE) test = test.map(preprocess_data).batch(BATCH_SIZE) test_steps = info.splits['test'].num_examples // BATCH_SIZE train_steps = info.splits['train'].num_examples // BATCH_SIZE #Define and train your model model = Sequential([ Flatten(), Dense(784, activation='sigmoid'), Dense(800, activation='sigmoid'), Dense(800, activation='sigmoid'), Dense(10, activation='softmax') ]) model.compile(optimizer=Adam(), loss=categorical_crossentropy, metrics=[categorical_accuracy]) model.fit(train.repeat(), epochs=5, steps_per_epoch=train_steps, validation_data=test, validation_steps=test_steps) #Define metrics that we want to gather metrics_accumulator = AttackMetricsAccumulator( [Accuracy(), L2_Metrics(), Robustness(), Timing()]) for data_sample in test.take(100): image, labels = data_sample fgsm = FGSMUntargeted(iter_max=100, eps=0.001) adv_image, adv_logits, parameters = fgsm(model,
splitter2.split(best_sarcasm_features_numpy[other_ind], sarcasm_target_numpy[other_ind])) # Build a multi-layer network. # 64 input for Dense layers: # With no dropout layers: the_layers = [ layers.Dense(64, activation='sigmoid'), layers.Dense(64, activation='sigmoid'), layers.Dense(1, activation='sigmoid') ] networkMLP = Sequential(layers=the_layers) # Configure the network in preparation for training. networkMLP.compile(optimizer='adam', metrics=['accuracy'], loss='binary_crossentropy') # Train the model using the data. # Results in a history object that contains training and validation loss and metrics values. # History dictionary keys => ['val_loss', 'val_acc', 'loss', 'acc'] training064 = networkMLP.fit( best_sarcasm_features_numpy[train_ind], sarcasm_target_numpy[train_ind], validation_data=(best_sarcasm_features_numpy[val_ind], sarcasm_target_numpy[val_ind]), epochs=10) # Get the evaluation accuracy value of the network model using the acc_est data chunk. # Results in a list object that contains loss and accuracy values. # Metrics names => ['loss', 'acc']
class QNetwork: def __init__(self, env, parameters): self.observations_size = env.observation_space.shape[0] self.action_size = env.action_space.n self.learning_rate = parameters["learning_rate"] self.learning_rate_decay = parameters["learning_rate_decay"] self.loss_metric = parameters["loss_metric"] self.layers = parameters['layers'] self.input_shape = parameters.get('input_shape') def build_q_dense_network(self): self.model = Sequential() self.model.add( Dense(self.layers[0], input_dim=self.observations_size, activation='relu')) self.model.add(Dense(self.layers[1], activation='relu')) self.model.add(Dense(self.action_size, activation='linear')) self.model.compile(loss=self.loss_metric, optimizer=Adam(lr=self.learning_rate, decay=self.learning_rate_decay)) return self.model def build_q_dense_from_json(self): self.model = Sequential() len_layers = len(self.layers) assert len_layers >= 2, 'You must have a network of \ at least 2 layers' for i, units in enumerate(self.layers): if i == 0: self.model.add( Dense(units=units, input_dim=self.observations_size, activation='relu', name='Input_state')) else: self.model.add( Dense(units=units, activation='relu', name='Hidden_layer')) if i + 1 == len_layers: break self.model.add( Dense(self.action_size, activation='linear', name='Output_Q_action')) self.model.compile(loss=self.loss_metric, optimizer=Adam(lr=self.learning_rate, decay=self.learning_rate_decay)) return self.model def build_q_CNN(self): self.model = Sequential() self.model.add( Conv2D(32, kernel_size=8, activation='relu', strides=4, input_shape=self.input_shape)) self.model.add(Conv2D(64, kernel_size=4, activation='relu', strides=2)) self.model.add(Conv2D(64, kernel_size=3, activation='relu', strides=1)) self.model.add(Flatten()) self.model.add(Dense(512, activation='relu')) self.model.add(Dense(self.action_size, activation='linear')) self.model.compile(loss=self.loss_metric, optimizer=Adam(lr=self.learning_rate, decay=self.learning_rate_decay)) return self.model
from tensorflow.python.keras import Sequential from tensorflow.python.keras.layers import Bidirectional, Dense, CuDNNLSTM batch_size = 1 embedding_dim = 100 max_time = 100 lstm_output_dim = 128 output_dim = 10 sequence_length = [6, 10] model = Sequential([ Bidirectional(CuDNNLSTM(lstm_output_dim, return_sequences=True), input_shape=(max_time, embedding_dim)), Dense(output_dim, activation="sigmoid") ]) model.compile(loss='categorical_crossentropy', optimizer='adam') print(model.output_shape)
import numpy as np from tensorflow.python.keras import Sequential from tensorflow.python.keras.layers import Conv2D, Flatten, Dense, MaxPooling2D, Dropout # Load pickled data with open('small_train_traffic.p', mode='rb') as f: data = pickle.load(f) # split the data X_train, y_train = data['features'], data['labels'] model = Sequential() model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3))) model.add(MaxPooling2D()) model.add(Dropout(.5)) model.add(Flatten()) model.add(Dense(5, activation='softmax')) # preprocess data X_normalized = np.array(X_train / 255.0 - 0.5) from sklearn.preprocessing import LabelBinarizer label_binarizer = LabelBinarizer() y_one_hot = label_binarizer.fit_transform(y_train) # compile and fit model model.compile('adam', 'categorical_crossentropy', ['accuracy']) history = model.fit(X_normalized, y_one_hot, epochs=3, validation_split=0.2)
class TrainTop: """ Trains the top layer. The class variables includes a parametrized Model created using SuperNet Call the train function of class to start training and the test function to test the function. The test function also writes the data to the buckets file. :param epochs: The number of epochs :param batch_size: Model training batch size :param loss: Defines the criterion function i.e. Loss function. Default is MSELoss() :param lr: The learning rate for the model :param verbose: Whether to print the logs :param identifier: Used to identify the type of dataset :param n1: Number of layers in the first layer :param n2: Number of layers in the second layer :param bias: Bias used or not for Model: bool :param validation_split: Amount of validation used to avoid overfitting :param optimizer: Defines the optimizer used """ def __init__(self, identifier, epochs, batch_size, filename, lr=0.01, loss="mse", n1=32, n2=0, bias=True, optimizer='RMSprop', validation_split=0.1, verbose=True): self.epochs = epochs self.batch_size = batch_size self.loss = loss self.verbose = verbose self.optimizer = optimizer self.identifier = identifier self.n1 = n1 self.n2 = n2 self.bias = bias self.lr = lr self.validation_split = validation_split self.model = None self.keys, self.values = None, None self.filename = filename def train(self): self.model = Sequential() self.model.add(Dense(self.n1, activation=tf.nn.relu, use_bias=self.bias, input_shape=(1,))) if self.n2 != 0: self.model.add(Dense(self.n2, activation=tf.nn.relu, use_bias=self.bias)) self.model.add(Dense(1)) self.model.compile(optimizer=self.optimizer, loss=self.loss, metrics=['mse', 'mse']) self.keys, self.values = import_data(self.filename) self.model.fit(self.keys, self.values, epochs=self.epochs, batch_size=self.batch_size, verbose=self.verbose, validation_split=self.validation_split) if not os.path.exists("models_tf/{}".format(self.identifier)): os.makedirs("models_tf/{}".format(self.identifier)) self.model.save("models_tf/{}/super_layer.h5".format(self.identifier)) converter = tf.lite.TFLiteConverter.from_keras_model(self.model) # TF 2.0 # converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE] # Following code is used for further optimization of weights. Here we notice a massive drop in performance converter.optimizations = [tf.lite.Optimize.DEFAULT] sample = tf.cast(self.keys, tf.float32) sample = tf.data.Dataset.from_tensor_slices((sample)).batch(1) def representative_data_gen(): for input_value in sample.take(1300000): yield [input_value] converter.representative_dataset = representative_data_gen tflite_model = converter.convert() open("models_tf/{}/super_layer.tflite".format(self.identifier), "wb").write(tflite_model) def getWeights(self, tflite=False, read_model=False): """ :param read_model: Whether to read the model saved by the train function :param tflite: Read from quantized tflite file """ if self.keys is None: self.keys, self.values = import_data(self.filename) predictions = None if read_model: if tflite: self.model = tf.lite.Interpreter(model_path="models_tf/{}/super_layer.tflite".format(self.identifier)) self.model.allocate_tensors() # Get input and output tensors. details = self.model.get_tensor(0) print(details) details = self.model.get_tensor(1) print(details) details = self.model.get_tensor(2) print(details) details = self.model.get_tensor(3) print(details) # details = self.model.get_tensor(4) # print(details) # details = self.model.get_tensor(4) # print(details) # details = self.model.get_tensor(5) # print(details) # details = self.model.get_tensor(6) # print(details) input_details = self.model.get_input_details() output_details = self.model.get_output_details() else: if self.model is None: self.model = tf.keras.models.load_model("models_tf/{}/super_layer.h5".format(self.identifier)) for layer in self.model.layers: print(layer.get_weights()) else: for layer in self.model.layers: print(layer.get_weights()) def test(self, tflite=False, read_model=False, write_buckets=True, total_buckets=100): """ :param read_model: Whether to read the model saved by the train function :param total_buckets: Divide the data between the buckets to train the model for next layer :param write_buckets: Write the buckets out to disk. Writes the training data for next layer to the buckets directory. :param tflite: Read from quantized tflite file """ if self.keys is None: self.keys, self.values = import_data(self.filename) predictions = None if read_model: if tflite: self.model = tf.lite.Interpreter(model_path="models_tf/{}/super_layer.tflite".format(self.identifier)) self.model.allocate_tensors() # Get input and output tensors. input_details = self.model.get_input_details() output_details = self.model.get_output_details() self.keys = np.reshape(self.keys, (-1,1,1)).astype(np.float32) predictions = [] for i in range(self.keys.shape[0]): self.model.set_tensor(input_details[0]['index'], self.keys[i]) self.model.invoke() predictions.append(self.model.get_tensor(output_details[0]['index'])[0]) predictions = np.asarray(predictions) else: self.model = tf.keras.models.load_model("models_tf/{}/super_layer.h5".format(self.identifier)) predictions = self.model.predict(self.keys) else: predictions = self.model.predict(self.keys) if self.verbose: print("\n\nEvaluation:\n\n") big_bucket = dict() self.keys = np.reshape(self.keys, (-1,1)) predictions = np.concatenate((self.keys, self.values, predictions), axis=1) total_length = predictions.shape[0] for i in range(total_buckets): big_bucket[i] = [] for i, (k, v, o) in enumerate(predictions): k = k.item() v = v.item() o = o.item() if self.verbose and i % 8000 == 0: print("Record: ", i+1, "Key: ", k, "Value: ", v, "Model Output: ", o, "Difference: ", o-v) mn = (total_buckets * o) / total_length model_num = np.clip(np.floor(mn), 0, total_buckets - 1) big_bucket[int(model_num)].append([v, k]) if write_buckets: print("\n\nSaving data files for layer 2:\n\n") if not os.path.exists("buckets_tf/{}".format(self.identifier)): os.makedirs("buckets_tf/{}".format(self.identifier)) for b in big_bucket: np.savetxt(fname="buckets_tf/{}/bucket_{}.txt".format(self.identifier, b), X=np.array(big_bucket[b]), fmt="%u")
p, t = convert_to_matrix(data) # print("Input matrix: \n", p) # print("Output matrix: \n", t) print("Pradinis reiksmiu saraso dydis: ", len(data[0])) print("Ivesties reiksmiu saraso dydis: ", len(p)) print("Isvesties reiksmiu saraso dydis: ", len(t)) Lu = 310 # training data count Pu, Tu = p[:Lu], t[:Lu] Pu_test, Tu_test = p[:Lu], t[:Lu] model = Sequential() model.add(Dense(1, input_dim=2)) model.compile(optimizer='Adam', loss='mean_squared_error', metrics=['mse']) weights_before_train = model.get_weights() history = model.fit(Pu, Tu, epochs=1000, batch_size=10, verbose=1) weights_after_train = model.get_weights() print("Weights before train: ", weights_before_train) print("Weights after train: ", weights_after_train) model_predictions = model.predict(Pu) #print(model_predictions) drawPredictionComparison1(data, model_predictions) plt.plot(history.history['mse']) plt.xlabel("Iterations")
def test_no_2_000_then_111_what_is_brilliant_idea(self): # Testujemy dla stanu ktory raz sie pojawil, ale takze dla bardzo podobnego - i chcemy podobnego wyniku # aby nie bylo overfittingu act_preds_1_reg = [] close_preds_1_reg = [] agents: List[SmartAgent] = get_SmartAgents() for agent in agents: model = Sequential() model.add( Dense(13, input_dim=10, activation='relu')) # 1st hidden layer; states as input # model.add(Dense(8, activation='relu')) model.add( Dense(8, activation='relu', kernel_regularizer=regularizers.l2(0.5))) model.add(Dense(3, activation='linear')) model.compile(loss='mse', optimizer=Adam()) agent.model = model env = Env(agents) env.u = env_settings.u_all_2 max_time = 90 Globals().time = 0 for t in range(max_time): # actions = [1, 1, 1] if t < 60 elif 60 == t [2, 2, 2] actions = [0, 0, 0] if t == 60 or t >= 63: actions = [1, 1, 1] if t == 61 or t == 62: actions = [orange, orange, orange] env.step(actions) for agent in agents: agent.reshape_rewards() i = 0 epochs = 5 a = True while a: i += epochs agents[0].train(batch_size=40, epochs=epochs, learning_rate=0.001) x = [2, 2, 2] + [0.6, 0.6, 28.88] + [0.126, 0.126, 0.18] + [0] predictions_actual = agents[0].model.predict(np.array([x])) x = [0, 0, 0] + [0, 0, 29] + [0, 0, 0] + [1] predictions_close = agents[0].model.predict(np.array([x])) act_preds_1_reg.append(predictions_actual[0][1]) close_preds_1_reg.append(predictions_close[0][1]) print( f'{i},actual: {predictions_actual} close: {predictions_close}') if i == 6000: a = False plt.plot(act_preds_1_reg, color='blue') plt.plot(close_preds_1_reg, color='green') # plt.ylabel('some numbers') # plt.show() # #NOT REGULIZED # act_preds_1 = [] # close_preds_1 = [] # agents: List[SmartAgent] = get_SmartAgents() # for agent in agents: # model = Sequential() # model.add(Dense(13, input_dim=10, activation='relu')) # 1st hidden layer; states as input # model.add(Dense(8, activation='relu')) # model.add(Dense(3, activation='linear')) # model.compile(loss='mse', # optimizer=Adam()) # agent.model = model # # Globals().time = 0 # env = Env(agents) # env.u = env_settings.u_all_2 # max_time = 90 # for t in range(max_time): # # actions = [1, 1, 1] if t < 60 elif 60 == t [2, 2, 2] # actions = [0, 0, 0] # if t == 60 or t >= 63: # actions = [1, 1, 1] # if t == 61 or t == 62: # actions = [orange, orange, orange] # env.step(actions) # for agent in agents: # agent.reshape_rewards() # i = 0 # epochs = 20 # a = True # while a: # i += epochs # agents[0].train(batch_size=40, epochs=epochs, learning_rate=0.001) # x = [2, 2, 2] + [0.6, 0.6, 28.88] + [0.126, 0.126, 0.18] + [0] # predictions_actual = agents[0].model.predict(np.array([x])) # x = [0, 0, 0] + [0, 0, 29] + [0, 0, 0] + [1] # predictions_close = agents[0].model.predict(np.array([x])) # act_preds_1.append(predictions_actual[0][1]) # close_preds_1.append(predictions_close[0][1]) # print(f'{i},actual: {predictions_actual} close: {predictions_close}') # if i == 40000: # a = False # plt.plot(close_preds_1,color='yellow') # plt.plot(act_preds_1,color='orange') plt.show()
# split into train and test sets train_size = int(len(dataset) * 0.67) test_size = len(dataset) - train_size train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:] # reshape into X=t and Y=t+1 look_back = 1 trainX, trainY = create_dataset(train, look_back) testX, testY = create_dataset(test, look_back) # reshape input to be [samples, time steps, features] trainX = numpy.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) testX = numpy.reshape(testX, (testX.shape[0], 1, testX.shape[1])) # create and fit the LSTM network model = Sequential() model.add(LSTM(4, input_shape=(1, look_back))) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2) # make predictions trainPredict = model.predict(trainX) testPredict = model.predict(testX) # invert predictions trainPredict = scaler.inverse_transform(trainPredict) trainY = scaler.inverse_transform([trainY]) testPredict = scaler.inverse_transform(testPredict) testY = scaler.inverse_transform([testY]) # calculate root mean squared error trainScore = math.sqrt(mean_squared_error(trainY[0], trainPredict[:,0])) print('Train Score: %.2f RMSE' % (trainScore)) testScore = math.sqrt(mean_squared_error(testY[0], testPredict[:,0])) print('Test Score: %.2f RMSE' % (testScore)) # shift train predictions for plotting
def test_constrained_viterbi_tags(self): constraints = {(0, 0), (0, 1), (1, 1), (1, 2), (2, 2), (2, 3), (3, 3), (3, 4), (4, 4), (4, 0)} # Add the transitions to the end tag # and from the start tag. for i in range(5): constraints.add((5, i)) constraints.add((i, 6)) mask = np.array([ [1, 1, 1], [1, 1, 0] ]) crf = CRF( units=5, use_kernel=False, # disable kernel transform chain_initializer=initializers.Constant(self.transitions), use_boundary=True, # left_boundary_initializer=initializers.Constant(self.transitions_from_start), # right_boundary_initializer=initializers.Constant(self.transitions_to_end), transition_constraint=constraints, name="crf_layer" ) crf.left_boundary = crf.add_weight( shape=(5,), name="left_boundary", initializer=initializers.Constant(self.transitions_from_start), ) crf.right_boundary = crf.add_weight( shape=(5,), name="right_boundary", initializer=initializers.Constant(self.transitions_to_end), ) crf_loss_instance = ConditionalRandomFieldLoss() model = Sequential() model.add(layers.Input(shape=(3, 5))) model.add(MockMasking(mask_shape=(2, 3), mask_value=mask)) model.add(crf) model.compile('adam', loss={"crf_layer": crf_loss_instance}) for layer in model.layers: print(layer.get_config()) print(dict(zip(layer.weights, layer.get_weights()))) # Get just the tags from each tuple of (tags, score). viterbi_tags = model.predict(self.logits) # Now the tags should respect the constraints expected_tags = [ [2, 3, 3], [2, 3, 0] ] # if constrain not work it should be: # [ # [2, 4, 3], # [2, 3, 0] # ] # test assert np.testing.assert_equal(viterbi_tags, expected_tags)
gmm_llk = gmm.score(x) gmm_mean = gmm.means_.ravel().astype('float32') # ====== mdn ====== # def fn_loss(y_true, y_pred): # negative log-likelihood nllk = tf.reduce_mean(-y_pred.log_prob(y_true)) return nllk mdn = MixtureDensityNetwork(1, n_components=n_components, covariance_type='none') model = Sequential([mdn]) model.compile(optimizer='adam', loss=fn_loss) model.fit(x=x, y=x, epochs=48, batch_size=32, verbose=True) y = model(x) mdn_llk = tf.reduce_mean(y.log_prob(x)).numpy() mdn_mean = tf.reduce_mean(y.components_distribution.mean(), axis=(0, -1)).numpy() # ====== visualizing ====== # fig = plt.figure() sns.distplot(x, bins=80) plt.title('Data') fig = plt.figure() sns.distplot(gmm.sample(n * n_components)[0], bins=80) plt.title('GMM - llk: %.2f' % gmm_llk)
def test_unmasked_constrained_viterbi_tags(self): # TODO: using BILUO tag scheme instead of BIO. # So that, transition from tags to end can be tested. raw_constraints = np.array([ # O B-X I-X B-Y I-Y start end [ 1, 1, 0, 1, 0, 0, 1], # O [ 1, 1, 1, 1, 0, 0, 1], # B-X [ 1, 1, 1, 1, 0, 0, 1], # I-X [ 1, 1, 0, 1, 1, 0, 1], # B-Y [ 1, 1, 0, 1, 1, 0, 1], # I-Y [ 1, 1, 0, 1, 0, 0, 0], # start [ 0, 0, 0, 0, 0, 0, 0], # end ]) constraints = np.argwhere(raw_constraints > 0).tolist() # transitions = np.array([ # # O B-X I-X B-Y I-Y # [ 0.1, 0.2, 0.3, 0.4, 0.5], # O # [ 0.8, 0.3, 0.1, 0.7, 0.9], # B-X # [ -0.3, 2.1, -5.6, 3.4, 4.0], # I-X # [ 0.2, 0.4, 0.6, -0.3, -0.4], # B-Y # [ 1.0, 1.0, 1.0, 1.0, 1.0] # I-Y # ]) transitions = np.ones([5, 5]) # transitions_from_start = np.array( # # O B-X I-X B-Y I-Y # [ 0.1, 0.2, 0.3, 0.4, 0.6] # start # ) transitions_from_start = np.ones(5) # transitions_to_end = np.array( # [ # # end # -0.1, # O # -0.2, # B-X # 0.3, # I-X # -0.4, # B-Y # -0.4 # I-Y # ] # ) transitions_to_end = np.ones(5) logits = np.array([ [ # constraint transition from start to tags # O B-X I-X B-Y I-Y [ 0., .1, 1., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 1., 0., 0.] ], [ # constraint transition from tags to tags # O B-X I-X B-Y I-Y [ 0., 1., 0., 0., 0.], [ 0., 0., .1, 1., 0.], [ 0., 0., 1., 0., 0.] ] ]) crf = CRF( units=5, use_kernel=False, # disable kernel transform chain_initializer=initializers.Constant(transitions), use_boundary=True, # left_boundary_initializer=initializers.Constant(transitions_from_start), # right_boundary_initializer=initializers.Constant(transitions_to_end), transition_constraint=constraints, name="crf_layer" ) crf.left_boundary = crf.add_weight( shape=(5,), name="left_boundary", initializer=initializers.Constant(self.transitions_from_start), ) crf.right_boundary = crf.add_weight( shape=(5,), name="right_boundary", initializer=initializers.Constant(self.transitions_to_end), ) crf_loss_instance = ConditionalRandomFieldLoss() model = Sequential() model.add(layers.Input(shape=(3, 5))) model.add(crf) model.compile('adam', loss={"crf_layer": crf_loss_instance}) for layer in model.layers: print(layer.get_config()) print(dict(zip(layer.weights, layer.get_weights()))) # Get just the tags from each tuple of (tags, score). viterbi_tags = model.predict(logits) # Now the tags should respect the constraints expected_tags = [ [1, 2, 2], # B-X I-X I-X [1, 2, 2] # B-X I-X I-X ] # if constrain not work it should be: # [ # [2, 4, 3], # [2, 3, 0] # ] # test assert np.testing.assert_equal(viterbi_tags, expected_tags)
def _fit(self, X, y, step_score=None): # Parameter step_score controls the calculation of self.scores_ # step_score is not exposed to users # and is used when implementing RFECV # self.scores_ will not be calculated when calling _fit through fit X, y = check_X_y(X, y, "csc") X = pd.DataFrame(X) n_samples, n_features = X.shape if self.n_features_to_select is None: n_features_to_select = n_features // 2 else: n_features_to_select = self.n_features_to_select support_ = np.ones(n_features, dtype=np.bool) ranking_ = np.ones(n_features, dtype=np.int) if step_score: self.scores_ = [] worst_feature = 0 # Recursive elimination i = 1 while np.sum(support_) > n_features_to_select: if worst_feature == n_features: break z = (np.cov(X.T)**2)[:, support_].sum(axis=1) z[support_ == False] = 0 z_max = np.argmax(z) z_2 = z z_2[z_max] = 0 z_2 = z_2 / np.max(z_2) a = z_2 > 0.5 support_[z_max] = False X_worse = X.iloc[:, z_max] X_reduced = X.iloc[:, a] skf = KFold(n_splits=self.n_splits, shuffle=True, random_state=self.random_state) train_index, val_index = [split for split in skf.split(X_worse)][0] X_train, X_val = X_reduced.iloc[train_index], X_reduced.iloc[ val_index] y_train, y_val = X_worse[train_index], X_worse[val_index] # Eliminate predictable features if self.verbose > 0: print("Fitting estimator with %d features (%d/%d)" % (np.sum(support_), i, n_features)) i += 1 # estimator = clone(self.estimator) # estimator.fit(X_train, y_train) # score = estimator.score(X_val, y_val) # define model input_shape = X_train.shape[1] model = Sequential() model.add( Dense(10, activation='relu', kernel_initializer='he_normal', input_shape=(input_shape, ))) model.add( Dense(8, activation='relu', kernel_initializer='he_normal')) model.add(Dense(1)) # compile the model model.compile(optimizer='adam', loss='mse') # fit the model model.fit(X_train, y_train, epochs=150, batch_size=32, verbose=0) # evaluate the model yhat = model.predict(X_val) score = r2_score(y_val, yhat) if score >= self.base_score: # Compute step score on the previous selection iteration # because 'estimator' must use features # that have not been eliminated yet ranking_[np.logical_not(support_)] += 1 else: support_[z_max] = True worst_feature += 1 self.n_features_ = support_.sum() self.support_ = support_ self.ranking_ = ranking_ return self
def test_masked_viterbi_decode(): transitions = np.ones([5, 5]) transitions_from_start = np.ones(5) transitions_to_end = np.ones(5) logits = np.array([ [ # O B-X I-X B-Y I-Y [ 0., 1., 0., 0., 0.], [ 0., 0., 1., 0., 0.], [ 0., 0., 1., 0., 0.] ], [ # O B-X I-X B-Y I-Y [ 0., 1., 0., 0., 0.], [ 0., 1., 0., 0., 0.], [ 0., 1., 0., 0., 0.] ] ]) # TODO: this test case is right padding mask only # due to the underline crf function only support sequence length mask = np.array([ [1, 1, 0], [1, 1, 0] ]) crf = CRF( units=5, use_kernel=False, # disable kernel transform chain_initializer=initializers.Constant(transitions), use_boundary=True, # left_boundary_initializer=initializers.Constant(transitions_from_start), # right_boundary_initializer=initializers.Constant(transitions_to_end), name="crf_layer" ) crf_loss_instance = ConditionalRandomFieldLoss() model = Sequential() model.add(layers.Input(shape=(3, 5))) model.add(MockMasking(mask_shape=(2, 3), mask_value=mask)) model.add(crf) model.compile('adam', loss={"crf_layer": crf_loss_instance}) # for layer in model.layers: # print(layer.get_config()) # print(dict(zip(layer.weights, layer.get_weights()))) # Get just the tags from each tuple of (tags, score). result = model.predict(logits) # Now the tags should respect the constraints expected = [ [1, 2, 0], # B-X I-X NA [1, 1, 0] # B-X B-X NA ] # if constrain not work it should be: # [ # [2, 4, 3], # [2, 3, 0] # ] # test assert np.testing.assert_equal(result, expected)
classifier.add(Dropout(rate=0.5)) # antes era 0.25 # Step 3 - Flattening classifier.add(Flatten()) # Step 4 - Full connection classifier.add(Dense(units=512, activation='relu')) # classifier.add(Dropout(rate=0.5)) classifier.add(Dense(units=4, activation='softmax')) # show classifier detail classifier.summary() # Compiling the CNN classifier.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) # Using ImageDataGenerator to read images from directories train_datagen = ImageDataGenerator(rescale=1. / 255) test_datagen = ImageDataGenerator(rescale=1. / 255) training_set = train_datagen.flow_from_directory('dataset/training_set', target_size=(28, 28), batch_size=16, class_mode='categorical') test_set = test_datagen.flow_from_directory('dataset/test_set', target_size=(28, 28), batch_size=16, class_mode='categorical')
def train_task(data: InputBinaryFile(str), epochs: int, batch_size: int, model_path: OutputBinaryFile(str)): """Train CNN model on MNIST dataset.""" from tensorflow.python import keras from tensorflow.python.keras import Sequential, backend as K from tensorflow.python.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense import numpy as np mnistdata = np.load(data) train_x = mnistdata['train_x'] train_y = mnistdata['train_y'] test_x = mnistdata['test_x'] test_y = mnistdata['test_y'] num_classes = 10 img_w = 28 img_h = 28 if K.image_data_format() == 'channels_first': train_x.shape = (-1, 1, img_h, img_w) test_x.shape = (-1, 1, img_h, img_w) input_shape = (1, img_h, img_w) else: train_x.shape = (-1, img_h, img_w, 1) test_x.shape = (-1, img_h, img_w, 1) input_shape = (img_h, img_w, 1) model = Sequential([ Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape), Conv2D(64, (3, 3), activation='relu'), MaxPooling2D(pool_size=(2, 2)), Dropout(0.25), Flatten(), Dense(128, activation='relu'), Dropout(0.5), Dense(num_classes, activation='softmax'), ]) model.compile( loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy'], ) model.fit( train_x, train_y, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(test_x, test_y), ) score = model.evaluate(test_x, test_y) print('Test loss & accuracy: %s' % (score, )) model.save(model_path)
# 80% train und 20% Evaluation input_data = iris_data[:,0:4] # Spalten 0 bis 4 werden extrahier bzw. 'sepal length' 'sepal width' 'petal length' 'petal width' output_data = iris_data[:,4].reshape(-1, 1) # Die 4. Spalte wird extrahiert und in einen Array von 1D-Array umgewandelt output_data = to_categorical(output_data) iris_train_input, iris_test_input, iris_train_output, iris_test_output = train_test_split(input_data, output_data, test_size=0.20) # Aufbau des Modells mit Keras iris_model = Sequential() iris_model.add(Dense(5,input_shape=(4,),activation="relu")) iris_model.add(Dense(24,activation="relu")) iris_model.add(Dense(3,activation="softmax")) sgd = SGD(lr=0.001) iris_model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy",metrics.mae]) iris_model.fit(x=iris_train_input, y=iris_train_output, batch_size=10, epochs=500, verbose=1) # Evaluation auf Test Daten evaluation_results = iris_model.evaluate(iris_test_input, iris_test_output) print("Loss: {}".format(evaluation_results[0])) print("Accuracy: {}".format(evaluation_results[1])) print("Mean Absolute Error: {}".format(evaluation_results[2])) # Test test = np.array([[5.1,3.5,1.4,0.2], [5.9,3.,5.1,1.8], [4.9,3.,1.4,0.2], [5.8,2.7,4.1,1.]]) predictions = iris_model.predict(test) index_max_predictions = np.argmax(predictions,axis=1)
# define the keras model #from keras.layers import LSTM #stadard model = Sequential() #input 8 first hidden layer of 12 model.add(Dense(12, input_dim=17, activation='relu')) #goes second hidden layer with 8 model.add(Dense(24, activation='relu')) #final output layer model.add(Dense(1, activation='relu')) # compile the keras model #just a test to change the learning rate #we tried with SDG, it didn't work model.compile(loss='mean_squared_error', optimizer='adam', metrics=[ 'mse', 'mean_absolute_error', 'mean_absolute_percentage_error', 'cosine_proximity' ]) # fit the keras model on the dataset #use first one for final model for production #model.fit(X_train, y_train, epochs=50, batch_size=12) model.fit(X_train, y_train, epochs=2000, batch_size=12) #score score = model.evaluate(X_test, y_test, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], score[1] * 100)) #make a prediction prediction1 = model.predict(XAle) print(prediction1) predplusnormalized = np.column_stack([XAle, prediction1[:, -1]])
def test_crf_config(get_random_data): nb_samples = 2 timesteps = 10 embedding_dim = 4 output_dim = 5 embedding_num = 12 x, y = get_random_data( nb_samples, timesteps, x_high=embedding_num, y_high=output_dim ) # right padding; left padding is not supported due to the tf.contrib.crf x[0, -4:] = 0 crf_loss_instance = ConditionalRandomFieldLoss() # test with masking, fix length model = Sequential() model.add( Embedding(embedding_num, embedding_dim, input_length=timesteps, mask_zero=True) ) model.add(CRF(output_dim, name="crf_layer")) model.compile(optimizer="rmsprop", loss={"crf_layer": crf_loss_instance}) model.fit(x, y, epochs=1, batch_size=10) # test config result = model.get_config() expected = { "name": "sequential", "layers": [ { "class_name": "Embedding", "config": { "name": "embedding", "trainable": True, "batch_input_shape": (None, 10), "dtype": "float32", "input_dim": 12, "output_dim": 4, "embeddings_initializer": { "class_name": "RandomUniform", "config": { "minval": -0.05, "maxval": 0.05, "seed": None, "dtype": "float32", }, }, "embeddings_regularizer": None, "activity_regularizer": None, "embeddings_constraint": None, "mask_zero": True, "input_length": 10, }, }, { "class_name": "CRF", "config": { "name": "crf_layer", "trainable": True, "dtype": "float32", "units": 5, "use_boundary": True, "use_bias": True, "use_kernel": True, "kernel_initializer": { "class_name": "GlorotUniform", "config": {"seed": None, "dtype": "float32"}, }, "chain_initializer": { "class_name": "Orthogonal", "config": {"gain": 1.0, "seed": None, "dtype": "float32"}, }, "boundary_initializer": { "class_name": "Zeros", "config": {"dtype": "float32"}, }, "bias_initializer": { "class_name": "Zeros", "config": {"dtype": "float32"}, }, "activation": "linear", "kernel_regularizer": None, "chain_regularizer": None, "boundary_regularizer": None, "bias_regularizer": None, "kernel_constraint": None, "chain_constraint": None, "boundary_constraint": None, "bias_constraint": None, }, }, ], } assert result == expected
class KerasNetwork: def __init__(self, discount_factor, name='DQNetwork', model=None, state_size=None, action_size=None, hidden_sizes=None, hidden_activation_functions=None, output_activation_function=None): self.name = name self.discount_factor = discount_factor if model is not None: self.model = load_model(model) else: try: assert state_size is not None assert action_size is not None assert output_activation_function is not None except AssertionError: print( "Network needs to know at least state_size, actionsize, and have an output_activation_function" ) try: if hidden_activation_functions is not None or hidden_sizes is not None: assert len(hidden_activation_functions) == len( hidden_sizes) except AssertionError: if len(hidden_activation_functions) > len(hidden_sizes): print( "Too many hidden activation functions, must have length(hidden sizes) " ) else: print( "Too few hidden activation functions, must have length(hidden sizes) " ) exit(1) except TypeError: print( "Either hidden_activation_functions or hidden_sizes is None; Make both None or neither." ) self.model = Sequential() self.model.add(InputLayer(input_shape=(state_size, ))) if hidden_activation_functions is not None and hidden_sizes is not None: hidden_inputs = np.roll(hidden_sizes, 1) hidden_inputs[0] = state_size for s, i, a in zip(hidden_sizes, hidden_inputs, hidden_activation_functions): self.model.add(Dense(s, input_dim=i, activation=a)) self.model.add(Dropout(0.1)) self.model.add( Dense(action_size, input_dim=state_size, activation=output_activation_function)) self.model.compile(loss='mse', optimizer='adam', metrics=['mse']) def summary(self): return self.model.summary() def save(self, path): save_model(self.model, path) def load(self, path): self.model = load_model(path) def generate_target_vecs(self, states, actions, rewards, next_states, final_states): target_vecs = [ self.model.predict(np.array([state]))[0] for state in states ] for vec, action, reward, next_state, final_state in zip( target_vecs, actions, rewards, next_states, final_states): if final_state or self.discount_factor == 0: vec[action] = reward else: vec[action] = reward + self.discount_factor * np.min( self.model.predict(np.array([next_state]))[0]) return target_vecs