def _model_build(self, *arg): self._prepare_test_data() model = KerasClassifier( build_fn=self.create_model, verbose=0) optimizers = [ 'adam'] init = [ 'normal', 'uniform'] epochs = [ 100, 150] batches = [ 5, 10] param_grid = dict( optimizer=optimizers, nb_epoch=epochs, batch_size=batches, init=init) grid = GridSearchCV( estimator=model, param_grid=param_grid, cv=5) grid_result = grid.fit( self.x_train, self.y_train) print("Best: %f using %s" % ( grid_result.best_score_, grid_result.best_params_)) # means = grid_result.cv_results_[ # 'mean_test_score'] # stds = grid_result.cv_results_[ # 'std_test_score'] # params = grid_result.cv_results_[ # 'params'] # for mean, stdev, param in zip(means, stds, params): # print("%f (%f) with: %r" % ( # mean, # stdev, # param)) # Training # with Best # Parameter model = Sequential() model.add(Dense( 12, input_dim=8, init=grid_result.best_params_['init'], activation='relu')) model.add(Dense( 8, init=grid_result.best_params_['init'], activation='relu')) model.add(Dense( 1, init=grid_result.best_params_['init'], activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer=grid_result.best_params_['optimizer'], metrics=['accuracy']) # Compile # model model.fit( self.x_train, self.y_train, nb_epoch=grid_result.best_params_['nb_epoch'], batch_size=grid_result.best_params_['batch_size']) yy_pred = model.predict( self.x_test) self.y_pred = [np.round( x) for x in yy_pred] self.y_true = self.y_test self.prob = model.predict_proba( self.x_test) self._analyse_result()
epochs=epochs, optimizer=optimizer, activation=activation, dropout_rate=dropout_rate) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1, cv=3) grid_result = grid.fit(images_train, labels_train) print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_)) x = grid_result.best_params_ a, b, c, d, e = x.values() #Building model with best parameters model = models.Sequential() model.add( layers.Conv2D(32, (5, 5), activation='relu', input_shape=(299, 299, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (5, 5), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu')) model.add(layers.AveragePooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(9, activation=a)) model.add(layers.Dropout(rate=c)) model.add(layers.Dense(9, activation='softmax')) #Compiling model.compile(loss='categorical_crossentropy',
X = X_values.reshape((X_values.shape[0], 1, X_values.shape[1])) Y = y.values split_value = 1500 test_X = X[split_value:, :] test_Y = Y[split_value:] train_X = X[:split_value, :] train_Y = Y[:split_value] opt = Adamax(lr=0.01) opt = Adam(lr=0.01) opt = SGD(lr=0.01, momentum=0.0) model = Sequential() model.add(LSTM(40, return_sequences=True)) model.add(Dropout(0.0)) model.add(Dense(1)) model.add(Flatten()) model.compile(loss='mean_absolute_error', optimizer=opt, metrics=['accuracy']) history = model.fit(train_X, train_Y, epochs=100, batch_size=40, validation_data=(test_X, test_Y), verbose=1) print(history.history.keys()) plt.plot(history.history['acc']) plt.plot(history.history['val_acc'])
y=y_train, cv=10, n_jobs=-1) print("Results: %.2f%% (%.2f%%)" % (accuracies.mean() * 100, accuracies.std() * 100)) # checking for overfitting (Dropout Regularization to reduce overfitting if needed) # classifier.add(Dropout(p = 0.1)) ########################## manually running model seed = 7 np.random.seed(seed) classifier = Sequential() classifier.add( Dense(units=45, kernel_initializer='uniform', activation='relu', input_dim=15)) #classifier.add(Dropout(rate=0.1)) classifier.add(Dense(units=30, kernel_initializer='uniform', activation='relu')) #classifier.add(Dropout(rate=0.3)) classifier.add( Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) hist = classifier.fit(X_train, y_train, batch_size=1, epochs=100) y_pred = classifier.predict(X_test) y_pred = (y_pred >= 0.5)
metrics=['accuracy']) return classifier classifier = KerasClassifier(build_fn=build_classifier, batch_size=10, epochs=30, verbose=1) accuracies = cross_val_score(classifier, X_train, y_train, cv=10) from keras.layers import Dropout classifier = Sequential() classifier.add( Dense(6, activation='relu', kernel_initializer='uniform', input_shape=(11, ))) classifier.add(Dropout(rate=.1)) classifier.add(Dense(6, activation='relu', kernel_initializer='uniform')) classifier.add(Dropout(rate=.1)) classifier.add(Dense(1, kernel_initializer='uniform', activation='sigmoid')) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) classifier.fit(X_train, y_train, batch_size=10, epochs=100, callbacks=[early_stop])
grid = GridSearchCV(estimator=model, param_grid=param_grid3, n_jobs=1, scoring='f1_weighted', verbose=1) grid_result = grid.fit(Xtrain_encoded, Ytrain_integer) print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_)) means = grid_result.cv_results_['mean_test_score'] stds = grid_result.cv_results_['std_test_score'] params = grid_result.cv_results_['params'] for mean, stdev, param in zip(means, stds, params): print("%f (%f) with: %r" % (mean, stdev, param)) #final model model = Sequential() model.add(Embedding(20000, 100, input_length=MAX_SEQUENCE_LENGTH)) model.add(LSTM(100)) model.add(Dropout(0.3)) model.add(Dense(16, activation='relu')) model.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['accuracy']) model.fit(Xtrain_encoded, Ytrain_encoded, validation_split=0.2, epochs=20, batch_size=16, verbose=1) loss, accuracy = model.evaluate(Xtest_encoded, Ytest, verbose=1) print('Accuracy: %f' % (accuracy * 100))
batch_size = [50,100,150,10000,30000] param_grid = dict(dropout_prob=dropout_prob, num_layers=num_layers, batch_size=batch_size) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=1) grid_result = grid.fit(X_train_processed_norm, y_train_encoded) print("Best validation accuracy: %f using %s" % (grid_result.best_score_, grid_result.best_params_)) # Tune number of epochs using the tuned value of other hyper-parameters obtained above # In[16]: model = Sequential() model.add(Flatten(input_shape=X_train.shape[1:])) model.add(Dense(512, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(512, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(10, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) checkpointer = ModelCheckpoint(filepath='mnist.model.best.hdf5',verbose=1, save_best_only=True) results = model.fit(X_train_processed_norm, y_train_encoded, batch_size=150, epochs=30, validation_split=0.33, callbacks=[checkpointer], verbose=0, shuffle=True)
accuracies = cross_val_score(estimator = classifier, X = X_train, y = y_train, cv = 10, n_jobs = 1) mean=accuracies.mean() variance=accuracies.std() #improving the ANN #Dropout regularization to reduce overfitting if needed classifier =Sequential() # adding Input layer and first hidden layer with dropout classifier.add( Dense(output_dim=6,init= "uniform",activation="relu",input_dim=11)) classifier.add(Dropout(p=0.1)) # adding second hidden layer classifier.add( Dense(output_dim=6,init= "uniform",activation="relu")) classifier.add(Dropout(p=0.1)) # adding output layer #if we have more than 1 output layer we use classifier.add( Dense(output_dim=1,init= "uniform",activation="sigmoid")) #compiling the ann #dependent variable has binary outcome we use loss function as binary_crossentropy #dependentvariable are more than two outcome then we use loss function as categorical_crossentropy classifier.compile(optimizer="adam",loss= "binary_crossentropy", metrics=["accuracy"])
#Proporción 70% train, 15% validation, 15% test X_train, X_test, y_train, y_test = train_test_split(all_images, all_labels_images_grouped, test_size=0.30, random_state=42) X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, test_size=0.5, random_state=42) X_train = np.asarray(X_train) X_test= np.asarray(X_test) X_val= np.asarray(X_val) y_train=np.asarray(pd.get_dummies(y_train)) y_val=np.asarray(pd.get_dummies(y_val)) y_test=np.asarray(pd.get_dummies(y_test)) model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(100, 800, 3))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(128, (3, 3), activation='relu', padding='same')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Flatten()) model.add(layers.Dense(512, activation='relu')) model.add(layers.Dense(3, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4),
class NeuralNetwork: def __init__(self, ds: Dataset): self.ds = ds def create_model(self, typ): clear_session() if typ == 'Sequential': self.model = Sequential() def add_final_layer(self): if self.ds.y_train.nunique() == 2: self.model.add(layers.Dense(1, activation='sigmoid')) self.model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) def sequential(self, layers, activation='relu'): """Create a sequential Keras model""" self.create_model('Sequential') self.add_dense(layers, activation) self.add_final_layer() def add_dense(self, filters, activation='relu'): for x in filters: self.model.add(layers.Dense(x, activation=activation)) def add_embedding_layer(self): if self.ds.weights is not None: self.model.add( layers.Embedding(input_dim=self.ds.vocab_size, output_dim=self.ds.weights.shape[1], input_length=self.ds.X_train.shape[1], weights=[self.ds.weights])) else: self.model.add( layers.Embedding(input_dim=self.ds.vocab_size, output_dim=self.ds.weights.shape[1], input_length=self.ds.X_train.shape[1])) def embedding_to_sequential(self, filters, activation='relu'): self.create_model('Sequential') self.add_embedding_layer() self.model.add(layers.GlobalMaxPool1D()) self.add_dense(filters) self.add_final_layer() def cnn(self, cnn_filters, kernel_sizes, dense_filters, activation='relu'): self.create_model('Sequential') self.add_embedding_layer() self.add_cnn(cnn_filters, kernel_sizes) self.model.add(layers.GlobalMaxPool1D) self.add_dense(dense_filters) self.add_final_layer() def grid_search(self, param_grid, **kwargs): #kwargs: epoch=10, verbose=False #not sure if this works, might need to return model if 'kernel_size' in param_grid: self.model = KerasClassifier(build_fn=self.cnn, **kwargs) elif 'filters' in param_grid: self.model = KerasClassifier(build_fn=self.embedding_to_sequential, **kwargs) else: self.model = KerasClassifier(build_fn=self.sequential, **kwargs) grid = RandomizedSearchCV(estimator=self.model, param_distributions=param_grid, verbose=1) grid.fit(self.ds.X_train, self.ds.y_train) test_accuracy = grid.score(self.ds.X_test, self.ds.y_test) print(f'Test accuracy for best model is {test_accuracy}') return grid def add_cnn(self, filters, kernels): assert len(filters) == len(kernels) for i in range(len(filters)): self.model.add(layers.Conv1D(filters[i], kernels[i])) def train(self, **kwargs): self.model.fit(self.ds.X_train, self.ds.y_train, **kwargs) def evaluate(self): trainl, traina = self.model.evaluate(self.ds.X_train, self.ds.y_train, verbose=False) vall, vala = self.model.evaluate(self.ds.X_test, self.ds.y_test, verbose=False) print(f'Training loss {trainl}, training accuracy {traina}') print(f'Validation loss {vall}, validation accuracy {vala}') return vall, vala def plot_history(self, path): metrics = ['acc', 'val_acc', 'loss', 'val_loss'] metric_dict = { 'acc': ['Training Accuracy', 'b'], 'val_acc': ['Validation Accuracy', 'r'], 'loss': ['Training Loss', 'b'], 'val_loss': ['Validation Loss', 'r'] } plt.figure(figsize=(12, 5)) plt.subplot(1, 2, 1) plt.title('Training and validation accuracy') plt.legend() for metric in metrics: if 'loss' in metric: plt.subplot(1, 2, 2) met = self.model.history.history[metric] x = range(1, len(met) + 1) plt.plot(x, met, metric_dict[met][1], label=metric_dict[met][0]) plt.title('Training and validation loss') plt.legend() plt.savefig(path)
scaler_test_10=StandardScaler().fit(X_test) X_test=scaler_test_10.transform(X_test) pickle.dump( scaler_test_10, open( "scaler_test_10.p", "wb" ) ) X_train = np.array(X_train) X_test= np.array(X_test) X_val= np.array(X_val) y_train=np.asarray(pd.get_dummies(y_train)) y_val=np.asarray(pd.get_dummies(y_val)) y_test=np.asarray(pd.get_dummies(y_test)) model = models.Sequential() model.add(layers.Dense(256, activation='relu', kernel_regularizer=regularizers.l2(0.01), input_shape=(32,))) model.add(layers.Dense(128, activation='relu', )) model.add(layers.Dense(64, activation='relu',)) model.add(layers.Dense(10, activation='softmax')) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc']) model.summary() history = model.fit(X_train, y_train, epochs=35, batch_size=120, validation_data=(X_val, y_val))
# If you look at the full docs it will appear intimidating. We only # need to set `units` in this lab. `Units` is the same as size or # channels from the last lab. It just determines how many # transformations we perform each step. from keras.layers import LSTM units = 32 lstm_layer = LSTM(units) # This layer can be applied to a sequence of inputs $x_1, \ldots, # x_T$, and the output will be the final features. values_per_time = 1 input_shape = (input_length, values_per_time) model = Sequential() model.add(Reshape(input_shape)) model.add(lstm_layer) # Note that we need to use a `Reshape` because we have 1 value at each # time. The LSTM layer allows `sequence_length x values per time` inputs as # we will see later. # To run the model it looks exactly as we saw the last couple weeks. # take the first example as input # input shape: num samples x input_length # output shape: num samples x hidden size inputs = tf.convert_to_tensor(df_train[features].iloc[:1]) output = model(inputs) print(inputs.shape) print(output.shape)
def create_model(): # create model model = Sequential() model.add(Dense(12, activation='relu', input_shape=(11, ))) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) #compile model model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return model #create a classifier for use in scikit-learn seed = 7 from keras.wrappers.scikit_learn import KerasClassifier from sklearn.model_selection import StratifiedKFold, cross_val_score model = KerasClassifier(build_fn=create_model, epochs=150, batch_size=10) kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed) results = cross_val_score(model, X, Y, cv=kfold) print(results.mean()) #reducing overfitting using Dropout model.add(Dropout(0.2)) #lift performance with learning rate schedule sgd = SGD(lr=0.1, momentum=0.9, decay=0.0001, nesterov=False) model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy'])
stds = grid_result.cv_results_['std_test_score'] params = grid_result.cv_results_['params'] used = [] for mean, stdev, param in zip(means, stds, params): print("%f (%f) with: %r" % (mean, stdev, param)) f.write("%f (%f) with: %r\n\n" % (mean, stdev, param)) used.append(param) ######################################## ## train the actual model with the best parameters best = grid_result.best_params_ model = Sequential() model.add(Dense(best['neurons'], input_dim=1000, activation=best['activation'])) model.add(Dropout(best['dropout_rate'])) if best['hidden_layers'] == 0: pass else: for i in range(best['hidden_layers']): model.add(Dense(best['neurons'], activation=best['activation'])) model.add(Dropout(best['dropout_rate'])) model.add(Dense(2, kernel_initializer='uniform', activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer=best['optimizer'], metrics=['accuracy']) hist = model.fit(x_train, y_train, batch_size=best['batch_size'],
Plot a graph where the x-axis is the number of hidden units, and the y-axis is the model performance (two lines: one with test loss, and one with test accuracy) ''' from keras.callbacks import History history = History() units = [2**i for i in range(1, 15)] loss = [] accuracy = [] for i in units: print('\n', 'number of hidden units: ', i) model = Sequential() model.add(Dense(i, input_dim=input_unit_size, activation='relu')) model.add(Dropout(0)) model.add(Dense(num_classes, activation='softmax')) sgd = SGD(lr=0.5) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) model_result = model.fit(X_train, y_train, validation_split=0.2) loss.append(model_result.history['val_loss']) accuracy.append(model_result.history['val_acc']) print('\n\n\n', 'loss: ', '\n', loss) print('\n\n\n', 'accuracy: ', '\n', accuracy) print('\n\n\n') plt.plot(units, loss, marker='o', color='r', label='loss')
cv = 10) grid_search = grid_search.fit(X_train, y_train) best_params = grid_search.best_params_ best_accuracy = grid_search.best_score_ ## BEST PARAMS {optimizer = rmsprop, batch_size = 25, nb_epoch = 500} ###################################################################################################################### #################################### MAKING THE PREDICTION AND EVALUATING MODEL ###################################################### ## Initialise the Artificial Neural Network classifier = Sequential() # Adding the input layer and the first hidden layer - best practice - avereage between input nodes and output nodes((11+1)/2) classifier.add(Dense(output_dim = 6, init = 'uniform', activation = 'relu', input_dim=11)) ### relu for rectifier (hidden node) ## Adding the second hidden layer classifier.add(Dense(output_dim = 16, init = 'uniform', activation = 'relu')) classifier.add(Dense(output_dim = 16, init = 'uniform', activation = 'relu')) classifier.add(Dense(output_dim = 16, init = 'uniform', activation = 'relu')) ## Adding the output layer classifier.add(Dense(output_dim = 1, init = 'uniform', activation = 'tanh')) ## only one node(yes/no) and activation function changed to sigmoid ## if output variable is encoded then dim=3, activation = softmax ## Compiling the Artificial Neural Network - finding the best weight values with stochastic approach
# Dropout Regularization to reduce overfitting if needed # Dropout: At each iteration of the training some neurons are randomly # disables , to prevent them be highly dependent when they learn the correlations # and therefore by overwriting these neurons the ANN learns several independent correlations in the data # This prevents the neurons from learn too much and thus overfitting # We can apply dropout in one or several layers # When we have overfitting its better to apply dropout in all layers # Creating an ANN with dropouts classifier = Sequential() classifier.add( Dense(output_dim=6, input_dim=11, init='uniform', activation='relu')) classifier.add(Dropout(rate=0.1)) classifier.add(Dense(output_dim=6, init='uniform', activation='relu')) classifier.add(Dropout(rate=0.1)) classifier.add(Dense(output_dim=1, init='uniform', activation='sigmoid')) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # Parameter tuning with GridSearch # GridSearch test multiple combination of hyperparameters and it helps us identify the best combo for our dataset # Tuning the ANN
model = KerasClassifier(build_fn=build_model, verbose=1) hyperparameters = create_hyperparameters() pipe = Pipeline([('minmax', MinMaxScaler()), ('model', model)]) search = RandomizedSearchCV(estimator=pipe, param_distributions=hyperparameters, n_iter=10, n_jobs=-1, cv=5) search.fit(x_train, y_train) # 평가하기 print("Score :", search.score(x_test, y_test)) ''' model = Sequential() model.add(Dense(3, input_dim=11, activation='relu')) model.add(Dense(256)) model.add(Dense(5)) model.add(Dense(512, activation='relu')) model.add(Dropout(keep_prob)) model.add(Dense(7, activation='relu')) model.add(Dense(512, activation='relu')) model.add(Dense(3, activation='relu')) model.add(Dense(12, activation='relu')) model.add(Dense(1, activation='relu')) model.add(Dense(2, activation='relu')) model.add(Dense(3, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy',optimizer='adam', metrics=['accuracy'])
classifier.add(Dense(units = 4, activation = 'relu', kernel_initializer = 'uniform')) #classifier.add(Dropout(0.1)) classifier.add(Dense(units = 1, activation = 'sigmoid', kernel_initializer = 'uniform')) classifier.compile(optimizer = optimizer, loss = 'binary_crossentropy', metrics = ['accuracy']) return classifier classifier = KerasClassifier(build_fn = my_model) parameters = {'batch_size':[25, 32], 'epochs':[100, 500], 'optimizer': ['adam', 'rmsprop'] } grid_search = GridSearchCV(estimator = classifier, param_grid = parameters, scoring = 'accuracy', cv = 10 ) grid_search_result = grid_search.fit(X_train, y_train) best_parameters = grid_search_result.best_params_ best_score = grid_search_result.best_score_ #Prediction after Tuning the ANN classifier = Sequential() classifier.add(Dense(units = 4, activation = 'relu', kernel_initializer = 'uniform', input_dim = 7)) #classifier.add(Dropout(0.1)) classifier.add(Dense(units = 4, activation = 'relu', kernel_initializer = 'uniform')) #classifier.add(Dropout(0.1)) classifier.add(Dense(units = 4, activation = 'relu', kernel_initializer = 'uniform')) #classifier.add(Dropout(0.1)) classifier.add(Dense(units = 1, activation = 'sigmoid', kernel_initializer = 'uniform')) classifier.compile(optimizer = 'rmsprop', loss = 'binary_crossentropy', metrics = ['accuracy']) classifier.fit(X_train,y_train, batch_size = 32, epochs = 100) #Evaluate the model score = classifier.evaluate(X_train, y_train) print('test loss', score[0]) print('test accuracy', score[1]) #Prediction on Test set y_pred = classifier.predict(X_test) y_pred = (y_pred > 0.4)
param_grid=param_grid, cv=ps, refit=False, verbose=3, n_jobs=1) # grid_result = grid.fit(X, Y) # summarize results print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_)) means = grid_result.cv_results_['mean_test_score'] stds = grid_result.cv_results_['std_test_score'] params = grid_result.cv_results_['params'] for mean, stdev, param in zip(means, stds, params): print("%f (%f) with: %r" % (mean, stdev, param)) """ # Build Keras model model = Sequential() model.add(Dense(50,activation='tanh',input_shape=(trainX.shape[1],))) model.add(GaussianNoise(0.5)) model.add(Dense(50)) model.add(Dense(trainY.shape[1],activation='softmax')) #sgd = SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) tb = TensorBoard(log_dir='/tmp/keras_logs/sg_class1')
model = KerasClassifier(build_fn=build_classifier, batch_size=5, epochs=200) accuracies = cross_val_score(estimator=model, X=X_train, y=y_train, cv=5) #CV = K-fold cross val. splits mean = accuracies.mean() variance = accuracies.std() print("Average accuracy:", mean, "Variance:", variance) # Improving the ANN # Dropout Regularization to reduce overfitting if needed from keras.layers import Dropout model = Sequential() model.add( Dense(input_dim=7, units=8, kernel_initializer='uniform', activation='relu')) model.add(Dropout(rate=0.1)) model.add(Dense(units=8, kernel_initializer='uniform', activation='relu')) model.add(Dropout(rate=0.2)) model.add(Dense(units=3, kernel_initializer='uniform', activation='softmax')) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(X_train, y_train, batch_size=5, epochs=200) y_pred_drop = model.predict(X_test)
for i in range(1, len(encoded)): sequence = encoded[i - 1:i + 1] sequences.append(sequence) print('Total Sequences: %d' % len(sequences)) # pad sequences max_length = max([len(seq) for seq in sequences]) sequences = pad_sequences(sequences, maxlen=max_length, padding='pre') print('Max Sequence Length: %d' % max_length) # split into input and output elements sequences = array(sequences) X, y = sequences[:, :-1], sequences[:, -1] y = to_categorical(y, num_classes=vocab_size) # define model model = Sequential() model.add(Embedding(vocab_size, 30, input_length=max_length - 1)) model.add(LSTM(60)) model.add(Dense(vocab_size, activation='softmax')) print(model.summary()) # compile network model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # fit network model.fit(X, y, epochs=500, verbose=2) # evaluate model # prepare the tokenizer on the source text tokenizer2 = Tokenizer()
test_features = conv_base.predict(np.array(test_X), batch_size=BATCH_SIZE, verbose=1) val_features = conv_base.predict(np.array(valid_X), batch_size=BATCH_SIZE, verbose=1) np.savez("train_features", train_features, train_label) np.savez("test_features", test_features, target_test) np.savez("val_features", val_features, valid_label) train_features_flat = np.reshape(train_features, (48000, 1*1*512)) test_features_flat = np.reshape(test_features, (10000, 1*1*512)) val_features_flat = np.reshape(val_features, (12000, 1*1*512)) NB_TRAIN_SAMPLES = train_features_flat.shape[0] NB_VALIDATION_SAMPLES = val_features_flat.shape[0] NB_EPOCHS = 10 model = models.Sequential() model.add(layers.Dense(512, activation='relu', input_dim=(1*1*512))) model.add(layers.LeakyReLU(alpha=0.1)) model.add(layers.Dense(num_classes, activation='softmax')) model.compile( loss='categorical_crossentropy', optimizer=optimizers.Adam(), metrics=['acc']) reduce_learning = callbacks.ReduceLROnPlateau( monitor='val_loss', factor=0.2, patience=2, verbose=1, mode='auto',
# In[ ]: ############################second way ################################################# # In[8]: # Instantiate a Sequential model model = Sequential() # Add a hidden layer of 64 neurons and a 20 neuron's input model.add(Dense(64, input_shape=(19,), activation='relu')) # Add an output layer of 3 neurons with sigmoid activation model.add(Dense(9, activation='sigmoid')) # Compile your model with adam and binary crossentropy loss model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.summary() # In[5]:
activations = [ 'relu'] param_grid = dict(layers=layers, activation=activations, batch_size = [10], epochs=[10]) grid = RandomizedSearchCV(estimator=model, param_distributions=param_grid,cv=5) grid_result = grid.fit(train_images, to_categorical(train_labels)) print("Best Score:",grid_result.best_score_) print("-------------------------------------------------------------") print("Best Parameters selected:",grid_result.best_params_) """**So we have got the best hyper paramters that we will use to build our final model**""" model=keras.Sequential() # Adding the input layer and the first hidden layer model.add(Dense(128,activation='relu',kernel_initializer = 'he_uniform',input_dim=784)) # Adding the second hidden layer model.add(Dense(units = 64, kernel_initializer = 'he_uniform',activation='relu')) # Adding the output layer model.add(Dense(units= 10, kernel_initializer = 'glorot_uniform', activation = 'softmax')) # Compiling the ANN model.compile(optimizer = 'Adamax', loss = 'categorical_crossentropy', metrics = ['accuracy']) from keras.utils import to_categorical # Fitting the ANN to the Training set model_history=model.fit(train_images, to_categorical(train_labels) ,batch_size = 10, epochs = 20)
classifier = KerasClassifier(build_classifier, batch_size=5, epochs=100) accuracies = cross_val_score(estimator=classifier, X=X_train, y=y_train, cv=5, n_jobs=1) mean = accuracies.mean() variance = accuracies.std() #improving the ANN for overfitting sing dropout from keras.layers import Dropout classifier = Sequential() classifier.add( Dense(4, input_dim=8, kernel_initializer='uniform', activation='relu')) classifier.add(Dropout(rate=0.2)) classifier.add(Dense(4, kernel_initializer='uniform', activation='relu')) classifier.add(Dropout(rate=0.2)) classifier.add(Dense(1, kernel_initializer='uniform', activation='sigmoid')) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) classifier.fit(X_train, y_train, epochs=50, batch_size=5) #Tuning the ANN from sklearn.model_selection import GridSearchCV
(grid_result.best_score_, grid_result.best_params_)) means = grid_result.cv_results_['mean_test_score'] stds = grid_result.cv_results_['std_test_score'] params = grid_result.cv_results_['params'] for mean, stdev, param in zip(means, stds, params): print("%f (%f) with: %r" % (mean, stdev, param)) # # # RUN MODEL # # model = Sequential() model.add(Dense(20, activation='relu', input_dim=len(elo_data.columns) - 1)) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) model.fit(X_train_elo, Y_train_elo, epochs=10, batch_size=50, validation_split=0.2, verbose=1) model.test_on_batch(X_test_elo, Y_test_elo, sample_weight=None) model.evaluate(X_test_elo, Y_test_elo, verbose=1)
metrics=['accuracy']) # model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, verbose=1, validation_data=(x_test, y_test)) # score = model.evaluate(x_test, y_test, verbose=0) # print('Test loss: ', score[0]) # print('Test accuracy: ', score[1]) # 将定义好的model传入sklearn进行cross_validation model = KerasClassifier(build_fn=create_model, nb_epoch=20, batch_size=128) kfold = StratifiedKFold(n_splits=3, shuffle=True, random_state=41) # results = cross_val_score(model, X, Y, cv=kfold, scoring='accuracy') scores_history = [] for train_ind, test_ind in kfold.split(X, Y0): model = Sequential() model.add(Dense(units=512, input_dim=784, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(units=512, activation='relu')) model.add(Dropout(0.2)) model.add(Dense(units=num_classes, activation='softmax')) model.summary() model.compile(optimizer=RMSprop(), loss='categorical_crossentropy', metrics=['accuracy']) model.fit(X[train_ind], Y[train_ind], epochs=epochs, batch_size=batch_size, verbose=0)
y=y_train, cv=10, n_jobs=-1) print("Results: %.2f%% (%.2f%%)" % (accuracies.mean() * 100, accuracies.std() * 100)) # checking for overfitting (Dropout Regularization to reduce overfitting if needed) # classifier.add(Dropout(p = 0.1)) ########################## manually running model seed = 7 np.random.seed(seed) classifier = Sequential() classifier.add( Dense(units=66, kernel_initializer='uniform', activation='relu', input_dim=22)) classifier.add(Dropout(rate=0.1)) classifier.add(Dense(units=44, kernel_initializer='uniform', activation='relu')) classifier.add(Dropout(rate=0.3)) classifier.add( Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) classifier.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) hist = classifier.fit(X_train, y_train, batch_size=1, epochs=100) y_pred = classifier.predict(X_test) y_pred = (y_pred >= 0.5)
#model = Sequential() #model.add(Dense(units=16, kernel_initializer='uniform', activation='relu', input_dim=29)) #model.add(Dense(units=8, kernel_initializer='uniform', activation='relu')) #model.add(Dense(units=6, kernel_initializer='uniform', activation='relu')) #model.add(Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) #model = Sequential() #model.add(Dense(units=16, kernel_initializer='uniform', activation='relu', input_dim=29)) #model.add(Dense(units=8, kernel_initializer='uniform', activation='relu')) #model.add(Dense(units=6, kernel_initializer='uniform', activation='relu')) #model.add(Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) #Construction du modèle model = Sequential() model.add(Dense(units=16, kernel_initializer='uniform', activation='relu', input_dim=4)) model.add(Dense(units=8, kernel_initializer='uniform', activation='relu')) model.add(Dense(units=6, kernel_initializer='uniform', activation='relu')) model.add(Dense(units=1, kernel_initializer='uniform', activation='sigmoid')) # model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy']) # attributs_pertinents_DDoS_train=attributs_pertinents_DDoS_train.astype(float) # attributs_tag_train=attributs_tag_train.astype(float) #Compilez le classifieur #model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) #Maintenant ajustons sur les données. #model.fit(XTrain, yTrain, batch_size=1, epochs=120) model.fit(attributs_pertinents_DDoS_train, attributs_tag_train, batch_size=1, epochs=120)