def generate_optimal_pipeline(features, outcomes, output_dir, memory=None): """ Generate a training set and test set from data Parameters: - features: The feature set to train on. In scikit-learn this is often refered to as X. - outcomes: The labeled outcomes we are trying to predict. In scikit-learn this often refered to as y. - output_dir: The directory that TPOT can write to. This will be where the cache and intermitent save are written. Output: The TPOT object returned by fitting TPOTRegressor https://epistasislab.github.io/tpot/api/ """ if (features.shape[0] * features.shape[1] > (50000 * 250)): config_dict = 'TPOT light' else: config_dict = None pipeline_optimizer = TPOTRegressor( generations=GENERATIONS, population_size=POPULATION_SIZE, verbosity=get_verbosity('tpot'), random_state=RANDOM_STATE, template='Selector-Transformer-Regressor', n_jobs=N_JOBS, warm_start=True, memory=memory, config_dict=config_dict, periodic_checkpoint_folder='{DIR}/tpot-intermediate-save/'.format( DIR=output_dir)) pipeline_optimizer.fit(features, outcomes) return pipeline_optimizer
def train_tpot(l=None): # can also do directly from the command line if l is None: l = get_data() model = TPOTRegressor( config_dict=None, crossover_rate=0.1, cv=5, disable_update_check=False, early_stop=None, generations=100, max_eval_time_mins=5, max_time_mins=None, memory=_tpot_cache, mutation_rate=0.9, n_jobs=-1, offspring_size=None, periodic_checkpoint_folder='tpot_periodic_checkpoint', population_size=100, random_state=None, scoring=None, subsample=1.0, use_dask=False, verbosity=1, warm_start=False) model.fit(l.X_train.copy(), l.y_train.copy()) # to be safe: model.export('tpot_exported_pipeline.py') return attributedict_from_locals('model')
def run_example(self): train = pd.read_csv("./data/churn-train.csv") #dummy_train = pd.get_dummies(train[categorical_cols]) categorical_feature_mask = train.dtypes == object categorical_cols = train.columns[categorical_feature_mask].tolist() le = LabelEncoder() #le.fit(train[categorical_cols]) #le.transform(train[categorical_cols]) train[categorical_cols] = train[categorical_cols].apply( lambda col: le.fit_transform(col)) # numpy X_train = train.drop(columns=['churn_probability']).to_numpy() y_train = train["churn_probability"].to_numpy() test = pd.read_csv("./data/churn-test.csv") #dummy_new = pd.get_dummies(test[categorical_cols]) test[categorical_cols] = test[categorical_cols].apply( lambda col: le.fit_transform(col)) X_test = test.drop(columns=['churn_probability']).to_numpy() y_test = test["churn_probability"].to_numpy() tpot = TPOTRegressor(generations=5, population_size=50, verbosity=2, random_state=42, scoring='neg_mean_absolute_error', cv=5) tpot.fit(X_train, y_train) print(tpot.score(X_test, y_test)) tpot.export('tpot_iris_pipeline.py') return tpot.score(X_test, y_test)
def train_tpot(name, X, y, gen, cores): test_name = str('gen_' + str(gen) + name + '_' + time.strftime('%y%m%d')) print('Training with TPOT .... ', test_name) t1 = time.time() X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.75, test_size=0.25) tpot = TPOTRegressor(generations=gen, population_size=50, verbosity=2, n_jobs=cores) tpot.fit(X_train, y_train.reshape(-1, )) print(tpot.score(X_test, y_test)) t2 = time.time() delta_time = t2 - t1 print('Time to train...:', delta_time) print('Saving the model ...') tpot.export('trained_models/' + test_name + '.py') joblib.dump(tpot.fitted_pipeline_, 'trained_models/' + test_name + '.pk1') print(test_name, ' saved ... ')
def works(): config_dict = { 'sklearn.gaussian_process.GaussianProcessRegressor': { 'alpha': [1e1, 1, 1e-1] } } model = TPOTRegressor(config_dict=config_dict, crossover_rate=0.1, cv=5, disable_update_check=False, early_stop=None, generations=10, max_eval_time_mins=5, max_time_mins=None, mutation_rate=0.9, n_jobs=-1, offspring_size=None, population_size=100, random_state=None, scoring=None, subsample=1.0, use_dask=False, verbosity=3, warm_start=False) model.fit(X, y)
def tpot_test(conf): from tpot import TPOTRegressor from sklearn.model_selection import train_test_split from sklearn.model_selection import TimeSeriesSplit p.load_config(conf) ds = dl.load_price_data() ds = add_features(ds) X = ds[p.feature_list][:-1] y = ds['DR'].shift(-1)[:-1] # Split Train and Test X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, test_size=0.2) tpot = TPOTRegressor(n_jobs=-1, verbosity=2, max_time_mins=60, cv=TimeSeriesSplit(n_splits=3)) tpot.fit(X_train, y_train) print(tpot.score(X_test, y_test)) tpot.export('./tpot_out.py')
def fails(): config_dict = { 'example_tpot.MyGP': { 'alpha': [1e1, 1, 1e-1], # 'mu_x': np.logspace(-2, 4, 10), # 'mu_y': np.logspace(-2, 4, 10), } } model = TPOTRegressor(config_dict=config_dict, crossover_rate=0.1, cv=5, disable_update_check=False, early_stop=None, generations=10, max_eval_time_mins=5, max_time_mins=None, mutation_rate=0.9, n_jobs=-1, offspring_size=None, population_size=100, random_state=None, scoring=None, subsample=1.0, use_dask=False, verbosity=3, warm_start=False) model.fit(X, y)
def tpot(use_dask=True): # TODO: Add some documentation... # TODO: Investigate why tpot crashes when uing Dask (probably a RAM problem). if use_dask: client = Client("tcp://192.168.1.94:8786") print(client) tpot_reg = TPOTRegressor(generations=TPOT_GENERATIONS, population_size=TPOT_POPULATION_SIZE, random_state=SEED, cv=CV, use_dask=use_dask, verbosity=2, memory="auto") df = pd.read_csv("elo/data/augmented_train.csv") print(df.sample(5)) # TODO: Find a better way to impute inf and missing values. df = df.replace([np.inf, -np.inf], np.nan) df = df.fillna(df.median()) X = df.drop(FEATS_EXCLUDED, axis=1, errors='ignore').values y = df.loc[:, "target"].values if use_dask: with ProgressBar() as pbar, Profiler() as prof: tpot_reg.fit(X, y) else: tpot_reg.fit(X, y) export_path = str( Path('elo/data/tpot_few_generations_augmented_dataset.py').absolute()) tpot_reg.export(export_path) return tpot_reg
def train_and_pickle_best_model(target, X, y, val_X, val_y): print('AutoML Search for good model for {}'.format(target)) pipeline_optimizer = TPOTRegressor( generations=10, population_size=150, cv=3, random_state=0xDEADBEEF, verbosity=3, scoring='r2', n_jobs=-1, early_stop=5, periodic_checkpoint_folder='tpot_checkpoint') pipeline_optimizer.fit(X, y) new_preds = pipeline_optimizer.predict(val_X) mae = mean_absolute_error(val_y, new_preds) rmse = sqrt(mean_squared_error(val_y, new_preds)) r2 = r2_score(val_y, new_preds) print("TPOT mae:", mae) print("TPOT rmse:", rmse) print("TPOT R^2 score:", r2) pipeline_optimizer.export( 'models/tpot_exported_pipeline_{}.py'.format(target)) dump(pipeline_optimizer.fitted_pipeline_, 'models/{}-best-model-automl.joblib'.format(target)) return r2, mae, rmse
def tpotregressor(self, i): print("TPOTRegressor") tpot = TPOTRegressor(generations=50, population_size=50, verbosity=2, random_state=42) tpot.fit(self.X, self.y) #print(tpot.score(X, y_test2)) tpot.export('tpot_covid_pipeline_day_' + str(i) + '.py') print("\n") return None
def auto_ml(X_train, X_test, y_train, y_test): tpot = TPOTRegressor(generations=30, population_size=200, verbosity=2, periodic_checkpoint_folder="tpot_checkpoint/") tpot.fit(X_train, y_train) print(tpot.score(X_test, y_test)) tpot.export('tpot_pipeline.py')
def tpotRegressor(train_data, target_value): regressor = TPOTRegressor() X_train, X_test, y_train, y_test = train_test_split( train_data, train_data[target_value], train_size=0.75, test_size=0.25) regressor.fit(X_train, y_train) score = regressor.score(X_test, y_test) regressor.export('my_pipeline.py') return regressor, score
def tpot_regression(x_calib, y_calib, x_prod, y_prod, results_direct, cv_folds, error_metric, num_jobs, gens, pop, mins, mins_per_pipeline, verbose, early_stop_generations, tpot_config_dict, model_name='tpot_best'): checkpoint_folder = results_direct + 'checkpoint_folder/' if not Path(checkpoint_folder).is_dir(): os.mkdir(checkpoint_folder) ml_model = TPOTRegressor(generations=gens, population_size=pop, scoring=error_metric, max_time_mins=mins, cv=cv_folds, verbosity=verbose, n_jobs=num_jobs, early_stop=early_stop_generations, max_eval_time_mins=mins_per_pipeline, config_dict=tpot_config_dict, periodic_checkpoint_folder=checkpoint_folder) ml_model.fit(x_calib, y_calib) # save entire pipeline ml_model.export(results_direct + model_name + '.py') joblib.dump(ml_model.fitted_pipeline_, results_direct + model_name + '.sav') # for cross valdation errors see the exported model py file # production - results and errors y_prod_predict = ml_model.predict(x_prod) np.save(results_direct + model_name + '_prod_predicted.npy', y_prod_predict) df_prod_errors = pd.DataFrame(index=[ 'Mean Squared Error', 'Median Absolute Error', 'Correlation Coefficient', 'R2' ]) df_prod_errors['TPOT Best'] = [ mean_squared_error(y_prod, y_prod_predict), median_absolute_error(y_prod, y_prod_predict), np.corrcoef(y_prod, y_prod_predict)[0][-1], r2_score(y_prod, y_prod_predict) ] df_prod_errors.to_csv(results_direct + model_name + '_prod_errors.csv')
def build_regressor(data, name): X, y = data config = make_tpot_pmml_config(regressor_config_dict) del config["sklearn.neighbors.KNeighborsRegressor"] regressor = TPOTRegressor(generations = 3, population_size = 3, random_state = 13, config_dict = config, verbosity = 2) regressor.fit(X, y) pipeline = make_pmml_pipeline(regressor.fitted_pipeline_, active_fields = X.columns.values, target_fields = [y.name]) print(repr(pipeline)) store_pkl(pipeline, name) result = DataFrame(regressor.predict(X), columns = [y.name]) store_csv(result, name)
def go_tpot(): from tpot import TPOTRegressor import datetime tpot = TPOTRegressor(generations=5, population_size=20, verbosity=3, scoring='mean_absolute_error') tpot.fit(X_train, y_train) print(tpot.score(X_test, y_test)) tpot.export('../models/tpot_pipeline_' + datetime.datetime.now().strftime('%Y.%m.%d_%H%M%S') + '.py')
def tpotting(): from tpot import TPOTRegressor """deprecated""" for target in range(4): # replace with real targets tpot = TPOTRegressor( verbosity=2, cv=5, random_state=2017, n_jobs=4, periodic_checkpoint_folder='out/out_{}'.format(target)) tpot.fit(tra_df['x_cols'], tra_df[target]) tpot.export('out/tpotted_{}.py'.format(target))
def fit_model0_adsorption_energies(adsorbate): ''' Create and save a modeling pipeline to predict adsortion energies. Arg: adsorbate String indicating which adsorbate you want to fit the model for Saves: pipeline An `sklearn.pipeline.Pipeline` object that is fit to our data and can be used to make predictions on adsorption energies. The pipeline is automatically saved to our GASdb cache location, which is specified as 'gasdb_path' in the `gaspyrc.json` file. ''' model_name = 'model0' print('[%s] Making %s pipeline/regression for %s...' % (datetime.utcnow(), model_name, adsorbate)) # Fit the transformers and models docs = get_adsorption_docs(adsorbate=adsorbate) energies_dft = np.array([doc['energy'] for doc in docs]) inner_fingerprinter = fingerprinters.InnerShellFingerprinter() outer_fingerprinter = fingerprinters.OuterShellFingerprinter() fingerprinter = fingerprinters.StackedFingerprinter( inner_fingerprinter, outer_fingerprinter) scaler = StandardScaler() pca = PCA() preprocessing_pipeline = Pipeline([('fingerprinter', fingerprinter), ('scaler', scaler), ('pca', pca)]) features = preprocessing_pipeline.fit_transform(docs) tpot = TPOTRegressor(generations=2, population_size=32, offspring_size=32, verbosity=2, scoring='neg_median_absolute_error', n_jobs=16) tpot.fit(features, energies_dft) # Make the pipeline steps = [('fingerprinter', fingerprinter), ('scaler', scaler), ('pca', pca)] for step in tpot.fitted_pipeline_.steps: steps.append(step) pipeline = Pipeline(steps) # Save the pipeline file_name = GASDB_LOCATION + '/pipeline_%s_%s.pkl' % (adsorbate, model_name) with open(file_name, 'wb') as file_handle: pickle.dump(pipeline, file_handle)
def regression(): housing = load_boston() X_train, X_test, y_train, y_test = train_test_split(housing.data, housing.target, train_size=0.75, test_size=0.25, random_state=42) tpot = TPOTRegressor(generations=5, population_size=50, verbosity=2, random_state=42) tpot.fit(X_train, y_train) print(tpot.score(X_test, y_test)) tpot.export('tpot_boston_pipeline.py')
def rolling_forecasts(data, target): """ Fits the rolling forecast model :param data: feature Dataframe :param window: lookback window :param horizon: forecast horizon :param target: variable to be forecasted :return: """ model = TPOTRegressor(generations=5, population_size=50, verbosity=2) model.fit(data.values, target) # for i in range(0, ldf.shape[0] - window): # model.fit(ldf.values[i:i + window, :], ldf['target'].values[i:i + window]) return model
def regression(self, timeMax=60): def rmse_scorer(y_true, y_pred): return mean_squared_error(y_true, y_pred, squared=False) my_custom_scorer = make_scorer(rmse_scorer, greater_is_better=False) print(f"Starting regression with {self.modelName}") X_train, X_test, y_train, y_test = self.dataFunction( preprocessed=self.preprocessed, specifics="TPOT", trainSize=self.trainSize, nDataPoints=self.nDataPoints) # Change dict for prediction model config_copy = regressor_config.copy() config_copy.update(self.model) # TPOT automated feature engineering start_time = time.time() tpot = TPOTRegressor(generations=self.generations, population_size=self.popSize, verbosity=2, config_dict=config_copy, max_time_mins=timeMax, max_eval_time_mins=30, cv=4, scoring=my_custom_scorer) tpot.fit(X_train, y_train) total_time = int(divmod(time.time() - start_time, 60)[0]) print(tpot.evaluated_individuals_) print(f"Time: {total_time}") # prediction score predictionScore = int(-tpot.score(X_test, y_test)) print(f"Final MSE prediction score: {predictionScore}") # Export model tpot.export( f'{self.savePath}/time{total_time}_score{predictionScore}_trainSize{self.trainSize}_PIPE.py' ) # Export History with open(f'{self.savePath}/performance_history.pkl', "wb") as handle: pickle.dump(tpot.evaluated_individuals_, handle) # Export pareto front with open(f'{self.savePath}/PARETO.pkl', "wb") as handle: pickle.dump(tpot.pareto_front_fitted_pipelines_, handle)
def model_selection_and_HPO(dataframe, target="job_performance", test_size=0.25, r_seed=123): """ Pass in the dataframe that has gone through feature selection Uses the TPOT regressor module from TPOT to perform MS and HPO. As this modeling uses some element of stochasticity, it may provide different results every time. The longer you run this, the more similar the final models will look like in the end. Finally outputs a .py file with the selected model and its hyperparameters, for which we can import. """ import TPOT from sklearn.model_selection import train_test_split import timeit from tpot import TPOTRegressor from sklearn.metrics import ( confusion_matrix, roc_auc_score, precision_recall_fscore_support, accuracy_score, ) # train test split X_train, X_test, y_train, y_test = train_test_split( dataframe.loc[:, dataframe.columns != target].values, dataframe[target].values.ravel(), test_size=test_size, random_state=r_seed) y_train = y_train.ravel() y_test = y_test.ravel() # model selection and hyperparameter optimization with TPOT Regressor tpot_regressor = TPOTRegressor(generations=20, population_size=50, cv=10, random_state=r_seed, verbosity=2, memory='auto') start_time = timeit.default_timer() tpot_regressor.fit(X_train, y_train) y_pred = tpot_regressor.predict(X_test) end_time = timeit.default_timer() print(f"Total runtime for the Employee dataset: {end_time-start_time}s") print("TPOT Score: {}".format(tpot_regressor.score(X_test, y_test))) tpot_regressor.export('tpot_exported_pipeline.py')
def tpot_fit_pred(X_train, y_train, X_test, id_test, name_dataset, id_name, target_name): tp = TPOTRegressor(verbosity=2) start_time = timer(None) tp.fit(X_train, y_train) tp.export('tpot_pipeline_dont_overfit.py') time = timer(start_time) preds = tp.predict(X_test) time_out = open(name_dataset + '_' + 'tpot', "w") time_out.write(time) time_out.close() submission = pd.DataFrame({id_name: id_test, target_name: preds}) submission.to_csv('submission_' + name_dataset + '_' + 'tpot.csv', index=False)
def fit_single_output(row): tpot = TPOTRegressor(generations=generations, population_size=population_size, verbosity=2, n_jobs=1, config_dict='TPOT light') fit_model = tpot.fit(X, row).fitted_pipeline_ print(tpot.score(X, row)) return fit_model
def fit(self): X_train, X_test, y_train, y_test = train_test_split( self.X, self.y, train_size=self.train_size, random_state=0) tpot = TPOTRegressor(generations=self.generation, population_size=self.generation, verbosity=3, warm_start=True, config_dict=self.config_dict) startTime = datetime.datetime.now() tpot.fit(X_train, y_train) endTime = datetime.datetime.now() predict_score = tpot.score(X_test, y_test) cost_time = endTime - startTime return predict_score, cost_time
def functionRegression(sparkDF, listOfFeatures, label): sparkDF.persist(pyspark.StorageLevel.MEMORY_AND_DISK) df = sparkDF.toPandas() df.columns.intersection(listOfFeatures) X = df.drop(label, axis=1).values y = df[label].values X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1, test_size=0.2) tpotModel = TPOTRegressor(verbosity=3, generations=10, max_time_mins=15, n_jobs=-1, random_state=25, population_size=15) tpotModel.fit(X_train, y_train) print(tpotModel.score(X_test, y_test))
def train_tpot_regressor(dat, target): # print(target) df = dat.rename(columns={target: 'class'}) X = df.drop(columns='class') y = df['class'].copy() X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=42) my_custom_scorer = make_scorer(my_custom_accuracy, greater_is_better=True) tpot = TPOTRegressor(generations=1, population_size=20, verbosity=2, scoring=my_custom_scorer) tpot.fit(X_train, y_train) #tpot.export('tpot_mnist_pipeline_'+tname+"_"+ str(target) + '.py') with open('tpot_pkl_' + tname + "_" + str(target) + '.pkl', 'wb') as f: pickle.dump(tpot, f)
def train_gpr_tpot(l=None): # with auto tuning if l is None: l = get_data() config_dict = { 'sklearn.gaussian_process.GaussianProcessRegressor': { 'alpha': np.logspace(-10, 1, 12), }, 'sklearn.pipeline.FeatureUnion': {}, 'sklearn.preprocessing.QuantileTransformer': {}, 'sklearn.preprocessing.MinMaxScaler': {}, # 'competitions.MyGP': { # 'alpha':np.logspace(-10, 1, 12), # 'mu_x': np.logspace(-1, 2, 4), # 'mu_y': np.logspace(-1, 2, 4), # } } model = TPOTRegressor( config_dict=config_dict, crossover_rate=0.1, cv=5, disable_update_check=False, early_stop=None, generations=10, max_eval_time_mins=5, max_time_mins=None, # memory=os.path.join(_mydir, 'tpot_cache'), mutation_rate=0.9, n_jobs=-1, offspring_size=None, # periodic_checkpoint_folder='periodic_checkpoint_gpr_tpot', population_size=100, random_state=None, scoring=None, subsample=1.0, use_dask=False, verbosity=3, warm_start=False) model.fit(l.X_train.copy(), l.y_train.copy().squeeze()) model.export('tpot_gpr.py') return attributedict_from_locals('model')
def TPOTRegressor(ATM): X = ATM.inputs["X"] y = ATM.inputs["y"] tpot = TPOTRegressor(generations=ATM.props["generations"], population_size=ATM.props["population_size"], verbosity=ATM.props["verbosity"], random_state=ATM.props["random_state"]) tpot.fit(X, y) ATM.report({ 'name': "stats", 'stats': { 'score': tpot.score(payload.X_test, y_test) } }) ATM.report({ 'name': "log", 'payload': { 'model': tpot.export() } }) ATM.save("model.tpot", tpot.export())
def show_data(dataset_train, classifier_name, params): st.write("Training dataset:", dataset_train) X = dataset_train.values[:, 1:] y = dataset_train.values[:, 0] st.write('Shape of dataset:', X.shape, '=> ', X.shape[0], 'rows and ', X.shape[1], 'columns of dataset') st.write(f'Classifier = {classifier_name}', '=> model to train the dataset') generation = params['2.1 Tune parameter: Generation (Epoch)'] X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.75, test_size=0.25, random_state=42) tpot = TPOTRegressor(generations=generation, population_size=50, verbosity=2, random_state=42) #generations=5 tpot.fit(X_train, y_train) #st.write('Info for reference only:', tpot.fit(X_train, y_train)) #print(tpot.score(X_test, y_test)) tpot.export('tpot_boston_pipeline.py') #tpot.log('tpot_progress_content.txt') MSE = abs(tpot.score(X_test, y_test)) st.write("MSE (Mean Squared Error):", MSE.round(2)) #st.write(tpot.evaluated_individuals_) # save the model to disk #model=tpot #pickle.dump(model, open(filename, 'wb')) #from joblib import dump, load #dump(tpot, 'filename.joblib') #https://github.com/EpistasisLab/tpot/issues/11#issuecomment-341421022 pickle.dump(tpot.fitted_pipeline_, open(filename, 'wb'))
def ensemble_tpot(city, state, target, horizon, lookback): with open('../analysis/clusters_{}.pkl'.format(state), 'rb') as fp: clusters = pickle.load(fp) data, group = get_cluster_data(city, clusters=clusters, data_types=DATA_TYPES, cols=PREDICTORS) casos_est_columns = ['casos_est_{}'.format(i) for i in group] casos_columns = ['casos_{}'.format(i) for i in group] data = data.drop(casos_columns, axis=1) data_lag = build_lagged_features(data, lookback) data_lag.dropna() X_data = data_lag.drop(casos_est_columns, axis=1) X_train, X_test, y_train, y_test = train_test_split(X_data, data_lag[target], train_size=0.7, test_size=0.3, shuffle=False) tgt_full = data_lag[target].shift(-(horizon - 1))[:-(horizon - 1)] tgt = tgt_full[:len(X_train)] tgtt = tgt_full[len(X_train):] model = TPOTRegressor(generations=20, population_size=100, verbosity=2, n_jobs=32) model.fit(X_train, target=tgt) model.export('tpot_{}_pipeline.py'.format(city)) print(model.score(X_test[:len(tgtt)], tgtt)) pred = plot_prediction(X_data[:len(tgt_full)], tgt_full, model, 'Out_of_Sample_{}_{}'.format(horizon, city), horizon) plt.show() return pred
test = combi[train.shape[0]:] test.drop('Item_Outlet_Sales',axis=1,inplace=True) ## removing id variables tpot_train = train.drop(['Outlet_Identifier','Item_Type','Item_Identifier'],axis=1) tpot_test = test.drop(['Outlet_Identifier','Item_Type','Item_Identifier'],axis=1) target = tpot_train['Item_Outlet_Sales'] tpot_train.drop('Item_Outlet_Sales',axis=1,inplace=True) # finally building model using tpot library from tpot import TPOTRegressor X_train, X_test, y_train, y_test = train_test_split(tpot_train, target,train_size=0.75, test_size=0.25) tpot = TPOTRegressor(generations=5, population_size=50, verbosity=2) tpot.fit(X_train, y_train) print(tpot.score(X_test, y_test)) tpot.export(data+'tpot_boston_pipeline.py') ## predicting using tpot optimised pipeline tpot_pred = tpot.predict(tpot_test) sub1 = pd.DataFrame(data=tpot_pred) #sub1.index = np.arange(0, len(test)+1) sub1 = sub1.rename(columns = {'0':'Item_Outlet_Sales'}) sub1['Item_Identifier'] = test['Item_Identifier'] sub1['Outlet_Identifier'] = test['Outlet_Identifier'] sub1.columns = ['Item_Outlet_Sales','Item_Identifier','Outlet_Identifier'] sub1 = sub1[['Item_Identifier','Outlet_Identifier','Item_Outlet_Sales']] sub1.to_csv('tpot.csv',index=False)
def model_dev(train_set,matchups,spreads): """ Create the testing set for the algo creation """ # Create a sample set to pass into the machine learning algorithm X = train_set[['rush_attempt_diff', 'turn_diff', 'yards_diff', 'third_diff', 'sack_diff', 'sack_ydiff', 'poss_diff', 'p_attempt_diff']].copy() # X = df[['poss_diff', 'third_diff', 'turn_diff', 'pass_diff', 'rush_diff']].copy() # Create results vector (a home win = 1, a home loss or tie = 0) train_set.rename(columns={'result_spread':'class'},inplace=True) y = train_set['class']#np.array(np.where(df['home_score'] > df['away_score'], 1, 0)) """ Train, test, and predict the algorithm """ # Scale the sample data scaler = preprocessing.StandardScaler().fit(X) X = scaler.transform(X) # Delete the dataframe to clear memory del train_set # Split out training and testing data sets X_train, X_test, y_train, y_test = model_selection.train_test_split(X,y,test_size=0.25,random_state=0) # alphas = [0.1, 0.3, 0.9, 1.0, 1.3, 1.9, 2.0, 2.3, 2.9] # for alpha in alphas: # reg = linear_model.Ridge(alpha = alpha) # reg.fit(X_train,y_train) # print 'alpha = ',alpha,', score = ',reg.score(X_test,y_test) # input() pipeline_optimizer = TPOTRegressor(generations = 5, population_size = 10, random_state = 42, cv = 5, verbosity = 2, n_jobs = 3)#, scoring = 'f1') pipeline_optimizer.fit(X_train,y_train) print pipeline_optimizer.score(X_test,y_test) pipeline_optimizer.export('NFL_ML_TPOT_Regressor.py') # Remove the 'week' 'home_team' and 'away_team' columns from matchups as they are not used in the algorithm matchups.drop(['week', 'home_team', 'away_team'], axis=1, inplace=True) """ for feat in range(1,len(matchups.columns)): for c in C_vec: # Create the classifier and check the score # clf = LogisticRegression() clf = linear_model.LogisticRegression(C=c,random_state=42) selector = RFE(clf) selector = selector.fit(X_train,y_train) # Calculate probabilities using the predict_proba method for logistic regression probabilities = selector.predict_proba(scaler.transform(matchups)) # Vectorize the spread_conversion function and apply the function to the probabilities result vector vfunc = np.vectorize(spread_conversion) predicted_spreads = np.apply_along_axis(vfunc,0,probabilities[:,0]) # If the actual line for the home team is lower than the predicted line then you would take the away team, otherwise take the home team bet_vector = np.array(np.where(predicted_spreads > spreads,0,1)) # Create the actual result vector where a tie counts as a loss for the home team game_result = np.array(np.where(home_score.ix[:,0] + predicted_spreads[:] > away_score.ix[:,0], 1, 0)) # Check to see where the bet_vector equals the actual game result with the spread included result = np.array(np.where(bet_vector == game_result,1,0)) prob_result = float(np.sum(result)) / len(result) # print 'Number of features =', feat, 'C =',c,' Percent correct =',prob_result if prob_result > prob_val: prob_val = prob_result C_val = c feat_val = feat print 'Score =',selector.score(X_test,y_test) # print prob_val, C_val, feat clf = linear_model.LogisticRegression(C=C_val,random_state=42) clf = clf.fit(X_train,y_train) probabilities = clf.predict_proba(scaler.transform(matchups)) vfunc = np.vectorize(spread_conversion) predicted_spreads = np.apply_along_axis(vfunc,0,probabilities[:,0]) """ predicted_spreads = pd.DataFrame(pipeline_optimizer.predict(scaler.transform(matchups)),columns = ['results']) bet_vector = np.array(np.where(predicted_spreads > spreads,0,1)) print spreads print predicted_spreads print bet_vector