def main(args=None): r"""The main program for SportFlow. Notes ----- (1) Initialize logging. (2) Parse the command line arguments. (3) Get the game configuration. (4) Get the model configuration. (5) Generate game frames for each season. (6) Create statistics for each team. (7) Merge the team frames into the final model frame. (8) Run the AlphaPy pipeline. Raises ------ ValueError Training date must be before prediction date. """ # Logging logging.basicConfig(format="[%(asctime)s] %(levelname)s\t%(message)s", filename="sport_flow.log", filemode='a', level=logging.DEBUG, datefmt='%m/%d/%y %H:%M:%S') formatter = logging.Formatter("[%(asctime)s] %(levelname)s\t%(message)s", datefmt='%m/%d/%y %H:%M:%S') console = logging.StreamHandler() console.setFormatter(formatter) console.setLevel(logging.INFO) logging.getLogger().addHandler(console) logger = logging.getLogger(__name__) # Start the pipeline logger.info('*'*80) logger.info("SportFlow Start") logger.info('*'*80) # Argument Parsing parser = argparse.ArgumentParser(description="SportFlow Parser") parser.add_argument('--pdate', dest='predict_date', help="prediction date is in the format: YYYY-MM-DD", required=False, type=valid_date) parser.add_argument('--tdate', dest='train_date', help="training date is in the format: YYYY-MM-DD", required=False, type=valid_date) parser.add_mutually_exclusive_group(required=False) parser.add_argument('--predict', dest='predict_mode', action='store_true') parser.add_argument('--train', dest='predict_mode', action='store_false') parser.set_defaults(predict_mode=False) args = parser.parse_args() # Set train and predict dates if args.train_date: train_date = args.train_date else: train_date = pd.datetime(1900, 1, 1).strftime("%Y-%m-%d") if args.predict_date: predict_date = args.predict_date else: predict_date = datetime.date.today().strftime("%Y-%m-%d") # Verify that the dates are in sequence. if train_date >= predict_date: raise ValueError("Training date must be before prediction date") else: logger.info("Training Date: %s", train_date) logger.info("Prediction Date: %s", predict_date) # Read game configuration file sport_specs = get_sport_config() # Section: game league = sport_specs['league'] points_max = sport_specs['points_max'] points_min = sport_specs['points_min'] random_scoring = sport_specs['random_scoring'] seasons = sport_specs['seasons'] window = sport_specs['rolling_window'] # Read model configuration file specs = get_model_config() # Add command line arguments to model specifications specs['predict_mode'] = args.predict_mode specs['predict_date'] = args.predict_date specs['train_date'] = args.train_date # Unpack model arguments directory = specs['directory'] target = specs['target'] # Create directories if necessary output_dirs = ['config', 'data', 'input', 'model', 'output', 'plots'] for od in output_dirs: output_dir = SSEP.join([directory, od]) if not os.path.exists(output_dir): logger.info("Creating directory %s", output_dir) os.makedirs(output_dir) # Create the game scores space space = Space('game', 'scores', '1g') # # Derived Variables # series = space.schema team1_prefix = 'home' team2_prefix = 'away' home_team = PSEP.join([team1_prefix, 'team']) away_team = PSEP.join([team2_prefix, 'team']) # # Read in the game frame. This is the feature generation phase. # logger.info("Reading Game Data") data_dir = SSEP.join([directory, 'data']) file_base = USEP.join([league, space.subject, space.schema, space.fractal]) df = read_frame(data_dir, file_base, specs['extension'], specs['separator']) logger.info("Total Game Records: %d", df.shape[0]) # # Locate any rows with null values # null_rows = df.isnull().any(axis=1) null_indices = [i for i, val in enumerate(null_rows.tolist()) if val == True] for i in null_indices: logger.info("Null Record: %d on Date: %s", i, df.date[i]) # # Run the game pipeline on a seasonal loop # if not seasons: # run model on all seasons seasons = df['season'].unique().tolist() # # Initialize the final frame # ff = pd.DataFrame() # # Iterate through each season of the game frame # for season in seasons: # Generate a frame for each season gf = df[df['season'] == season] gf = gf.reset_index() # Generate derived variables for the game frame total_games = gf.shape[0] if random_scoring: gf['home.score'] = np.random.randint(points_min, points_max, total_games) gf['away.score'] = np.random.randint(points_min, points_max, total_games) gf['total_points'] = gf['home.score'] + gf['away.score'] gf = add_features(gf, game_dict, gf.shape[0]) for index, row in gf.iterrows(): gf['point_margin_game'].at[index] = get_point_margin(row, 'home.score', 'away.score') gf['won_on_points'].at[index] = True if gf['point_margin_game'].at[index] > 0 else False gf['lost_on_points'].at[index] = True if gf['point_margin_game'].at[index] < 0 else False gf['cover_margin_game'].at[index] = gf['point_margin_game'].at[index] + row['line'] gf['won_on_spread'].at[index] = True if gf['cover_margin_game'].at[index] > 0 else False gf['lost_on_spread'].at[index] = True if gf['cover_margin_game'].at[index] <= 0 else False gf['overunder_margin'].at[index] = gf['total_points'].at[index] - row['over_under'] gf['over'].at[index] = True if gf['overunder_margin'].at[index] > 0 else False gf['under'].at[index] = True if gf['overunder_margin'].at[index] < 0 else False # Generate each team frame team_frames = {} teams = gf.groupby([home_team]) for team, data in teams: team_frame = USEP.join([league, team.lower(), series, str(season)]) logger.info("Generating team frame: %s", team_frame) tf = get_team_frame(gf, team, home_team, away_team) tf = tf.reset_index() tf = generate_team_frame(team, tf, home_team, away_team, window) team_frames[team_frame] = tf # Create the model frame, initializing the home and away frames mdict = {k:v for (k,v) in list(sports_dict.items()) if v != bool} team1_frame = pd.DataFrame() team1_frame = add_features(team1_frame, mdict, gf.shape[0], prefix=team1_prefix) team2_frame = pd.DataFrame() team2_frame = add_features(team2_frame, mdict, gf.shape[0], prefix=team2_prefix) frames = [gf, team1_frame, team2_frame] mf = pd.concat(frames, axis=1) # Loop through each team frame, inserting data into the model frame row # get index+1 [if valid] # determine if team is home or away to get prefix # try: np.where((gf[home_team] == 'PHI') & (gf['date'] == '09/07/14'))[0][0] # Assign team frame fields to respective model frame fields: set gf.at(pos, field) for team, data in teams: team_frame = USEP.join([league, team.lower(), series, str(season)]) logger.info("Merging team frame %s into model frame", team_frame) tf = team_frames[team_frame] for index in range(0, tf.shape[0]-1): gindex = index + 1 model_row = tf.iloc[gindex] key_date = model_row['date'] at_home = False if team == model_row[home_team]: at_home = True key_team = model_row[home_team] elif team == model_row[away_team]: key_team = model_row[away_team] else: raise KeyError("Team %s not found in Team Frame" % team) try: if at_home: mpos = np.where((mf[home_team] == key_team) & (mf['date'] == key_date))[0][0] else: mpos = np.where((mf[away_team] == key_team) & (mf['date'] == key_date))[0][0] except: raise IndexError("Team/Date Key not found in Model Frame") # print team, gindex, mpos # insert team data into model row mf = insert_model_data(mf, mpos, mdict, tf, index, team1_prefix if at_home else team2_prefix) # Compute delta data 'home' - 'away' mf = generate_delta_data(mf, mdict, team1_prefix, team2_prefix) # Append this to final frame frames = [ff, mf] ff = pd.concat(frames) # Write out dataframes input_dir = SSEP.join([directory, 'input']) if args.predict_mode: new_predict_frame = ff.loc[ff.date >= predict_date] if len(new_predict_frame) <= 1: raise ValueError("Prediction frame has length 1 or less") # rewrite with all the features to the train and test files logger.info("Saving prediction frame") write_frame(new_predict_frame, input_dir, datasets[Partition.predict], specs['extension'], specs['separator']) else: # split data into training and test data new_train_frame = ff.loc[(ff.date >= train_date) & (ff.date < predict_date)] if len(new_train_frame) <= 1: raise ValueError("Training frame has length 1 or less") new_test_frame = ff.loc[ff.date >= predict_date] if len(new_test_frame) <= 1: raise ValueError("Testing frame has length 1 or less") # rewrite with all the features to the train and test files logger.info("Saving training frame") write_frame(new_train_frame, input_dir, datasets[Partition.train], specs['extension'], specs['separator']) logger.info("Saving testing frame") write_frame(new_test_frame, input_dir, datasets[Partition.test], specs['extension'], specs['separator']) # Create the model from specs logger.info("Running Model") model = Model(specs) # Run the pipeline model = main_pipeline(model) # Complete the pipeline logger.info('*'*80) logger.info("SportFlow End") logger.info('*'*80)
def run_analysis(analysis, lag_period, forecast_period, leaders, predict_history, splits=True): r"""Run an analysis for a given model and group. First, the data are loaded for each member of the analysis group. Then, the target value is lagged for the ``forecast_period``, and any ``leaders`` are lagged as well. Each frame is split along the ``predict_date`` from the ``analysis``, and finally the train and test files are generated. Parameters ---------- analysis : alphapy.Analysis The analysis to run. lag_period : int The number of lagged features for the analysis. forecast_period : int The period for forecasting the target of the analysis. leaders : list The features that are contemporaneous with the target. predict_history : int The number of periods required for lookback calculations. splits : bool, optional If ``True``, then the data for each member of the analysis group are in separate files. Returns ------- analysis : alphapy.Analysis The completed analysis. """ # Unpack analysis name = analysis.name model = analysis.model group = analysis.group # Unpack model data predict_file = model.predict_file test_file = model.test_file train_file = model.train_file # Unpack model specifications directory = model.specs['directory'] extension = model.specs['extension'] predict_date = model.specs['predict_date'] predict_mode = model.specs['predict_mode'] separator = model.specs['separator'] target = model.specs['target'] train_date = model.specs['train_date'] # Calculate split date logger.info("Analysis Dates") split_date = subtract_days(predict_date, predict_history) logger.info("Train Date: %s", train_date) logger.info("Split Date: %s", split_date) logger.info("Test Date: %s", predict_date) # Load the data frames data_frames = load_frames(group, directory, extension, separator, splits) # Create dataframes if predict_mode: # create predict frame predict_frame = pd.DataFrame() else: # create train and test frames train_frame = pd.DataFrame() test_frame = pd.DataFrame() # Subset each individual frame and add to the master frame leaders.extend([TAG_ID]) for df in data_frames: try: tag = df[TAG_ID].unique()[0] except: tag = 'Unknown' first_date = df.index[0] last_date = df.index[-1] logger.info("Analyzing %s from %s to %s", tag, first_date, last_date) # sequence leaders, laggards, and target(s) df = sequence_frame(df, target, forecast_period, leaders, lag_period) # get frame subsets if predict_mode: new_predict = df.loc[(df.index >= split_date) & (df.index <= last_date)] if len(new_predict) > 0: predict_frame = predict_frame.append(new_predict) else: logger.info( "Prediction frame %s has zero rows. Check prediction date.", tag) else: # split data into train and test new_train = df.loc[(df.index >= train_date) & (df.index < split_date)] if len(new_train) > 0: new_train = new_train.dropna() train_frame = train_frame.append(new_train) new_test = df.loc[(df.index >= split_date) & (df.index <= last_date)] if len(new_test) > 0: # check if target column has NaN values nan_count = df[target].isnull().sum() forecast_check = forecast_period - 1 if nan_count != forecast_check: logger.info("%s has %d records with NaN targets", tag, nan_count) # drop records with NaN values in target column new_test = new_test.dropna(subset=[target]) # append selected records to the test frame test_frame = test_frame.append(new_test) else: logger.info( "Testing frame %s has zero rows. Check prediction date.", tag) else: logger.info( "Training frame %s has zero rows. Check data source.", tag) # Write out the frames for input into the AlphaPy pipeline directory = SSEP.join([directory, 'input']) if predict_mode: # write out the predict frame write_frame(predict_frame, directory, predict_file, extension, separator, index=True, index_label='date') else: # write out the train and test frames write_frame(train_frame, directory, train_file, extension, separator, index=True, index_label='date') write_frame(test_frame, directory, test_file, extension, separator, index=True, index_label='date') # Run the AlphaPy pipeline analysis.model = main_pipeline(model) # Return the analysis return analysis
def run_analysis(analysis, forecast_period, leaders, predict_history, splits=True): r"""Run an analysis for a given model and group. First, the data are loaded for each member of the analysis group. Then, the target value is lagged for the ``forecast_period``, and any ``leaders`` are lagged as well. Each frame is split along the ``predict_date`` from the ``analysis``, and finally the train and test files are generated. Parameters ---------- analysis : alphapy.Analysis The analysis to run. forecast_period : int The period for forecasting the target of the analysis. leaders : list The features that are contemporaneous with the target. splits : bool, optional If ``True``, then the data for each member of the analysis group are in separate files. Returns ------- analysis : alphapy.Analysis The completed analysis. """ # Unpack analysis name = analysis.name model = analysis.model group = analysis.group # Unpack model data predict_file = model.predict_file test_file = model.test_file test_labels = model.test_labels train_file = model.train_file # Unpack model specifications directory = model.specs['directory'] extension = model.specs['extension'] predict_date = model.specs['predict_date'] predict_mode = model.specs['predict_mode'] separator = model.specs['separator'] target = model.specs['target'] train_date = model.specs['train_date'] # Calculate split date split_date = subtract_days(predict_date, predict_history) # Load the data frames data_frames = load_frames(group, directory, extension, separator, splits) # Create dataframes if predict_mode: # create predict frame predict_frame = pd.DataFrame() else: # create train and test frames train_frame = pd.DataFrame() test_frame = pd.DataFrame() # Subset each individual frame and add to the master frame for df in data_frames: last_date = df.index[-1] # shift the target for the forecast period if forecast_period > 0: df[target] = df[target].shift(-forecast_period) df.index = df.index.shift(forecast_period, freq='D') # shift any leading features if necessary if leaders: df[leaders] = df[leaders].shift(-1) # get frame subsets if predict_mode: new_predict = df.loc[(df.index >= split_date) & (df.index <= last_date)] if len(new_predict) > 0: predict_frame = predict_frame.append(new_predict) else: logger.info( "A prediction frame has zero rows. Check prediction date.") else: # split data into train and test new_train = df.loc[(df.index >= train_date) & (df.index < split_date)] if len(new_train) > 0: # train frame new_train = new_train.dropna() train_frame = train_frame.append(new_train) # test frame new_test = df.loc[(df.index >= split_date) & (df.index <= last_date)] if len(new_test) > 0: if test_labels: new_test = new_test.dropna() test_frame = test_frame.append(new_test) else: logger.info( "A testing frame has zero rows. Check prediction date." ) else: logger.warning( "A training frame has zero rows. Check data source.") # Write out the frames for input into the AlphaPy pipeline directory = SSEP.join([directory, 'input']) if predict_mode: # write out the predict frame write_frame(predict_frame, directory, predict_file, extension, separator, index=True, index_label='date') else: # write out the train and test frames write_frame(train_frame, directory, train_file, extension, separator, index=True, index_label='date') write_frame(test_frame, directory, test_file, extension, separator, index=True, index_label='date') # Run the AlphaPy pipeline analysis.model = main_pipeline(model) # Return the analysis return analysis