def main(pred_week, vegas_adjustment=False, run_query=False, expert_projections=False): db = nfldb.connect() result_path='../results' full_train, pipe, stats = load_feature_set(db, load_cached=not run_query, to_yr_wk=(2015, pred_week)) # picks columns to model lag_cols = [stat + '_lag' for stat in stats] mean_cols = [stat + '_mean' for stat in stats] other_cols = ['same_year_lag', 'played_lag'] infoColumns = ExtractColumns(like=[], exact=['year','week','time','player_id','full_name']) row_info = infoColumns.fit_transform(X=full_train) pred_data, predict_i, pred_info, pred_yr_wk = prediction_feature_set(db, pipe, infoColumns, pred_week=pred_week) X_all = full_train pred_all = pred_data.iloc[predict_i] pred_results = pred_info.iloc[predict_i] # which rows did players play played_bool = full_train['played'] == 1 played_index = [i for i in range(X_all.shape[0]) if played_bool[i]] # random split train and test train_index, test_index = train_test_split_index(X_all.shape[0], test_size=0.1, seed=0) feature_cols = lag_cols + mean_cols + other_cols XColumns = ExtractColumns(like=feature_cols) X = XColumns.fit_transform(X=X_all) X_pred = XColumns.fit_transform(X=pred_all) played_only = True y_cols = ['played', 'receiving_rec', 'receiving_tds', 'receiving_yds', 'rushing_att', 'rushing_tds','rushing_yds'] # added for saving test results for model evaluation rows = [] for y_col in y_cols: y = X_all[y_col] if(played_only and y_col != 'played'): train_i = list(set.intersection(set(train_index), set(played_index))) test_i = list(set.intersection(set(test_index), set(played_index))) else: train_i = train_index test_i = test_index X_train = X.iloc[train_i] y_train = y.iloc[train_i] X_test = X.iloc[test_i] y_test = y.iloc[test_i] # get player info for train and test data X_train_info = row_info.iloc[train_i] X_test_info = row_info.iloc[test_i] ### Test Predictions predict_proba = y_col == 'played' if(predict_proba): models = { 'gb':GradientBoostingClassifier(n_estimators=100, learning_rate=0.1), 'rf':RandomForestClassifier(), 'lin':LogisticRegression(), 'dum':DummyClassifier() } else: models = { 'gb':GradientBoostingRegressor(n_estimators=100, learning_rate=0.1), 'rf':RandomForestRegressor(), 'lin':LinearRegression(), 'dum':DummyRegressor() } gb, gb_test, gb_scores = fit_predict( model=models['gb'], X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, predict_proba=predict_proba) rf, rf_test, rf_scores = fit_predict( model=models['rf'], X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, predict_proba=predict_proba) lin, lin_test, lin_scores = fit_predict( model=models['lin'], X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, predict_proba=predict_proba) dum, dum_test, dum_scores = fit_predict( model=models['dum'], X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, predict_proba=predict_proba) if vegas_adjustment and y_col != 'played': print '-'*50 print 'Vegas Adjusted:', y_col X_train_all = build_vegas_dataframe(X=X_train, y=y_train, row_info=X_train_info, model=gb, db=db, y_col=y_col) X_test_all = build_vegas_dataframe(X=X_test, y=y_test, row_info=X_test_info, model=gb, db=db, y_col=y_col) features = [y_col, 'Total','is_favorite','spread_x_favorite'] X_cols = ExtractColumns(exact=features) X_train = X_cols.fit_transform(X=X_train_all) X_test = X_cols.fit_transform(X=X_test_all) gb_a, gb_test_a, gb_scores_a = fit_predict( model=models['gb'], X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test) rf_a, rf_test_a, rf_scores_a = fit_predict( model=models['rf'], X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test) lin_a, lin_test_a, lin_scores_a = fit_predict( model=models['lin'], X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test) print 'Predicting %s' % (y_col) print lin_a.coef_ print 'Gradient Boosting: RMSE %.2f | MAE %.2f' % (gb_scores_a['rmse'], gb_scores_a['mae']) print 'Random Forest: RMSE %.2f | MAE %.2f' % (rf_scores_a['rmse'], rf_scores_a['mae']) print '%s Regression: RMSE %.2f | MAE %.2f' % ('Linear', lin_scores_a['rmse'], lin_scores_a['mae']) print '-'*50 print 'Historical Prediction:', y_col # Print Results print 'Gradient Boosting: RMSE %.2f | MAE %.2f' % (gb_scores['rmse'], gb_scores['mae']) print 'Random Forest: RMSE %.2f | MAE %.2f' % (rf_scores['rmse'], rf_scores['mae']) print '%s Regression: RMSE %.2f | MAE %.2f' % ('Logistic' if predict_proba else 'Linear', lin_scores['rmse'], lin_scores['mae']) print 'Baseline: RMSE %.2f | MAE %.2f' % (dum_scores['rmse'], dum_scores['mae']) result_row(method='Historical Only', results=gb_scores, stat=y_col, learner='Gradient Boosting', rows=rows) result_row(method='Historical Only', results=rf_scores, stat=y_col, learner='Random Forest', rows=rows) result_row(method='Historical Only', results=lin_scores, stat=y_col, learner='Logistic' if predict_proba else 'Linear', rows=rows) result_row(method='Baseline', results=dum_scores, stat=y_col, learner='Stratified' if predict_proba else 'Mean', rows=rows) # result_row(method='Vegas Adjusted', results=gb_scores_a, stat=y_col, learner='Gradient Boosting', rows=rows) # result_row(method='Vegas Adjusted', results=rf_scores_a, stat=y_col, learner='Random Forest', rows=rows) # result_row(method='Vegas Adjusted', results=lin_scores_a, stat=y_col, learner='Logistic' if predict_proba else 'Linear', rows=rows) # Build full models on all data gb = gb.fit(X, y) rf = rf.fit(X, y) lin = lin.fit(X, y) #### Next week's predictions # Make prediction, just gbr for now if(y_col == 'played'): preds = gb.predict_proba(X_pred)[:,1] else: preds = gb.predict(X_pred) if expert_projections: # create dataframe with predictions for all weeks of current # year to use with the expert prediction mask = (row_info.year == 2015) & (row_info.week <= pred_week) X_2015 = X[mask] y_2015 = X_all[mask][y_col] preds_2015 = cross_val_predict(gb, X_2015, y_2015) info_2015 = row_info[mask][['full_name','week','year']] info_2015.loc[:, y_col] = preds_2015 info_2015.loc[:,'position'] = 'RB' info_2015.loc[:, y_col] = X_all[mask][y_col] # add our prediction based on historical data to output pred_results.loc[:,y_col] = preds # add expert projections, then make a final prediction if expert_projections and y_col != 'played': pred_results = add_expert_projections(pred_results, pred_week, y_col, info_2015, result_rows=rows) pred_results.replace(0, np.nan, inplace=True) out_path = result_path + '/predictions' + '_' + str(int(pred_yr_wk[0])) + '_' + str(int(pred_yr_wk[1])) + '.json' pred_results.to_json(path_or_buf = out_path, orient = 'records')
def main(): # connect to nfldb db = nfldb.connect() result_path = '../results' # make player data transformer yr_wk = [(j, i) for j in range(2009,2015) for i in range(1,18)] yr_wk += [(2015, i) for i in range(1,5)] #stats = ['rushing_yds','rushing_att'] stats = ['receiving_rec', 'receiving_tar', 'receiving_tds', 'receiving_yac_yds', 'receiving_yds', 'rushing_att', 'rushing_tds','rushing_yds'] player_info = ['player_id','full_name','position'] playerData = WeeklyPlayerData(db=db, yr_wk=yr_wk, stats=stats, player_info=player_info, fill_time=True, position='RB') # creates lags of the data lag_cols = ['year', 'week', 'played'] + stats lagData = LagPlayerData(nlag=6, groupby_cols=['player_id'], lag_cols=lag_cols, same_year_bool=True) # creates means of the data mean_cols = stats meanData = MeanPlayerData(groupby_cols=['player_id'], mean_cols=mean_cols) # pipeline for getting data #pipe = Pipeline(steps=[('data',playerData), ('lag',lagData)]) pipe1 = Pipeline(steps=[('data',playerData), ('lag',lagData), ('mean',meanData)]) processed_data = pipe1.fit_transform(X=None) # print processed_data # pipeline for seting which columns we want and handling NaN pct_played_threshold = 0.2 pipe2_steps = [('handle',HandleNaN(method='fill')), ('filterplayed',FilterPlayedPercent(pct_played_threshold=pct_played_threshold))] pipe2 = Pipeline(steps=pipe2_steps) all_columns = pipe2.fit_transform(X=processed_data) # picks columns to model lag_cols = [stat + '_lag' for stat in stats] mean_cols = [stat + '_mean' for stat in stats] other_cols = ['same_year_lag', 'played_lag'] infoColumns = ExtractColumns(like=[], exact=['year','week','time','player_id','full_name']) row_info = infoColumns.fit_transform(X=all_columns) yr_wk_pred = [(2015, 4)] train_i, predict_i = split_by_year_week(all_columns, yr_wk_pred) df_pred = row_info.iloc[predict_i] # set y_col y_cols = ['receiving_rec', 'receiving_tds', 'receiving_yds', 'rushing_att', 'rushing_tds','rushing_yds'] for y_col in y_cols: # Pick the right columns keep_like = [y_col] + lag_cols + mean_cols + other_cols pickColumns = ExtractColumns(like=keep_like) X_y = pickColumns.fit_transform(X=all_columns) # get X and y y = X_y[y_col] X = X_y.drop(y_col, axis=1) # random split train and test train_i, test_i = train_test_split_index(X.shape[0], test_size=0.05) # set up data y_train = y.iloc[train_i] y_test = y.iloc[test_i] X_train = X.iloc[train_i] X_test = X.iloc[test_i] ### Test Predictions # Gradident Boosting gbr = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1).fit(X_train, y_train) predict_test = gbr.predict(X_test) gbr_rmse = mean_squared_error(y_test, predict_test)**0.5 gbr_mae = mean_absolute_error(y_test, predict_test) # Random Forest Regressor rf = RandomForestRegressor().fit(X_train, y_train) predict_test = rf.predict(X_test) rf_rmse = mean_squared_error(y_test, predict_test)**0.5 rf_mae = mean_absolute_error(y_test, predict_test) # Linear Regression lr = LinearRegression().fit(X_train, y_train) predict_test = lr.predict(X_test) lr_rmse = mean_squared_error(y_test, predict_test)**0.5 lr_mae = mean_absolute_error(y_test, predict_test) # Print Results print 'Predictng %s' % (y_col) print 'Gradient Boosting: RMSE %.2f yards | MAE %.2f yards' % (gbr_rmse, gbr_mae) print 'Random Forest: RMSE %.2f yards | MAE %.2f yards' % (rf_rmse, rf_mae) print 'Linear Regression: RMSE %.2f yards | MAE %.2f yards' % (lr_rmse, lr_mae) # Build full models on all but the last week & predict the last week gbr = gbr.fit(X.iloc[train_i], y.iloc[train_i]) rf = rf.fit(X.iloc[train_i], y.iloc[train_i]) lr = lr.fit(X.iloc[train_i], y.iloc[train_i]) #### Next week's predictions #pipe1 = pipe1.set_params(data__yr_wk=yr_wk_pred) #data1 = pipe1.transform(X=None) #data2 = pipe2.transform(X=data1) #X_y_pred = pickColumns.transform(X=data2) #info_pred = infoColumns.transform(X=data2) #X_pred = X_y_pred.drop(y_col, axis=1) #y_pred = X_y_pred[y_col] # Make prediction, just gbr for now preds = gbr.predict(X.iloc[predict_i]) df_pred[y_col] = preds out_path = result_path + '/predictions' + '_' + str(int(yr_wk_pred[0][0])) + '_' + str(int(yr_wk_pred[0][1])) + '.json' df_pred.to_json(path_or_buf = out_path, orient = 'records')
def main(): ################################ ### CONFIGURE pred_week = 14 #None db = nfldb.connect() result_path='../results' ### LOAD DATA # load train data full_train, pipe, stats = load_feature_set(db) # picks columns to model lag_cols = [stat + '_lag' for stat in stats] mean_cols = [stat + '_mean' for stat in stats] other_cols = ['same_year_lag', 'played_lag'] infoColumns = ExtractColumns(like=[], exact=['year','week','time','player_id','full_name']) row_info = infoColumns.fit_transform(X=full_train) # load prediction data pred_data, predict_i, pred_info, pred_yr_wk = prediction_feature_set(db, pipe, infoColumns, pred_week=pred_week) ################################## ### PREPARE DATA FOR TRAIN AND PREDICT # train data with all columns X_all = full_train # prediction data with all columns pred_all = pred_data.iloc[predict_i] # which rows did players play played_bool = full_train['played'] == 1 played_index = [i for i in range(X_all.shape[0]) if played_bool[i]] # random split train and test train_index, test_index = train_test_split_index(X_all.shape[0], test_size=0.1, seed=0) feature_cols = lag_cols + mean_cols + other_cols XColumns = ExtractColumns(like=feature_cols) X = XColumns.fit_transform(X=X_all) X_pred = XColumns.fit_transform(X=pred_all) ################################## ### SET UP & TRAIN KNN # fit k nearest neighbors k = 100 played_only = True i_knn = played_index if played_only else range(X.shape[0]) #nn = NearestNeighbors(n_neighbors=k).fit(X.iloc[i_knn]) # regularization reg = CoefScaler(linear_model=Ridge()) reg = reg.fit(X=X.iloc[i_knn], y = score_stats(X_all, make_scorer(base_type='standard')).iloc[i_knn]) X_reg = reg.transform(X.iloc[i_knn]) nn = NearestNeighbors(n_neighbors=k).fit(X_reg) # returns tuple of (distances, indices of neighbors) # for prediction set #distance, neighbor = nn.kneighbors(X=X_pred) X_reg_pred = reg.transform(X=X_pred) distance, neighbor = nn.kneighbors(X=X_reg_pred) ################################## ### READ AND PLOT KNN RESULTS nn_dict = {} for check_i in range(pred_all.shape[0]): # check neighbors # check_nn is a data frame where the first row is the player # and the rest of the rows are the nearest neighbors check_nn = pred_all.iloc[[check_i],:].append(X_all.iloc[i_knn].iloc[neighbor[check_i,:]]) check_nn['StandardPoints'] = score_stats(check_nn, make_scorer(base_type='standard')) check_nn['PPRPoints'] = score_stats(check_nn, make_scorer(base_type='ppr')) nn_i = plot_knn(check_nn, save_image=True, plot_stat='StandardPoints', pred_yr_wk=pred_yr_wk, result_path=plot_image_path(result_path, pred_yr_wk), n_bins=25, bandwidth=2.5) nn_dict.update(nn_i) save_plot_data_json(nn_dict, result_path, pred_yr_wk)