def train(data): X = np.asarray(data.drop(['ETA'], axis=1)) y = np.asarray(data["ETA"]) scaler = MinMaxScaler() X = scaler.fit_transform(X) with open("han_bike_scalers.pkl", "wb") as outfile: pkl.dump(scaler, outfile) upload_to_bucket('model/han_bike_scalers.pkl', 'han_bike_scalers.pkl', 'aha-ds-ml-pipeline') X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) model = KerasRegressor(build_fn=baseline_model, epochs=2, batch_size=3, verbose=1) history = model.fit(X_train, y_train, validation_data=(X_test, y_test), callbacks=[telegram_callback]) #============================================================================== # Predict & Evaluation #============================================================================== prediction = model.predict(X_test) score = mean_absolute_error(y_test, prediction) if score < 5: model.model.save('han_bike_models.h5') upload_to_bucket('model/han_bike_models.h5', 'han_bike_models.h5', 'aha-ds-ml-pipeline') return model
def create_scikit_keras_regressor(X, y): # create simple (dummy) Keras DNN model for regression batch_size = 500 epochs = 10 model_func = create_scikit_keras_model_func(X.shape[1]) model = KerasRegressor(build_fn=model_func, nb_epoch=epochs, batch_size=batch_size, verbose=1) model.fit(X, y) return model
def _base_learner(name_model, data_name): """Creates base-model object. Args: name_model: name of the base-model. data_name: name of the dataset Raises: Exception: Not Implemented Error. Returns: model object. """ if name_model == 'LinearRegression': return linear_model.LinearRegression() elif name_model == 'Lasso': return linear_model.Lasso() elif name_model == 'RandomForest': return ensemble.RandomForestRegressor() elif name_model == 'ElasticNet': return linear_model.ElasticNet() elif name_model == 'XGBoost': return ensemble.GradientBoostingRegressor() elif name_model == 'NN_regression': if data_name == 'ACIC': return KerasRegressor(build_fn=create_nn_regression_acic, verbose=0) elif data_name == 'IHDP': return KerasRegressor(build_fn=create_nn_regression_ihdp, verbose=0) else: return KerasRegressor(build_fn=create_nn_regression, verbose=0) elif name_model == 'MeanDiff': return _MeanDiff() else: if data_name == 'ukb': model_config = {} model_config['weights'] = 'imagenet' model_config['input_shape'] = (587, 587, 3) if name_model == 'resnet50': model_config['name_base_model'] = 'resnet50' return image_model_construction(model_config) elif name_model == 'inceptionv3': model_config['name_base_model'] = 'inceptionv3' return image_model_construction(model_config) else: model_config['name_base_model'] = 'image_regression' return image_model_construction(model_config) raise NotImplementedError( 'Estimator not supported:{}'.format(name_model))
def do(self): regressor = KerasRegressor(build_fn=self.model) grid = GridSearchCV(regressor, param_grid=self.parameters, cv=2) # i need to solve this cv issue # my_callbacks = EarlyStopping(monitor='mse', patience=10, verbose=2) return grid
def fitness(filter1, filter2, filter3, learning_rate): n_input = 51 # Number of gold nanocluster classes n_classes = 751 # Total wavelengths in UV-VIS pattern EPOCHS = 300 BATCH_SIZE = 10 # wrap model with KerasRegressor in order to include epochs and batch size model = KerasRegressor(build_fn = lambda: cnn_model(n_input, n_classes, filter1, filter2, filter3, learning_rate), epochs = EPOCHS, batch_size = BATCH_SIZE, verbose = False) print("") print("Current hyperparams:") print(f"filter1: {filter1}") print(f"filter2: {filter2}") print(f"filter3: {filter3}") print(f"learning_rate: {learning_rate}") # 5 sets of train validation splits kfold = KFold(n_splits = 5, shuffle = True, random_state = 42) results = cross_val_score(model, X_train, Y_train, cv = kfold, scoring = 'neg_mean_absolute_error', verbose = 1) print(results) mean_neg_MAE = results.mean() K2.clear_session() return -mean_neg_MAE
def set_pipeline(self): """defines the pipeline as a class attribute""" # preprocessing pipeline preproc_pipe = Pipeline([('text_preprocessor', TextProcessor())]) # instantiate pipeline with sklearn wrapper for keras model (to be able to save it into a .joblib format) self.pipeline = Pipeline([('preproc', preproc_pipe), ('nn_model', KerasRegressor(build_fn = initialize_model))])
def grid_search_cv(self): """ Performs grid search cross validation on the train data """ logger.info( "\tBeggining grid_search_cv to discover optimal hyperparameters") model = KerasRegressor(build_fn=self.compile_model, verbose=self.verbose) grid = grid_search_cv(estimator=model, param_grid=self.exploreParams, n_jobs=-1, cv=2) #return_train_score=True, grid_result = grid.fit(self.train_X, self.train_Y) bestParameters = grid_result.best_params_ bestModel = grid_result.best_estimator_.model bestModel.summary() bestModel.save(os.path.join(self.modelpath), overwrite=True) logger.info( "\tgrid_search_cv finished, flashing model to disk and saving best parameters to config..." ) logger.info("\tBest parameters: {params}".format(bestParameters)) # Save best found parameters to config file with open(os.path.join(args.configpath, args.configoptname)) as outfile: configOpt = yaml.load(file, Loader=yaml.FullLoader) configOpt['Optimal LSTM Parameters'] = bestParameters yaml.dump(configOpt, outfile, default_flow_style=False) self.history = bestModel.history.history return bestModel
def kfold_cross_val(df, target_col, bucket_mod, data_path, verbose, n_jobs): # evaluate using 10-fold cross validation X, y = prep.split_Xy(df, target_col) # run estimator if target_col == "mem_bin": # Y = y.reshape(-1, 1) encoder = LabelEncoder() y = encoder.fit_transform(y) # y_enc = keras.utils.to_categorical(y) estimator = KerasClassifier(build_fn=train.memory_classifier, epochs=60, batch_size=32, verbose=verbose) kfold = StratifiedKFold(n_splits=10, shuffle=True) elif target_col == "memory": estimator = KerasRegressor(build_fn=train.memory_regressor, epochs=60, batch_size=32, verbose=verbose) kfold = KFold(n_splits=10, shuffle=True) elif target_col == "wallclock": estimator = KerasRegressor(build_fn=train.wallclock_regressor, epochs=150, batch_size=64, verbose=verbose) kfold = KFold(n_splits=10, shuffle=True) print("\nStarting KFOLD Cross-Validation...") start = time.time() results = cross_val_score(estimator, X, y, cv=kfold, n_jobs=n_jobs) end = time.time() duration = io.proc_time(start, end) if target_col == "mem_bin": score = np.mean(results) else: score = np.sqrt(np.abs(np.mean(results))) print(f"\nKFOLD scores: {results}\n") print(f"\nMean Score: {score}\n") print("\nProcess took ", duration) kfold_dict = { "kfold": { "results": list(results), "score": score, "time": duration } } keys = io.save_to_pickle(kfold_dict, target_col=target_col) io.s3_upload(keys, bucket_mod, f"{data_path}/results")
def initialize_network(self, network_function): """ Initialize KerasRegressor object that makes Keras model compatible with scikit-learn library :param network_function: any function that returns a compiled Keras model, taking hyper parameters as input :return: """ self._model = KerasRegressor(build_fn=network_function) self._is_model_initialized = True return
def best_model(self): model = KerasRegressor(build_fn=self.DNN, verbose=1) if self.search_method == 'grid': search = GridSearchCV(model, self.hyper, cv=5) best_search = search.fit(self.data, self.label, verbose=2) best_param = search.best_params_ return best_search, best_param if self.search_method == 'random': search = RandomizedSearchCV(model, self.hyper, cv=5) best_search = search.fit(self.data, self.label, verbose=2) best_param = search.best_params_ return best_search, best_param
def best_model_pca8(data, label, search_method): model = KerasRegressor(build_fn=DNN_pca8, verbose=1) if search_method == 'grid': search = GridSearchCV(model, hyper, cv=5) best_search = search.fit(data, label, verbose=2) best_param = search.best_params_ return best_search, best_param if search_method == 'random': search = RandomizedSearchCV(model, hyper, cv=5) best_search = search.fit(data, label, verbose=2) best_param = search.best_params_ return best_search, best_param
def train_model_cnn(epochs, batch, train_data, val_data, train_target, val_target): """train KerasRegressor model to predict PHI with 2D CNN""" n_dim = train_data.shape np.random.seed(7) estimator = KerasRegressor(build_fn=createModel.model_cnn, dim=n_dim, epochs=epochs, batch_size=batch, verbose=2) cross_validation(estimator, train_data, train_target, val_data, val_target)
def do_grid_search(): batch_size = [1, 10, 32, 64] epochs = [10, 50, 100] model = KerasRegressor(build_fn=design_model) param_grid = dict(batch_size=batch_size, epochs=epochs) grid = GridSearchCV(estimator=model, param_grid=param_grid, scoring=make_scorer(mean_squared_error, greater_is_better=False), return_train_score=True) grid_result = grid.fit(x_train, y_train, verbose=0) print(grid_result) print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
def create_regressor(perceptron_no: int, epoch_no: int = 500): """ Creates and returns regressor based on a MLP with given number of perceptrons and trained given number of times. :param perceptron_no: number of perceptrons :param epoch_no: number of epochs to train ANN MLP :return: KerasRegressor object configured to spec """ nn = KerasRegressor(build_fn=create_nn, perceptron_no=perceptron_no, epochs=epoch_no, batch_size=100, verbose=0) return nn
def nnTrain(self, X, Y): # use neural net for training seed = 7 np.random.seed(seed) estimators = [] estimators.append((RapidNN.SCALER, StandardScaler())) estimators.append((RapidNN.REGRESSER, KerasRegressor(build_fn=self.initNNModel, epochs=30, batch_size=10, verbose=0))) pipeline = Pipeline(estimators) kfold = KFold(n_splits=10, random_state=seed) pipeline.fit(X, Y) # scores = pipeline.evaluate(X, Y) # print("%s: %.2f%%" % (model.metrics_names[1], scores[1] * 100)) return pipeline
def wrap_model(): """ Build and wrap keras-TF model for use with scikit-learn API. ====================================== Input: None Output: wrapped_model (KerasRegressor) - Wrapped model for use with scikit-learn API. """ # Build and wrap model. wrapped_model = KerasRegressor(build_multilayer_perceptron) # Return model return wrapped_model
def DNNRegressor(inputDim): ''' Parameters inputDim: int, input dimension, i.e. # of features Returns model: wrapped DNN model ''' def make_model(layers=[64, 64], optimizer='adam', activation='relu', inputDim=10): ''' Parameters layers: lst, length is the # of hidden layers, element is the # of neurons in each layer optimizer: str, tensorflow optimizer activation: str, tensorflow activation inputDim: int, input dimension, i.e. # of features Returns model: DNN model ''' model = Sequential() for i, neurons in enumerate(layers): if not i: model.add( Dense(neurons, activation=activation, input_dim=inputDim)) else: model.add(Dense(neurons, activation=activation)) model.add(Dense(1)) model.compile(loss='mse', optimizer=optimizer, metrics=['mae']) return model model = KerasRegressor(build_fn=make_model, inputDim=inputDim, verbose=0) return model
def get_opt_params_by_randomized_search_cv(X_train, y_train): # pass in fixed parameters n_input and n_class model_keras = KerasRegressor( build_fn = build_CNN_base, epochs=150, batch_size=12, #callbacks = callbacks, verbose=0 ) # parameter ranges to use in randomized search n_filters_opts = [1, 2, 4, 8, 32, 64] n_kernel_opts = list(range(2, 12)) l2_penalty_opts = [0.0, 0.01, 0.25, 0.50] keras_param_options = { 'n_filters': n_filters_opts, 'n_kernel': n_kernel_opts, 'l2_penalty': l2_penalty_opts } # Create a RandomizedSearchCV instance, and then fit. rs_keras = RandomizedSearchCV( model_keras, param_distributions = keras_param_options, scoring = 'neg_mean_absolute_error', n_iter = 10, cv = 5, n_jobs = -1, verbose = 1 ) rs_keras.fit(X_train, y_train) print('Best score obtained: {0}'.format(rs_keras.best_score_)) print('Parameters:') for param, value in rs_keras.best_params_.items(): print('\t{}: {}'.format(param, value)) return rs_keras.best_params_
def run_experiment(writer, name, generate_data): np.random.seed(SEED) data = DataHolder(generate_data(TRAIN_SIZE), generate_data(TEST_SIZE)) if DUMP_FILES: data.dump(name) # Define model types to use models = [ svr_grid(), RandomForestRegressor(n_estimators=100), GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=10, random_state=0, verbose=VERBOSE), KerasRegressor(build_fn=neural_network_regression, data=data) ] for model in models: eval_data(writer, name, model, data)
def make_regressor_pipeline(X: pd.DataFrame) -> Pipeline: """ Make the regressor pipeline with the required preprocessor steps and estimator in the end. Parameters ---------- X: pd.DataFrame X containing all the required features for training Returns ------- regressor_pipeline: Pipeline Regressor pipeline with preprocessor and estimator """ numerics = ["int16", "int32", "int64", "float16", "float32", "float64"] num_features = list( X.dropna(axis=1, how="all").select_dtypes(include=numerics).columns) # This example model only uses numeric features and drops the rest num_transformer = Pipeline(steps=[("imputer", SimpleImputer( strategy="mean")), ("standardize", StandardScaler())]) preprocessor = ColumnTransformer(transformers=[("num", num_transformer, num_features)]) # create model estimator = KerasRegressor( build_fn=create_regression_model, num_features=len(num_features), epochs=200, batch_size=8, verbose=1, ) # pipeline with preprocessor and estimator bundled regressor_pipeline = Pipeline( steps=[("preprocessor", preprocessor), ("estimator", estimator)]) return regressor_pipeline
def train_net(X, Y, dil, drop, poolsize, kernel, ep, ba, k, validate, window_size, stride, freq_factor, files): cur_model = partial(depthwise_model, shape_X=X.shape, shape_Y=Y.shape, drp=drop, krnl=kernel, dilate=dil, mpool=poolsize) model = cur_model() if not validate: data_path = r'C:\Users\hbkm9\Documents\Projects\CYB\Balint\CYB104\Data' X0, Y0, _ = data_proc(data_path, norm_emg, window_size=window_size, task='Validation', stride=stride, freq_factor=freq_factor) #Y0 = normalize(np.array(Y0), axis=1) #Y0 = np.expand_dims(Y0[:, 2], 1) X0 = np.expand_dims(X0, 1) mc = ModelCheckpoint('../Models/best_model.h5', monitor='val_loss', mode='min', verbose=1, save_best_only=True) es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=8) history = model.fit(X, Y, batch_size=ba, epochs=ep, verbose=1, callbacks=[es, mc], validation_data=(X0, Y0)) dir_path, ends = incr_dir(r'/Models', 'model_') model.save(dir_path+'\\model_' + str(max(ends) + 1) + '.h5') import pickle with open(dir_path+'\\history_' + str(max(ends) + 1) + r'.pickle', 'wb') as handle: pickle.dump(history.history, handle, protocol=pickle.HIGHEST_PROTOCOL) file_names = "\n".join(files) str_sum = model_summary_to_string(model) + '\n' str_sum += kw_summary(dil=dil, drop=drop, poolsize=poolsize, kernel=kernel, epochs=ep, batch=ba, window_size=window_size, stride=stride) str_sum += '\n\n' + file_names print_to_file(str_sum, dir_path + '\\summary_'+ str(max(ends) + 1) + r'.txt') return estimator = KerasRegressor(build_fn=cur_model, epochs=ep, batch_size=ba, verbose=2) kfold = KFold(n_splits=k) scores = cross_val_score(estimator, X, Y, cv=kfold, scoring='neg_mean_squared_error', n_jobs=3) return scores, model
def deep_mlp_model(build_fn, param_dict): return KerasRegressor(build_fn=build_fn, batch_size=param_dict.get(BATCH_SIZE), epochs=param_dict.get(EPOCHS), verbose=False)
Dense(input_layer_neurons, activation='relu', input_shape=(input_layer_neurons, ))) if (second_layer_boolean): model.add(Dense(neurons_on_first_layer / 2, activation='relu')) model.add(Dense(neurons_on_second_layer, activation='relu')) model.add(Dense(neurons_on_chokehold_layer, activation='relu')) if (second_layer_boolean): model.add(Dense(neurons_on_first_layer / 2, activation='relu')) model.add(Dense(neurons_on_first_layer, activation='relu')) model.add(Dense(input_layer_neurons, activation=None)) model.compile(loss='mean_squared_error', optimizer='adam', metrics=metrics) return model model = KerasRegressor(build_fn=create_model, verbose=2) input_layer_neurons = [X_train.shape[1]] batch_size = [500000] #, 10000] epochs = [200] learn_rate = [0.0001] #, 0.001] dropout_rate = [0.0] weight_constraint = [0] neurons_on_first_layer = [32] #, 64] neurons_on_chokehold_layer = [4] #, 8] second_layer_boolean = [False] #, True] # Is there another layer? param_grid = dict(batch_size=batch_size, epochs=epochs, dropout_rate=dropout_rate, learn_rate=learn_rate, weight_constraint=weight_constraint, input_layer_neurons=input_layer_neurons,
def createModel(self): X = self.df[list(self.predictor_list.get(0, tk.END))].to_numpy() y = self.df[self.target_list.get(0)].to_numpy().reshape(-1) layers = self.no_optimization_choice_var.get() learning_rate = self.hyperparameters[4].get() momentum = self.hyperparameters[5].get() optimizers = { "Adam": Adam(learning_rate=learning_rate), "SGD": SGD(learning_rate=learning_rate, momentum=momentum), "RMSprop": RMSprop(learning_rate=learning_rate, momentum=momentum) } def base_model(): model = Sequential() for i in range(layers): neuron_number = self.neuron_numbers_var[i].get() activation = self.activation_var[i].get() if i == 0: model.add( Dense(neuron_number, activation=activation, input_dim=X.shape[1])) else: model.add(Dense(neuron_number, activation=activation)) model.add(Dense(1, activation="relu")) model.compile(optimizer=optimizers[self.hyperparameters[2].get()], loss=self.hyperparameters[3].get()) return model do_forecast = self.do_forecast_option.get() val_option = self.validation_option.get() if val_option == 0 or val_option == 1: model = base_model() elif val_option == 2 or val_option == 3: model = KerasRegressor(build_fn=base_model, epochs=self.hyperparameters[0].get(), batch_size=self.hyperparameters[1].get()) if val_option == 0: model.fit(X, y, epochs=self.hyperparameters[0].get(), batch_size=self.hyperparameters[1].get()) if do_forecast == 0: pred = model.predict(X).reshape(-1) losses = loss(y, pred)[:-1] self.y_test = y self.pred = pred for i, j in enumerate(losses): self.test_metrics_vars[i].set(j) self.model = model elif val_option == 1: X_train, X_test, y_train, y_test = train_test_split( X, y, train_size=self.random_percent_var.get() / 100) model.fit(X_train, y_train, epochs=self.hyperparameters[0].get(), batch_size=self.hyperparameters[1].get()) if do_forecast == 0: pred = model.predict(X_test).reshape(-1) losses = loss(y_test, pred)[:-1] self.y_test = y_test.reshape(-1) self.pred = pred for i, j in enumerate(losses): self.test_metrics_vars[i].set(j) self.model = model elif val_option == 2: cvs = cross_validate(model, X, y, cv=self.cross_val_var.get(), scoring=skloss) for i, j in enumerate(list(cvs.values())[2:]): self.test_metrics_vars[i].set(j.mean()) elif val_option == 3: cvs = cross_validate(model, X, y, cv=X.shape[0] - 1, scoring=skloss) for i, j in enumerate(list(cvs.values())[2:]): self.test_metrics_vars[i].set(j.mean())
input_dim=87)) regressor.add( Dense(units=66, kernel_initializer='normal', activation='relu')) regressor.add( Dense(units=66, kernel_initializer='normal', activation='relu')) regressor.add( Dense(units=66, kernel_initializer='normal', activation='relu')) regressor.add( Dense(units=66, kernel_initializer='normal', activation='relu')) regressor.add( Dense(units=1, kernel_initializer='normal', activation='relu')) regressor.compile(optimizer='sgd', loss='mean_squared_error') return regressor regressor = KerasRegressor(build_fn=build_regressor, batch_size=10, epochs=100) regressor.fit(X_train, y_train) preds = regressor.predict(X_test) rmse = np.sqrt(mean_squared_error(y_test, preds)) rmse #XGBoost import xgboost as xgb data_dmatrix = xgb.DMatrix(data=X, label=y) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123) xg_reg = xgb.XGBRegressor(objective='reg:linear', colsample_bytree=0.3,
# 훈련 loop for train_index, valid_index in kfold.split(x_train1): # print(train_index, len(train_index)) #2777702 # print(valid_index, len(valid_index)) #694426 x_train = x_train1[train_index] x_valid = x_train1[valid_index] y_train = y_train1[train_index] y_valid = y_train1[valid_index] x_train = x_train.reshape(x_train.shape[0], x_train.shape[1], 1) x_valid = x_valid.reshape(x_valid.shape[0], x_valid.shape[1], 1) #2. 모델구성 model2 = KerasRegressor(build_fn=build_model, verbose=1) #, epochs = 2) search = GridSearchCV(model2, hyperparameters, cv=kfold) start_time = timeit.default_timer() #3. 훈련 modelpath = f'./data/hdf5/1_conv1d_kfold_{num}.hdf5' er, mo, lr = callbacks(modelpath) search.fit(x_train, y_train, verbose=1, epochs=200, validation_data=(x_valid, y_valid), callbacks=[er, lr, mo]) finish_time = timeit.default_timer() time = round(finish_time - start_time, 2)
dropout = [0.1, 0.2, 0.3, 0.4] activation = ['relu', 'selu', 'elu', 'swish'] batches = [10, 20, 30, 40, 50] optimizer = ['adam', 'nadam', 'rmseprop', 'adadelta'] return { "node": node, "drop": dropout, "optimizer": optimizer, "batch_size": batches, "activation": activation } parameters = param() model = KerasRegressor(build_fn=dnn_model, verbose=1) search = RandomizedSearchCV(model, parameters, cv=3) # search = GridSearchCV(model, parameters, cv=3) filepath = '../data/modelcheckpoint/k62_iris_{epoch:02d}-{val_loss:.4f}.hdf5' es = EarlyStopping(monitor='val_loss', patience=10, mode='auto') cp = ModelCheckpoint(filepath=filepath, monitor='val_loss', save_best_only=True, mode='auto') lr = ReduceLROnPlateau(monitor='val_loss', patience=3, factor=0.5, mode='auto') search.fit(x_train, y_train, validation_split=0.2, verbose=1,
'activation1': activations, 'activation2': activations, 'activation3': activations, 'a': nodes, 'b': nodes, 'c': nodes } hyperparameters = create_hyperparameters() model2 = build_model from tensorflow.keras.wrappers.scikit_learn import KerasClassifier, KerasRegressor # 여기서 epochs, validation, callback등 넣을수 있다 model2 = KerasRegressor(build_fn=build_model, verbose=1) #,epochs= 3,validation_split = 0.2) search = GridSearchCV(model2, hyperparameters, cv=3) lr = ReduceLROnPlateau(monitor='val_loss', patience=25, factor=0.5, verbose=1) modelpath = '../Data/modelCheckPoint/k62_boston_{epoch:02d}-{val_loss:.4f}.hdf5' mc = ModelCheckpoint(filepath=modelpath, monitor='val_loss', save_best_only=True, mode='auto') es = EarlyStopping(monitor='val_loss', patience=50, mode='auto') # epochs, validation, callback등 fit에서도 먹힌다 (fit이 우선순위가 더 높다) search.fit(x_train, y_train, verbose=1,
# hidden layers for hidden_layer_number in range(1, number_of_hidden_layers): model.add(Dense(number_of_neurons, activation='relu')) # output layer model.add(Dense(1)) model.compile(optimizer='adam', loss='mse') return model # In[13]: tuned_model = KerasRegressor(build_fn=build_model) # In[16]: from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split tuned_model = KerasRegressor(build_fn=build_model) # possible values of parameters - we want to find the best set of them params = { 'number_of_hidden_layers': [2, 3, 4, 5], 'number_of_neurons': [5, 15, 25] }
model.add(Dense(3500, input_dim=X_train.shape[1], activation='relu')) model.add(Dense(3500, activation='relu')) model.add(Dense(3500, activation='relu')) model.add(Dense(3500, activation='relu')) model.add(Dense(3500, activation='relu')) model.add(Dense(3500, activation='relu')) model.add(Dense(3500, activation='relu')) model.add(Dense(len(y_train[0]), activation='linear')) # compile the keras model model.compile(loss='mse', optimizer='adam') return model estimator = KerasRegressor(build_fn=baseline_model, nb_epoch=20, batch_size=1000, verbose=1) # fit the keras model on the dataset estimator.fit(X_train, y_train, epochs=20, batch_size=1000, verbose=1) # make class predictions with the model\ predictions = estimator.predict(X_test) top_20_count = 0 correct_count = 0 pred_list = np.zeros((len(predictions), 2)) for i in range(len(predictions)): pred_list[i][0] = i pred_list_temp = np.zeros((len(y_test), 2))