def replay(self, batch_size): x_batch, y_batch = [], [] minibatch = random.sample(self.memory, batch_size) for state, action_index, reward, next_state, done in minibatch: state = state / 255.0 if next_state is not None: next_state = next_state / 255.0 y_target = self.model.predict(state) y_target[0][ action_index] = reward if done else reward + self.discount * np.max( self.model.predict(next_state)[0]) x_batch.append(state[0]) y_batch.append(y_target[0]) #self.model.fit(np.array(x_batch), np.array(y_batch), batch_size=len(x_batch), verbose=0) self.double_model.fit(np.array(x_batch), np.array(y_batch), batch_size=len(x_batch), verbose=0) # we update the double network weights to the main network every 100 steps if self.count % 100 == 0: self.double_model.save_weights("models/double_model.h5") self.model.load_weights("models/double_model.h5") if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay
def train(self): create_file_and_folders_if_not_exist(self.get_csv_log_file_name()) _callbacks = [ callbacks.EarlyStopping(monitor='val_loss', patience=EPOCH_PATIENCE), callbacks.CSVLogger(self.get_csv_log_file_name()) ] train_x = np.array(self.char_vectors[0 * SAMPLES_PER_WRITER:50 * SAMPLES_PER_WRITER]) test_x = np.array(self.char_vectors[50 * SAMPLES_PER_WRITER:60 * SAMPLES_PER_WRITER]) train_y = np.array(self.char_labels[0 * SAMPLES_PER_WRITER:50 * SAMPLES_PER_WRITER]) test_y = np.array(self.char_labels[50 * SAMPLES_PER_WRITER:60 * SAMPLES_PER_WRITER]) self.model.fit(train_x, train_y, batch_size=self.batch_size, epochs=EPOCHS_LIMIT, callbacks=_callbacks) self.model.evaluate(test_x, test_y, batch_size=self.batch_size) self.save_model() score, acc = self.model.evaluate(test_x, test_y) print('Score: %f' % score) print('Test accuracy: %f%%' % (acc * 100)) print('Score', score)
def main(layers=4): dataset = Dataset(config.DATA_PATH, config.LABELS_PATH) X_train, X_test, y_train, y_test = dataset.split(ratio=0.7) input_layer_size = len(X_train[0]) output_layer_size = len(dataset.classes()) hidden_layer_sizes = config.HIDDEN_LAYER_SIZES[layers - 1] clf = Sequential() clf.add(Dense(hidden_layer_sizes[0], activation='relu', input_dim=input_layer_size)) for layer_size in hidden_layer_sizes[1:]: clf.add(Dense(layer_size, activation='relu')) clf.add(Dense(output_layer_size, activation='softmax')) clf.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy', t5er]) y_train = keras.utils.to_categorical(np.array(y_train), num_classes=output_layer_size) y_test = keras.utils.to_categorical(np.array(y_test), num_classes=output_layer_size) history = clf.fit(np.array(X_train), y_train, epochs=config.PERCEPTRON_MAX_EPOCHS, batch_size=32, validation_data=(np.array(X_test), y_test)) print(clf.evaluate(np.array(X_test), y_test, batch_size=32)) plot_training_accuracy(history, layers) plot_validation_accuracy(history, layers) create_roc(clf, X_test, y_test, layers, output_layer_size)
def create_neural_network(x_train, y_train, path, lr=0.1, epochs=50, batch=50): if os.path.isfile(path): return load_model(path) model = Sequential() model.add(Dense(units=8, activation='relu', input_dim=len(x_train[0]))) model.add(Dropout(0.1)) model.add(Dense(units=8, activation='tanh')) model.add(Dropout(0.1)) model.add(Dense(units=8, activation='tanh')) model.add(Dropout(0.1)) model.add(Dense(units=len(y_train[0]), activation='relu')) sgd = SGD(lr=lr, momentum=0.1, decay=0.0, nesterov=False) rmsprop = RMSprop(lr=lr) model.compile(loss='mean_squared_error', optimizer=sgd, metrics=['mae']) model.fit(np.array(x_train), np.array(y_train), epochs=epochs, batch_size=batch, verbose=0) # serialize model to JSON save_model(model, path) net = model return net
def train_5fold(self, training_images, training_labels): self.model = InceptionV3(include_top=False, weights='imagenet') self.model = self.add_new_last_layer(self.model, nb_classes=2) self.model.trainable = True self.model.compile(optimizer=Adam(lr=0.0001, beta_1=0.1), loss='categorical_crossentropy', metrics=['categorical_accuracy']) # self.model.load_weights("D:\Projects\jiaomo-master\Model\model5_resNet5fold\ResNet_best_weights_fold_0.h5") k = 5 train_datagen = ImageDataGenerator(rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') val_datagen = ImageDataGenerator(rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest') folds, x_train, y_train = self.load_data_kfold(k, training_images, training_labels) # print(folds) print(len(training_images)) print(len(x_train)) for j, (train_idx, val_idx) in enumerate(folds): print('\nFold ', j) x_train_cv = x_train[train_idx] y_train_cv = y_train[train_idx] y_train_cv = to_categorical(np.array(y_train_cv)) print(len(x_train_cv)) x_valid_cv = x_train[val_idx] y_valid_cv = y_train[val_idx] print(len(x_valid_cv)) y_valid_cv = to_categorical(np.array(y_valid_cv)) steps = int(np.size(x_train_cv, 0) // self.batch_size) val_steps = int(np.size(x_valid_cv, 0) // self.batch_size) name_weights = "_fold_" + str(j) self.init_callbacks(name=str(name_weights)) self.model.fit_generator( generator=train_datagen.flow(x=x_train_cv, y=y_train_cv, batch_size=self.batch_size), epochs=self.args.epoch, steps_per_epoch=steps, validation_steps=val_steps, verbose=1, callbacks=self.callbacks, validation_data=val_datagen.flow(x=x_valid_cv, y=y_valid_cv, batch_size=self.batch_size)) print(self.model.evaluate(x_valid_cv, y_valid_cv))
def load_data(data_path): """ 加载本地的UCI的训练数据和验证数据 :param data_path 数据集 :return: 训练数据和验证数据 """ train_path = os.path.join(data_path, "train") train_X_path = os.path.join(train_path, "Inertial Signals") X_trainS1_x = np.loadtxt(os.path.join(train_X_path, "body_acc_x_train.txt")) X_trainS1_y = np.loadtxt(os.path.join(train_X_path, "body_acc_y_train.txt")) X_trainS1_z = np.loadtxt(os.path.join(train_X_path, "body_acc_z_train.txt")) X_trainS1 = np.array([X_trainS1_x, X_trainS1_y, X_trainS1_z]) X_trainS1 = X_trainS1.transpose([1, 2, 0]) Y_train = np.loadtxt(os.path.join(train_path, "y_train.txt")) Y_train = to_categorical(Y_train - 1.0) # 标签是从1开始 print("训练数据: ") print("传感器1: %s, 传感器1的X轴: %s" % (str(X_trainS1.shape), str(X_trainS1_x.shape))) print("传感器标签: %s" % str(Y_train.shape)) print("---------------------------------") test_path = os.path.join(data_path, "test") test_X_path = os.path.join(test_path, "Inertial Signals") X_valS1_x = np.loadtxt(os.path.join(test_X_path, "body_acc_x_test.txt")) X_valS1_y = np.loadtxt(os.path.join(test_X_path, "body_acc_y_test.txt")) X_valS1_z = np.loadtxt(os.path.join(test_X_path, "body_acc_z_test.txt")) X_valS1 = np.array([X_valS1_x, X_valS1_y, X_valS1_z]) X_valS1 = X_valS1.transpose([1, 2, 0]) Y_val = np.loadtxt(os.path.join(test_path, "y_test.txt")) Y_val = to_categorical(Y_val - 1.0) print("验证数据: ") print("传感器1: %s, 传感器1的X轴: %s" % (str(X_valS1.shape), str(X_valS1.shape))) print("传感器标签: %s" % str(Y_val.shape)) print("\n") return X_trainS1, Y_train, X_valS1, Y_val
def get_single_frame(image_name): image = cv2.imread(image_name, cv2.IMREAD_GRAYSCALE) resized_image = cv2.resize(image, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_AREA) return np.array(resized_image)
def fragment_gravity_center(self, state, fragment_number, dim): """The center of weight of the fragment fragment_number: should be in range [0,1] dim: should be in ['x','y']""" offset = 0 if dim == 'x' else 1 start = 20 * fragment_number + 2 up = state[start + offset:start + 20 + offset:4] bottom = state[start + offset + 40:start + 60 + offset:4] return np.mean(np.array([up, bottom]))
def fragment_velocity(self, state, fragment_number, dim): """The velocity of the fragment fragment_number: should be in range [0,1,2] dim: should be in ['x','y']""" offset = 0 if dim == 'x' else 1 start = 20 * fragment_number + 4 up = state[start + offset:start + 20 + offset:4] bottom = state[start + offset + 40:start + 60 + offset:4] return np.mean(np.array([up, bottom]))
def process_frame(self, frame): if frame is None: return None frame = np.array(frame) frame = resize(frame, (self.frame_width, self.frame_height)) frame = np.reshape( frame, [1, self.frame_height, self.frame_width, self.state_size]) frame = 255 * frame frame = np.uint8(frame) return frame
def replay(self, batch_size): x_batch, y_batch = [], [] minibatch = random.sample(self.memory, batch_size) for state, action_index, reward, next_state, done in minibatch: y_target = self.model.predict(state) y_target[0][ action_index] = reward if done else reward + self.discount * np.max( self.model.predict(next_state)[0]) x_batch.append(state[0]) y_batch.append(y_target[0]) self.model.fit(np.array(x_batch), np.array(y_batch), batch_size=len(x_batch), verbose=1) if self.epsilon > self.epsilon_min: #None self.epsilon *= self.epsilon_decay
def create_image_dataset(self, directory): dataset = [] filenames = os.listdir(directory) for f in filenames: if f.endswith(IMAGE_FORMAT): image = tiff.imread(directory + f) if len(image) == IMAGE_SIZE: dataset.append(image) dataset = np.array(dataset, np.float16) #/ 1024. return dataset
def learn(self, batch_size): if not self.is_learning: return # Not enough samples if len(self.memory) < batch_size: return minibatch = random.sample(self.memory, batch_size) for state, action, reward, next_state, done in minibatch: state = np.array([state]) target = reward + self.gamma * \ np.amax(self.model.predict(np.array([next_state]))[0]) if done: target += 10 target_f = self.model.predict(state) target_f[0][action] = target self.model.fit(state, target_f, epochs=1, verbose=0) if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay print(self.epsilon)
def create_roc(clf, X_test, y_test, layers, output_layer_size): y_score = clf.predict(np.array(X_test)) # Plot linewidth. lw = 2 # Compute ROC curve and ROC area for each class n_classes = output_layer_size fpr = dict() tpr = dict() roc_auc = dict() for i in range(n_classes): fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i]) roc_auc[i] = auc(fpr[i], tpr[i]) # Compute micro-average ROC curve and ROC area fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel()) roc_auc["micro"] = auc(fpr["micro"], tpr["micro"]) # Compute macro-average ROC curve and ROC area # First aggregate all false positive rates all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)])) # Then interpolate all ROC curves at this points mean_tpr = np.zeros_like(all_fpr) for i in range(n_classes): mean_tpr += interp(all_fpr, fpr[i], tpr[i]) # Finally average it and compute AUC mean_tpr /= n_classes fpr["macro"] = all_fpr tpr["macro"] = mean_tpr roc_auc["macro"] = auc(fpr["macro"], tpr["macro"]) # Plot all ROC curves plt.figure(1) plt.plot(fpr["micro"], tpr["micro"], label='micro-average ROC curve (area = {0:0.2f})'.format(roc_auc["micro"]), color='deeppink', linestyle=':', linewidth=4) plt.plot(fpr["macro"], tpr["macro"], label='macro-average ROC curve (area = {0:0.2f})'.format(roc_auc["macro"]), color='navy', linestyle=':', linewidth=4) plt.plot([0, 1], [0, 1], 'k--', lw=lw) plt.xlim([0.0, 1.05]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic to bird_classification') plt.legend(loc="lower right") plt.axes().set_aspect('equal') plt.grid(True) name = 'plot_roc{}_lbp_radius{}.png'.format(layers, config.LBP_RADIUS) plt.savefig(figure_path(name)) plt.clf()
def act(self, state): if np.random.rand() <= self.epsilon: # The agent acts randomly # print('rand: ', end='') return self.random_action() # Predict the reward value based on the given state # print('net: ', end='') act_values = self.model.predict(np.array([state])) # print(act_values, end=', ') # Pick the action based on the predicted reward return np.argmax(act_values[0])
def getAction(self, state): """ Compute the action to take in the current state. With probability self.epsilon, we should take a random action and take the best policy action otherwise. Note that if there are no legal actions, which is the case at the terminal state, you should choose None as the action. HINT: You might want to use util.flipCoin(prob) HINT: To pick randomly from a list, use random.choice(list) """ # Pick Action legalActions = self.getLegalActions(state) # if 'Stop' in legalActions: # legalActions.remove('Stop') action = None "*** YOUR CODE HERE ***" if not self.getLegalActions(state): return action # Terminal State, return None self.image = getFrame() self.image = np.array(self.image) self.image = resize(self.image, (self.frame_width, self.frame_height)) self.image = np.reshape(self.image, [1, self.frame_height, self.frame_width, 3]) self.image = np.uint8(self.image) #print 'Epsilon value: ', self.epsilon if self.epsilon > random.random(): action = random.choice(legalActions) # Explore else: #action = self.computeActionFromQValues(state) # Exploit #state_matrix = self.getStateMatrices(state) #state_matrix = np.reshape(np.array(state_matrix), [1, self.state_size]) #state_matrix = np.reshape(state_matrix, (1, self.frame_width, self.frame_height)) act_values = self.model.predict(self.image) action = PACMAN_ACTIONS[(np.argmax( act_values[0]))] # returns action if action not in legalActions: action = 'Stop' #action = random.choice(legalActions) self.doAction(state, action) return action
def analyze(self, signals_group: SignalsGroup) -> AutoencoderResult: if len(signals_group.signals) != self._signals_count: raise ValueError( f'Модель может обработать строго {self._signals_count} сигналов' ) model_path = self._get_model_path(signals_group.name) if not os.path.exists(model_path): raise FileNotFoundError( f'Модель для группы сигналов {signals_group.name} не найдена. Выполните обучение' ) self._model.load_weights(model_path) data = np.array([ self._preprocess(signal) for signal in signals_group.signals_data.values() ]) data_stacked = np.column_stack(data) # samples, sample_len, features data_reshaped = data_stacked.reshape(data_stacked.shape[0], data_stacked.shape[1], 1) decoded_data_reshaped = self._model.predict(data_reshaped, batch_size=self.BATCH_SIZE) decoded_data = decoded_data_reshaped.reshape(data_stacked.shape) decoded_data = np.column_stack(decoded_data) mse = np.sum([ squared_error(predictions, targets) for predictions, targets in zip(decoded_data, data) ], axis=0) ewma_mse = ewma(mse, window=self.EWMA_WINDOW_SIZE, alpha=self.EWMA_ALPHA) return AutoencoderResult( signals=data, decoded_signals=decoded_data, mse=mse, ewma_mse=ewma_mse, )
def distance_of_the_middle_segment(self, state): """Distance between the middle segment and the target point""" x = np.mean(np.array([state[18], state[22], state[62], state[66]])) y = np.mean(np.array([state[19], state[23], state[63], state[67]])) return self.distance(x, y, self.end_point[0], self.end_point[1])
def distance_of_the_last_segment(self, state): """Distance between the last segment and the target point""" x = np.mean(np.array([state[34], state[38], state[74], state[78]])) y = np.mean(np.array([state[35], state[39], state[75], state[79]])) return self.distance(x, y, self.end_point[0], self.end_point[1])
def evaluate(self, generator, iou_threshold=0.3, score_threshold=0.3, max_detections=100, save_path=None): """ Evaluate a given dataset using a given model. code originally from https://github.com/fizyr/keras-retinanet # Arguments generator : The generator that represents the dataset to evaluate. model : The model to evaluate. iou_threshold : The threshold used to consider when a detection is positive or negative. score_threshold : The score confidence threshold to use for detections. max_detections : The maximum number of detections to use per image. save_path : The path to save images with visualized detections to. # Returns A dict mapping class names to mAP scores. """ # gather all detections and annotations all_detections = [[None for i in range(generator.num_classes())] for j in range(generator.size())] all_annotations = [[None for i in range(generator.num_classes())] for j in range(generator.size())] for i in range(generator.size()): raw_image = generator.load_image(i) raw_height, raw_width, raw_channels = raw_image.shape # make the boxes and the labels pred_boxes = self.predict(raw_image) score = np.array([box.score for box in pred_boxes]) pred_labels = np.array([box.label for box in pred_boxes]) if len(pred_boxes) > 0: pred_boxes = np.array([[box.xmin * raw_width, box.ymin * raw_height, box.xmax * raw_width, box.ymax * raw_height, box.score] for box in pred_boxes]) else: pred_boxes = np.array([[]]) # sort the boxes and the labels according to scores score_sort = np.argsort(-score) pred_labels = pred_labels[score_sort] pred_boxes = pred_boxes[score_sort] # copy detections to all_detections for label in range(generator.num_classes()): all_detections[i][label] = pred_boxes[pred_labels == label, :] annotations = generator.load_annotation(i) # copy detections to all_annotations for label in range(generator.num_classes()): all_annotations[i][label] = annotations[annotations[:, 4] == label, :4].copy() # compute mAP by comparing all detections and all annotations average_precisions = {} for label in range(generator.num_classes()): false_positives = np.zeros((0,)) true_positives = np.zeros((0,)) scores = np.zeros((0,)) num_annotations = 0.0 for i in range(generator.size()): detections = all_detections[i][label] annotations = all_annotations[i][label] num_annotations += annotations.shape[0] detected_annotations = [] for d in detections: scores = np.append(scores, d[4]) if annotations.shape[0] == 0: false_positives = np.append(false_positives, 1) true_positives = np.append(true_positives, 0) continue overlaps = compute_overlap(np.expand_dims(d, axis=0), annotations) assigned_annotation = np.argmax(overlaps, axis=1) max_overlap = overlaps[0, assigned_annotation] if max_overlap >= iou_threshold and assigned_annotation not in detected_annotations: false_positives = np.append(false_positives, 0) true_positives = np.append(true_positives, 1) detected_annotations.append(assigned_annotation) else: false_positives = np.append(false_positives, 1) true_positives = np.append(true_positives, 0) # no annotations -> AP for this class is 0 (is this correct?) if num_annotations == 0: average_precisions[label] = 0 continue # sort by score indices = np.argsort(-scores) false_positives = false_positives[indices] true_positives = true_positives[indices] # compute false positives and true positives false_positives = np.cumsum(false_positives) true_positives = np.cumsum(true_positives) # compute recall and precision recall = true_positives / num_annotations precision = true_positives / np.maximum(true_positives + false_positives, np.finfo(np.float64).eps) # compute average precision average_precision = compute_ap(recall, precision) average_precisions[label] = average_precision return average_precisions
def train(): x_data, y_data = read(os.getcwd() + "\datasets\\2\parkinsons_updrs.data.csv") reduces = [y[0] for y in y_data] x_data = feature_selection(np.array(x_data), np.array(reduces)).tolist() x_data, m, s = normalize_data(x_data) x_train, x_validation, x_test = divide_data_set(x_data) y_train, y_validation, y_test = divide_data_set(y_data) motor_x_train = np.array([[y[0]] for y in y_train]) total_x_train = np.array([[y[1]] for y in y_train]) motor_x_test = np.array([[y[0]] for y in y_test]) total_x_test = np.array([[y[1]] for y in y_test]) x_test = np.array(x_test) y_test = np.array(y_test) print("\t\tFinished divide data...") n_x_train = np.array(x_train) n_y_train = np.array([[y[0]] for y in y_train]) n_y_train = np.array(y_train) print("\t\tTraining neural network...") # Step 6: train network path = input("Input output file name for neural network(enter for end): ") while path != "": for i in range(0, 10): net = create_neural_network(n_x_train, n_y_train, path=os.getcwd() + "\\" + path, lr=(i + 1) / 10) test(x_test, y_test, net, i) path = input( "Input output file name for neural network(enter for end): ")
memory_unit, n_layers_postprocessing, t_pred, mask_value, n_features_pred, regularization): netin = Input(batch_shape=(batch_size, t_train + t_pred, n_features_train * n_stations)) mask = Masking(mask_value=mask_value)(netin) preprocessing = create_preprocessing(mask, n_stations, activation, n_layers_preprocessing, width, regularization) memory_unit = create_memory(preprocessing, memory_unit, n_layers_memory, int(n_stations / n_layers_preprocessing)) shift = Lambda(lambda x: x[:, -t_pred:, :])(memory_unit) postprocessing = create_postprocessing(shift, activation, n_layers_postprocessing, int(n_stations / n_layers_preprocessing), regularization) out = Dense(n_features_pred)(postprocessing) model = Model(netin, out) return model if __name__ == '__main__': monday_til_saturday = np.array([ [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6]], [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6]], [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6]] ]) sunday = np.array([7, 7, 7, ]) model = meijer_net() model.compile(optimizer='Adam', loss='mean_squared_error') model.fit(x=monday_til_saturday, y=sunday, epochs=1, batch_size=3) prediction = model.predict(monday_til_saturday, batch_size=3, verbose=2) print(prediction)
train_steps, train_generator = utils.batch_iter(x_train, y_train, NUM_LABEL, BATCH_SIZE, shuffle=SHUFFLE) model.fit_generator(generator=train_generator, steps_per_epoch=train_steps, epochs=EPOCHS, verbose=VERBOSE) # model.save(MODEL_PATH) # model.save_weights(MODEL_PATH) print('Validation set') # Score X_valid = utils.process_data_for_keras(NUM_LABEL, x_valid) length = np.array([len(sent) for sent in x_valid], dtype='int32') y_pred = model.predict(X_valid) y = np.argmax(y_pred, -1) y_pred = [iy[:l] for iy, l in zip(y, length)] true = MultiLabelBinarizer().fit_transform(y_valid) pred = MultiLabelBinarizer().fit_transform(y_pred) score = sk_f1_score(true, pred, average='micro') print('F1(sk-learn): {0}'.format(score)) a = np.array(y_valid).flatten() b = np.array(y_pred).flatten() f1_v1 = F1_score_v1(a, b, label2idx, idx2label) print('F1(Any Overlap OK): {0}'.format(f1_v1)) f1_v2 = F1_score_v2(y_valid, y_pred, label2idx, idx2label)
def load_data(): x_train = [] y_train = [] x_test = [] y_test = [] ratings = defaultdict(lambda: Rating()) cutoff = int(len(DATA) * 0.7) for i, scene in enumerate(DATA): if len(scene['fights']) < 10: continue x = [] y = [] for fight in reversed(scene['fights']): # skip if no odds: if 'odds' not in fight: continue f1 = fight['fighters'][0]['name'] f2 = fight['fighters'][1]['name'] f1_odds = fight['odds'][f1] f2_odds = fight['odds'][f2] if not -50 < f1_odds < 50 or not -50 < f2_odds < 50: raise ValueError( f'surely these odds are wrong? {f1_odds} {f2_odds}') win1_prob = win_probability([ratings[f1]], [ratings[f2]]) win2_prob = win_probability([ratings[f2]], [ratings[f1]]) # get winner fw = fight['winner']['fighter'] is_win_1 = fw == f1 fl = f2 if is_win_1 else f1 if not is_win_1 and fw != f2 and fw is not None: raise ValueError(f'unknown winner {fw}') drawn = fw is None x.extend([ 1 / f1_odds, 1 / f2_odds, win1_prob, win2_prob, ]) y.extend([ fight['odds'][f1] if is_win_1 else 0, fight['odds'][f2] if not is_win_1 else 0, ]) # update ratings ratings[fw], ratings[fl] = rate_1vs1(ratings[fw], ratings[fl], drawn=drawn) if len(x) == 40: break # add data and results for rewards if i < cutoff: x_train.append(x) y_train.append(y) else: x_test.append(x) y_test.append(y) return np.array(x_train), np.array(y_train), np.array(x_test), np.array( y_test)
from keras import Input, Model from keras.layers import Dense, LSTM, np deep_lstm = Input(shape=(None, 2)) dl = Dense(4)(deep_lstm) dl = LSTM(1)(dl) model = Model(inputs=deep_lstm, outputs=dl) model.compile(optimizer='rmsprop', loss="mse") x = np.array([[[1, 2], [3, 4]], [[4, 3], [2, 1]]]) y = np.array([1, -1]) model.fit(x, y, epochs=100) print(model.predict(np.reshape(x[0], (-1, 2, 2))))
model = models.Sequential() # use model.add() to add any layers you like # read Keras documentation to find which layers you can use: # https://keras.io/layers/core/ # https://keras.io/layers/convolutional/ # https://keras.io/layers/pooling/ # model.add(layers.Conv2D(32, (3, 3), input_shape=(128, 128, 3))) model.add(layers.Activation('relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) keras.layers.ActivityRegularization(l1=0.0, l2=0.0) keras.layers.Masking(mask_value=0.0) lr = np.array([1e-6, 1e-4, 1e-2]) keras.layers.AveragePooling3D(pool_size=(2, 2, 2), strides=None, padding='valid', data_format=None) model.add(layers.Conv2D(32, (3, 3))) model.add(layers.Activation('relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) model.add(layers.Conv2D(32, (3, 3))) model.add(layers.Activation('relu')) model.add(layers.MaxPooling2D(pool_size=(2, 2))) keras.layers.Dropout(0, noise_shape=None, seed=None) model.add(Flatten())