diff --git "a/Notebook.ipynb" "b/Notebook.ipynb"
new file mode 100644--- /dev/null
+++ "b/Notebook.ipynb"
@@ -0,0 +1,1030 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 193,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nfl_data_py.nfl_data_py as nfl\n",
+    "from tqdm import tqdm\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "pd.set_option('chained_assignment',None)\n",
+    "pd.set_option('display.max_columns',None)\n",
+    "\n",
+    "\n",
+    "def get_pbp_data(years,overwrite=False):\n",
+    "    \"\"\"\n",
+    "    Pull data from nflFastR's Github repo. \n",
+    "    If you choose to overwrite, it will replace the existing pbp data with the data you pull.\n",
+    "\n",
+    "    \"\"\"\n",
+    "    pbp = nfl.import_pbp_data(years)\n",
+    "    pbp['TOP_seconds'] = pbp['drive_time_of_possession'].apply(lambda x: int(x.split(':')[0]) * 60 + int(x.split(':')[1]) if pd.notnull(x) else 0)\n",
+    "    \n",
+    "    if overwrite:\n",
+    "        pbp.to_csv('pbp.csv')\n",
+    "\n",
+    "    return pbp\n",
+    "\n",
+    "\n",
+    "def build_gbg_data(update_seasons=[]):\n",
+    "    \"\"\"\n",
+    "    Using pbp.csv, build a game-by-game dataset to use for prediction models.\n",
+    "    Populate update_seasons with the current year to only update this season's data while preserving historical data.\n",
+    "\n",
+    "    \"\"\"\n",
+    "    print('Loading play-by-play data.')\n",
+    "    pbp = pd.read_csv('pbp.csv', index_col=0, low_memory=False)\n",
+    "    game_date_dict = dict(pbp[['game_id','game_date']].values)\n",
+    "\n",
+    "    if update_seasons:\n",
+    "        print('Getting data for', update_seasons)\n",
+    "        pbp = get_pbp_data(update_seasons)\n",
+    "\n",
+    "    teams = pbp['home_team'].unique()\n",
+    "    seasons = pbp['season'].unique()\n",
+    "    \n",
+    "    print('Building game-by-game data.')\n",
+    "    data = pd.DataFrame()\n",
+    "    for season in seasons:\n",
+    "        print(season)\n",
+    "        for team_name in tqdm(teams):\n",
+    "            # create features\n",
+    "            team = pbp.loc[((pbp['home_team']==team_name) | (pbp['away_team']==team_name)) & (pbp['season']==season)] \n",
+    "            team['GP'] = team['week']\n",
+    "            team['W'] = [1 if r>0 and team_name==h else 1 if r<0 and team_name==a else 0 for r,a,h in team[['result','away_team','home_team']].values]\n",
+    "            team['L'] = [0 if r>0 and team_name==h else 0 if r<0 and team_name==a else 1 for r,a,h in team[['result','away_team','home_team']].values]\n",
+    "            team['W_PCT'] = team['W']/team['GP']\n",
+    "            team['TOP'] = [t if team_name==p else 0 for t,p in team[['TOP_seconds','posteam']].values]\n",
+    "            team['FGA'] = [1 if team_name==p and f==1 else 0 for p,f in team[['posteam','field_goal_attempt']].values]\n",
+    "            team['FGM'] = [1 if team_name==p and f=='made' else 0 for p,f in team[['posteam','field_goal_result']].values]\n",
+    "            team['FG_PCT'] = team['FGM']/team['FGA']\n",
+    "            team['PassTD'] = np.where((team['posteam'] == team_name) & (team['pass_touchdown'] == 1), 1, 0)\n",
+    "            team['RushTD'] = np.where((team['posteam'] == team_name) & (team['rush_touchdown'] == 1), 1, 0)\n",
+    "            team['PassTD_Allowed'] = np.where((team['defteam'] == team_name) & (team['pass_touchdown'] == 1), 1, 0)\n",
+    "            team['RushTD_Allowed'] = np.where((team['defteam'] == team_name) & (team['rush_touchdown'] == 1), 1, 0)\n",
+    "            team['PassYds'] = [y if p==team_name else 0 for p,y in team[['posteam','passing_yards']].values]\n",
+    "            team['RushYds'] = [y if p==team_name else 0 for p,y in team[['posteam','rushing_yards']].values]\n",
+    "            team['PassYds_Allowed'] = [y if d==team_name else 0 for d,y in team[['defteam','passing_yards']].values]\n",
+    "            team['RushYds_Allowed'] = [y if d==team_name else 0 for d,y in team[['defteam','rushing_yards']].values]\n",
+    "            team['Fum'] = np.where((team['defteam'] == team_name) & (team['fumble_lost'] == 1), 1, 0)\n",
+    "            team['Fum_Allowed'] = np.where((team['posteam'] == team_name) & (team['fumble_lost'] == 1), 1, 0)\n",
+    "            team['INT'] = np.where((team['defteam'] == team_name) & (team['interception'] == 1), 1, 0)\n",
+    "            team['INT_Allowed'] = np.where((team['posteam'] == team_name) & (team['interception'] == 1), 1, 0)\n",
+    "            team['Sacks'] = np.where((team['defteam'] == team_name) & (team['sack'] == 1), 1, 0)\n",
+    "            team['Sacks_Allowed'] = np.where((team['posteam'] == team_name) & (team['sack'] == 1), 1, 0)\n",
+    "            team['Penalties'] = np.where((team['penalty_team'] == team_name), 1, 0)\n",
+    "            team['FirstDowns'] = [1 if team_name==p and f==1 else 0 for p,f in team[['posteam','first_down']].values]\n",
+    "            team['3rdDownConverted'] = [1 if p==team_name and t==1 else 0 for p,t in team[['posteam','third_down_converted']].values]\n",
+    "            team['3rdDownFailed'] = [1 if p==team_name and t==1 else 0 for p,t in team[['posteam','third_down_failed']].values]\n",
+    "            team['3rdDownAllowed'] = [1 if d==team_name and t==1 else 0 for d,t in team[['defteam','third_down_converted']].values]\n",
+    "            team['3rdDownDefended'] = [1 if d==team_name and t==1 else 0 for d,t in team[['defteam','third_down_failed']].values]\n",
+    "            team['PTS'] = [ap if at==team_name else hp if ht==team_name else None for ht,at,hp,ap in team[['home_team','away_team','home_score','away_score']].values]\n",
+    "            team['PointDiff'] = [r if team_name==h else -r if team_name==a else 0 for r,a,h in team[['result','away_team','home_team']].values]\n",
+    "\n",
+    "            # aggregate from play-by-play to game-by-game\n",
+    "            features = {\n",
+    "                'GP':'mean',\n",
+    "                'W':'mean',\n",
+    "                'L':'mean',\n",
+    "                'W_PCT':'mean',\n",
+    "                'TOP':'sum',\n",
+    "                'FGA':'sum',\n",
+    "                'FGM':'sum',\n",
+    "                'FG_PCT':'mean',\n",
+    "                'PassTD':'sum',\n",
+    "                'RushTD':'sum',\n",
+    "                'PassTD_Allowed':'sum',\n",
+    "                'RushTD_Allowed':'sum',\n",
+    "                'PassYds':'sum',\n",
+    "                'RushYds':'sum',\n",
+    "                'PassYds_Allowed':'sum',\n",
+    "                'RushYds_Allowed':'sum',\n",
+    "                'Fum':'sum',\n",
+    "                'Fum_Allowed':'sum',\n",
+    "                'INT':'sum',\n",
+    "                'INT_Allowed':'sum',\n",
+    "                'Sacks':'sum',\n",
+    "                'Sacks_Allowed':'sum',\n",
+    "                'Penalties':'sum',\n",
+    "                'FirstDowns':'sum',\n",
+    "                '3rdDownConverted':'sum',\n",
+    "                '3rdDownFailed':'sum',\n",
+    "                '3rdDownAllowed':'sum',\n",
+    "                '3rdDownDefended':'sum',\n",
+    "                'PTS':'mean',\n",
+    "                'PointDiff':'mean'\n",
+    "            }\n",
+    "\n",
+    "            game = team.groupby('game_id').agg(features).reset_index()\n",
+    "            game[['W','L']] = game[['W','L']].expanding().sum()\n",
+    "            game[game.columns[4:]] = game[game.columns[4:]].expanding().mean()\n",
+    "            game[game.columns[1:]] = game[game.columns[1:]].shift()\n",
+    "            game['TEAM'] = team_name\n",
+    "            game['Season'] = season\n",
+    "\n",
+    "            data = pd.concat([data,game])\n",
+    "\n",
+    "    # get rank data for each feature\n",
+    "    #feature_columns = list(features.keys())\n",
+    "    #for col in feature_columns:\n",
+    "    #    rank_col = f\"{col}_Rank\"\n",
+    "    #    data[rank_col] = data.groupby(['Season', 'GP', 'TEAM'])[col].rank(ascending=False)\n",
+    "\n",
+    "    # separate home and away data and merge\n",
+    "    data = data.merge(pbp[['game_id','home_team','away_team']].drop_duplicates())\n",
+    "    home = data.loc[data['home_team']==data['TEAM']]\n",
+    "    away = data.loc[data['away_team']==data['TEAM']]\n",
+    "    away.columns = [f'{i}.Away' for i in away.columns]\n",
+    "    gbg = home.merge(away,left_on='game_id',right_on='game_id.Away')\n",
+    "    gbg.drop(columns=['TEAM','TEAM.Away','home_team.Away','away_team.Away','Season.Away','game_id.Away'], inplace=True)\n",
+    "    gbg['game_date'] = gbg['game_id'].map(game_date_dict)\n",
+    "\n",
+    "    if update_seasons:\n",
+    "        old = pd.read_csv('gbg.csv', index_col=0, low_memory=False)\n",
+    "        old = old.loc[~old['Season'].isin(seasons)]\n",
+    "        gbg = pd.concat([old,gbg])\n",
+    "\n",
+    "    gbg.to_csv('gbg.csv')\n",
+    "\n",
+    "\n",
+    "def add_odds_data():\n",
+    "    \"\"\"\n",
+    "    Get odds from Australian Sports Betting's free online dataset and merge it with game-by-game data.\n",
+    "\n",
+    "    \"\"\"\n",
+    "    # load gbg data\n",
+    "    gbg = pd.read_csv('gbg.csv', index_col=0)\n",
+    "    \n",
+    "    # get team abbreviations\n",
+    "    team_descriptions = nfl.import_team_desc()\n",
+    "    team_abbreviation_dict = dict(team_descriptions[['team_name','team_abbr']].values)\n",
+    "    \n",
+    "    # get odds\n",
+    "    odds = pd.read_excel('https://www.aussportsbetting.com/historical_data/nfl.xlsx')\n",
+    "    odds['Home Team'] = odds['Home Team'].str.replace('Washington Redskins','Washington Commanders').str.replace('Washington Football Team','Washington Commanders')\n",
+    "    odds['Away Team'] = odds['Away Team'].str.replace('Washington Redskins','Washington Commanders').str.replace('Washington Football Team','Washington Commanders')\n",
+    "    odds['Season'] = [i.year if i.month in [8,9,10,11,12] else i.year-1 for i in odds['Date']]\n",
+    "    odds['Home Team Abbrev'] = odds['Home Team'].map(team_abbreviation_dict)\n",
+    "    odds['Away Team Abbrev'] = odds['Away Team'].map(team_abbreviation_dict)\n",
+    "    odds = odds[['Date','Home Score','Away Score','Home Team Abbrev','Away Team Abbrev','Home Odds Close','Away Odds Close','Total Score Close']]\n",
+    "    odds['Key'] = odds['Date'].astype(str) + odds['Home Team Abbrev'] + odds['Away Team Abbrev']\n",
+    "    odds = odds.drop(columns=['Date','Home Team Abbrev','Away Team Abbrev']).dropna()\n",
+    "    odds['Home Odds'] = [round((i-1)*100) if i>= 2 else round(-100/(i-1)) for i in odds['Home Odds Close']]\n",
+    "    odds['Away Odds'] = [round((i-1)*100) if i>= 2 else round(-100/(i-1)) for i in odds['Away Odds Close']]\n",
+    "    odds['Home Winnings'] = [ho-1 if h>a else -1 if a>h else 0 for ho,h,a in odds[['Home Odds Close','Home Score','Away Score']].values]\n",
+    "    odds['Away Winnings'] = [ao-1 if a>h else -1 if h>a else 0 for ao,h,a in odds[['Away Odds Close','Home Score','Away Score']].values]\n",
+    "\n",
+    "    # merge with gbg\n",
+    "    gbg['Key'] = gbg['game_date'].astype(str) + gbg['home_team'] + gbg['away_team']\n",
+    "    gbg_and_odds = gbg.merge(odds, left_on='Key', right_on='Key')\n",
+    "    gbg_and_odds['Home-Team-Win'] = (gbg_and_odds['Home Score']>gbg_and_odds['Away Score']).astype(int)\n",
+    "    gbg_and_odds['Over'] = ((gbg_and_odds['Home Score'] + gbg_and_odds['Away Score'])>gbg_and_odds['Total Score Close']).astype(int)\n",
+    "    gbg_and_odds.to_csv('gbg_and_odds.csv')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ML"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 196,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 100/100 [01:15<00:00,  1.33it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best accuracy: 75.4%\n",
+      "Done\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import xgboost as xgb\n",
+    "import pickle as pkl\n",
+    "from IPython.display import clear_output\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "data = pd.read_csv('gbg_and_odds.csv', index_col=0).dropna()\n",
+    "\n",
+    "margin = data['Home-Team-Win']\n",
+    "data.drop(columns=['Home-Team-Win','Over','Season','home_team','away_team','game_date','Key','Home Score','Away Score','Home Odds Close','Away Odds Close','Home Winnings','Away Winnings'], inplace=True)\n",
+    "\n",
+    "acc_results = []\n",
+    "for x in tqdm(range(100)):\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(data, margin, test_size=.1)\n",
+    "\n",
+    "    train_games = X_train['game_id']\n",
+    "    test_games = X_test['game_id']\n",
+    "\n",
+    "    X_train.drop(columns=['game_id'], inplace=True)\n",
+    "    X_test.drop(columns=['game_id'], inplace=True)\n",
+    "\n",
+    "    train = xgb.DMatrix(X_train.astype(float).values, label=y_train)\n",
+    "    test = xgb.DMatrix(X_test.astype(float).values, label=y_test)\n",
+    "\n",
+    "    param = {\n",
+    "        'max_depth': 2,\n",
+    "        'eta': 0.01,\n",
+    "        'objective': 'multi:softprob',\n",
+    "        'num_class': 2\n",
+    "    }\n",
+    "    epochs = 500\n",
+    "\n",
+    "    model = xgb.train(param, train, epochs)\n",
+    "    predictions = model.predict(test)\n",
+    "    y = []\n",
+    "    for z in predictions:\n",
+    "        y.append(np.argmax(z))\n",
+    "\n",
+    "    acc = round(accuracy_score(y_test, y)*100, 1)\n",
+    "    acc_results.append(acc)\n",
+    "    clear_output(wait=True)\n",
+    "    print(f\"Best accuracy: {max(acc_results)}%\")\n",
+    "\n",
+    "    # only save results if they are the best so far\n",
+    "    if acc == max(acc_results):\n",
+    "        with open('train_games_ML.pkl','wb') as f:\n",
+    "            pkl.dump(train_games,f)\n",
+    "        with open('test_games_ML.pkl','wb') as f:\n",
+    "            pkl.dump(test_games,f)\n",
+    "        model.save_model(f'models/xgboost_ML_{acc}%.json')\n",
+    "\n",
+    "print('Done')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 203,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import xgboost as xgb\n",
+    "xgb_ml = xgb.Booster()\n",
+    "xgb_ml.load_model('models/xgboost_ML_75.4%.json')\n",
+    "\n",
+    "with open('test_games_ML.pkl','rb') as f:\n",
+    "    test_games = pkl.load(f).tolist()\n",
+    "\n",
+    "gbg_and_odds = pd.read_csv('gbg_and_odds.csv', index_col=0)\n",
+    "test_data = gbg_and_odds.loc[gbg_and_odds['game_id'].isin(test_games)]\n",
+    "test_data_matrix = xgb.DMatrix(test_data.drop(columns=['game_id','Over','Home-Team-Win','Season','home_team','away_team','game_date','Key','Home Score','Away Score','Home Odds Close','Away Odds Close','Home Winnings','Away Winnings']).astype(float).values)\n",
+    "\n",
+    "predicted_probas = xgb_ml.predict(test_data_matrix)\n",
+    "predictions = np.argmax(predicted_probas, axis=1)\n",
+    "test_data['predicted_proba'] = [i[1] for i in predicted_probas]\n",
+    "test_data['prediction'] = (test_data['predicted_proba']>0.5).astype(int)\n",
+    "test_data['correct'] = test_data['Home-Team-Win']==test_data['prediction']\n",
+    "test_data['home_ev'] = [((h-1)*p)+((-1)*p-1) for h,a,p in test_data[['Home Odds Close','Away Odds Close','predicted_proba']].values]\n",
+    "test_data['away_ev'] = [((-1)*p)+((a-1)*p-1) for h,a,p in test_data[['Home Odds Close','Away Odds Close','predicted_proba']].values]\n",
+    "\n",
+    "bets = test_data.loc[(test_data['predicted_proba']>0.6) | (test_data['predicted_proba']<0.4)]\n",
+    "bets['winnings'] = [h if he>ae else a for h,a,he,ae in bets[['Home Winnings','Away Winnings','home_ev','away_ev']].values]\n",
+    "bets['winnings'] = [h if c else a for h,a,c in bets[['Home Winnings','Away Winnings','correct']].values]\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.plot(bets['winnings'].cumsum().values*100, linewidth=3)\n",
+    "plt.title('MARCI 3.0 - MoneyLine w/ 10% Threshold')\n",
+    "plt.xlabel('Games Bet On')\n",
+    "plt.ylabel('Return (%)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## OU"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 204,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 100/100 [02:17<00:00,  1.37s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best accuracy: 59.3%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import xgboost as xgb\n",
+    "import pickle as pkl\n",
+    "from IPython.display import clear_output\n",
+    "from sklearn.metrics import accuracy_score\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "data = pd.read_csv('gbg_and_odds.csv', index_col=0).dropna()\n",
+    "\n",
+    "OU = data['Over']\n",
+    "data.drop(columns=['Home-Team-Win','Over','Season','home_team','away_team','game_date','Key','Home Score','Away Score','Home Odds Close','Away Odds Close','Home Winnings','Away Winnings'], inplace=True)\n",
+    "\n",
+    "acc_results = []\n",
+    "\n",
+    "for x in tqdm(range(100)):\n",
+    "    X_train, X_test, y_train, y_test = train_test_split(data, OU, test_size=.1)\n",
+    "\n",
+    "    train_games = X_train['game_id']\n",
+    "    test_games = X_test['game_id']\n",
+    "\n",
+    "    X_train.drop(columns=['game_id'], inplace=True)\n",
+    "    X_test.drop(columns=['game_id'], inplace=True)\n",
+    "\n",
+    "    train = xgb.DMatrix(X_train.astype(float).values, label=y_train)\n",
+    "    test = xgb.DMatrix(X_test.astype(float).values, label=y_test)\n",
+    "\n",
+    "    param = {\n",
+    "        'max_depth': 6,\n",
+    "        'eta': 0.05,\n",
+    "        'objective': 'multi:softprob',\n",
+    "        'num_class': 3\n",
+    "    }\n",
+    "    epochs = 300\n",
+    "\n",
+    "    model = xgb.train(param, train, epochs)\n",
+    "\n",
+    "    predictions = model.predict(test)\n",
+    "    y = []\n",
+    "\n",
+    "    for z in predictions:\n",
+    "        y.append(np.argmax(z))\n",
+    "\n",
+    "    acc = round(accuracy_score(y_test, y)*100, 1)\n",
+    "    acc_results.append(acc)\n",
+    "    clear_output(wait=True)\n",
+    "    print(f\"Best accuracy: {max(acc_results)}%\")\n",
+    "    \n",
+    "    # only save results if they are the best so far\n",
+    "    if acc == max(acc_results):\n",
+    "        with open('train_games_OU.pkl','wb') as f:\n",
+    "            pkl.dump(train_games,f)\n",
+    "        with open('test_games_OU.pkl','wb') as f:\n",
+    "            pkl.dump(test_games,f)\n",
+    "        model.save_model(f'models/xgboost_OU_{acc}%.json')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 207,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import xgboost as xgb\n",
+    "xgb_ou = xgb.Booster()\n",
+    "xgb_ou.load_model('models/xgboost_OU_59.3%.json')\n",
+    "\n",
+    "with open('test_games_OU.pkl','rb') as f:\n",
+    "    test_games = pkl.load(f).tolist()\n",
+    "\n",
+    "gbg_and_odds = pd.read_csv('gbg_and_odds.csv', index_col=0)\n",
+    "test_data = gbg_and_odds.loc[gbg_and_odds['game_id'].isin(test_games)]\n",
+    "test_data_matrix = xgb.DMatrix(test_data.drop(columns=['game_id','Over','Home-Team-Win','Season','home_team','away_team','game_date','Key','Home Score','Away Score','Home Odds Close','Away Odds Close','Home Winnings','Away Winnings']).astype(float).values)\n",
+    "\n",
+    "predicted_probas = xgb_ou.predict(test_data_matrix)\n",
+    "predictions = np.argmax(predicted_probas, axis=1)\n",
+    "test_data['predicted_proba'] = [i[1] for i in predicted_probas]\n",
+    "test_data['prediction'] = (test_data['predicted_proba']>0.5).astype(int)\n",
+    "test_data['correct'] = test_data['Over']==test_data['prediction']\n",
+    "\n",
+    "bets = test_data\n",
+    "bets['winnings'] = [0.91 if c else -1 for c in bets[['correct']].values]\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.plot(bets['winnings'].cumsum().values*100, linewidth=3)\n",
+    "plt.title('MARCI 3.0 - Over/Under')\n",
+    "plt.xlabel('Games Bet On')\n",
+    "plt.ylabel('Return (%)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 321,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Brayden\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python311\\site-packages\\dateutil\\parser\\_parser.py:1207: UnknownTimezoneWarning: tzname EST identified but not understood.  Pass `tzinfos` argument in order to correctly return a timezone-aware datetime.  In a future version, this will raise an exception.\n",
+      "  warnings.warn(\"tzname {tzname} identified but not understood.  \"\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Away TeamAway Team</th>\n",
+       "      <th>Home TeamHome Team</th>\n",
+       "      <th>Game TimeGame Time</th>\n",
+       "      <th>NetworkNetwork</th>\n",
+       "      <th>VenueVenue</th>\n",
+       "      <th>Away Team</th>\n",
+       "      <th>Home Team</th>\n",
+       "      <th>Date</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>DET Detroit Lions</td>\n",
+       "      <td>KC Kansas City Chiefs</td>\n",
+       "      <td>09/07/23 8:20 PM EST</td>\n",
+       "      <td>NBC</td>\n",
+       "      <td>GEHA Field at Arrowhead Stadium</td>\n",
+       "      <td>Detroit Lions</td>\n",
+       "      <td>Kansas City Chiefs</td>\n",
+       "      <td>Thursday 7/9 08:20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>CIN Cincinnati Bengals</td>\n",
+       "      <td>CLE Cleveland Browns</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>CBS</td>\n",
+       "      <td>Cleveland Browns Stadium</td>\n",
+       "      <td>Cincinnati Bengals</td>\n",
+       "      <td>Cleveland Browns</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Jax Jacksonville Jaguars</td>\n",
+       "      <td>IND Indianapolis Colts</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>FOX</td>\n",
+       "      <td>Lucas Oil Stadium</td>\n",
+       "      <td>Jacksonville Jaguars</td>\n",
+       "      <td>Indianapolis Colts</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>TB Tampa Bay Buccaneers</td>\n",
+       "      <td>MIN Minnesota Vikings</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>CBS</td>\n",
+       "      <td>U.S. Bank Stadium</td>\n",
+       "      <td>Tampa Bay Buccaneers</td>\n",
+       "      <td>Minnesota Vikings</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>TEN Tennessee Titans</td>\n",
+       "      <td>NO New Orleans Saints</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>CBS</td>\n",
+       "      <td>Caesars Superdome</td>\n",
+       "      <td>Tennessee Titans</td>\n",
+       "      <td>New Orleans Saints</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>CAR Carolina Panthers</td>\n",
+       "      <td>ATL Atlanta Falcons</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>FOX</td>\n",
+       "      <td>Mercedes-Benz Stadium</td>\n",
+       "      <td>Carolina Panthers</td>\n",
+       "      <td>Atlanta Falcons</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>HOU Houston Texans</td>\n",
+       "      <td>BAL Baltimore Ravens</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>CBS</td>\n",
+       "      <td>M&amp;T Bank Stadium</td>\n",
+       "      <td>Houston Texans</td>\n",
+       "      <td>Baltimore Ravens</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>SF San Francisco 49ers</td>\n",
+       "      <td>PIT Pittsburgh Steelers</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>FOX</td>\n",
+       "      <td>Acrisure Stadium</td>\n",
+       "      <td>San Francisco 49ers</td>\n",
+       "      <td>Pittsburgh Steelers</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>ARI Arizona Cardinals</td>\n",
+       "      <td>WAS Washington Commanders</td>\n",
+       "      <td>09/10/23 1:00 PM EST</td>\n",
+       "      <td>FOX</td>\n",
+       "      <td>FedEx Field</td>\n",
+       "      <td>Arizona Cardinals</td>\n",
+       "      <td>Washington Commanders</td>\n",
+       "      <td>Sunday 10/9 01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>GB Green Bay Packers</td>\n",
+       "      <td>CHI Chicago Bears</td>\n",
+       "      <td>09/10/23 4:25 PM EST</td>\n",
+       "      <td>FOX</td>\n",
+       "      <td>Soldier Field</td>\n",
+       "      <td>Green Bay Packers</td>\n",
+       "      <td>Chicago Bears</td>\n",
+       "      <td>Sunday 10/9 04:25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>MIA Miami Dolphins</td>\n",
+       "      <td>LAC Los Angeles Chargers</td>\n",
+       "      <td>09/10/23 4:25 PM EST</td>\n",
+       "      <td>CBS</td>\n",
+       "      <td>SoFi Stadium</td>\n",
+       "      <td>Miami Dolphins</td>\n",
+       "      <td>Los Angeles Chargers</td>\n",
+       "      <td>Sunday 10/9 04:25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>LV Las Vegas Raiders</td>\n",
+       "      <td>DEN Denver Broncos</td>\n",
+       "      <td>09/10/23 4:25 PM EST</td>\n",
+       "      <td>CBS</td>\n",
+       "      <td>Empower Field at Mile High</td>\n",
+       "      <td>Las Vegas Raiders</td>\n",
+       "      <td>Denver Broncos</td>\n",
+       "      <td>Sunday 10/9 04:25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>PHI Philadelphia Eagles</td>\n",
+       "      <td>NE New England Patriots</td>\n",
+       "      <td>09/10/23 4:25 PM EST</td>\n",
+       "      <td>CBS</td>\n",
+       "      <td>Gillette Stadium</td>\n",
+       "      <td>Philadelphia Eagles</td>\n",
+       "      <td>New England Patriots</td>\n",
+       "      <td>Sunday 10/9 04:25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>LAR Los Angeles Rams</td>\n",
+       "      <td>SEA Seattle Seahawks</td>\n",
+       "      <td>09/10/23 4:25 PM EST</td>\n",
+       "      <td>FOX</td>\n",
+       "      <td>Lumen Field</td>\n",
+       "      <td>Los Angeles Rams</td>\n",
+       "      <td>Seattle Seahawks</td>\n",
+       "      <td>Sunday 10/9 04:25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>DAL Dallas Cowboys</td>\n",
+       "      <td>NYG New York Giants</td>\n",
+       "      <td>09/10/23 8:20 PM EST</td>\n",
+       "      <td>NBC, PEAK</td>\n",
+       "      <td>MetLife Stadium</td>\n",
+       "      <td>Dallas Cowboys</td>\n",
+       "      <td>New York Giants</td>\n",
+       "      <td>Sunday 10/9 08:20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>BUF Buffalo Bills</td>\n",
+       "      <td>NYJ New York Jets</td>\n",
+       "      <td>09/11/23 8:15 PM EST</td>\n",
+       "      <td>ESPN, ABC, ESP+</td>\n",
+       "      <td>MetLife Stadium</td>\n",
+       "      <td>Buffalo Bills</td>\n",
+       "      <td>New York Jets</td>\n",
+       "      <td>Monday 11/9 08:15</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          Away TeamAway Team         Home TeamHome Team    Game TimeGame Time  \\\n",
+       "0          DET Detroit Lions      KC Kansas City Chiefs  09/07/23 8:20 PM EST   \n",
+       "1     CIN Cincinnati Bengals       CLE Cleveland Browns  09/10/23 1:00 PM EST   \n",
+       "2   Jax Jacksonville Jaguars     IND Indianapolis Colts  09/10/23 1:00 PM EST   \n",
+       "3    TB Tampa Bay Buccaneers      MIN Minnesota Vikings  09/10/23 1:00 PM EST   \n",
+       "4       TEN Tennessee Titans      NO New Orleans Saints  09/10/23 1:00 PM EST   \n",
+       "5      CAR Carolina Panthers        ATL Atlanta Falcons  09/10/23 1:00 PM EST   \n",
+       "6         HOU Houston Texans       BAL Baltimore Ravens  09/10/23 1:00 PM EST   \n",
+       "7     SF San Francisco 49ers    PIT Pittsburgh Steelers  09/10/23 1:00 PM EST   \n",
+       "8      ARI Arizona Cardinals  WAS Washington Commanders  09/10/23 1:00 PM EST   \n",
+       "9       GB Green Bay Packers          CHI Chicago Bears  09/10/23 4:25 PM EST   \n",
+       "10        MIA Miami Dolphins   LAC Los Angeles Chargers  09/10/23 4:25 PM EST   \n",
+       "11      LV Las Vegas Raiders         DEN Denver Broncos  09/10/23 4:25 PM EST   \n",
+       "12   PHI Philadelphia Eagles    NE New England Patriots  09/10/23 4:25 PM EST   \n",
+       "13      LAR Los Angeles Rams       SEA Seattle Seahawks  09/10/23 4:25 PM EST   \n",
+       "14        DAL Dallas Cowboys        NYG New York Giants  09/10/23 8:20 PM EST   \n",
+       "15         BUF Buffalo Bills          NYJ New York Jets  09/11/23 8:15 PM EST   \n",
+       "\n",
+       "     NetworkNetwork                       VenueVenue             Away Team  \\\n",
+       "0               NBC  GEHA Field at Arrowhead Stadium         Detroit Lions   \n",
+       "1               CBS         Cleveland Browns Stadium    Cincinnati Bengals   \n",
+       "2               FOX                Lucas Oil Stadium  Jacksonville Jaguars   \n",
+       "3               CBS                U.S. Bank Stadium  Tampa Bay Buccaneers   \n",
+       "4               CBS                Caesars Superdome      Tennessee Titans   \n",
+       "5               FOX            Mercedes-Benz Stadium     Carolina Panthers   \n",
+       "6               CBS                 M&T Bank Stadium        Houston Texans   \n",
+       "7               FOX                 Acrisure Stadium   San Francisco 49ers   \n",
+       "8               FOX                      FedEx Field     Arizona Cardinals   \n",
+       "9               FOX                    Soldier Field     Green Bay Packers   \n",
+       "10              CBS                     SoFi Stadium        Miami Dolphins   \n",
+       "11              CBS       Empower Field at Mile High     Las Vegas Raiders   \n",
+       "12              CBS                 Gillette Stadium   Philadelphia Eagles   \n",
+       "13              FOX                      Lumen Field      Los Angeles Rams   \n",
+       "14        NBC, PEAK                  MetLife Stadium        Dallas Cowboys   \n",
+       "15  ESPN, ABC, ESP+                  MetLife Stadium         Buffalo Bills   \n",
+       "\n",
+       "                Home Team                Date  \n",
+       "0      Kansas City Chiefs  Thursday 7/9 08:20  \n",
+       "1        Cleveland Browns   Sunday 10/9 01:00  \n",
+       "2      Indianapolis Colts   Sunday 10/9 01:00  \n",
+       "3       Minnesota Vikings   Sunday 10/9 01:00  \n",
+       "4      New Orleans Saints   Sunday 10/9 01:00  \n",
+       "5         Atlanta Falcons   Sunday 10/9 01:00  \n",
+       "6        Baltimore Ravens   Sunday 10/9 01:00  \n",
+       "7     Pittsburgh Steelers   Sunday 10/9 01:00  \n",
+       "8   Washington Commanders   Sunday 10/9 01:00  \n",
+       "9           Chicago Bears   Sunday 10/9 04:25  \n",
+       "10   Los Angeles Chargers   Sunday 10/9 04:25  \n",
+       "11         Denver Broncos   Sunday 10/9 04:25  \n",
+       "12   New England Patriots   Sunday 10/9 04:25  \n",
+       "13       Seattle Seahawks   Sunday 10/9 04:25  \n",
+       "14        New York Giants   Sunday 10/9 08:20  \n",
+       "15          New York Jets   Monday 11/9 08:15  "
+      ]
+     },
+     "execution_count": 321,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "url = 'https://www.nbcsports.com/nfl/schedule'\n",
+    "df = pd.read_html(url)[0]\n",
+    "df['Away Team'] = [' '.join(i.split('\\xa0')[1:]) for i in df['Away TeamAway Team']]\n",
+    "df['Home Team'] = [' '.join(i.split('\\xa0')[1:]) for i in df['Home TeamHome Team']]\n",
+    "df['Date'] = pd.to_datetime(df['Game TimeGame Time'])\n",
+    "df['Date'] = df['Date'].dt.strftime('%A %m/%d %I:%M %p')\n",
+    "df['Date'] = df['Date'].apply(lambda x: f\"{x.split()[0]} {int(x.split()[1].split('/')[1])}/{int(x.split()[1].split('/')[0])} {x.split()[2]}\".capitalize())\n",
+    "\n",
+    "return df[['Away Team','Home Team','Date']]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 243,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Brayden\\AppData\\Local\\Temp\\ipykernel_21628\\2050820634.py:1: DtypeWarning: Columns (181,182,184,185,191,192,195,196,199,200,205,206,207,208,220,221,222,224,226,228,245,246,247,255,256,257,262,264,265,285,286,303) have mixed types. Specify dtype option on import or set low_memory=False.\n",
+      "  pbp = pd.read_csv('Data/pbp_this_year.csv')\n"
+     ]
+    }
+   ],
+   "source": [
+    "pbp = pd.read_csv('Data/pbp_this_year.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 314,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Brayden\\AppData\\Local\\Temp\\ipykernel_21628\\414576273.py:8: DtypeWarning: Columns (181,182,184,185,191,192,195,196,199,200,205,206,207,208,220,221,222,224,226,228,245,246,247,255,256,257,262,264,265,285,286,303) have mixed types. Specify dtype option on import or set low_memory=False.\n",
+      "  pbp = pd.read_csv(file_path)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "current_directory = os.path.dirname('')\n",
+    "parent_directory = os.path.dirname(current_directory)\n",
+    "data_directory = os.path.join(parent_directory, 'Data')\n",
+    "model_directory = os.path.join(parent_directory, 'Models')\n",
+    "\n",
+    "file_path = os.path.join(data_directory, f'pbp_this_year.csv')\n",
+    "pbp = pd.read_csv(file_path)\n",
+    "\n",
+    "def get_one_week(team_name,season,week):\n",
+    "    # create columns\n",
+    "    team = pbp.loc[((pbp['home_team']==team_name) | (pbp['away_team']==team_name)) & (pbp['season']==season)] \n",
+    "    team['GP'] = team['week']\n",
+    "    team['W'] = [1 if r>0 and team_name==h else 1 if r<0 and team_name==a else 0 for r,a,h in team[['result','away_team','home_team']].values]\n",
+    "    team['L'] = [0 if r>0 and team_name==h else 0 if r<0 and team_name==a else 1 for r,a,h in team[['result','away_team','home_team']].values]\n",
+    "    team['W_PCT'] = team['W']/team['GP']\n",
+    "    team['TOP'] = [t if team_name==p else 0 for t,p in team[['TOP_seconds','posteam']].values]\n",
+    "    team['FGA'] = [1 if team_name==p and f==1 else 0 for p,f in team[['posteam','field_goal_attempt']].values]\n",
+    "    team['FGM'] = [1 if team_name==p and f=='made' else 0 for p,f in team[['posteam','field_goal_result']].values]\n",
+    "    team['FG_PCT'] = team['FGM']/team['FGA']\n",
+    "    team['PassTD'] = np.where((team['posteam'] == team_name) & (team['pass_touchdown'] == 1), 1, 0)\n",
+    "    team['RushTD'] = np.where((team['posteam'] == team_name) & (team['rush_touchdown'] == 1), 1, 0)\n",
+    "    team['PassTD_Allowed'] = np.where((team['defteam'] == team_name) & (team['pass_touchdown'] == 1), 1, 0)\n",
+    "    team['RushTD_Allowed'] = np.where((team['defteam'] == team_name) & (team['rush_touchdown'] == 1), 1, 0)\n",
+    "    team['PassYds'] = [y if p==team_name else 0 for p,y in team[['posteam','passing_yards']].values]\n",
+    "    team['RushYds'] = [y if p==team_name else 0 for p,y in team[['posteam','rushing_yards']].values]\n",
+    "    team['PassYds_Allowed'] = [y if d==team_name else 0 for d,y in team[['defteam','passing_yards']].values]\n",
+    "    team['RushYds_Allowed'] = [y if d==team_name else 0 for d,y in team[['defteam','rushing_yards']].values]\n",
+    "    team['Fum'] = np.where((team['defteam'] == team_name) & (team['fumble_lost'] == 1), 1, 0)\n",
+    "    team['Fum_Allowed'] = np.where((team['posteam'] == team_name) & (team['fumble_lost'] == 1), 1, 0)\n",
+    "    team['INT'] = np.where((team['defteam'] == team_name) & (team['interception'] == 1), 1, 0)\n",
+    "    team['INT_Allowed'] = np.where((team['posteam'] == team_name) & (team['interception'] == 1), 1, 0)\n",
+    "    team['Sacks'] = np.where((team['defteam'] == team_name) & (team['sack'] == 1), 1, 0)\n",
+    "    team['Sacks_Allowed'] = np.where((team['posteam'] == team_name) & (team['sack'] == 1), 1, 0)\n",
+    "    team['Penalties'] = np.where((team['penalty_team'] == team_name), 1, 0)\n",
+    "    team['FirstDowns'] = [1 if team_name==p and f==1 else 0 for p,f in team[['posteam','first_down']].values]\n",
+    "    team['3rdDownConverted'] = [1 if p==team_name and t==1 else 0 for p,t in team[['posteam','third_down_converted']].values]\n",
+    "    team['3rdDownFailed'] = [1 if p==team_name and t==1 else 0 for p,t in team[['posteam','third_down_failed']].values]\n",
+    "    team['3rdDownAllowed'] = [1 if d==team_name and t==1 else 0 for d,t in team[['defteam','third_down_converted']].values]\n",
+    "    team['3rdDownDefended'] = [1 if d==team_name and t==1 else 0 for d,t in team[['defteam','third_down_failed']].values]\n",
+    "    team['PTS'] = [ap if at==team_name else hp if ht==team_name else None for ht,at,hp,ap in team[['home_team','away_team','home_score','away_score']].values]\n",
+    "    team['PointDiff'] = [r if team_name==h else -r if team_name==a else 0 for r,a,h in team[['result','away_team','home_team']].values]\n",
+    "\n",
+    "    # aggregate from play-by-play to game-by-game\n",
+    "    features = {\n",
+    "        'GP':'mean',\n",
+    "        'W':'mean',\n",
+    "        'L':'mean',\n",
+    "        'W_PCT':'mean',\n",
+    "        'TOP':'sum',\n",
+    "        'FGA':'sum',\n",
+    "        'FGM':'sum',\n",
+    "        'FG_PCT':'mean',\n",
+    "        'PassTD':'sum',\n",
+    "        'RushTD':'sum',\n",
+    "        'PassTD_Allowed':'sum',\n",
+    "        'RushTD_Allowed':'sum',\n",
+    "        'PassYds':'sum',\n",
+    "        'RushYds':'sum',\n",
+    "        'PassYds_Allowed':'sum',\n",
+    "        'RushYds_Allowed':'sum',\n",
+    "        'Fum':'sum',\n",
+    "        'Fum_Allowed':'sum',\n",
+    "        'INT':'sum',\n",
+    "        'INT_Allowed':'sum',\n",
+    "        'Sacks':'sum',\n",
+    "        'Sacks_Allowed':'sum',\n",
+    "        'Penalties':'sum',\n",
+    "        'FirstDowns':'sum',\n",
+    "        '3rdDownConverted':'sum',\n",
+    "        '3rdDownFailed':'sum',\n",
+    "        '3rdDownAllowed':'sum',\n",
+    "        '3rdDownDefended':'sum',\n",
+    "        'PTS':'mean',\n",
+    "        'PointDiff':'mean'\n",
+    "    }\n",
+    "\n",
+    "    game = team.groupby('game_id').agg(features).reset_index()\n",
+    "    game[['W','L']] = game[['W','L']].expanding().sum()\n",
+    "    game[game.columns[4:]] = game[game.columns[4:]].expanding().mean()\n",
+    "    game['TEAM'] = team_name\n",
+    "    game['Season'] = season\n",
+    "    return game.loc[game['GP']==week]\n",
+    "\n",
+    "\n",
+    "def get_one_week_home_and_away(home,away,season,week):\n",
+    "    home = get_one_week(home,season,week)\n",
+    "    away = get_one_week(away,season,week)\n",
+    "    away.columns = [f'{i}.Away' for i in away.columns]\n",
+    "    gbg = home.merge(away,left_index=True,right_index=True)\n",
+    "    gbg.drop(columns=['TEAM','TEAM.Away','Season.Away','game_id.Away'], inplace=True)\n",
+    "    return gbg\n",
+    "\n",
+    "\n",
+    "def predict(home,away,season,week,total,home_odds,away_odds):\n",
+    "    # finish preparing data\n",
+    "    gbg = get_one_week_home_and_away(home,away,season,week)\n",
+    "    gbg['Total Score Close'] = total\n",
+    "    gbg['Home Odds'] = home_odds\n",
+    "    gbg['Away Odds'] = away_odds\n",
+    "    matrix = xgb.DMatrix(gbg.drop(columns=['game_id','Season']).astype(float).values)\n",
+    "\n",
+    "    # moneyline\n",
+    "    model = 'xgboost_ML_75.4%'\n",
+    "    file_path = os.path.join(model_directory, f'{model}.json')\n",
+    "    xgb_ml = xgb.Booster()\n",
+    "    xgb_ml.load_model(file_path)\n",
+    "    ml_predicted_proba = xgb_ml.predict(matrix)[0][1]\n",
+    "\n",
+    "    # over/under\n",
+    "    model = 'xgboost_OU_59.3%'\n",
+    "    file_path = os.path.join(model_directory, f'{model}.json')\n",
+    "    xgb_ou = xgb.Booster()\n",
+    "    xgb_ou.load_model(file_path)\n",
+    "    ou_predicted_proba = xgb_ou.predict(matrix)[0][1]\n",
+    "\n",
+    "    # return dict\n",
+    "    predictions = {'Moneyline':{\n",
+    "                        home: ml_predicted_proba,\n",
+    "                        away: 1-ml_predicted_proba},\n",
+    "                    'Over/Under':{\n",
+    "                        'Over':ou_predicted_proba,\n",
+    "                        'Under':1-ou_predicted_proba}\n",
+    "                    }\n",
+    "    \n",
+    "    return predictions\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 315,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'Moneyline': {'PHI': 0.4090659, 'KC': 0.5909340977668762},\n",
+       " 'Over/Under': {'Over': 0.8390681, 'Under': 0.16093188524246216}}"
+      ]
+     },
+     "execution_count": 315,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "predict('PHI','KC',2022,22,51,-125,105)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import Source.Build.nfl_data_py.nfl_data_py as nfl\n",
+    "# get team abbreviations\n",
+    "team_descriptions = nfl.import_team_desc()\n",
+    "team_abbreviation_dict = dict(team_descriptions[['team_name','team_abbr']].values)\n",
+    "team_name_dict = dict(team_descriptions[['team_abbr','team_name']].values)\n",
+    "\n",
+    "import pickle as pkl\n",
+    "\n",
+    "with open('Source/Pickles/team_name_to_abbreviation.pkl', 'wb') as f:\n",
+    "    pkl.dump(team_abbreviation_dict,f)\n",
+    "\n",
+    "with open('Source/Pickles/team_abbreviation_to_name.pkl', 'wb') as f:\n",
+    "    pkl.dump(team_name_dict,f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1782"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pickle as pkl\n",
+    "with open('Source/Pickles/train_games_OU.pkl', 'rb') as f:\n",
+    "    train_games_ML = pkl.load(f)\n",
+    "len(train_games_ML)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}