def create_model(): model = Sequential() model.add(Conv2D(LAYER1_SIZE, activation="relu", kernel_size=(3, 3), input_shape=(2, BOARD_SIZE, BOARD_SIZE), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(Conv2D(LAYER1_SIZE, activation="relu", kernel_size=(3, 3), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(MaxPooling2D((2, 2), data_format="channels_first")) model.add(Conv2D(LAYER1_SIZE * 2, activation="relu", kernel_size=(3, 3), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(Conv2D(LAYER1_SIZE * 2, activation="relu", kernel_size=(3, 3), data_format="channels_first", kernel_regularizer=l2(L2_REGULARISATION), padding='same')) model.add(MaxPooling2D((2, 2), data_format="channels_first")) model.add(Flatten()) model.add(Dense(LAYER2_SIZE, activation='relu', kernel_regularizer=l2(L2_REGULARISATION))) model.add(Dense(1, activation='tanh')) optimizer = Adam(decay=DECAY, lr=LR) model.compile(loss='mse', optimizer=optimizer, metrics=['accuracy', 'mae']) model.summary() return model
def create(cls, tokenizer: Tokenizer, hidden: int, dropout: float) -> "LanguageModel": from keras import Sequential from keras.layers import LSTM, Dropout, Dense if tokenizer.vocabulary_size == 0: logging.warning("Creating a model using a codec with an empty vocabulary.") model = Sequential() model.add(LSTM(hidden, input_shape=(tokenizer.context_size, 1))) model.add(Dropout(dropout)) model.add(Dense(tokenizer.vocabulary_size, activation="softmax")) model.compile(loss="categorical_crossentropy", optimizer="adam") return cls(model, tokenizer)
def train_model(train_test_path): """ Creates a model and performs training. """ # Load train/test data train_test_data = np.load(train_test_path) x_train = train_test_data['X_train'] y_train = train_test_data['y_train'] print("x_train:", x_train.shape) print("y_train:", y_train.shape) del train_test_data x_train = np.expand_dims(x_train, axis=3) # Create network model = Sequential() model.add(Conv1D(128, 5, input_shape=x_train.shape[1:], padding='same', activation='relu')) model.add(MaxPooling1D(5)) model.add(Conv1D(128, 5, padding='same', activation='relu')) model.add(MaxPooling1D(5)) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(1024, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(512, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(256, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(128, kernel_initializer='glorot_uniform', activation='relu')) model.add(Dropout(0.5)) model.add(Dense(len(language_codes), kernel_initializer='glorot_uniform', activation='softmax')) model_optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) model.compile(loss='categorical_crossentropy', optimizer=model_optimizer, metrics=['accuracy']) # Train model.fit(x_train, y_train, epochs=10, validation_split=0.10, batch_size=64, verbose=2, shuffle=True) model.save(model_path)
def build_model(spec, X_train): model = Sequential() # create first layer layer = spec[0] num_posts, bow_dim = X_train[0].shape model.add(InputLayer(input_shape=(num_posts, bow_dim))) model.add(Flatten()) if 'none' in layer: model.add(Dense( # input_dim=1, units=int(layer.split('none')[1]), activation=None )) elif 'relu' in layer: model.add(Dense( # input_shape=train_X[0].shape, units=int(layer.split('relu')[1]), activation='relu' )) elif 'sig' in layer: model.add(Dense( # input_shape=train_X[0].shape, units=int(layer.split('sig')[1]), activation='sigmoid' )) else: return None for layer in spec[1:]: if 'none' in layer: model.add(Dense(int(layer.split('none')[1]), activation=None)) elif 'relu' in layer: model.add(Dense(int(layer.split('relu')[1]), activation='relu')) elif 'sig' in layer: model.add(Dense(int(layer.split('sig')[1]), activation='sigmoid')) elif 'drop' in layer: model.add(Dropout(float(layer.split('drop')[1]), seed=None)) elif 'l1' in layer: model.add(ActivityRegularization(l1=float(layer.split('l1')[1]))) elif 'l2' in layer: model.add(ActivityRegularization(l2=float(layer.split('l2')[1]))) else: return None # add softmax layer model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def create_lstm_model(num_features): model = Sequential() # "Encode" the input sequence using an RNN, producing an output of HIDDEN_SIZE. # Note: In a situation where your input sequences have a variable length, # use input_shape=(None, num_feature). # By setting return_sequences to True, return not only the last output but # all the outputs so far in the form of (num_samples, timesteps, # output_dim). This is necessary as TimeDistributed in the below expects # the first dimension to be the timesteps. model.add(RNN(HIDDEN_SIZE, input_shape=(None, num_features), return_sequences=True)) # Apply a dense layer to the every temporal slice of an input. For each of step # of the output sequence, decide which character should be chosen. model.add(layers.TimeDistributed(layers.Dense(len(LABEL_CLASS_MAPPING) + 1))) model.add(layers.Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() return model
import numpy as np import tensorflow as tf from keras import Sequential from keras.layers import Dense print("Tensorflow version", tf.__version__) model1 = Sequential() model1.add(Dense(10, input_shape=(1000,))) model1.add(Dense(3, activation='relu')) model1.compile('sgd', 'mse') def gen(): while True: yield np.zeros([10, 1000]), np.ones([10, 3]) import os import psutil process = psutil.Process(os.getpid()) g = gen() while True: print(process.memory_info().rss / float(2 ** 20)) model1.fit_generator(g, 100, 2, use_multiprocessing=True, verbose=0) model1.evaluate_generator(gen(), 100, use_multiprocessing=True, verbose=0)
from keras.layers import Dense, Flatten, Convolution2D, MaxPooling2D from keras import Sequential from keras_preprocessing.image import ImageDataGenerator classifier = Sequential() classifier.add( Convolution2D(32, 3, 3, input_shape=(32, 32, 3), activation='relu')) #relu=rectifier linear fiuntion classifier.add(MaxPooling2D(pool_size=(2, 2))) #pooling layer for kernal classifier.add(Flatten()) #flatenning the inputs classifier.add(Dense(64, activation='relu') ) #creating ANN and flanetting outputs are now inputs for ANN classifier.add(Dense(1, activation='sigmoid')) #says prob of what ans is classifier.compile( optimizer='adam', metrics=['accuracy'], loss='binary_crossentropy' ) #adam=sgd,in we hace more than 2 inputs then loss = 'catogirical_crossentropy' #layers are finished till here NN is done #to increase accuracy add deepNN oincrease dense to 64 or 128 or anything up to you train_datagen = ImageDataGenerator(rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) train_set = train_datagen.flow_from_directory( 'C:/Users/hrith/Downloads/cat-and-dog/training_set/training_set', target_size=(32, 32), batch_size=25, class_mode='binary')
model.add(MaxPooling2D((3, 3))) model.add(Dropout(0.3)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add(Dense(64, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add(Dense(10, activation='softmax')) model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(lr=0.002, epsilon=None), metrics=['acc']) learning_history = model.fit_generator(train_generator, epochs=2000, validation_data=valid_generator, callbacks=[es, mc, reLR]) # predict model.load_weights('best_cvision.h5') result += model.predict_generator(test_generator, verbose=True) / 40 # save val_loss hist = pd.DataFrame(learning_history.history) val_loss_min.append(hist['val_loss'].min())
def fitting(self): timesteps = self.lags # tiempo features = 1 # features or chanels (Volume) num_classes = 3 # 3 for categorical #data = np.random.random((1000, dim_row, dim_col)) #clas = np.random.randint(3, size=(1000, 1)) ##print(clas) #clas = to_categorical(clas) ##print(clas) data = self.X_train data_test = self.X_test print(data) data = data.values.reshape(len(data), timesteps, 1) data_test = data_test.values.reshape(len(data_test), timesteps, 1) print(data) clas = self.y_train clas_test = self.y_test clas = to_categorical(clas) clas_test = to_categorical(clas_test) cat0 = self.y_train.tolist().count(0) cat1 = self.y_train.tolist().count(1) cat2 = self.y_train.tolist().count(2) print("may: ", cat1, " ", "menor: ", cat2, " ", "neutro: ", cat0) n_samples_0 = cat0 n_samples_1 = (cat1 + cat2)/2.0 n_samples_2 = (cat1 + cat2)/2.0 class_weight={ 0: 1.0, 1: n_samples_0/n_samples_1, 2: n_samples_0/n_samples_2} def class_1_accuracy(y_true, y_pred): # cojido de: http://www.deepideas.net/unbalanced-classes-machine-learning/ class_id_true = K.argmax(y_true, axis=-1) class_id_preds = K.argmax(y_pred, axis=-1) accuracy_mask = K.cast(K.equal(class_id_preds, 1), 'int32') class_acc_tensor = K.cast(K.equal(class_id_true, class_id_preds), 'int32') * accuracy_mask class_acc = K.sum(class_acc_tensor) / K.maximum(K.sum(accuracy_mask), 1) return class_acc class SecondOpinion(Callback): def __init__(self, model, x_test, y_test, N): self.model = model self.x_test = x_test self.y_test = y_test self.N = N self.epoch = 1 def on_epoch_end(self, epoch, logs={}): if self.epoch % self.N == 0: y_pred = self.model.predict(self.x_test) pred_T = 0 pred_F = 0 for i in range(len(y_pred)): if np.argmax(y_pred[i]) == 1 and np.argmax(self.y_test[i]) == 1: pred_T += 1 if np.argmax(y_pred[i]) == 1 and np.argmax(self.y_test[i]) != 1: pred_F += 1 if pred_T + pred_F > 0: Pr_pos = pred_T/(pred_T + pred_F) print("Yoe: epoch, Probabilidad pos: ", self.epoch, Pr_pos) else: print("Yoe Probabilidad pos: 0") self.epoch += 1 ################################################################################################################# model = Sequential() if self.nConv == 0: model.add(LSTM(units=self.lstm_nodes, return_sequences=True, activation='tanh', input_shape=(timesteps, features), bias_regularizer=regularizers.l1_l2(l1=0.01, l2=0.01))) for i in range(self.nLSTM - 2): model.add(LSTM(units=self.lstm_nodes, return_sequences=True, activation='tanh')) model.add(LSTM(units=self.lstm_nodes, activation='tanh')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax')) # the dimension of index one will be considered to be the temporal dimension #model.add(Activation('sigmoid')) # for loss = 'binary_crossentropy' # haciendo x: x[:, -1, :], la segunda dimension desaparece quedando solo # los ULTIMOS elementos (-1) de dicha dimension: # Try this to see: # data = np.random.random((5, 3, 4)) # print(data) # print(data[:, -1, :]) # model.add(Lambda(lambda x: x[:, -1, :], output_shape = [output_dim])) print(model.summary()) tensorboard_active = False val_loss = False second_opinion = True callbacks = [] if tensorboard_active: callbacks.append(TensorBoard( log_dir=self.putmodel + "Tensor_board_data", histogram_freq=0, write_graph=True, write_images=True)) if val_loss: callbacks.append(EarlyStopping( monitor='val_loss', patience=5)) if second_opinion: callbacks.append(SecondOpinion(model, data_test, clas_test, 10)) #model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = ['categorical_accuracy']) #model.compile(loss = 'binary_crossentropy', optimizer=Adam(lr=self.learning), metrics = ['categorical_accuracy']) model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy]) model.fit(x=data, y=clas, batch_size=self.batch_size, epochs=800, verbose=2, callbacks = callbacks, class_weight = class_weight) #validation_data=(data_test, clas_test)) ##################################################################################################################### # serialize model to YAML model_yaml = model.to_yaml() with open("model.yaml", "w") as yaml_file: yaml_file.write(model_yaml) # serialize weights to HDF5 model.save_weights("model.h5") print("Saved model to disk") # # load YAML and create model # yaml_file = open('model.yaml', 'r') # loaded_model_yaml = yaml_file.read() # yaml_file.close() # loaded_model = model_from_yaml(loaded_model_yaml) # # load weights into new model # loaded_model.load_weights("model.h5") # print("Loaded model from disk") # loaded_model.compile(loss = 'categorical_crossentropy', optimizer='Adam', metrics = [class_1_accuracy]) # print("Computing prediction ...") y_pred = model.predict_proba(data_test) model.reset_states() print("Computing train evaluation ...") score_train = model.evaluate(data, clas, verbose=2) print('Train loss:', score_train[0]) print('Train accuracy:', score_train[1]) model.reset_states() # score_train_loaded = loaded_model.evaluate(data, clas, verbose=2) # loaded_model.reset_states() # print('Train loss loaded:', score_train[0]) # print('Train accuracy loaded:', score_train[1]) print("Computing test evaluation ...") score_test = model.evaluate(data_test, clas_test, verbose=2) print('Test loss:', score_test[0]) print('Test accuracy:', score_test[1]) model.reset_states() # score_test_loaded = loaded_model.evaluate(data_test, clas_test, verbose=2) # loaded_model.reset_states() # print('Test loss loaded:', score_test[0]) # print('Test accuracy loaded:', score_test[1]) pred_T = 0 pred_F = 0 for i in range(len(y_pred)): if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) == 1: pred_T += 1 # print(y_pred[i]) if np.argmax(y_pred[i]) == 1 and np.argmax(clas_test[i]) != 1: pred_F += 1 if pred_T + pred_F > 0: Pr_pos = pred_T/(pred_T + pred_F) print("Yoe Probabilidad pos: ", Pr_pos) else: print("Yoe Probabilidad pos: 0") history = DataFrame([[self.skip, self.nConv, self.nLSTM, self.learning, self.batch_size, self.conv_nodes, self.lstm_nodes, score_train[0], score_train[1], score_test[0], score_test[1]]], columns = ('Skip', 'cConv', 'nLSTM', 'learning', 'batch_size', 'conv_nodes', 'lstm_nodes', 'loss_train', 'acc_train', 'loss_test', 'acc_test')) self.history = self.history.append(history)
class RLAgent(AgentInterface): """description of class""" def __init__(self, actionSelector, memoryFileName=None, discountFactor=0.95): self.discountFactor = discountFactor self.model = Sequential() self.model.add( Dense(100, input_shape=(42, ), activation='relu', kernel_initializer='zeros')) self.model.add( Dense(100, activation='relu', kernel_initializer='zeros')) self.model.add( Dense(100, activation='relu', kernel_initializer='zeros')) self.model.add( Dense(100, activation='relu', kernel_initializer='zeros')) self.model.add(Dense(7, kernel_initializer='zeros')) self.model.compile(sgd(lr=.2), 'mse') #self.model.compile( loss = 'mse', optimizer = 'adam', metrics = [ 'mae' ] ) if memoryFileName: inputs, targets = self._prepare_memory(memoryFileName) self.model.train_on_batch(inputs, targets) self.reset() self.actionSelector = actionSelector self.memory = [] @staticmethod def _prepare_memory(memoryFileName): memory = pickle.load(open(memoryFileName, 'rb')) memory_size = len(memory) inputs = np.zeros((memory_size, 42)) targets = np.zeros((memory_size, 7)) for i in range(memory_size): state, action, reward = memory[i] inputs[i] = state.board.reshape(1, -1) targets[i, action] = reward return inputs, targets def __del__(self): #self.save() pass def getAction(self): action = self.actionSelector.getAction( self.model.predict(self.board.asVector())) self.lastAction = action return action def _remember(self, state, action, reward): self.memory.append((state, action, reward)) def save(self): t = datetime.now() file = open( 'c:\\work\\memories_{}_{}.pkl'.format(t.date(), t.time().microsecond), 'wb') pickle.dump(self.memory, file) def update(self, nextState, reward): return if self.lastAction is None: self.board = nextState.make_copy() return if reward == 0: ## if there's a non zero reward, that's the last move of the game and there's no discounting of future rewards #target = self.discountFactor * np.max( self.model.predict( nextState.asVector() ) ) self.board = nextState.make_copy() return else: self._remember(self.board, self.lastAction, reward) # target = reward #target_vec = self.model.predict( self.board.asVector() )[ 0 ] #target_vec[ self.lastAction ] = target #target_vec = target_vec.reshape( -1, 7 ) #self.model.fit( self.board.asVector(), target_vec, epochs = 1, verbose = 0 ) #return #if reward == 0: # self.board = nextState.make_copy() def reset(self): self.board = Board() self.lastAction = None
def neural_network(): dataset = read_dataset('dataset','csv') df = normalize(dataset) y = np.array(df['DO%']) df.drop(columns='DO%',inplace=True) df.head() x = df.values folds = 2 rmse_avg = [] r2_avg = [] nrmse_avg = [] loss_avg = [] folds = 1 for i in range(folds): X_train,X_test,Y_train,Y_test = train_test_split(x,y,test_size = 0.2) print(X_train.shape,X_test.shape,Y_train.shape,Y_test.shape) model = Sequential() model.add(layers.Dense(256,activation = 'relu',input_shape = (X_train.shape[1],))) #model.add(layers.Dropout(0.3)) model.add(layers.Dense(128,activation='relu')) model.add(layers.Dense(64,activation = 'relu')) #model.add(layers.Dropout(0.3)) model.add(layers.Dense(32,activation = 'relu')) #model.add(layers.Dropout(0.3)) model.add(layers.Dense(16, activation = 'relu')) model.add(layers.Dense(8, activation = 'relu')) model.add(layers.Dense(1,activation = 'linear')) sgd = keras.optimizers.SGD(lr =0.001,decay=1e-6,momentum = 0.9,nesterov = True) model.compile(optimizer = 'Adam',loss = 'mean_squared_error',metrics = ['mean_squared_error']) print(model.summary()) count = 0 history = model.fit(X_train,Y_train,epochs = 100,batch_size=64,validation_data = (X_test,Y_test)) preds = model.predict(X_test) preds1 = model.predict(x) result = model.evaluate(X_test,Y_test) loss = result[0] print(result) rmse_test = mean_squared_error(Y_test, preds) r2_test = r2_score(Y_test, preds) print("MSE of test set is {}".format(rmse_test)) print("R score of test set is {}".format(r2_test)) nrmse = cal_nrmse(Y_test,preds) print("nrmse of test set is {}".format(nrmse)) loss_avg.append(loss) rmse_avg.append(rmse_test) r2_avg.append(r2_test) nrmse_avg.append(nrmse) with open('res_nn_paper.txt','a') as f: count = count + 1 f.write("fold=%s\n" % str(count)) f.write("rmse=%s\n" % str(rmse_test)) f.write("loss=%s\n" % str(loss)) f.write("r score=%s\n" % str(r2_test)) f.write("nrmse=%s\n" % str(nrmse)) f.write("-------------------------------------------------\n") #print("Mean_absolute_percentage_error of test set is",mean_absolute_percentage_error(Y_test,preds)) plt.plot(history.history['mae']) plt.plot(history.history['val_mae']) plt.title('model mae') plt.ylabel('mae') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show(block=False) plt.pause(1) plt.close() plt.plot(history.history['mse']) plt.plot(history.history['val_mse']) plt.title('model mse') plt.ylabel('mae') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show(block=False) plt.pause(1) plt.close() plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show(block=False) plt.pause(1) plt.close() print('True 10 samples',Y_test[0:10]) print('Predicted 10 samples',preds[0:10]) arra = [] arrak = [] from tqdm import tqdm ''' for i in tqdm(range(0,39988)): arrak.append(i) plt.gca().set_prop_cycle("color", ['blue','green']) plt.title('For DO% NN') plt.plot(np.array(arrak),y) plt.plot(np.array(arrak),np.array(preds1)) plt.xlabel('Index') plt.ylabel('Values') plt.legend(['Normal data', ' Predicted Output'], loc='upper left') plt.show(block=False) plt.pause() plt.close() ''' nrmse_avg = np.array(nrmse_avg) r2_avg = np.array(r2_avg) rmse_avg = np.array(rmse_avg) loss_avg = np.array(loss_avg) print("RMSE is {}".format(rmse_avg.mean())) print("R score is {}".format(r2_avg.mean())) print("loss_avgis{}".format(loss_avg.mean())) print("nrmse is {}".format(nrmse_avg.mean()))
classifier.add(Conv2D(128, kernel_size=3, padding="same", activation='relu')) classifier.add(MaxPooling2D(pool_size=(2, 2))) classifier.add(Dropout(0.25)) classifier.add(Conv2D(256, kernel_size=3, padding="same", activation='relu')) classifier.add(MaxPooling2D(pool_size=(2, 2))) classifier.add(Dropout(0.25)) classifier.add(Flatten()) classifier.add(Dense(256, activation='relu')) classifier.add(Dropout(0.5)) classifier.add(Dense(10, activation='softmax')) # Compiling the ANN classifier.compile(loss='sparse_categorical_crossentropy', optimizer="Adam", metrics=['accuracy']) # Fitting the ANN to the Training set classifier.fit(train_feature, train_y, batch_size=1, epochs=100) # Part 3 - Making predictions and evaluating the classifier # Predicting the Test set results y_pred = classifier.predict(test_feature) results = np.argmax(y_pred, axis=1) data_out = pd.DataFrame({'id': range(1, 10001), 'label': results}) data_out.to_csv('submission.csv', index=None)
cls = Sequential() cls.add( Dense(100, input_dim=SIZE, activation='relu', kernel_initializer='random_uniform')) cls.add( Dense(len(y_train[0]), activation='softmax', kernel_initializer='random_uniform')) opt = Adam(lr=INIT_LR) cls.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) cls.fit(X_train, y_train, epochs=EPOCHS, steps_per_epoch=10, verbose=0) inferenceTest = cls.predict(X_test) gt = y_test correct = 0 for t in range(len(gt)): if (get_highest(inferenceTest[t]) == gt[t]).all(): correct += 1 #print correct score = correct / (len(gt) * 1.0)
def lstm(): dataset = read_dataset('dataset','csv') df = normalize(dataset) y = np.array(df['DO%']) df.drop(columns='DO%',inplace=True) df.head() x = df.values count = 0 rmse_avg = [] r2_avg = [] nrmse_avg = [] loss_avg = [] folds = 5 my_learning_rate = 0.01 for i in range(folds): model = Sequential() X_train,X_test,Y_train,Y_test = train_test_split(x,y,test_size = 0.2) print(X_train.shape,X_test.shape,Y_train.shape,Y_test.shape) es = keras.callbacks.EarlyStopping(monitor='val_loss',patience=10, verbose=1, mode='auto',restore_best_weights = True) X_train=X_train.reshape(X_train.shape[0],X_train.shape[1],1) X_test = X_test.reshape(X_test.shape[0],X_test.shape[1],1) model.add(layers.LSTM(1024,input_shape = (X_train.shape[1],1))) #model.add(layers.Dense(2048,activation = 'relu')) #model.add(layers.Dropout(0.3)) #model.add(layers.Dense(1024,activation = 'relu')) #model.add(layers.Dropout(0.3)) model.add(layers.Dense(512, activation = 'relu')) model.add(layers.Dense(256,activation='relu')) model.add(layers.Dense(128,activation='relu')) #model.add(layers.Dropout(0.3)) model.add(layers.Dense(64,activation = 'relu')) #model.add(layers.Dropout(0.3)) model.add(layers.Dense(32,activation = 'relu')) #model.add(layers.Dropout(0.3)) model.add(layers.Dense(16, activation = 'relu')) model.add(layers.Dense(8, activation = 'relu')) model.add(layers.Dense(1,activation = 'linear')) sgd = keras.optimizers.SGD(lr =0.001,decay=1e-6,momentum = 0.9,nesterov = True) model.compile(optimizer=tf.keras.optimizers.Adam(lr=my_learning_rate),loss="mean_squared_error",metrics=[tf.keras.metrics.MeanSquaredError()]) print(model.summary()) history = model.fit(X_train,Y_train,epochs = 150,batch_size =64,validation_data = (X_test,Y_test),callbacks=[es]) preds = model.predict(X_test) result = model.evaluate(X_test,Y_test) loss = result[0] print(result) rmse_test = mean_squared_error(Y_test, preds) r2_test = r2_score(Y_test, preds) print("MSE of test set is {}".format(rmse_test)) print("R score of test set is {}".format(r2_test)) nrmse = cal_nrmse(Y_test,preds) print("nrmse of test set is {}".format(nrmse)) loss_avg.append(loss) rmse_avg.append(rmse_test) r2_avg.append(r2_test) nrmse_avg.append(nrmse) with open('res_lstm_paper.txt','a') as f: count = count + 1 f.write("fold=%s\n" % str(count)) f.write("rmse=%s\n" % str(rmse_test)) f.write("loss=%s\n" % str(loss)) f.write("r score=%s\n" % str(r2_test)) f.write("nrmse=%s\n" % str(nrmse)) f.write("-------------------------------------------------\n") #print("Mean_absolute_percentage_error of test set is",mean_absolute_percentage_error(Y_test,preds)) # plt.plot(history.history['mae']) # plt.plot(history.history['val_mae']) # plt.title('model mae') # plt.ylabel('mae') # plt.xlabel('epoch') # plt.legend(['train', 'val'], loc='upper left') # plt.show(block=False) # plt.pause(3) # plt.close() plt.plot(history.history["mean_squared_error"]) plt.plot(history.history["val_mean_squared_error"]) plt.title('model mse') plt.ylabel('mae') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show(block=False) plt.pause(3) plt.close() plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['train', 'val'], loc='upper left') plt.show(block=False) plt.pause(3) plt.close() nrmse_avg = np.array(nrmse_avg) r2_avg = np.array(r2_avg) rmse_avg = np.array(rmse_avg) loss_avg = np.array(loss_avg) print("RMSE is {}".format(rmse_avg.mean())) print("R score is {}".format(r2_avg.mean())) print("loss_avgis{}".format(loss_avg.mean())) print("nrmse is {}".format(nrmse_avg.mean()))
trainDATA = trainDS[:,1:] trainLABLE = trainDS[:,0] print("Start training!") print("{} secondes have passed. ".format(str(time.time() - startTime))) np.random.seed(10) myModel = Sequential() myModel.add(Dense(units=64,input_dim=39, activation='relu')) myModel.add(Dense(units=8, activation='relu')) myModel.add(Dense(1, activation='sigmoid')) myModel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) myModel.fit(x=trainDATA, y=trainLABLE, epochs=NUM_EPOCH, batch_size=64) # Save the trained model myModel_json = myModel.to_json() with open(modelDIR + '/' + modelFILE, 'w') as json_file: json_file.write(myModel_json) myModel.save_weights(modelDIR + '/' + weightFILE) print("The trained model has been saved.") print("Start testing!") print("Time point 3 is " + str(time.time() - startTime)) # Load the model
def train(datapath,layer): train_cycle,c_c,threshold,activate,pool,imgpath,row,col,bands,value,dtype,dtypevalue=extract() values = [] c_l={} path=datapath c=0 for add in path: c=int(c)+1 print("{} class {} ".format(add,c)) c_l[add]=c clicks={} for address in path: with open(address, "rb") as f: k = len(f.read()) clicks[address] = (k // 2 // bands) if (k // 2 // bands) < 400 else (k // 2 // bands) // 4 print('{} ==> {}'.format(address, clicks[address])) for address in path: with open(address, "rb") as f: b = array.array("H") b.fromfile(f, clicks[address]*bands) if sys.byteorder == "little": b.byteswap() for v in b: values.append(v) ll = (len(values)) rex = ll // bands print(ll, rex) f_in = np.zeros([ll], dtype) x = 0 for i in range(ll): f_in[x] = values[i] x += 1 y_train = np.zeros([rex], dtype) mark = 0 for add in path: for i in range(clicks[add]): y_train[mark+i] = c_l[add] mark = mark + clicks[add] x_train = f_in.reshape(rex, bands) seed = 6 np.random.seed(seed) x_train = x_train / (2**(dtypevalue-1)) num_pixels = bands for v in y_train: print(v, end=" ") y_train = np_utils.to_categorical(y_train) n_classes = c_c print(x_train) print(20*'#') print(y_train) print(x_train.shape) print(y_train.shape) X = x_train.reshape(x_train.shape[0], bands, 1) n_units=128 n_classes=c_c batch_size=50 j=3 t=int(len(layer))-1 model = Sequential() for i in range(0,len(layer)): if(layer[i]=="Convolution"): if(i==0): model.add(Conv1D(2 ** j, 2, activation=activate, padding='same', input_shape=[bands, 1])) else: model.add(Conv1D(2 ** j, 2, activation="relu", padding='same')) j=j+1 elif(layer[i]=="MaxPooling"): model.add(MaxPooling1D(2)) elif(layer[i]=="AveragePooling"): model.add(AveragePooling1D(2)) elif(layer[i]=="LSTM"): if(i==0): model.add(LSTM(2**j,return_sequences=False, input_shape=(bands ,1))) elif(i==t): model.add(LSTM(2**(j-1))) else: model.add(LSTM(2**j, return_sequences=True)) j=j+1 model.add(Dense(n_classes, activation='sigmoid')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() #model.fit(X, y_train, batch_size=10, epochs=10) model.fit(X, y_train, batch_size=50, epochs=train_cycle) return model,c_c,activate,threshold
test_x = data[:10000] test_y = targets[:10000] train_x = data[10000:] train_y = targets[10000:] model = Sequential() model.add(layers.Dense(50, activation="relu", input_shape=(idim,))) model.add(layers.Dropout(0.5)) model.add(layers.Dense(50, activation="relu")) model.add(layers.Dropout(0.45)) model.add(layers.Dense(50, activation="relu")) model.add(layers.Dropout(0.3)) model.add(layers.Dense(1, activation="sigmoid")) model.compile(optimizer="adam", loss="binary_crossentropy", metrics=["accuracy"]) history = model.fit(train_x, train_y, epochs=5, batch_size=3000, validation_data=(test_x, test_y)) plot_single_history(history.history) plot.show() results = model.evaluate(test_x, test_y) print(results) goodFiles = [ "good/1.txt" ] badFiles = [ "bad/1.txt" ]
return sample_X, sample_Y #this_x, this_y = gen_sample(0) model = Sequential() #model.add(LSTM(276, input_shape = (6,69), return_sequences = True)) #model.add(LSTM(276, input_shape = (6,69), return_sequences = True)) model.add(LSTM(276, input_shape=(6, 69), return_sequences=True)) #model.add(LSTM(138, input_shape = (6,69), return_sequences = True)) model.add(LSTM(207, input_shape=(6, 69))) model.add(tf.keras.layers.Dense(138, activation='relu')) #model.add(tf.keras.layers.Dense(69, activation='swish')) model.add(tf.keras.layers.Dense(69, activation='softmax')) model.compile(optimizer=keras.optimizers.Adagrad(lr=.0001), loss="categorical_crossentropy") model.summary() test_1 = [9, 36, 49, 56, 62, 9] #june 27 test_2 = [15, 28, 52, 53, 63, 18] #july 1 test_3 = [16, 21, 27, 60, 61, 6] #july4 test_4 = [3, 10, 34, 36, 62, 5] #july 8 test_5 = [14, 19, 61, 62, 64, 4] #july11 test_6 = [27, 47, 61, 62, 69, 4] #july15 test_7 = [13, 16, 32, 58, 59, 9]
def getModel(): print("Using", __name__) input("Press enter to continue...") from keras.layers import Conv2D, Dense, MaxPool2D, Activation, Flatten, Reshape, BatchNormalization, Dropout from keras.initializers import VarianceScaling from keras.optimizers import Adam from keras import Sequential model = Sequential() model.add( Conv2D(filters=32, kernel_size=(5, 5), strides=(5, 5), kernel_initializer=VarianceScaling(), input_shape=(INPUT_WIDTH, INPUT_HEIGHT, INPUT_CHANNELS))) model.add(Activation('relu')) model.add( Conv2D(filters=64, kernel_size=(2, 2), kernel_initializer=VarianceScaling())) model.add(Activation('relu')) model.add( Conv2D(filters=256, kernel_size=(2, 2), strides=(2, 2), kernel_initializer=VarianceScaling())) model.add(Activation('relu')) model.add(Flatten()) model.add( Dense( units=128, activation='relu', kernel_initializer=VarianceScaling(), )) model.add(Dropout(0.3)) model.add( Dense( units=64, activation='relu', kernel_initializer=VarianceScaling(), )) model.add(Dropout(0.3)) model.add( Dense( units=OUTPUT_LENGTH, activation='softmax', kernel_initializer=VarianceScaling(), )) model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.00001), metrics=['accuracy']) model.summary() return model
model.add( Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dense(256, activation='relu')) model.add(BatchNormalization()) model.add(Dense(10, activation='softmax')) model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy']) filepath = "best.hd5f" callback = ModelCheckpoint(filepath, monitor='val_loss', verbose=0, save_best_only=True) history_callback = model.fit(X_train, Y_train, batch_size=128, epochs=30, validation_split=0.1, callbacks=[callback]) model.load_weights("best.hd5f") Y_test = np.argmax(model.predict(X_test), axis=1) with open(outputfilename, "w") as w:
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
Conv1D(name="conv0", filters=4, kernel_size=k, strides=s, padding=p, data_format=f, dilation_rate=d, activation="sigmoid", use_bias=True, input_shape=input_shape)) #model.add(Activation(name="out", activation='sigmoid')) opt = keras.optimizers.RMSprop(learning_rate=0.0001, decay=1e-6) model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy']) print('Saving model details') save_model_details(model, prefix=name, out_dir=OUT_DIR) exp_out = model.predict(features) print("Input = ", str(features.shape), ", Out = ", str(exp_out.shape), " case - ", name) print('Saving model outputs') save_model_output(model, features, exp_out,
"""### **Treina a Rede Neural**""" # treinamento #Otimização por Gradiente Descendente (SGD) #otimizador = SGD(lr=0.001, decay=1e-6, momentum=0.9) #decay=1e-6, #otimizador = RMSprop() #otimizador = SGD() #otimizador = Adam() otimizador = Nadam() #Configura o modelo para treinamento #RN.compile(optimizer = sgd, loss = 'mean_squared_error', metrics = ['accuracy', 'mean_squared_error']) RN.compile(optimizer = otimizador, loss = 'mean_absolute_percentage_error', #tf.keras.losses.MeanAbsolutePercentageError(), #tf.keras.losses.MeanAbsoluteError(), #tf.keras.losses.MeanSquaredError(), metrics = ['mean_absolute_error', #tf.keras.metrics.RootMeanSquaredError(), 'mean_squared_error', 'mean_absolute_percentage_error','accuracy' ]) # Treina o modelo para um certo numero de epocas trainedRN = RN.fit(X_train_normalized,y_train, epochs = 350, verbose = 0) """# **Métricas de Avaliação** ### **Métricas Calculadas Automaticamente pelo Keras** """ trainedRN.model.metrics_names import math score = trainedRN.model.evaluate(X_test_normalized, y_test, verbose = 0)
# embedded = Embedding(input_dim=max_features, output_dim=num_features, input_length=maxlen, weights=[W], trainable=False) (sequence) model.add(Dropout(0.25)) # bi-directional LSTM # hidden = Bidirectional(LSTM(hidden_dim//2, recurrent_dropout=0.25)) (embedded) # bi-directional GRU model.add(Bidirectional(GRU(hidden_dim // 2, recurrent_dropout=0.25))) # 双向循环神经网络 (Bidirectional Recurrent Neural Network, Bi-RNN) 由两层循环神经网络组成, # 它们的输入相同, 只是信息传递的方向不同 model.add(Dense(2, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) print('plot model...') plot_model(model, to_file='imdb_bidirectional_lstm.png', show_shapes=True, show_layer_names=True) # 网络可视化 history = model.fit(X_train, y_train, validation_data=[X_dev, y_dev], batch_size=batch_size, epochs=nb_epoch, verbose=2) y_pred = model.predict(X_test, batch_size=batch_size)
class RNN(): def __init__(self, model=None): print("Setting up model...\n") if model == None: # setting up a sequential model self.model = Sequential() # setting up a long-short-term-memory cell, with an input size of the substring and the unique characters # the LSTM cell will be connected to a 32 dense layer self.model.add( LSTM(32, return_sequences=False, input_shape=(length, len(chars)))) # here we set up a drop out cell of 10%, this is used to make sure that we won't be overfitting the model in the long run self.model.add(Dropout(0.1)) self.model.add(Dense(512)) # self.model.add(Dropout(0.3)) # this is the final layer, it is the size of the unique characters # it will spill out a probability of what the next character should be, # we used a softmax activation function to normalize the vector between [-1,1] self.model.add(Dense(len(chars), activation='softmax')) # we are going to use Adam optimizer on the model, with a learning rate of 0.01 optimizer = Adam(learning_rate=0.01) self.model.compile(loss='categorical_crossentropy', optimizer=optimizer) else: # in the case a user want to load up a previous model print("Loading model...\n") self.model = load_model(model) print("\nModel loaded!\n") self.model.summary() def train(self): print("\nSetting up the data...\n") # we first going to shuffle the files random.shuffle(data) # the model name will be always unique as we attach the time into it # each model is named based on the substring length, batch size, and epoch size # this is used for setting up the program later when loading the model NAME = "Model_" + str(int(time.time())) + "x" + str( length) + "x" + str(batch_size) + "x" + str(epoch_size) + ".h5" # while we could specify the epoch size when compiling the model, # it was necessary to use a for loop on each file. That is because if ... # each data from the file was extracted and was appended to the array, we could run # out of memory space. A for loop also allows you to speed up the runtime of the program as ... # we can clear the previous extracted data from the memory. for eps in range(epoch_size): for filename in data: subtext = [] target = [] print("\nExtracting text from " + filename + "...\n") data_file = codecs.open("./Dataset/Converted/" + filename, "r", "utf-8") lines = "" # this variable is used in order to indicate that we at the line of the compressed data start_reading = 0 for line in data_file: if ("START READING" in line): start_reading = 1 elif (start_reading == 1): lines = lines + line # we going to break the text into a substrings # the target character which the model is going to try to predict ... # would be the next character after the substring for i in range(0, len(lines) - length, 1): subtext.append(lines[i:i + length]) target.append(lines[i + length]) # LSTM cell requires a 3D matrix as an input shape x = np.zeros((len(subtext), length, len(chars)), dtype=np.bool) y = np.zeros((len(subtext), len(chars)), dtype=np.bool) for i, text in enumerate(subtext): for t, char in enumerate(text): if char in chars: x[i, t, chars.index(char)] = 1 if target[i] in chars: y[i, chars.index(target[i])] = 1 # TensorBoard callback is used to visuals the process of our model training, # we can use this to better understand and debug our model tb_callback = TensorBoard(log_dir='logs/' + NAME[:len(NAME) - 3]) # checkpoint call back is used for backup cp_callback = ModelCheckpoint(filepath='./Models/CP_' + NAME, monitor='loss', save_best_only=True, save_weights_only=False, mode='auto', save_freq='epoch') # for better optimization, its worth to consider stoping the model early if it's not improving at all es_callback = EarlyStopping(monitor='loss', min_delta=0, patience=3, verbose=0, mode='auto') self.model.fit( x, y, epochs=1, batch_size=batch_size, callbacks=[cp_callback, tb_callback, es_callback]) save_model(self.model, './Models/' + NAME) def generate(self, size, diversity): print("\nGenerating music...\n") # this is a general text that will be added at the start of the text file # the trained model would generate a compressed text of the music data ... # but not the arbitrary information such as the title or music instrument type generated = "0, 0, Header, 1, 2, 480\n" generated = generated + "1, 0, Start_track\n" generated = generated + "1, 0, Title_t, Generated Music\n" generated = generated + "1, 0, Text_t, Sample for MIDIcsv Distribution\n" generated = generated + "1, 0, Copyright_t, This file is in the public domain\n" generated = generated + "1, 0, Time_signature, 4, 2, 24, 8\n" generated = generated + "1, 0, Tempo, 500000\n" generated = generated + "1, 0, Instrument_name_t, A-01\n" generated = generated + "1, 0, End_track\n" generated = generated + "2, 0, Start_track\n" generated = generated + "START READING\n" '''sentence = '' for i in range(length-1): sentence = sentence + " " sentence = sentence + random.choice(chars)''' # here we shuffling a data and picking a random text file as our starting point random.shuffle(data) filename = data[0] data_file = codecs.open("./Dataset/Converted/" + filename, "r", "utf-8") lines = "" start_reading = 0 for line in data_file: if ("START READING" in line): start_reading = 1 elif (start_reading == 1): lines = lines + line # we going to choose a random index from the text file as the starting point of a substring rnd_index = random.randint(0, len(lines) - length - 1) sentence = lines[rnd_index:rnd_index + length] generated += sentence for i in range(size): # creating a prediction matrix x_pred = np.zeros((1, length, len(chars))) # set up the prediction matrix based on the random substring that we got for t, char in enumerate(sentence): x_pred[0, t, chars.index(char)] = 1 # let the model predict a vector of unique characters preds = self.model.predict(x_pred, verbose=0)[0] # sample the next character next_index = sample(preds, diversity) next_char = chars[next_index] # add the predicted character to the string and shift the input substring by one ... # while including the next predicted character generated += next_char sentence = sentence[1:] + next_char file = codecs.open( "./Generated/Text/generatedx" + str(size) + "x" + str(diversity) + ".txt", "w", "utf-8") file.write(generated) file.close() # we going to automatically generate a midi file using our decompressor program Convert.run().create_mid("./Generated/Text/generatedx" + str(size) + "x" + str(diversity) + ".txt") print("\nGenerated midi file can be found at " + "/Generated/Midis/decomprssed_generatedx" + str(size) + "x" + str(diversity) + ".MID \n")
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='relu')) 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=20, verbose=1, validation_data=(test_data, test_labels_one_hot)) [test_loss, test_acc] = model.evaluate(test_data, test_labels_one_hot) print("Evaluation result on Test Data : Loss = {}, accuracy = {}".format( test_loss, test_acc))
model.add(Dropout(0.25)) model.add(Conv1D(1024, 5, activation='relu', padding='same')) model.add(BatchNormalization()) model.add(MaxPooling1D(2)) model.add(Dropout(0.25)) model.add(Conv1D(1024, 5, activation='relu', padding='same')) model.add(BatchNormalization()) model.add(GlobalMaxPooling1D()) model.add(Dropout(0.25)) model.add(Dense(1024, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.25)) model.add(Dense(len(labels_index), activation='softmax')) model.compile(loss='sparse_categorical_crossentropy', optimizer='rmsprop', metrics=['acc']) print('model summary: ') model.summary() # save model summary in model folder so we can reference it later when comparing models with open(MODEL_PATH + '/summary.txt', 'w') as handle: model.summary(print_fn=lambda x: handle.write(x + '\n')) # make sure we only keep the weights from the epoch with the best accuracy, rather than the last set of weights checkpointer = ModelCheckpoint(filepath=MODEL_PATH + '/model.h5', verbose=1, save_best_only=True) history_checkpointer = util.SaveHistoryCheckpoint(model_path=MODEL_PATH) util.print_memory()
for units in results.keys(): for train_index, test_index in kf.split(df2_data): # print('Train') # print(train_index) # print('Test') # print(test_index) X_train = df2_data.iloc[train_index] X_test = df2_data.iloc[test_index] y_train = to_categorical([df2_labels[i] for i in train_index],num_classes=64) y_test = to_categorical([df2_labels[i] for i in test_index],num_classes=64) # classifier = Sequential() classifier.add(Dense(units, activation='relu', kernel_initializer='random_normal', input_dim=X_train.shape[1])) classifier.add(Dense(64, activation='softmax', kernel_initializer='random_normal')) classifier.compile(optimizer ='adam',loss='categorical_crossentropy', metrics =['accuracy']) # #Fitting the data to the training dataset classifier.fit(X_train,y_train, batch_size=50, epochs=50,use_multiprocessing=True,verbose=0) eval_model=classifier.evaluate(X_train, y_train,use_multiprocessing=True,verbose=0) eval_model y_pred=classifier.predict(X_test) # y_pred =(y_pred>0.5) cm = confusion_matrix(y_test.argmax(axis=1), y_pred.argmax(axis=1)) # print(cm) # np.sum(cm.diagonal()) # np.sum(cm) # print('Units:',units) results[units]['accuracy'].append(accuracy_score(y_test.argmax(axis=1), y_pred.argmax(axis=1))) results[units]['recall'].append(recall_score(y_test.argmax(axis=1), y_pred.argmax(axis=1),average='weighted'))
from sklearn.model_selection import train_test_split # from matplotlib.pyplot import plt train_data=pd.read_csv('D:\sufe\A\contest_basic_train.tsv',sep='\t') train_data=train_data.drop(['REPORT_ID',"ID_CARD",'LOAN_DATE'],1) train_data=train_data.dropna() # print(train_data.info()) X=train_data.drop(['Y'],1).as_matrix()#7 y=train_data['Y'].as_matrix()#1 X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1) model=Sequential() model.add(Dense(14,input_shape=(7,))) model.add(Activation('relu')) model.add(Dense(1)) model.add((Dropout(0.3))) model.compile(loss='mean_squared_error', optimizer='adam') model.summary() model.fit(X_train,y_train,epochs=10000,batch_size=16) t=model.predict(X_test) rate=0 for i in range(len(t)): if t[i]==y_test[i]: rate+=1 else: pass rate=1.0*rate/len(t) print(rate)
def model_train_and_fit(samples_num=80000, n_in=100, epochs=25, batch_size=128): 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) reframed.drop(reframed.columns[range(8, reframed.shape[1])], axis=1, inplace=True) print(reframed.columns) # 对齐powert 与 t-5的数据 scaled_y = scaled[n_in:, 0:1] reframed['power(t)'] = scaled_y values = reframed.values # 划分训练集和测试集 train_size = round(len(values) * 0.6) val_size = round(len(values) * 0.2) train = values[:train_size, :] val = values[train_size:val_size + train_size, :] test = values[val_size + train_size:, :] train_x, train_y = train[:, :-1], train[:, -1] test_x, test_y = test[:, :-1], test[:, -1] val_x, val_y = val[:, :-1], val[:, -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])) val_X = val_x.reshape((val_x.shape[0], 1, val_x.shape[1])) model = Sequential() model.add(LSTM(16, input_shape=(train_X.shape[1], train_X.shape[2]))) # model.add(LSTM(10, input_shape=(train_X.shape[1], train_X.shape[2]), return_sequences=True)) # model.add(Dropout(0.3)) # model.add(LSTM(10,return_sequences=True)) # model.add(Dropout(0.3)) # model.add(GRU(10)) # model.add(Dropout(0.3)) model.add(Dense(1)) model.compile(loss='mae', optimizer='adam') history = model.fit(train_X, train_y, epochs, batch_size, validation_data=(val_X, val_y)) # , validation_data=(test_X, test_y) ''' 对数据绘图 ''' plt.plot(history.history['loss'], label='train') plt.plot(history.history['val_loss'], label='val') 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 ahead_hour = round(n_in / 120, 2) plt.figure(12) plt.suptitle("%s samples,%s h ahead,Test RMSE:%s" % (samples_num, ahead_hour, 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() print("samples_num:", samples_num, "ahead_hour:", ahead_hour, "rmse", rmse) return inv_yHat
class NeuralNetwork(object): def __init__(self, input_nodes, hidden_nodes, output_nodes, lr=None): self.input_nodes = input_nodes self.hidden_nodes = hidden_nodes self.output_nodes = output_nodes self.lr = lr self.scales_x = [] self.scales_y = [] input_kernel_range = np.sqrt(6) / (np.sqrt(input_nodes) + np.sqrt(hidden_nodes)) input_kernel_initializer = RandomUniform(minval=-input_kernel_range, maxval=input_kernel_range) input_layer = Dense(input_nodes, kernel_initializer=input_kernel_initializer, name='input') hidden_kernel_range = np.sqrt(6) / (np.sqrt(hidden_nodes) + np.sqrt(output_nodes)) hidden_kernel_initializer = RandomUniform(minval=-hidden_kernel_range, maxval=hidden_kernel_range) hidden_layer = Dense(hidden_nodes, kernel_initializer=hidden_kernel_initializer, name='hidden') output_layer = Dense(output_nodes, name='output') self.model = Sequential() self.model.add(input_layer) self.model.add(hidden_layer) self.model.add(output_layer) def train(self, x_train, y_train): self.set_normalize_scales(x_train, y_train) x_train = self.normalize(x_train, self.scales_x) y_train = self.normalize(y_train, self.scales_y) optimizer = SGD(lr=self.lr) self.model.compile(loss='mse', optimizer=optimizer) self.model.fit(x_train, y_train, batch_size=20, epochs=500) def evaluate(self, x_test, y_test): x_test = self.normalize(x_test, self.scales_x) y_test = self.normalize(y_test, self.scales_y) return self.model.evaluate(x_test, y_test) def predict(self, x): x = self.normalize(x, self.scales_x) y = self.model.predict(x) return self.unnormalize(y, self.scales_y) def set_normalize_scales(self, x, y): for i in range(x.shape[1]): mean, std = x[:, i].mean(), x[:, i].std() self.scales_x.append([mean, std]) for i in range(y.shape[1]): mean, std = y[:, i].mean(), y[:, i].std() self.scales_y.append([mean, std]) @staticmethod def normalize(data, scales): for i in range(0, len(scales)): mean, std = scales[i] data[:, i] = (data[:, i] - mean) / std return data @staticmethod def unnormalize(data, scales): for i in range(0, len(scales)): mean, std = scales[i] data[:, i] = data[:, i] * std + mean return data
#add LSTM to model model = Sequential() model.add( TimeDistributed(cnn, input_shape=(seq_length, 72, 72, 3), trainable=False)) model.add( LSTM(128, input_shape=(batch_size, seq_length, 1), return_sequences=True)) model.add(TimeDistributed(Dropout(0.5))) # add FC model.add(TimeDistributed(Dense(64))) model.add(TimeDistributed(Dropout(0.5))) model.add(TimeDistributed(Dense(class_num, activation='linear'))) # train print(model.summary()) model.compile(optimizer=adam, loss='mse', metrics=[util.ccc, 'mse']) # save the model if not os.path.exists("./model"): os.makedirs("./model") filepath = "./model/model.h5" checkpoint = ModelCheckpoint(filepath, save_best_only=True) callbacks_list = [checkpoint] hist = model.fit(x=x_train, y=y_train, validation_data=(x_val, y_val), epochs=epoch, batch_size=batch_size, callbacks=callbacks_list)
model = Sequential() print(base_model.output) model.add(Flatten(input_shape=base_model.output_shape[1:])) #7*7*512---->256 model.add(Dense(num_classes)) model.add(Activation('softmax')) #输出为VGG16的数据,经过VGG16的特征层,2层全连接到num_classes输出 model = Model(inputs=base_model.input, outputs=model(base_model.output)) #冻结VGG16的前15层,权值不变,即在训练过程中不训练 for layer in model.layers[:15]: layer.trainable = False #优化器 opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6) #编译模型 model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) #----------------------------------------------------------训练----------------------------------------------- #如果没有使用数据增强 if not data_augmentation: print('Not using data augmentation') history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_test, y_test), shuffle=True) else: # 进行数据增强 print('Using real-time data augmentation.')
import keras import numpy as np from keras import Sequential from keras.layers import Dense, Convolution2D, Flatten, Convolution1D from keras.optimizers import SGD, Adam from util import load_single_train_data model = Sequential() model.add(Convolution1D(input_shape=[16, 8], filters=64, kernel_size=3, activation='relu')) model.add(Flatten()) model.add(Dense(units=8, activation='softmax')) adam = Adam(lr=0.1, decay=0.0) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=adam, metrics=['accuracy']) train_x, train_y, test_x, test_y = load_single_train_data('.cache/dba/data', 1) train_x = train_x.reshape(train_x.shape[0], 16, 8) test_x = test_x.reshape(train_x.shape[0], 16, 8) train_y = keras.utils.to_categorical(train_y - 1, 8) test_y = keras.utils.to_categorical(test_y - 1, 8) model.fit(train_x, train_y, batch_size=1000, validation_data=(test_x, test_y), epochs=28)
def SegNet(): model = Sequential() model.add(Conv2D(8, (3, 3), input_shape=(128, 128, 1), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(8, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(16, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(16, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(UpSampling2D(size=(2, 2))) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(UpSampling2D(size=(2, 2))) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(UpSampling2D(size=(2, 2))) model.add(Conv2D(32, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(UpSampling2D(size=(2, 2))) model.add(Conv2D(16, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(16, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(UpSampling2D(size=(2, 2))) model.add(Conv2D(8, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(8, (3, 3), padding='same')) model.add(BatchNormalization(axis=3)) model.add(Activation('relu')) model.add(Conv2D(1, (1, 1), activation='sigmoid')) model.compile(optimizer=Adam(lr=0.01), loss='binary_crossentropy', metrics=[processor.mean_iou]) return model
import numpy as np from keras import Sequential from keras.layers import Dense data = np.random.random((1000, 32)) label = np.random.random((1000, 10)) model = Sequential() model.add(Dense(64, activation='relu', input_shape=(32, ))) model.add(Dense(64, activation='relu')) model.add(Dense(10, activation='softmax')) model.compile('adam', 'categorical_crossentropy') model.fit(data, label, epochs=100) model.save('my_model.h5')
class lstm: def __init__(self, market: Market = Market.US): self.model = None self.market = market self.sp500 = self.load_stock_data('^GSPC') def add_features(self, ohlcv: pd.DataFrame): # add SMA 5, 30, 90, 180 for feature in [StockPriceField.Close.value]: for sma in [5, 30, 90, 180]: ohlcv['%s_sma_%s' % (feature, sma)] = talib.abstract.SMA( ohlcv, timeperiod=sma, price=feature) # normalize to pct_change ohlcv = ohlcv.pct_change() # drop na ohlcv.dropna(inplace=True) return ohlcv def load_stock_data(self, symbol: str) -> pd.DataFrame: data = Utility.load_stock_price(self.market, symbol) del data[StockPriceField.Symbol.value] return self.add_features(data) def prepare_data(self, symbol: str, timesteps, validate_pct: float = 0.2, test_pct: float = 0.2): base_data = self.load_stock_data(symbol) # combine with sp500 base_data = pd.concat([base_data, self.sp500], axis=1, join='inner').dropna() training_steps = [base_data] for step in range(timesteps, 0, -1): one_step = base_data.shift(step) one_step.columns = [ '%s(-%d)' % (col, step) for col in base_data.columns ] training_steps.append(one_step) featured_data = pd.concat(training_steps, axis=1, join='inner').dropna() input = featured_data.iloc[:, base_data.shape[1]:].values output = featured_data.iloc[:, 3].values # close price # scaler = MinMaxScaler(feature_range=(0, 1)) scaled_input = input.reshape(-1, timesteps, base_data.shape[1]) scaled_output = output training_ends = math.floor(scaled_input.shape[0] * (1 - validate_pct - test_pct)) validate_ends = math.floor(scaled_input.shape[0] * (1 - test_pct)) training_data = scaled_input[:training_ends] training_label = scaled_output[:training_ends] validate_data = scaled_input[training_ends:validate_ends] validate_label = scaled_output[training_ends:validate_ends] test_data = scaled_input[validate_ends:] test_label = scaled_output[validate_ends:] return training_data, training_label, validate_data, validate_label, test_data, test_label def create_model(self, timesteps, feature_size, outputs=1): self.model = Sequential() self.model.add( GRU(2048, input_shape=(timesteps, feature_size), dropout=0.5)) self.model.add(Dropout(0.5)) self.model.add(Dense(outputs)) self.model.compile(loss='mae', optimizer='adam') def train_model(self, train_data, train_label, validation_data, validation_label, epochs, batch_size): return self.model.fit(train_data, train_label, validation_data=(validation_data, validation_label), epochs=epochs, batch_size=batch_size, shuffle=False, verbose=2)
print('Minimum review length: {}'.format(len(min((X_test + X_test), key=len)))) from keras.preprocessing import sequence max_words = 500 X_train = sequence.pad_sequences(X_train, maxlen=max_words) X_test = sequence.pad_sequences(X_test, maxlen=max_words) from keras import Sequential from keras.layers import Embedding, LSTM, Dense, Dropout embedding_size=32 model=Sequential() model.add(Embedding(vocabulary_size, embedding_size, input_length=max_words)) model.add(LSTM(100)) model.add(Dense(1, activation='sigmoid')) print(model.summary()) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) batch_size = 64 num_epochs = 3 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 = model.evaluate(X_test, y_test, verbose=0) print('Test accuracy:', scores[1])
def phase_estimator_100k(time_sequence): seq = Sequential() seq.add( ConvLSTM2D(filters=50, kernel_size=(2, 2), input_shape=(None, 10, 10, time_sequence), padding='same', return_sequences=True)) seq.add(BatchNormalization()) #seq.add(Dropout(0.2)) seq.add( ConvLSTM2D(filters=75, kernel_size=(2, 2), padding='same', return_sequences=True)) seq.add(BatchNormalization()) #seq.add(Dropout(0.2)) seq.add( ConvLSTM2D(filters=100, kernel_size=(2, 2), padding='same', return_sequences=True)) seq.add(BatchNormalization()) #seq.add(Dropout(0.1)) seq.add( ConvLSTM2D(filters=75, kernel_size=(2, 2), padding='same', return_sequences=True)) seq.add(BatchNormalization()) seq.add( ConvLSTM2D(filters=50, kernel_size=(2, 2), padding='same', return_sequences=True)) seq.add(BatchNormalization()) seq.add( Conv3D(filters=time_sequence, kernel_size=(2, 2, 2), activation='relu', padding='same', data_format='channels_last')) seq.add(BatchNormalization()) seq.add(Dropout(.15)) seq.add( Conv3D(filters=time_sequence, kernel_size=(2, 2, 2), activation='softmax', padding='same', data_format='channels_last')) seq.compile( loss='categorical_crossentropy', optimizer='adadelta', metrics=[metrics.categorical_accuracy, metrics.binary_accuracy]) return seq