def fit(self, X, y): # check is tensorflow is available _check_tensorflow() sequence_length = X.shape[1] if self._model is None or sequence_length != self.sequence_length: self.sequence_length = sequence_length keras_model = _create_lstm_pool_model( embedding_matrix=self.embedding_matrix, backwards=self.backwards, dropout=self.dropout, optimizer=self.optimizer, max_sequence_length=sequence_length, lstm_out_width=self.lstm_out_width, learn_rate=self.learn_rate, verbose=self.verbose) self._model = KerasClassifier(keras_model, verbose=self.verbose) self._model.fit(X, y, batch_size=self.batch_size, epochs=self.epochs, shuffle=self.shuffle, class_weight=self.class_weight, verbose=self.verbose)
class NeuralNet(BaseEstimator): def __init__(self, neuralNet, epochs, batch_size, verbose): self.neuralNet = neuralNet self.epochs = epochs self.batch_size = batch_size self.verbose = verbose def fit(self, X, y): weights = np.mean(np.sum(y, axis=0)) / np.sum(y, axis=0) self.dict_weights = dict(enumerate(weights)) self.classifier = KerasClassifier( build_fn=self.neuralNet, epochs=self.epochs, batch_size=self.batch_size, verbose=self.verbose, class_weight=self.dict_weights, ) self.classifier.fit(X, y) return self def predict(self, X): return self.classifier.predict_proba(X) > 0.5 def score(self, X, y): return self.classifier.score(X, y) def predict_proba(self, X): return self.classifier.predict_proba(X)
def test_LSTM_compilation_and_fit_predict_without_execution_error(self): # given x_train = np.array( ['this is really awesome !', 'this is really crap !!']) y_train = np.array([1, 0]) ids_x_train = np.empty([2, 5]) for i in range(0, len(x_train)): ids = [ dummy_hash_function(token) for token in x_train[i].split(' ') ] ids_x_train[i, :] = ids num_labels = 2 y_enc = to_categorical(y_train, num_labels) dictionary_size = np.int(np.max(ids_x_train) + 1) # when lstm_factory = LSTMFactory() clf_keras = KerasClassifier(build_fn=lstm_factory.create_model, dictionary_size=dictionary_size, num_labels=num_labels) clf_keras.fit(ids_x_train, y_enc, epochs=1, verbose=False) x_test = np.array(['it is really awesome !']) ids_x_test = np.empty([1, 5]) ids_x_test[0, :] = [ dummy_hash_function(token) for token in x_test[0].split(' ') ] y_pred = clf_keras.predict(ids_x_test) # then self.assertIsNotNone(y_pred)
def fit(self, X, y, **kwargs): """ Fit the workflow by building the word corpus, and fitting the keras model. Parameters ---------- X : array-like, iterable Collection of str or an iterable which yields str y : array-like, shape (n_samples,) Class targets. **kwargs : parameters passed to inner keras model Returns ------- self : object Returns an instance of self. """ x = self.text2seq.fit_transform(X) y_enc = to_categorical(y, self.num_labels) self.model_ = KerasClassifier(build_fn=self.factory.create_model, dictionary_size=self.text2seq.dictionary_size_, num_labels=self.num_labels) self.model_.fit(x, y_enc, **kwargs) return self
class KerasGridOptimizer(): def __init__(self, epochs=10, n_layers=1, n_nodes=32, learning_rate=5e-4, batch_size=128): self._epochs = epochs self._n_layers = n_layers self._n_nodes = n_nodes self._learn_rate = learning_rate self._batch_size = batch_size def get_params(self, deep=False): return { 'epochs': self._epochs, 'n_layers': self._n_layers, 'n_nodes': self._n_nodes } def set_params(self, epochs=None, n_layers=None, n_nodes=None, learning_rate=None, batch_size=None): if epochs is not None: self._epochs = epochs if n_layers is not None: self._n_layers = n_layers if n_nodes is not None: self._n_nodes = n_nodes if learning_rate is not None: self._learn_rate = learning_rate if batch_size is not None: self._batch_size = batch_size return self def fit(self, X, y): self._model = models.Sequential() self._model.add(layers.Flatten(input_shape=(26, ))) for i in range(self._n_layers): self._model.add(layers.Dense(self._n_nodes, activation='relu')) self._model.add(layers.Dense(3, activation='softmax')) opt = keras.optimizers.Adam(learning_rate=self._learn_rate) self._model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) self._est = KerasClassifier(build_fn=lambda: self._model, epochs=self._epochs, verbose=0, batch_size=self._batch_size) self._est.fit(X, y) def score(self, X, y): return self._est.score(X, y)
def fit(self, X_raw, y_raw): """Classifier training function. Here you will implement the training function for your classifier. Parameters ---------- X_raw : numpy.ndarray A numpy array, this is the raw data as downloaded y_raw : numpy.ndarray (optional) A one dimensional numpy array, this is the binary target variable Returns ------- ? """ X_clean = self._preprocessor(X_raw) class_weights = class_weight.compute_class_weight( 'balanced', np.unique(y_raw), y_raw) es = EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=5, mode='auto', restore_best_weights=True) # ARCHITECTURE OF OUR MODEL def make_nn(hidden_layers=[7, 7], lrate=0.001): sgd = optimizers.SGD(lr=lrate) adam = optimizers.Adam(lr=lrate) he_init = he_normal() model = Sequential() for k in hidden_layers: model.add( Dense(k, activation='relu', kernel_initializer=he_init, bias_initializer='zeros')) model.add( Dense(1, activation='sigmoid', kernel_initializer=he_init, bias_initializer='zeros')) model.compile(loss='binary_crossentropy', optimizer=adam) return model self.base_classifier = KerasClassifier(make_nn, class_weight=class_weights, epochs=350, validation_split=0.1, batch_size=32, callbacks=[es]) # THE FOLLOWING GETS CALLED IF YOU WISH TO CALIBRATE YOUR PROBABILITES self.base_classifier.fit(X_clean, y_raw) return self.base_classifier
def classifier(X_train, y_train, X_test, X_params_select, y_params_select, tune_size, config_list, opt_modulo_params): ### # Hyperparameterarrays ### learn_rate = [0.1] momentum = [float(x) for x in np.linspace(start=0, stop=0.9, num=4)] hidden_layer_n = [int(x) for x in np.linspace(start=10, stop=100, num=4)] param_grid = { 'learn_rate': learn_rate, 'momentum': momentum, 'hidden_layer_n': hidden_layer_n, } ### # Training and Fitting ### early_stopping = EarlyStopping(monitor='accuracy', patience=500) model = KerasClassifier(build_fn=create_model, epochs=10000) if config_list['optimize_method'] == 1: if config_list['randomized_search'] == 1: grid = RandomizedSearchCV(estimator=model, param_distributions=param_grid, cv=2, n_iter=25) else: grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=2) model = grid.fit(X_params_select, y_params_select, epochs=10000, callbacks=[early_stopping], verbose=0) opt_modulo_params = grid.best_params_ #model = create_model(**opt_modulo_params) print(opt_modulo_params) else: model = create_model() model.fit(X_train, y_train, epochs=10000, callbacks=[early_stopping], verbose=0) predictions_prob = model.predict( X_test ) #bugfix: https://datascience.stackexchange.com/questions/13461/how-can-i-get-prediction-for-only-one-instance-in-keras print(predictions_prob) y_pred = np.where(predictions_prob >= 0.5, 1, -1) y_pred = list(itertools.chain(*y_pred)) y_pred = np.array(y_pred) print(y_pred) print(type(y_pred)) return y_pred, opt_modulo_params
def ede_dnn(dnn_model, Xtrain, ytrain, Xtest, ytest, batch_size, epochs, model_dir, patience=3, factor=0.2, export='DNN_y2', verbose=0): """ Used to generate DNN model instance and training. :param dnn_model: Model to be generated :param Xtrain: Training input data :param ytrain: Training ground truth :param Xtest: Testing input data :param ytest: Testing ground truth :param batch_size: DNN Batch size :param epochs: Training Epochs :param model_dir: Model directory location :param patience: Patiance for early stopping callback :param factor: Factor for reduce learning rate :param export: name used for exporting :return: tf.history """ # One hot encoding of groundtruth both testing and training y_oh_train = pd.get_dummies(ytrain, prefix='target') y_oh_test = pd.get_dummies(ytest, prefix='target') early_stopping = EarlyStopping(monitor="loss", patience=patience) # early stop patience reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=factor, patience=5, min_lr=0.00001) model = KerasClassifier(build_fn=dnn_model, verbose=verbose, callbacks=[early_stopping, reduce_lr]) history = model.fit(np.asarray(Xtrain), np.asarray(y_oh_train), batch_size=batch_size, epochs=epochs, callbacks=[early_stopping, reduce_lr], verbose=0, validation_data=(np.asarray(Xtest), np.asarray(y_oh_test))) # Saving History df_history = pd.DataFrame(history.history) history_name = "DNN_history_{}.csv".format(export) df_history.to_csv(os.path.join(model_dir, history_name), index=False) return history
def create_scikit_keras_classifier(X, y): # create simple (dummy) Keras DNN model for classification batch_size = 500 epochs = 10 model_func = create_scikit_keras_model_func(X.shape[1]) model = KerasClassifier(build_fn=model_func, nb_epoch=epochs, batch_size=batch_size, verbose=1) model.fit(X, y) return model
def fit(self, X, y): weights = np.mean(np.sum(y, axis=0)) / np.sum(y, axis=0) self.dict_weights = dict(enumerate(weights)) self.classifier = KerasClassifier( build_fn=self.neuralNet, epochs=self.epochs, batch_size=self.batch_size, verbose=self.verbose, class_weight=self.dict_weights, ) self.classifier.fit(X, y) return self
def fit(self, X, y): if scipy.sparse.issparse(X): X = X.toarray() if self._model is None or X.shape[1] != self.input_dim: self.input_dim = X.shape[1] keras_model = _create_dense_nn_model( self.input_dim, self.dense_width, self.optimizer, self.learn_rate, self.regularization, self.verbose) self._model = KerasClassifier(keras_model, verbose=self.verbose) self._model.fit(X, y, batch_size=self.batch_size, epochs=self.epochs, shuffle=self.shuffle, verbose=self.verbose, class_weight=_set_class_weight(self.class_weight))
def fit(self, X_raw, y_raw, claims_raw): """Classifier training function. Here you will use the fit function for your classifier. Parameters ---------- X_raw : ndarray This is the raw data as downloaded y_raw : ndarray A one dimensional array, this is the binary target variable claims_raw: ndarray A one dimensional array which records the severity of claims Returns ------- self: (optional) an instance of the fitted model """ nnz = np.where(claims_raw != 0)[0] self.y_mean = np.mean(claims_raw[nnz]) # ============================================================= # REMEMBER TO A SIMILAR LINE TO THE FOLLOWING SOMEWHERE IN THE CODE X_clean = self._preprocessor(X_raw, mode='train') #Compute class weights and define callback for early stopping class_weights = class_weight.compute_class_weight('balanced', np.unique(y_raw), y_raw) es = EarlyStopping(monitor='val_loss', min_delta = 0.0001, patience = 5, mode='auto', restore_best_weights=True) # ARCHITECTURE OF OUR MODEL def make_nn(hidden_layers=[5,5], lrate=0.0005, random_seed=0): sgd = optimizers.SGD(lr=lrate) he_init = he_normal(seed=random_seed) model = Sequential() for k in hidden_layers: model.add(Dense(k, activation='relu', kernel_initializer=he_init, bias_initializer='zeros')) model.add(Dense(1, activation='sigmoid', kernel_initializer=he_init, bias_initializer='zeros')) model.compile(loss='binary_crossentropy', optimizer=sgd) return model self.base_classifier = KerasClassifier(make_nn, class_weight=class_weights, epochs=350, validation_split=0.1, batch_size=64, callbacks=[es]) # THE FOLLOWING GETS CALLED IF YOU WISH TO CALIBRATE YOUR PROBABILITES if self.calibrate: self.base_classifier = fit_and_calibrate_classifier( self.base_classifier, X_clean, y_raw) else: self.base_classifier.fit(X_clean, y_raw) return self.base_classifier
def load_keras_classifier(name, path=ASSETS_PATH): """Load a Keras model from disk, as KerasClassifier (sklearn wrapper)""" model_path, classes_path = keras_model_and_classes_paths(name) nn = KerasClassifier(build_fn=do_nothing) # load model and classes nn.model = keras.models.load_model(model_path) classes = pickle.load(open(classes_path, 'rb')) # required for sklearn to believe that the model is trained nn._estimator_type = "classifier" nn.classes_ = classes return nn
def neural_network_hyper(features_encoded, target_encoded): """ Hyperparameter tuning of Neural network :param: Features data :param: Target data :return: Neural network model with best parameters """ global hyperparameter if not hyperparameter: estimator = KerasClassifier(build_fn=create_model, n_hidden=5, size_nodo=12, ativ="relu", opt="adam", dropout=0.1, epochs=500, batch_size=10000, validation_split=0.1, verbose=0) return estimator grid_param = { 'n_hidden': [2, 5], 'size_nodo': [50, 200], 'ativ': ['relu', 'softmax'], 'opt': ['adam'], 'dropout': [0.1], 'epochs': [50], 'batch_size': [20000] } model = KerasClassifier(build_fn=create_model, verbose=1, validation_split=0.1) ann_hyper_parameters = grid_search(features_encoded, target_encoded, 2, grid_param, model) print('\n\n\nBest Neural Network Hyper-parameters using GridSearch:\n', ann_hyper_parameters) estimator = KerasClassifier( build_fn=create_model, n_hidden=ann_hyper_parameters['n_hidden'], size_nodo=ann_hyper_parameters['size_nodo'], ativ=ann_hyper_parameters['ativ'], opt=ann_hyper_parameters['opt'], dropout=ann_hyper_parameters['dropout'], epochs=1000, #ann_hyper_parameters['epochs'], batch_size=ann_hyper_parameters['batch_size'], validation_split=0.1, verbose=1) return estimator
def run_classification_nn(path_dataset, name_type, dim, cross_values, epochs=100): """Draft classification function with NN2. Development stopped.""" path_base = join(path_dataset, "reduced") if name_type in ("mae", "maae"): path_read = join(path_base, "ae_{}".format(name_type)) else: path_read = join(path_base, name_type) data, class_ = read_feature_data(path_read, dim) data = data.to_numpy() kfold = KFold(n_splits=cross_values, random_state=42, shuffle=True) history_acc = [] accumulate_acc = [] def create_model(): model = Sequential() model.add(Dense(22, input_dim=dim, activation="relu")) model.add(Dense(12, activation="relu")) model.add(Dense(1, activation="softmax")) model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"]) return model for train_index, val_index in kfold.split(data): model = KerasClassifier(build_fn=create_model, epochs=epochs, batch_size=128, verbose=0) history = model.fit(data[train_index], class_[train_index]) pred = model.predict(data[val_index]) accuracy = accuracy_score(class_[val_index], pred) accumulate_acc.append(accuracy) history_acc.append(history.history["loss"]) return history_acc, accumulate_acc
def grid_search(layers_list, epochs_list, X_train, Y_train, indim=300): tup_layers = tuple([tuple(l) for l in layers_list]) tup_epochs = tuple(epochs_list) model = KerasClassifier(build_fn=create_model, verbose=0) #use our create_model # define the grid search parameters batch_size = [1] #starting with just a few choices epochs = tup_epochs lyrs = tup_layers #use this to override our defaults. keys must match create_model args param_grid = dict(batch_size=batch_size, epochs=epochs, input_dim=[indim], lyrs=lyrs) # buld the search grid grid = GridSearchCV( estimator=model, #we created model above param_grid=param_grid, cv=3, #use 3 folds for cross-validation verbose=2) # include n_jobs=-1 if you are using CPU grid_result = grid.fit(np.array(X_train), np.array(Y_train)) # 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))
def gridSearch(inputs_train, output_train): model = KerasClassifier(build_fn=create_model, verbose=10) # defining grid search parameters param_grid = { 'optimizer': ['RMSprop'], 'batch_size': [10], 'epochs': [100], # 'learn_rate': [0.001, 0.01, 0.1, 0.2, 0.3], # 'momentum': [0.0, 0.2, 0.4, 0.6, 0.8, 0.9], 'init_mode': ['lecun_uniform'], 'activation': ['softmax'], 'weight_constraint': [1], 'dropout_rate': [0.0, 0.5, 0.9], 'neurons': [10, 30] } grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=3, verbose=10) grid_result = grid.fit(inputs_train, output_train) # summarize results print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_)) return grid.best_params_, grid.best_score_
def Keras_Classifier(n_splits, save_model_address, model_types, train_images, train_labels, test_images, test_labels, image_size1, image_size2, image_size3, label_types, epochs, times, L1, L2, F1, F2, F3): print("begin of keras_classifier: ") model = KerasClassifier(build_fn=create_model, model_types=model_types, image_size1=image_size1, image_size2=image_size2, label_types=label_types, image_size3=image_size3, times=times, L1=L1, L2=L2, F1=F1, F2=F2, F3=F3, epochs=epochs, batch_size=2, verbose=1) kfold = KFold(n_splits=n_splits, shuffle=True, random_state=5000) #scores = cross_val_score(model1, train_images, train_labels, cv=kfold) print("before of cross_val_predict:") y_pre = cross_val_predict(model, train_images, train_labels, cv=kfold) print(y_pre) y_scores = y_pre print("train_labels", train_labels) print("y_scores", y_scores) fpr, tpr, thresholds = roc_curve(train_labels, y_scores) plt.plot(fpr, tpr) plt.savefig("ROC.png") plt.show()
def cross_val_nn(): print('Cross validation initializing') X, y = data_time() mod = KerasClassifier(build_fn=phish_nn, epochs=15, batch_size=1500, verbose=0) num_folds = 5 kfold = StratifiedKFold(n_splits=num_folds, shuffle=True, random_state=808) print('Starting 5-fold cross validation of model') cv_results = cross_val_score(mod, X, y, cv=kfold) print('Starting 5-fold cross-validation predictions') cv_preds = cross_val_predict(mod, X, y, cv=kfold, verbose=0, method='predict') print('The average cross-validation accuracy is: ', round(cv_results.mean(), 4) * 100, '%') print('The 5-fold cross validation accuracy results are: \n', cv_results) acc = accuracy_score(y, cv_preds) cm = confusion_matrix(y, cv_preds) print('Confusion Matrix \n', cm) print('Accuracy Score: \n', acc) f1s = f1_score(y, cv_preds) print('The F1 score for the cross validated model is: \n', f1s) precis = precision_score(y, cv_preds, average='binary') rec = recall_score(y, cv_preds, average='binary') print('The precision-recall score is: \n', precis) print('The recall score is: \n', rec) return cm
def train_age(X, Y, X_test, train=True, epoch=10, batch_size=1024): # 类别转换为0和1 encoder = LabelEncoder() encoder.fit(Y) Y = encoder.transform(Y) if train: scaler = StandardScaler() scaler.fit(X) X = scaler.transform(X) Y = to_categorical(Y) model = create_age_model() model.fit(X, Y, batch_size=batch_size, epochs=epoch) X_test = scaler.transform(X_test) y_pre = model.predict(X_test) y_pred_age = np.argmax(y_pre, axis=1) return y_pred_age else: # estimator = KerasClassifier( # build_fn=create_gender_model, epochs=epoch, batch_size=batch_size, verbose=0) estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasClassifier(build_fn=create_age_model, epochs=epoch, batch_size=batch_size, verbose=0))) pipeline = Pipeline(estimators) kfold = StratifiedKFold(n_splits=10, shuffle=True) results = cross_val_score(pipeline, X, Y, cv=kfold) print("Baseline: %.2f%% (%.2f%%)" % (results.mean() * 100, results.std() * 100))
def run_gridSearch(X_train, y_train): # Tuning the model: Grid Search method # Method to tune and test different combinations of parameters/hyperparameters # Wrap the whole thing wrappedClassifier = KerasClassifier( build_fn=build_model(dropout_rate=0.2, optimizer='adam')) # Create parameters dictionary params = { 'batch_size': [10, 20], 'epochs': [15, 20], 'Optimizer': ['adam', 'nadam'] } gridSearch = GridSearchCV(estimator=wrappedClassifier, param_grid=params, scoring='accuracy', cv=7) gridSearch = gridSearch.fit(X_train, y_train) best_param = gridSearch.best_params_ best_accuracy = gridSearch.best_score_ return best_param, best_accuracy
def __init__(self, vocab_size, create_model_callback, title, layers, isFinal, existentModel): print("""\n\nRNN PARAMETERS _________________________________ vocab_size: {} title: {} layers: {} isFinal: {} existentModel: {} \n\n""".format(vocab_size, title, layers, isFinal, existentModel)) metric_monitor = "val_recall" #"val_loss" self.callbacks = [ EarlyStopping(monitor=metric_monitor, mode='min', verbose=1), ModelCheckpoint("{}_checkpoint_model.h5".format(title), monitor=metric_monitor, mode='max', save_best_only=True, verbose=1), CSVLogger('{}_train_callback_log.txt'.format(title)) ] MLModel.__init__(self, model=KerasClassifier( build_fn=create_model_callback, epochs=50, batch_size=10, verbose=2, vocab_size=vocab_size, hidden_dims=layers, ), param_grid=getRNNGrid(), title=title, isFinal=isFinal, existentModel=existentModel)
def gridSearch(inputs_train, output_train): model = KerasClassifier(build_fn=create_model, verbose=0) # defining grid search parameters param_grid = { 'optimizer': ['SGD', 'RMSprop', 'Adam'], #best:SGD , 'Adagrad',, 'Adadelta', 'Adamax', 'Nadam' 'batch_size': [10, 100, 500], #best:10 'epochs': [100, 1000], #best:100 # 'learn_rate': [0.001, 0.01, 0.1, 0.2, 0.3], # 'momentum': [0.0, 0.2, 0.4, 0.6, 0.8, 0.9], # 'init_mode': ['uniform','normal'], #, 'zero', 'lecun_uniform',, 'glorot_normal', 'glorot_uniform', 'he_normal', 'he_uniform' # 'activation': ['softmax','relu','sigmoid'], #, 'softplus', 'softsign', , 'tanh', , 'hard_sigmoid', 'linear' # # 'weight_constraint': [1, 3, 5], # 'dropout_rate': [0.0, 0.9], #, 0.5 # 'neurons': [25, 50] #10, } grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=3, verbose=10) grid_result = grid.fit(inputs_train, output_train) # 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)) return grid.best_params_, grid.best_score_
def neural_network_classifier(X_train, X_test, t_train, t_test): # Function to create model, required for KerasClassifier def create_model(): # create model model = keras.Sequential() model.add(layers.Dense(16, input_shape=(4,), activation='tanh')) model.add(layers.Dense(8, activation='tanh')) model.add(layers.Dense(4, activation='tanh')) model.add(layers.Dense(3, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model nnclassifier = KerasClassifier(build_fn=create_model, verbose=0) k_fold = StratifiedKFold( n_splits=folds, random_state=random_seed, shuffle=True) param_grid = { "batch_size": [10, 20, 40, 60, 80, 100], "epochs": [10, 50, 100] } gs = GridSearchCV(nnclassifier, param_grid, scoring=scoring, cv=k_fold, n_jobs=-1) gs.fit(X_train, t_train) print(gs.best_params_) use_model(gs, gs.best_score_, X_train, X_test, t_test, 'Neural Net Classification')
def main(): ''' Main function ''' # Load data x_train, y_train, x_test, y_test, test_img_idx = prepare_data() MCBN_model = KerasClassifier(build_fn=create_model, epochs=15, batch_size=32, verbose=0) print("Start fitting monte carlo batch_normalization model") X = x_train[0:int(TRAIN_VAL_SPLIT * len(x_train))] X = X.astype('float32') Y = y_train[0:int(TRAIN_VAL_SPLIT * len(x_train))] X /= 255 # define the grid search parameters optimizer = [ 'SGD', 'RMSprop', 'Adagrad', 'Adadelta', 'Adam', 'Adamax', 'Nadam' ] param_grid = dict(optimizer=optimizer) grid = GridSearchCV(estimator=MCBN_model, param_grid=param_grid, n_jobs=-1, cv=3) 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))
def build_nn_classifier(self, X, y, params): return KerasClassifier(self.build_classifier, input_dim=X.shape[1], epochs=200, batch_size=8, verbose=1 if self.verbose else 0, **params)
def get_keras_classifier_pipeline(data): """ Keras Classifier: https://www.tensorflow.org/api_docs/python/tf/keras/wrappers/scikit_learn/KerasClassifier """ # Infer the shape of the feature vector size after passing in some testing through the pipeline ot transform it if config.INFER_KERAS_INPUT_SHAPE: spy = utils.Pipeline_Spy() pipeline = create_classifier_pipeline(spy, data) # Need to represent the single data sample as a 1 by num_features array, not a 1-dimensional vector num_features long data_sample = np.array(data.iloc[1, :])[np.newaxis, ...] print("Original data shape: {}".format(data_sample.shape)) feature_vector_transformed = pipeline.fit_transform(data_sample)[0] print("Transformed data shape: {}".format( feature_vector_transformed.shape)) feature_vector_input_length = len(feature_vector_transformed) print("Inferred feature vector length for Keras model: {}".format( feature_vector_input_length)) else: feature_vector_input_length = config.KERAS_INPUT_SHAPE clf = KerasClassifier(build_fn=create_keras_model, input_dim=feature_vector_input_length, epochs=150, batch_size=32) return create_classifier_pipeline(clf, data)
def train_gender(X, Y, X_test, train=True, epoch=10, batch_size=1024): # 类别转换为0和1 encoder = LabelEncoder() encoder.fit(Y) Y_encoded = encoder.transform(Y) if train: scaler = StandardScaler() scaler.fit(X) X = scaler.transform(X) model = create_gender_model() model.fit(X, Y_encoded, validation_split=0.1, batch_size=batch_size, epochs=epoch) X_test = scaler.transform(X_test) y_pre = model.predict(X_test) threshold = 0.5 y_pred_gender = np.where(y_pre > threshold, 1, 0) return y_pred_gender else: estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasClassifier(build_fn=create_gender_model, epochs=epoch, batch_size=batch_size, verbose=0))) pipeline = Pipeline(estimators) kfold = StratifiedKFold(n_splits=5, shuffle=True) results = cross_val_score(pipeline, X, Y_encoded, cv=kfold) print("Baseline: %.2f%% (%.2f%%)" % (results.mean() * 100, results.std() * 100))
def main(): args = parse_option() print(args) x_train, y_train = mnist_reader.load_mnist('data/fashion', kind='train') x_test, y_test = mnist_reader.load_mnist('data/fashion', kind='t10k') class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'] x_train=x_train.reshape(x_train.shape[0], 28, 28, 1) x_test=x_test.reshape(x_test.shape[0], 28, 28 ,1) x_train = x_train / 255.0 x_test = x_test / 255.0 y_train=keras.utils.to_categorical(y_train) y_test=keras.utils.to_categorical(y_test) num_classes = 10 print("Grid search for batch_size,batch norm and learning rate") model = KerasClassifier(build_fn=build_model,,epochs=40,verbose=1) batch_size = [32,64,128] lr = [0.01,0.001] use_bn = [True,False] param_grid = dict(batch_size=batch_size, lr=lr,use_bn=use_bn) grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1, cv=3) grid_result = grid.fit(x_train, 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))
def build_nn_classifier(self, X, y, params): return KerasClassifier(build_fn=self.nn_classifier_model, input_dim=X.shape[1], num_classes=len(np.unique(y)), epochs=200, batch_size=8, verbose=1 if self.verbose else 0, **params)