diff --git a/baseball/hit-location-diagram.ipynb b/baseball/hit-location-diagram.ipynb index 3f704ef..d99bd50 100644 --- a/baseball/hit-location-diagram.ipynb +++ b/baseball/hit-location-diagram.ipynb @@ -1,15 +1,40 @@ { "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Baseball hit diagram\n", + "This example notebook uses pandas and matplot to breakdown the most common location for a strike out.\n", + "\n", + "// Need to add more details about how arrays are manipulated to create sections.\n", + "\n", + "// Should we delete the results of python cells so new users don't know the result?" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import needed modules" + ] + }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "ok\n" + "ename": "ModuleNotFoundError", + "evalue": "No module named 'pandas'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mnumpy\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mnp\u001b[39;00m \n\u001b[1;32m----> 2\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mpandas\u001b[39;00m \n\u001b[0;32m 3\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mos\u001b[39;00m\n\u001b[0;32m 4\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mre\u001b[39;00m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'pandas'" ] } ], @@ -26,6 +51,14 @@ "print('ok')" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Back up MLB season from bigdata/baseball" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -53,6 +86,14 @@ "print('ok')" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Breakdown the results of each play" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -133,36 +174,13 @@ ] }, { - "cell_type": "code", - "execution_count": 4, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# Total events in 2022: 214,038\n", - "# \n", - "# event_type\n", - "# Field out 82804\n", - "# Strikeout 40812\n", - "# Field hit 34460\n", - "# No play 26673\n", - "# Walk 16973\n", - "# Non-batter event 5278\n", - "# Home run 5215\n", - "# Error 1118\n", - "# Fielders choice 705\n", - "# dtype: int64\n", - "\n", - "\n", - "# batter_hand (overall)\n", - "# R 128878\n", - "# L 85160\n", - "# dtype: int64\n", - "\n", - "\n", - "# batter_hand (on fielder outs)\n", - "# R 49731\n", - "# L 33073\n", - "# dtype: int64" + "# Filter out \"\" plays\n", + "\n", + "TODO(KoT17): Breakdown of what each acronym means" ] }, { @@ -226,93 +244,69 @@ "print('loading out info for field outs...')\n", "events_df.loc[events_df['event_type'] == 'Field out', 'out_info'] = events_df[events_df['event_type'] == 'Field out']['theplay'].apply(lambda x: '/'.join(str(x).split('/')[1:]))\n", "\n", - "\n", - "# print(events_df.loc[14890286]['out_info'])\n", - "# print(events_df.loc[12601834]['out_info'])\n", - "\n", "dp_re = re.compile('(\\/)*(L|G|N)*(D|T)+(P)+(\\/)*')\n", "ix = events_df[\n", " (events_df['event_type'] == 'Field out') \n", " & (events_df['out_info'].apply(lambda x: re.search(dp_re, str(x)) != None))\n", "].index\n", - "# yix = events_df[events_df.index.isin(ix)].sample(10).index\n", - "# print(events_df[events_df.index.isin(yix)]['out_info'])\n", "\n", "print('\\n')\n", "print('removing (N)DP/TP (n = {0:,.0f})...'.format(len(ix)))\n", "events_df.loc[ix, 'edited'] = True\n", "events_df.loc[ix, 'out_info'] = events_df[events_df.index.isin(ix)\n", " ]['out_info'].apply(lambda x: re.sub(dp_re, '', str(x)))\n", - "#print('----------------------------------------------')\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", "\n", "int_re = re.compile('(\\/)*(R|B)*(INT)+(\\/)*')\n", "ix = events_df[\n", " (events_df['event_type'] == 'Field out') \n", " & (events_df['out_info'].apply(lambda x: re.search(int_re, str(x)) != None))\n", "].index\n", - "print('removing INT (n = {0:,.0f})...'.format(len(ix)))\n", - "# yix = events_df[events_df.index.isin(ix)].sample(10).index\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", "\n", + "print('removing INT (n = {0:,.0f})...'.format(len(ix)))\n", "events_df.loc[ix, 'edited'] = True\n", "events_df.loc[ix, 'out_info'] = events_df[events_df.index.isin(ix)\n", - " ]['out_info'].apply(lambda x: re.sub(int_re, '', str(x)))# print('----------------------------------------------')\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", + " ]['out_info'].apply(lambda x: re.sub(int_re, '', str(x)))\n", "\n", "fo_re = re.compile('(\\/)*(FO)+(\\/)*')\n", "ix = events_df[\n", " (events_df['event_type'] == 'Field out') \n", " & (events_df['out_info'].apply(lambda x: re.search(fo_re, str(x)) != None))\n", "].index\n", - "print('removing FO (n = {0:,.0f})...'.format(len(ix)))\n", - "yix = events_df[events_df.index.isin(ix)].sample(10).index\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", "\n", + "print('removing FO (n = {0:,.0f})...'.format(len(ix)))\n", "events_df.loc[ix, 'edited'] = True\n", "events_df.loc[ix, 'out_info'] = events_df[events_df.index.isin(ix)\n", - " ]['out_info'].apply(lambda x: re.sub(fo_re, '', str(x)))# print('----------------------------------------------')\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", + " ]['out_info'].apply(lambda x: re.sub(fo_re, '', str(x)))\n", "\n", "if_sf_re = re.compile('(\\/)*(IF|SF|SH)+(\\/)*')\n", "ix = events_df[(events_df['event_type'] == 'Field out') & (events_df['out_info'].apply(lambda x: re.search(if_sf_re, str(x)) != None))].index\n", + "\n", "print('removing IF/SF/SH (n = {0:,.0f})...'.format(len(ix)))\n", - "yix = events_df[events_df.index.isin(ix)].sample(10).index\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", "events_df.loc[ix, 'edited'] = True\n", "events_df.loc[ix, 'out_info'] = events_df[events_df.index.isin(ix)\n", - " ]['out_info'].apply(lambda x: re.sub(if_sf_re, '', str(x)))# print('----------------------------------------------')\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", + " ]['out_info'].apply(lambda x: re.sub(if_sf_re, '', str(x)))\n", "\n", "fl_re = re.compile('(\\/)*(FL)+(\\/)*')\n", "ix = events_df[\n", " (events_df['event_type'] == 'Field out') \n", " & (events_df['out_info'].apply(lambda x: re.search(fl_re, str(x)) != None))\n", "].index\n", - "yix = events_df[events_df.index.isin(ix)].sample(10).index\n", - "#print('\\n')\n", + "\n", "print('removing FL (n = {0:,.0f})...'.format(len(ix)))\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", "events_df.loc[ix, 'edited'] = True\n", "events_df.loc[ix, 'out_info'] = events_df[events_df.index.isin(ix)\n", - " ]['out_info'].apply(lambda x: re.sub(fl_re, '', str(x)))# print('----------------------------------------------')\n", - "# #print('-------------------------------')\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", + " ]['out_info'].apply(lambda x: re.sub(fl_re, '', str(x)))\n", "\n", "th_re = re.compile('(\\/)*(TH)+(\\/)*')\n", "ix = events_df[\n", " (events_df['event_type'] == 'Field out') \n", " & (events_df['out_info'].apply(lambda x: re.search(th_re, str(x)) != None))\n", "].index\n", - "#yix = events_df[events_df.index.isin(ix)].index\n", - "#print('\\n')\n", + "\n", "print('removing TH (n = {0:,.0f})...'.format(len(ix)))\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", "events_df.loc[ix, 'edited'] = True\n", "events_df.loc[ix, 'out_info'] = events_df[events_df.index.isin(ix)\n", - " ]['out_info'].apply(lambda x: re.sub(th_re, '', str(x)))# print('----------------------------------------------')\n", - "# #print('-------------------------------')\n", - "#print(events_df[events_df.index.isin(yix)]['out_info'])\n", + " ]['out_info'].apply(lambda x: re.sub(th_re, '', str(x)))\n", "\n", "ix = events_df[events_df['theplay'] == '54/SH/25'].index\n", "print('removing some special cases (n = {0:,.0f})...'.format(len(ix)))\n", @@ -346,10 +340,15 @@ "\n", "e = time.time()\n", "print('\\n')\n", - "print('Done in {0:.0f} seconds!'.format(e-s))\n", - "\n", - "\n", - "events_df[(events_df['event_type'] == 'Field out') & (events_df['edited'] == False)]['out_info']\n" + "print('Done in {0:.0f} seconds!'.format(e-s))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Determine the out type and location" ] }, { @@ -390,9 +389,15 @@ "\n", "e = time.time()\n", "print('\\n')\n", - "print('Done in {0:.0f} seconds!'.format(e-s))\n", - "\n", - "#events_df[(events_df['event_type'] == 'Field out') & (events_df['out_info'].apply(lambda x: len(str(x)) > 1))]['out_info'].apply(lambda x: )" + "print('Done in {0:.0f} seconds!'.format(e-s))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Populate plot with amount of outs" ] }, { @@ -523,8 +528,8 @@ " if (not(np.isnan(rightdata[i,j]))):\n", " rightsumtotal += rightdata[i,j]\n", " \n", - "print('\\tn = {0:,.0f}'.format(rightsumtotal))\n", - "print('\\t\\tChecksum = {0:,.0f}'.format(rdf.to_numpy().sum()))\n", + "print('n = {0:,.0f}'.format(rightsumtotal))\n", + "print('Checksum = {0:,.0f}'.format(rdf.to_numpy().sum()))\n", "\n", "\n", "print('\\n')\n", @@ -597,123 +602,17 @@ "rightdata_bk = rightdata\n", "leftdata_bk = leftdata\n", "\n", - "print('\\tn = {0:,.0f}'.format(leftsumtotal))\n", - "print('\\t\\tChecksum = {0:,.0f}'.format(ldf.to_numpy().sum()))\n", + "print('n = {0:,.0f}'.format(leftsumtotal))\n", + "print('Checksum = {0:,.0f}'.format(ldf.to_numpy().sum()))\n", "\n" ] }, { - "cell_type": "code", - "execution_count": 9, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ok\n" - ] - } - ], "source": [ - "def heatmap(data, ax=None,\n", - " cbar_kw=None, cbarlabel=\"\", **kwargs):\n", - " \"\"\"\n", - " Create a heatmap from a numpy array and two lists of labels.\n", - "\n", - " Parameters\n", - " ----------\n", - " data\n", - " A 2D numpy array of shape (M, N).\n", - " row_labels\n", - " A list or array of length M with the labels for the rows.\n", - " col_labels\n", - " A list or array of length N with the labels for the columns.\n", - " ax\n", - " A `matplotlib.axes.Axes` instance to which the heatmap is plotted. If\n", - " not provided, use current axes or create a new one. Optional.\n", - " cbar_kw\n", - " A dictionary with arguments to `matplotlib.Figure.colorbar`. Optional.\n", - " cbarlabel\n", - " The label for the colorbar. Optional.\n", - " **kwargs\n", - " All other arguments are forwarded to `imshow`.\n", - " \"\"\"\n", - "\n", - " if ax is None:\n", - " ax = plt.gca()\n", - "\n", - " if cbar_kw is None:\n", - " cbar_kw = {}\n", - "\n", - " # Plot the heatmap\n", - " im = ax.imshow(data, **kwargs)\n", - "\n", - " # Create colorbar\n", - " cbar = ax.figure.colorbar(im, ax=ax, **cbar_kw)\n", - " cbar.ax.set_xlabel(cbarlabel)\n", - "\n", - " return im, cbar\n", - "\n", - "\n", - "def annotate_heatmap(im, data=None, valfmt=\"{x:.2f}\",\n", - " textcolors=(\"black\", \"white\"),\n", - " threshold=None, **textkw):\n", - " \"\"\"\n", - " A function to annotate a heatmap.\n", - "\n", - " Parameters\n", - " ----------\n", - " im\n", - " The AxesImage to be labeled.\n", - " data\n", - " Data used to annotate. If None, the image's data is used. Optional.\n", - " valfmt\n", - " The format of the annotations inside the heatmap. This should either\n", - " use the string format method, e.g. \"$ {x:.2f}\", or be a\n", - " `matplotlib.ticker.Formatter`. Optional.\n", - " textcolors\n", - " A pair of colors. The first is used for values below a threshold,\n", - " the second for those above. Optional.\n", - " threshold\n", - " Value in data units according to which the colors from textcolors are\n", - " applied. If None (the default) uses the middle of the colormap as\n", - " separation. Optional.\n", - " **kwargs\n", - " All other arguments are forwarded to each call to `text` used to create\n", - " the text labels.\n", - " \"\"\"\n", - "\n", - " if not isinstance(data, (list, np.ndarray)):\n", - " data = im.get_array()\n", - "\n", - " # Normalize the threshold to the images color range.\n", - " if threshold is not None:\n", - " threshold = im.norm(threshold)\n", - " else:\n", - " threshold = im.norm(data.max())/2.\n", - "\n", - " # Set default alignment to center, but allow it to be\n", - " # overwritten by textkw.\n", - " kw = dict(horizontalalignment=\"center\",\n", - " verticalalignment=\"center\")\n", - " kw.update(textkw)\n", - "\n", - " # Get the formatter in case a string is supplied\n", - " if isinstance(valfmt, str):\n", - " valfmt = mpl.ticker.StrMethodFormatter(valfmt)\n", - "\n", - " # Loop over the data and create a `Text` for each \"pixel\".\n", - " # Change the text's color depending on the data.\n", - " texts = []\n", - " for i in range(data.shape[0]):\n", - " for j in range(data.shape[1]):\n", - " kw.update(color=textcolors[int(im.norm(data[i, j]) > threshold)])\n", - " text = im.axes.text(j, i, valfmt(data[i, j], None), **kw)\n", - " texts.append(text)\n", - "\n", - " return texts\n", - "print('ok')" + "# Plot out heatmap for left and right handed batters" ] }, { @@ -723,7 +622,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -744,7 +643,7 @@ "oflabels = ['', '7LF', '7L', '7', '78', '8', '89', '9', '9L', '9LF']\n", "iflabels = ['5F', '5', '56', '6', '6M', '4M', '4', '34', '3', '3F']\n", "\n", - "im, _ = heatmap(leftdata, ax=ax,\n", + "im, _ = plt.heatmap(leftdata, ax=ax,\n", " cmap=cmapname, cbarlabel=\"Outs to sector\")#, cbar_kw={'location': 'bottom'})\n", "#annotate_heatmap(im, valfmt=\"{x:.0f}\", size=7, textcolors=thelabelcolors)\n", "\n", @@ -753,7 +652,7 @@ "#ax.spines[:].set_visible(False)\n", "ax.set_title('LEFT-handed batters')\n", "\n", - "im, _ = heatmap(rightdata, ax=ax2,\n", + "im, _ = plt.heatmap(rightdata, ax=ax2,\n", " cmap=cmapname, cbarlabel=\"Outs to sector\")#, cbar_kw={'location': 'bottom'})\n", "#annotate_heatmap(im, valfmt=\"{x:.0f}\", size=7, textcolors=thelabelcolors)\n", "\n", @@ -777,9 +676,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8 (py38)", + "display_name": "Python 3", "language": "python", - "name": "py38" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -791,7 +690,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.0" + }, + "vscode": { + "interpreter": { + "hash": "a8712b7f88d470a3450a2747036c2653d8e7da53ae1b559f2a80ca921b7ec002" + } } }, "nbformat": 4,