currentPath = str(Path().absolute()) filePath = currentPath + '\\testData\\' dataList = os.listdir('testData') # Initialize labels array y = np.zeros(len(dataList)) X = np.empty((1, 990), float) # Call the method to adjust the dataset and split it into train/test parts X_test, y_test = prepare_dataset(X, y) # Setup the model model = Sequential([ InputLayer((990, )), Dense(64), Dropout(0.5), ReLU(), Dense(32), Dropout(0.5), ReLU(), Dense(1, activation='sigmoid') ]) model.summary() # Load weights model.load_weights("nnData/weights4.h5") model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) score = model.evaluate(X_test, y_test, verbose=0) print("%s: %.2f%%" % (model.metrics_names[1], score[1] * 100))
def main(): args = get_cmd_args() #set the vocabulary size and load and test the training data vocabulary_size = args.vocab_size max_words = args.max_words embedding_size = args.embedding_size batch_size = args.batch_size num_epochs = args.epochs (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocabulary_size) print('Loaded dataset with {} training samples, {} test samples'.format( len(x_train), len(x_test))) print('---review---') print(x_train[6]) print('---label---') print(y_train[6]) #use the dictionary returned by imdb.get_word_index() to map review back to the original words word2id = imdb.get_word_index() id2word = {i: word for word, i in word2id.items()} print('---review with words---') print([id2word.get(i, ' ') for i in x_train[6]]) print('---label---') print(y_train[6]) # sen1 = "This is test sentence" # sen2id = sen1.get_word_index() # id2wordsen1 = {i: word for word, i in sen2id.items()} # print([id2word.get(i, ' ') for i in sen1]) #maximum review length and minimum review length print('Maximum review length: {}'.format( len(max((x_train + x_test), key=len)))) #print minimum review length print('Minimum review length: {}'.format( len(min((x_test + x_test), key=len)))) #set max words to 500 x_train = sequence.pad_sequences(x_train, maxlen=max_words) x_test = sequence.pad_sequences(x_test, maxlen=max_words) #keras model with LSTM layer model = Sequential() model.add( Embedding(vocabulary_size, embedding_size, input_length=max_words)) model.add(LSTM(100)) model.add(Dense(1, activation='sigmoid')) model.summary() #Evaluate and train model model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) #specify the batch size and the number of epochs x_valid, y_valid = x_train[:batch_size], y_train[:batch_size] x_train2, y_train2 = x_train[batch_size:], y_train[batch_size:] model.fit(x_train2, y_train2, validation_data=(x_valid, y_valid), batch_size=batch_size, epochs=num_epochs) #scores[1] will correspond to accuracy is we pass metrics=['accuracy] scores = model.evaluate(x_test, y_test, verbose=0) print('Test accuracy:', scores[1])
dimData = np.prod(train_images.shape[1:]) train_data = train_images.reshape(train_images.shape[0], dimData) test_data = test_images.reshape(test_images.shape[0], dimData) #convert data to float and scale values between 0 and 1 train_data = train_data.astype('float') test_data = test_data.astype('float') #scale data train_data /= 255.0 test_data /= 255.0 #change the labels frominteger to one-hot encoding train_labels_one_hot = to_categorical(train_labels) test_labels_one_hot = to_categorical(test_labels) #creating network model = Sequential() model.add(Dense(512, activation='relu', input_shape=(dimData, ))) model.add(Dense(512, activation='tanh')) model.add(Dense(512, activation='sigmoid')) model.add(Dense(10, activation='softmax')) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit(train_data, train_labels_one_hot, batch_size=256, epochs=3, verbose=1, validation_data=(test_data, test_labels_one_hot))
def ConvNet(): net = Sequential(name='ConvNet') net.add( Dense(units=500, input_shape=(None, None, 3), activation='relu', name='DenseIn')) for idx in range(1, 3): net.add( Conv2D(filters=int(128 / idx), kernel_size=(2, 2), padding='same', kernel_initializer='he_uniform', kernel_regularizer=l2(0.01), name=('LoopConv1_' + str(idx)))) net.add( Conv2D(filters=int(64 / idx), kernel_size=(3, 3), padding='same', kernel_initializer='he_uniform', kernel_regularizer=l2(0.01), name=('LoopConv2_' + str(idx)))) net.add(Activation('relu', name=('ReluAct' + str(idx * 1)))) net.add( Conv2D(filters=int(64 / idx), kernel_size=(5, 5), padding='same', kernel_initializer='he_uniform', kernel_regularizer=l2(0.01), name=('LoopConv3_' + str(idx)))) net.add( MaxPool2D(pool_size=(2, 2), strides=(2, 2), name=('MaxPool' + str(idx * 1)))) net.add( Dense(units=150, activation='relu', name=('DenseOut' + str(idx * 1)))) # encoder end for idx in range(2, 0, -1): net.add(Dense(units=150, activation='relu')) net.add(UpSampling2D(size=(2, 2))) net.add( Conv2D(filters=int(64 / idx), kernel_size=(5, 5), padding='same', kernel_initializer='he_uniform', kernel_regularizer=l2(0.01))) net.add(Activation('relu')) net.add( Conv2D(filters=int(64 / idx), kernel_size=(3, 3), padding='same', kernel_initializer='he_uniform', kernel_regularizer=l2(0.01))) net.add( Conv2D(filters=int(128 / idx), kernel_size=(2, 2), padding='same', kernel_initializer='he_uniform', kernel_regularizer=l2(0.01))) net.add(Dense(units=500, activation='relu')) net.add( Conv2D(filters=3, kernel_size=(2, 2), activation='relu', padding='same')) return net
def createRegularizedModel(self, inputs, outputs, hiddenLayers, activationType, learningRate): bias = True dropout = 0 regularizationFactor = 0.01 model = Sequential() if len(hiddenLayers) == 0: model.add( Dense(self.output_size, input_shape=(self.input_size, ), kernel_initializer='lecun_uniform', bias=bias)) model.add(Activation("linear")) else: if regularizationFactor > 0: model.add( Dense(hiddenLayers[0], input_shape=(self.input_size, ), kernel_initializer='lecun_uniform', W_regularizer=l2(regularizationFactor), bias=bias)) else: model.add( Dense(hiddenLayers[0], input_shape=(self.input_size, ), kernel_initializer='lecun_uniform', bias=bias)) if (activationType == "LeakyReLU"): model.add(LeakyReLU(alpha=0.01)) else: model.add(Activation(activationType)) for index in range(1, len(hiddenLayers)): layerSize = hiddenLayers[index] if regularizationFactor > 0: model.add( Dense(layerSize, kernel_initializer='lecun_uniform', W_regularizer=l2(regularizationFactor), bias=bias)) else: model.add( Dense(layerSize, kernel_initializer='lecun_uniform', bias=bias)) if (activationType == "LeakyReLU"): model.add(LeakyReLU(alpha=0.01)) else: model.add(Activation(activationType)) if dropout > 0: model.add(Dropout(dropout)) model.add( Dense(self.output_size, kernel_initializer='lecun_uniform', bias=bias)) model.add(Activation("linear")) optimizer = optimizers.RMSprop(lr=learningRate, rho=0.9, epsilon=1e-06) model.compile(loss="mse", optimizer=optimizer) model.summary() return model
def param_model(): ''' frame = {{choice([1, 2, 4, 6, 8, 10, 12, 14, 16, 20, 24])}} hide_num = {{choice([1, 2, 3])}} hide_unit = {{choice([2, 4, 8, 16])}} lstm_unit = {{choice([2, 4, 8, 16])}} lr = {{choice([-2, -3, -4, -5, -6])}} # {'frame': 1, 'hide_num': 1, 'hide_unit': 8, 'hide_unit_1': 8, 'lr': -4} lr = 10**lr ''' frame = 8 hide_num = 2 hide_unit = 8 lstm_unit = 8 lr = 0.0001 l2 = 0.0005 model = Sequential() # model.add(LSTM(lstm_unit, batch_input_shape=(None, frame, 6), return_sequences=False, dropout=0.5, recurrent_dropout=0.5)) # model.add(Dropout(0.5, batch_input_shape=(None, frame, 6))) model.add(Dense(lstm_unit, batch_input_shape=(None, frame, 3))) model.add(Flatten()) model.add(Activation('relu')) for _ in range(hide_num): model.add(Dense(hide_unit)) model.add(Activation('relu')) model.add(Dense(1)) model.add(Activation('linear')) plot_model(model, to_file='model.png', show_shapes=True) model.compile(loss="mean_squared_error", optimizer="adam") # es = EarlyStopping(patience=30, monitor='loss', verbose=1, mode='auto') es = EarlyStopping(patience=5) rlr = ReduceLROnPlateau() file_list = glob.glob("./roted_data/rot*.csv") file_num = 0 for train_file in file_list: log_path = './logs_curve/log_{}_{}_{}_{}_{}-{}/'.format( frame, hide_num, hide_unit, lstm_unit, lr, file_num) filepath = './saves_curve/models_{}_{}_{}_{}_{:.0f}-{}/'.format( frame, hide_num, hide_unit, lstm_unit, lr * 1000000, file_num) os.makedirs(filepath, exist_ok=True) tb = TensorBoard(log_dir=log_path) cp = ModelCheckpoint(filepath=filepath + 'model_{epoch:02d}.hdf5', monitor='val_loss', verbose=1, save_best_only=True, mode='auto') df = pd.read_csv(train_file) time_data = df.loc[:, 'dt[s]'].values pos_data = df.loc[:, 'pos_x':'pos_z'].values accel_data = df.loc[:, 'accel_x':'accel_z'].values width = frame times = time_data poses = pos_data accels = accel_data data, target = [], [] prev_time = np.vstack((np.zeros( (1, 1)), times[:frame - 1].reshape(frame - 1, 1))) v = np.zeros_like(accels) i = 0 for a in accels: if i > 0: dt = times[i] - times[i - 1] v[i] = v[i - 1] + a * 9.8 * dt else: v[i] = a * 9.8 * times[0] i = i + 1 prev_time = np.vstack((np.zeros( (1, 1)), times[:frame - 1].reshape(frame - 1, 1))) for i in range(len(times) - width): time = times[i:i + width].reshape(width, 1) DT = (time - prev_time) temp = v[i:i + width, :] data.append(temp) dt = times[i + width] - times[i + width - 1] delta = poses[i + width] - poses[i + width - 1] dist = math.sqrt(delta[0] * delta[0] + delta[2] * delta[2]) temp = dist / dt target.append(temp) prev_time = time pos_input, pos_target = np.array(data), np.array(target) print(pos_input[:, 0, 3:7]) model.fit(pos_input, pos_target, epochs=1000, verbose=1, batch_size=10, callbacks=[tb, es, cp], validation_split=0.1, shuffle=True) file_num = file_num + 1 test_file = file_list[2] df = pd.read_csv(test_file) time_data = df.loc[:, 'dt[s]'].values pos_data = df.loc[:, 'pos_x':'pos_z'].values accel_data = df.loc[:, 'accel_x':'accel_z'].values width = frame times = time_data poses = pos_data accels = accel_data data, target = [], [] prev_time = np.vstack((np.zeros( (1, 1)), times[:frame - 1].reshape(frame - 1, 1))) v = np.zeros_like(accels) i = 0 for a in accels: if i > 0: dt = times[i] - times[i - 1] v[i] = v[i - 1] + a * 9.8 * dt else: v[i] = a * 9.8 * times[0] i = i + 1 prev_time = np.vstack((np.zeros( (1, 1)), times[:frame - 1].reshape(frame - 1, 1))) for i in range(len(times) - width): time = times[i:i + width].reshape(width, 1) temp = v[i:i + width, :] data.append(temp) dt = times[i + width] - times[i + width - 1] delta = poses[i + width] - poses[i + width - 1] dist = math.sqrt(delta[0] * delta[0] + delta[2] * delta[2]) temp = dist / dt target.append(temp) prev_time = time test_pos_input, test_pos_target = np.array(data), np.array(target) pred = np.array([[0.0]] * df.shape[0]) pred[:frame] = test_pos_input[0, :] # evaluation total_loss = 0 i = frame for pos_input in test_pos_input: pred[i] = model.predict(np.array([pos_input])) total_loss = total_loss + abs(test_pos_target[i - frame] - pred[i]) i = i + 1 pred = pred[frame:] total_loss = total_loss / test_pos_input.shape[0] print(test_pos_target.shape) print(pred.shape) print("total loss:\t{0}".format(total_loss)) print("total loss sum:\t{0}".format(np.sum(total_loss))) return {'loss': np.sum(total_loss), 'status': STATUS_OK, 'model': model}
def CNN(conn, x_train, x_test, y_train, y_test, epochs, batch, learning_rate, n, project, uid, ptype): model = Sequential() model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(256, 256, 3))) model.add(MaxPooling2D((2, 2))) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2))) model.add(Conv2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2))) model.add(Conv2D(128, (3, 3), activation='relu')) model.add(MaxPooling2D((2, 2))) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dense(n, activation='softmax')) model.compile(Adam(learning_rate=learning_rate), loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit(x_train, y_train, epochs=epochs, batch_size=batch, verbose=1) predicted = model.predict(x_test) predicted = np.argmax(predicted, axis=1) y_test = np.argmax(y_test, axis=1) print("Accuracy score : ", str(accuracy_score(y_test, predicted))) print("F1 score : ", str(f1_score(y_test, predicted, zero_division=1))) print("Confusion Matrix : ") print(confusion_matrix(y_test, predicted)) losses = history.history['loss'] plt.plot(losses) plt.show() message_to_send = "Saving Model...".encode("UTF-8") conn.send(len(message_to_send).to_bytes(2, byteorder='big')) conn.send(message_to_send) print("Saving Model ....\n") model.save(project + ".h5") message_to_send = "Converting Model...".encode("UTF-8") conn.send(len(message_to_send).to_bytes(2, byteorder='big')) conn.send(message_to_send) print("Conerting Model to .tflite ....\n") convert(project) message_to_send = "Pushing Model to cloud...".encode("UTF-8") conn.send(len(message_to_send).to_bytes(2, byteorder='big')) conn.send(message_to_send) print("pushing model to cloud...\n") push_model(project, uid, ptype) print("Pushing to cloud successful...\n")
def _build_model: from keras import Sequential model = Sequential() model.add(Embedding(self.max_int)) model.compile('rmsprop', 'mse') self._model = model
class CNN_run: model = Sequential() model.add( Conv2D(filters=32, kernel_size=(3, 3), activation="relu", padding="same", input_shape=(64, 64, 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(2, activation="softmax")) #SVG(model_to_dot(model).create(prog='dot', format='svg')) model.compile(Adam(lr=0.001), loss="binary_crossentropy", metrics=["accuracy"]) gen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) #gen=ImageDataGenerator() train_batches = gen.flow_from_directory( "/Users/dwp167/PycharmProjects/CNN_cs445/input/chest_xray/chest_xray/train", model.input_shape[1:3], color_mode="grayscale", shuffle=True, seed=1, batch_size=16) valid_batches = gen.flow_from_directory( "/Users/dwp167/PycharmProjects/CNN_cs445/input/chest_xray/chest_xray/val", model.input_shape[1:3], color_mode="grayscale", shuffle=True, seed=1, batch_size=16) test_batches = gen.flow_from_directory( "/Users/dwp167/PycharmProjects/CNN_cs445/input/chest_xray/chest_xray/test", model.input_shape[1:3], shuffle=False, color_mode="grayscale", batch_size=8) history1 = model.fit_generator(train_batches, steps_per_epoch=163, epochs=30, validation_data=valid_batches, validation_steps=624) test_accu = model.evaluate_generator(test_batches, steps=624) print('The testing accuracy is:', test_accu[1] * 100, '%') # history1 = model.fit_generator(test_batches,validation_data=valid_batches,epochs=3) p = model.predict_generator(test_batches, verbose=True) pre = DataFrame(p) pre["filename"] = test_batches.filenames pre["label"] = (pre["filename"].str.contains("PNEUMONIA")).apply(int) pre['pre'] = (pre[1] > 0.5).apply(int) 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.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.title('Model Loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Training set', 'Test set'], loc='upper left') plt.show()
data_generator(normalGlob, abNormalGlob, 2) # In[34]: img_height = 256 img_width = 384 # build the VGG16 network model = applications.VGG16(weights='imagenet', include_top=False, input_shape=(img_height, img_width, 3)) # In[11]: top_model = Sequential() top_model.add(Flatten(input_shape=model.output_shape[1:])) top_model.add(Dense(256, activation='relu')) top_model.add(Dropout(0.5)) top_model.add(Dense(1, activation='sigmoid')) # In[12]: # model.add(top_model) this throws error alternative is below new_model = Sequential() #new model for layer in model.layers: new_model.add(layer) new_model.add(top_model) # now this works
def create_models(X_train, list_labels): # build convolution model # input shape = (128, 128, 1) model = Sequential() input_shape = X_train.shape[1:] model.add(Conv2D(24, (5, 5), strides=(1, 1), input_shape=input_shape)) model.add(MaxPooling2D((4, 2), strides=(4, 2))) model.add(Activation('relu')) model.add(Conv2D(48, (5, 5), padding="valid")) model.add(MaxPooling2D((4, 2), strides=(4, 2))) model.add(Activation('relu')) model.add(Conv2D(48, (5, 5), padding="valid")) model.add(Activation('relu')) model.add(Flatten()) model.add(Dropout(rate=0.5)) model.add(Dense(64)) model.add(Activation('relu')) model.add(Dropout(rate=0.5)) model.add(Dense(len(list_labels))) model.add(Activation('softmax')) model.summary() MAX_EPOCHS = 50 MAX_BATCH_SIZE = 20 # learning rate reduction rate MAX_PATIENT = 2 # saved model checkpoint file best_model_file = "./best_model_trained.hdf5" # callbacks # removed EarlyStopping(patience=MAX_PATIENT) callback = [ ReduceLROnPlateau(patience=MAX_PATIENT, verbose=1), ModelCheckpoint(filepath=best_model_file, monitor='loss', verbose=1, save_best_only=True) ] # compile model.compile(optimizer="Adam", loss="categorical_crossentropy", metrics=['accuracy']) # train print('training started.... please wait!') checkpoint = ModelCheckpoint(best_model_file, monitor='val_acc', verbose=0, save_best_only=True, mode='max') callbacks_list = [checkpoint] history = model.fit(x=X_train, y=y_train, epochs=MAX_EPOCHS, batch_size=MAX_BATCH_SIZE, verbose=1, validation_data=(X_val, y_val), callbacks=callbacks_list) history = model.fit(X_train, y_train, batch_size=MAX_BATCH_SIZE, nb_epoch=MAX_EPOCHS, verbose=1) print('training finished') # quick evaludate model print('Evaluate model with test data') score = model.evaluate(x=X_test, y=y_test) print('test loss:', score[0]) print('test accuracy:', score[1])
def MLP(name, input_dir, best_dir, output): if not os.path.exists(best_dir): os.makedirs(best_dir) best_dir_dat = "/".join((best_dir, name)) if not os.path.exists(best_dir_dat): os.makedirs(best_dir_dat) colnames = "HType,ABType,dimension,learnFac,margin,constr,LType,MLP_acc,MLP_wF1,MLP_epoch" with open(output, "w") as file: file.write(colnames) file.write("\n") models = sorted(os.listdir(input_dir)) for model in models: modelpath = "/".join((input_dir, model)) files = sorted(os.listdir(modelpath)) # create model subdir to store best MLP models best_subdir = "/".join((best_dir_dat, model)) if not os.path.exists(best_subdir): os.makedirs(best_subdir) for i, file in enumerate(files): print(i) # embedding datasets labelpath = "/".join((modelpath, file)) dataset = pd.read_csv(labelpath, index_col=0) # specify file path to store best MLP model [for later] filepath = best_subdir + "/" + file[:-4] + ".hdf5" ################################################################################ ############################# DATA SPLIT ############################## ################################################################################ lb = preprocessing.LabelBinarizer() lb.fit(list(dataset["pgroup"])) X_train = dataset[dataset["split"] == "LRN"].iloc[:,1:-2].values y_train = dataset[dataset["split"] == "LRN"].iloc[:,-1].values # get weights first weights = compute_class_weight("balanced", np.unique(y_train), y_train) # then transform y_train = lb.transform(y_train) X_valid = dataset[dataset["split"] == "VLD"].iloc[:,1:-2].values y_valid = dataset[dataset["split"] == "VLD"].iloc[:,-1].values y_valid = lb.transform(y_valid) X_test = dataset[dataset["split"] == "TST"].iloc[:,1:-2].values y_test = dataset[dataset["split"] == "TST"].iloc[:,-1].values y_test = lb.transform(y_test) ################################################################################ ############################# CLASSIFIER STRUCTURE ############################## ################################################################################ classifier = Sequential() dim = len(dataset.iloc[0,1:-2]) nodes = dim*2 # Hidden layer classifier.add(Dense(nodes, activation="sigmoid", kernel_initializer="uniform", input_dim=dim)) # Output layer classifier.add(Dense(8, activation="softmax", kernel_initializer="uniform")) # compile the model sgd = optimizers.SGD(lr=0.01, decay=0.0, momentum=0.0, nesterov=False) classifier.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"]) ################################################################################ ############################# MODEL FITTING ############################## ################################################################################ # checkpoint best model checkpoint = ModelCheckpoint(filepath, monitor="val_acc", verbose=0, save_best_only=True, mode="auto") # model settings and fit history = classifier.fit(X_train, y_train, validation_data=(X_valid, \ y_valid), epochs=5000, verbose=0, callbacks=[checkpoint], \ class_weight=weights) ################################################################################ ############################# MAKE PREDICTIONS ############################## ################################################################################ #load best model final_model = load_model(filepath) # get accuracy scores = final_model.evaluate(X_test, y_test, verbose=0) # get weighted F1-by-class le = preprocessing.LabelEncoder() le.fit(list(dataset["pgroup"])) y_test2 = dataset[dataset["split"] == "TST"].iloc[:,-1].values y_test2 = le.transform(y_test2) y_pred = final_model.predict_classes(X_test, verbose=0) weighted_f1 = f1_score(y_test2, y_pred, average="weighted") # get best epoch acc_history = history.history["val_acc"] best_epoch = acc_history.index(max(acc_history)) + 1 K.clear_session() # destroy TF graph to avoid loop slowing down ################################################################################ ############################# ASSEMBLE W/ CONFIG ############################## ################################################################################ # get model type (H1-4, A/B) modelType = model.split("-")[1] # ["H1A"] HType = modelType[0:2] ABType = modelType[-1] # get dimension filenamesplit = file.split("-") dimension = int([s for s in filenamesplit if "D00" in s][0][1:]) # get learnFac learnFac = int([s for s in filenamesplit if "LF0" in s][0][3:]) # get margin margin = float([s for s in filenamesplit if "LM" in s][0][2:]) # get constraint constr = [s for s in filenamesplit if "_VALUE" in s][0][:-6].lower() # get LType LType = filenamesplit[-1][:2] with open(output, "a") as file: file.write("%s,%s,%d,%d,%.1f,%s,%s,%.17f,%.17f,%d" % (HType, ABType, dimension, learnFac, margin, constr, LType, scores[1], weighted_f1, best_epoch)) file.write("\n")
def main(): # labels = pd.read_csv(data_dir+'labels.csv') # num_classes = len(labels.groupby('breed')) # selected_labels = labels.groupby('breed').count().sort_values(by='id',ascending=False).head(num_classes).index.values # labels = labels[labels['breed'].isin(selected_labels)] # labels['target'] = 1 # labels['rank'] = labels.groupby('breed').rank()['id'] # labels_pivot = labels.pivot('id', 'breed', 'target').reset_index().fillna(0) # values必须是breed和target对应的值 # np.random.seed(SEED) # # rnd = np.random.random(len(labels)) # # is_train = rnd < 0.8 # # is_val = rnd >= 0.8 # y_train = labels_pivot[selected_labels].values # # ytr = y_train[is_train] # # yv = y_train[is_val] # ytr = y_train # # x_train = np.zeros((len(labels), INPUT_SIZE, INPUT_SIZE, 3), dtype='float32') # for i, img_id in tqdm(enumerate(labels['id'])): # # print i, img_id # img = read_img(img_id, 'train', (INPUT_SIZE,INPUT_SIZE)) # x = xception.preprocess_input(np.expand_dims(img.copy(), axis=0)) # x_train[i] = x # print('Train Images shape: {} size: {:,}'.format(x_train.shape, x_train.size)) # # num_tests = len(listdir(data_dir + '/test/')) # x_test = np.zeros((num_tests,INPUT_SIZE, INPUT_SIZE, 3), dtype='float32') # test_id = [] # for i in range(num_tests): # img_file_name = listdir(data_dir + '/test/')[i] # img_id = img_file_name[0:len(img_file_name)-4] # img = read_img(img_id, 'test',(INPUT_SIZE,INPUT_SIZE)) # x = xception.preprocess_input(np.expand_dims(img.copy(), axis=0)) # x_test[i] = x # test_id.append(img_id) # # # xtr = x_train[is_train] # xtr = x_train # # xv = x_train[is_val] # # xception_bottleneck = xception.Xception(weights='imagenet', include_top=False, pooling=POOLING) # train_x_bf = xception_bottleneck.predict(xtr, batch_size=32, verbose=1) # valid_x_bf = xception_bottleneck.predict(x_test, batch_size=32, verbose=1) # # inception_bottleneck = inception_v3.InceptionV3(weights='imagenet', include_top=False, pooling=POOLING) # train_i_bf = inception_bottleneck.predict(xtr, batch_size=32, verbose=1) # valid_i_bf = inception_bottleneck.predict(x_test, batch_size=32, verbose=1) # # train_x = np.hstack([train_x_bf, train_i_bf]) # test_x = np.hstack([valid_x_bf, valid_i_bf]) # data = {'train_x':train_x, 'train_y':ytr, 'test_x':test_x} # with open('x_inception_fc_data.pickle', 'wb') as handle: # pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL) with open(data_dir + 'xicpt_data.pickle', 'rb') as handle: load_data = pickle.load(handle) fc = Sequential() fc.add(Dense(500, activation='relu', input_shape=(4096, ))) fc.add(Dropout(0.2)) fc.add(BatchNormalization()) fc.add(Dense(load_data['num_class'], activation='softmax')) fc.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) fc.fit(load_data['train_x'], load_data['train_y'], batch_size=32, epochs=10, verbose=1) valid_probs = fc.predict(load_data['test_x']) # without formatting df1 = {'id': load_data['test_id']} res1 = pd.DataFrame(data=df1) res2 = pd.DataFrame(columns=load_data['selected_labels'], data=valid_probs) res = pd.concat([res1, res2], axis=1) # res.to_csv("./x_icpt_fc"+str(dropout)+"_"+str(output)+"_"+str(opt)+"_"+str(batch)+".csv", index=False) # format as the sample submission sample_submission = pd.read_csv(data_dir + 'sample_submission.csv') sample_ids = list(sample_submission['id']) sample_breeds = list(sample_submission.columns.values)[1:] reorder_df = res.set_index('id') reorder_df = reorder_df.loc[sample_ids].reset_index().reindex( columns=['id'] + sample_breeds) reorder_df.to_csv("./xicpt_fcbnorm.csv", index=False)
plt.figure(figsize=(10, 10)) for c in range(16): plt.subplot(4, 4, c + 1) plt.imshow(x_train[c].reshape(28, 28), cmap='gray') plt.show() print(y_train[:16]) """# Modeling""" model = Sequential([ Conv2D(input_shape=(28, 28, 1), kernel_size=3, filters=32), MaxPool2D(strides=2), Conv2D(kernel_size=3, filters=64), MaxPool2D(strides=2), Conv2D(kernel_size=3, filters=128), Flatten(), Dense(128, activation='relu'), Dropout(0.3), Dense(10, activation='softmax') ]) model.compile(optimizer=optimizers.Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.summary() """## Training""" history = model.fit(x_train, y_train, epochs=10, validation_split=0.25) """# Evaluation"""
y_test = scalerY.transform(y_test) #neural network training definition layers = [ Dense(100, input_shape=(exampleData.shape[1], )), Dropout(0.1), Dense(100, activation='relu'), Dropout(0.1), Dense(100, activation='relu'), Dropout(0.1), Dense(100, activation='relu'), Dropout(0.1), Dense(1) ] model = Sequential(layers) #train the model model.compile(optimizer="SGD", loss='mean_squared_error', metrics=['mean_absolute_error']) model.fit(X_train, y_train, epochs=1000, verbose=0) #evaluate the model (still scalled wierdly) #print(model.evaluate(x=X_train, y=y_train, verbose=0)) #to check for overfitting print(model.evaluate(x=X_test, y=y_test, verbose=0)) #acutal score #print 8 potential squares print(scalerY.inverse_transform(y_test[0:8])) print(scalerY.inverse_transform(model.predict(X_test[0:8])))
def transfer_and_fine_tune(sentences_train, sentences_test, targets_train, targets_test): """ Create and train multi level perceptron with Keras API and save it. :param1 sentences_train: train sentences. :param2 sentences_test: test sentences. :param3 targets_train: train target embeddings. :param4 targets_test: test target embeddings. """ from keras import Sequential from keras.callbacks import EarlyStopping from keras.callbacks import ModelCheckpoint from keras.layers.core import Dense, Activation from keras.models import model_from_json from keras.optimizers import Adam print("GUSE version") # transfer learning print("TRANSFER LEARNING STEP:") model = Sequential() encoderlayer = hub.KerasLayer(c.GUSE_PATH, input_shape=[], dtype=tf.string, trainable=False) model.add(encoderlayer) n_hidden = encoderlayer.output_shape[1] model.add(Dense(int(n_hidden))) model.add(Activation('relu')) model.add(Dense(int(n_hidden * SCALE_1))) model.add(Activation('relu')) model.add(Dense(int(n_hidden * SCALE_1 * SCALE_1))) model.add(Activation('relu')) model.add(Dense(len(targets_train[0]), activation='linear')) # compile model model.compile(loss=cosine_distance, optimizer='adam', metrics=['cosine_proximity']) es = EarlyStopping(monitor='val_loss', mode='min', verbose=c.LOG_LEVEL, patience=c.PATIENCE) best_weights_file = c.TL_MODEL_WEIGHTS_FILE_NAME mc = ModelCheckpoint(best_weights_file, monitor='val_loss', mode='min', verbose=c.ONE_LINE_PER_EPOCH, save_best_only=True) # train model testing it on each epoch model.fit(sentences_train, targets_train, validation_data=(sentences_test, targets_test), batch_size=c.BATCH_SIZE, epochs=c.MAX_EPOCHS, verbose=c.ONE_LINE_PER_EPOCH, callbacks=[es, mc]) # serialize model to JSON model_json = model.to_json() with open(c.TL_MODEL_JSON_FILE_NAME, "w") as json_file: json_file.write(model_json) print("model saved") # fine tuning print("FINE TUNING STEP:") # Model reconstruction from JSON file with open(c.TL_MODEL_JSON_FILE_NAME, 'r') as f: json = f.read() model = model_from_json(json, custom_objects={'KerasLayer': hub.KerasLayer}) # Load weights into the new model model.load_weights(c.TL_MODEL_WEIGHTS_FILE_NAME) model.trainable = True # compile model model.compile(loss=cosine_distance, optimizer=Adam(3e-5), metrics=['cosine_proximity']) es = EarlyStopping(monitor='val_loss', mode='min', verbose=c.LOG_LEVEL, patience=c.PATIENCE) best_weights_file = c.FT_MODEL_WEIGHTS_FILE_NAME mc = ModelCheckpoint(best_weights_file, monitor='val_loss', mode='min', verbose=c.ONE_LINE_PER_EPOCH, save_best_only=True) # train model testing it on each epoch model.fit(sentences_train, targets_train, validation_data=(sentences_test, targets_test), batch_size=c.BATCH_SIZE, epochs=c.MAX_EPOCHS, verbose=c.ONE_LINE_PER_EPOCH, callbacks=[es, mc]) # serialize model to JSON model_json = model.to_json() with open(c.FT_MODEL_JSON_FILE_NAME, "w") as json_file: json_file.write(model_json) print("model saved")
test_images = test_images / 255.0 plt.figure(figsize=(10, 10)) for i in range(25): plt.subplot(5, 5, i + 1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(train_images[i], cmap=plt.cm.binary) plt.xlabel(class_names[train_labels[i]]) # plt.show() print(train_images.shape, train_labels.shape) print(train_images[0]) print(train_labels[:10]) model1 = Sequential([layers.Flatten(input_shape=(28, 28)), layers.Dense(128, activation='relu'), layers.Dense(10, activation='softmax')]) print(model1.summary()) model1.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model1.fit(train_images, train_labels, epochs=5) test_loss, test_accuracy = model1.evaluate(test_images, test_labels, verbose=2) print("test accuracy:", test_accuracy) ################################################## predictions = model1.predict(test_images) num_rows = 5 num_cols = 3
def SegNet(): model = Sequential() #encoder model.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=(img_w2, img_h2, 3), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(128,128) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(64,64) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(32,32) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(16,16) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(8,8) #decoder model.add(UpSampling2D(size=(2, 2))) #(16,16) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(32,32) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(64,64) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(128,128) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(256,256) model.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=(img_w2, img_h2, 3), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(Conv2D(n_label, (1, 1), strides=(1, 1), padding='same')) model.add(Reshape((n_label, img_w2 * img_h2))) model.add(Permute((2, 1))) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) model.summary() return model
def nn_with_past_outliers_multi_step_forecast(series, validation_series, input_length, horizon, del_outliers=False, normalize=False, plot=False): """ Perform forecasting of a time series using a simple neural network with a single 128 neurons hidden layer. The network is trained using samples of shape input_length (corresponding to the last input_length days) to predict an array of horizon values (corresponding to horizon days). In this case, the network predicts horizon days at the time. Performance of the trained network is assessed on a validation series. The size of the validation series must be horizon. This function differs from nn_multi_step_forecast as in addition to the last input_length days, we also use horizon days at the same period the previous year as an input to the network. In addition, the horizon days from the previous year are normalized from the original series and contain the outliers. The hope is to gain information from the previous year. :param series: :param validation_series: :param input_length: :param horizon: :param del_outliers: :param normalize: :param plot: :return: SMAPE for the validation series, the forecast validation series """ # whether to remove outliers in the training series if del_outliers: working_series = remove_outliers(series) else: working_series = series # whether to normalize the training series if normalize: scaler, working_series = normalize_series(working_series) scaler_bis, working_series_with_outliers = normalize_series(series) else: scaler = None working_series_with_outliers = series # input sequence is our data, np.log1p is applied to the data and mae error is used to approximate SMAPE error train_series = np.log1p(working_series) # we use the last n_steps_in days as input and predict n_steps_out n_steps_in, n_steps_out = input_length, horizon # split into samples train_samples, train_targets = split_sequence_nn_with_past_outliers_multi_step( train_series, working_series_with_outliers, n_steps_in, n_steps_out) # create the model model = Sequential() model.add(Dense(128, activation='relu', input_dim=n_steps_in + horizon)) # we predict n_steps_out values model.add(Dense(n_steps_out)) # we use 'mae' with data transformed with log1p and expm1 to approach SMAPE error model.compile(optimizer='adam', loss='mae') # fit model model.fit(train_samples, train_targets, epochs=200, verbose=0) # perform prediction # input is the last n_steps_in values of the train series (working_series is not log1p transformed) # in addition, we prepend the horizon values from the last year validation_in_sample = np.log1p( np.append( np.array(working_series_with_outliers.values[-365:-365 + horizon]), np.array(working_series.values[-n_steps_in:]))) validation_in_sample = validation_in_sample.reshape( (1, n_steps_in + horizon)) validation_forecast = model.predict(validation_in_sample, verbose=0) # dataframe which contains the result forecast_dataframe = pd.DataFrame(index=validation_series.index) # if data was normalized, we need to apply the reverse transform if normalize: # first reverse log1p using expm1 validation_forecast = np.expm1(validation_forecast) # use scaler to reverse normalizing denormalized_forecast = scaler.inverse_transform( validation_forecast.reshape(-1, 1)) denormalized_forecast = [val[0] for val in denormalized_forecast] # save the forecast in the dataframe forecast_dataframe['forecast'] = denormalized_forecast else: # save the forecast in the dataframe forecast_dataframe['forecast'] = np.expm1(validation_forecast) if plot: plt.figure(figsize=(10, 6)) plt.plot(series[-100:], color="blue", linestyle="-") plt.plot(validation_series, color="green", linestyle="-") plt.plot(forecast_dataframe, color="red", linestyle="--") plt.legend(["Train series", "Validation series", "Predicted series"]) plt.title( "Validation of simple multi step NN with past values and input size " + str(n_steps_in) + " output size " + str(n_steps_out)) plt.show() return smape( validation_series, forecast_dataframe['forecast']), forecast_dataframe['forecast']
def build_model(hype_space): """Create model according to the hyperparameter space given.""" print("Hyperspace:") print(hype_space) model = Sequential() # Define parameters to goverrn construction of model according to hype_space n_filters = int(round(hype_space['nb_conv_filters'])) if hype_space['nb_conv_in_conv_pool_layers'] == 2: two_conv_layers = True else: two_conv_layers = False # first conv+pool layer model.add(first_convolution(n_filters, hype_space)) if hype_space['conv_dropout'] is not None: model.add(conv_dropout(hype_space)) if two_conv_layers: model.add(convolution(n_filters, hype_space)) if hype_space['conv_dropout'] is not None: model.add(conv_dropout(hype_space)) model.add(pooling(hype_space)) # adds additional conv+pool layers based on hype_space for _ in range(hype_space['nb_conv_pool_layers'] - 1): model.add(convolution(n_filters, hype_space)) if hype_space['conv_dropout'] is not None: model.add(conv_dropout(hype_space)) if two_conv_layers: model.add(convolution(n_filters, hype_space)) if hype_space['conv_dropout'] is not None: model.add(conv_dropout(hype_space)) model.add(pooling(hype_space)) # fully connected layers model.add(Flatten()) model.add(keras.layers.core.Dense( units=int(round(hype_space['fc_nodes_1'])), activation=hype_space['activation'], kernel_regularizer=keras.regularizers.l2(hype_space['l2_weight_reg']) )) model.add(fc_dropout(hype_space)) if hype_space['fc_second_layer'] is not None: model.add(keras.layers.core.Dense( units=int(round(hype_space['fc_second_layer'])), activation=hype_space['activation'], kernel_regularizer=keras.regularizers.l2(hype_space['l2_weight_reg']))) model.add(fc_dropout(hype_space)) model.add(Dense(num_classes, activation='softmax')) # Finalize and compile model: model.compile( optimizer=OPTIMIZER_STR_TO_CLASS[hype_space['optimizer']]( lr=hype_space['lr_rate']), loss='categorical_crossentropy', metrics=['accuracy'] ) return model
def model_train_val_bow(X_train, X_val, y_train, y_val, vocab_size, max_sent_len): BATCH_SIZE = 16 EPOCHS = 300 print(f"BATCH_SIZE: {BATCH_SIZE}") model = Sequential() # 128, 64, 64 or 32, 网络结构的调整. 效果没有提升,基本不变 model.add( Embedding( input_dim=vocab_size + 1, output_dim=64, input_length=max_sent_len, mask_zero=True, name="embedding")) # mask_zero=True 不比mask_zero=False好, 基本差不多 # model.add(LSTM(units=64, return_sequences=True, dropout=0.25, name="lstm1")) model.add(LSTM(units=32, return_sequences=False, dropout=0.5, name="lstm1")) # model.add(LSTM(units=128, return_sequences=False, dropout=0.25, name="lstm2")) model.add(Dense(units=5, activation="softmax", name="dense3")) model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) early_stopping = EarlyStopping(monitor="val_loss", patience=10) lr_reduction = ReduceLROnPlateau(monitor="val_loss", patience=5, verbose=1, factor=0.2, min_lr=1e-5) # 检查最好模型: 只要有提升, 就保存一次 model_path = "../data/output/models/best_model_{epoch:02d}_{val_loss:.2f}.hdf5" # 保存到多个模型文件 # model_path = "../data/output/models/best_model.hdf5" # 保存到1个模型文件(因为文件名相同) checkpoint = ModelCheckpoint(filepath=model_path, monitor="val_loss", verbose=1, save_best_only=True, mode="min") # checkpoint = ModelCheckpoint(filepath=model_path, monitor="val_acc", verbose=1, save_best_only=True, mode="max") # hist_obj = model.fit(X_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_split=0.1) hist_obj = model.fit(X_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1, validation_data=(X_val, y_val), callbacks=[early_stopping, lr_reduction, checkpoint]) # shuffle默认值是True """ # NOTE: 上一行中validation_data改成validation_split=0.3后准确率下降了5~6个百分点: 当使用validation_split时"The validation data is selected from the last samples in the x and y data provided, before shuffling." 准确率下降可能和shuffle是有关的, 因为是在shuffle之前进行的切割,可能训练集、验证集的数据均衡性分布有问题,导致训练效果变差 "shuffle: whether to shuffle the training data before each epoch" 此外, 本来使用validation_split是想使用交叉验证的,但似乎并不会起到交叉验证的作用(不一定,需要进一步确认), 只是把这些数据剔除出来不进行训练, 和sklearn的train_test_split是一样的,但train_test_split提供了shuffle, 所以还是train_test_split好些 """ with open(f"../data/output/history_{BATCH_SIZE}.pkl", "wb") as f: pickle.dump(hist_obj.history, f)
def model_train_and_fit(samples_num,n_in=10,epochs=25, batch_size=32): values = ndata.iloc[:samples_num,:].values scaler = MinMaxScaler(feature_range=(0, 1)) scaled = scaler.fit_transform(values) scaled_y = scaled[:,0:1] scaled_exc_y = scaled[:,1:] scaled_columns = ['speed_wind_30s_avr','temp_de','speed_generator','temp_nde','speed_rotor', 'speed_high_shaft', 'temp_ambient', 'temp_main_bearing'] # 将序列数据转化为监督学习数据 """ Frame a time series as a supervised learning dataset. Arguments: data: Sequence of observations as a list or NumPy array. n_in: Number of lag observations as input (X). n_out: Number of observations as output (y). dropnan: Boolean whether or not to drop rows with NaN values. Returns: Pandas DataFrame of series framed for supervised learning. """ # n_in = 10 #调整n_in 即可 # 将序列数据转化为监督学习数据 reframed = series_to_supervised(scaled_exc_y, scaled_columns, n_in, 0) #对齐powert 与 t-5的数据 scaled_y = scaled[:-n_in,0:1] reframed['power(t)'] = scaled_y values = reframed.values #划分训练集和测试集 train_size = round(len(values)*0.67) train = values[:train_size,:] test = values[train_size:,:] train_x, train_y = train[:, :-1], train[:, -1] test_x, test_y = test[:, :-1], test[:, -1] # 为了在LSTM中应用该数据,需要将其格式转化为3D format,即[Samples, timesteps, features] train_X = train_x.reshape((train_x.shape[0],1, train_x.shape[1])) test_X = test_x.reshape(( test_x.shape[0],1, test_x.shape[1])) model = Sequential() #model.add(LSTM(10, input_shape=(train_X.shape[1], train_X.shape[2]))) model.add(LSTM(10,input_shape=(train_X.shape[1], train_X.shape[2]))) model.add(Dense(1)) model.compile(loss='mae', optimizer='adam') history = model.fit(train_X, train_y, epochs=25, batch_size=32) # , validation_data=(test_X, test_y) ''' 对数据绘图 ''' plt.plot(history.history['loss'], label='train') # plt.plot(history.history['val_loss'], label='test') plt.legend() plt.show() # make the prediction,为了在原始数据的维度上计算损失,需要将数据转化为原来的范围再计算损失 yHat = model.predict(test_X) ''' 这里注意的是保持拼接后的数组 列数 需要与之前的保持一致 ''' inv_yHat = concatenate((yHat, test_x[:,:8]), axis=1) # 数组拼接 inv_yHat = scaler.inverse_transform(inv_yHat) inv_yHat = inv_yHat[:, 0] test_y = test_y.reshape((len(test_y), 1)) inv_y = concatenate((test_y, test_x[:, :8]), axis=1) inv_y = scaler.inverse_transform(inv_y) # 将标准化的数据转化为原来的范围 inv_y = inv_y[:, 0] rmse = sqrt(mean_squared_error(inv_yHat, inv_y)) print('Test RMSE: %.3f' % rmse) ahead_second = n_in * 30 plt.figure(12) plt.suptitle("%s s ahead,Test RMSE:%s"%(ahead_second,rmse)) plt.subplot(221),plt.plot(inv_yHat,label='predict') plt.legend() plt.subplot(223),plt.plot(inv_y,label='raw') plt.legend() plt.subplot(122),plt.plot(inv_y,label='raw'),plt.plot(inv_yHat,label='predict') plt.legend() plt.show()
def model(self, country): self.country = country time = list(range(1, len(self.df) + 1)) # 解决画图时中文乱码问题 from pylab import mpl mpl.rcParams['font.sans-serif'] = ['SimHei'] # 试测Arima模型 # Arima模型忽略了确诊,死亡,治愈的关联关系,只是单纯依靠时间做的预测 # 进行ADF检验 ''' pList = [] for i in range(1, 10): series = self.df['China'].diff(2) series.fillna(0, inplace=True) p = adfuller(series)[1] pList.append({str(i): p}) # 计算p值 ''' # 发现1-10阶的差分的数据都通不过显著性检验,即p>0.05 故而舍弃Arima算法 # # 试测logistics曲线模型 # 设置参数范围 if self.method == 'logistics': bounds = ([self.df[country][1], self.df[country][1], 0], [ self.df[country][len(time)], self.df[country][len(time)], 1 ]) # 开始最优化参数 self.popt, self.pcov = curve_fit(Model_Function.logistics, time, self.df[country], bounds=bounds) x = self.dayTime y = self.df[country] y_pre = pd.Series([ ceil( Model_Function.logistics(time[i], self.popt[0], self.popt[1], self.popt[2])) for i in range(len(time)) ]) # 采用LSTM算法 elif self.method == 'LSTM': # 设置随机种子 np.random.seed(1) # 设置滑动窗口 self.windows = 2 # 标准化 self.scaler = MinMaxScaler(feature_range=(0, 1)) self.dataSet = pd.DataFrame(self.scaler.fit_transform( pd.DataFrame(self.df[country])), index=time) #dataSet = pd.DataFrame(scaler.fit_transform(self.df), columns=self.df.columns, index=self.df.index) # 创建LSTM数据集 trainX, trainY = Model_Function.createLSTMDataSet( self.dataSet[0], self.windows) # 对x进行扩维 trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) # 搭建LSTM网络 self.model = Sequential() self.model.add(LSTM(4, input_shape=(1, self.windows))) self.model.add(Dense(1)) self.model.compile(loss='mean_squared_error', optimizer='adam') # 衰减学习率 learn_rate = ReduceLROnPlateau(monitor='val_loss', patience=10, mode='max') # with open(os.path.abspath(os.path.dirname(__file__)) + '/result/learn_rate.txt', 'a', encoding='UTF-8') as f: # f.write(self.country + "的" + self.name + "LSTM模型的衰减学习率为" + str(learn_rate) + "\n") # f.close() self.model.fit(trainX, trainY, epochs=100, batch_size=5, verbose=2, callbacks=[learn_rate]) trainPredict = self.model.predict(trainX) # 反标准化 trainPredict = self.scaler.inverse_transform(trainPredict) # 计算RMSE trainY = self.scaler.inverse_transform([trainY]) trainScore = np.sqrt(sum((trainY[0, :] - trainPredict[:, 0])** 2)) / (len(trainY) * max(trainY[0, :])) with open(os.path.abspath(os.path.dirname(__file__)) + '/result/rmse.txt', 'a', encoding='UTF-8') as f: f.write(self.country + "的" + self.name + "预测与实际的RMSE为" + str(trainScore) + "\n") f.close() # print('Train Score: %.2f RMSE' % (trainScore)) x = self.dayTime[self.windows:] y = self.df[country][self.windows:] y_pre = pd.Series(trainPredict[:, 0]).astype(int) else: raise Exception('方法不存在!') x = Model_Function.timeMonthDay(x) plt.figure(figsize=[80, 60]) plt.scatter(x, y, s=35, c='blue', marker='+', label=self.name + '人数') plt.plot(x, y_pre, 'r-s', marker='+', linewidth=1.5, label="验证曲线") plt.tick_params(labelsize=8) plt.xlabel('日期', fontsize=2) plt.ylabel(self.name + '人数') x_major_locator = MultipleLocator(5) # 把x轴的刻度间隔设置为5,并存在变量里 ax = plt.gca() # ax为两条坐标轴的实例 ax.xaxis.set_major_locator(x_major_locator) plt.legend(loc=0) plt.title(self.country + "的新冠病毒疫情的" + self.name + "发展及预测情况")
def deep2_cnn_arch(x_train, y_train, epochs, batch_size, validation_split): model = Sequential() model.add( Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu', input_shape=(48, 48, 1))) conv_arch = [(32, 3), (64, 3), (128, 3)] dense = [64, 2] if (conv_arch[0][1] - 1) != 0: for i in range(conv_arch[0][1] - 1): model.add( Conv2D(conv_arch[0][0], kernel_size=(3, 3), padding='same', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) if conv_arch[1][1] != 0: for i in range(conv_arch[1][1]): model.add( Conv2D(conv_arch[1][0], kernel_size=(3, 3), padding='same', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) if conv_arch[2][1] != 0: for i in range(conv_arch[2][1]): model.add( Conv2D(conv_arch[2][0], kernel_size=(3, 3), padding='same', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) # this converts 3D feature maps to 1D feature vectors if dense[1] != 0: for i in range(dense[1]): model.add(Dense(dense[0], activation='relu')) model.add(Dropout(0.5)) model.add(Dense(y_train.shape[1], activation='softmax')) # 16 layers # optimizer: model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) print('Training....') hist = model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, validation_split=validation_split, shuffle=True, verbose=2) train_val_accuracy = hist.history train_acc = train_val_accuracy['acc'] val_acc = train_val_accuracy['val_acc'] print(' Done!') print(' Train acc: ', train_acc[-1]) print('Validation acc: ', val_acc[-1]) print(' Overfit ratio: ', val_acc[-1] / train_acc[-1]) save_model(model, index="deep2")
def get_model5(): model = Sequential() model.add(Dense(8, activation='relu', kernel_regularizer=regularizers.l2(0.01))) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[auc_roc]) return model
categorical_featuresX = sc.fit_transform(categorical_features) X = np.concatenate( (gaussian_featuresX, categorical_featuresX, disease_data.iloc[:, 10:13]), axis=1) # Reassembling the data after nomalization Y = disease_data.iloc[:, 13] sc = StandardScaler() X = sc.fit_transform(X) # Splitting data for Training and Test sets X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.30) ## CREATING NEURAL NETWORKS classifier = Sequential() # First Hidden Layer classifier.add( Dense(7, activation='tanh', kernel_initializer='random_normal', input_dim=13)) # Second Hidden Layer classifier.add(Dense(7, activation='tanh', kernel_initializer='random_normal')) # Output Layer classifier.add( Dense(1, activation='sigmoid', kernel_initializer='random_normal')) # Compiling the neural network classifier.compile(optimizer='adam',
# Turn into an array X_train = X_train.values X_test = X_test.values y_train = y_train.values y_test = y_test.values # Keras || OverSampling (SMOTE): # Synthetic Minority Over-sampling TEchnique - It will create the new point between minority values within the minority range. sm = SMOTE(random_state=42) Xsm_train, ysm_train = sm.fit_sample(X_train, y_train) n_inputs = Xsm_train.shape[1] print('model input=', n_inputs) model = Sequential([ Dense(n_inputs, input_shape=(n_inputs, ), activation='relu'), Dense(32, activation='relu'), Dense(10, activation='relu'), Dense(2, activation='softmax') ]) model.compile(Adam(lr=0.002), loss='sparse_categorical_crossentropy', metrics=['accuracy']) print(model.summary()) model.fit(Xsm_train, ysm_train, validation_split=0.2, batch_size=300, epochs=20, shuffle=True,
# Fill missing or null values with mean column values in the train set import numpy as np # Encoding categorical data from sklearn.preprocessing import LabelEncoder from sklearn import preprocessing labelEncoder = preprocessing.LabelEncoder() labelEncoder.fit(dataset['diagnosis']) dataset['diagnosis'] = labelEncoder.transform(dataset['diagnosis']) dataset=dataset.values X_train, X_test, Y_train, Y_test = train_test_split(dataset[:,2:32], dataset[:,1], test_size=0.25, random_state=87) np.random.seed(155) my_first_nn = Sequential() # create model my_first_nn.add(Dense(10, input_dim=30, activation='relu'))# hidden layer my_first_nn.add(Dense(32, activation='softplus')) #my_first_nn.add(Dense(156, activation='sigmoid')) #added one laye #my_first_nn.add(Dense(7, activation='sigmoid')) #added another layer my_first_nn.add(Dense(1, activation='sigmoid')) # output layer my_first_nn.compile(loss='binary_crossentropy', optimizer='adam') my_first_nn_fitted = my_first_nn.fit(X_train, Y_train, epochs=100, verbose=0, initial_epoch=0) print(my_first_nn.summary()) print(my_first_nn.evaluate(X_test, Y_test, verbose=0))
tied_to=encoder1, use_bias=False) encoder2 = Dense(hidden_dim, activation="relu", input_shape=(encoding_dim, ), use_bias=True, kernel_regularizer=WeightsOrthogonalityConstraint( encoding_dim, weightage=1., axis=0), kernel_constraint=UnitNorm(axis=0)) decoder2 = DenseTied(encoding_dim, activation="relu", tied_to=encoder2, use_bias=False) autoencoder = Sequential() autoencoder.add(encoder1) autoencoder.add(encoder2) autoencoder.add(decoder2) autoencoder.add(decoder1) autoencoder.summary() autoencoder.compile(metrics=['accuracy'], loss='mean_squared_error', optimizer='adam') #earlyStopping = EarlyStopping(monitor='val_loss', patience=10, verbose=0, mode='min') mcp_save = ModelCheckpoint('autoencoder_classifier.h5', save_best_only=True, monitor='val_loss',
print((cv_results["test-rmse-mean"]).tail(1)) ## Neural Network with Keras #based off https://www.freecodecamp.org/news/how-to-build-your-first-neural-network-to-predict-house-prices-with-keras-f8db83049159/ #I'm also messing with the hyperparms as I go. Here's some notes so not to try things many times #sequential layer, relu, relu, sigmoid works best #softmax->relu # tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead. # define the keras model from tensorflow.keras import layers model = Sequential() model.add(Dense(12, input_shape=((900,)), activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # model = Sequential([ Dense(40, activation='relu', input_shape=(900,)), Dense(32, activation='relu'), Dense(1, activation='sigmoid')]) # model.compile(optimizer='sgd', loss='binary_crossentropy', metrics=['accuracy']) #adam is stochastic gradient descent algorithm # model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.compile(loss='mean_squared_error',optimizer='sgd',metrics=[metrics.mae]) ) hist = model.fit(x_train, y_train, batch_size=64, epochs=100,validation_data=(x_train,y_train),verbose=0) # model.evaluate(X_test, Y_test)[1] Y_pred = model.predict(x_test) loss_NN = model.evaluate(x_test, y_test, batch_size=128) print(model.metrics_names) print(loss_NN)