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)
# 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(500, activation='relu', input_shape=(dimData,))) model.add(Dense(446, activation='relu')) model.add(Dense(10, activation='softmax')) model.compile(optimizer='adam', 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)) # DL_ICP2 - question2 predict_test = model.predict_classes(test_data[[30], :]) print("The prediction of the 30th in the test dataset is: ", predict_test) plt.imshow(test_images[30, :, :], cmap='gray') plt.title('Ground Truth : {}'.format(test_labels[30])) plt.show()
# print(series.shape) # choose a number of time steps n_steps = 3 X, y = split_sequence(raw_seq, n_steps) print(X.shape, y.shape) # reshape from [samples, timesteps] into [samples, timesteps, features] n_features = 1 X = X.reshape((X.shape[0], X.shape[1], n_features)) # define model model = Sequential() model.add( Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(n_steps, n_features))) model.add(MaxPooling1D(pool_size=2)) model.add(Flatten()) model.add(Dense(50, activation='relu')) model.add(Dense(1)) model.compile(optimizer='adam', loss='mse') # fit model model.fit(X, y, epochs=1000) # demonstrate prediction x_input = array([70, 80, 90]) x_input = x_input.reshape((1, n_steps, n_features)) yhat = model.predict(x_input) print(yhat)
#Construct the model model = Sequential() model.add(Dense(64)) model.add(Activation('softmax')) model.add(Dropout(0.5)) model.add(Dense(1)) model.add(Activation('sigmoid')) #I set the learning rate extremely low because early on the model couldn't learn anything other than the baseline opt = Adam(lr=0.00001) #Compile the model model.compile( loss='binary_crossentropy', optimizer=opt, #optimizer='adam', metrics=['accuracy']) #Fit the model to the training and validation data, using early stopping to prevent overfitting model.fit(X_train, y_train, callbacks=[EarlyStopping(patience=5)], epochs=100, validation_data=(X_test, y_test)) #Save the model to a file using the fold number and the value set at the start to create the filename name = 'fold' + str(i) + 'attempt' + str(attempt) + '.h5' i += 1 model.save(name)
#ST2.add( myDense_1(n_nodes) ) #ST2.add( Activation('relu') ) ST2.add(myDense_1(n_class)) ST2.add(Activation('softmax')) #ST2.add( Dense(n_class, activation='softmax') ) ST2.compile(optimizer=Optimizer, loss=loss_func, metrics=Metric, weighted_metrics=['accuracy']) ST2.fit(x=X_train, y=Y_train, sample_weight=W_train, epochs=n_epochs, verbose=vb, shuffle=True, batch_size=batch_s) ST2.summary() ## Test custom layer########################### STs = [ST2] for STi in STs: ## Show learned weights: ii = 1 for layer in STi.layers: g = layer.get_config() h = layer.get_weights() if ii == 4:
clf.add(Dense(20, input_dim=11, activation='relu')) # after the first layer, you don't need to specify # the size of the input anymore clf.add(Dense(16, activation='relu')) clf.add(Dense(1, activation='sigmoid')) # softmax is used for multiclass classification # an instance of optimizer of class can be passed instead of string [it supports hyper pramaeter tuning] # passing string version doesn't support changing parameters clf.compile(optimizer=keras.optimizers.Nadam(), metrics=['accuracy'], loss='binary_crossentropy') # Training the model history = clf.fit(x=X_train, y=y_train, batch_size=850, validation_split=.2, epochs=1600) score_history = history.history y_pred_vanilla = clf.predict_classes(X_test) plt.plot(range(1, 1601), score_history['loss'], label='Train Loss') plt.plot(range(1, 1601), score_history['val_loss'], label='Validation Loss') plt.legend() plt.xlabel('No of Epochs') plt.ylabel('Loss') plt.show() plt.plot(range(1, 1601), score_history['accuracy'], label='Train Accuracy') plt.plot(range(1, 1601), score_history['val_accuracy'],
cls = Sequential() cls.add( Dense(2, input_dim=2, activation='relu', kernel_initializer='random_uniform')) cls.add(Dense(30, activation='relu', kernel_initializer='random_uniform')) cls.add(Dense(3, activation='softmax', kernel_initializer='random_uniform')) opt = Adam(lr=INIT_LR) cls.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) history = cls.fit(newX, y, epochs=EPOCHS, steps_per_epoch=10, validation_split=0.2, validation_steps=50) plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('gmm rca model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['test', 'train'], loc='upper left') plt.show()
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))) 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)
model = Sequential() # input_shape = (time_step, 每个时间步的input_dim) # LSTM的第一个参数5表示LSTM的单元数为5,我们可以把LSTM理解为一个特殊的且带有时序信息的全连接层。 # model.add(LSTM(10, input_shape=(train_X.shape[1], train_X.shape[2]))) model.add( LSTM(4, input_shape=(train_X.shape[1], train_X.shape[2]), return_sequences=True)) model.add(LSTM(4, return_sequences=False)) model.add(Dense(1)) model.compile(loss='mae', optimizer='adam') # fit network history = model.fit(train_X, train_y, nb_epoch=20, batch_size=1, validation_data=(test_X, test_y), verbose=2, shuffle=False) model.save("currentlstm.h5") #plot history plt.plot(history.history['loss'], label='train') plt.plot(history.history['val_loss'], label='test') plt.legend() plt.show() plt.figure(figsize=(16, 8)) train_predict = model.predict(train_X) test_predict = model.predict(test_X) plt.plot(scaled[1:, 0], c='b') plt.plot([x for x in train_predict], c='g')
lstm_out = 200 #@ model_lstm = Sequential() model_lstm.add(Embedding(max_features, embed_dim, input_length=X1.shape[1])) model_lstm.add(SpatialDropout1D(0.2)) model_lstm.add(LSTM(lstm_out, dropout=0.2, recurrent_dropout=0.2)) model_lstm.add(Dense(15, activation='softmax')) model_lstm.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) print(model_lstm.summary()) batch_size = 32 model_lstm.fit(X1_train, Y1_train, epochs=2, batch_size=batch_size, verbose=2, validation_data=(X1_test, Y1_test)) y_pred = model_lstm.predict(X1_test) loss, acc = model_lstm.evaluate(X1_test, Y1_test, verbose=1, batch_size=batch_size) #Η Εκτίμηση της loss function ή αλλιώς η συνάρτηση κόστους(όσο πιο μικρό είναι το score , τόσο χαμηλότερο είναι τολάθος πρόβλεψης) # print("Test val_loss: %.2f" % (loss)) #Το ποσοστό των προβλέψεων για τις κατηγορίες από το σύνολο ελέγχου print("Test val_accuracy: %.2f" % (acc))
from keras.utils import to_categorical (features, labels), (test_features, test_labels) = mnist.load_data() num_pixel = features.shape[1] * features.shape[2] features = features.reshape(features.shape[0], num_pixel).astype('float32') test_features = test_features.reshape(test_features.shape[0], num_pixel).astype('float32') labels = to_categorical(labels) test_labels = to_categorical(test_labels) num_classes = test_labels.shape[1] features = features / 255 test_features = test_features / 255 model = Sequential() model.add(Dense(num_pixel, input_dim=num_pixel)) model.add(Dense(25, activation="relu")) model.add(Dense(num_classes, activation="softmax")) model.compile(optimizer="Adam", loss="categorical_crossentropy") model.fit(features, labels, epochs=3) '''model = SVC() model.fit(features,labels)''' print(model.evaluate(test_features, test_labels, batch_size=128)) joblib.dump(model, "keras_mdoel", compress=3)
cls.add( Dense(7, input_dim=7, activation='relu', kernel_initializer='random_uniform')) cls.add(Dense(30, activation='relu', kernel_initializer='random_uniform')) cls.add(Dense(3, 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) accTest = score if accTest > maxTstAcc:
def create_model(_rows, data_dict, max_flow): def rmse(y_true, y_pred, axis=0): return np.sqrt(((y_pred - y_true)**2).mean(axis=axis)) def create_dataset_from_dict(ddata, lookback=1, steps=1): dataX = [] dataY = [] for dt, data in ddata.items(): timestep = [] yval = ddata.get(dt + timedelta(minutes=5 * steps)) # check the future value exists and is not an error if yval is not None: for j in range(lookback): offset = dt - timedelta(minutes=5 * steps * j) # make sure we have all previous values in the lookback if ddata.get(offset) is not None: timestep.append(ddata[offset]) if len(timestep) == lookback: dataX.append(timestep) dataY.append(yval[0]) fields = len(dataX[0][0]) return np.array(dataX, dtype=np.double), np.array(dataY, dtype=np.double), fields def fit_to_batch(arr, b_size): lim = len(arr) - (len(arr) % b_size) return arr[:lim] class TerminateOnNaN(Callback): """Callback that terminates training when a NaN loss is encountered. """ def __init__(self): super(TerminateOnNaN, self).__init__() self.terminated = False def on_batch_end(self, batch, logs=None): logs = logs or {} loss = logs.get('loss') if loss is not None: if np.isnan(loss) or np.isinf(loss): print('Batch %d: Invalid loss, terminating training' % (batch)) self.model.stop_training = True self.terminated = True # input fields are: """ Input is: [ flow dayOfWeek MinuteOfDay month week isWeekend ] for `lookback` records """ lookback = int({{quniform(1, 40, 1)}}) scaler = MinMaxScaler((0, 1)) # rows = scaler.fit_transform(_rows) # dataX, dataY, fields = create_dataset(rows, lookback) scaled = scaler.fit_transform(list(data_dict.values())) scaled_data_dict = dict(zip(data_dict.keys(), scaled)) dataX, dataY, fields = create_dataset_from_dict(scaled_data_dict, lookback) test_train_split = 0.60 ## 60% training 40% test split_idx = int(len(dataX) * test_train_split) train_x = dataX[:split_idx] train_y = dataY[:split_idx] test_x = dataX[split_idx:] test_y = dataY[split_idx:] batch_size = int({{quniform(1, 5, 1)}}) train_x = fit_to_batch(train_x, batch_size) train_y = fit_to_batch(train_y, batch_size) test_x = fit_to_batch(test_x, batch_size) test_y = fit_to_batch(test_y, batch_size) nb_epoch = 1 lstm_size_1 = {{quniform(96, 300, 4)}} lstm_size_2 = {{quniform(96, 300, 4)}} lstm_size_3 = {{quniform(69, 300, 4)}} optimizer = {{choice(['adam', 'rmsprop'])} } # 'nadam', 'adamax', 'adadelta', 'adagrad'])}} l1_dropout = {{uniform(0.001, 0.7)}} l2_dropout = {{uniform(0.001, 0.7)}} l3_dropout = {{uniform(0.001, 0.7)}} output_activation = {{choice(['relu', 'tanh', 'linear'])}} # reset_interval = int({{quniform(1, 100, 1)}}) # layer_count = {{choice([1, 2, 3])}} l1_reg = {{uniform(0.0001, 0.1)}} l2_reg = {{uniform(0.0001, 0.1)}} params = { 'batch_size': batch_size, 'lookback': lookback, 'lstm_size_1': lstm_size_1, 'lstm_size_2': lstm_size_2, 'lstm_size_3': lstm_size_3, 'l1_dropout': l1_dropout, 'l2_dropout': l2_dropout, 'l3_dropout': l3_dropout, 'l1_reg': l1_reg, 'l2_reg': l2_reg, 'optimizer': optimizer, 'output_activation': output_activation, # 'state_reset': reset_interval, # 'layer_count': layer_count, # 'use_embedding': use_embedding } print("PARAMS=", json.dumps(params, indent=4)) def krmse(y_true, y_pred): return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1)) def geh(y_true, y_pred): return K.sqrt(2 * K.pow(y_pred - y_true, 2) / (y_pred + y_true)).mean(axis=-1) reg = L1L2(l1_reg, l2_reg) start = datetime.now() model = Sequential() # if conditional(use_embedding): # model.add(Embedding()) model.add( LSTM(int(lstm_size_1), batch_input_shape=(batch_size, lookback, fields), return_sequences=True, stateful=True, activity_regularizer=reg, bias_initializer='ones')) model.add(Dropout(l1_dropout)) model.add(Activation('relu')) model.add( LSTM(int(lstm_size_2), return_sequences=True, bias_initializer='ones', stateful=True, activity_regularizer=reg)) model.add(Dropout(l2_dropout)) model.add(Activation('relu')) model.add( LSTM(int(lstm_size_3), bias_initializer='ones', stateful=True, activity_regularizer=reg)) model.add(Dropout(l3_dropout)) model.add(Activation('relu')) model.add(Dense(1, activation='relu')) terminate_cb = TerminateOnNaN() model.compile(loss='mse', optimizer=optimizer) try: model.fit( train_x, train_y, epochs=1, verbose=1, batch_size=batch_size, shuffle=False, callbacks=[terminate_cb], ) except Exception as e: print(e) return {'status': STATUS_FAIL, 'msg': e} if terminate_cb.terminated: return {'status': STATUS_FAIL, 'msg': "Invalid loss"} # have it continue learning during this phase # split the test_x,test_y preds = [] def group(iterable, n): it = iter(iterable) while True: chunk = tuple(itertools.islice(it, n)) if not chunk: return yield chunk test_y_it = iter(group(test_y, batch_size)) test_batch_idx = 0 prog = tqdm(range(len(test_y / batch_size)), desc='Train ') for batch in group(test_x, batch_size): batch = np.array(batch) test_y_batch = np.array(next(test_y_it)) model.train_on_batch(batch, test_y_batch) batch_preds = model.predict_on_batch(batch)[:, 0] preds.extend(batch_preds) test_batch_idx += 1 prog.update() # if test_batch_idx % reset_interval == 0: # model.reset_states() preds = np.array(preds) finish = datetime.now() preds_pad = np.zeros((preds.shape[0], fields)) preds_pad[:, 0] = preds.flatten() test_y_pad = np.zeros((preds.shape[0], fields)) test_y_pad[:, 0] = test_y.flatten() unscaled_pred = scaler.inverse_transform(preds_pad) unscaled_test_y = scaler.inverse_transform(test_y_pad) rmse_result = rmse(unscaled_pred, unscaled_test_y)[0] plot_x = np.arange(test_x.shape[0]) dpi = 80 width = 1920 / dpi height = 1080 / dpi plt.figure(figsize=(width, height), dpi=dpi) plt.plot(plot_x, unscaled_test_y[:, 0], color='b', label='Actual') plt.plot(plot_x, unscaled_pred[:, 0], color='r', label='Predictions') plt.legend() plt.title("LSTM Discrete Predictions at 115, SI 2\nRMSE:{}".format( round(rmse_result, 3))) plt.xlabel('Time') plt.ylabel('Flow') fig_name = 'model_{}.png'.format(time()) plt.savefig(fig_name) plt.show() with open(fig_name, 'rb') as img_file: fig_b64 = base64.b64encode(img_file.read()).decode('ascii') return { 'loss': rmse_result, 'status': STATUS_OK, 'model': model._updated_config(), 'metrics': { 'rmse': rmse_result, # 'geh': geh(unscaled_pred, unscaled_test_y)[0], 'duration': (finish - start).total_seconds() }, 'figure': fig_b64, 'params': params }
for k in range(f1, mid): f2m[i - 1, k] = (k - floor1[i - 1]) / (floor1[i] - floor1[i - 1]) for k in range(mid, f2): f2m[i - 1, k] = (floor1[i + 1] - k) / (floor1[i + 1] - floor1[i]) print(np.shape(f2m)) print(f2m) datatotrain = np.dot(np.abs(data_rfft), f2m.T) print(np.shape(datatotrain)) print(np.count_nonzero((datatotrain))) print(np.amax((datatotrain))) xtrain = datatotrain / np.amax(datatotrain) print(np.amin(datatotrain)) y_train = np.asarray(labels_list) from keras.layers import Input, Dense from keras.models import Model from keras import optimizers from keras.callbacks import TensorBoard from time import time from keras import Sequential from keras.utils import np_utils labels_train = np_utils.to_categorical(y_train, 46) model = Sequential() model.add(Dense(128, input_dim=40, activation='relu')) model.add(Dense(46, activation='relu')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(xtrain, labels_train, epochs=150, batch_size=10, verbose=1)
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) # test_data=pd.read_csv('D:\sufe\A\contest_basic_test.tsv',sep='\t')
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
from keras.datasets import imdb from keras.layers import Flatten, Dense, Embedding, SimpleRNN from keras.preprocessing import sequence from keras import Sequential max_features = 1000 max_len = 20 (xtrain, ytrain), (xtest, ytest) = imdb.load_data(num_words=max_features) xtrain = sequence.pad_sequences(xtrain, maxlen=max_len) xtest = sequence.pad_sequences(xtest, maxlen=max_len) model = Sequential([ Embedding(10000, 8, input_length=max_len), Flatten(), Dense(1, activation='sigmoid') ]) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) model.summary() history = model.fit(xtrain, ytrain, epochs=10, batch_size=32, validation_split=0.2)
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) label = 'seq_len:{}, units:{}'.format(seq_lenth, units) with open(file, 'a') as outfile: outfile.write('+++++++++++++++++++++++++++++++++++++++\n') outfile.write(label) outfile.write('\n+++++++++++++++++++++++++++++++++++++++\n') loss = [] #Iterate through each training duration for ind, epochs in enumerate(epochs_list): #Fit the model for the current number of epochs history = model.fit(X, y, epochs=epochs, batch_size=batch_size) loss.extend(history.history['loss']) # print(history.history['loss']) #Extract the weights from the training model to set the weights for the #character generation model weights = model.get_weights() trained_model.set_weights(weights) #Select a sample from X to be the seed seed = np.array(X[100]) #Generate the results and output to file with open(file, 'a') as outfile: #Write the header line with number of epochs, seed, etc outfile.write(
class SemiSupLabeler(): """ @_init_: initialises the model - data_lab: labelled data - data_unlab: unlabelled data - data_submit: the submit version of the data """ def __init__(self, data_lab, data_unlab, data_submit): ###########################Default parameters##################### #NB:if some mandatory parameters are lacking in the json, default values will be taken #list of all potential parameters """ @params_nn: parameters of neural network - loss : loss used for the NN, cf the dictionnary above - optimizer: Adam, SGD, etc - learning rate: speaks for itself - metrics accuracy, we wont change it normally - decay: decay of the learning rate, generally of the order 1e-5 - momentum: momentum of the lr - patience: number of epochs you wait if you use earlystopmode for the validation accuracy to increase again - layers: shape of the network """ self.params_nn = [ 'loss', 'optimizer', 'learning rate', 'metrics', 'decay', 'momentum', 'batch_size', 'number of epochs', 'layers', 'patience' ] """ @params_ss: parameters of label spreading - manyfit: since the ss accuracy has some variance but doesnt take much to be computed, manyfit designs how many independant times we run it before averaging it in order to obtain a better estimation of the accuracy in question - ss_model: 'LabSpr' or 'LabProp'. So far, only LabSpr has converged - ss_kernel: 'knn' or 'rbf. So far only knn converges. ***WATCH OUT***: when using rbf, euler will complain that you use too much memory!! - gamma parameter for the rbf - neighbor parameter for knn - alpha parameter for knn and rbf: tells at which point you will take the information of your neighbors into account """ self.params_ss = [ 'UsingSS', 'manyfit', 'ss_model', 'ss_kernel', 'gamma', 'neighbor', 'alpha' ] """ @param_list: list of all parameters - Ratio: ratio represented by the training set - pca: number of principal components to use. if not present, no pca will be done - UsingNN: if set to false, the NN is not used. - data_state: 'save' or 'load'. If you want to train the NN only without having to run the ss algo again, do one run with data_state to true, and use data_state= 'load for the next ones. - scaler: 'normal' or 'standard' describes the preprocessing before applying the pca - paramsout: designates which parameters will be present in the output name ==> put the one you're playing with in order to easily see the difference """ self.param_list = [ 'Ratio', 'pca', 'UsingNN', 'paramsout', 'data_state', 'scaler' ] + self.params_nn + self.params_ss self.param_out = ['Ratio', 'pca', 'optimizer', 'layers'] self.data_lab = data_lab self.data_unlab = data_unlab self.data_submit = data_submit #--------------------- DATA IF NO JSON PROVIDED -------------------------- #Training: self.RATIO = 0.9 self.INPUT_DIM = 139 #PCA: self.scaler = 'Standard' self.PCA_MODE = True self.pca = 50 #Early stopping: self.EARLY_STOP_MODE = False self.patience = 50 #NEURAL NETWORK: self.USING_NN = True self.USING_SS = False assert (self.USING_NN or self.USING_SS) self.loss = "sparse_categorical_crossentropy" self.opt = "SGD" self.lr = 0.001 self.metric = "accuracy" self.decay = 0 self.momentum = 0 self.batch_size = 32 self.epochs = 5 self.lay_node = [("relu", 206), ('dropout', 0.33)] #Semi Supervised learning: self.datastate = 'save' self.ss_mod = 'LabSpr' self.ss_kern = 'knn' self.gamma = 20 self.neighbors = 7 self.alpha = 0.2 self.manyfit = 1 #----------------------- JSON AS ARGUMENT: ------------------------- #Checks wether the provided JSON is well formed: def check(inner, outer): for i in inner: if not (i in outer): print('unknown parameter. abort.', i) exit() self.JSON_MODE = (len(sys.argv) > 1) #In case a JSON was provided for the parameters: if (self.JSON_MODE): fn = sys.argv[1] if os.path.isfile(fn): print("successfully read the json file." + sys.argv[1]) self.json_dict = json.load(open(fn)) assert ('UsingNN' and 'paramsout' in self.json_dict) self.USING_NN = self.json_dict['UsingNN'] self.USING_SS = self.json_dict['UsingSS'] check(self.json_dict, self.param_list) check(self.json_dict['paramsout'], self.param_list) #iterate over the printed parameters and ensure they exist: self.param_out = self.json_dict['paramsout'] self.RATIO = self.json_dict['Ratio'] self.ss_mod = self.json_dict['ss_model'] self.ss_kern = self.json_dict['ss_kernel'] self.gamma = self.json_dict['gamma'] self.neighbors = self.json_dict['neighbor'] self.alpha = self.json_dict['alpha'] self.datastate = self.json_dict['data_state'] self.scaler = self.json_dict['scaler'] if ('manyfit' in self.json_dict): self.manyfit = self.json_dict['manyfit'] if (self.USING_NN): self.loss = self.json_dict['loss'] self.opt = self.json_dict['optimizer'] self.lr = self.json_dict['learning rate'] self.metric = self.json_dict['metrics'] self.decay = self.json_dict['decay'] self.momentum = self.json_dict['momentum'] self.batch_size = self.json_dict['batch_size'] self.epochs = self.json_dict['number of epochs'] lay_node = self.json_dict['layers'] self.PCA_MODE = ('pca' in self.json_dict) if (self.PCA_MODE): self.pca = self.json_dict['pca'] self.INPUT_DIM = self.pca self.EARLY_STOP_MODE = ('patience' in self.json_dict) if (self.EARLY_STOP_MODE): self.patience = self.json_dict['patience'] else: print("uncorrect path. abort.") print(sys.argv[1]) exit() #if no JSON is provided, the values are taken from the code: else: print("taking the values of the code because no JSON was given.") #Dictionnary of all the values of parameters used: self.json_dict = { 'Ratio': self.RATIO, 'UsingNN': self.USING_NN, 'UsingSS': self.USING_SS, 'ss_model': self.ss_mod, 'ss_kernel': self.ss_kern, 'loss': self.loss, 'optimizer': self.opt, 'learning rate': self.lr, 'metrics': self.metric, 'decay': self.decay, 'momentum': self.momentum, 'batch_size': self.batch_size, 'number of epochs': self.epochs, 'gamma': self.gamma, 'neighbor': self.neighbors, 'alpha': self.alpha, 'layers': self.lay_node, 'manyfit': self.manyfit, 'scaler': self.scaler } if (self.PCA_MODE): self.json_dict['pca'] = self.pca self.INPUT_DIM = self.pca if (self.EARLY_STOP_MODE): self.jsondict['patience'] = self.patience self.build_output_name() #Tensorboard/log part: self.logs_base_dir = "./logs" os.makedirs(self.logs_base_dir, exist_ok=True) self.log_spec = os.path.join(self.logs_base_dir, self.output_name) os.makedirs(self.log_spec, exist_ok=True) self.init_variables() """ @label_spr: performs label spreading """ def label_spr(self): RESULT_ACC_SS = 0 for i in range(self.manyfit): #Initialisinig of variables: self.init_variables() #PCA preprocessing: if (self.PCA_MODE): self.pca_preprocess(self.pca) #Semi supervised algo if (self.ss_mod == 'LabSpr' and self.ss_kern == 'knn'): self.label_prop_model = LabelSpreading( kernel='knn', gamma=self.gamma, n_neighbors=self.neighbors, alpha=self.alpha) elif (self.ss_mod == 'LabProp' and self.ss_kern == 'rbf'): self.label_prop_model = LabelPropagation( kernel='rbf', gamma=self.gamma, n_neighbors=self.neighbors, alpha=self.alpha, max_iter=10) else: self.label_prop_model = LabelPropagtion( kernel=self.ss_kern, gamma=self.gamma, n_neighbors=self.neighbors) print('Starting to fit. Run for shelter!') self.label_prop_model.fit(self.X_tot, self.y_tot) temp_acc = self.label_prop_model.score(self.X_valid_lab, self.y_valid) print('{} / {} :accuracy = {}'.format(i, self.manyfit, temp_acc)) RESULT_ACC_SS += temp_acc self.y_tot = self.label_prop_model.transduction_ self.y_submit = self.label_prop_model.predict(self.X_submit) if (self.datastate == "save"): self.save_to_csv(self.X_tot, self.y_tot, self.X_valid_lab, self.y_valid) RESULT_ACC_SS /= self.manyfit self.json_dict['ss_accuracy'] = RESULT_ACC_SS print('accuracy obtained on the test set of the ss algo:', RESULT_ACC_SS) """ @labelspr_predict: returns the predicion of the label spreading """ def labelspr_predict(self, X): return self.label_prop_model.predict(X) """ @init_variables : transforms the input data so that it is usable """ def init_variables(self): X_submit = self.data_submit.to_numpy() X_big_lab = (self.data_lab.to_numpy())[:, 1:] y_big = ((self.data_lab.to_numpy())[:, 0]).astype(int) X_train_lab, X_valid_lab, self.y_train, self.y_valid = train_test_split( X_big_lab, y_big, test_size=(1 - self.RATIO), random_state=14) X_unlab = self.data_unlab.to_numpy() X_tot = np.concatenate((X_train_lab, X_unlab), axis=0) self.y_tot = np.concatenate((self.y_train, np.full(len(X_unlab), -1))) if (self.scaler == 'Standard'): scaler = StandardScaler() elif (self.scaler == 'Normal'): scaler = Normalizer() else: scaler = StandardScaler() self.X_tot = scaler.fit_transform(X_tot) self.X_train_lab = scaler.transform(X_train_lab) self.X_unlab = scaler.transform(X_unlab) self.X_valid_lab = scaler.transform(X_valid_lab) self.X_submit = scaler.transform(X_submit) """@pca_preprocess: performs the preprocessing before the PCA """ def pca_preprocess(self, number): pca_mod = PCA(n_components=number) self.X_tot = pca_mod.fit_transform(self.X_tot) self.X_train_lab = pca_mod.transform(self.X_train_lab) self.X_unlab = pca_mod.transform(self.X_unlab) self.X_valid_lab = pca_mod.transform(self.X_valid_lab) self.X_submit = pca_mod.transform(self.X_submit) self.INPUT_DIM = number """@build_model: creates the model of the neural network """ def build_model(self): self.model = Sequential() for counter, (name, num) in enumerate(self.lay_node): if (counter == 0): self.model.add( Dense(num, activation='relu', input_dim=self.INPUT_DIM)) elif (name == 'dropout'): self.model.add(Dropout(rate=num)) elif (name == 'relu'): self.model.add(Dense(num, activation=tf.nn.relu)) elif (name == 'relu_bn'): self.model.add(Dense(num)) self.model.add(BatchNormalization()) self.model.add(Activation('relu')) else: print('uncorrect name for the layers. exit.') exit() #Last layer of neural network: self.model.add(Dense(10, activation='softmax')) #optimizer if (self.opt == 'SGD'): optimiz = SGD(lr=self.lr, decay=self.decay, momentum=self.momentum) elif (self.opt == 'Adam'): optimiz = Adam(lr=self.lr, decay=self.decay) else: print('uncorrect name for the layers. exit.') exit() self.model.compile(optimizer=optimiz, loss=self.loss, metrics=[self.metric]) """ @fit_lab: trains the neural network on labeled data """ def fit_lab(self): temp = self.nn_fit(self.X_train_lab, self.y_train) self.json_dict["small_lab_dataset_nn_acc"] = temp """ @fit_tot: trains the neural network on the total data """ def fit_tot(self): temp = self.nn_fit(self.X_tot, self.y_tot) self.json_dict["big_dataset_nn_acc"] = temp def fit_tot_mesh(): tableau = [] tabl = [] number_it = 10 temp = self.nn_fit(self.X_tot, self.y_tot) for i in range(number_it): probabs_values = self.model.predict(self.X_submit) tableau.append(self.probas_values) tabl = [(sum(x) / number_it) for x in zip(*tableau)] self.y_submit = np.array([np.argmax(i) for i in tabl]) """ @nn_fit: fits the neural network to input data X and y provided. """ def nn_fit(self, X, y): call_back_list = [] #call_back_list.append(keras.callbacks.TensorBoard(self.log_spec,histogram_freq=1,write_grads=True)) if (self.EARLY_STOP_MODE): call_back_list.append( EarlyStopping(patience=self.patience, verbose=1, mode='min', restore_best_weights=True)) self.model.fit(x=X, y=y, epochs=self.epochs, batch_size=self.batch_size, validation_data=(self.X_valid_lab, self.y_valid)) test_loss, aut_acc = self.model.evaluate(self.X_valid_lab, self.y_valid) y_temp = self.model.predict(self.X_submit) self.y_submit = np.array([np.argmax(i) for i in y_temp]) return aut_acc """ @complete_ublab: completes the unlabeled data by predicting the labels for it """ def complete_unlab(self): y_missing = self.model.predict(self.X_unlab) y_missing = np.array([np.argmax(i) for i in y_missing]) self.X_tot = np.concatenate((self.X_train_lab, self.X_unlab), axis=0) self.y_tot = np.concatenate((self.y_train, y_missing), axis=0) def probas_values(self): temp = self.nn_fit(self.X_train_lab, self.y_train) probas_val = self.model.predict_proba(self.X_unlab) return probas_val def mesh(self): tableau = [] number_it = 20 tabl = [] for i in range(number_it): tableau.append(self.probas_values()) tabl = [(sum(x) / number_it) for x in zip(*tableau)] #print((tabl[0])) predict = [] """" for x in tabl: for j in range(len(x)): if max(x) == x[j]: predict.append(j) """ #print(predict[0]) predict = [np.argmax(i) for i in tabl] y_missing = predict self.X_tot = np.concatenate((self.X_train_lab, self.X_unlab), axis=0) self.y_tot = np.concatenate((self.y_train, y_missing), axis=0) def filtered_mesh(self): tableau = [] number_it = 10 tabl = [] for i in range(number_it): tableau.append(self.probas_values()) tabl = [(sum(x) / number_it) for x in zip(*tableau)] THRESHOLD_PROBAS = 0.7 #Si la probabilité maximale est en dessous du threshold: truncated_tabl = [i for i in tabl if max(i) > THRESHOLD_PROBAS] print(len(truncated_tabl)) #Trouver les indices de ses points pour les enlever du unlabeled set. indices = [] for i in range(len(tabl)): if max(tabl[i]) <= THRESHOLD_PROBAS: indices.append(i) self.X_unlab_truncated = np.delete(self.X_unlab, indices, axis=0) print(len(self.X_unlab_truncated)) #print((tabl[0])) #print(predict[0]) #Faire la prédiction que sur les points au dessus du threshold: predict = [np.argmax(i) for i in truncated_tabl] y_missing = predict self.X_tot = np.concatenate((self.X_train_lab, self.X_unlab_truncated), axis=0) self.y_tot = np.concatenate((self.y_train, y_missing), axis=0) """ @build_output_name: provides the name of the output with all the parameters """ def build_output_name(self): self.output_name = (datetime.datetime.now().strftime("%Y%m%d-%H%M%S")) if (self.JSON_MODE): if ('origin' in os.path.basename(os.path.normpath(sys.argv[1]))): self.output_name += '_OR_' nn_string = 'NN:' ss_string = 'SS:' for i in self.param_out: temp = (i + '=' + str(self.json_dict[i])) if (i in self.params_nn): nn_string += temp elif (i in self.params_ss): ss_string += temp else: self.output_name += temp self.output_name += ss_string if (self.USING_NN): self.output_name += nn_string """ @submission_formed: provides the good format to the submission file - predicted_y : the predicted values - name: name containing all parameters """ def submission_formed(self, predicted_y, name): result_dir = "./results" os.makedirs(result_dir, exist_ok=True) out = pd.DataFrame(predicted_y) out.insert(0, 'Id', range(30000, len(out) + 30000)) out.rename(columns={"Id": "Id", 0: "y"}, inplace=True) path = 'results/' + name + '.csv' out.to_csv(os.path.join(path), index=False) """ @save_to_csv: useful when self.datastate is set to 'save': save the datas obtained after the ss algorithm """ def save_to_csv(self, X_tot, y_tot, X_valid, y_valid): out_x = pd.DataFrame(X_tot) out_y = pd.DataFrame(y_tot) out_xv = pd.DataFrame(X_valid) out_yv = pd.DataFrame(y_valid) os.makedirs('./saved_datas', exist_ok=True) path_x = 'saved_datas/X_tot.csv' path_y = 'saved_datas/y_tot.csv' path_xv = 'saved_datas/X_valid.csv' path_yv = 'saved_datas/y_valid.csv' out_x.to_csv(os.path.join(path_x), index=False) out_y.to_csv(os.path.join(path_y), index=False) out_xv.to_csv(os.path.join(path_xv), index=False) out_yv.to_csv(os.path.join(path_yv), index=False) """ @load_xy: when self.datastate is set to 'load', loads data from saved data """ def load_xy(self): print('Loading the X and y...') self.X_valid_lab = (pd.read_csv('saved_datas/X_valid.csv')).to_numpy() self.y_valid = (pd.read_csv('saved_datas/y_valid.csv')).to_numpy() self.X_tot = (pd.read_csv('saved_datas/X_tot.csv')).to_numpy() self.y_tot = (pd.read_csv('saved_datas/y_tot.csv')).to_numpy() """@out: final output of the programm """ def out(self): self.submission_formed(self.y_submit, self.output_name) with open(self.log_spec + '/recap.json', 'w') as fp: json.dump(self.json_dict, fp, indent=1) print( '########################################DONE##################################' ) print("\n")
#First Hidden Layer classifier.add( Dense(6, 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')) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) history = classifier.fit(x_train, y_train, batch_size=20000, epochs=40) #end for eval_model = classifier.evaluate(x_train, y_train) eval_model filename2 = "11-03304.txt" f22 = open(filename2, "r") f2 = f22.readlines() ar2 = [] i = 0 for x2 in f2: ar2.append(x2.split()) i = 0 j = 0 t2 = [] for i in range(0, len(ar2)): for j in range(int(float(ar2[i][0]) * 100),
# train/dev set division x_train, x_test, y_train, y_test = train_test_split(flattened_images, categorical_labels, test_size=0.1, random_state=42) # noise addition x_train_noisy = x_train + noise_factor * np.random.normal( loc=0.0, scale=1.0, size=x_train.shape) x_test_noisy = x_test + noise_factor * np.random.normal( loc=0.0, scale=1.0, size=x_test.shape) x_train_noisy = np.clip(x_train_noisy, 0., 1.) x_test_noisy = np.clip(x_test_noisy, 0., 1.) # model building model = Sequential() model.add(Dense(90, activation='relu', input_dim=flattened_images.shape[1])) model.add(Dense(10, activation='sigmoid')) sgd = optimizers.SGD(lr=0.1) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) model.fit(x_train_noisy, y_train, epochs=10, verbose=0) # model evaluation score = model.evaluate(x_test_noisy, y_test, verbose=0) print('Test set loss : ', score[0]) print('Test set accuracy : ', score[1]) print("#" * 50)
model.add(Dropout(0.5)) model.add(Dense(64, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='softmax')) optimizer = Adam(lr=0.001) model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy']) import time start_time = time.time() hist = model.fit(x_train, y_train, validation_data=(x_val, y_val), batch_size=256, epochs=30, verbose=1) training_time = time.time() - start_time print(hist.history) model.evaluate(test_images, test_labels) model.save('my_2cnn3fc_model.h5') #training time mm = training_time // 60 ss = training_time % 60 print('Training {} epochs in {}:{}'.format(10, int(mm), round(ss, 1))) #plot loss and accuracy loss = hist.history['loss']
#model = Sequential #model_age = load_model('./models/age.h5') model = Sequential() model.add( TimeDistributed(Conv2D(36, kernel_size=(5, 5)), input_shape=input_shape)) model.add(TimeDistributed(MaxPooling2D(pool_size=(2, 2)))) model.add(TimeDistributed(Flatten())) model.add(CuDNNLSTM(128)) model.add(Dense(90)) model.add(Activation('relu')) model.add(Dropout(0.2)) model.add(Dense(10)) model.add(Activation('softmax')) model.summary() model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x=x_train, y=y_train, epochs=5, batch_size=256) acc = model.evaluate(x_test, y_test) print('acc test = ', acc[1], "%")
X_train = Train_data[:, 0] Y_train = Train_data[:, 1] X_test = Test_data[:, 0] Y_test = Test_data[:, 1] model = Sequential() model.add(Dense(units=100, input_shape=(1, ), activation='relu')) model.add(Dense(units=100, activation='relu')) model.add(Dense(units=100, activation='relu')) model.add(Dense(units=1, dtype=np.int)) model.compile(Adam(lr=0.001), loss='mean_squared_error', metrics=['accuracy']) model.fit(X_train, Y_train, epochs=100, batch_size=16, verbose=2) Y_predict = model.predict(X_test) ''' print(Y_predict) print(Y_test) plt.plot(Y_predict, color = 'red') plt.plot(Y_test, color = 'green') plt.show() ''' New_predicted_data = [] for i in range(len(Y_predict)): New_predicted_data.append([X_test[i], Y_predict[i]])
def train_A(Clean_trainA): #load tidy data data = pd.read_csv(Clean_trainA) #remain label and tidy tweet data = data[['Sentiment', 'tidy_tweet']] #creat dataset and tokenization tk = TweetTokenizer(reduce_len=True) global X, Y X = [] Y = [] tidy_token_list = [] for x, y in zip(data['tidy_tweet'], data['Sentiment']): x = json.dumps(x) X.append(tk.tokenize(x)) Y.append(y) tidy_token_list.append((tk.tokenize(x), y)) #print(tidy_token_list) word_to_index, index_to_word, word_to_vec_map = read_glove_vecs( 'model\\glove.6B.100d.txt') max_len = 30 print('max_len:', max_len) X = np.zeros((len(tidy_token_list), max_len)) Y = np.zeros((len(tidy_token_list), )) for i, tk_lb in enumerate(tidy_token_list): tokens, label = tk_lb sentence_to_indices(tokens, word_to_index, max_len, i) Y[i] = label Y = to_categorical(Y, 3) model = Sequential() model.add( pretrained_embedding_layer(word_to_vec_map, word_to_index, max_len)) #model.add(Conv1D(filters, kernel_size, padding='valid', activation='relu', strides=1)) model.add(Conv1D(256, 2, padding='same', activation='relu', strides=1)) model.add(Dropout(0.4)) model.add(MaxPooling1D(pool_size=2)) model.add(Conv1D(256, 3, padding='same', activation='relu', strides=1)) model.add(Dropout(0.4)) model.add(MaxPooling1D(pool_size=2)) model.add(Conv1D(256, 4, padding='same', activation='relu', strides=1)) model.add(Dropout(0.4)) model.add(MaxPooling1D(pool_size=2)) model.add(Bidirectional(LSTM(units=256, return_sequences=True))) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(300)) model.add(Dense(3, activation='softmax')) model.summary() model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) H = model.fit(X, Y, validation_split=0.2, epochs=9, batch_size=128, shuffle=True) model.save('A\\modelA.hdf5') plt.plot(H.history['acc']) plt.plot(H.history['val_acc']) plt.title('Model A accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Train', 'Validation'], loc='upper left') plt.show() plt.savefig("Accuracy_A.png") plt.plot(H.history['loss']) plt.plot(H.history['val_loss']) plt.title('Model A loss') plt.ylabel('loss') plt.xlabel('Epoch') plt.legend(['Train', 'Validation'], loc='upper right') plt.show() plt.savefig("Loss_A.png") return H.history['acc'][-1], H.history['val_acc'][-1]
model = Sequential() model.add(layers.Embedding(vocab_size, embedding_dim, input_length=maxlen)) model.add(layers.Conv1D(128, 5, activation='relu')) model.add(layers.GlobalMaxPooling1D()) model.add(layers.Dense(10, activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.summary() #train the model history = model.fit(X_train, y_train, epochs=2, verbose=True, validation_data=(X_test, y_test), batch_size=10) loss, accuracy = model.evaluate(X_train, y_train, verbose=False) print("Training Accuracy: {:.4f}".format(accuracy)) loss, accuracy = model.evaluate(X_test, y_test, verbose=False) print("Testing Accuracy: {:.4f}".format(accuracy)) plot_history(history) #test examples ex_sent = "conservative feeling" X_ex_sent = tokenizer.texts_to_sequences([ex_sent]) X_ex_sent = pad_sequences(X_ex_sent, padding='post', maxlen=maxlen) print(model.predict(X_ex_sent)) #save the model
# define model model = Sequential() model.add( LSTM(n_steps_in, activation='relu', return_sequences=True, input_shape=(n_steps_in, n_features))) model.add(LSTM(n_steps_in, activation='relu', return_sequences=True)) model.add(Dense(n_features)) model.compile(optimizer='adam', loss='mse') model.summary() print("done!") print("training model...") # fit model history = model.fit(X, y, epochs=E, verbose=1, callbacks=[es], batch_size=B) model_name = M model.save(model_name) print("done!") loss = history.history['loss'] outputfilename = T output_file = open(outputfilename, "w") print("Opened txt file") output_file.write("loss\n") for i in range(len(loss)): output_file.write(str(loss[i]))
# To summarize, our model is a simple RNN model with 1 embedding, 1 LSTM and 1 dense layers. 213,301 parameters in total need to be trained. # ### Train and evaluate our model # # We first need to compile our model by specifying the loss function and optimizer we want to use while training, as well as any evaluation metrics we'd like to measure. Specify the approprate parameters, including at least one metric 'accuracy'. model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Once compiled, we can kick off the training process. There are two important training parameters that we have to specify - batch size and number of training epochs, which together with our model architecture determine the total training time. # # Training may take a while, so grab a cup of coffee, or better, go for a run! 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[1] will correspond to accuracy if we pass metrics=['accuracy'] scores = model.evaluate(X_test, y_test, verbose=0) print('Test accuracy:', scores[1])
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() history = model.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=NUM_EPOCHS, batch_size=BATCH_SIZE, callbacks=[checkpointer, history_checkpointer]) util.copy_model_to_latest(BASE_PATH, MODEL_PATH, MODEL_NAME) print('total time: %ds' % round(util.total_time())) util.print_memory()
classifier.add( Dense(4, activation='relu', kernel_initializer='random_normal', input_dim=5)) #Second Hidden Layer classifier.add( Dense(4, activation='relu', kernel_initializer='random_normal')) #Output Layer classifier.add( Dense(1, activation='sigmoid', kernel_initializer='random_normal')) #Compiling the neural network classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) classifier.fit(X_train, y_train, batch_size=10, epochs=100) #Dumping model in a file file1 = open('model_neural.pkl', 'wb') pickle.dump(classifier, file1) '''df=pd.read_csv('data.csv') #getting splitted data from function train,test = data_split(df, 0.3) # splitting features and output for prediction x_train = train[['fever','bodypain','age','runnynose','diffbreath']].to_numpy() x_test = test[['fever','bodypain','age','runnynose','diffbreath']].to_numpy() y_train = train[['infected']].to_numpy().reshape(train.shape[0],)
sequences_tr = sequence.pad_sequences(X_train, maxlen=max_len) sequences_te = sequence.pad_sequences(X_test, maxlen=max_len) sequences_tr = to_categorical(sequences_tr) sequences_te = to_categorical(sequences_te) print(sequences_tr) #print(type(sequences_hot.shape)) #print(sequences_hot.shape) #sequences_hot = list(sequences_hot) #print(sequences_hot) #sequences_hot = pd.DataFrame(sequences_hot) #sequences_hot.to_csv("seq.csv") #print(sequences_hot) model = Sequential() model.add(Embedding(256, len(sequences_tr[0]))) # 사용된 단어 수 & input 하나 당 size model.add(LSTM(len(sequences_tr[0]))) model.add(Dense(3, activation='softmax')) # 카테고리 수 model.summary() class_weight = {0.: 1., 1.: 7.} hist = model.fit(sequences_tr, Y_train, batch_size=128, epochs=10, validation_split=0.2, class_weight=class_weight)
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')
model.add(Activation('sigmoid')) #再加一層fully connected layer(dense), 不用input, 跟前一層output一樣 model.add(Dense(500)) model.add(Activation('sigmoid')) model.add(Dense(10)) model.add(Activation('softmax')) #evaluate model好壞 #configuration(optimizer) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #batch越大,速度越快,但是結果會爛掉 #batch越小,速度越慢,gpu平行運算加速效果不明顯 model.fit(data_train, target_train, batch_size=100, epochs=20) score = model.evaluate(data_test, target_test) im = Image.fromarray(data_test[4].reshape(28, 28)) plt.imshow(im) predict = model.predict(data_test)[4] np.where(predict == np.amax(predict)) # read handwrite image data = Image.open(r'C:\Users\yt335\Desktop\handwriting number.png').convert( 'L') data_np = np.array(data).reshape(1, 784) data_np = data_np / 255 predict = model.predict(data_np)
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])
model.add(layers.Dense(label_size, activation="softmax")) model = utils.multi_gpu_model(model, gpus=4) model.compile(metrics=['acc'], loss='categorical_crossentropy', optimizer='adam') """ mirrored_strategy = tf.distribute.MirroredStrategy() with mirrored_strategy.scope(): model = Sequential() model.add( efn.EfficientNetB3(weights="imagenet", include_top=False, pooling='avg')) model.add(layers.Dense(label_size, activation="softmax")) model.compile(metrics=['acc'], loss='categorical_crossentropy', optimizer='adam') # """ checkpointer = ModelCheckpoint(filepath='best.hdf5', verbose=1, save_best_only=True) # Save best weight file csv_logger = CSVLogger('history.log') history = model.fit(train_generator, validation_data=validation_generator, epochs=150, callbacks=[csv_logger, checkpointer]) model.save('last.hdf5') # Save last weight file