我们从Python开源项目中，提取了以下29个代码示例，用于说明如何使用hyperopt.STATUS_OK。
def score_train_test_split(self, parameters): logger.info("Evaluating with test size %s with parameters %s", self.task.test_size, parameters) logger.info("Training model ...") self.model.set_params(**parameters) self.model.fit(self.task.X_train, self.task.y_train) logger.info("Training model done !") y_pred = self.get_prediction(self.model, self.task.X_test) score = self.scorer.scoring_function(self.task.y_test, y_pred) logger.info("Score = %s", score) result = OptimizationResult( task=self.task.name, model=str(self.model), parameters=parameters, score=score, scorer_name=self.scorer.name, validation_method=self.task.validation_method, predictions=y_pred.tolist(), random_state=self.task.random_state) self.opt_logger.save(result) return {'loss': score, 'status': STATUS_OK}
def objective(space): estimator = XGBClassifier( n_estimators=n_estimators, max_depth=int(space['max_depth']), min_child_weight=int(space['min_child_weight']), gamma=space['gamma'], subsample=space['subsample'], colsample_bytree=space['colsample_bytree'] ) estimator.fit( x_train, y_train, eval_set=[(x_train, y_train), (x_val, y_val)], early_stopping_rounds=30, verbose=False, eval_metric='error' ) score = accuracy_score(y_val, estimator.predict(x_val)) return {'loss': 1 - score, 'status': STATUS_OK}
def model(X_train, X_test, Y_train, Y_test): model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([400, 512, 600])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) nb_epoch = 10 batch_size = 128 model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def model(X_train, Y_train, X_test, Y_test): model = Sequential() model.add(Dense(50, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([20, 30, 40])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) model.fit(X_train, Y_train, batch_size={{choice([64, 128])}}, nb_epoch=1, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def ensemble_model(X_train, X_test, Y_train, Y_test): model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([400, 512, 600])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) nb_epoch = 10 batch_size = 128 model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def model(X_train, Y_train, X_test, Y_test): model = Sequential() model.add(Dense({{choice([15, 512, 1024])}},input_dim=8,init='uniform', activation='softplus')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([256, 512, 1024])}})) model.add(Activation({{choice(['relu', 'sigmoid','softplus'])}})) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(1, init='uniform', activation='sigmoid')) model.compile(loss='mse', metrics=['accuracy'], optimizer={{choice(['rmsprop', 'adam', 'sgd'])}}) model.fit(X_train, Y_train, batch_size={{choice([10, 50, 100])}}, nb_epoch={{choice([1, 50])}}, show_accuracy=True, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def hyperopt_search(args, data, model, param_grid, max_evals): def objective(param_grid): args.num_hidden = param_grid['num_hidden'] args.dropout_output = param_grid['dropout_output'] args.dropout_input = param_grid['dropout_input'] args.clip_norm = param_grid['clip_norm'] args.batch_size = param_grid['batch_size'] # args.learning_rate = param_grid['learning_rate'] print(args) print() scores = run_network(args, data, model, tuning=args.tune) test_score, eval_score = scores tf.reset_default_graph() eval_score = -eval_score[0] return {'loss': eval_score, 'params': args, 'status': STATUS_OK} trials = Trials() results = fmin( objective, param_grid, algo=tpe.suggest, trials=trials, max_evals=max_evals) return results, trials.results
def score(self, params): print "Training with params : " print params N_boost_round=[] Score=[] skf = cross_validation.StratifiedKFold(self.train_y, n_folds=6, shuffle=True, random_state=25) for train, test in skf: X_Train, X_Test, y_Train, y_Test = self.train_X[train], self.train_X[test], self.train_y[train], self.train_y[test] dtrain = xgb.DMatrix(X_Train, label=y_Train) dvalid = xgb.DMatrix(X_Test, label=y_Test) watchlist = [(dtrain, 'train'),(dvalid, 'eval')] model = xgb.train(params, dtrain, num_boost_round=150, evals=watchlist, early_stopping_rounds=10) predictions = model.predict(dvalid) N = model.best_iteration N_boost_round.append(N) score = model.best_score Score.append(score) Average_best_num_boost_round = np.average(N_boost_round) Average_best_score = np.average(Score) print "\tAverage of best iteration {0}\n".format(Average_best_num_boost_round) print "\tScore {0}\n\n".format(Average_best_score) return {'loss': Average_best_score, 'status': STATUS_OK, 'Average_best_num_boost_round': Average_best_num_boost_round}
def train_and_cv_error(self, features, hyper_params): self.train_for_cv(features, hyper_params) target = self.train_and_cv[self.target] prediction = self.train_and_cv['cv_prediction'] if prediction.isnull().any(): Exception('Some predictions where N/A.') self._truncate_predictions(self.train_and_cv, 'cv_prediction') loss = self.eval_metric.error(target, prediction) loss_variance = self.bootstrap_errors_(target, prediction).var() if loss is None or np.isnan(loss) or loss_variance is None or np.isnan(loss_variance): raise Exception('Could not calculate cv error.') return { 'status': STATUS_OK, 'loss': loss, 'loss_variance': loss_variance }
def score_cv(self, parameters): logger.info("Evaluating using %s-fold CV with parameters %s", self.task.kfold.n_folds, parameters) self.model.set_params(**parameters) scores = [] fold_predictions = [] for i, (train_index, test_index) in enumerate(self.task.kfold): logger.info("Starting fold %s ...", i) X_train, X_test = self.task.X[train_index], self.task.X[test_index] y_train, y_test = self.task.y[train_index], self.task.y[test_index] self.model.fit(X_train, y_train) logger.info("Training for fold %s done !", i) y_pred = self.get_prediction(self.model, X_test) fold_predictions.append(y_pred.tolist()) score = self.scorer.scoring_function(y_test, y_pred) logger.info("Score %s", score) scores.append(score) logger.info("Cross validation done !") mean_score = np.mean(scores) logger.info("Mean Score = %s", mean_score) result = OptimizationResult( model=str(self.model), parameters=parameters, score=mean_score, scorer_name=self.scorer.name, validation_method=self.task.validation_method, predictions=fold_predictions, random_state=self.task.random_state) self.opt_logger.save(result) return {'loss': mean_score, 'status': STATUS_OK}
def my_model(X_train, y_train, X_test, y_test): ############ model params ################ line_length = 248 # seq size train_char = 58 hidden_neurons = 512 # hidden neurons batch = 64 # batch_size no_epochs = 3 ################### Model ################ ######### begin model ######## model = Sequential() # layer 1 model.add(LSTM(hidden_neurons, return_sequences=True, input_shape=(line_length, train_char))) model.add(Dropout({{choice([0.4, 0.5, 0.6, 0.7, 0.8])}})) # layer 2 model.add(LSTM(hidden_neurons, return_sequences=True)) model.add(Dropout({{choice([0.4, 0.5, 0.6, 0.7, 0.8])}})) # layer 3 model.add(LSTM(hidden_neurons, return_sequences=True)) model.add(Dropout({{choice([0.4, 0.5, 0.6, 0.7, 0.8])}})) # fc layer model.add(TimeDistributed(Dense(train_char, activation='softmax'))) model.load_weights("weights/model_maha1_noep50_batch64_seq_248.hdf5") ######################################################################## checkpoint = ModelCheckpoint("weights/hypmodel2_maha1_noep{0}_batch{1}_seq_{2}.hdf5".format( no_epochs, batch, line_length), monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=False, mode='min') initlr = 0.00114 adagrad = Adagrad(lr=initlr, epsilon=1e-08, clipvalue={{choice([0, 1, 2, 3, 4, 5, 6, 7])}}) model.compile(optimizer=adagrad, loss='categorical_crossentropy', metrics=['accuracy']) history = History() # fit model model.fit(X_train, y_train, batch_size=batch, nb_epoch=no_epochs, validation_split=0.2, callbacks=[history, checkpoint]) score, acc = model.evaluate(X_test, y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def model(X_train, Y_train, X_test, Y_test): ''' Model providing function: Create Keras model with double curly brackets dropped-in as needed. Return value has to be a valid python dictionary with two customary keys: - loss: Specify a numeric evaluation metric to be minimized - status: Just use STATUS_OK and see hyperopt documentation if not feasible The last one is optional, though recommended, namely: - model: specify the model just created so that we can later use it again. ''' model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([256, 512, 1024])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(10)) model.add(Activation('softmax')) rms = RMSprop() model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy']) model.fit(X_train, Y_train, batch_size={{choice([64, 128])}}, nb_epoch=1, verbose=2, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def model(X_train, X_test, y_train, y_test, max_features, maxlen): model = Sequential() model.add(Embedding(max_features, 128, input_length=maxlen)) model.add(LSTM(128)) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) early_stopping = EarlyStopping(monitor='val_loss', patience=4) checkpointer = ModelCheckpoint(filepath='keras_weights.hdf5', verbose=1, save_best_only=True) model.fit(X_train, y_train, batch_size={{choice([32, 64, 128])}}, nb_epoch=1, validation_split=0.08, callbacks=[early_stopping, checkpointer]) score, acc = model.evaluate(X_test, y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def model(X_train, X_test, y_train, y_test, maxlen, max_features): embedding_size = 300 pool_length = 4 lstm_output_size = 100 batch_size = 200 nb_epoch = 1 model = Sequential() model.add(Embedding(max_features, embedding_size, input_length=maxlen)) model.add(Dropout({{uniform(0, 1)}})) # Note that we use unnamed parameters here, which is bad style, but is used here # to demonstrate that it works. Always prefer named parameters. model.add(Convolution1D({{choice([64, 128])}}, {{choice([6, 8])}}, border_mode='valid', activation='relu', subsample_length=1)) model.add(MaxPooling1D(pool_length=pool_length)) model.add(LSTM(lstm_output_size)) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) print('Train...') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_data=(X_test, y_test)) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size) print('Test score:', score) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def score(params): logging.info("Training with params: ") logging.info(params) # Delete 'n_estimators' because it's only a constructor param # when you're using XGB's sklearn API. # Instead, we have to save 'n_estimators' (# of boosting rounds) # to xgb.cv(). num_boost_round = int(params['n_estimators']) del params['n_estimators'] dtrain = xgb.DMatrix(X_train, label=y_train) # As of version 0.6, XGBoost returns a dataframe of the following form: # boosting iter | mean_test_err | mean_test_std | mean_train_err | mean_train_std # boost iter 1 mean_test_iter1 | mean_test_std1 | ... | ... # boost iter 2 mean_test_iter2 | mean_test_std2 | ... | ... # ... # boost iter n_estimators score_history = xgb.cv(params, dtrain, num_boost_round, nfold=5, stratified=True, early_stopping_rounds=250, verbose_eval=500) # Only use scores from the final boosting round since that's the one # that performed the best. mean_final_round = score_history.tail(1).iloc[0, 0] std_final_round = score_history.tail(1).iloc[0, 1] logging.info("\tMean Score: {0}\n".format(mean_final_round)) logging.info("\tStd Dev: {0}\n\n".format(std_final_round)) # score() needs to return the loss (1 - score) # since optimize() should be finding the minimum, and AUC # naturally finds the maximum. loss = 1 - mean_final_round return {'loss': loss, 'status': STATUS_OK}
def score(self, params): self.change_to_int(params, self.to_int_params) self.level0.set_params(**params) score = model_selection.cross_val_score(self.level0, self.trainX, self.trainY, cv=5, n_jobs=-1) print('%s ------ Score Mean:%f, Std:%f' % (params, score.mean(), score.std())) return {'loss': score.mean(), 'status': STATUS_OK}
def model(params): max_len = 5 n_songs = 7 classifier = DeepRNN(*params, max_len, n_songs) acc = classifier.train(X_train, Y_train, X_val, Y_val, SNR) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def myFunc(params): print '########################' global run_counter print '{} run out of {}'.format(run_counter+1, max_num_runs) start_time = time.time() print params acc= hyperopt_train_test(params) print '\nend time: {}'.format(time.time() - start_time) run_counter += 1 return {'loss': acc, 'status':STATUS_OK } #!# uniform fp length? Should be integer...
def xgb2(train2, y, test2, v, z): cname = sys._getframe().f_code.co_name N_splits = 9 N_seeds = 4 from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval dtrain = xgb.DMatrix(train2, y) def step_xgb(params): cv = xgb.cv(params=params, dtrain=dtrain, num_boost_round=10000, early_stopping_rounds=100, nfold=10, seed=params['seed']) score = cv.ix[len(cv)-1, 0] print(cname, score, len(cv), params) return dict(loss=score, status=STATUS_OK) space_xgb = dict( max_depth = hp.choice('max_depth', range(2, 8)), subsample = hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree = hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate = hp.quniform('learning_rate', 0.005, 0.03, 0.005), min_child_weight = hp.quniform('min_child_weight', 1, 6, 1), gamma = hp.quniform('gamma', 0.5, 10, 0.05), objective = 'binary:logistic', eval_metric = 'logloss', seed = 1, silent = 1 ) trs = load_state(cname + '_trials') if trs == None: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:'%(len(tr.trials)), space_eval(space_xgb, tr.argmin)) for n in range(5): best = fmin(step_xgb, space_xgb, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials = tr) save_state(cname + '_trials', (tr, space_xgb)) xgb_params = space_eval(space_xgb, best) print(xgb_params) xgb_common(train2, y, test2, v, z, N_seeds, N_splits, cname, xgb_params)
def xgb2(train2, y, test2, v, z): cname = sys._getframe().f_code.co_name N_splits = 9 N_seeds = 4 from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval dtrain = xgb.DMatrix(train2, y) def step_xgb(params): cv = xgb.cv(params=params, dtrain=dtrain, num_boost_round=10000, early_stopping_rounds=100, nfold=10, seed=params['seed']) score = cv.ix[len(cv)-1, 0] print(cname, score, len(cv), params) return dict(loss=score, status=STATUS_OK) space_xgb = dict( max_depth = hp.choice('max_depth', range(2, 8)), subsample = hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree = hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate = hp.quniform('learning_rate', 0.005, 0.03, 0.005), min_child_weight = hp.quniform('min_child_weight', 1, 6, 1), gamma = hp.quniform('gamma', 0.5, 10, 0.05), objective = 'binary:logistic', eval_metric = 'logloss', seed = 1, silent = 1 ) trs = load_state(cname + '_trials') if trs == None: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:'%(len(tr.trials)), space_eval(space_xgb, tr.argmin)) for n in range(15): best = fmin(step_xgb, space_xgb, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials = tr) save_state(cname + '_trials', (tr, space_xgb)) xgb_params = space_eval(space_xgb, best) print(xgb_params) xgb_common(train2, y, test2, v, z, N_seeds, N_splits, cname, xgb_params)
def xgb2(train2, y, test2, v, z): cname = sys._getframe().f_code.co_name N_splits = 9 N_seeds = 4 from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval dtrain = xgb.DMatrix(train2, y) def step_xgb(params): cv = xgb.cv(params=params, dtrain=dtrain, num_boost_round=10000, early_stopping_rounds=100, nfold=10, seed=params['seed']) score = cv.ix[len(cv)-1, 0] print(cname, score, len(cv), params) return dict(loss=score, status=STATUS_OK) space_xgb = dict( max_depth = hp.choice('max_depth', range(2, 8)), subsample = hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree = hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate = hp.quniform('learning_rate', 0.005, 0.03, 0.005), min_child_weight = hp.quniform('min_child_weight', 1, 6, 1), gamma = hp.quniform('gamma', 0.5, 10, 0.05), objective = 'binary:logistic', eval_metric = 'logloss', seed = 1, silent = 1 ) trs = load_state(cname + '_trials') if trs == None: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:'%(len(tr.trials)), space_eval(space_xgb, tr.argmin)) for n in range(25): best = fmin(step_xgb, space_xgb, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials = tr) save_state(cname + '_trials', (tr, space_xgb)) xgb_params = space_eval(space_xgb, best) print(xgb_params) xgb_common(train2, y, test2, v, z, N_seeds, N_splits, cname, xgb_params)
def score(self, params): outputs = self.calculate_loss(params) Writer.append_line_list(self.fpath, [params[c] for c in self.columns] + [outputs[c] for c in self.output_items]) return {'loss': outputs["loss"], 'status': STATUS_OK}
def model(datagen, X_train, Y_train, X_test, Y_test): batch_size = 32 nb_epoch = 200 # input image dimensions img_rows, img_cols = 32, 32 # the CIFAR10 images are RGB img_channels = 3 model = Sequential() model.add(Convolution2D(32, 3, 3, border_mode='same', input_shape=X_train.shape[1:])) model.add(Activation('relu')) model.add(Convolution2D(32, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout({{uniform(0, 1)}})) model.add(Convolution2D(64, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout({{uniform(0, 1)}})) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) # let's train the model using SGD + momentum (how original). sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) # fit the model on the batches generated by datagen.flow() model.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_size), samples_per_epoch=X_train.shape[0], nb_epoch=nb_epoch, validation_data=(X_test, Y_test)) score, acc = model.evaluate(X_test, Y_test, verbose=0) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def model(x_train, y_train, x_test, y_test): """ Model providing function: Create Keras model with double curly brackets dropped-in as needed. Return value has to be a valid python dictionary with two customary keys: - loss: Specify a numeric evaluation metric to be minimized - status: Just use STATUS_OK and see hyperopt documentation if not feasible The last one is optional, though recommended, namely: - model: specify the model just created so that we can later use it again. """ model = Sequential() model.add(Dense(512, input_shape=(784,))) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 1)}})) model.add(Dense({{choice([256, 512, 1024])}})) model.add(Activation({{choice(['relu', 'sigmoid'])}})) model.add(Dropout({{uniform(0, 1)}})) # If we choose 'four', add an additional fourth layer if conditional({{choice(['three', 'four'])}}) == 'four': model.add(Dense(100)) # We can also choose between complete sets of layers model.add({{choice([Dropout(0.5), Activation('linear')])}}) model.add(Activation('relu')) model.add(Dense(10)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer={{choice(['rmsprop', 'adam', 'sgd'])}}) model.fit(x_train, y_train, batch_size={{choice([64, 128])}}, epochs=1, verbose=2, validation_data=(x_test, y_test)) score, acc = model.evaluate(x_test, y_test, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def xgb3(train2, y, test2, v, z): cname = sys._getframe().f_code.co_name N_splits = 9 N_seeds = 4 from hyperopt import fmin, tpe, hp, STATUS_OK, Trials, space_eval dtrain = xgb.DMatrix(train2, y) def step_xgb(params): cv = xgb.cv(params=params, dtrain=dtrain, num_boost_round=10000, early_stopping_rounds=100, nfold=10, seed=params['seed']) score = cv.ix[len(cv)-1, 0] print(cname, score, len(cv), params) return dict(loss=score, status=STATUS_OK) space_xgb = dict( max_depth = hp.choice('max_depth', range(2, 8)), subsample = hp.quniform('subsample', 0.6, 1, 0.05), colsample_bytree = hp.quniform('colsample_bytree', 0.6, 1, 0.05), learning_rate = hp.quniform('learning_rate', 0.005, 0.03, 0.005), min_child_weight = hp.quniform('min_child_weight', 1, 6, 1), gamma = hp.quniform('gamma', 0, 10, 0.05), alpha = hp.quniform('alpha', 0.0, 1, 0.0001), objective = 'binary:logistic', eval_metric = 'logloss', seed = 1, silent = 1 ) trs = load_state(cname + '_trials') if trs == None: tr = Trials() else: tr, _ = trs if len(tr.trials) > 0: print('reusing %d trials, best was:'%(len(tr.trials)), space_eval(space_xgb, tr.argmin)) for n in range(25): best = fmin(step_xgb, space_xgb, algo=tpe.suggest, max_evals=len(tr.trials) + 1, trials = tr) save_state(cname + '_trials', (tr, space_xgb)) xgb_params = space_eval(space_xgb, best) print(xgb_params) xgb_common(train2, y, test2, v, z, N_seeds, N_splits, cname, xgb_params)
