From a1523dbc2a18987474b532b12635216dfe65cb59 Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Tue, 22 Aug 2023 15:10:05 -0500 Subject: [PATCH 01/12] minor edits and adding barcharts --- textbook/16/1/background.ipynb | 4 +- textbook/16/2/investigation.ipynb | 313 +++++++++++++++++++++--------- 2 files changed, 224 insertions(+), 93 deletions(-) diff --git a/textbook/16/1/background.ipynb b/textbook/16/1/background.ipynb index 7c7a0ead..9455b2c6 100644 --- a/textbook/16/1/background.ipynb +++ b/textbook/16/1/background.ipynb @@ -8,7 +8,9 @@ "\n", "Beginning in 2004, the Illlinois Department of Transportation (IDOT) began a statistical study of traffic and pedestrian stops throughout Illinois [^*]. This study has been extended multiple times and continues as of the writing of this chapter. After the institution of the Racial Profiling Prevention and Data Oversight Board in 2008, the collection of racial profiling information as a part of this study was improved and became an additional focus of the study [^**].\n", "\n", - "In our investigation, we will use data for traffic stops in 2020 in the City of Chicago collected by IDOT and used for Illinois Traffic and Pedestrian Stop Study (made available by request [^***]). We will conduct an analysis similar to that done in the IDOT statistical study called **benchmarking**. Benchmarking involves comparing proportions of the population who are stopped by police to the proportions of the total population those groups make up. The idea is that if 30% of those who are stopped by police are Hispanic or Latino and the population of the area is also 30% Hispanic or Latino, there is no bias present. However, if the population of the area is only 10% Hispanic or Latino, this group is being stopped as a rate disproportionate to its population proportion indicating potential bias.\n", + "In our investigation, we will use data for traffic stops in 2020 in the City of Chicago collected by IDOT and used for Illinois Traffic and Pedestrian Stop Study (made available by request [^***]). The subset of data used here includes 7 variables collected by the officer at the time of the traffic stop including: when and where the stop was made, the reason for the stop, the perceived race of the driver, whether the officer searched the car or its passengers, and, if so, whether the officer found any contraband during that search.\n", + "\n", + "We will conduct an analysis similar to that done in the IDOT statistical study called **benchmarking**. Benchmarking involves comparing proportions of the population who are stopped by police to the proportions of the local population those groups make up. The idea is that if 30% of those who are stopped by police are Hispanic or Latino and the population of the area is also 30% Hispanic or Latino, there is no bias present. However, if the population of the area is only 10% Hispanic or Latino, this group is being stopped as a rate disproportionate to its population proportion indicating potential bias.\n", "\n", "Benchmarking works well only if the benchmark used for comparison is accurate. In this case, we are considering drivers who are stopped by police. The best comparison to use would be the total population of *drivers*. However, this information is not freely available. It can, however, be estimated using additional data and knowledge of probability. IDOT did exactly this in their recent 2019 and 2020 traffic stop report which can be found [here](https://idot.illinois.gov/transportation-system/local-transportation-partners/law-enforcement/reporting/illinois-traffic-and-pedestrian-stop-study/studies.html). We have already done this estimation and will be using the estimated population of drivers by race for our investigation." ] diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index e4dbc829..1b08d7a1 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 28, "metadata": { "tags": [ "remove-cell" @@ -10,7 +10,12 @@ }, "outputs": [], "source": [ - "import pandas as pd" + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use('fivethirtyeight')" ] }, { @@ -24,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -121,7 +126,7 @@ "4 2019 moving 0 0 hispanic 2423 24" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -133,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -142,7 +147,7 @@ "(925805, 7)" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -155,12 +160,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Our dataset has 7 columns and 925,805 rows where each row is a traffic stop that occurred in Chicago." + "Our dataset has 7 columns and 925,805 rows where each row is a traffic stop that occurred in Chicago. \n", + "\n", + "The 7 variables can be described as follows:\n", + "- `year` - the year the traffic stop happened\n", + "- `reason` - the reason for the stop, one of: moving, equipment, liscence, or none\n", + "- `any_search` - a boolean variable indicating whether (1) or not (0) the car or any of its passengers were searched during the traffic stop\n", + "- `search_hit` - a boolean variable indicating whether (1) or not (0) anything illegal was found during a search (value is 0 if no search was conducted)\n", + "- `driver_race` - perceived race of the driver as reported by the officer, one of: black, white, hispanic, asian, am_indian, or other\n", + "- `beat` - the police beat in which the traffic stop occurred (first 2 digits indicate the surrounding police district)\n", + "- `district` - the police district in which the traffic stop occurred\n", + "\n", + "Let's look at these variables more closely." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -169,7 +185,7 @@ "array([2019, 2020])" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -187,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -284,7 +300,7 @@ "4 2020 moving 0 0 black 2011 20" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -296,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -305,7 +321,7 @@ "(327290, 7)" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -323,7 +339,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -356,7 +372,7 @@ "Name: reason, dtype: int64" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -374,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -388,7 +404,7 @@ "Name: district, dtype: int64" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -415,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -545,7 +561,7 @@ "[327290 rows x 4 columns]" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -561,12 +577,12 @@ "source": [ "Recall, we also could have selected only the columns we wanted instead of dropping the columns we didn't need (see [Chapter 6](../../06/DataFrames.ipynb)).\n", "\n", - "Now, let's group the data by `driver_race` and count how many drivers of each race were stopped." + "Now, let's group the data by `driver_race` and count how many drivers of each race were stopped in 2020." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -639,7 +655,7 @@ "5 white 35053" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -653,12 +669,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "From this table, it certainly looks like more Black and Hispanic drivers were stopped in 2020 than drivers of other races. However, we are only looking at raw counts. It will be easier to see a pattern if we convert these counts to a proportion of total stops." + "From this table, it certainly looks like more Black and Hispanic drivers were stopped in 2020 than drivers of other races. However, we are only looking at raw counts. It will be easier to see a pattern if we convert these counts to a proportion of total stops and then visualize the data." ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -738,7 +754,7 @@ "5 white 35053 0.107101" ] }, - "execution_count": 33, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -748,11 +764,34 @@ "stopped" ] }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(stopped['driver_race'], stopped[\"prop_stopped\"])\n", + "plt.xlabel(\"Driver's Race\")\n", + "plt.ylabel(\"Proportion of Stops\")\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now, we can see that 62% of drivers stopped were Black, 24% were Hispanic, and 11% were White." + "Now, we can see that approximately 62% of drivers stopped were Black, 24% were Hispanic, and 11% were White." ] }, { @@ -766,7 +805,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -863,7 +902,7 @@ "4 1913 739.593202 2429.896179 535.721544 121.083960 159.015646 0.0" ] }, - "execution_count": 45, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -882,7 +921,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -961,7 +1000,7 @@ "6 Other 212.537290" ] }, - "execution_count": 60, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -980,7 +1019,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1006,7 +1045,6 @@ " \n", " driver_race\n", " est_pop\n", - " prop_pop\n", " \n", " \n", " \n", @@ -1014,53 +1052,47 @@ " 1\n", " White\n", " 298755.197477\n", - " 0.255627\n", " \n", " \n", " 2\n", " Black\n", " 248709.530847\n", - " 0.212806\n", " \n", " \n", " 3\n", " Hispanic\n", " 222341.224432\n", - " 0.190244\n", " \n", " \n", " 4\n", " Asian\n", " 60069.768541\n", - " 0.051398\n", " \n", " \n", " 5\n", " Native\n", " 2664.876752\n", - " 0.002280\n", " \n", " \n", " 6\n", " Other\n", " 212.537290\n", - " 0.000182\n", " \n", " \n", "\n", "" ], "text/plain": [ - " driver_race est_pop prop_pop\n", - "1 White 298755.197477 0.255627\n", - "2 Black 248709.530847 0.212806\n", - "3 Hispanic 222341.224432 0.190244\n", - "4 Asian 60069.768541 0.051398\n", - "5 Native 2664.876752 0.002280\n", - "6 Other 212.537290 0.000182" + " driver_race est_pop\n", + "1 White 298755.197477\n", + "2 Black 248709.530847\n", + "3 Hispanic 222341.224432\n", + "4 Asian 60069.768541\n", + "5 Native 2664.876752\n", + "6 Other 212.537290" ] }, - "execution_count": 62, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1079,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1159,7 +1191,7 @@ "6 Other 212.537290 0.000255" ] }, - "execution_count": 63, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1173,12 +1205,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We want to compare these proportions with the proportion of stops we calculated above. This is easier to do if they are in the same DataFrame. We can combine them using `merge`, but first, we need to make sure each race has the same name in both DataFrames. One data frame has races capitalized, while the other is all lowercase. Also, one data frame uses the shortened term 'native' while the other uses 'am_indian'. Let's use `.apply` and `.replace` to fix this." + "We want to compare these proportions with the proportion of stops we calculated above. This is easier to do if they are in the same DataFrame. We can combine them using `merge`, but first, we need to make sure each race has the same name in both DataFrames. One DataFrame has races capitalized, while the other is all lowercase. Also, one DataFrame uses the shortened term 'native' while the other uses 'am_indian'. Let's use `.apply` and `.replace` to fix this." ] }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1258,19 +1290,23 @@ "6 other 212.537290 0.000255" ] }, - "execution_count": 66, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "pop_total['driver_race'] = pop_total['driver_race'].apply(lambda x: x.lower())\n", + "def to_lowercase(x):\n", + " '''A function that takes in a string and returns that string converted to all lowercase letters'''\n", + " return x.lower()\n", + "\n", + "pop_total['driver_race'] = pop_total['driver_race'].apply(to_lowercase)\n", "pop_total" ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1350,7 +1386,7 @@ "6 other 212.537290 0.000255" ] }, - "execution_count": 68, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1364,7 +1400,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1458,7 +1494,7 @@ "5 white 35053 0.107101 298755.197477 0.358756" ] }, - "execution_count": 69, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1468,11 +1504,49 @@ "stops_vs_pop" ] }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(len(stops_vs_pop.driver_race)) # the label locations\n", + "width = 0.44 # the width of the bars\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "rects1 = ax.bar(x, round(stops_vs_pop.prop_stopped,2), width, label=\"Proportion of Stops\")\n", + "ax.bar_label(rects1, padding=4)\n", + "\n", + "rects2 = ax.bar(x + width, round(stops_vs_pop.prop_pop,2), width, label=\"Proportion of Population\")\n", + "ax.bar_label(rects2, padding=4)\n", + "\n", + "# Add some text for labels, title and custom x-axis tick labels, etc.\n", + "ax.set_ylabel('Proportion of Stops/Population')\n", + "ax.set_xlabel(\"Driver's Race\")\n", + "ax.set_title('Traffic Stops by Race')\n", + "ax.set_xticks(x + width/2, stops_vs_pop.driver_race)\n", + "ax.legend(loc=4, bbox_to_anchor=(1.3, 0.7))\n", + "\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Using this new table, we can see that American Indian, Hispanic, and Other drivers are all stopped at a proportion that is similar to the proportion of the population they make up. However, Black drivers are stopped twice as often as they should be according to their population, and Asian and White drivers are stopped at rates less than their proportion of the population." + "Using this figure, we can see that American Indian, Hispanic, and Other drivers are all stopped at a proportion that is similar to the proportion of the population they make up. However, Black drivers are stopped twice as often as they should be according to their population, and Asian and White drivers are stopped at rates less than their proportion of the population." ] }, { @@ -1486,7 +1560,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -1566,7 +1640,7 @@ "5 white 190 66" ] }, - "execution_count": 41, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1585,7 +1659,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1612,7 +1686,6 @@ " driver_race\n", " num_searched\n", " num_hit\n", - " prop_hit\n", " prop_searched\n", " \n", " \n", @@ -1622,7 +1695,6 @@ " am_indian\n", " 3\n", " 1\n", - " 0.333333\n", " 0.000590\n", " \n", " \n", @@ -1630,7 +1702,6 @@ " asian\n", " 31\n", " 12\n", - " 0.387097\n", " 0.006101\n", " \n", " \n", @@ -1638,7 +1709,6 @@ " black\n", " 3712\n", " 980\n", - " 0.264009\n", " 0.730565\n", " \n", " \n", @@ -1646,7 +1716,6 @@ " hispanic\n", " 1140\n", " 317\n", - " 0.278070\n", " 0.224365\n", " \n", " \n", @@ -1654,7 +1723,6 @@ " other\n", " 5\n", " 3\n", - " 0.600000\n", " 0.000984\n", " \n", " \n", @@ -1662,7 +1730,6 @@ " white\n", " 190\n", " 66\n", - " 0.347368\n", " 0.037394\n", " \n", " \n", @@ -1670,16 +1737,16 @@ "" ], "text/plain": [ - " driver_race num_searched num_hit prop_hit prop_searched\n", - "0 am_indian 3 1 0.333333 0.000590\n", - "1 asian 31 12 0.387097 0.006101\n", - "2 black 3712 980 0.264009 0.730565\n", - "3 hispanic 1140 317 0.278070 0.224365\n", - "4 other 5 3 0.600000 0.000984\n", - "5 white 190 66 0.347368 0.037394" + " driver_race num_searched num_hit prop_searched\n", + "0 am_indian 3 1 0.000590\n", + "1 asian 31 12 0.006101\n", + "2 black 3712 980 0.730565\n", + "3 hispanic 1140 317 0.224365\n", + "4 other 5 3 0.000984\n", + "5 white 190 66 0.037394" ] }, - "execution_count": 43, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1691,7 +1758,39 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoEAAAHOCAYAAADntdOcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlOUlEQVR4nO3de1zO9/8/8MfVSaWUhVQ6OJPzWYqmnJMoJswwxow+NtscPsYWNmxOH7TMzGmSTauJSIhSznOImVNFhVLSCel0/f7w6/q6dl3V1bvr6qqux/122+3z8X6/3u/X83pd11WPXu+TKCsrSwwiIiIi0iha6i6AiIiIiKofQyARERGRBmIIJCIiItJADIFEREREGoghkIiIiEgDMQQSERERaSCGQCIiIiINxBBIREREpIEYAomIiIg0EEMgERERkQZiCCQiIiLSQAyBJFd+fj4SEhKQn5+v7lLqHI6t6nBsVYdjq1ocX9Xh2JaNIZDKVFxcrO4S6iyOrepwbFWHY6taHF/V4djKxxBIREREpIEYAomIiIg0EEMgERERkQZiCCQiIiLSQAyBRERERBqIIZCIiIhIAzEEEhEREWkghkAiIiIiDcQQSERERKSBGAKJiIiINBBDIBEREZEGYggkIiIi0kAMgUREREQaiCGQiIiISAPpqLsAIqr9THc+UncJbzEE8EzdRQAAsqZZqbsEIqIycSaQiIiISAMxBBIRERFpIIZAIiIiIg3EEEhERESkgRgCiYiIiDQQQyARERGRBmIIJCIiItJADIFEREREGoghkIiIiEgD1ZoQeOXKFYwbNw42NjawtLTEoEGDEBISovD2nTp1gqmpabn/nT17VoWvgIiIiKjmqBWPjYuOjoaXlxf09fXh6ekJIyMjhIaGYtq0aUhJSYGPj0+F+5g9ezays7NllmdmZuLnn3+GqakpunfvroryiYiIiGqcGh8Ci4qKMG/ePGhpaSEsLAydO3cGACxYsACurq5YsWIFPDw8YGNjU+5+PvnkE7nLN2/eDAB47733oK+vr9ziiYiIiGqoGn84ODo6GomJiRg7dqwkAAKAiYkJ5s+fj4KCAgQGBgre/969ewEAkydPrnKtRERERLVFjQ+BMTExAAAXFxeZda6urgCA2NhYQfu+cOEC7ty5g27duqFTp07CiyQiIiKqZWr84eD4+HgAQMuWLWXWmZubw8jICAkJCYL2/euvvwIAPvjgA4W3yc/PF9RXbVNQUCD1v6Q8HFvNUZd+XvBzq1ocX9XRpLGt7GltNT4E5uTkAAAaNGggd72xsbGkTWXk5eXhzz//hKGhIby8vBTe7vHjxyguLq50f7VVWlqaukuos+rW2Bqqu4AaKTk5Wd0lKF3d+tzWPBxf1anrY6utrY0WLVpUapsaHwJVJTg4GHl5eZgwYUKZAVMeS0tLFVZVcxQUFCAtLQ3m5ubQ09NTdzl1St0c22fqLqBGsra2VncJSlM3P7c1B8dXdTi2ZavxIbA0oJU125ebmwtTU9NK77f0gpDKHAoGKj/VWtvp6elp3GuuLhzbuq8uvr/83KoWx1d1OLayavyFIaXnApaeG/i2tLQ05OXlVXr68/bt27h48SLatGkDBwcHpdRJREREVJvU+BDo6OgIAIiMjJRZd/LkSak2iiq9IIS3hSEiIiJNVeNDoLOzM+zs7BAUFIS4uDjJ8uzsbKxfvx56enrw9vaWLE9NTcXdu3flPh0EAAoLC/Hbb79BV1dXajsiIiIiTVLjQ6COjg42bdqEkpISuLm5Yd68eViyZAmcnJxw//59LF26FLa2tpL2vr6+6N27Nw4fPix3f0eOHEFGRgaGDRuGxo0bV9fLICIiIqpRavyFIQAwYMAAhIeHY9WqVQgJCUFhYSHs7e3h6+sLT0/PSu1L6AUhRERERHVJrQiBANCjRw8EBQVV2M7f3x/+/v5lrj9w4IAyyyIiIiKqlWr84WAiIiIiUj6GQCIiIiINxBBIREREpIEYAomIiIg0EEMgERERkQZiCCQiIiLSQAyBRERERBqIIZCIiIhIAzEEEhEREWkghkAiIiIiDcQQSERERKSBGAKJiIiINBBDIBEREZEGYggkIiIi0kAMgUREREQaiCGQiIiISAMxBBIRERFpIIZAIiIiIg3EEEhERESkgRgCiYiIiDQQQyARERGRBhIcAjMyMhAVFYX79+/LrNu5cyccHR3RokULjBs3Dvfu3atSkURERESkXIJD4NatWzFmzBhcunRJavmuXbvw+eef49atW3j+/DlOnDgBd3d3ZGZmVrlYIiIiIlIOwSHwzJkz0NbWhru7u9Ty9evXAwB8fHywd+9eODg44OnTp/jxxx+rVikRERERKY3gEJicnAxzc3MYGRlJlt24cQPJycno06cPli9fDjc3N+zcuRPa2to4duyYUgomIiIioqoTHAIzMzPRtGlTqWXnz58HAIwYMUKyzNzcHC1atMCDBw+EdkVERERESiY4BGppaSEvL09q2cWLFyESidC3b1+p5Q0aNEBBQYHQroiIiIhIyQSHQBsbGyQkJOD58+cAgMLCQkRGRsLAwADdunWTavvs2TOYmZlVrVIiIiIiUhrBIdDFxQWFhYWYPn06jh49Ch8fH2RmZsLV1RU6OjqSdtnZ2Xjw4AGsrKyUUjARERERVZ1OxU3k+/TTTxEcHIxTp07h9OnTEIvF0NfXx8KFC6XahYeHQywWw8HBocrFEhEREZFyCA6BTZo0QWRkJDZt2oT79+/D2toaH3/8Mdq2bSvV7ty5c+jYsSOGDh1a5WKJiIiISDkEh0AAsLS0xOrVq8tts3Hjxqp0QUREREQqwGcHExEREWmgKs0Elrp69SqioqLw6NEjvHr1Clu2bJGsS01NRWFhIaytrZXRFREREREpQZVCYFpaGmbNmoXo6GgAgFgshkgkkgqBK1euxL59+3Ds2DH06tWratUSERERkVIIPhycl5cHd3d3REVFwcLCAhMmTJB7Gxhvb2+IxWIcOXKkSoVeuXIF48aNg42NDSwtLTFo0CCEhIRUej/p6elYvHgxunfvDnNzczRv3hyDBw/GL7/8UqX6iIiIiGoTwTOBfn5+uHfvHoYMGYJffvkFRkZGGD58OB4/fizVzsHBAfXq1UNUVJTgIqOjo+Hl5QV9fX14enrCyMgIoaGhmDZtGlJSUuDj46PQfuLi4uDp6YmsrCwMGTIEHh4eyMvLw927dxEeHo7p06cLrpGIiIioNhEcAkNDQ6Gjo4PNmzfDyMiozHba2tpo0aIFEhMTBfVTVFSEefPmQUtLC2FhYejcuTMAYMGCBXB1dcWKFSvg4eEBGxubcveTk5ODiRMnAgBOnz6Njh07yvRDREREpCkEHw5+8OABWrRogSZNmlTY1sjISOY5w4qKjo5GYmIixo4dKwmAAGBiYoL58+ejoKAAgYGBFe7nl19+QUpKCr7++muZAAhA6iknRERERHWd4OQjEokUbpuVlYX69esL6icmJgbAm8fU/ZurqysAIDY2tsL9BAcHQyQSYdSoUbh37x4iIyORn5+P1q1bY9CgQdDT0xNUHxEREVFtJDgE2tjYICEhAS9fvoShoWGZ7Z4+fYr4+Hj06NFDUD/x8fEAgJYtW8qsMzc3h5GRERISEsrdR0FBAW7duoVGjRph27ZtWLVqFUpKSiTr7ezsEBAQgA4dOlRYT35+fiVfQe1UUFAg9b+kPBxbzVGXfl7wc6taHF/V0aSx1dfXr1R7wSFw0KBB2LJlCzZu3Ij//ve/Zbb77rvvIBaLMWTIEEH95OTkAAAaNGggd72xsbGkTVmeP3+O4uJiZGZm4vvvv4evry+8vb1RWFiInTt3Yu3atfD29salS5cqHMDHjx+juLhY0GupjdLS0tRdQp1Vt8a27D8ENVlycrK6S1C6uvW5rXk4vqpT18e29BqMyhAcAufMmYNdu3Zh7dq1yMvLw4cffii1/u+//8amTZvw+++/o1GjRpgxY4bQrqqsdNavuLgYH330kdTVxEuWLMH9+/cREhKCgwcPYvz48eXuy9LSUqW11hQFBQVIS0uDubk5D5UrWd0c22fqLqBGqks3ya+bn9uag+OrOhzbsgkOgebm5vj1118xefJkbN26FVu3bpWsMzMzg1gshlgshrGxMXbt2gVTU1NB/ZTOAJY125ebm1vhvt+eRRw+fLjM+uHDhyMkJARXr16tMARWdqq1ttPT09O411xdOLZ1X118f/m5VS2Or+pwbGVV6dnBzs7OiIqKwtixY2FgYCAJfiUlJdDT08OoUaMQGRkJR0dHwX2UngtYem7g29LS0pCXl1fh9Gf9+vUlM3gmJiYy60uX1aXzd4iIiIjKU6UQCADNmzfHtm3b8PDhQ5w/fx7h4eE4c+YMHjx4gN27d6NVq1ZV2n9pgIyMjJRZd/LkSak25enfvz8A4M6dOzLrSpdVdK9BIiIiorqiyiGwlI6ODtq2bYs+ffqgY8eOSptydXZ2hp2dHYKCghAXFydZnp2djfXr10NPTw/e3t6S5ampqbh79y6ys7Ol9lN6zuLGjRuRlZUlWZ6WloatW7dCS0sLo0aNUkrNRERERDWd0kKgqujo6GDTpk0oKSmBm5sb5s2bhyVLlsDJyQn379/H0qVLYWtrK2nv6+uL3r174/Dhw1L76dOnD+bMmYN//vkHTk5O+OKLLzBv3jw4OTnh8ePH+Oqrr6o8a0lERERUW1T5MRkvXrzAmTNnkJCQgLy8PIjF4jLbLly4UFAfAwYMQHh4OFatWoWQkBAUFhbC3t4evr6+8PT0VHg/3377Lezt7bF9+3bs27cPIpEInTt3xvr16+Hu7i6oNiIiIqLaSJSVlVV2aqvA9u3bsXz58gofCScWiyESiZCZmSm0K6pm+fn5SE5OhrW1Na+mUrK6OLamOx+pu4QaKWualbpLUJq6+LmtSTi+qsOxLZvgmcDg4GB8+eWXAIBGjRqhc+fOaNy4MbS0avwRZiIiIiKNJzgE/vjjjxCJRJg+fTpWrlyJevXqKbMuIiIiIlIhwSHwn3/+gYmJCdasWcPZPyIiIqJaRnB609HRQfPmzRkAiYiIiGohwQmuY8eOePz4sTJrISIiIqJqIjgEzpkzB2lpaQgODlZmPURERERUDQSHwBEjRmDx4sXw8fHB+vXrpZ7CQUREREQ1m0IXhnTp0qXMdYWFhVi5ciVWrlwJMzMzGBoaym0nEolw7do1QUUSERERkXIpFAKTkpIU2llGRkaZ60QikWIVEREREZHKKRQCDx06pOo6iIiIiKgaKRQCnZycVF0HEREREVUj3uSPiIiISAMJDoGFhYVITk5GZmZmue0yMzORnJyMoqIioV0RERERkZIJDoF79+5Fly5dEBAQUG67gIAAdOnSBYGBgUK7IiIiIiIlExwCDx06BJFIhIkTJ5bbztvbGwAQGhoqtCsiIiIiUjLBIfDu3bto2rQpzMzMym3XuHFjWFhY4M6dO0K7IiIiIiIlExwC09PTYWFhoVDbpk2bIj09XWhXRERERKRkgkNg/fr18fTpU4Xapqeno169ekK7IiIiIiIlExwC27dvj5SUFMTFxZXbLi4uDsnJyWjXrp3QroiIiIhIyQSHQHd3d4jFYsyZM6fM28Q8f/4cc+bMgUgkgru7u+AiiYiIiEi5FHpiiDxTp07Fjh078Pfff6NPnz6YMmUKevfuDRMTE2RnZ+PixYvYs2cP0tPT0aZNG0yfPl2ZdRMRERFRFQgOgfr6+vj9998xfvx43L17F+vXr5dpIxaL0a5dOwQGBkJfX79KhRIRERGR8ggOgQBgZ2eHqKgo7N69G4cOHcKtW7eQm5sLY2NjdOjQAR4eHpg8eTIvCiEiIiKqYQSHwOTkZACAlZUVZs2ahVmzZimtKCIiIiJSLcEhsHPnzmjcuDFu376tzHqIiIiIqBoIvjrY2NgYNjY20NISvAsiIiIiUhPBCa5169ZIS0tTZi1EREREVE0Eh8AJEyYgJSUFUVFRyqyHiIiIiKqB4BA4ffp0uLu7Y9q0aQgODkZJSYky6yIiIiIiFRJ8YcioUaMgFouRk5ODGTNm4NNPP0Xr1q1haGgot71IJEJoaKjgQomIiIhIeQSHwJiYGKl/5+bm4sqVK2W2F4lEQrsiIiIiIiUTHAL9/PyUWQcRERERVSPBIXDixInKrIOIiIiIqhFv8kdERESkgRgCiYiIiDSQ4MPBb0tPT8eNGzeQmZmJwsLCMttNmDBBGd0RERERURVVKQQmJSXh888/R2RkJMRicYXtqxICr1y5glWrVuHChQsoKiqCvb095syZgzFjxii0fUBAAObMmVPm+kOHDqF///6C6yMiIiKqTQSHwIyMDAwbNgxPnjyBpaUlcnNzkZeXh759++L58+e4f/8+ioqKYGBggO7du1epyOjoaHh5eUFfXx+enp4wMjJCaGgopk2bhpSUFPj4+Ci8rxEjRqBTp04yy21sbKpUIxEREVFtIjgEbt68GU+ePMHUqVOxYcMGDB8+HBcuXMCRI0cAAFlZWfDz88OGDRvQqlUrbNy4UVA/RUVFmDdvHrS0tBAWFobOnTsDABYsWABXV1esWLECHh4eCoc4Nzc3TJo0SVAtRERERHWF4AtDjh8/Dj09PSxbtkzuelNTUyxZsgSrVq3Cnj17EBAQIKif6OhoJCYmYuzYsZIACAAmJiaYP38+CgoKEBgYKGjfRERERJpKcAh8+PAhbGxs0LBhQ6nlRUVFUv+eMWMGzMzMsGfPHkH9lD6ZxMXFRWadq6srACA2Nlbh/cXFxWHz5s3YuHEjgoODkZmZKaguIiIiotqsSheGNGjQQPL/69evDwB49uwZzM3NJctFIhGsra1x+/ZtQX3Ex8cDAFq2bCmzztzcHEZGRkhISFB4fz/99JPUvw0MDLBw4UJ8+umnCm2fn5+vcF+1WUFBgdT/kvJwbDVHXfp5wc+tanF8VUeTxlZfX79S7QWHQAsLC6Snp0v+bW1tDQC4fv06hgwZIlleUlKC5ORkwYOfk5MDQDpwvs3Y2FjSpjy2trb4/vvv4erqCktLSzx//hzR0dFYvnw5vvnmGxgYGGDWrFkV7ufx48coLi6u3IuoxdLS0tRdQp1Vt8bWUN0F1EjJycnqLkHp6tbntubh+KpOXR9bbW1ttGjRolLbCA6Bbdu2xcmTJ1FYWAhdXV04Ojpi165dWLVqFXr37g1TU1MAwKpVq5CRkSF1Pp86ODk5wcnJSfJvAwMDeHt7o0uXLhg4cCBWr16N6dOnQ0en/CGxtLRUdak1QkFBAdLS0mBubg49PT11l1On1M2xfabuAmqk0j+O64K6+bmtOTi+qsOxLZvgEDhkyBAcOXIE0dHRcHV1hbu7O2xsbHD9+nV06NABbdq0QXp6Oh4/fgyRSISPPvpIUD+lM4Blzfbl5uZKAqcQ7du3R9++fXH69GncuXMHHTp0KLd9Zadaazs9PT2Ne83VhWNb99XF95efW9Xi+KoOx1aW4AtD3N3d8f333+Odd94BANSrVw+///47WrdujZcvX+LatWt49OgRdHR08MUXX+D9998X1E/puYCl5wa+LS0tDXl5eZWe/vw3MzMzAMDLly+rtB8iIiKi2kLwTOA777wjM7vXtm1bnD9/Hn/99RcePnwIAwMD9O7dG40aNRJcoKOjI9avX4/IyEh4eXlJrTt58qSkjVDFxcW4evUqgLp16IaIiIioPIJnAssiEonQs2dPeHl5YcSIEVUKgADg7OwMOzs7BAUFIS4uTrI8Ozsb69evh56eHry9vSXLU1NTcffuXWRnZ0vt59q1azL7Li4uxjfffIOEhAT0798fTZs2rVKtRERERLVFlW4RUx10dHSwadMmeHl5wc3NTeqxccnJyVixYgVsbW0l7X19fREYGAg/Pz+pJ4O8++676NChAzp06CC5Ojg2Nhb379+HlZUVNm/erI6XR0RERKQWVQ6BCQkJ8Pf3R1RUFB49eoT8/Hw8e/Z/Vwru2bMHT548wZw5c2BkZCSojwEDBiA8PByrVq1CSEgICgsLYW9vD19fX3h6eiq0j7lz5+Ly5cs4ffo0nj9/Dj09PTRv3hxffPEF5s6dW6WLS4iIiIhqmyqFwJCQEMyZMwf5+fkQi8UA3hwOfltWVhbWrFmDtm3bYvTo0YL76tGjB4KCgips5+/vD39/f5nlK1euFNw3ERERUV0j+JzAmzdvYtasWXj9+jU++ugjHD58GF27dpVpN2rUKIjFYhw5cqQqdRIRERGREgmeCdy0aROKiorw3Xff4eOPPwYg/55YdnZ2aNSoEf766y/hVRIRERGRUgmeCYyJiYGRkZEkAJbHysoKqampQrsiIiIiIiUTHAIzMjIUvkmztrY2ioqKhHZFREREREomOAQaGxsjPT1dobbJycmSp3IQERERkfoJDoEdOnTAkydPcOfOnXLbnT9/Hunp6ejevbvQroiIiIhIyQSHwPfeew9isRjz589Hbm6u3DYZGRn49NNPIRKJ8N577wkukoiIiIiUS/DVwRMnTkRAQADOnj0LJycneHl5SQ4P79u3D3///Tf279+PzMxMDBw4EKNGjVJa0URERERUNYJDoJaWFgIDA/HRRx/hxIkT2Lhxo2Td3LlzAQBisRguLi7YsWNHlQslIiIiIuWp0hNDTE1NceDAAURFRSE4OBg3b95EVlYW6tevD3t7e4wZMwZDhw5VVq1EREREpCRVfnYwADg7O8PZ2VkZuyIiIiKiaiD4whAiIiIiqr2UMhNYqqSkBAcPHsSlS5dQWFiIli1bwsvLC40bN1ZmN0RERERURQqHwHv37mHLli0wNzfHf//7X5n1z549g6enJ27cuCG1fPXq1di9ezcPFxMRERHVIAofDj527Bh+/fVXiEQiues/+eQTxMXFQSwWo1GjRujRowfq16+P7OxsTJkyBc+ePVNa0URERERUNQqHwHPnzgEARo8eLbPuxo0biIiIgEgkwowZM3D79m0cP34ccXFx6NmzJ3JycrBz506lFU1EREREVaNwCLx//z5MTEzQvn17mXWHDh0CAFhYWODbb7+Fltab3TZs2BArV66EWCxGZGSkkkomIiIioqpSOARmZGTA1tZW7roLFy5AJBJh6NCh0NPTk1rXp08fNGrUCPfu3atapURERESkNAqHwJycHIjFYrnr4uLiAAD9+vWTu97S0hI5OTkCyiMiIiIiVVA4BBobG+PRo0cyyxMSEpCVlQUA6NKli9xtxWKx5BAxEREREamfwsmsbdu2yMzMRExMjNTyI0eOAADMzMzQunVruds+evQIZmZmVSiTiIiIiJRJ4RA4YsQIiMVifPbZZ7h27RoKCgoQFRWFjRs3QiQSwd3dXe52CQkJyMzMRJs2bZRWNBERERFVjcI3i54+fTp+/vlnxMfHw8XFRbJcLBZDX18fc+fOlbvdn3/+CZFIhP79+1e9WiIiIiJSCoVnAg0NDRESEgJ7e3uIxWLJfw0aNMBPP/2EFi1ayGxTWFiIHTt2AAAGDhyovKqJiIiIqEoq9ezgli1bIiYmBleuXEFiYiKMjY3h4OAAY2Njue1fvHiBdevWQSQSoWvXrsqol4iIiIiUoFIhsFT37t3RvXv3CtuZmppi6NChQrogIiIiIhXifVuIiIiINBBDIBEREZEGYggkIiIi0kAMgUREREQaiCGQiIiISAMxBBIRERFpIIVCYHJyMtLT01VdCxERERFVE4VCYOfOnTFlyhSpZXPmzMGGDRtUUhQRERERqZbCh4PFYrHUv/ft24eIiAilF0REREREqqdQCDQ0NMSzZ89UXQsRERERVROFHhvXtm1bXLt2DZs3b8bQoUNhYGAAACgoKEBycrLCnVlbWwurEsCVK1ewatUqXLhwAUVFRbC3t8ecOXMwZswYQfvLysqCg4MDnjx5AldXV/zxxx+CayMiIiKqbRQKgTNmzMCcOXPw9ddf4+uvv5Ysv3r1Krp06aJQRyKRSPBsYnR0NLy8vKCvrw9PT08YGRkhNDQU06ZNQ0pKCnx8fCq9zy+//BI5OTmC6iEiIiKq7RQ6HDxx4kRs2bIFnTt3hr6+PsRiMUQiEcRiscL/lZSUCCqwqKgI8+bNg5aWFsLCwvC///0P3377LWJiYtCqVSusWLECSUlJldrnwYMHceDAAXzzzTeCaiIiIiKq7RS+MGTSpEk4ffo0Hj9+jOfPn0MsFqNv3754/vy5wv8JER0djcTERIwdOxadO3eWLDcxMcH8+fNRUFCAwMBAhfeXkZGBzz//HOPHj8eQIUME1URERERU29X4m0XHxMQAAFxcXGTWubq6AgBiY2MV3t9nn30GbW1trFmzRjkFEhEREdVCCp0TKI/Qmb3Kio+PBwC0bNlSZp25uTmMjIyQkJCg0L5+++03HDp0CAEBATA1NUV2dnal68nPz6/0NrVRQUGB1P+S8nBsNUdd+nnBz61qcXxVR5PGVl9fv1LtBYfAfysqKkJSUhJyc3NhbGwMGxsb6OhUffelF280aNBA7npjY2OFLvB48uQJFi5ciLFjx8LNzU1wPY8fP0ZxcbHg7WubtLQ0dZdQZ9WtsTVUdwE1UmXunlBb1K3Pbc3D8VWduj622traaNGiRaW2qXJKu3LlCn744QdERUVJ/dWrr6+PgQMH4osvvkC3bt2q2k2V/ec//4Gurm6VDwNbWloqqaKaraCgAGlpaTA3N4eenp66y6lT6ubY8j6i8lTltlg1Td383NYcHF/V4diWrUohcPfu3fjiiy9QXFws80SRV69e4ciRI4iIiMC6devwwQcfCOqjdAawrNm+3NxcmJqalruPffv24fjx49i9ezfMzMwE1VGqslOttZ2enp7GvebqwrGt++ri+8vPrWpxfFWHYytL8IUh169fx+eff46ioiL07dsX+/btw7Vr15Camopr165h3759cHBwQFFREebPn4/r168L6qf0XMDScwPflpaWhry8vAqnP+Pi4gAAU6ZMgampqeS/0nscnjx5EqampnBychJUIxEREVFtI3gmcMuWLSguLsbcuXOxYsUKqXW2trawtbXF8OHDsWzZMmzevBl+fn7Ytm1bpftxdHTE+vXrERkZCS8vL6l1J0+elLQpT+/evfHixQuZ5S9evEBwcDCsrKzg4uKCZs2aVbo+IiIiotpIlJWVJa64mawOHTrgxYsXuHfvHnR1dctsV1hYiFatWsHIyAh///13pfspKipCz5498eTJExw/flxyr8Ds7Gy4uroiKSkJly5dgq2tLQAgNTUVOTk5MDc3h4mJSbn7fvjwIbp06cLHxsmRn5+P5ORkWFtbc/pcyeri2JrufKTuEmqkrGlW6i5Baeri57Ym4fiqDse2bIIPB6enp6Nly5blBkAA0NXVRatWrZCRkSGoHx0dHWzatAklJSVwc3PDvHnzsGTJEjg5OeH+/ftYunSpJAACgK+vL3r37o3Dhw8L6o+IiIhIEwg+HGxkZKTw5dZpaWmoX7++0K4wYMAAhIeHY9WqVQgJCUFhYSHs7e3h6+sLT09PwfslIiIi0lSCQ2Dnzp0RHR2NI0eOYMSIEWW2CwsLw6NHj+Ds7Cy0KwBAjx49EBQUVGE7f39/+Pv7K7RPW1tbZGVlVakuIiIiotpI8OHg999/H2KxGDNnzsSWLVvw8uVLqfUvX77E5s2bMWvWLIhEIkyePLnKxRIRERGRcgieCRw7diwOHTqE0NBQLFu2DN999x1sbGzQpEkTPH36FElJScjPz4dYLIaHh4fMlb1EREREpD6CZwIBYMeOHVi4cCGMjIzw6tUr3LlzB2fOnMGdO3fw6tUrGBkZYdGiRfjll1+UVS8RERERKUGVnhiira2NRYsW4T//+Q/OnTuHe/fuIS8vD0ZGRmjTpg369u0LQ0M+U5SIiIiopqnys4MBwNDQEK6urnB1dVXG7oiIiIhIxap0OJiIiIiIaieGQCIiIiINxBBIREREpIEYAomIiIg0EEMgERERkQZiCCQiIiLSQAyBRERERBqIIZCIiIhIAzEEEhEREWmgKj0xpKSkBPv370d4eDgSEhKQl5cHsVgst61IJMK1a9eq0h0RERERKYngEJibm4uxY8fi0qVLZQa/t4lEIqFdEREREZGSCQ6Ba9aswcWLF2FoaIj3338fvXv3RuPGjaGlxSPMRERERDWd4BAYGhoKLS0tBAYGYsCAAcqsiYiIiIhUTPC0XVpaGqytrRkAiYiIiGohwSHQzMwMDRs2VGYtRERERFRNBIdAFxcX3L59G7m5ucqsh4iIiIiqgeAQuGjRItSrVw8LFy5EcXGxMmsiIiIiIhUTfGHIw4cPsXjxYixduhRXr17FBx98gFatWsHQ0LDMbRwdHYV2R0RERERKJDgEjhw5UnLvv9u3b2PJkiXltheJRHj27JnQ7oiIiIhIiQSHwGbNmvEG0ERERES1lOAQeOPGDWXWQURERETViI/3ICIiItJADIFEREREGkjw4eC3Xb9+HREREbh37x5yc3NhbGyMNm3aYPDgwejSpYsyuiAiIiIiJapSCMzMzMQnn3yCiIgIAIBYLJasE4lE+O677zBs2DBs2bIF77zzTtUqJSIiIiKlERwCX79+jTFjxuDGjRsQi8Xo3Lkz7O3t0bRpU6SmpuLWrVuIi4tDeHg4PD09cezYMdSrV0+ZtRMRERGRQIJD4M8//4y4uDhYWVnBz88Pzs7OMm2io6MxZ84cxMXFYfv27ZgzZ06ViiUiIiIi5RB8YUhISAhEIhH27dsnNwACwIABAxAQEACxWIzg4GDBRRIRERGRcgkOgffu3UPr1q3RuXPnctt17twZbdq0wb1794R2RURERERKJjgEFhYWwsDAQKG2BgYGKCwsFNoVERERESmZ4BBoZWWF27dvIysrq9x2z58/x+3bt2FpaSm0KwDAlStXMG7cONjY2MDS0hKDBg1CSEiIwtsfP34cH374IXr16gUbGxtYWFigV69emDt3Lu7fv1+l2oiIiIhqG8EhcODAgXj9+jU++eQT5Ofny22Tn5+PTz75BAUFBRg0aJDgIqOjozF06FCcP38eY8aMwbRp05CWloZp06Zh8+bNCu0jIiICly5dQseOHTFp0iR89NFHaNGiBQIDA+Ho6IioqCjB9RERERHVNqKsrCxxxc1kPXr0CA4ODsjLy0OjRo0wdepU2Nvbo0mTJnj69Clu3bqFXbt2ISMjA8bGxjh79iysrKwq3U9RURF69eqFx48f4/jx45JzELOzs+Hq6oqkpCRcvnwZNjY25e4nPz8f+vr6MsujoqLg4eGBbt264dSpU5Wur67Kz89HcnIyrK2t5Y4bCVcXx9Z05yN1l1AjZU2r/M+8mqoufm5rEo6v6nBsyyb4FjFWVlbYt28fpk6divT0dKxdu1amjVgsRqNGjbBr1y5BARB4MwuYmJiISZMmSV2EYmJigvnz5+OTTz5BYGAgFi5cWO5+ynrjnZ2dYWpqioSEBEH1EREREdVGVXpiiJOTEy5evIjt27fj+PHjuHfvHvLy8mBkZIQ2bdpgyJAh+PDDD6v0tJCYmBgAgIuLi8w6V1dXAEBsbKzg/V+8eBFZWVlwcHAQvA8iIiKi2qbKzw5+5513sGDBAixYsEAZ9ciIj48HALRs2VJmnbm5OYyMjCo1ixcZGYkLFy6goKAA8fHxOHbsGMzMzPDdd98prWYiIiKimq7KIVDVcnJyAAANGjSQu97Y2FjSRhGRkZHYsmWL5N8tWrTAjh070LVrV4W2L+simLqmoKBA6n9JeTi2mqMu/bzg51a1OL6qo0ljW9lzHmt8CFS2lStXYuXKlcjLy8OdO3fw/fffY+jQodiyZQvGjRtX4faPHz9GcXFxNVRaM6Slpam7hDqrbo2toboLqJGSk5PVXYLS1a3Pbc3D8VWduj622traaNGiRaW2USgErlmzBgBgZmaGGTNmSC2rjIou3pCndAawrNm+3NxcmJqaVnq/RkZG6NGjBwICAvDuu+/i008/xcCBA9GoUaNyt6vq/Q5ri4KCAqSlpcHc3Bx6enrqLqdOqZtj+0zdBdRI1tbW6i5Baerm57bm4PiqDse2bAqFwNWrV0MkEqF169aSEFi6TBFisRgikUhQCCw9FzA+Pl7mkG1aWhry8vLQvXv3Su+3lI6ODvr374+bN2/i6tWrGDx4cLntNe3ycj09PY17zdWFY1v31cX3l59b1eL4qg7HVpZCIdDb2xsikQhNmzaVWaZqjo6OWL9+PSIjI+Hl5SW17uTJk5I2VZGamgoA0NXVrdJ+iIiIiGoLhUKgv7+/QstUwdnZGXZ2dggKCsKsWbOkbha9fv166OnpwdvbW9I+NTUVOTk5MDc3h4mJiWT51atX0a1bN5n9nzx5EocPH4aJiQl69eql+hdEREREVAPU+AtDdHR0sGnTJnh5ecHNzQ2enp4wMjJCaGgokpOTsWLFCtja2kra+/r6IjAwEH5+fpg0aZJk+cCBA2Fvb48OHTrA0tISL1++xM2bN3Hu3Dno6upiy5YtqF+/vjpeIhEREVG1ExwC58yZg1atWuGzzz6rsO3GjRtx7949+Pn5CeprwIABCA8Px6pVqxASEoLCwkLY29vD19cXnp6eCu1j2bJlOHPmDGJjY5GRkQEtLS00a9YMU6dOxezZs9G2bVtBtRERERHVRoKfHdywYUP07dsXR48erbDtyJEjcfbsWWRmZgrpitSAz1pUnbo4tnx2sHx8djApiuOrOhzbsmlVRyclJSXVchEJERERESmmWkLgkydPeL4dERERUQ2i8DmBycnJSEpKklqWk5OD2NjYMrd59eoVoqKi8ODBA155S0RERFSDKBwCAwIC8P3330st++eff+Du7l7udmLxm1MOp06dWvnqiIiIiEglFA6BJiYmaNasmeTfKSkp0NPTQ5MmTeS2F4lEMDQ0RPPmzeHt7Y1Ro0ZVvVoiIiIiUgqFQ+Ds2bMxe/Zsyb8bNmyIbt26KXR1MBERERHVLILvE+jn5wdzc3Nl1kJERERE1URwCFy9ejWMjIzg5OSEevXqKbMmIiIiIlIxwbeISU9PR7169RgAiYiIiGohwSGwWbNmyM/PV2YtRERERFRNBIfAESNG4O7du3jw4IESyyEiIiKi6iA4BH7++eews7PDlClTkJKSosyaiIiIiEjFBF8Y4u/vD1dXV+zYsQM9e/aEs7Mz2rVrB0NDwzK3WbhwodDuiIiIiEiJqnR1sEgkglgsRnFxMSIiInD8+HG5bcViMUQiEUMgERERUQ0hOAR6e3tDJBIpsxYiIiIiqiZVOhxMRERERLWT4AtDiIiIiKj2YggkIiIi0kCCDweXys3NxZ49exAREYF79+4hLy8PRkZGaNOmDYYOHYr3338fxsbGyqiViIiIiJSkSiHwypUr+OCDD/D48WOIxWLJ8tzcXDx58gTR0dHw8/PDr7/+im7dulW5WCIiIiJSDsEhMC0tDePGjUNmZiaMjY0xefJk2Nvbo2nTpkhNTcWtW7ewd+9ePHr0COPGjUNsbCzMzc2VWTsRERERCSQ4BG7atAmZmZlwdnbGrl27YGpqKtNmwYIFmDp1KqKiorB582asXLmyKrUSERERkZIIvjDk+PHj0NPTw/bt2+UGQAAwMTHBtm3boKOjg4iICKFdEREREZGSCQ6BKSkpaN++PRo1alRuu8aNG6N9+/Z8vjARERFRDSI4BOro6OD169cKtS0oKICOTpUvRCYiIiIiJREcAlu2bIm7d+/izp075ba7ffs27ty5g5YtWwrtioiIiIiUTHAIHDVqFEpKSjB58mRcu3ZNbptr167h/fffBwB4eHgI7YqIiIiIlEzwMdpZs2bht99+w507d+Di4oK+ffvC3t4eTZo0wdOnT3Hr1i2cP38eYrEY7du3x6xZs5RZNxERERFVgeAQaGhoiD///BMzZsxAbGwszp07h/Pnz0vWl9482snJCT///DMMDAyqXi0RERERKUWVrtZo2rQpDh8+jHPnzsl9bNyQIUPQt29fZdVKREREREqilEt2HRwc4ODgoIxdERHRv5jufKTuEv4/QwDP1F0EACBrmpW6SyCq9QRfGEJEREREtZdSZgLj4uIQERGBu3fvIjc3F8bGxmjTpg0GDx6MLl26KKMLIiIiIlKiKoXA9PR0zJ07F8ePHwfwfxeDAIBIJMJ3332HwYMHY9OmTTA3N69apURERESkNIJDYHZ2NkaMGIH4+HiIxWJ0794d7dq1k9wi5vbt27hy5QqOHz+OkSNH4sSJEzAxMVFm7UREREQkkOAQuHbtWty/fx/NmzeHv78/+vTpI9Pm4sWLmD17NuLj47F27VqsWLGiSsUSERERkXIIvjAkNDQUWlpaCAwMlBsAAaB3797Yt2+fpH1VXLlyBePGjYONjQ0sLS0xaNAghISEKLStWCzG8ePHMX/+fPTr1w82NjawsLCAo6Mj1q1bh/z8/CrVRkRERFTbCJ4JTE1NRdu2bdG2bdty27Vt2xbt2rVDQkKC0K4QHR0NLy8v6Ovrw9PTE0ZGRggNDcW0adOQkpICHx+fcrd//fo1xo0bh3r16sHJyQmurq7Iz89HZGQkVqxYgbCwMBw+fBiGhoaCayQiIiKqTQSHwEaNGkFHR7HNdXR0YGZmJqifoqIizJs3D1paWggLC0Pnzp0BAAsWLICrqytWrFgBDw8P2NjYlLkPbW1tfPXVV5gxYwZMTU0lywsLCzF58mSEh4dj+/bt+M9//iOoRiIiIqLaRvDh4HfffRf//PMPnjx5Um67x48f459//oGLi4ugfqKjo5GYmIixY8dKAiAAmJiYYP78+SgoKEBgYGC5+9DV1cUXX3whFQBLl8+fPx8AEBsbK6g+IiIiotpIcAj873//CxMTE0yZMgWPHsm/m/2jR48wbdo0mJqaYvHixYL6iYmJAQC5IdLV1RVA1QKcrq4ugDezhURERESaQvDh4OjoaEyfPh0bNmxAt27dMHLkSLRv317qFjGHDx8GAHz22WeIioqSu58JEyaU2098fDwAoGXLljLrzM3NYWRkVKXzDffu3QtAfsiUR1MuIikoKJD6X1Iejq3m0JSfF+pQ18aWPxdUR5PGVl9fv1LtRVlZWeKKm8lq2LAhRCKR5AbRIpFIpk1560plZmaW28+YMWNw6tQpXLlyBS1atJBZ3759e7x48QJJSUmVKR8AcPz4cYwfPx6tW7dGdHQ06tWrV+E2CQkJKC4urnRfRHVZrxheVCXPJaeXStkPx1eWssaWqK7Q1taWm5PKI3gmsF+/fuWGu5ruypUr+PDDD9GgQQPs2rVLoQAIAJaWliqurGYoKChAWloazM3Noaenp+5y6pS6ObbP1F1AjWRtba2kPXF8/015Y1sz1M2fCzUDx7ZsgkNgWFiYMusoU4MGDQAAOTk5ctfn5ubKXPBRkatXr2LMmDEQiUQIDg5G+/btFd62slOttZ2enp7GvebqwrGt+/j+qk5dHVv+XFAdjq0swReGVJfScwFLzw18W1paGvLy8io1/Xn16lWMHj0aYrEYwcHB6N69u9JqJSIiIqotanwIdHR0BABERkbKrDt58qRUm4qUBsCSkhIEBQWhZ8+eyiuUiIiIqBYRfDi4lFgsxuHDhxEREYF79+4hNzcXxsbGaNOmDYYMGQI3N7cqnTvo7OwMOzs7BAUFYdasWZJ7BWZnZ2P9+vXQ09ODt7e3pH1qaipycnJgbm4OExMTyfJr165h9OjRKC4uRlBQEHr37i38RRMRERHVclUKgQ8ePMAHH3yAmzdvAvi/q4EB4OLFi9i7dy86deqE3bt3w87OTliBOjrYtGkTvLy84ObmJvXYuOTkZKxYsQK2traS9r6+vggMDISfnx8mTZoEAHj+/DlGjx6N7OxsDBo0CKdOncKpU6ek+jExMcEnn3wiqEYiIiKi2kZwCMzJyYGHhweSkpKgra2N4cOHw97eHk2bNkVqaipu3bqFo0ePIi4uDmPGjEFUVJTkIo/KGjBgAMLDw7Fq1SqEhISgsLAQ9vb28PX1haenp0K1ZmVlAQBOnDiBEydOyLSxtrZmCCQiIiKNITgE+vn5ISkpCZ06dcLOnTvl3sw5ISEBU6dOxc2bN/Hjjz9i0aJFggvt0aMHgoKCKmzn7+8Pf39/qWW2traSEEhEREREVbgw5PDhw9DW1saePXvkBkAAaNGiBfbs2QORSIRDhw4JLpKIiIiIlEtwCHz48CHatm1b4bl+dnZ2aNeuHR4+fCi0KyIiIiJSMsEhUCwWQ0tLsc3ffrwcEREREamf4BBoa2uL27dv4/Hjx+W2S0lJwe3bt6Wu4CUiIiIi9RIcAocNG4aioiJMmzYNqampcts8efIEH374IUpKSjBixAjBRRIRERGRcgm+OtjHxwf79+/HpUuX0LVrV4wePRr29vZo0qQJnj59ilu3buHPP//E69evYWlpiblz5yqzbiIiIiKqAsEhsGHDhggODsbkyZNx//59/P7771LrS88BbN26Nfbs2QNTU9MqFUpEREREylOlJ4a0a9cOsbGxCAkJkTw2Li8vD0ZGRpLHxo0ZMwa6urrKqpeIiIiIlEBwCIyNjQUA9O7dG+PHj8f48eOVVhQRERERqZbgEDhy5EhYWVlJnhtMRERERLWH4KuDTU1N0bRpU2XWQkRERETVRHAItLe3R0pKijJrISIiIqJqIjgETps2DWlpafjjjz+UWQ8RERERVQPB5wSOHTsWV65cwdy5c5GcnIzJkyfDzMxMmbURERERkYoIDoFdunQBABQWFmL58uVYvnw5zMzMYGhoKLe9SCTCtWvXhHZHREREREokOAQmJSXJLMvIyCizvUgkEtoVERERESmZ4BB46NAhZdZBRERERNVIcAh0cnJSZh1EREREVI0EhcDs7GwkJiYCAJo3bw4TExOlFkVEREREqlWpEJiWlob58+fj2LFjKCkpAQBoaWlh2LBhWLduHczNzVVSJBEREREpl8Ih8OXLl3Bzc0NCQgLEYrFkeXFxMY4cOYK7d+8iKioKBgYGKimUiIiIiJRH4ZtFb9++HfHx8TA0NMQ333yDU6dOITIyEl9//TUMDQ1x//59bN++XZW1EhEREZGSKDwTGBYWBpFIBH9/f7i7u0uWd+vWDc2bN8fUqVMRFhYGHx8flRRKRERERMqj8Ezg3bt3YWZmJhUAS3l4eMDMzAx37txRanFEREREpBoKh8CcnBzY2dmVud7Ozg65ubnKqImIiIiIVEzhEFhSUgIdnbKPHuvq6kquGCYiIiKimk3hEEhEREREdUel7hOYkpKCNWvWyF2XnJwMAGWuB4CFCxdWpjsiIiIiUpFKhcBHjx6VGfJK7x3IEEhERERU8ykcAvv16weRSKTKWoiIiIiomlTqPoFEREREVDfwwhAiIiIiDcQQSERERKSBGAKJiIiINBBDIBEREZEGYggkIiIi0kC1JgReuXIF48aNg42NDSwtLTFo0CCEhIQovH1iYiJWrVoFb29vtG/fHqampujUqZMKKyYiIiKquSp1s2h1iY6OhpeXF/T19eHp6QkjIyOEhoZi2rRpSElJgY+PT4X7OHv2LNasWQNtbW20bdsWaWlp1VA5ERERUc1U40NgUVER5s2bBy0tLYSFhaFz584AgAULFsDV1RUrVqyAh4cHbGxsyt2Po6Mjjh8/jo4dO8LAwADm5ubVUT4RERFRjVTjDwdHR0cjMTERY8eOlQRAADAxMcH8+fNRUFCAwMDACvdjZ2eHXr16wcDAQJXlEhEREdUKNT4ExsTEAABcXFxk1rm6ugIAYmNjq7UmIiIiotquxh8Ojo+PBwC0bNlSZp25uTmMjIyQkJBQbfXk5+dXW1/qVFBQIPW/pDwcW82hKT8v1KGujS1/LqiOJo2tvr5+pdrX+BCYk5MDAGjQoIHc9cbGxpI21eHx48coLi6utv7UjRfQqE7dGltDdRdQIyUnJytpTxzff1Pe2NYsdevnQs1S18dWW1sbLVq0qNQ2NT4E1jSWlpbqLqFaFBQUIC0tDebm5tDT01N3OXVK3RzbZ+ouoEaytrZW0p44vv+mvLGtGermz4WagWNbthofAktnAMua7cvNzYWpqWm11VPZqdbaTk9PT+Nec3Xh2NZ9fH9Vp66OLX8uqA7HVlaNvzCk9FzA0nMD35aWloa8vLxKT38SERERaboaHwIdHR0BAJGRkTLrTp48KdWGiIiIiBRT40Ogs7Mz7OzsEBQUhLi4OMny7OxsrF+/Hnp6evD29pYsT01Nxd27d5Gdna2OcomIiIhqhRp/TqCOjg42bdoELy8vuLm5ST02Ljk5GStWrICtra2kva+vLwIDA+Hn54dJkyZJlj979gxfffWV5N+FhYXIzMzE7NmzJctWrlwJMzOz6nlhRERERGpU40MgAAwYMADh4eFYtWoVQkJCUFhYCHt7e/j6+sLT01OhfeTl5ck8WeTFixdSyxYtWsQQSERERBqhVoRAAOjRoweCgoIqbOfv7w9/f3+Z5ba2tsjKylJBZURERES1T40/J5CIiIiIlI8hkIiIiEgDMQQSERERaSCGQCIiIiINxBBIREREpIEYAomIiIg0EEMgERERkQZiCCQiIiLSQAyBRERERBqIIZCIiIhIAzEEEhEREWkghkAiIiIiDcQQSERERKSBGAKJiIiINBBDIBEREZEGYggkIiIi0kAMgUREREQaiCGQiIiISAMxBBIRERFpIIZAIiIiIg3EEEhERESkgRgCiYiIiDQQQyARERGRBtJRdwFERERU95jufKTuEt5iCOCZuosAAGRNs1J3CRKcCSQiIiLSQAyBRERERBqIIZCIiIhIAzEEEhEREWkghkAiIiIiDcQQSERERKSBGAKJiIiINBBDIBEREZEGYggkIiIi0kAMgUREREQaiCGQiIiISAPVmhB45coVjBs3DjY2NrC0tMSgQYMQEhJSqX28fv0aa9asQffu3WFubo527dph3rx5SE9PV1HVRERERDWTjroLUER0dDS8vLygr68PT09PGBkZITQ0FNOmTUNKSgp8fHwq3EdJSQkmTpyIkydPolevXhg1ahTi4+OxZ88eREVF4cSJE2jUqFE1vBoiIiIi9avxIbCoqAjz5s2DlpYWwsLC0LlzZwDAggUL4OrqihUrVsDDwwM2Njbl7mffvn04efIkxo4di59//hkikQgAsGPHDsyfPx8rV67Exo0bVf1yiIiIiGqEGh8Co6OjkZiYiEmTJkkCIACYmJhg/vz5+OSTTxAYGIiFCxeWu589e/YAAJYtWyYJgAAwbdo0bNq0CQcOHMCqVatgYGCgmhdCame685G6S3iLIYBn6i4CAJA1zUrdJRARkRrU+BAYExMDAHBxcZFZ5+rqCgCIjY0tdx/5+fm4fPkyWrduLTNjKBKJMHDgQOzcuRNXr15Fv379lFR57aetra3uEpTKrF6tOQW21uHYqhbHVzPwZy5VtxofAuPj4wEALVu2lFlnbm4OIyMjJCQklLuPxMRElJSUoEWLFnLXly6Pj49nCPz/9PX1yxyv2ip+ooW6S6izOLaqxfGt+/gzl9Shxsf0nJwcAECDBg3krjc2Npa0qWgfJiYmcteX7rui/RARERHVFTU+BBIRERGR8tX4EFjRLF1ubm6Zs4T/3kd2drbc9RXNNhIRERHVNTU+BJaeC1h6buDb0tLSkJeXV+F5FHZ2dtDS0irz3MHS5fLOOyQiIiKqi2p8CHR0dAQAREZGyqw7efKkVJuyGBgYoEePHrh37x6SkpKk1onFYpw6dQr169dHt27dlFQ1ERERUc1W40Ogs7Mz7OzsEBQUhLi4OMny7OxsrF+/Hnp6evD29pYsT01Nxd27d2UO/U6ZMgUAsHz5cojFYsnynTt34sGDBxg3bhzvEUhEREQao8aHQB0dHWzatAklJSVwc3PDvHnzsGTJEjg5OeH+/ftYunQpbG1tJe19fX3Ru3dvHD58WGo/EydOhKurK4KCgjBkyBB88803+OCDD/D555/D1tYWX331VXW/NLVatWoVTE1NcebMGZX14ebmBlNTU6llAQEBMDU1RUBAgMr6rYkePnwIU1NTzJ49W92lqN2ZM2dgamqKVatWKdRe3udIlaq7P3kqO0adOnVCp06dVFxV9akJ74EqzZ49G6ampnj48KG6S6n1KvtdAere96UqanwIBIABAwYgPDwcffr0QUhICHbs2IEmTZpgx44dCj03GAC0tLSwb98+LFq0CBkZGfjxxx9x4cIFTJ48GcePH+dzg4mISCmEBBNSr+qYGKmJavzNokv16NEDQUFBFbbz9/eHv7+/3HX16tXDokWLsGjRImWXV+vMnDkTXl5eaNasWbX2O3LkSPTq1Qvm5ubV2q+6WVpa4uLFi7wCnVQiNDRU3SUo1datW/Hq1St1l0F1VF37vlRFrQmBpFxmZmYwMzOr9n5NTEzKvGl3Xaarq4s2bdqouwyqo5o3b67uEpTK2tpa3SVQHVbXvi9VUSsOB9dGBQUF+Omnn+Dp6YkOHTqgSZMmaNWqFd5//31cv35dqu3b58kdPXoUrq6usLCwQPv27bFy5UqUlJQAAPbt2wdHR0c0bdoUHTt2xKZNmwTXJ2/q++3z1hISEjBp0iTY2trC0tISHh4euHHjhtx9nTt3DiNGjIClpSWaN2+OadOmISUlRW7bss4JPHToEKZPn45u3brBwsICNjY2GD58OA4ePCizD6F1Kqoy711JSQn27NkDFxcX2NnZoWnTprC3t8f48ePLHNu3Xbt2DV9++SUcHBxgY2ODpk2bol+/ftiwYQMKCwtlais9lyUvLw8LFy5Eu3bt0KRJE/Tr10/uWNV0586dg5ubG5o1awYbGxtMnjy5wsdAAm8uDNu4cSNGjBiBdu3aoXHjxmjXrh1mzZqFxMREuduIxWLs3bsXw4cPh42NDSwsLNC9e3d8+umnSE5OrrDP4OBgNGnSBI6OjkhNTa30axXq6tWrGD16tGSMJk2aJHMumbxznPLz87F582Y4OjrCxsYGlpaW6NSpE6ZOnSr1HXn7OxkWFgYXFxdYWFigZcuWmDNnDp4+fSpTk6q/r+WdExgWFoYxY8agefPmMDc3R6dOnTBz5kzcunVLkeGssr1798LV1RVWVlawsrKCq6ur1M+zVatWwd3dHQCwZs0amJqaSv779/smFouxdetW9OrVC02aNEHHjh2xevVqyc/8fwsLC8OoUaNga2sLc3NzODg4YPPmzSguLpZq9+/fKUOHDkWzZs1q5HlwWVlZeOeddzB+/Hip5XFxcZJx+/fPBDc3NzRt2hSvX7+WWq7IdwWQ/b64ublhzZo1AAB3d3dJv/8er/T0dCxevBjdunVDkyZN0KJFC0yePLnaPnuqwJlAFXn+/DkWL14MBwcHDB48GKampnjw4AGOHj2KEydO4MiRI+jevbvUNocPH8apU6fg5uaGPn36ICIiAmvXrgXw5kbWa9euxfDhw+Hk5IRDhw5h2bJlaNy4MSZMmKDU2pOSkjBo0CC0a9cO77//PhITE3HkyBG4u7vj4sWLaNKkiaRtVFQUxo4dCy0tLYwZMwYWFhaIiorCsGHDKjXjt3z5cujq6qJv375o2rQpMjIycPToUUyZMgVr1qzBrFmzqlRnZVTmvfP19cX//vc/NG/eHOPGjYORkREeP36M8+fPIyoqCv379y+3r927dyM8PBz9+vXD4MGD8erVK8TExMDX1xdXrlzBr7/+KrNNUVERPD09kZWVBXd3d7x69QrBwcGYOnUq/vjjD7i4uAh63dXt8uXL2LBhA1xdXTFz5kz8888/OHz4MM6dO4cTJ07Azs6uzG3v3r2L7777Dv3798fIkSNhaGiIu3fvIigoCBEREYiKioKNjY2kfUlJCaZNm4aDBw/C0tISY8eOhbGxMZKSkhASEoJBgwaVO/v0008/YdGiRXBwcEBgYGC1zWZfvXoVmzZtQv/+/TF16lTExcUhLCwMt27dwrlz56Cvr1/mtrNnz0ZISAg6dOiAiRMnol69enj06BHOnDmDq1evyvyCCw0NRWRkJDw8PPDuu+/i0qVLCAgIwLlz5xAZGSkVytT1fV2yZAn8/PzQsGFDuLm5oXHjxnj06BGioqLQtWtX2NvbKz64AixYsADbtm2DpaUl3n//fQBvAvGcOXMQFxeHNWvWwMnJCUlJSQgMDISjoyOcnJwk2//7c7Ns2TLExsZi6NChcHFxQVhYGFavXo3CwkIsXbpUqq2vry82bNgAS0tLuLu7o0GDBjh37hyWLl2Ky5cvY/fu3TL1Hjx4EJGRkRg6dCimT5+O3NxcFYxK1ZiamqJjx444d+4ciouLoa2tDQBSf0SfOXNGcj/g/Px8XL58Gb1790a9evUkbaryXZk4cSIAIDY2FhMmTJD87Hj7/UpMTMTIkSPx6NEjuLi4wM3NDenp6Th06BAiIyNx8OBB9OzZU3kDU00YAlXE1NQUN2/ehKWlpdTyf/75B4MHD8by5cvx559/Sq07ceIEjh07JgkYixcvRvfu3fHjjz/C2NgY0dHRkl+MPj4+6N69OzZv3qz0EBgbG4tvvvkGn376qWTZypUrsXbtWgQEBOCzzz4D8OYX67x581BUVIQjR47AwcEBwJu/bmfOnIkDBw4o3OeBAwdkfunn5eVhyJAh+PbbbzF58mQYGhoKqrOyKvPe7dmzBxYWFoiNjZWp7/nz5xX2NX/+fKxdu1bygw94M34+Pj7Yu3cvzp8/j759+0pt8+TJE3Tr1g2HDx+Gnp4eAGDcuHHw8PCAn59frQmBJ0+exIYNGzBt2jTJsp07d+Kzzz7DwoUL8dtvv5W5bZs2bXDnzh00bNhQanl0dDRGjx6NtWvXSs2Ub9++HQcPHoSzszP2798vdTuoV69eIT8/v8y+VqxYgXXr1mHkyJHYvn17ub9MlC0iIgI7duyAp6enZNmsWbPw22+/ISwsDF5eXnK3y87Oxp9//omuXbvi5MmTUp+v4uJiuWHg2LFj+OOPP+Dq6ipZVho8vv32W/zwww+S5er4voaHh8PPzw/29vY4fPgw3nnnHcm6oqIiZGZmlrt9VcXGxmLbtm1o27YtIiIiJAFh8eLFGDRoEH766Sd4eHhI/vALDAyEk5MTFi9eXOY+r1+/jtjYWDRt2hTAm5DZvXt3bNu2DQsXLpR8v0+dOiX5g2nPnj2oX78+gDc/Kz7//HPs2LEDBw8ehIeHh9T+T5w4geDgYLz77rvKHg6l6t+/P+Li4nDt2jX06NEDwJvg16pVK+Tn5+PMmTOS27xduHABr1+/lvkDW+h3BQAmTZqEpKQkxMbGYuLEiXL/eP/444+Rmpoq8x358ssvMXDgQPznP//B2bNnqzQO6sDDwSpSr149mRABAO3bt4eTkxPOnj0rc7jvvffek5odNDY2xtChQ/Hy5Ut8+OGHUj90mzVrhr59++LOnTsoKipSau22trb4z3/+I7Vs8uTJAIArV65Ilp07dw4PHjzA0KFDJQEQAEQiEZYuXSr1i6ci8mZ9jIyMMHHiROTk5Ej1W9k6K6uy752urq7c1/rvgCKPtbW1zLYikQgzZswAAJw+fVrudt99953kFwTw5n6a1tbWVXrd1a1Vq1aSH+ylpkyZgpYtWyIiIgIZGRllbmtiYiJ3fAcMGIB27drJjNsvv/wCbW1trF+/XuZ+oAYGBnL3VVxcDB8fH6xbtw5TpkzB7t27qzUAAkC/fv2kfqkBkMxAlfdei0QiiMVi6OvrQ0tL+se8tra23EOt7777rtQvNwD4/PPPYWJigt9++03qEKU6vq+//PILAGD16tVSARB4cysxoTP/igoMDAQALFq0SGqGyNTUFAsXLgTw5pSdyvjyyy8lARB4c672iBEjkJubi3v37kmWb9u2DQCwceNGSQAE3rzPX3/9NUQiEf744w+Z/Y8YMaLGB0AAktAVHR0N4M137+zZs+jfvz+cnJxkZgUBSM2wAsK/K4q4fv06Lly4gAkTJsh8R1q1aoUPPvgAt27dqpWHhTkTqEJxcXHYtGkTzp8/j7S0NJnQ9+zZM6kfAPLO1yhdX9a64uJiPH36VG5oEapTp04yvzisrKwASD9/+ebNmwDefPn+zcbGBlZWVjJPaClLeno6NmzYgBMnTiA5OVnmykB552ApWqcQir53Xl5e2L59OxwcHODp6Yn+/fujd+/eCt94vKCgANu2bUNwcDDu3buHvLw8qZuZy3vdJiYmcn8JW1lZ4eLFi5V7oWrUp08fmfdPS0sLffr0QXx8PG7evFnuL7AzZ87A398ff/31F549eyb1x9DbATkvLw937txBixYtKvVoyMmTJ+PIkSP44osv1HYf0a5du8osU+Qz3qBBAwwZMgQREREYMGAARo8eDScnJ3Tv3h26urpyt3n7D7lSRkZG6NSpE2JiYvDgwQPJITl1fF//+usv1KtXT+aXf3UpfViBvP5LQ0xlz0dW9P29fPky6tevj71798rdj4GBgVRoLFU6q1bT9evXD9ra2jhz5gw+++wzxMXFIScnBwMGDMDLly+xf/9+3LlzB23btkVMTAwMDAxkDr0K/a4o4vLlywDefO7l3fandOzv3bun8lMSlI0hUEUuXLiAUaNGAQAGDhwIDw8P1K9fHyKRCGFhYbh586bMSa3GxsYy+ymdJSpvnbwLCKpCXl86Om8+Km+fgJyTkwMAZd5jsUmTJgqFwOfPn2PgwIFISUlB37594ezsDBMTE2hra+PGjRs4cuSIzFhVps7Kqsx7t3r1atja2iIgIABr167F2rVroa+vj9GjR+Pbb7+t8ArsDz74AOHh4WjVqhXGjBmDxo0bQ0dHB9nZ2di6davc113WbWa0tbXLPKG8Jipr5qZ0eXk/uP/8809MmzYNRkZGcHFxgY2NDQwMDCASibBv3z6pCz1KP6cWFhaVqu/s2bPQ19fH4MGDK7WdMpX3va/oM75r1y6sX78eBw4cwIoVKwC8+exMnDgRy5YtkzlcW9H7UTqO6vq+5uTkwMLCQiZIVpfc3FxoaWnJ/XnXpEkTiESiSp9zp+j7+/z5cxQVFUkuXpDnxYsXMssaN25cqXrUpUGDBujSpQsuXLiAwsJCnDlzBiKRCP3798fLly8BvPmjz9raGn/99RccHR2l/tADqvZdqUjpqT3Hjh3DsWPHymwn7z2o6RgCVWTdunV4/fo1jh49KvMX9uXLlyWzaLVZaRgp67CdvKsK5fn111+RkpKCJUuW4Msvv5Rat2HDBhw5cqRqhVZSZd47HR0d+Pj4wMfHB0+ePEFsbCwCAgKwf/9+PH36FMHBwWX2c+XKFYSHh8PV1RW///671GHhS5cuYevWrcp/cTVIWZ+P0uXlXXyxevVq6Ovr4/Tp0zKze/8e89LP6ZMnTypV38GDBzF69GiMHTsWQUFB6NOnT6W2VzdDQ0N89dVX+Oqrr/DgwQOcOXMGO3fuxNatW5Gfn4+NGzdKta/o/SgdR3V9X01MTPD06VOUlJSoJQgaGxujpKQEGRkZMuEqPT0dYrFYbhBRVt8ikUihK+ffJhKJVFKPKvTv3x9XrlzBX3/9hZiYGLRv314SuG1tbXHmzBm0bNkShYWFFV5wp2yl7+v333+PmTNnVmvfqsZzAlUkMTERDRs2lAkRL1++lLnNSG3VsWNHAJB7MmxSUhIePXqk0H5Kb+kxYsQImXXnzp2rQoXCCH3vLCwsMHbsWPzxxx9o0aIFTp8+Xe4Nb0tf95AhQ2TOC1TH665uFy5ckJm5LCkpwcWLFyESiSSfL3kSExPRpk0bmQCYmpqKBw8eSC0zMjJCu3bt8PDhQ8THxytcX5cuXRAaGgpdXV2MHTsW58+fV3jbmsbOzg6TJ09GWFgYjIyMcPToUZk28j5zeXl5uHHjBho0aCA5BUFd39cePXrg9evXiImJUVkf5encuTMAyO2/dFnpaTvKmoEq1bNnT2RmZlbq81vblAa7yMhInDt3TiroDRgwADExMZJzBlVxSkDpeybvaErpoedLly4pvV91YwhUEWtra2RlZeGff/6RLCsuLsbSpUvLPeG9NnFwcICtrS2OHTsm9cNfLBZjxYoVCv8ALL01x79/yR44cAARERHKK1hBir53r1+/xoULF2S2f/HiBV68eAFdXd1yZyzKet3//PMP1q9fX9WXUePdv39f5rYWu3fvxv379zFkyJByH+VobW2NxMREqdmr/Px8zJ8/X+7pETNmzEBxcTE+//xzmWCen59f5pXcnTp1QmhoKPT09DB27NhaE84zMjLknqSelZWF169fS91ao9Tp06dx8uRJqWXr1q1DdnY2xo8fL/ksq+v7Wnqx1KJFi2Ter6KiIoWPPAhVeheGNWvWSA6NA29OWyg9TFvapvRCI0X/EK5I6S135s6dK/cq6LS0NNy5c0cpfalL3759oaOjgx07diA3NxcDBgyQrOvfvz+ePXuGX3/9FfXr15e5vZoylL5n8u5x26NHD/Ts2RNBQUFyj+6UlJSo7Y+TquLhYBWZOXMmIiMjMWzYMIwZMwb16tVDTEwMnjx5Aicnp1r7gXmblpYW/ve//2HcuHEYPXq05D6B0dHRSEtLQ4cOHfD3339XuJ/x48dj48aNWLBggeS8j5s3byIqKgru7u44dOhQNbya/6Poe/fq1SsMHToUrVq1QteuXdGsWTO8ePEC4eHhSEtLg4+Pj9xftqV69OiBHj16ICQkBKmpqejVqxdSUlJw9OhRDBkypFbe/LkyXF1dsXDhQkRERKB9+/b4559/EB4eDjMzs3LPfQLevEcLFizAgAEDMGrUKBQXF+PUqVMQi8Xo2LGjzOkW06dPR2xsLEJCQtCjRw8MHz4cxsbGSElJwcmTJ7F582aMHDlSbl8dO3ZEaGgoPDw8MG7cOPz+++9yL4aqSR4/fowBAwagY8eO6NChAywtLZGZmYkjR46gsLBQ7jPXhw4dCm9vb3h4eMDGxgaXLl3CmTNn0Lx5cyxZskTSTl3f1yFDhsDHxwebN29G9+7dMXLkSDRu3BiPHz9GdHQ05s6di08++UQlfQOAo6MjZs6ciW3btqFfv35wd3eHWCzGoUOH8OjRI8yaNQuOjo4A3tzCyMLCAsHBwZK7DYhEIsycOVPQPSYHDRqEL7/8Ej/88AO6desmua9lZmYmEhIScO7cOXz11Vdo27atsl92tTEyMkL37t1x8eJFaGlpScYS+L9ZwoyMDLi6upZ5cVNV9O/fHyKRCCtWrMDt27fRoEEDmJiYSA7/bt++He7u7vjwww/h7++PLl26QF9fHykpKbh06RIyMjKQlpam9LpUjTOBKjJs2DDs3r0bdnZ2+P333xEUFIQ2bdogMjKyTj0S6d1338XBgwfRo0cPHDx4ELt27YK1tTWOHj1a5h3//83KygphYWFwdnbG6dOnsWvXLhQUFCAkJATDhg1T7QuQQ9H3rn79+vD19YWNjQ3OnTuHH3/8EQcPHoS1tTW2b9+O5cuXl9uPtrY2fvvtN7z//vt48OABtm3bhtu3b2PFihXw9fVV9ctUu549e+LgwYPIycnBTz/9hNjYWLi5ueH48ePl3igaAD766CNs2LABDRs2xJ49e3D48GE4Ojri+PHjcn/JikQi7NixA5s2bYKVlRX279+Pbdu24erVqxgzZozcKwvf1qFDB4SGhsLAwADjxo1DbGxsFV656tnY2GDRokVo0KABoqKi4Ofnh4iICHTp0gVBQUH46KOPZLYZNWoUdu3ahYSEBPj7++Pvv//GxIkTER4eLvVdVuf3dcWKFdizZw86duyIgwcPws/PT3IrkYEDB6q0b+DNOWFbtmxBkyZNsHv3buzZswfm5ubYsmWL1B8u2tra+PXXX9GzZ0/88ccf+O677/Dtt98iKytLcN9LlizBn3/+CQcHB8l7euzYMRQUFGDRokUYN26cEl6hepWGvc6dO0t95iwsLNCqVSsAqjkUDADt2rWDn58f3nnnHWzbtg3ffvstNm/eLFlvZ2eHM2fO4IsvvsCLFy8QEBCAXbt24caNG+jXrx+2b9+ukrpUTZSVlSWuuBkREdVFAQEBmDNnDvz8/DBp0iR1l0NE1YgzgUREREQaiCGQiIiISAPxwpA6ovRh2RWxsbHhIR8iIiLiOYF1Rel5PRVxdHRUKCwSERFR3cYQSERERKSBeE4gERERkQZiCCQiIiLSQAyBRERERBqIIZCIiIhIAzEEElGt9fDhQ5iamir8iEIiIvo/DIFEpFRubm6SYFb6n7m5OVq3bg1HR0fMnj0b+/btw8uXL9VdqlqsWrUKpqamWLVqlUr7CQgIkHkfTE1NYWlpie7du+Pjjz/GX3/9pdIaiKhm482iiUglmjVrhmbNmgEAioqKkJOTg/j4ePz9998IDAzEokWL8M033+DDDz8U3Ieuri5at26trJLrpHr16qFbt26Sfz99+hRJSUlISEjA77//jjVr1uCjjz5SY4VEpC4MgUSkEpMmTcLixYullhUWFuLixYvYsmULjh49ivnz5+Pu3btYvXq1oD4sLS1x6dIlZZRbZzVp0gTh4eFSyx4/foy5c+ciMjISixcvxuDBg2FnZ6eeAolIbXg4mIiqja6uLhwdHREYGIhly5YBALZu3YpDhw6puTLNYmlpie3bt0NfXx9FRUUIDQ1Vd0lEpAYMgUSkFvPnz8e7774LAFizZo3M+tJz2B4+fIi//voLH3zwAdq0aYN33nlHcj5dWReGdOvWDaampjhw4ECZ/WdnZ6Np06YwNTXF1atXZdZHR0djypQpaN++PRo3bozmzZvD09OzzMculp6D5+bmhpKSEmzfvh0uLi6wsbGRvI6KJCQkYN68eejWrRvMzc1hYWGBjh07YuTIkVi7di1evHhR4T4U9c4776BVq1YAgAcPHsisf/ToEfz9/eHl5YWuXbuiadOmsLa2hrOzM3744Qfk5uZW+Fq+/PJL9O7dG1ZWVmjWrBl69eqFuXPnIjY2Vu42165dw8cff4xOnTrB3NwcNjY2GD58OAICAlBSUlLl10xE0hgCiUhtZs2aBQC4efMmkpOT5bYJDQ3F0KFDERkZCUtLS7Ro0QIikajc/Y4fPx4AsH///jLb/Pnnn8jPz0e7du2kzpkTi8VYsGABRo0ahYMHD+LVq1do3749dHV1ERkZiUmTJuHLL78sc79isRhTpkzBF198gadPn6JVq1YwMzMrt14AuH79OpydnbF79248efIEzZs3R9u2bVFYWIizZ89i5cqVSEtLq3A/lfHq1SsAgKGhocw6f39/LF68GGfPnoVYLIa9vT3MzMxw8+ZNfPvttxg8eDCysrLk7jcgIAB9+/bFzz//jISEBNja2sLOzg5paWnYu3cvvvvuO5ltNm3ahIEDB2L//v3IyspC69atYWxsjHPnzmHOnDmYPHkyiouLlfr6iTQdzwkkIrVxcHCASCSCWCzGpUuXYG1tLdPmm2++wezZs/HVV19BX18fwP+Fl7J4e3tjzZo1OH36NFJTU9G0aVOZNqUB0dvbW2r5pk2bsG3bNlhZWWHdunUYNmyYZN3Jkyfx8ccf4+eff0aPHj1ktgWACxcuwNjYGMHBwXBxcQHw5sKYUosXL5Y5VxJ4Mxuam5uL9957D2vXrkWDBg0k6zIyMhASEgJjY+NyX3dl3Lx5E4mJiQCALl26yKwfPHgwhg0bBgcHB2hra0uWp6Sk4Msvv8TRo0fh6+uLDRs2SG0XFRUFHx8flJSU4KOPPsKSJUukZmovX76Ma9euSW0THByMZcuWwcTEBKtXr8b48eOhpfVmjuLKlSuYMWMGwsLCsG7dOixYsEBJI0BEnAkkIrUxNTWVBJunT5/KbePs7IyVK1dKAiAAGBgYlLtfOzs79O3bF8XFxXIPCT948ADnz5+HlpYW3nvvPcnyrKws/PDDD9DW1sbevXulAiAAuLq6Yt26dQAgE35KFRcX44cffpAEQADQ0dGBjk75f3Pfu3cPAODj4yMVAAGgUaNG+Oijj9C4ceNy96GI9PR0HDx4EJMmTUJJSQnatm2L0aNHy7RzdnaGk5OTVAAE3lz1/csvv0BXVxcHDhyQmZ1btmwZSkpK4O3tjR9++EHmUH3Pnj0xY8YMyb+Liorw9ddfAwC2bNmCCRMmSAIgAHTv3h07duyASCSCn58fCgoKqjgCRFSKM4FEpFZGRkbIyclBXl6e3PWTJ08WtF9vb2+cO3cO+/fvh4+Pj9S633//HWKxGO+++y4sLS0lyyMiIpCXl4eePXtKHSJ+2/Dhw6Grq4s7d+7InWU0NjbGmDFjKl2vtbU17t27h+DgYHTo0EEqCFVFcnKy3Jtpa2lpwcPDAz/88AN0dXXlbpuTk4OQkBBcuHABqampePXqFcRisWT7vLw8xMfHo02bNgDenKN5/fp1AMAXX3yhUH2XL19GcnIyzM3N4e7uLrdN165dYW1tjaSkJFy7dg29e/dWaN9EVD6GQCJSq9Lw9+/Zr1Lt2rUTtN/Ro0dj4cKF+PvvvxEXF4fOnTtL1v32228AZA8F37x5E8CbMPPvWcC3lZ6T+OjRI5kQ2KpVqwpn/eT5z3/+g9OnT2PDhg3Yv38/XFxc0Lt3bzg4OEhClhBv3yewsLAQycnJePr0KfT09NC1a1c0adJE7naxsbGYOnUq0tPTy91/Zmam5P/funULgPRFJxUpHfNXr16VO+bPnz8H8GbMiUg5GAKJSG2eP3+OnJwcACgzjMi7aEERJiYmGDFiBIKDg7F//35JCLx06RLi4+NhbGwsM/NUeqFDenp6heEHgNynngit991330VoaCjWrVuHmJgYBAQEICAgAMCbILx48WJ4eHhUer//vk+gWCzGwYMH8fHHH8PX1xf169fHzJkzpbbJycnBlClTkJGRAWdnZ3z22Wfo0KEDTE1NJbOGHTt2REpKCgoLCyXblV4xbGJionB9pWOek5OD8+fPV9heU580Q6QKDIFEpDZnz56V/P9evXopff/e3t4IDg5GUFAQVqxYAW1tbckFIe7u7jKBrX79+pLttm7dqvR6KuLk5AQnJye8fPkSly5dwvnz5xEaGoq///4bU6ZMwYEDBzB48OAq9SESiTB69GhkZmZi/vz5+PrrrzFixAjJ010A4Pjx48jIyECzZs2wf/9+mXMwxWKx3CuDS8/vzM7OVrie0jHv168fjhw5IuAVEZFQvDCEiNTmp59+AvDm6lQrKyul79/V1RVNmjTB06dPcfLkSRQUFCA4OBgAMGHCBJn29vb2AIC///5b6bVUhqGhIZydnbFw4ULExMRIZgC3b9+utD6mTp0Ke3t7vHr1Ct9++63UutJ7Gnbr1k3uRTi3bt2Sew5nhw4dALw5RHz//n2F6igd89u3b/NegETVjCGQiNRi/fr1iI6OBgAsXLhQJX1oa2tj7NixAN6cB3js2DE8f/4c1tbWcHJykmk/bNgwGBgY4MaNGzh16pRKaqoskUiEPn36AACePHmitP1qaWlJxv33339HfHy8ZF1p8CvrvoSbNm2Su9zGxkZy/uH69esVqsPBwQEWFhbIzMzEr7/+qnD9RFR1DIFEVG2Kiopw9uxZTJgwAcuXLwcAzJ07FyNGjFBZn6UXfxw5ckQykzZ+/Hi5N5xu3Lix5KrWKVOmIDAwUOoef8Cb8xgDAwOxdOlSpdY5ZcoUhIaGypzzlpiYiN27dwN4c7sUZRo1ahTs7e1RXFyM77//XrK8X79+AICLFy9i165dkuUFBQVYuXIlDhw4AD09Pbn79PX1hZaWFvbt24eFCxfKHDb+66+/pGY09fT0JJ+FBQsW4Mcff5S5D2ReXh4OHjwoc5U3EVWNKCsrS6zuIoio7nBzc0NsbCyaNWsmOc+suLgYOTk5SEpKkvyCNzExwfLlyzFlyhS5+ym9rcn169dha2srt83Dhw8lNzou6+kVwJtQU3rlKvAmiLRs2VJuW7FYjK+//loy22VkZISWLVtCR0cHT58+RUpKCsRiMRwdHaUeIRcQEIA5c+bILFeUjY0NcnJyoKOjg+bNm8PExATPnz9HQkICxGIxWrZsiaNHj5Z5Ac2/ldZjbW2NGzdulNnu4MGDmDJlCrS1tXHhwgXJVb2zZs2SXEVtYWGBpk2bIj4+Hjk5Ofjqq6+we/duJCcn49ChQ+jfv7/UPvfu3YvPPvsMhYWF0NXVRZs2bSASiZCUlIScnBy5Y+Tv74+lS5eiqKgI+vr6aNWqFfT19fHs2TM8fPgQJSUlFb4WIqocXhhCRCqRkpKClJQUAG9mexo0aIAWLVqgc+fOGDBgAEaPHl3hTZ+VZcKECZKZu169epUZAIE3h1+XL1+O0aNH45dffsHZs2dx584dFBcXo1GjRnB1dcWQIUPg5uam1Bq3bt2KU6dO4cKFC3jy5AkSExNhaGiIbt26wc3NDTNnzlTqE0NKlc4G3rp1C99//z22bdsGAPjxxx9hb2+PvXv34sGDB3j16hW6dOmCWbNmYeTIkZLZSXnef/999OnTBz/++CNOnz6N+Ph46OnpwcLCAqNHj5Z7Pubs2bPh6uqKn3/+GdHR0UhMTMTr16/xzjvvoF+/fhg8eDBGjhyp9NdPpMk4E0hERESkgXhOIBEREZEGYggkIiIi0kAMgUREREQaiCGQiIiISAMxBBIRERFpIIZAIiIiIg3EEEhERESkgRgCiYiIiDQQQyARERGRBmIIJCIiItJADIFEREREGoghkIiIiEgDMQQSERERaSCGQCIiIiIN9P8AeNBb2BilFlMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(searched['driver_race'], searched[\"prop_searched\"])\n", + "plt.xlabel(\"Driver's Race\")\n", + "plt.ylabel(\"Proportion of Searches\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see from this barchart that Black drivers are searched much more often than drivers of any other race. Over 70% of searches conducted in 2020 were of Black drivers!\n", + "\n", + "Are these searches successful? If these were necessary searches, offices should be finding contraband more often when searching Black drivers." + ] + }, + { + "cell_type": "code", + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -1718,8 +1817,8 @@ " driver_race\n", " num_searched\n", " num_hit\n", - " prop_hit\n", " prop_searched\n", + " prop_hit\n", " \n", " \n", " \n", @@ -1728,64 +1827,64 @@ " am_indian\n", " 3\n", " 1\n", - " 0.333333\n", " 0.000590\n", + " 0.333333\n", " \n", " \n", " 1\n", " asian\n", " 31\n", " 12\n", - " 0.387097\n", " 0.006101\n", + " 0.387097\n", " \n", " \n", " 2\n", " black\n", " 3712\n", " 980\n", - " 0.264009\n", " 0.730565\n", + " 0.264009\n", " \n", " \n", " 3\n", " hispanic\n", " 1140\n", " 317\n", - " 0.278070\n", " 0.224365\n", + " 0.278070\n", " \n", " \n", " 4\n", " other\n", " 5\n", " 3\n", - " 0.600000\n", " 0.000984\n", + " 0.600000\n", " \n", " \n", " 5\n", " white\n", " 190\n", " 66\n", - " 0.347368\n", " 0.037394\n", + " 0.347368\n", " \n", " \n", "\n", "" ], "text/plain": [ - " driver_race num_searched num_hit prop_hit prop_searched\n", - "0 am_indian 3 1 0.333333 0.000590\n", - "1 asian 31 12 0.387097 0.006101\n", - "2 black 3712 980 0.264009 0.730565\n", - "3 hispanic 1140 317 0.278070 0.224365\n", - "4 other 5 3 0.600000 0.000984\n", - "5 white 190 66 0.347368 0.037394" + " driver_race num_searched num_hit prop_searched prop_hit\n", + "0 am_indian 3 1 0.000590 0.333333\n", + "1 asian 31 12 0.006101 0.387097\n", + "2 black 3712 980 0.730565 0.264009\n", + "3 hispanic 1140 317 0.224365 0.278070\n", + "4 other 5 3 0.000984 0.600000\n", + "5 white 190 66 0.037394 0.347368" ] }, - "execution_count": 44, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1795,11 +1894,41 @@ "searched" ] }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(searched['driver_race'], searched[\"prop_hit\"])\n", + "plt.xlabel(\"Driver's Race\")\n", + "plt.ylabel(\"Proportion of Searches Resulting in a Hit\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "American Indian, Asian, and other drivers all have small numbers of searches. Focusing on the 3 races with enough searches to analyze, we see that, despite being searched more often, searches of Black drivers result in a hit slightly less often than searches of White drivers. " + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here, we can see that Black and Hispanic drivers are also searched more often than other races despite all races having similar hit rates. In other words, though contraband is found in similar rates across all races, police search Black and Hispanic drivers for contraband more often than other drivers. This type of investigation is called an **outcomes analysis** since we are comparing the outcomes (hits) of searches. " + "In other words, though contraband is found in similar rates across Black, Hispanic, and White drivers, police search Black and Hispanic drivers for contraband more often than other drivers. This type of investigation is called an **outcomes analysis** since we are comparing the outcomes (hits) of searches. " ] }, { From 9a9f93a06ff4480e734eef428cf2b8b17a806fd5 Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Tue, 22 Aug 2023 16:05:45 -0500 Subject: [PATCH 02/12] adding boostrap CI --- textbook/16/2/investigation.ipynb | 83 ++++++++++++++++++++++++++++--- 1 file changed, 77 insertions(+), 6 deletions(-) diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index 1b08d7a1..a33f9734 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -385,7 +385,52 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "So, there were 15,905 traffic stops made in the district surrounding Hyde Park in 2020. We can also investigate the reason for the traffic stops." + "So, there were 15,905 traffic stops made in the district surrounding Hyde Park in 2020. \n", + "\n", + "We can create a histogram to see the distribution of numbers of stops per police beat." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Distribution of Traffice Stops By Beat')" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(idot_20.groupby(\"beat\")[\"reason\"].count());\n", + "plt.xlabel(\"Number of Traffic Stops\")\n", + "plt.ylabel(\"Frequency\")\n", + "plt.title(\"Distribution of Traffice Stops By Beat\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This shows that there is a wide range of numbers of stops in each police beat, with one beat having around 6,000 stops in 2020.\n", + "\n", + "\n", + "We can also investigate the reason for the traffic stops." ] }, { @@ -1555,7 +1600,7 @@ "source": [ "## Searches\n", "\n", - "Our data doesn't just have information on stops. It also has information on whether the driver or car were searched during the traffic stop. Let's investigate this by race as well." + "Our data doesn't just have information on stops. It also has information on whether the driver or car were searched during the traffic stop. Let's investigate searches and hits by race as well. This type of investigation is called an **outcomes analysis** since we are comparing the outcomes (hits) of searches. " ] }, { @@ -1896,12 +1941,12 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 55, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1913,7 +1958,7 @@ "source": [ "plt.bar(searched['driver_race'], searched[\"prop_hit\"])\n", "plt.xlabel(\"Driver's Race\")\n", - "plt.ylabel(\"Proportion of Searches Resulting in a Hit\")\n", + "plt.ylabel(\"Proportion of Successful Searches\")\n", "plt.show()" ] }, @@ -1928,7 +1973,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In other words, though contraband is found in similar rates across Black, Hispanic, and White drivers, police search Black and Hispanic drivers for contraband more often than other drivers. This type of investigation is called an **outcomes analysis** since we are comparing the outcomes (hits) of searches. " + "We see a slightly taller bar for White drivers in the previous barchart. It would be interesting to know if contraband is found on White drivers significantly more often than Black drivers. Let's add a confidence interval to the point estimates shown in the plot. We will focus on the three most common races in our data: Black, Hispanic, and White." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "props_white = np.array([])\n", + "props_black = np.array([])\n", + "props_hispanic = np.array([])\n", + "for i in np.arange(1000):\n", + " bootstrap_sample = original_sample.sample(len(original_sample),replace=True)\n", + " searched = original_sample.groupby(\"driver_race\")[[\"any_search\",\"search_hit\"]].sum().reset_index().rename(columns={\"any_search\":\"num_searched\", \"search_hit\":\"num_hit\"})\n", + " searched['prop_hit'] = searched['num_hit'] / searched['num_searched']\n", + " resampled_white = searched[searched.driver_race == \"white\"][\"prop_hit\"]\n", + " resampled_black = searched[searched.driver_race == \"black\"][\"prop_hit\"]\n", + " resampled_hispanic = searched[searched.driver_race == \"hispanic\"][\"prop_hit\"]\n", + " props_white = np.append(props_white, resampled_white)\n", + " props_black = np.append(props_black, resampled_black)\n", + " props_hispanic = np.append(props_hispanic, resampled_hispanic)\n", + "\n", + "plt.bar(searched['driver_race'], searched[\"prop_hit\"])\n", + "plt.xlabel(\"Driver's Race\")\n", + "plt.ylabel(\"Proportion of Successful Searches\")\n", + "plt.show()" ] }, { From 37076274806e62049bfacb2d3a212034d0c85e2b Mon Sep 17 00:00:00 2001 From: W Trimble Date: Tue, 22 Aug 2023 12:48:16 -0500 Subject: [PATCH 03/12] Moved 16 csv files into textbook/data directory --- textbook/07/1/Functions_to_DataFrames.ipynb | 2 +- textbook/07/3/Groups.ipynb | 2 +- textbook/07/4/pivots.ipynb | 2 +- textbook/08/3/Set_Based_Similarity.ipynb | 2 +- textbook/08/5/Reduced_Alphabets.ipynb | 4 ++-- textbook/08/6/Levinshtein.ipynb | 6 +++--- textbook/09/1/Libraries.ipynb | 4 ++-- textbook/09/2/Categorical_Data.ipynb | 2 +- textbook/09/3/Numerical_Data.ipynb | 2 +- textbook/10/1/causality.ipynb | 2 +- textbook/13/1/HypothesisTesting_1_Consistency.ipynb | 2 +- textbook/13/2/HypothesisTesting_2_Test.ipynb | 2 +- textbook/13/3/HypothesisTesting_3_TwoSample.ipynb | 2 +- textbook/13/4/HypothesisTesting_4_Categorical.ipynb | 2 +- textbook/14/2/ConfidenceIntervals_2_Bootstrap.ipynb | 2 +- .../14/3/ConfidenceIntervals_3_PercentileBootstrap.ipynb | 2 +- textbook/14/ConfidenceIntervals_Intro.ipynb | 2 +- textbook/16/2/investigation.ipynb | 4 ++-- textbook/17/1/prediction.ipynb | 2 +- textbook/17/2/correlation.ipynb | 2 +- textbook/{07 => }/data/Data_Science_Jobs_Salaries.csv | 0 textbook/{17/1 => data}/Housing.csv | 0 textbook/{08/5 => data}/Names_2010Census.csv | 0 textbook/{13/1 => data}/Natality2016.csv | 0 textbook/{08/6 => data}/SINGLE.txt | 0 textbook/{14 => data}/Salaries.csv | 0 textbook/{11/4 => data}/US_births_2000-2014_SSA.csv | 0 textbook/{08/1 => data}/address_list.csv | 0 textbook/{16/2 => data}/adjusted_population_beat.csv | 0 textbook/{13/4 => data}/gss.csv | 0 textbook/{16/2 => data}/idot_abbrv.csv | 0 textbook/{08/3 => data}/nametable.csv | 0 textbook/{10/1 => data}/simpsons_paradox_covid.csv | 0 textbook/{07 => }/data/student_scores_data.csv | 0 34 files changed, 25 insertions(+), 25 deletions(-) rename textbook/{07 => }/data/Data_Science_Jobs_Salaries.csv (100%) rename textbook/{17/1 => data}/Housing.csv (100%) rename textbook/{08/5 => data}/Names_2010Census.csv (100%) rename textbook/{13/1 => data}/Natality2016.csv (100%) rename textbook/{08/6 => data}/SINGLE.txt (100%) rename textbook/{14 => data}/Salaries.csv (100%) rename textbook/{11/4 => data}/US_births_2000-2014_SSA.csv (100%) rename textbook/{08/1 => data}/address_list.csv (100%) rename textbook/{16/2 => data}/adjusted_population_beat.csv (100%) rename textbook/{13/4 => data}/gss.csv (100%) rename textbook/{16/2 => data}/idot_abbrv.csv (100%) rename textbook/{08/3 => data}/nametable.csv (100%) rename textbook/{10/1 => data}/simpsons_paradox_covid.csv (100%) rename textbook/{07 => }/data/student_scores_data.csv (100%) diff --git a/textbook/07/1/Functions_to_DataFrames.ipynb b/textbook/07/1/Functions_to_DataFrames.ipynb index 23efcf4c..b0d15350 100644 --- a/textbook/07/1/Functions_to_DataFrames.ipynb +++ b/textbook/07/1/Functions_to_DataFrames.ipynb @@ -159,7 +159,7 @@ } ], "source": [ - "student_scores_df = pd.read_csv('../data/student_scores_data.csv')\n", + "student_scores_df = pd.read_csv('../../data/student_scores_data.csv')\n", "student_scores_df.head(5)" ] }, diff --git a/textbook/07/3/Groups.ipynb b/textbook/07/3/Groups.ipynb index 550368a9..39794364 100644 --- a/textbook/07/3/Groups.ipynb +++ b/textbook/07/3/Groups.ipynb @@ -689,7 +689,7 @@ } ], "source": [ - "salary_data = pd.read_csv(\"../data/Data_Science_Jobs_Salaries.csv\")\n", + "salary_data = pd.read_csv(\"../../data/Data_Science_Jobs_Salaries.csv\")\n", "salary_data.head(5)" ] }, diff --git a/textbook/07/4/pivots.ipynb b/textbook/07/4/pivots.ipynb index 0c3f591a..ae05fcc3 100644 --- a/textbook/07/4/pivots.ipynb +++ b/textbook/07/4/pivots.ipynb @@ -174,7 +174,7 @@ } ], "source": [ - "salary_data = pd.read_csv(\"../data/Data_Science_Jobs_Salaries.csv\")\n", + "salary_data = pd.read_csv(\"../../data/Data_Science_Jobs_Salaries.csv\")\n", "\n", "salary_data.head(5)" ] diff --git a/textbook/08/3/Set_Based_Similarity.ipynb b/textbook/08/3/Set_Based_Similarity.ipynb index 8612802a..d36c2acb 100644 --- a/textbook/08/3/Set_Based_Similarity.ipynb +++ b/textbook/08/3/Set_Based_Similarity.ipynb @@ -755,7 +755,7 @@ } ], "source": [ - "nametable= pd.read_csv(\"nametable.csv\")\n", + "nametable= pd.read_csv(\"../../data/nametable.csv\")\n", "nametable" ] }, diff --git a/textbook/08/5/Reduced_Alphabets.ipynb b/textbook/08/5/Reduced_Alphabets.ipynb index f18af653..d333cd93 100644 --- a/textbook/08/5/Reduced_Alphabets.ipynb +++ b/textbook/08/5/Reduced_Alphabets.ipynb @@ -394,7 +394,7 @@ ], "source": [ "import pandas as pd\n", - "surnames2010 = pd.read_csv(\"Names_2010Census.csv\")\n", + "surnames2010 = pd.read_csv(\"../../data/Names_2010Census.csv\")\n", "surnames2010" ] }, @@ -547,7 +547,7 @@ "metadata": {}, "outputs": [], "source": [ - "surnames2010 = pd.read_csv(\"Names_2010Census.csv\", na_filter=False )" + "surnames2010 = pd.read_csv(\"../../data/Names_2010Census.csv\", na_filter=False )" ] }, { diff --git a/textbook/08/6/Levinshtein.ipynb b/textbook/08/6/Levinshtein.ipynb index da421122..49c8d658 100644 --- a/textbook/08/6/Levinshtein.ipynb +++ b/textbook/08/6/Levinshtein.ipynb @@ -438,7 +438,7 @@ "outputs": [], "source": [ "import pandas as pd\n", - "words = pd.read_csv(\"SINGLE.txt\", header=None)" + "words = pd.read_csv(\"../../data/SINGLE.txt\", header=None)" ] }, { @@ -772,7 +772,7 @@ "metadata": {}, "outputs": [], "source": [ - "words = pd.read_csv(\"SINGLE.txt\", header=None, dtype=\"str\")" + "words = pd.read_csv(\"../../data/SINGLE.txt\", header=None, dtype=\"str\")" ] }, { @@ -854,7 +854,7 @@ "metadata": {}, "outputs": [], "source": [ - "words = pd.read_csv(\"SINGLE.txt\", header=None, na_filter=False)" + "words = pd.read_csv(\"../../data/SINGLE.txt\", header=None, na_filter=False)" ] }, { diff --git a/textbook/09/1/Libraries.ipynb b/textbook/09/1/Libraries.ipynb index 37e76683..5449a418 100644 --- a/textbook/09/1/Libraries.ipynb +++ b/textbook/09/1/Libraries.ipynb @@ -126,7 +126,7 @@ "\n", "from io import StringIO\n", "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)" + "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(../../data/NorthAmerica_Military_USD_PercentGDP_Combined_csv)" ] }, { @@ -324,7 +324,7 @@ } ], "source": [ - "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", + "military = pd.read_csv(../../data/NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", "\n", "military" ] diff --git a/textbook/09/2/Categorical_Data.ipynb b/textbook/09/2/Categorical_Data.ipynb index 484b4d0d..c882a3cc 100644 --- a/textbook/09/2/Categorical_Data.ipynb +++ b/textbook/09/2/Categorical_Data.ipynb @@ -111,7 +111,7 @@ "\n", "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", "\n", - "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", + "military = pd.read_csv(../../data/NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", "\n", "import warnings\n", "warnings.filterwarnings('ignore')" diff --git a/textbook/09/3/Numerical_Data.ipynb b/textbook/09/3/Numerical_Data.ipynb index 430a0480..99da178d 100644 --- a/textbook/09/3/Numerical_Data.ipynb +++ b/textbook/09/3/Numerical_Data.ipynb @@ -103,7 +103,7 @@ "\n", "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", "\n", - "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')" + "military = pd.read_csv(../../data/NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')" ] }, { diff --git a/textbook/10/1/causality.ipynb b/textbook/10/1/causality.ipynb index 236d7205..f7d37942 100644 --- a/textbook/10/1/causality.ipynb +++ b/textbook/10/1/causality.ipynb @@ -140,7 +140,7 @@ } ], "source": [ - "covid = pd.read_csv(\"simpsons_paradox_covid.csv\")\n", + "covid = pd.read_csv(\"../../data/simpsons_paradox_covid.csv\")\n", "covid.head()" ] }, diff --git a/textbook/13/1/HypothesisTesting_1_Consistency.ipynb b/textbook/13/1/HypothesisTesting_1_Consistency.ipynb index 3c0aceac..947dec36 100644 --- a/textbook/13/1/HypothesisTesting_1_Consistency.ipynb +++ b/textbook/13/1/HypothesisTesting_1_Consistency.ipynb @@ -253,7 +253,7 @@ ], "source": [ "#data from CDC\n", - "natality2016=pd.read_csv(\"Natality2016.csv\")\n", + "natality2016=pd.read_csv(\"../../data/Natality2016.csv\")\n", "natality2016.head(3)" ] }, diff --git a/textbook/13/2/HypothesisTesting_2_Test.ipynb b/textbook/13/2/HypothesisTesting_2_Test.ipynb index fb051a18..afc61960 100644 --- a/textbook/13/2/HypothesisTesting_2_Test.ipynb +++ b/textbook/13/2/HypothesisTesting_2_Test.ipynb @@ -18,7 +18,7 @@ "import matplotlib.pyplot as plt\n", "plt.style.use('fivethirtyeight')\n", "\n", - "natality2016=pd.read_csv(\"Natality2016.csv\")" + "natality2016=pd.read_csv(\"../../data/Natality2016.csv\")" ] }, { diff --git a/textbook/13/3/HypothesisTesting_3_TwoSample.ipynb b/textbook/13/3/HypothesisTesting_3_TwoSample.ipynb index 519c396b..47ac7eaf 100644 --- a/textbook/13/3/HypothesisTesting_3_TwoSample.ipynb +++ b/textbook/13/3/HypothesisTesting_3_TwoSample.ipynb @@ -166,7 +166,7 @@ } ], "source": [ - "diabetes=pd.read_csv(\"diabetes.csv\")\n", + "diabetes=pd.read_csv(\"../../data/diabetes.csv\")\n", "diabetes.head(5)" ] }, diff --git a/textbook/13/4/HypothesisTesting_4_Categorical.ipynb b/textbook/13/4/HypothesisTesting_4_Categorical.ipynb index 7ddd0c83..bb79c68f 100644 --- a/textbook/13/4/HypothesisTesting_4_Categorical.ipynb +++ b/textbook/13/4/HypothesisTesting_4_Categorical.ipynb @@ -123,7 +123,7 @@ } ], "source": [ - "gss=pd.read_csv(\"gss.csv\")\n", + "gss=pd.read_csv(\"../../data/gss.csv\")\n", "gss" ] }, diff --git a/textbook/14/2/ConfidenceIntervals_2_Bootstrap.ipynb b/textbook/14/2/ConfidenceIntervals_2_Bootstrap.ipynb index a1b6ccd9..94467561 100644 --- a/textbook/14/2/ConfidenceIntervals_2_Bootstrap.ipynb +++ b/textbook/14/2/ConfidenceIntervals_2_Bootstrap.ipynb @@ -18,7 +18,7 @@ "import matplotlib.pyplot as plt\n", "plt.style.use('fivethirtyeight')\n", "\n", - "population_salary=pd.read_csv(\"Salaries.csv\")" + "population_salary=pd.read_csv(\"../../data/Salaries.csv\")" ] }, { diff --git a/textbook/14/3/ConfidenceIntervals_3_PercentileBootstrap.ipynb b/textbook/14/3/ConfidenceIntervals_3_PercentileBootstrap.ipynb index 84cf28c7..86ea881d 100644 --- a/textbook/14/3/ConfidenceIntervals_3_PercentileBootstrap.ipynb +++ b/textbook/14/3/ConfidenceIntervals_3_PercentileBootstrap.ipynb @@ -18,7 +18,7 @@ "import matplotlib.pyplot as plt\n", "plt.style.use('fivethirtyeight')\n", "\n", - "population_salary=pd.read_csv(\"Salaries.csv\")" + "population_salary=pd.read_csv(\"../../data/Salaries.csv\")" ] }, { diff --git a/textbook/14/ConfidenceIntervals_Intro.ipynb b/textbook/14/ConfidenceIntervals_Intro.ipynb index 9cb60b06..29d313a6 100644 --- a/textbook/14/ConfidenceIntervals_Intro.ipynb +++ b/textbook/14/ConfidenceIntervals_Intro.ipynb @@ -58,7 +58,7 @@ } ], "source": [ - "population_salary=pd.read_csv(\"Salaries.csv\")\n", + "population_salary=pd.read_csv(\"../../data/Salaries.csv\")\n", "population_salary.shape" ] }, diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index e4dbc829..c26d54e5 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -127,7 +127,7 @@ } ], "source": [ - "idot = pd.read_csv('./idot_abbrv.csv')\n", + "idot = pd.read_csv('../../data/idot_abbrv.csv')\n", "idot.head()" ] }, @@ -869,7 +869,7 @@ } ], "source": [ - "pop = pd.read_csv('./adjusted_population_beat.csv')\n", + "pop = pd.read_csv('../../data/adjusted_population_beat.csv')\n", "pop.head()" ] }, diff --git a/textbook/17/1/prediction.ipynb b/textbook/17/1/prediction.ipynb index 1edfea3d..ecff6e62 100644 --- a/textbook/17/1/prediction.ipynb +++ b/textbook/17/1/prediction.ipynb @@ -153,7 +153,7 @@ } ], "source": [ - "housing_df = pd.read_csv(\"Housing.csv\")\n", + "housing_df = pd.read_csv(\"../../data/Housing.csv\")\n", "housing_df.head()" ] }, diff --git a/textbook/17/2/correlation.ipynb b/textbook/17/2/correlation.ipynb index 62ba85c0..bdcdf3dd 100644 --- a/textbook/17/2/correlation.ipynb +++ b/textbook/17/2/correlation.ipynb @@ -249,7 +249,7 @@ } ], "source": [ - "heights_df = pd.read_csv(\"../../12/3/galton.csv\")\n", + "heights_df = pd.read_csv(\"../../data/galton.csv\")\n", "heights_df.head()" ] }, diff --git a/textbook/07/data/Data_Science_Jobs_Salaries.csv b/textbook/data/Data_Science_Jobs_Salaries.csv similarity index 100% rename from textbook/07/data/Data_Science_Jobs_Salaries.csv rename to textbook/data/Data_Science_Jobs_Salaries.csv diff --git a/textbook/17/1/Housing.csv b/textbook/data/Housing.csv similarity index 100% rename from textbook/17/1/Housing.csv rename to textbook/data/Housing.csv diff --git a/textbook/08/5/Names_2010Census.csv b/textbook/data/Names_2010Census.csv similarity index 100% rename from textbook/08/5/Names_2010Census.csv rename to textbook/data/Names_2010Census.csv diff --git a/textbook/13/1/Natality2016.csv b/textbook/data/Natality2016.csv similarity index 100% rename from textbook/13/1/Natality2016.csv rename to textbook/data/Natality2016.csv diff --git a/textbook/08/6/SINGLE.txt b/textbook/data/SINGLE.txt similarity index 100% rename from textbook/08/6/SINGLE.txt rename to textbook/data/SINGLE.txt diff --git a/textbook/14/Salaries.csv b/textbook/data/Salaries.csv similarity index 100% rename from textbook/14/Salaries.csv rename to textbook/data/Salaries.csv diff --git a/textbook/11/4/US_births_2000-2014_SSA.csv b/textbook/data/US_births_2000-2014_SSA.csv similarity index 100% rename from textbook/11/4/US_births_2000-2014_SSA.csv rename to textbook/data/US_births_2000-2014_SSA.csv diff --git a/textbook/08/1/address_list.csv b/textbook/data/address_list.csv similarity index 100% rename from textbook/08/1/address_list.csv rename to textbook/data/address_list.csv diff --git a/textbook/16/2/adjusted_population_beat.csv b/textbook/data/adjusted_population_beat.csv similarity index 100% rename from textbook/16/2/adjusted_population_beat.csv rename to textbook/data/adjusted_population_beat.csv diff --git a/textbook/13/4/gss.csv b/textbook/data/gss.csv similarity index 100% rename from textbook/13/4/gss.csv rename to textbook/data/gss.csv diff --git a/textbook/16/2/idot_abbrv.csv b/textbook/data/idot_abbrv.csv similarity index 100% rename from textbook/16/2/idot_abbrv.csv rename to textbook/data/idot_abbrv.csv diff --git a/textbook/08/3/nametable.csv b/textbook/data/nametable.csv similarity index 100% rename from textbook/08/3/nametable.csv rename to textbook/data/nametable.csv diff --git a/textbook/10/1/simpsons_paradox_covid.csv b/textbook/data/simpsons_paradox_covid.csv similarity index 100% rename from textbook/10/1/simpsons_paradox_covid.csv rename to textbook/data/simpsons_paradox_covid.csv diff --git a/textbook/07/data/student_scores_data.csv b/textbook/data/student_scores_data.csv similarity index 100% rename from textbook/07/data/student_scores_data.csv rename to textbook/data/student_scores_data.csv From 694828516f411744f6346bffa86a7720f8408b74 Mon Sep 17 00:00:00 2001 From: W Trimble Date: Tue, 22 Aug 2023 16:31:53 -0500 Subject: [PATCH 04/12] Cleanup: neglected to move one file; fixing some broken internal links --- textbook/12/3/galton.csv => data | 0 textbook/04/4/Arrays-Slicing.ipynb | 2 +- textbook/05/3/Control_Statements_Iteration.ipynb | 2 +- textbook/07/1/Functions_to_DataFrames.ipynb | 2 +- textbook/10/3/sampling.ipynb | 2 +- textbook/11/4/Probability_4_BirthdayPb_RelaxedAssumptions.ipynb | 2 +- textbook/12/3/normal.ipynb | 2 +- textbook/12/4/binomial.ipynb | 2 +- 8 files changed, 7 insertions(+), 7 deletions(-) rename textbook/12/3/galton.csv => data (100%) diff --git a/textbook/12/3/galton.csv b/data similarity index 100% rename from textbook/12/3/galton.csv rename to data diff --git a/textbook/04/4/Arrays-Slicing.ipynb b/textbook/04/4/Arrays-Slicing.ipynb index 2d26fd71..b1280730 100644 --- a/textbook/04/4/Arrays-Slicing.ipynb +++ b/textbook/04/4/Arrays-Slicing.ipynb @@ -46,7 +46,7 @@ "id": "d8b545b5", "metadata": {}, "source": [ - "1D arrays can be indexed similarly to how lists are indexed, as mentioned in the [Lists](../../1/Lists) section of Chapter 4.\n", + "1D arrays can be indexed similarly to how lists are indexed, as mentioned in the [Lists](../1/Lists) section of Chapter 4.\n", "\n", "A single colon (:) can be used to slice a range of elements. If used between the numbers *j* and *k*, slicing the elements of an array will return all elements between *j* and *k*, **excluding** ***k***:" ] diff --git a/textbook/05/3/Control_Statements_Iteration.ipynb b/textbook/05/3/Control_Statements_Iteration.ipynb index 8bc6a3ef..8bd307ae 100644 --- a/textbook/05/3/Control_Statements_Iteration.ipynb +++ b/textbook/05/3/Control_Statements_Iteration.ipynb @@ -354,7 +354,7 @@ "id": "25e09fb1", "metadata": {}, "source": [ - "In [Section 4.1: Lists](../../1/Lists.html) we created the following list of prime numbers:" + "In [Section 4.1: Lists](../1/Lists.html) we created the following list of prime numbers:" ] }, { diff --git a/textbook/07/1/Functions_to_DataFrames.ipynb b/textbook/07/1/Functions_to_DataFrames.ipynb index b0d15350..d136b5e6 100644 --- a/textbook/07/1/Functions_to_DataFrames.ipynb +++ b/textbook/07/1/Functions_to_DataFrames.ipynb @@ -28,7 +28,7 @@ "id": "92e8b786", "metadata": {}, "source": [ - "Now that we know the foundations of [DataFrames](../../../06/DataFrames.html) and [functions](../../../03/5/IntroFunctions.html), we can discuss how to use functions directly on columns or rows of our DataFrame." + "Now that we know the foundations of [DataFrames](../../06/DataFrames.html) and [functions](../../03/5/IntroFunctions.html), we can discuss how to use functions directly on columns or rows of our DataFrame." ] }, { diff --git a/textbook/10/3/sampling.ipynb b/textbook/10/3/sampling.ipynb index ce1af389..dbff29a6 100644 --- a/textbook/10/3/sampling.ipynb +++ b/textbook/10/3/sampling.ipynb @@ -147,7 +147,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Or, we can give different elements different chances of being chosen by using the argument `p` which takes in a list of the same size as marbles. Each element in the `p` list corresponds to an element of marbles, and together they must add to 1 (the reasoning for this will be explained further in the [next chapter](../../11/Probability.ipynb)). The last 3 elements are 0 since those marbles have no chance of being chosen. The first two are 0.5 or $\\frac{1}{2}$ since they have a 1 in 2 chance of being chosen. " + "Or, we can give different elements different chances of being chosen by using the argument `p` which takes in a list of the same size as marbles. Each element in the `p` list corresponds to an element of marbles, and together they must add to 1 (the reasoning for this will be explained further in the [next chapter](../../11/Probability_1_RulesDefinitions.ipynb)). The last 3 elements are 0 since those marbles have no chance of being chosen. The first two are 0.5 or $\\frac{1}{2}$ since they have a 1 in 2 chance of being chosen. " ] }, { diff --git a/textbook/11/4/Probability_4_BirthdayPb_RelaxedAssumptions.ipynb b/textbook/11/4/Probability_4_BirthdayPb_RelaxedAssumptions.ipynb index df2903bf..dd2ccd48 100644 --- a/textbook/11/4/Probability_4_BirthdayPb_RelaxedAssumptions.ipynb +++ b/textbook/11/4/Probability_4_BirthdayPb_RelaxedAssumptions.ipynb @@ -184,7 +184,7 @@ } ], "source": [ - "birth_data = pd.read_csv(\"US_births_2000-2014_SSA.csv\")\n", + "birth_data = pd.read_csv(\"../../data/US_births_2000-2014_SSA.csv\")\n", "birth_data" ] }, diff --git a/textbook/12/3/normal.ipynb b/textbook/12/3/normal.ipynb index d64a3c16..de6b0738 100644 --- a/textbook/12/3/normal.ipynb +++ b/textbook/12/3/normal.ipynb @@ -1 +1 @@ -{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"tAzM3r78p08k","tags":["remove-cell"]},"outputs":[],"source":["import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","%matplotlib inline"]},{"cell_type":"markdown","metadata":{"id":"HtrRcRR0uFAM"},"source":["# Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"q0LoZTYHoCuw"},"source":["Let's consider another distribution by considering real data.\n","\n","Below we load in the Galton Height Data. This dataset was collected from families and contains heights of the father, mother, children. We focus on the father heights, and plot the distribution of heights in a histogram."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":235},"executionInfo":{"elapsed":188,"status":"ok","timestamp":1689610841357,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"UOdUEyhemMef","outputId":"79220073-def2-4067-bec0-293762a2f8a4"},"outputs":[{"data":{"text/html":["\n","\n","
\n","
\n","
\n","\n","\n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n","
familyfathermothermidparentHeightchildrenchildNumgenderchildHeight
0178.567.075.4341male73.2
1178.567.075.4342female69.2
2178.567.075.4343female69.0
3178.567.075.4344female69.0
4275.566.573.6641male73.5
5275.566.573.6642male72.5
\n","
\n"," \n","\n","\n","\n","
\n"," \n","
\n","\n","\n","\n"," \n","\n"," \n"," \n","\n"," \n","
\n","
\n"],"text/plain":[" family father mother midparentHeight children childNum gender \\\n","0 1 78.5 67.0 75.43 4 1 male \n","1 1 78.5 67.0 75.43 4 2 female \n","2 1 78.5 67.0 75.43 4 3 female \n","3 1 78.5 67.0 75.43 4 4 female \n","4 2 75.5 66.5 73.66 4 1 male \n","5 2 75.5 66.5 73.66 4 2 male \n","\n"," childHeight \n","0 73.2 \n","1 69.2 \n","2 69.0 \n","3 69.0 \n","4 73.5 \n","5 72.5 "]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["galton_df = pd.read_csv(\"galton.csv\")\n","galton_df.head(6)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":1567,"status":"ok","timestamp":1689610867384,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"6Mi-17cNm1oG","outputId":"93ce9d81-264e-49aa-c749-3c4867921b15"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["bin_size=np.arange(60, 80.5, 1)\n","plt.hist(galton_df[\"father\"], bins = bin_size, density = True)\n","plt.title('Father heights')\n","plt.xlabel('heights (in inches)')\n","plt.ylabel('Probabilities')\n","plt.scatter(galton_df['father'].mean(), 0, color='red', s=60);\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"MO3r-9W6moSJ"},"source":["This is another empirical distribution, but a special one!\n","An empirical *normal* distribution.\n","\n","The values for the normal distribution are continous variables - as heights can take on any real number in a given range."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"ja0QmiNunQY0"},"source":["## Normal Probability Distribution\n","\n","Arguably one of the most important continuous distributions, the normal distribution is a common distribution of heights, weights, and SAT scores, to name a few.\n","This distribution is symmetric and bell-shaped, giving it the nickname \"bell-curve\". The three measures of center: mode, median, and mean, are exactly the same for the normal distribution. Further, the distribution itself is defined entirely in terms of its mean and standard deviation. Notationally, given a random variable $X$ that is normally distributed, we can say $X \\sim N(\\mu,\\sigma)$, where $\\mu$ and $\\sigma$ are the mean and standard deviation of the distribution, respectively.\n","\n","\n","Below is a plot of a normal distribution, with the mean in red on the graph. We use the scipy library and the *normal* function by calling\n","\n","```python\n","stats.norm(µ, σ)\n","```\n","where the arguments correspond to the mean and standard deviation of the normal distribution. To get the corresponding $y$ values, we call the pdf method on a given array of x-values:\n","```python\n","stats.norm(µ, σ).pdf(x)\n","```"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":480,"status":"ok","timestamp":1689622686716,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"cFM9Aj9QAvxi","outputId":"3fe0093d-f87d-4ee2-a46a-bdd4555ffbff"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["from scipy import stats\n","\n","snd = stats.norm(0, 1)\n","\n","#generates 100 values from -5 to 5, equally spaced\n","x = np.linspace(-5, 5, 100)\n","\n","plt.plot(x, snd.pdf(x))\n","plt.scatter(0, 0, color='red', s=60);\n","\n","plt.xlim(-5, 5)\n","plt.title('Normal Distribution')\n","plt.xlabel('Values of Random Variable X')\n","plt.ylabel('Probability')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"lMLzxQhPDN3x"},"source":["While there is not an easy formula to compute probabilities by hand, the normal curve itself can be written as a function $$f(x)=\\frac{1}{\\sigma \\sqrt{2\\pi}}e^{\\left(-\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^{2}\\right)},$$ where probabilites of interest are calculated by finding area under the curve.\n"]},{"cell_type":"markdown","metadata":{"id":"b_amsPoPFuY5"},"source":["## Standard Deviation and the Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"2Qd1emqtF1IZ"},"source":["Remember how we said standard deviation was a good measure of spread? One reason is because it can be used to bound the data. In particular, a majority of the data that is normally distributed falls within one standard deviation of the mean: about $68.27\\%$ of the data! About $95.45\\%$ of the data falls within two standard deviations, and roughly $99.73\\%$ falls within three standard deviations.\n","\n","![](normal_std_plot.png)"]},{"cell_type":"markdown","metadata":{"id":"OsTsmVkDYAdn"},"source":["The special case of the normal distribution is called the **standard normal** distribution and occurs when $\\mu = 0$ and $\\sigma = 1$.\n","Given a random variable and any values for $\\mu$ and $\\sigma$, that is $X ∼ N(\\mu, \\sigma)$, we can *transform* to a standard normal, by normalizing it! That is:\n","\n","$$\\frac{X-\\mu}{\\sigma}$$\n","\n","Note this may be useful if you are comparing values from multiple normal distributions."]},{"cell_type":"markdown","metadata":{"id":"aGmmlswknQdG"},"source":["## Central Limit Theorem"]},{"cell_type":"markdown","metadata":{"id":"EvrgC9pP1Rg4"},"source":["Recall the rolling of the die example from [the previous section](../12/2/uniform.html). Now, suppose I am not interested in each roll but in the average value of all the dice rolls of students in my classroom. I have 50 students present and each student rolls 1 die. I then take the mean of all 50 dice rolls. What is the probability distribution for the average dice roll? This is another question can be easily answered through simulation!"]},{"cell_type":"markdown","metadata":{"id":"3-gnT0Dp0qqf"},"source":["Simulations use a computer to mimic real experiments. Returning to our dice-rolling example from the [the previous section](../12/2/uniform.html), instead of asking all of my students to roll dice and take the mean 100s or 1000s of times to plot an empirical distribution (which would be both cumbersome and time consuming), I can have the computer do it for us. First, we can write code that does this experiment one time. We use `sample` to roll our die and `np.mean` to take the average."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"hKfpyHL90qqg","outputId":"dd3d4011-2fc9-4a26-dbef-80989804cd1b"},"outputs":[{"data":{"text/plain":["Face 3.6\n","dtype: float64"]},"execution_count":2,"metadata":{},"output_type":"execute_result"}],"source":["import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","%matplotlib inline\n","\n","die = pd.DataFrame(\n"," {\n"," 'Face': np.arange(1, 7),\n"," }\n",")\n","np.mean(die.sample(50, replace=True))"]},{"cell_type":"markdown","metadata":{"id":"jw3scddc0qqg"},"source":["The next step is to write a function that can repeat the experiment a certain number of times. We can do this using a `for loop` and saving the results of each experiment in a `numpy` array."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vWcmm54V0qqg"},"outputs":[],"source":["def face_mean_sim(nsim):\n"," \"\"\"Simulates nsim repetions of 50 dice rolls and returns their sample mean.\"\"\"\n"," np.random.seed(1234)\n"," means = np.array([])\n"," for i in np.arange(nsim):\n"," means = np.append(means, np.mean(die.sample(50, replace=True)))\n"," return means"]},{"cell_type":"markdown","metadata":{"id":"BLV1ElBdDYRC"},"source":["If we repeat the experiment 10 times we get an idea of what the means look like. Plotting a histogram we see the empirical distribution of these 10 experiments. In particular, we find that 3 of these 10 experiments have a mean of around 3.45, while all experiments have a mean in the range 3.22 to 3.76."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vdGI2hEGDTn-","outputId":"88008e86-b9bb-4869-c128-3242640e9180"},"outputs":[{"data":{"text/plain":["array([3.42, 3.5 , 3.24, 3.44, 3.22, 3.6 , 3.08, 3.76, 3.66, 3.46])"]},"execution_count":3,"metadata":{},"output_type":"execute_result"}],"source":["ten_runs = face_mean_sim(10)\n","ten_runs"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":295},"id":"hWV_0YWlD7C5","outputId":"ffff25a8-2fb5-48ff-d139-89c5f672febb"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["plt.hist(ten_runs);\n","plt.xlabel('Mean')\n","plt.ylabel('Frequency')\n","plt.title('Mean Dice Roll Simulation: Ten Runs')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"XFod8VdI0qqg"},"source":["It is difficult to determine what this distribution looks like with only 10 runs, so we experiment by ploting the empirical distributions of results from 100, 1000, and 10000 replications of the dice rolling experiment."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":585},"id":"2OAHXHU80qqg","outputId":"2121369d-e903-4d89-b726-5abf80360976"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["fig, axs = plt.subplots(3, figsize=(8, 8))\n","fig.suptitle('Mean Dice Roll Simulation: 100, 1000, and 10000', fontsize=16)\n","fig.tight_layout()\n","axs[0].hist(face_mean_sim(100), 30);\n","axs[1].hist(face_mean_sim(1_000), 30);\n","axs[2].hist(face_mean_sim(10_000),30);"]},{"cell_type":"markdown","metadata":{"id":"YXasPZ5g0qqg"},"source":["As we saw with our Uniform Distribution experiment, with larger numbers of experiments/samples our empirical distribution approaches the true probability distribution.\n","\n","Based on our empirical distribution with 10000 experiments, we can see that the average value of the dice rolls is symmetric and approximately bell-shaped with a mean of around 3.5. In fact, these properties of being approximately bell-shaped and symmetric are distinct to the empirical *normal distribution*.\n","\n","As we are plotting the distribution means of samples from a uniform distribution, the resulting probability distribution will always take on this shape, that is it will always be approximately normal, as long as the sample size is sufficiently large. This is due to an important mathematical theorem, the *Central Limit Theorem*[^***]. The Central Limit Theorem (CLT) states that if you take sufficiently large random samples from a population with replacement, the distribution of sample means will be approximately normally distributed. The CLT is a property of sample means and holds true for samples from *any* distribution, not just the uniform distribution of dice rolls. For example, the distribution of average heights, average weights, and average test scores of data science students would all be approximately normally distributed as long as we take large enough random samples from our population with replacement.\n","\n"]},{"cell_type":"markdown","metadata":{"id":"0VW8nyQG4Vot"},"source":["In the [the previous section](../12/1/uniform.html) we calculated the mean and standard deviation of the uniform distribution of our dice rolls. The CLT allows us to use these to learn the mean (μ) and standard deviation (σ) of our distribution of sample means. According to the Central Limit Theorem, if the mean and standard deviation of the population you are sampling from are $\\mu$ and $\\sigma$ respectively, then the mean and standard deviation of the distribution of sample means are $\\mu$ and $\\frac{σ}{\\sqrt{n}}$ respectively where n is the sample size. Therefore, since we know from earlier that the mean of the uniform dice rolling distribution is 3.5 and the standard deviation is 1.71, the mean of the distribution of sample means is also 3.5 and the standard deviation is $\\frac{1.71}{\\sqrt{50}} = 0.24$. Let's investigate this further using our empirical distribution."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LhLQc4oD3zUB","outputId":"1c38e57a-04d1-4d1b-ddd3-9dace39f8bf0"},"outputs":[{"data":{"text/plain":["3.4967740000000007"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["np.mean(face_mean_sim(10_000))"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"05URqhM234nV","outputId":"8599cfc7-2f21-4e2c-93e5-a140323e1eba"},"outputs":[{"data":{"text/plain":["0.23814748707471173"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["np.std(face_mean_sim(10_000))"]},{"cell_type":"markdown","metadata":{"id":"cnPp3SB24KBQ"},"source":["Our empirical distribution matches what we expected to see mathematically according to the Central Limit Theorem!"]},{"cell_type":"markdown","metadata":{"id":"wrdpcFZg8BaL"},"source":["[^***]: For more information on the Central Limit Theorem, see the online Statistics Textbook at [OpenStax](https://cnx.org/contents/MBiUQmmY@25.39:MVbL0vFO@10/Introduction)"]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3.9.13 64-bit","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.9.13"},"vscode":{"interpreter":{"hash":"aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"}}},"nbformat":4,"nbformat_minor":0} +{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"tAzM3r78p08k","tags":["remove-cell"]},"outputs":[],"source":["import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","%matplotlib inline"]},{"cell_type":"markdown","metadata":{"id":"HtrRcRR0uFAM"},"source":["# Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"q0LoZTYHoCuw"},"source":["Let's consider another distribution by considering real data.\n","\n","Below we load in the Galton Height Data. This dataset was collected from families and contains heights of the father, mother, children. We focus on the father heights, and plot the distribution of heights in a histogram."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":235},"executionInfo":{"elapsed":188,"status":"ok","timestamp":1689610841357,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"UOdUEyhemMef","outputId":"79220073-def2-4067-bec0-293762a2f8a4"},"outputs":[{"data":{"text/html":["\n","\n","
\n","
\n","
\n","\n","\n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n","
familyfathermothermidparentHeightchildrenchildNumgenderchildHeight
0178.567.075.4341male73.2
1178.567.075.4342female69.2
2178.567.075.4343female69.0
3178.567.075.4344female69.0
4275.566.573.6641male73.5
5275.566.573.6642male72.5
\n","
\n"," \n","\n","\n","\n","
\n"," \n","
\n","\n","\n","\n"," \n","\n"," \n"," \n","\n"," \n","
\n","
\n"],"text/plain":[" family father mother midparentHeight children childNum gender \\\n","0 1 78.5 67.0 75.43 4 1 male \n","1 1 78.5 67.0 75.43 4 2 female \n","2 1 78.5 67.0 75.43 4 3 female \n","3 1 78.5 67.0 75.43 4 4 female \n","4 2 75.5 66.5 73.66 4 1 male \n","5 2 75.5 66.5 73.66 4 2 male \n","\n"," childHeight \n","0 73.2 \n","1 69.2 \n","2 69.0 \n","3 69.0 \n","4 73.5 \n","5 72.5 "]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["galton_df = pd.read_csv(\"galton.csv\")\n","galton_df.head(6)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":1567,"status":"ok","timestamp":1689610867384,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"6Mi-17cNm1oG","outputId":"93ce9d81-264e-49aa-c749-3c4867921b15"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["bin_size=np.arange(60, 80.5, 1)\n","plt.hist(galton_df[\"father\"], bins = bin_size, density = True)\n","plt.title('Father heights')\n","plt.xlabel('heights (in inches)')\n","plt.ylabel('Probabilities')\n","plt.scatter(galton_df['father'].mean(), 0, color='red', s=60);\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"MO3r-9W6moSJ"},"source":["This is another empirical distribution, but a special one!\n","An empirical *normal* distribution.\n","\n","The values for the normal distribution are continous variables - as heights can take on any real number in a given range."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"ja0QmiNunQY0"},"source":["## Normal Probability Distribution\n","\n","Arguably one of the most important continuous distributions, the normal distribution is a common distribution of heights, weights, and SAT scores, to name a few.\n","This distribution is symmetric and bell-shaped, giving it the nickname \"bell-curve\". The three measures of center: mode, median, and mean, are exactly the same for the normal distribution. Further, the distribution itself is defined entirely in terms of its mean and standard deviation. Notationally, given a random variable $X$ that is normally distributed, we can say $X \\sim N(\\mu,\\sigma)$, where $\\mu$ and $\\sigma$ are the mean and standard deviation of the distribution, respectively.\n","\n","\n","Below is a plot of a normal distribution, with the mean in red on the graph. We use the scipy library and the *normal* function by calling\n","\n","```python\n","stats.norm(µ, σ)\n","```\n","where the arguments correspond to the mean and standard deviation of the normal distribution. To get the corresponding $y$ values, we call the pdf method on a given array of x-values:\n","```python\n","stats.norm(µ, σ).pdf(x)\n","```"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":480,"status":"ok","timestamp":1689622686716,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"cFM9Aj9QAvxi","outputId":"3fe0093d-f87d-4ee2-a46a-bdd4555ffbff"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["from scipy import stats\n","\n","snd = stats.norm(0, 1)\n","\n","#generates 100 values from -5 to 5, equally spaced\n","x = np.linspace(-5, 5, 100)\n","\n","plt.plot(x, snd.pdf(x))\n","plt.scatter(0, 0, color='red', s=60);\n","\n","plt.xlim(-5, 5)\n","plt.title('Normal Distribution')\n","plt.xlabel('Values of Random Variable X')\n","plt.ylabel('Probability')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"lMLzxQhPDN3x"},"source":["While there is not an easy formula to compute probabilities by hand, the normal curve itself can be written as a function $$f(x)=\\frac{1}{\\sigma \\sqrt{2\\pi}}e^{\\left(-\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^{2}\\right)},$$ where probabilites of interest are calculated by finding area under the curve.\n"]},{"cell_type":"markdown","metadata":{"id":"b_amsPoPFuY5"},"source":["## Standard Deviation and the Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"2Qd1emqtF1IZ"},"source":["Remember how we said standard deviation was a good measure of spread? One reason is because it can be used to bound the data. In particular, a majority of the data that is normally distributed falls within one standard deviation of the mean: about $68.27\\%$ of the data! About $95.45\\%$ of the data falls within two standard deviations, and roughly $99.73\\%$ falls within three standard deviations.\n","\n","![](normal_std_plot.png)"]},{"cell_type":"markdown","metadata":{"id":"OsTsmVkDYAdn"},"source":["The special case of the normal distribution is called the **standard normal** distribution and occurs when $\\mu = 0$ and $\\sigma = 1$.\n","Given a random variable and any values for $\\mu$ and $\\sigma$, that is $X ∼ N(\\mu, \\sigma)$, we can *transform* to a standard normal, by normalizing it! That is:\n","\n","$$\\frac{X-\\mu}{\\sigma}$$\n","\n","Note this may be useful if you are comparing values from multiple normal distributions."]},{"cell_type":"markdown","metadata":{"id":"aGmmlswknQdG"},"source":["## Central Limit Theorem"]},{"cell_type":"markdown","metadata":{"id":"EvrgC9pP1Rg4"},"source":["Recall the rolling of the die example from [the previous section](../../12/2/uniform.html). Now, suppose I am not interested in each roll but in the average value of all the dice rolls of students in my classroom. I have 50 students present and each student rolls 1 die. I then take the mean of all 50 dice rolls. What is the probability distribution for the average dice roll? This is another question can be easily answered through simulation!"]},{"cell_type":"markdown","metadata":{"id":"3-gnT0Dp0qqf"},"source":["Simulations use a computer to mimic real experiments. Returning to our dice-rolling example from the [the previous section](../../12/2/uniform.html), instead of asking all of my students to roll dice and take the mean 100s or 1000s of times to plot an empirical distribution (which would be both cumbersome and time consuming), I can have the computer do it for us. First, we can write code that does this experiment one time. We use `sample` to roll our die and `np.mean` to take the average."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"hKfpyHL90qqg","outputId":"dd3d4011-2fc9-4a26-dbef-80989804cd1b"},"outputs":[{"data":{"text/plain":["Face 3.6\n","dtype: float64"]},"execution_count":2,"metadata":{},"output_type":"execute_result"}],"source":["import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","%matplotlib inline\n","\n","die = pd.DataFrame(\n"," {\n"," 'Face': np.arange(1, 7),\n"," }\n",")\n","np.mean(die.sample(50, replace=True))"]},{"cell_type":"markdown","metadata":{"id":"jw3scddc0qqg"},"source":["The next step is to write a function that can repeat the experiment a certain number of times. We can do this using a `for loop` and saving the results of each experiment in a `numpy` array."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vWcmm54V0qqg"},"outputs":[],"source":["def face_mean_sim(nsim):\n"," \"\"\"Simulates nsim repetions of 50 dice rolls and returns their sample mean.\"\"\"\n"," np.random.seed(1234)\n"," means = np.array([])\n"," for i in np.arange(nsim):\n"," means = np.append(means, np.mean(die.sample(50, replace=True)))\n"," return means"]},{"cell_type":"markdown","metadata":{"id":"BLV1ElBdDYRC"},"source":["If we repeat the experiment 10 times we get an idea of what the means look like. Plotting a histogram we see the empirical distribution of these 10 experiments. In particular, we find that 3 of these 10 experiments have a mean of around 3.45, while all experiments have a mean in the range 3.22 to 3.76."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vdGI2hEGDTn-","outputId":"88008e86-b9bb-4869-c128-3242640e9180"},"outputs":[{"data":{"text/plain":["array([3.42, 3.5 , 3.24, 3.44, 3.22, 3.6 , 3.08, 3.76, 3.66, 3.46])"]},"execution_count":3,"metadata":{},"output_type":"execute_result"}],"source":["ten_runs = face_mean_sim(10)\n","ten_runs"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":295},"id":"hWV_0YWlD7C5","outputId":"ffff25a8-2fb5-48ff-d139-89c5f672febb"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["plt.hist(ten_runs);\n","plt.xlabel('Mean')\n","plt.ylabel('Frequency')\n","plt.title('Mean Dice Roll Simulation: Ten Runs')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"XFod8VdI0qqg"},"source":["It is difficult to determine what this distribution looks like with only 10 runs, so we experiment by ploting the empirical distributions of results from 100, 1000, and 10000 replications of the dice rolling experiment."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":585},"id":"2OAHXHU80qqg","outputId":"2121369d-e903-4d89-b726-5abf80360976"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["fig, axs = plt.subplots(3, figsize=(8, 8))\n","fig.suptitle('Mean Dice Roll Simulation: 100, 1000, and 10000', fontsize=16)\n","fig.tight_layout()\n","axs[0].hist(face_mean_sim(100), 30);\n","axs[1].hist(face_mean_sim(1_000), 30);\n","axs[2].hist(face_mean_sim(10_000),30);"]},{"cell_type":"markdown","metadata":{"id":"YXasPZ5g0qqg"},"source":["As we saw with our Uniform Distribution experiment, with larger numbers of experiments/samples our empirical distribution approaches the true probability distribution.\n","\n","Based on our empirical distribution with 10000 experiments, we can see that the average value of the dice rolls is symmetric and approximately bell-shaped with a mean of around 3.5. In fact, these properties of being approximately bell-shaped and symmetric are distinct to the empirical *normal distribution*.\n","\n","As we are plotting the distribution means of samples from a uniform distribution, the resulting probability distribution will always take on this shape, that is it will always be approximately normal, as long as the sample size is sufficiently large. This is due to an important mathematical theorem, the *Central Limit Theorem*[^***]. The Central Limit Theorem (CLT) states that if you take sufficiently large random samples from a population with replacement, the distribution of sample means will be approximately normally distributed. The CLT is a property of sample means and holds true for samples from *any* distribution, not just the uniform distribution of dice rolls. For example, the distribution of average heights, average weights, and average test scores of data science students would all be approximately normally distributed as long as we take large enough random samples from our population with replacement.\n","\n"]},{"cell_type":"markdown","metadata":{"id":"0VW8nyQG4Vot"},"source":["In the [the previous section](../../12/1/uniform.html) we calculated the mean and standard deviation of the uniform distribution of our dice rolls. The CLT allows us to use these to learn the mean (μ) and standard deviation (σ) of our distribution of sample means. According to the Central Limit Theorem, if the mean and standard deviation of the population you are sampling from are $\\mu$ and $\\sigma$ respectively, then the mean and standard deviation of the distribution of sample means are $\\mu$ and $\\frac{σ}{\\sqrt{n}}$ respectively where n is the sample size. Therefore, since we know from earlier that the mean of the uniform dice rolling distribution is 3.5 and the standard deviation is 1.71, the mean of the distribution of sample means is also 3.5 and the standard deviation is $\\frac{1.71}{\\sqrt{50}} = 0.24$. Let's investigate this further using our empirical distribution."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LhLQc4oD3zUB","outputId":"1c38e57a-04d1-4d1b-ddd3-9dace39f8bf0"},"outputs":[{"data":{"text/plain":["3.4967740000000007"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["np.mean(face_mean_sim(10_000))"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"05URqhM234nV","outputId":"8599cfc7-2f21-4e2c-93e5-a140323e1eba"},"outputs":[{"data":{"text/plain":["0.23814748707471173"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["np.std(face_mean_sim(10_000))"]},{"cell_type":"markdown","metadata":{"id":"cnPp3SB24KBQ"},"source":["Our empirical distribution matches what we expected to see mathematically according to the Central Limit Theorem!"]},{"cell_type":"markdown","metadata":{"id":"wrdpcFZg8BaL"},"source":["[^***]: For more information on the Central Limit Theorem, see the online Statistics Textbook at [OpenStax](https://cnx.org/contents/MBiUQmmY@25.39:MVbL0vFO@10/Introduction)"]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3.9.13 64-bit","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.9.13"},"vscode":{"interpreter":{"hash":"aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"}}},"nbformat":4,"nbformat_minor":0} diff --git a/textbook/12/4/binomial.ipynb b/textbook/12/4/binomial.ipynb index 2b0cd811..f1e815d7 100644 --- a/textbook/12/4/binomial.ipynb +++ b/textbook/12/4/binomial.ipynb @@ -1 +1 @@ -{"cells":[{"cell_type":"code","execution_count":2,"metadata":{"id":"ISsA-8KSIY6e","tags":["remove-cell"]},"outputs":[],"source":["import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","%matplotlib inline"]},{"cell_type":"markdown","metadata":{"id":"APw6oRCNOWHW"},"source":["# Binomial Distribution\n","\n","As the prefix *bi-* implies, the Binomial Probability distribution describes a situation with two possible outcomes - often times described as 'success' or 'failure'.\n","\n","## Bernoulli Trials\n","\n","Statisticians call any random experiment with two possible outcomes as described above a **Bernoulli Trial**. For example, flipping a coin has two outcomes: \"Heads\" or \"Tails\" each with a fixed probability. Each independent coin flip would be a Bernoulli trial. Many other scenarios can be presented as Bernoulli trials as well. Consider a standard, shuffled deck of cards. I am interested in whether the top card in the deck is a 7. The card either is or is not a 7 (two options) so independent events of flipping the top card of a shuffled deck are Bernoulli trials.\n","\n","## What is the Binomial Distribution?\n","\n","The **Binomial distribution** describes the probability of specific types of experiments called a sequence of Bernoulli trials. Such a sequence satisfies\n","\n","* There are a fixed, $n$, number of trials\n","* There are exactly two possibile outcomes - often times described as 'success' or 'failure'.\n","* Each trial is independent (i.e. does not depend on outcomes of previous trials)\n","* The probability of success, $p$, is the same for each trial\n","\n","\n","Examples satifiying these requirements include: flipping a coin 5 times to see how many heads occur or having 6 children to see how many girls are born. In each of these cases, we are dealing with counts of successes. This means that the binomial distribution is a *discrete* probability distribution."]},{"cell_type":"markdown","metadata":{"id":"hGQqDSdmzu51"},"source":["## Binomial Empirical Distribution\n","\n","Let's again consider our six-sided die for a different experiment! Suppose we are interested in rolling a die and getting an even number. We want to know what happens if we repeat this trial 10 times, what is the probability that we have 1 success (1 even), 2 successes (2 evens), 3 successes...?\n","\n","This example is indeed a sequence of Bernoulli trials as there are a fixed $n=10$ number of trials, there are exactly two outcomes: evens - 'success' and odds - 'failure', each trail is independent, and the probability of success is $p=0.5$.\n","To determine what this distribution looks like through observation, we would repeat this experiment 100, 1000 or more times to get an empirical distribution.\n","\n","Recall in [Section 5.2: Conditional Statements](../05/2/Control_Statements_conditionals.ipynb) we experimented with a parity function which finds the number of even dice rolls when rolling a six-sided die five times.\n","\n","Below we'll redefine the six-sided die and re-run our simulation from Section 5.2 with experiments of size 10, 100, and 1,000."]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":475},"executionInfo":{"elapsed":354,"status":"ok","timestamp":1689102186899,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"lCeh_hQxukCu","outputId":"7782de35-f992-442a-fdd5-229f182f77fb"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["die = np.arange(1, 7)\n","\n","def parity(input_integer):\n"," if (input_integer % 2) == 0:\n"," return \"even\"\n"," else:\n"," return \"odd\"\n","\n","vec_parity = np.vectorize(parity)\n","\n","np.random.seed(1234)\n","\n","def parity_experiment(num_experiments):\n"," total_evens = np.empty(0)\n"," for i in np.arange(num_experiments):\n"," choices = np.random.choice(die, 5)\n"," labels = vec_parity(choices)\n","\n"," total_evens = np.append(total_evens, sum(labels == 'even'))\n","\n"," legend = f'Even numbers with {num_experiments:,} repetitions'\n","\n"," options, counts = np.unique(total_evens, return_counts=True)\n"," pd.DataFrame({legend:counts}, index=options).plot.bar()\n","\n"," plt.xlabel('Number of Evens')\n"," plt.ylabel(\"Frequency\");\n","\n","parity_experiment(10)"]},{"cell_type":"markdown","metadata":{"id":"jvnkT-_Zz2HZ"},"source":["This histogram records the observed number of evens (out of 5 dice rolls) with this experiment repeated num_experiment=10 times. For example, there were 2 evens recorded from 4 experiments, 3 evens recorded from 3 experiments, and 4 evens recorded from 2 experiments.\n","\n","The empirical probability of 2 evens rolled out of 5 is $4/10=0.4$.\n","\n","We repeat the experiment below by changing the num_experiments to 100 and then 1000 to see the resulting empirical distribution."]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":475},"executionInfo":{"elapsed":330,"status":"ok","timestamp":1689102191823,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"f2NwgPC-ukMC","outputId":"a8542aa7-ce60-4c6b-bfd5-9515560b7ca0"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["np.random.seed(1234)\n","parity_experiment(100)"]},{"cell_type":"markdown","metadata":{"id":"1SMho1lxJQhg"},"source":["Above the empirical probability of 2 even numbers rolled out of 5 is $33/100 = 0.33$."]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":475},"executionInfo":{"elapsed":357,"status":"ok","timestamp":1689102217375,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"AGS-xOhoukSq","outputId":"1d5a7343-f280-4c77-ce83-c7815835413f"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["parity_experiment(1000)"]},{"cell_type":"markdown","metadata":{"id":"AHt7CUOZJ2lC"},"source":["And above the observed probability that 2 even numbers were rolled in 5 tosses of the die is $304/1000 = 0.304$."]},{"cell_type":"markdown","metadata":{"id":"-0zN7fRpz2cT"},"source":["## Binomial Probability Distribution\n","For the event that we just simulated, we have the ability to calculate the probabilities for each event in the sample space.\n","In particular, we can assign probabilites corresponding to the number of successes. For a trial of $n$ experiments, we are interested in the probability of exactly $j$ successes, where $1 \\leq j \\leq n$.\n","Given a sequence of Bernoulli trials, we define a random variable $X$ that records the number of successes. The discrete distribution function for $X$ is called the Binomial Probability Distribution and its pmf is given by:\n","\n","> $P(X=j) = b(n,p,j) = {n \\choose j} p^j (1-p)^{n-j}.$\n","\n"]},{"cell_type":"markdown","metadata":{"id":"r3KNiOH-LHoy"},"source":["To dissect this formula, we first expand on the notation ${n \\choose j}$, read \"n choose j\". In general, for non-negative numbers $n$ and $j$ with $0 \\leq j \\leq n$, ${n \\choose j}$ counts the number of ways to choose $j$ objects from a set of $n$ while ignoring the order. Mathematically, we have:\n","\n","> ${n \\choose j} = \\frac{n!}{j!(n-j)!} = \\frac{n(n-1)(n-2)\\cdot \\cdot \\cdot (n-(j-1))(n-j)!}{j! (n-j)!} = \\frac{n(n-1)(n-2)\\cdot \\cdot \\cdot (n-(j-1))}{j!},$\n","\n","\n","which says we have $n$ ways to choose the first element from a set of $n$ objects, $n-1$ ways to choose the second element from the remaining $n-1$ elements all the way up to $n-(j+1)$ ways to choose the $j^{th}$ element. But because order does not matter, that is the first element choosen is no different than the third, we have overcounted! There are $j!$ ways of ordering the $j$ chosen elements, so dividing by $j!$ gives us the number of subsets of size $j$ from an $n$ element set. The table below gives examples of how to calculate ${n \\choose j}$. Notice the pattern in results. The number of ways to choose 2 elements from a set of 5 is the same as the number of ways to 3 elements (and therefore not choose 2 elements) from a set of 5."]},{"cell_type":"markdown","metadata":{"id":"v4Cq3ciHkJUV"},"source":["| ${n \\choose j}$ | $\\frac{n!}{j!(n-j)!}$ | Number of ways
to choose j elements
from a set of n |\n","| ---------------- | ------------------ |------------------ |\n","| ${5 \\choose 0}$ | $\\frac{5*4*3*2*1}{0!(5*4*3*2*1)}$ | $=1$|\n","| ${5 \\choose 1}$ | $\\frac{5*4*3*2*1}{1!(4*3*2*1)}$ | $=5$|\n","| ${5 \\choose 2}$ |$\\frac{5*4*3*2*1}{(2*1)(3*2*1}$ | $=10$ |\n","| ${5 \\choose 3}$ | $\\frac{5*4*3*2*1}{(3*2*1)(2*1)}$ | $=10$|\n","| ${5 \\choose 4}$ | $\\frac{5*4*3*2*1}{(4*3*2*1)1!}$ | $=5$|\n","| ${5 \\choose 5}$ |$\\frac{5*4*3*2*1}{(5*4*3*2*1)0!}$ | $=1$|"]},{"cell_type":"markdown","metadata":{"id":"Lu--9AzSLHyV"},"source":["How does ${n \\choose j} p^j (1-p)^{n-j}$ count the probability of exactly $j$ successes in $n$ trials? Since the trials are independent, probabilities are multiplicative, so the probability of a sequence containing $j$ successes and $n-j$ failures is $\\underbrace{p \\cdot p \\cdot \\cdot \\cdot p}_\\text{j times} \\cdot \\underbrace{(1-p) \\cdot \\cdot \\cdot (1-p)}_\\text{n-j times} = p^j\\, (1-p)^{n-j}$. There are ${n \\choose j}$ such sequences as we are choosing $j$ places in our sequence of length $n$ to be successes. Therefore ${n \\choose j} p^j (1-p)^{n-j}$ gives the probability there are exactly $j$ succeses in $n$ trials."]},{"cell_type":"markdown","metadata":{"id":"k_O92tQz-rve"},"source":["The example above of rolling a die 10 times and considering getting an even number is a sequence of Bernoulli trials and the probability can be determined by the Binomial Probability Distribution. As mentioned above, $n=10$ and $p=0.5$ in this example. Thus $P(X=2) = b(5,0.5,2) = {5 \\choose 2} 0.5^2 (0.5)^{3} = 0.3125$. Recall above our empirical distribution gave a probability of $0.304$ for rolling 2 evens out of 5. Below we graph the bar plot in addition to a table corresponding to the probability distribution of this example.\n","\n","| P(Number of Successes) | Formula: b(n,p,j) | Probability |\n","| ---------------- | ------------------ |------------------ |\n","| P(X=0) | $b(5,0.5,0)= {5 \\choose 0} 0.5^0 (0.5)^{10}$ | $=0.03125$|\n","| P(X=1) | $b(5,0.5,1)= {5 \\choose 1} 0.5^1 (0.5)^{9}$ | $=0.15625$|\n","| P(X=2) |$b(5,0.5,2) = {5 \\choose 2}0.5^2(0.5)^{8}$ | $=0.3125$ |\n","| P(X=3) | $b(5,0.5,3) = {5 \\choose 3} 0.5^3 (0.5)^{7}$ | $=0.3125$|\n","| P(X=4) | $b(5,0.5,4)= {5 \\choose 4} 0.5^4 (0.5)^{6}$ | $=0.15625$|\n","| P(X=5) |$b(5,0.5,5) = {5 \\choose 5}0.5^5(0.5)^{5}$ | $=0.03125$|\n","\n","\n","\n","\n","\n","\n"]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":444},"executionInfo":{"elapsed":549,"status":"ok","timestamp":1689102734096,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"gxzfAzi7N10Z","outputId":"976b959f-5216-4a9c-e7e8-c0ea5c89c605"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["def binomial_prob(n, p, j):\n"," '''A function that calculates probabilities from a binomial distribution with parameters n and p'''\n"," n_choose_j = np.math.factorial(n)/(np.math.factorial(j)*np.math.factorial(n-j))\n"," return n_choose_j*p**j*(1-p)**(n-j)\n","\n","binomial_list =[]\n","n=5\n","p=0.5\n","for i in range(0,6):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of Evens in 5 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Evens')\n","plt.ylabel(\"Probability\");"]},{"cell_type":"markdown","metadata":{"id":"Kqhf9HTZj4y7"},"source":["Notice that the graph looks symmetric around 2.5. You can see the symmetry even more when we increase the number of trials. Let's look at the number of evens in 10 rolls instead of 5."]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":453},"executionInfo":{"elapsed":511,"status":"ok","timestamp":1689102814302,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"c8gaMoy9XUGc","outputId":"d1fb5788-2bbd-416f-8af2-b263618279d1"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_list =[]\n","n=10\n","p=0.5\n","for i in range(0,11):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of Evens in 10 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Evens')\n","plt.ylabel(\"Probability\");"]},{"cell_type":"markdown","metadata":{"id":"03uSxQKaXSeE"},"source":["In fact, the shape of the graph is dependent on $p$, the probability of success. The closer $p$ is to $0.5$ the more symmetric it will be. Suppose we are instead interested in rolling the number 2 on a six-sided die. Here 'success' is rolling a 2, and 'failure' is rolling anything else. Thus, $p=\\frac{1}{6}$. Below we see the probability distribution of this example."]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":453},"executionInfo":{"elapsed":998,"status":"ok","timestamp":1689102841520,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"NSURsmnwV6PE","outputId":"849e218b-a65f-4cbf-e39b-5c25cfa0448f"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_list =[]\n","n=10\n","p=1/6\n","for i in range(0,11):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of Twos in 10 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Twos')\n","plt.ylabel(\"Probability\");"]},{"cell_type":"markdown","metadata":{"id":"3W5fWUe0ls2Q"},"source":["Here we see the peak of the distribution lies around 1. With a success probability of $\\frac{1}{6}$, on average we should see about 1.6 twos in 10 tosses. Therefore a peak between 1 and 2 makes sense!\n","\n","What we just calculated was the mean of our binomial distribution, 1.6. We calculated it by multiplying the probability of success by the number of trials. In general, we can calculate the mean by drawing a sample and taking the mean empirically, or computing it based on the expected value.\n","For given parameters $n$, and $p$, the formula for the mean of a binomial distribution is $E(X) = \\mu(X) = n*p$. We can also calculate the standard deviation of the binomial distribution using $\\sigma(X) = \\sqrt{n*p*(1-p)}$. Evaluating this equation we see that the standard deviation of the binomial distribution with $n = 5$ and $p = \\frac{1}{6}$ is:\n"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":2,"status":"ok","timestamp":1689102906613,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"Iyn677ONba3F","outputId":"c7dee0ab-2d6c-41e8-997b-efcd5bb3b403"},"outputs":[{"data":{"text/plain":["1.1785113019775793"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["np.sqrt(10*(1/6)*(1-(1/6)))"]},{"cell_type":"markdown","metadata":{"id":"_E-QDNmch2-_"},"source":["## Normal Approximation to the Binomial Distribution\n","\n","We learned in the [last section](../3/normal.ipynb) that the normal distribution has a number of special properties that make it easy to use. You will learn later in this book that many statistical methods are based on the normal distribution. For this reason, it is convenient to be able to model data using the normal distribution (even when the data is not actually normally distributed!). Sometimes, we can approximate other distributions using a version of the normal distribution. Specifically, we can use a **normal approximation to the binomial distribution**.\n","\n","We can approximate a binomial distribution using a normal distribution when the number of trials, n, is 'sufficiently large'. The rule-of-thumb for deciding when n is large enough to do the approximation is to check the following:\n","- Is $np \\geq 5$?\n","- Is $n(1-p) \\geq 5$?\n","\n","If both conditions are met, you can approximate the binomial distribution with a normal distribution with mean:\n","\n","> $\\mu = np$\n","\n","and standard deviation:\n","\n","> $\\sigma = \\sqrt{np(1-p)}$\n","\n","Recall, we've been counting the number of occurrence of certain dice rolls. Let's now call a 'success' in our binomial experiment rolling either a 1 or a 6. There is a 1/3 probability of rolling a 1 or a 6 so this is our $p$. Now, let's count the number of successes in 50 dice rolls.\n","\n","First, we check if n is large enough. We have $np = 50*(1/3) \\approx 16.66 \\geq 5$ and $np = 100*(1 - 1/3) \\approx 33.33 \\geq 5$. So, we can use the approximation.\n","\n","Now, let's characterize our normal distribution. The mean is $np$ which we already calculated is approximately 16.66. The standard deviation is $\\sqrt{np(1-p)} = \\sqrt{100*(1/3)(2/3)} \\approx 3.33$.\n","\n","Below we compare the graph of the binomial distribution with n = 50 an p = 1/3 to the graph of the normal distribution with mean 16.66 and standard deviation 3.33."]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":448},"executionInfo":{"elapsed":1464,"status":"ok","timestamp":1689108344229,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"4F_zMNTqriiw","outputId":"495e0c9a-3ef8-462b-9fac-08db009b8d30"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_list =[]\n","n=50\n","p=1/3\n","for i in range(0,51):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of 1s or 6s in 50 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Ones or Sixes');\n","plt.ylabel(\"Probability\");\n","plt.xticks(rotation = 90, fontsize=7);"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":448},"executionInfo":{"elapsed":446,"status":"ok","timestamp":1689111836735,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"JjPsIwU4s_ap","outputId":"c5259d5b-9385-47c4-a3d2-d2b49c97b760"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["import scipy\n","import math\n","\n","def normal_prob(mu, sigma, x):\n"," '''A function that calculates probabilities from a normal distribution with mean mu and standard deviation sigma'''\n"," bottom = math.sqrt(2 * math.pi * sigma**2)\n"," top = math.exp(-(x - mu)**2/(2 * sigma**2))\n"," return top/bottom\n","\n","normal_list =[]\n","mu=16.66\n","sigma=3.33\n","for i in range(0,51):\n"," normal_list.append(normal_prob(mu, sigma, i))\n","\n","legend = f'Approximate Probability Distribution'\n","\n","pd.DataFrame({legend: normal_list}).plot();\n","plt.xlabel('Number of Ones or Sixes');\n","plt.ylabel(\"Probability\");\n","#plt.xticks(rotation = 90, fontsize=7);"]},{"cell_type":"markdown","metadata":{"id":"zjaN_6qWuBZO"},"source":["Now, let's view them together:"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":430},"executionInfo":{"elapsed":497,"status":"ok","timestamp":1689109464833,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"lvC1Hu-puA64","outputId":"86bf4f58-985a-4d17-cef4-51fd848142a5"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_df = pd.DataFrame({\"Real\": binomial_list})\n","normal_df = pd.DataFrame({\"Approximate\": normal_list})\n","\n","bin = plt.bar(height = binomial_df.Real, x = binomial_df.index)\n","norm, = plt.plot(normal_df, color='red')\n","plt.legend([bin, norm], ['True Probability Distribution','Approximate Probability Distribution'])\n","plt.xlabel('Number of Ones or Sixes');\n","plt.ylabel(\"Probability\");\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"Qc0T9apDxS2X"},"source":["It looks like the normal is a pretty good approximation to the binomial in this case!"]},{"cell_type":"markdown","metadata":{"id":"DlLOvh0yYWQu"},"source":["Learning about distributions like the ones presented in this chapter can help us better understand the data that we work with as data scientists. In the next few chapters, we will explore ways that statisticians and data scientists use distributions to test hypotheses about data."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"BuZFEc-iYEtr"},"outputs":[],"source":[]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3.9.13 64-bit","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.10.9"},"vscode":{"interpreter":{"hash":"aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"}}},"nbformat":4,"nbformat_minor":0} +{"cells":[{"cell_type":"code","execution_count":2,"metadata":{"id":"ISsA-8KSIY6e","tags":["remove-cell"]},"outputs":[],"source":["import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","%matplotlib inline"]},{"cell_type":"markdown","metadata":{"id":"APw6oRCNOWHW"},"source":["# Binomial Distribution\n","\n","As the prefix *bi-* implies, the Binomial Probability distribution describes a situation with two possible outcomes - often times described as 'success' or 'failure'.\n","\n","## Bernoulli Trials\n","\n","Statisticians call any random experiment with two possible outcomes as described above a **Bernoulli Trial**. For example, flipping a coin has two outcomes: \"Heads\" or \"Tails\" each with a fixed probability. Each independent coin flip would be a Bernoulli trial. Many other scenarios can be presented as Bernoulli trials as well. Consider a standard, shuffled deck of cards. I am interested in whether the top card in the deck is a 7. The card either is or is not a 7 (two options) so independent events of flipping the top card of a shuffled deck are Bernoulli trials.\n","\n","## What is the Binomial Distribution?\n","\n","The **Binomial distribution** describes the probability of specific types of experiments called a sequence of Bernoulli trials. Such a sequence satisfies\n","\n","* There are a fixed, $n$, number of trials\n","* There are exactly two possibile outcomes - often times described as 'success' or 'failure'.\n","* Each trial is independent (i.e. does not depend on outcomes of previous trials)\n","* The probability of success, $p$, is the same for each trial\n","\n","\n","Examples satifiying these requirements include: flipping a coin 5 times to see how many heads occur or having 6 children to see how many girls are born. In each of these cases, we are dealing with counts of successes. This means that the binomial distribution is a *discrete* probability distribution."]},{"cell_type":"markdown","metadata":{"id":"hGQqDSdmzu51"},"source":["## Binomial Empirical Distribution\n","\n","Let's again consider our six-sided die for a different experiment! Suppose we are interested in rolling a die and getting an even number. We want to know what happens if we repeat this trial 10 times, what is the probability that we have 1 success (1 even), 2 successes (2 evens), 3 successes...?\n","\n","This example is indeed a sequence of Bernoulli trials as there are a fixed $n=10$ number of trials, there are exactly two outcomes: evens - 'success' and odds - 'failure', each trail is independent, and the probability of success is $p=0.5$.\n","To determine what this distribution looks like through observation, we would repeat this experiment 100, 1000 or more times to get an empirical distribution.\n","\n","Recall in [Section 5.2: Conditional Statements](../../05/2/Control_Statements_conditionals.ipynb) we experimented with a parity function which finds the number of even dice rolls when rolling a six-sided die five times.\n","\n","Below we'll redefine the six-sided die and re-run our simulation from Section 5.2 with experiments of size 10, 100, and 1,000."]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":475},"executionInfo":{"elapsed":354,"status":"ok","timestamp":1689102186899,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"lCeh_hQxukCu","outputId":"7782de35-f992-442a-fdd5-229f182f77fb"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["die = np.arange(1, 7)\n","\n","def parity(input_integer):\n"," if (input_integer % 2) == 0:\n"," return \"even\"\n"," else:\n"," return \"odd\"\n","\n","vec_parity = np.vectorize(parity)\n","\n","np.random.seed(1234)\n","\n","def parity_experiment(num_experiments):\n"," total_evens = np.empty(0)\n"," for i in np.arange(num_experiments):\n"," choices = np.random.choice(die, 5)\n"," labels = vec_parity(choices)\n","\n"," total_evens = np.append(total_evens, sum(labels == 'even'))\n","\n"," legend = f'Even numbers with {num_experiments:,} repetitions'\n","\n"," options, counts = np.unique(total_evens, return_counts=True)\n"," pd.DataFrame({legend:counts}, index=options).plot.bar()\n","\n"," plt.xlabel('Number of Evens')\n"," plt.ylabel(\"Frequency\");\n","\n","parity_experiment(10)"]},{"cell_type":"markdown","metadata":{"id":"jvnkT-_Zz2HZ"},"source":["This histogram records the observed number of evens (out of 5 dice rolls) with this experiment repeated num_experiment=10 times. For example, there were 2 evens recorded from 4 experiments, 3 evens recorded from 3 experiments, and 4 evens recorded from 2 experiments.\n","\n","The empirical probability of 2 evens rolled out of 5 is $4/10=0.4$.\n","\n","We repeat the experiment below by changing the num_experiments to 100 and then 1000 to see the resulting empirical distribution."]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":475},"executionInfo":{"elapsed":330,"status":"ok","timestamp":1689102191823,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"f2NwgPC-ukMC","outputId":"a8542aa7-ce60-4c6b-bfd5-9515560b7ca0"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["np.random.seed(1234)\n","parity_experiment(100)"]},{"cell_type":"markdown","metadata":{"id":"1SMho1lxJQhg"},"source":["Above the empirical probability of 2 even numbers rolled out of 5 is $33/100 = 0.33$."]},{"cell_type":"code","execution_count":5,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":475},"executionInfo":{"elapsed":357,"status":"ok","timestamp":1689102217375,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"AGS-xOhoukSq","outputId":"1d5a7343-f280-4c77-ce83-c7815835413f"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["parity_experiment(1000)"]},{"cell_type":"markdown","metadata":{"id":"AHt7CUOZJ2lC"},"source":["And above the observed probability that 2 even numbers were rolled in 5 tosses of the die is $304/1000 = 0.304$."]},{"cell_type":"markdown","metadata":{"id":"-0zN7fRpz2cT"},"source":["## Binomial Probability Distribution\n","For the event that we just simulated, we have the ability to calculate the probabilities for each event in the sample space.\n","In particular, we can assign probabilites corresponding to the number of successes. For a trial of $n$ experiments, we are interested in the probability of exactly $j$ successes, where $1 \\leq j \\leq n$.\n","Given a sequence of Bernoulli trials, we define a random variable $X$ that records the number of successes. The discrete distribution function for $X$ is called the Binomial Probability Distribution and its pmf is given by:\n","\n","> $P(X=j) = b(n,p,j) = {n \\choose j} p^j (1-p)^{n-j}.$\n","\n"]},{"cell_type":"markdown","metadata":{"id":"r3KNiOH-LHoy"},"source":["To dissect this formula, we first expand on the notation ${n \\choose j}$, read \"n choose j\". In general, for non-negative numbers $n$ and $j$ with $0 \\leq j \\leq n$, ${n \\choose j}$ counts the number of ways to choose $j$ objects from a set of $n$ while ignoring the order. Mathematically, we have:\n","\n","> ${n \\choose j} = \\frac{n!}{j!(n-j)!} = \\frac{n(n-1)(n-2)\\cdot \\cdot \\cdot (n-(j-1))(n-j)!}{j! (n-j)!} = \\frac{n(n-1)(n-2)\\cdot \\cdot \\cdot (n-(j-1))}{j!},$\n","\n","\n","which says we have $n$ ways to choose the first element from a set of $n$ objects, $n-1$ ways to choose the second element from the remaining $n-1$ elements all the way up to $n-(j+1)$ ways to choose the $j^{th}$ element. But because order does not matter, that is the first element choosen is no different than the third, we have overcounted! There are $j!$ ways of ordering the $j$ chosen elements, so dividing by $j!$ gives us the number of subsets of size $j$ from an $n$ element set. The table below gives examples of how to calculate ${n \\choose j}$. Notice the pattern in results. The number of ways to choose 2 elements from a set of 5 is the same as the number of ways to 3 elements (and therefore not choose 2 elements) from a set of 5."]},{"cell_type":"markdown","metadata":{"id":"v4Cq3ciHkJUV"},"source":["| ${n \\choose j}$ | $\\frac{n!}{j!(n-j)!}$ | Number of ways
to choose j elements
from a set of n |\n","| ---------------- | ------------------ |------------------ |\n","| ${5 \\choose 0}$ | $\\frac{5*4*3*2*1}{0!(5*4*3*2*1)}$ | $=1$|\n","| ${5 \\choose 1}$ | $\\frac{5*4*3*2*1}{1!(4*3*2*1)}$ | $=5$|\n","| ${5 \\choose 2}$ |$\\frac{5*4*3*2*1}{(2*1)(3*2*1}$ | $=10$ |\n","| ${5 \\choose 3}$ | $\\frac{5*4*3*2*1}{(3*2*1)(2*1)}$ | $=10$|\n","| ${5 \\choose 4}$ | $\\frac{5*4*3*2*1}{(4*3*2*1)1!}$ | $=5$|\n","| ${5 \\choose 5}$ |$\\frac{5*4*3*2*1}{(5*4*3*2*1)0!}$ | $=1$|"]},{"cell_type":"markdown","metadata":{"id":"Lu--9AzSLHyV"},"source":["How does ${n \\choose j} p^j (1-p)^{n-j}$ count the probability of exactly $j$ successes in $n$ trials? Since the trials are independent, probabilities are multiplicative, so the probability of a sequence containing $j$ successes and $n-j$ failures is $\\underbrace{p \\cdot p \\cdot \\cdot \\cdot p}_\\text{j times} \\cdot \\underbrace{(1-p) \\cdot \\cdot \\cdot (1-p)}_\\text{n-j times} = p^j\\, (1-p)^{n-j}$. There are ${n \\choose j}$ such sequences as we are choosing $j$ places in our sequence of length $n$ to be successes. Therefore ${n \\choose j} p^j (1-p)^{n-j}$ gives the probability there are exactly $j$ succeses in $n$ trials."]},{"cell_type":"markdown","metadata":{"id":"k_O92tQz-rve"},"source":["The example above of rolling a die 10 times and considering getting an even number is a sequence of Bernoulli trials and the probability can be determined by the Binomial Probability Distribution. As mentioned above, $n=10$ and $p=0.5$ in this example. Thus $P(X=2) = b(5,0.5,2) = {5 \\choose 2} 0.5^2 (0.5)^{3} = 0.3125$. Recall above our empirical distribution gave a probability of $0.304$ for rolling 2 evens out of 5. Below we graph the bar plot in addition to a table corresponding to the probability distribution of this example.\n","\n","| P(Number of Successes) | Formula: b(n,p,j) | Probability |\n","| ---------------- | ------------------ |------------------ |\n","| P(X=0) | $b(5,0.5,0)= {5 \\choose 0} 0.5^0 (0.5)^{10}$ | $=0.03125$|\n","| P(X=1) | $b(5,0.5,1)= {5 \\choose 1} 0.5^1 (0.5)^{9}$ | $=0.15625$|\n","| P(X=2) |$b(5,0.5,2) = {5 \\choose 2}0.5^2(0.5)^{8}$ | $=0.3125$ |\n","| P(X=3) | $b(5,0.5,3) = {5 \\choose 3} 0.5^3 (0.5)^{7}$ | $=0.3125$|\n","| P(X=4) | $b(5,0.5,4)= {5 \\choose 4} 0.5^4 (0.5)^{6}$ | $=0.15625$|\n","| P(X=5) |$b(5,0.5,5) = {5 \\choose 5}0.5^5(0.5)^{5}$ | $=0.03125$|\n","\n","\n","\n","\n","\n","\n"]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":444},"executionInfo":{"elapsed":549,"status":"ok","timestamp":1689102734096,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"gxzfAzi7N10Z","outputId":"976b959f-5216-4a9c-e7e8-c0ea5c89c605"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["def binomial_prob(n, p, j):\n"," '''A function that calculates probabilities from a binomial distribution with parameters n and p'''\n"," n_choose_j = np.math.factorial(n)/(np.math.factorial(j)*np.math.factorial(n-j))\n"," return n_choose_j*p**j*(1-p)**(n-j)\n","\n","binomial_list =[]\n","n=5\n","p=0.5\n","for i in range(0,6):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of Evens in 5 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Evens')\n","plt.ylabel(\"Probability\");"]},{"cell_type":"markdown","metadata":{"id":"Kqhf9HTZj4y7"},"source":["Notice that the graph looks symmetric around 2.5. You can see the symmetry even more when we increase the number of trials. Let's look at the number of evens in 10 rolls instead of 5."]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":453},"executionInfo":{"elapsed":511,"status":"ok","timestamp":1689102814302,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"c8gaMoy9XUGc","outputId":"d1fb5788-2bbd-416f-8af2-b263618279d1"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_list =[]\n","n=10\n","p=0.5\n","for i in range(0,11):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of Evens in 10 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Evens')\n","plt.ylabel(\"Probability\");"]},{"cell_type":"markdown","metadata":{"id":"03uSxQKaXSeE"},"source":["In fact, the shape of the graph is dependent on $p$, the probability of success. The closer $p$ is to $0.5$ the more symmetric it will be. Suppose we are instead interested in rolling the number 2 on a six-sided die. Here 'success' is rolling a 2, and 'failure' is rolling anything else. Thus, $p=\\frac{1}{6}$. Below we see the probability distribution of this example."]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":453},"executionInfo":{"elapsed":998,"status":"ok","timestamp":1689102841520,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"NSURsmnwV6PE","outputId":"849e218b-a65f-4cbf-e39b-5c25cfa0448f"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_list =[]\n","n=10\n","p=1/6\n","for i in range(0,11):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of Twos in 10 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Twos')\n","plt.ylabel(\"Probability\");"]},{"cell_type":"markdown","metadata":{"id":"3W5fWUe0ls2Q"},"source":["Here we see the peak of the distribution lies around 1. With a success probability of $\\frac{1}{6}$, on average we should see about 1.6 twos in 10 tosses. Therefore a peak between 1 and 2 makes sense!\n","\n","What we just calculated was the mean of our binomial distribution, 1.6. We calculated it by multiplying the probability of success by the number of trials. In general, we can calculate the mean by drawing a sample and taking the mean empirically, or computing it based on the expected value.\n","For given parameters $n$, and $p$, the formula for the mean of a binomial distribution is $E(X) = \\mu(X) = n*p$. We can also calculate the standard deviation of the binomial distribution using $\\sigma(X) = \\sqrt{n*p*(1-p)}$. Evaluating this equation we see that the standard deviation of the binomial distribution with $n = 5$ and $p = \\frac{1}{6}$ is:\n"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":2,"status":"ok","timestamp":1689102906613,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"Iyn677ONba3F","outputId":"c7dee0ab-2d6c-41e8-997b-efcd5bb3b403"},"outputs":[{"data":{"text/plain":["1.1785113019775793"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["np.sqrt(10*(1/6)*(1-(1/6)))"]},{"cell_type":"markdown","metadata":{"id":"_E-QDNmch2-_"},"source":["## Normal Approximation to the Binomial Distribution\n","\n","We learned in the [last section](../3/normal.ipynb) that the normal distribution has a number of special properties that make it easy to use. You will learn later in this book that many statistical methods are based on the normal distribution. For this reason, it is convenient to be able to model data using the normal distribution (even when the data is not actually normally distributed!). Sometimes, we can approximate other distributions using a version of the normal distribution. Specifically, we can use a **normal approximation to the binomial distribution**.\n","\n","We can approximate a binomial distribution using a normal distribution when the number of trials, n, is 'sufficiently large'. The rule-of-thumb for deciding when n is large enough to do the approximation is to check the following:\n","- Is $np \\geq 5$?\n","- Is $n(1-p) \\geq 5$?\n","\n","If both conditions are met, you can approximate the binomial distribution with a normal distribution with mean:\n","\n","> $\\mu = np$\n","\n","and standard deviation:\n","\n","> $\\sigma = \\sqrt{np(1-p)}$\n","\n","Recall, we've been counting the number of occurrence of certain dice rolls. Let's now call a 'success' in our binomial experiment rolling either a 1 or a 6. There is a 1/3 probability of rolling a 1 or a 6 so this is our $p$. Now, let's count the number of successes in 50 dice rolls.\n","\n","First, we check if n is large enough. We have $np = 50*(1/3) \\approx 16.66 \\geq 5$ and $np = 100*(1 - 1/3) \\approx 33.33 \\geq 5$. So, we can use the approximation.\n","\n","Now, let's characterize our normal distribution. The mean is $np$ which we already calculated is approximately 16.66. The standard deviation is $\\sqrt{np(1-p)} = \\sqrt{100*(1/3)(2/3)} \\approx 3.33$.\n","\n","Below we compare the graph of the binomial distribution with n = 50 an p = 1/3 to the graph of the normal distribution with mean 16.66 and standard deviation 3.33."]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":448},"executionInfo":{"elapsed":1464,"status":"ok","timestamp":1689108344229,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"4F_zMNTqriiw","outputId":"495e0c9a-3ef8-462b-9fac-08db009b8d30"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_list =[]\n","n=50\n","p=1/3\n","for i in range(0,51):\n"," binomial_list.append(binomial_prob(n, p, i))\n","\n","legend = f'Probability Distribution: Number of 1s or 6s in 50 Tosses'\n","\n","pd.DataFrame({legend: binomial_list}).plot.bar();\n","plt.xlabel('Number of Ones or Sixes');\n","plt.ylabel(\"Probability\");\n","plt.xticks(rotation = 90, fontsize=7);"]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":448},"executionInfo":{"elapsed":446,"status":"ok","timestamp":1689111836735,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"JjPsIwU4s_ap","outputId":"c5259d5b-9385-47c4-a3d2-d2b49c97b760"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["import scipy\n","import math\n","\n","def normal_prob(mu, sigma, x):\n"," '''A function that calculates probabilities from a normal distribution with mean mu and standard deviation sigma'''\n"," bottom = math.sqrt(2 * math.pi * sigma**2)\n"," top = math.exp(-(x - mu)**2/(2 * sigma**2))\n"," return top/bottom\n","\n","normal_list =[]\n","mu=16.66\n","sigma=3.33\n","for i in range(0,51):\n"," normal_list.append(normal_prob(mu, sigma, i))\n","\n","legend = f'Approximate Probability Distribution'\n","\n","pd.DataFrame({legend: normal_list}).plot();\n","plt.xlabel('Number of Ones or Sixes');\n","plt.ylabel(\"Probability\");\n","#plt.xticks(rotation = 90, fontsize=7);"]},{"cell_type":"markdown","metadata":{"id":"zjaN_6qWuBZO"},"source":["Now, let's view them together:"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":430},"executionInfo":{"elapsed":497,"status":"ok","timestamp":1689109464833,"user":{"displayName":"Amanda Jotte","userId":"14869546754145298709"},"user_tz":300},"id":"lvC1Hu-puA64","outputId":"86bf4f58-985a-4d17-cef4-51fd848142a5"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["binomial_df = pd.DataFrame({\"Real\": binomial_list})\n","normal_df = pd.DataFrame({\"Approximate\": normal_list})\n","\n","bin = plt.bar(height = binomial_df.Real, x = binomial_df.index)\n","norm, = plt.plot(normal_df, color='red')\n","plt.legend([bin, norm], ['True Probability Distribution','Approximate Probability Distribution'])\n","plt.xlabel('Number of Ones or Sixes');\n","plt.ylabel(\"Probability\");\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"Qc0T9apDxS2X"},"source":["It looks like the normal is a pretty good approximation to the binomial in this case!"]},{"cell_type":"markdown","metadata":{"id":"DlLOvh0yYWQu"},"source":["Learning about distributions like the ones presented in this chapter can help us better understand the data that we work with as data scientists. In the next few chapters, we will explore ways that statisticians and data scientists use distributions to test hypotheses about data."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"BuZFEc-iYEtr"},"outputs":[],"source":[]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3.9.13 64-bit","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.10.9"},"vscode":{"interpreter":{"hash":"aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"}}},"nbformat":4,"nbformat_minor":0} From 9ce8a774f6c39bb4db731c5a7acd155b0359c8e1 Mon Sep 17 00:00:00 2001 From: W Trimble Date: Wed, 23 Aug 2023 09:22:55 -0500 Subject: [PATCH 05/12] Clean up - North America data is not a file, just a file handle --- textbook/05/3/Control_Statements_Iteration.ipynb | 2 +- textbook/09/1/Libraries.ipynb | 4 ++-- textbook/09/2/Categorical_Data.ipynb | 2 +- textbook/10/3/sampling.ipynb | 2 +- textbook/12/3/normal.ipynb | 2 +- textbook/data/galton.csv | 1 + 6 files changed, 7 insertions(+), 6 deletions(-) create mode 100644 textbook/data/galton.csv diff --git a/textbook/05/3/Control_Statements_Iteration.ipynb b/textbook/05/3/Control_Statements_Iteration.ipynb index 8bd307ae..63fb36f6 100644 --- a/textbook/05/3/Control_Statements_Iteration.ipynb +++ b/textbook/05/3/Control_Statements_Iteration.ipynb @@ -354,7 +354,7 @@ "id": "25e09fb1", "metadata": {}, "source": [ - "In [Section 4.1: Lists](../1/Lists.html) we created the following list of prime numbers:" + "In [Section 4.1: Lists](../../04/1/Lists.html) we created the following list of prime numbers:" ] }, { diff --git a/textbook/09/1/Libraries.ipynb b/textbook/09/1/Libraries.ipynb index 5449a418..37e76683 100644 --- a/textbook/09/1/Libraries.ipynb +++ b/textbook/09/1/Libraries.ipynb @@ -126,7 +126,7 @@ "\n", "from io import StringIO\n", "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(../../data/NorthAmerica_Military_USD_PercentGDP_Combined_csv)" + "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)" ] }, { @@ -324,7 +324,7 @@ } ], "source": [ - "military = pd.read_csv(../../data/NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", + "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", "\n", "military" ] diff --git a/textbook/09/2/Categorical_Data.ipynb b/textbook/09/2/Categorical_Data.ipynb index c882a3cc..484b4d0d 100644 --- a/textbook/09/2/Categorical_Data.ipynb +++ b/textbook/09/2/Categorical_Data.ipynb @@ -111,7 +111,7 @@ "\n", "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", "\n", - "military = pd.read_csv(../../data/NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", + "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", "\n", "import warnings\n", "warnings.filterwarnings('ignore')" diff --git a/textbook/10/3/sampling.ipynb b/textbook/10/3/sampling.ipynb index dbff29a6..fbd86ada 100644 --- a/textbook/10/3/sampling.ipynb +++ b/textbook/10/3/sampling.ipynb @@ -147,7 +147,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Or, we can give different elements different chances of being chosen by using the argument `p` which takes in a list of the same size as marbles. Each element in the `p` list corresponds to an element of marbles, and together they must add to 1 (the reasoning for this will be explained further in the [next chapter](../../11/Probability_1_RulesDefinitions.ipynb)). The last 3 elements are 0 since those marbles have no chance of being chosen. The first two are 0.5 or $\\frac{1}{2}$ since they have a 1 in 2 chance of being chosen. " + "Or, we can give different elements different chances of being chosen by using the argument `p` which takes in a list of the same size as marbles. Each element in the `p` list corresponds to an element of marbles, and together they must add to 1 (the reasoning for this will be explained further in the [next chapter](../../11/1/Probability_1_RulesDefinitions.ipynb)). The last 3 elements are 0 since those marbles have no chance of being chosen. The first two are 0.5 or $\\frac{1}{2}$ since they have a 1 in 2 chance of being chosen. " ] }, { diff --git a/textbook/12/3/normal.ipynb b/textbook/12/3/normal.ipynb index de6b0738..177e2400 100644 --- a/textbook/12/3/normal.ipynb +++ b/textbook/12/3/normal.ipynb @@ -1 +1 @@ -{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"tAzM3r78p08k","tags":["remove-cell"]},"outputs":[],"source":["import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","%matplotlib inline"]},{"cell_type":"markdown","metadata":{"id":"HtrRcRR0uFAM"},"source":["# Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"q0LoZTYHoCuw"},"source":["Let's consider another distribution by considering real data.\n","\n","Below we load in the Galton Height Data. This dataset was collected from families and contains heights of the father, mother, children. We focus on the father heights, and plot the distribution of heights in a histogram."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":235},"executionInfo":{"elapsed":188,"status":"ok","timestamp":1689610841357,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"UOdUEyhemMef","outputId":"79220073-def2-4067-bec0-293762a2f8a4"},"outputs":[{"data":{"text/html":["\n","\n","
\n","
\n","
\n","\n","\n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n","
familyfathermothermidparentHeightchildrenchildNumgenderchildHeight
0178.567.075.4341male73.2
1178.567.075.4342female69.2
2178.567.075.4343female69.0
3178.567.075.4344female69.0
4275.566.573.6641male73.5
5275.566.573.6642male72.5
\n","
\n"," \n","\n","\n","\n","
\n"," \n","
\n","\n","\n","\n"," \n","\n"," \n"," \n","\n"," \n","
\n","
\n"],"text/plain":[" family father mother midparentHeight children childNum gender \\\n","0 1 78.5 67.0 75.43 4 1 male \n","1 1 78.5 67.0 75.43 4 2 female \n","2 1 78.5 67.0 75.43 4 3 female \n","3 1 78.5 67.0 75.43 4 4 female \n","4 2 75.5 66.5 73.66 4 1 male \n","5 2 75.5 66.5 73.66 4 2 male \n","\n"," childHeight \n","0 73.2 \n","1 69.2 \n","2 69.0 \n","3 69.0 \n","4 73.5 \n","5 72.5 "]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["galton_df = pd.read_csv(\"galton.csv\")\n","galton_df.head(6)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":1567,"status":"ok","timestamp":1689610867384,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"6Mi-17cNm1oG","outputId":"93ce9d81-264e-49aa-c749-3c4867921b15"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["bin_size=np.arange(60, 80.5, 1)\n","plt.hist(galton_df[\"father\"], bins = bin_size, density = True)\n","plt.title('Father heights')\n","plt.xlabel('heights (in inches)')\n","plt.ylabel('Probabilities')\n","plt.scatter(galton_df['father'].mean(), 0, color='red', s=60);\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"MO3r-9W6moSJ"},"source":["This is another empirical distribution, but a special one!\n","An empirical *normal* distribution.\n","\n","The values for the normal distribution are continous variables - as heights can take on any real number in a given range."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"ja0QmiNunQY0"},"source":["## Normal Probability Distribution\n","\n","Arguably one of the most important continuous distributions, the normal distribution is a common distribution of heights, weights, and SAT scores, to name a few.\n","This distribution is symmetric and bell-shaped, giving it the nickname \"bell-curve\". The three measures of center: mode, median, and mean, are exactly the same for the normal distribution. Further, the distribution itself is defined entirely in terms of its mean and standard deviation. Notationally, given a random variable $X$ that is normally distributed, we can say $X \\sim N(\\mu,\\sigma)$, where $\\mu$ and $\\sigma$ are the mean and standard deviation of the distribution, respectively.\n","\n","\n","Below is a plot of a normal distribution, with the mean in red on the graph. We use the scipy library and the *normal* function by calling\n","\n","```python\n","stats.norm(µ, σ)\n","```\n","where the arguments correspond to the mean and standard deviation of the normal distribution. To get the corresponding $y$ values, we call the pdf method on a given array of x-values:\n","```python\n","stats.norm(µ, σ).pdf(x)\n","```"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":480,"status":"ok","timestamp":1689622686716,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"cFM9Aj9QAvxi","outputId":"3fe0093d-f87d-4ee2-a46a-bdd4555ffbff"},"outputs":[{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABwMklEQVR4nO3deVhUZfsH8O/MwAz7sMmmKCDuCygqrmGFoZZptphlKvlamVq+ZL1RJpb1Q8vKMtPyzSXLNH3bF81IMg1xxRUXFARFEFAY1hmYOb8/hpkcQQUEzizfz3XNJXPOM2fuw+DMPc9zn+eRCIIggIiIiMiGSMUOgIiIiKi1MQEiIiIim8MEiIiIiGwOEyAiIiKyOUyAiIiIyOYwASIiIiKbwwSIiIiIbA4TICIiIrI5TICIiIjI5jABIiKzM3z4cAwfPrxFji2RSLBgwYIWOfa1kpOTIZFIkJycbNw2fPhw9OzZs8WfGwCysrIgkUiwdu3aVnk+IkvDBIjIAq1duxYSiQQODg64ePFinf2t+UErpqCgIEgkEkgkEkilUri7u6NXr1546qmnkJqa2mzPs2HDBixdurTZjteczDk2InNmJ3YARNR0arUaixYtwrJly8QORTTh4eF44YUXAAClpaVIT0/H5s2bsWrVKvz73//Ge++9Z9K+srISdnaNe+vbsGEDjh07hjlz5jT4MXfccQcqKyshl8sb9VyNdaPYOnTogMrKStjb27fo8xNZKiZARBYsPDwcq1atQnx8PAICAlrkOQRBQFVVFRwdHVvk+Lerbdu2mDRpksm2xYsX47HHHsP777+PTp06YcaMGcZ9Dg4OLRpPVVUV5HI5pFJpiz/XzRh6CImofhwCI7Jgr7zyCrRaLRYtWnTLtjU1NVi4cCE6duwIhUKBoKAgvPLKK1Cr1SbtgoKCcN9992Hbtm3o168fHB0d8cknnxhrWr7++mu8/vrraNu2LVxdXfHQQw+hpKQEarUac+bMgY+PD1xcXBAbG1vn2GvWrMFdd90FHx8fKBQKdO/eHStWrGjW3wkAODo6Yv369fD09MRbb70FQRCM+66vASotLcWcOXMQFBQEhUIBHx8fjBgxAgcPHgSgH078+eefcf78eeNwW1BQEIB/6nw2btyIefPmoW3btnBycoJKpaq3BsjgwIEDGDx4MBwdHREcHIyVK1ea7DcMcWZlZZlsv/6YN4vtRjVAf/zxB4YNGwZnZ2e4u7tj7NixSE9PN2mzYMECSCQSZGRkYOrUqXB3d4dSqURsbCwqKioa9iIQmTn2ABFZsODgYEyePBmrVq3Cyy+/fNNeoH/9619Yt24dHnroIbzwwgtITU1FYmIi0tPT8e2335q0PXXqFCZOnIinn34a06dPR5cuXYz7EhMT4ejoiJdffhkZGRlYtmwZ7O3tIZVKcfXqVSxYsAB79uzB2rVrERwcjPnz5xsfu2LFCvTo0QP3338/7Ozs8OOPP+LZZ5+FTqfDzJkzm/V34+LiggceeACfffYZTpw4gR49etTb7plnnsGWLVswa9YsdO/eHUVFRdi1axfS09PRt29fvPrqqygpKcGFCxfw/vvvG499rYULF0Iul2Pu3LlQq9U3Hfa6evUqRo8ejUceeQQTJ07E119/jRkzZkAul+PJJ59s1Dk2JLZr/f777xg1ahRCQkKwYMECVFZWYtmyZRgyZAgOHjxoTJ4MHnnkEQQHByMxMREHDx7Ef//7X/j4+GDx4sWNipPILAlEZHHWrFkjABD27dsnnD17VrCzsxOee+454/6oqCihR48exvtpaWkCAOFf//qXyXHmzp0rABD++OMP47YOHToIAIStW7eatN2xY4cAQOjZs6eg0WiM2ydOnChIJBJh1KhRJu0HDRokdOjQwWRbRUVFnXOJiYkRQkJCTLZFRUUJUVFRN/8l1MZ677333nD/+++/LwAQvv/+e+M2AEJCQoLxvlKpFGbOnHnT57n33nvrnIsg/PM7CQkJqXNuhn07duwwbouKihIACO+++65xm1qtFsLDwwUfHx/j79Xw+mZmZt7ymDeKLTMzUwAgrFmzxrjN8DxFRUXGbYcPHxakUqkwefJk47aEhAQBgPDkk0+aHPOBBx4QvLy86jwXkSXiEBiRhQsJCcETTzyBTz/9FJcuXaq3zS+//AIAiIuLM9luKB7++eefTbYHBwcjJiam3mNNnjzZpLA2MjISgiDU6b2IjIxETk4OampqjNuurSMqKSlBYWEhoqKicO7cOZSUlNzqVBvN0BtSWlp6wzbu7u5ITU1Fbm5uk59nypQpDa6RsrOzw9NPP228L5fL8fTTT+Py5cs4cOBAk2O4lUuXLiEtLQ1Tp06Fp6encXvv3r0xYsQI49/ItZ555hmT+8OGDUNRURFUKlWLxUnUWpgAEVmBefPmoaam5oa1QOfPn4dUKkVoaKjJdj8/P7i7u+P8+fMm24ODg2/4XO3btze5r1QqAQCBgYF1tut0OpPEZvfu3YiOjjbWn7Rp0wavvPIKALRIAlRWVgYAcHV1vWGbt99+G8eOHUNgYCAGDBiABQsW4Ny5c416npv9vq4XEBAAZ2dnk22dO3cGgDo1P83J8BpfO5xp0K1bNxQWFqK8vNxk+/WvtYeHBwD9MB6RpWMCRGQFQkJCMGnSpJv2AgH6AuCGuFlvhkwma9R2obYA+ezZs7j77rtRWFiI9957Dz///DO2b9+Of//73wAAnU7XoNga49ixYwBQJ/G71iOPPIJz585h2bJlCAgIwDvvvIMePXrg119/bfDzNPcVcjd6nbRabbM+z63c6jUlsmRMgIishKEXqL4C1Q4dOkCn0+HMmTMm2/Pz81FcXIwOHTq0eHw//vgj1Go1fvjhBzz99NMYPXo0oqOjW+zy+rKyMnz77bcIDAxEt27dbtrW398fzz77LL777jtkZmbCy8sLb731lnF/QxPHhsjNza3T03L69GkAMBYhG3paiouLTdpd31PXmNgMr/GpU6fq7Dt58iS8vb3r9EwRWTMmQERWomPHjpg0aRI++eQT5OXlmewbPXo0ANSZMdgwSeC9997b4vEZehOu7T0oKSnBmjVrmv25Kisr8cQTT+DKlSt49dVXb9qjcv3Qm4+PDwICAkwu4Xd2dm62Ibqamhp88sknxvsajQaffPIJ2rRpg4iICAD61xIAdu7caRLrp59+Wud4DY3N398f4eHhWLdunUlidezYMfz222/GvxEiW8HL4ImsyKuvvor169fj1KlTJpd9h4WFYcqUKfj0009RXFyMqKgo7N27F+vWrcO4ceNw5513tnhs99xzD+RyOcaMGYOnn34aZWVlWLVqFXx8fG46bHcrFy9exBdffAFA3+tz4sQJbN68GXl5eXjhhRdMCo6vV1painbt2uGhhx5CWFgYXFxc8Pvvv2Pfvn149913je0iIiKwadMmxMXFoX///nBxccGYMWOaFG9AQAAWL16MrKwsdO7cGZs2bUJaWho+/fRTY3F5jx49MHDgQMTHx+PKlSvw9PTExo0bTQrKmxLbO++8g1GjRmHQoEGYNm2a8TJ4pVLZKuujEZkTJkBEViQ0NBSTJk3CunXr6uz773//i5CQEKxduxbffvst/Pz8EB8fj4SEhFaJrUuXLtiyZQvmzZuHuXPnws/PDzNmzECbNm0aPf/NtdLS0vDEE09AIpHA1dUVgYGBGDNmDP71r39hwIABN32sk5MTnn32Wfz222/45ptvoNPpEBoaio8//thk9uhnn30WaWlpWLNmDd5//3106NChyQmQh4cH1q1bh9mzZ2PVqlXw9fXFRx99hOnTp5u0+/LLL/H0009j0aJFcHd3x7Rp03DnnXdixIgRJu0aE1t0dDS2bt2KhIQEzJ8/H/b29oiKisLixYsbVchNZA0kAqvZiIiIyMawBoiIiIhsDhMgIiIisjlMgIiIiMjmMAEiIiIim8MEiIiIiGwOEyAiIiKyOZwHqB46nQ65ublwdXVt1inwiYiIqOUIgoDS0lIEBARAKr15Hw8ToHrk5ubWWdmaiIiILENOTg7atWt30zZMgOrh6uoKQP8LdHNzEzkaIiIiagiVSoXAwEDj5/jNMAGqh2HYy83NjQkQERGRhWlI+QqLoImIiMjmMAEiIiIim8MEiIiIiGwOEyAiIiKyOUyAiIiIyOYwASIiIiKbwwSIiIiIbA4TICIiIrI5ZpEALV++HEFBQXBwcEBkZCT27t3boMdt3LgREokE48aNM9kuCALmz58Pf39/ODo6Ijo6GmfOnGmByImIiMgSiZ4Abdq0CXFxcUhISMDBgwcRFhaGmJgYXL58+aaPy8rKwty5czFs2LA6+95++218+OGHWLlyJVJTU+Hs7IyYmBhUVVW11GkQERGRBRE9AXrvvfcwffp0xMbGonv37li5ciWcnJywevXqGz5Gq9Xi8ccfx+uvv46QkBCTfYIgYOnSpZg3bx7Gjh2L3r174/PPP0dubi6+++67Fj4bIiIisgSiJkAajQYHDhxAdHS0cZtUKkV0dDRSUlJu+Lg33ngDPj4+mDZtWp19mZmZyMvLMzmmUqlEZGTkTY9JREREtkPUxVALCwuh1Wrh6+trst3X1xcnT56s9zG7du3CZ599hrS0tHr35+XlGY9x/TEN+66nVquhVquN91UqVUNPgYgsRFGZGpXVWpNtCjsZ2rgqRIqIiMRkUavBl5aW4oknnsCqVavg7e3dbMdNTEzE66+/3mzHIyLzUVJRjYQfjuG7tNx694/s4Yc3H+gJbxcmQkS2RNQEyNvbGzKZDPn5+Sbb8/Pz4efnV6f92bNnkZWVhTFjxhi36XQ6AICdnR1OnTplfFx+fj78/f1NjhkeHl5vHPHx8YiLizPeV6lUCAwMbPJ5EZF52HHqMl7+3xHkq/Q9vAo701F/jVaHrcfzsC/rCt56oBdG9qz7vkNE1knUBEgulyMiIgJJSUnGS9l1Oh2SkpIwa9asOu27du2Ko0ePmmybN28eSktL8cEHHyAwMBD29vbw8/NDUlKSMeFRqVRITU3FjBkz6o1DoVBAoeC3PyJrUaauwVs/n8BXe3MAACFtnPHuw2Ho097DpN3x3BK88PVhnMwrxTNfHMADfdpiwZgeUDrZixE2EbUi0YfA4uLiMGXKFPTr1w8DBgzA0qVLUV5ejtjYWADA5MmT0bZtWyQmJsLBwQE9e/Y0eby7uzsAmGyfM2cO3nzzTXTq1AnBwcF47bXXEBAQUGe+ICKyPifzVPjXuv24cLUSAPDkkGC8NLILHOxlddr2CFDi+1lD8MHvZ7Dyz7P49tBF/H22EJ8+0Q9hge6tHDkRtSbRE6AJEyagoKAA8+fPR15eHsLDw7F161ZjEXN2djak0sZdrPbSSy+hvLwcTz31FIqLizF06FBs3boVDg4OLXEKRGQmVFXVeOrzA7hwtRLtPBzxzkNhGNTR66aPUdjJ8NLIroju7ou5Xx/GucJyPL3+AH55fhg8neWtFDkRtTaJIAiC2EGYG5VKBaVSiZKSEri5uYkdDhE1gCAImPXVIfx85BLaujvi5+eGwt2pcQlMmboG93+0C+cKynFnlzb4bEp/SKWSFoqYiJpbYz6/RZ8IkYioOXyZmo2fj1yCnVSCjx7r0+jkBwBcFHZY/lhfKOyk2HGqAKv+OtcCkRKROWACREQW73huCd746QQA4D8ju9Ypdm6Mbv5uSBjTAwDw9rZTOHD+arPESETmhQkQEVm0MnUNZm04BE2NDnd39cG/hgXf9jEnDgjEmLAAaHUCnvvqEIorNM0QKRGZEyZARGSxBEHAq98eRWZhOQKUDljycBgkktuv2ZFIJPi/B3oiyMsJF4srMXfzEbBcksi6MAEiIov1XdpFfJ+WC5lUgmWP9YFHM1615epgj48e6wu5TIrf0/PxRWp2sx2biMTHBIiILJKmRocl204DAObc3QkRHTyb/Tl6tlXi5VFdAQAf/H4aFZqaZn8OIhIHEyAiskib9ufgYnElfFwVmH5HSIs9zxODOqC9pxMKyzT4POV8iz0PEbUuJkBEZHGqqrVY/kcGAGDmnaH1zvLcXOxlUjx3dycAwCd/nkWZmr1ARNaACRARWZyv9mYjT1UFf6UDHh3Q8gsXjwsPQIi3M65WVGPt7swWfz4ianlMgIjIolRqtPg4+SwAYNZdoVDYtVzvj4GdTIrno/W9QJ/uPIeSyuoWf04iallMgIjIonyx5zwKStVo5+GIhyNavvfH4L7eAejk4wJVVQ1W72IvEJGlYwJERBajXF2DlX/qe3+eu6sT5Hat9xYmk0owJ7ozAGD1rkxOjkhk4ZgAEZHFWJeShaJyDYK8nDC+b9tWf/5RPf3Q1c8VpeoarhNGZOGYABGRRSitqsanO/VJx/PRnWAna/23L6lUgrgR+l6gNbuzUFSmbvUYiKh5MAEiIouwfs95FFdUo2MbZ9wf1vq9PwYjuvuiV1slKjRafMZaICKLxQSIiMyeTidgQ+1SFDOGh0Imvf31vppKIpFg5p2hAICv9+dAU6MTLRYiajomQERk9nZlFOLC1Uq4Odjhvt7+YoeDu7v5wMdVgcIyDZLS88UOh4iagAkQEZm9r/bqe3/G923XorM+N5S9TIqH+7UDAGzYy0VSiSwREyAiMmsFpWpsP6HvZWmNWZ8bakK/9gD0vVM5VypEjoaIGosJEBGZtS0HLqBGJ6BPe3d09XMTOxyj9l5OGNbJG4IAbNqXI3Y4RNRITICIyGzpdAI27dMPMU3s317kaOp6tDamr/fnoEbLYmgiS8IEiIjM1p5zRcgqqoCLwg73hYlf/Hy9Ed194eUsx+VSNf44eVnscIioEZgAEZHZ+qp2aGlseACc5HYiR1OX3E6KhyL0xdAbOQxGZFGYABGRWbpSrsG2Y3kAgIkDzG/4y2BCf31hdvKpy8gtrhQ5GiJqKCZARGSWvjl4ARqtDr3aKtGzrVLscG4opI0LBoZ4Qifoa4GIyDIwASIisyMIgnF+HXPu/TEwxPj1vhxodYLI0RBRQzABIiKzsy/rKs4VlMNJLsP94QFih3NLMT384O5kj9ySKuw8XSB2OETUAEyAiMjsbDmgH0oa0zsALgrzK36+noO9DOP76Iuhtxy4IHI0RNQQTICIyKxUa3X4rXbm57F9zL/3x2Bcbax/nLyMSo1W5GiI6FaYABGRWfn7bBGKK6rh7SJHZLCX2OE0WK+2SgR6OqKyWosdpzgnEJG5YwJERGbllyOXAAAje/pBJpWIHE3DSSQSjO6ln6zx56OXRI6GiG7FLBKg5cuXIygoCA4ODoiMjMTevXtv2Pabb75Bv3794O7uDmdnZ4SHh2P9+vUmbaZOnQqJRGJyGzlyZEufBhHdpmqtDttO6Of+MSQTluTe2pj/SOcwGJG5Ez0B2rRpE+Li4pCQkICDBw8iLCwMMTExuHy5/i5kT09PvPrqq0hJScGRI0cQGxuL2NhYbNu2zaTdyJEjcenSJePtq6++ao3TIaLbkGKhw18Gvdoq0c5DPwyWzGEwIrMmegL03nvvYfr06YiNjUX37t2xcuVKODk5YfXq1fW2Hz58OB544AF069YNHTt2xPPPP4/evXtj165dJu0UCgX8/PyMNw8Pj9Y4HSK6Db/UDh3F9LCs4S8DiURi7AXiMBiReRM1AdJoNDhw4ACio6ON26RSKaKjo5GSknLLxwuCgKSkJJw6dQp33HGHyb7k5GT4+PigS5cumDFjBoqKipo9fiJqPtVaHbYd1w9/3WuBw18GhqG7P05eRlU1h8GIzJWoE2wUFhZCq9XC19fXZLuvry9Onjx5w8eVlJSgbdu2UKvVkMlk+PjjjzFixAjj/pEjR2L8+PEIDg7G2bNn8corr2DUqFFISUmBTCarczy1Wg21Wm28r1KpmuHsiKgx9pwrwtWKang5yzEg2FPscJqsdzv9MNiFq5VIPnUZI3tabjJHZM3Mf4axeri6uiItLQ1lZWVISkpCXFwcQkJCMHz4cADAo48+amzbq1cv9O7dGx07dkRycjLuvvvuOsdLTEzE66+/3lrhE1E9jMNfPf1gJxN9dL7JDFeDfbrzHH4+mscEiMhMifou4+3tDZlMhvz8fJPt+fn58PPzu+HjpFIpQkNDER4ejhdeeAEPPfQQEhMTb9g+JCQE3t7eyMjIqHd/fHw8SkpKjLecHC5oSNSaarQ6bDuufx+w5OEvA8MwWFJ6PofBiMyUqAmQXC5HREQEkpKSjNt0Oh2SkpIwaNCgBh9Hp9OZDGFd78KFCygqKoK/f/1vrAqFAm5ubiY3Imo9e85dwZVyDTyd5Yi04OEvg7B2SrR1d0SFRovkU1wbjMgcid7PHBcXh1WrVmHdunVIT0/HjBkzUF5ejtjYWADA5MmTER8fb2yfmJiI7du349y5c0hPT8e7776L9evXY9KkSQCAsrIyvPjii9izZw+ysrKQlJSEsWPHIjQ0FDExMaKcIxHd3M9HcwHor/6y5OEvA/0wmL4Xm1eDEZkn0WuAJkyYgIKCAsyfPx95eXkIDw/H1q1bjYXR2dnZkEr/eUMsLy/Hs88+iwsXLsDR0RFdu3bFF198gQkTJgAAZDIZjhw5gnXr1qG4uBgBAQG45557sHDhQigUClHOkYhuzNqGvwxG9/LHqr8yjcNgDvZ1L8AgIvFIBEEQxA7C3KhUKiiVSpSUlHA4jKiF7TpTiEmfpcLTWY69r9xtFT1AgH6ajqGLd+BicSVWTorAyJ43rmskoubRmM9v63inISKLtfW4YfJDX6tJfgD9MNio2qTHML8REZkP63m3ISKLIwgCdpzUFwmP6O57i9aWx3BOyacuQ6tjZzuROWECRESiOZ1fhovFlVDYSTEoxFvscJpdRAcPuDnY4WpFNdJyisUOh4iuwQSIiETzx0n9gqGDO3rBUW59RcJ2Minu6NwGALDjJBdHJTInTICISDSGpOCurj4iR9JyDOf2BxMgIrPCBIiIRFFSUY0D2VcBAMO7WG8CFNW5DSQS4MQlFfJKqsQOh4hqMQEiIlH8eaYAWp2ATj4uCPR0EjucFuPlokBYO3cAwI5T7AUiMhdMgIhIFMk2MPxlwGEwIvPDBIiIWp1WJyD5tP7y9zttKAHanVEIdQ0XRyUyB0yAiKjVHb5QjCvlGrg62CGig4fY4bS4HgFu8HFVoEKjReq5K2KHQ0RgAkREIjBc/XVH5zawt6LZn29EIpHgzi4cBiMyJ9b/zkNEZseQBNxlxVd/Xc8w1Lfj1GVwCUYi8TEBIqJWla+qwvFcFSQSYHiXNmKH02qGdvKGvUyC80UVyCwsFzscIpvHBIiIWpVh+CusnTu8XBQiR9N6XBR2iAz2AsBhMCJzwASIiFqVYS6cO21o+MvA0OPF+YCIxMcEiIhajbpGi11nCgHYxvw/1zOc897MKyhT14gcDZFtYwJERK1mX+ZVlGu0aOOqQI8AN7HDaXUhbVwQ5OWEaq2AXWcKxA6HyKYxASKiVvPP8FcbSKUSkaMRh/FqsJNMgIjExASIiFqNYfgrqrPtDX8ZRHXW1wH9daaAl8MTiYgJEBG1isuqKpzKL4VEAgzu6CV2OKIZEOwJuUyK3JIqXg5PJCImQETUKnaf1ff+9AxQwsNZLnI04nGS26FvB3cA+rXBiEgcTICIqFX8VTv8NbSTt8iRiG9YJ8MwGBMgIrEwASKiFicIgrH+Z2goE6Ahtb+DlLNFqNHqRI6GyDYxASKiFpdxuQyXS9VQ2EltYvX3W+nVVgmloz1K1TU4crFE7HCIbBITICJqcYahngHBnnCwl4kcjfhkUomxEHwXh8GIRMEEiIha3K4MDn9dzzAMxgSISBxMgIioRVVrddhzrggAC6CvNaz2d3Ew+yrKuSwGUatjAkRELepQdjEqNFp4OcvRzc/2lr+4kfaeTmjn4YganYDUzCKxwyGyOUyAiKhFGYa/Bod62+zyF/WRSCTGXqBdZ5gAEbU2JkBE1KIMi34OY/1PHUND9fMB7crgumBErY0JEBG1GFVVNQ5f0F/mPYT1P3UM7ugFiQQ4nV+GfFWV2OEQ2RQmQETUYvacLYJWJyDE2xlt3R3FDsfseDjL0TNACYDLYhC1NrNIgJYvX46goCA4ODggMjISe/fuvWHbb775Bv369YO7uzucnZ0RHh6O9evXm7QRBAHz58+Hv78/HB0dER0djTNnzrT0aRDRdQz1P0M4/HVDvByeSByiJ0CbNm1CXFwcEhIScPDgQYSFhSEmJgaXL1+ut72npydeffVVpKSk4MiRI4iNjUVsbCy2bdtmbPP222/jww8/xMqVK5GamgpnZ2fExMSgqopdzEStaRfX/7olYyF0RiEEQRA5GiLbIRFE/h8XGRmJ/v3746OPPgIA6HQ6BAYGYvbs2Xj55ZcbdIy+ffvi3nvvxcKFCyEIAgICAvDCCy9g7ty5AICSkhL4+vpi7dq1ePTRR295PJVKBaVSiZKSEri58bJdoqa4WFyJIYv+gFQCpCXcAzcHe7FDMktV1VqEvf4b1DU6/PbvO9DZ11XskIgsVmM+v0XtAdJoNDhw4ACio6ON26RSKaKjo5GSknLLxwuCgKSkJJw6dQp33HEHACAzMxN5eXkmx1QqlYiMjLzhMdVqNVQqlcmNiG7P7tren7BAdyY/N+FgL8OAYE8AXB2eqDWJmgAVFhZCq9XC19fXZLuvry/y8vJu+LiSkhK4uLhALpfj3nvvxbJlyzBixAgAMD6uMcdMTEyEUqk03gIDA2/ntIgIwO6zXP6ioQy/o79ZCE3UakSvAWoKV1dXpKWlYd++fXjrrbcQFxeH5OTkJh8vPj4eJSUlxltOTk7zBUtkgwRBQMpZ/eR+g2oX/aQbM/yO9mZeQY1WJ3I0RLbBTswn9/b2hkwmQ35+vsn2/Px8+Pn53fBxUqkUoaGhAIDw8HCkp6cjMTERw4cPNz4uPz8f/v7+JscMDw+v93gKhQIKheI2z4aIDM4VluNyqRpyOyn6tvcQOxyz1yNACVcHO5RW1eB4rgphge5ih0Rk9UTtAZLL5YiIiEBSUpJxm06nQ1JSEgYNGtTg4+h0OqjVagBAcHAw/Pz8TI6pUqmQmpraqGMSUdMZen/6tneHg71M5GjMn0wqQWRtHVDKOS6LQdQaRB8Ci4uLw6pVq7Bu3Tqkp6djxowZKC8vR2xsLABg8uTJiI+PN7ZPTEzE9u3bce7cOaSnp+Pdd9/F+vXrMWnSJAD69XXmzJmDN998Ez/88AOOHj2KyZMnIyAgAOPGjRPjFIlsjuFDfFAI638aamCIfhhsDxMgolYh6hAYAEyYMAEFBQWYP38+8vLyEB4ejq1btxqLmLOzsyGV/pOnlZeX49lnn8WFCxfg6OiIrl274osvvsCECROMbV566SWUl5fjqaeeQnFxMYYOHYqtW7fCwcGh1c+PyNYIgoDU2g/xgSGeIkdjOQwJ0L7MK6jW6mAvE/37KZFVE30eIHPEeYCImu5MfilGvL8TCjspjiy4Bwo7DoE1hE4noM/C7SiprMY3zw5m7RRRE1jMPEBEZH0Mw1/9gjyY/DSC9No6oLMcBiNqaUyAiKhZGS9/D+Hl741luByedUBELY8JEBE1G51OMH54c/6fxjP8zvZnXYWmhvMBEbUkJkBE1GxO5ZfiakU1HO1l6N3OXexwLE5nH1d4OstRWa3FkQvFYodDZNWYABFRszEMf/UL8uBVTE3AOiCi1sN3KCJqNhz+un2G3x0nRCRqWUyAiKhZ6HQCUjOvAGAB9O0w/O4OnL8KdY1W5GiIrBcTICJqFicuqVBSWQ0XhR16tVWKHY7FCvVxgbeLAuoaHdKyi8UOh8hqMQEiomZhGP7qH+QBO9b/NJlEIjHOoM1hMKKWw3cpImoWhqLdgRz+um2G3yELoYlaDhMgIrptNVod9hrqf1gAfdsMv8ND2cWoqmYdEFFLYAJERLftxCUVStU1cHWwQ48A1v/crhBvZ/i4KqDR6nAw+6rY4RBZJSZARHTbDEM1kcGekEklIkdj+SQSyT/LYnAYjKhFMAEiottmKIBm/U/zMfwu95y7InIkRNaJCRAR3RatTsD+LP0wTWQwE6DmYpgROi2HdUBELYEJEBHdlhO5tfU/Cjt0D3ATOxyrEeztjDa1dUCHOB8QUbNjAkREtyU185/1v1j/03wkkn/WBTNcYUdEzYcJEBHdFsPyF5Gs/2l2ht+pIckkoubDBIiImkynE7AvqzYBqu2toOYzsPZ3ejD7KjQ1OpGjIbIuTICIqMlO5ZeiuKIaTnIZenL9r2YX6uMCT2c5qqp1OHKhWOxwiKwKEyAiarLU2svfIzp4wJ7rfzU7iUSCAUH6XqBU1gERNSu+YxFRkxnrfzj81WIiaxdG3cOFUYmaFRMgImoSQRCMVyexALrlGOZWOnD+Kmq0rAMiai5MgIioSc4WlKGoXAOFnRS927H+p6V09XOF0tEeFRotjuWqxA6HyGowASKiJjEs0dCnvTsUdjKRo7FeUqkE/Q11QBwGI2o2TICIqEn+qf/h8FdLGxjCQmii5sYEiIgaTRAEY2+EoUiXWo4hydyXeQVanSByNETWgQkQETVaVlEFLpeqIZdJ0be9h9jhWL1u/q5wUdihVF2D9EusAyJqDkyAiKjR9tYuzRAWqISDPet/WpqdTIp+QfpEk8NgRM2DCRARNVpqbQH0AM7/02oMw2AshCZqHkyAiKjRWADd+gy1VnuzrkDHOiCi22YWCdDy5csRFBQEBwcHREZGYu/evTdsu2rVKgwbNgweHh7w8PBAdHR0nfZTp06FRCIxuY0cObKlT4PIJuRcqcDF4krIpBJEdGD9T2vp1VYJJ7kMxRXVOH25VOxwiCye6AnQpk2bEBcXh4SEBBw8eBBhYWGIiYnB5cuX622fnJyMiRMnYseOHUhJSUFgYCDuueceXLx40aTdyJEjcenSJePtq6++ao3TIbJ6ht6fXm2VcFbYiRyN7bCXSY0Jp2EIkoiaTvQE6L333sP06dMRGxuL7t27Y+XKlXBycsLq1avrbf/ll1/i2WefRXh4OLp27Yr//ve/0Ol0SEpKMmmnUCjg5+dnvHl48JsqUXMwFEBz/a/WZ/idp2ayDojodomaAGk0Ghw4cADR0dHGbVKpFNHR0UhJSWnQMSoqKlBdXQ1PT9M34+TkZPj4+KBLly6YMWMGiopu/IahVquhUqlMbkRUv3/W/2IC1NoG1NZc7c28CkFgHRDR7RA1ASosLIRWq4Wvr6/Jdl9fX+Tl5TXoGP/5z38QEBBgkkSNHDkSn3/+OZKSkrB48WL8+eefGDVqFLRabb3HSExMhFKpNN4CAwObflJEVixfVYWsogpIJEC/ICZArS0sUAm5nRSFZWqcKywXOxwii2bRA/iLFi3Cxo0bkZycDAcHB+P2Rx991Phzr1690Lt3b3Ts2BHJycm4++676xwnPj4ecXFxxvsqlYpJEFE9DPU/3f3d4OZgL3I0tkdhJ0OfQHekZl7B3swr6NjGReyQiCyWqD1A3t7ekMlkyM/PN9men58PPz+/mz52yZIlWLRoEX777Tf07t37pm1DQkLg7e2NjIyMevcrFAq4ubmZ3IioLkP9D+f/EY+hDmgvJ0Qkui2iJkByuRwREREmBcyGguZBgwbd8HFvv/02Fi5ciK1bt6Jfv363fJ4LFy6gqKgI/v7+zRI3ka0y1v8wARLNP3VATICIbofoV4HFxcVh1apVWLduHdLT0zFjxgyUl5cjNjYWADB58mTEx8cb2y9evBivvfYaVq9ejaCgIOTl5SEvLw9lZWUAgLKyMrz44ovYs2cPsrKykJSUhLFjxyI0NBQxMTGinCORNbhSrsHpfP3/s/6s/xFN3w7usJNKcLG4EjlXKsQOh8hiiV4DNGHCBBQUFGD+/PnIy8tDeHg4tm7daiyMzs7OhlT6T562YsUKaDQaPPTQQybHSUhIwIIFCyCTyXDkyBGsW7cOxcXFCAgIwD333IOFCxdCoVC06rkRWRNDj0MnHxd4ufD/klic5Hbo1U6JQ9nF2Jt5BYGeTmKHRGSRRE+AAGDWrFmYNWtWvfuSk5NN7mdlZd30WI6Ojti2bVszRUZEBoYEiPU/4hsQ7GlMgB6MaCd2OEQWSfQhMCKyDHuzaidADOH6X2IzFkJnsQ6IqKmYABHRLamqqnEiVz9B6ADW/4iuX5AnJBIgs7Acl1VVYodDZJGalADt2LGjueMgIjN2IOsqdALQwcsJfkqHWz+AWpSbgz26++un60jl1WBETdKkBGjkyJHo2LEj3nzzTeTk5DR3TERkZlJ5+bvZGcD5gIhuS5MSoIsXL2LWrFnYsmULQkJCEBMTg6+//hoajaa54yMiM/DPBIis/zEXnBCR6PY0KQHy9vbGv//9b6SlpSE1NRWdO3fGs88+i4CAADz33HM4fPhwc8dJRCKp0NTgyIUSAOwBMieGuZhO5ZfiSjm/fBI11m0XQfft2xfx8fGYNWsWysrKsHr1akRERGDYsGE4fvx4c8RIRCI6lF2MGp0Af6UD2nk4ih0O1fJyUaCTj34tsH28Goyo0ZqcAFVXV2PLli0YPXo0OnTogG3btuGjjz5Cfn4+MjIy0KFDBzz88MPNGSsRieDa+h+JRCJyNHQt1gERNV2TJkKcPXs2vvrqKwiCgCeeeAJvv/02evbsadzv7OyMJUuWICAgoNkCJSJxsP7HfA0I9sSXqdlMgIiaoEkJ0IkTJ7Bs2TKMHz/+hstLeHt783J5IgunrtHiUHYxAM4AbY4ia5PS47klUFVVw83BXuSIiCxHk4bAEhIS8PDDD9dJfmpqarBz504AgJ2dHaKiom4/QiISzZELJVDX6ODtIkfHNs5ih0PX8VM6oIOXE3QCcOD8VbHDIbIoTUqA7rzzTly5UrfLtaSkBHfeeedtB0VE5uHa9b9Y/2OeDDNzp57jMBhRYzQpARIEod43w6KiIjg781sikbXYc662/ofLX5itfwqhi0SOhMiyNKoGaPz48QAAiUSCqVOnmgyBabVaHDlyBIMHD27eCIlIFNVanXFYhQugmq+Bta/NkQslqNDUwEnepNJOIpvTqP8pSqUSgL4HyNXVFY6O/8wJIpfLMXDgQEyfPr15IyQiURy7WIIKjRbuTvbo4usqdjh0A+08HBGgdEBuSRUOni/G0E7eYodEZBEalQCtWbMGABAUFIS5c+dyuIvIihnm/+kf5AmplPU/5koikSAyxAvfHrqI1MwiJkBEDdTkq8CY/BBZt9Ta+h8uf2H+DK8RC6GJGq7BPUB9+/ZFUlISPDw80KdPn5teEXLw4MFmCY6IxKHVCdifpa//Gcj6H7NnqNFKyylGVbUWDvYykSMiMn8NToDGjh1rLHoeN25cS8VDRGbgRK4KpeoauDrYoZu/m9jh0C0EeTnBx1WBy6VqHMy+isEdOQxGdCsNToASEhLq/ZmIrE9q7SXV/YM8IWP9j9kz1AH9eDgXqeeuMAEiaoDbXg2eiKzPnnP/LIBKlsFYB8T5gIgapME9QB4eHg2eCba+WaKJyDLodAL2ZdUmQKz/sRgDQ/QJ0KHsYqhrtFDYsQ6I6GYanAAtXbq0BcMgInNxMq8UJZXVcJbL0DOA9T+WomMbF3i7yFFYpsHhnBIuXkt0Cw1OgKZMmdKScRCRmTAMoUQEecJOxlFySyGRSDAg2BO/HM1D6rkiJkBEt9DgdzeVSmXy881uRGS5Uln/Y7Eig/VDloZJLInoxhpVA3Tp0iX4+PjA3d293nogwyKpWq22WYMkotYhCAL21tb/GGpKyHJE1r5mB85fRbVWB3v24BHdUIMToD/++AOenvr/XDt27GixgIhIPGcul+FKuQYO9lL0ausudjjUSJ19XOHuZI/iimocuVCCiA4eYodEZLYanABFRUXV+zMRWQ/D8hcRHTwgt2PvgaWRSiUYEOSJ307kIzWziAkQ0U00ajHUa129ehWfffYZ0tPTAQDdu3dHbGyssZeIiCzPnkxD/Q8vf7dUkSFe+gTo3BU8O1zsaIjMV5O+4u3cuRNBQUH48MMPcfXqVVy9ehUffvghgoODsXPnzuaOkYhagSAILIC2AobXbn/WFdRodSJHQ2S+mtQDNHPmTEyYMAErVqyATKafbEur1eLZZ5/FzJkzcfTo0WYNkoha3rnCchSWqaGwkyIs0F3scKiJuvm7wc3BDqqqGhzPVfG1JLqBJvUAZWRk4IUXXjAmPwAgk8kQFxeHjIyMRh9v+fLlCAoKgoODAyIjI7F3794btl21ahWGDRsGDw8PeHh4IDo6uk57QRAwf/58+Pv7w9HREdHR0Thz5kyj4yKyJYbenz7t3bmauAWTSSXGOYC4LAbRjTUpAerbt6+x9uda6enpCAsLa9SxNm3ahLi4OCQkJODgwYMICwtDTEwMLl++XG/75ORkTJw4ETt27EBKSgoCAwNxzz334OLFi8Y2b7/9Nj788EOsXLkSqampcHZ2RkxMDKqqqhp3okQ2ZE9tATTrfyyf4TU0rOlGRHVJBEEQGtLwyJEjxp/T09Px0ksvYfbs2Rg4cCAAYM+ePVi+fDkWLVqECRMmNDiAyMhI9O/fHx999BEAQKfTITAwELNnz8bLL798y8drtVp4eHjgo48+wuTJkyEIAgICAvDCCy9g7ty5AICSkhL4+vpi7dq1ePTRR295TJVKBaVSiZKSEri5cSkAsn6CIGDA/yWhoFSNr6YPxKCOTIIs2dELJRjz0S64KOyQNn8EZ/Qmm9GYz+8G1wCFh4dDIpHg2nzppZdeqtPusccea3ACpNFocODAAcTHxxu3SaVSREdHIyUlpUHHqKioQHV1tfHqs8zMTOTl5SE6OtrYRqlUIjIyEikpKfUmQGq1Gmq12nifs1mTrTlbUI6CUjXkdlL0ae8udjh0m7oH/FMHdCxXhXDWARHV0eAEKDMzs9mfvLCwEFqtFr6+vibbfX19cfLkyQYd4z//+Q8CAgKMCU9eXp7xGNcf07DveomJiXj99dcbGz6R1UgxzP/T3oP1P1ZAXwfkhd/T85FytogJEFE9GpwAdejQoSXjaJJFixZh48aNSE5OhoODQ5OPEx8fj7i4OON9lUqFwMDA5giRyCLsOatPgDj0ZT0GdaxNgM4VYcbwjmKHQ2R2mjwRIgCcOHEC2dnZ0Gg0Jtvvv//+Bj3e29sbMpkM+fn5Jtvz8/Ph5+d308cuWbIEixYtwu+//47evXsbtxsel5+fD39/f5NjhoeH13sshUIBhULRoJiJrI0gCMYCaCZA1mNQiP613J91heuCEdWjSQnQuXPn8MADD+Do0aMmdUGGBVIbuhiqXC5HREQEkpKSMG7cOAD6IuikpCTMmjXrho97++238dZbb2Hbtm3o16+fyb7g4GD4+fkhKSnJmPCoVCqkpqZixowZjTxTIut35nIZiso1cLSXIaydu9jhUDPp6ucKDyd7XOW6YET1atJXgueffx7BwcG4fPkynJyccPz4cezcuRP9+vVDcnJyo44VFxeHVatWYd26dUhPT8eMGTNQXl6O2NhYAMDkyZNNiqQXL16M1157DatXr0ZQUBDy8vKQl5eHsrIyAPokbM6cOXjzzTfxww8/4OjRo5g8eTICAgKMSRYR/SOldvirXxDX/7ImUqnkmsvhOR8Q0fWa1AOUkpKCP/74A97e3pBKpZBKpRg6dCgSExPx3HPP4dChQw0+1oQJE1BQUID58+cjLy8P4eHh2Lp1q7GIOTs7G1LpP2/KK1asgEajwUMPPWRynISEBCxYsACA/uq08vJyPPXUUyguLsbQoUOxdevW26oTIrJWhgRoYAiHv6zNoI5e2Ho8DylnizDzzlCxwyEyK01KgLRaLVxdXQHo63hyc3PRpUsXdOjQAadOnWr08WbNmnXDIa/re5SysrJueTyJRII33ngDb7zxRqNjIbIlOp2APZms/7FWhtd0//krUNdoobDjFX5EBk1KgHr27InDhw8jODgYkZGRePvttyGXy/Hpp58iJCSkuWMkohZyMq8UxRXVcJLL0KutUuxwqJl18nGBl7McReUaHM4pMS6RQURNrAGaN28edDr9KsNvvPEGMjMzMWzYMPzyyy/48MMPmzVAImo5hvl/+gd58iohKySRSIxDm4ahTiLSa1IPUExMjPHn0NBQnDx5EleuXIGHh4fxSjAiMn8pnP/H6g3s6IWfj15CyrlCPI9OYodDZDZuax4gAMjJyQEAThxIZGG0OsG4WvggFkBbLcNrezC7GFXVWs70TVSrSX3eNTU1eO2116BUKhEUFISgoCAolUrMmzcP1dXVzR0jEbWAE7kqlFbVwFVhhx4BXPTXWnVs44w2rgpoanQ4mH1V7HCIzEaTEqDZs2fj008/xdtvv41Dhw7h0KFDePvtt/HZZ5/hueeea+4YiagFpJwrBAAMCPbkauFWTCKRGHuB9rAOiMioSUNgGzZswMaNGzFq1Cjjtt69eyMwMBATJ07EihUrmi1AImoZrP+xHYM6euGHw7nGonciamIPkEKhQFBQUJ3twcHBkMvltxsTEbWwGq0O+7L0wyGcANH6GXqA0nKKUalp2FJFRNauSQnQrFmzsHDhQqjVauM2tVqNt95666ZreBGReTh6sQRl6hooHe3R3Z/1P9aug5cT/JUOqNYK2H/+itjhEJmFBg+BjR8/3uT+77//jnbt2iEsLAwAcPjwYWg0Gtx9993NGyERNTvDUEhksCekUk5dYe0MdUDfHLqIlLNFGNapjdghEYmuwQmQUmk6S+yDDz5ocp+XwRNZDtb/2J6BHfUJ0G4WQhMBaEQCtGbNmpaMg4haSVW1Fnsz9cMgQ0O9RY6GWsuQ2tf66IVilFRWQ+loL3JEROK6rWtfCwoKsGvXLuzatQsFBQXNFRMRtaCD569CXaODj6sCoT4uYodDraStuyNCvJ2hE4A9vBqMqGkJUHl5OZ588kn4+/vjjjvuwB133IGAgABMmzYNFRUVzR0jETWjXRn6+X+Ghnpz6RobY+gF2l37N0Bky5qUAMXFxeHPP//Ejz/+iOLiYhQXF+P777/Hn3/+iRdeeKG5YySiZmT48BvaicNftsbwmu9iAkTUtIkQ//e//2HLli0YPny4cdvo0aPh6OiIRx55hBMhEpmpkopqHLlYAuCf3gCyHQNDvCCVAOcKypFbXIkAd0exQyISTZN6gCoqKuDr61tnu4+PD4fAiMzY32cLIQhAJx8X+Lo5iB0OtTKloz16t3MHwGEwoiYlQIMGDUJCQgKqqqqM2yorK/H6669j0KBBzRYcETUvw9AHe39s11DWAREBaOIQ2NKlSzFy5Mg6EyE6ODhg27ZtzRogETWf3dcUQJNtGhLqjY92ZGBXRhEEQWAhPNmsJiVAvXr1wpkzZ/Dll1/i5MmTAICJEyfi8ccfh6Mjx5SJzFHOlQpkFVVAJpUgMsRT7HBIJH07uMPBXorCMjVO55ehi5+r2CERiaLRCVB1dTW6du2Kn376CdOnT2+JmIioBfx9Vt/7Ex7oDlcHToJnqxR2MgwI9sLO0wXYlVHIBIhsVqNrgOzt7U1qf4jIMuzK0E9+x/ofGhqqXwJl1xlOYEu2q0lF0DNnzsTixYtRU1PT3PEQUQvQ6QT8XVv/M4zz/9i8oaH6xVBTM69AU6MTORoicTSpBmjfvn1ISkrCb7/9hl69esHZ2dlk/zfffNMswRFR8ziZV4qicg2c5TKEB7qLHQ6JrKufK7yc5Sgq1yAtpxgDglkTRranSQmQu7t7ndXgich87crQD3VEhnjBXnZbSwCSFZBKJRgc6o0fD+diV0YhEyCySY1KgHQ6Hd555x2cPn0aGo0Gd911FxYsWMArv4jMHOt/6HpDQ73w4+Fc7M4oRNyIzmKHQ9TqGvVV8K233sIrr7wCFxcXtG3bFh9++CFmzpzZUrERUTNQ12ixN1OfAHH+HzIwJMNpOcUoraoWORqi1teoBOjzzz/Hxx9/jG3btuG7777Djz/+iC+//BI6HYvoiMzVwfPFqKrWwdtFgc6+LmKHQ2ainYcTgrycoNUJSD13RexwiFpdoxKg7OxsjB492ng/OjoaEokEubm5zR4YETWPf2Z/9uKsv2TC0AvE1eHJFjUqAaqpqYGDg+kCivb29qiuZvcpkbnaWTvXC+t/6HqGKRF2cj4gskGNKoIWBAFTp06FQqEwbquqqsIzzzxjcik8L4MnMg+FZWocuVACAIjq0kbkaMjcDA71hp1UgnMF5ci5UoFATyexQyJqNY3qAZoyZQp8fHygVCqNt0mTJiEgIMBkW2MsX74cQUFBcHBwQGRkJPbu3XvDtsePH8eDDz6IoKAgSCQSLF26tE6bBQsWQCKRmNy6du3aqJiIrMVftd/sewS4wcfV4Ratyda4OdijbwcPAEDyafYCkW1pVA/QmjVrmvXJN23ahLi4OKxcuRKRkZFYunQpYmJicOrUKfj4+NRpX1FRgZCQEDz88MP497//fcPj9ujRA7///rvxvp1dk6Y7IrJ4yaf0H2pRndn7Q/WL6twGezOv4M9Tl/HEwA5ih0PUakSdEe29997D9OnTERsbi+7du2PlypVwcnLC6tWr623fv39/vPPOO3j00UdNhuGuZ2dnBz8/P+PN25u1D2R7tDoBO2u/1Q/vUvcLBREADK8dGv37bBHUNVqRoyFqPaIlQBqNBgcOHEB0dPQ/wUiliI6ORkpKym0d+8yZMwgICEBISAgef/xxZGdn37S9Wq2GSqUyuRFZuqMXS3C1ohquCjv0ae8udjhkprr7u6GNqwIVGi32Z10VOxyiViNaAlRYWAitVgtfX1+T7b6+vsjLy2vycSMjI7F27Vps3boVK1asQGZmJoYNG4bS0tIbPiYxMdGkhikwMLDJz09kLpJPXQYADO3kzeUv6IYkEolxiNTwN0NkC6zuXXHUqFF4+OGH0bt3b8TExOCXX35BcXExvv766xs+Jj4+HiUlJcZbTk5OK0ZM1DL+NA5/sf6Hbs7wN/InC6HJhohWHezt7Q2ZTIb8/HyT7fn5+fDz82u253F3d0fnzp2RkZFxwzYKheKmNUVEluZq7SrfAHAHC6DpFoaGekMqAU7nlyG3uBIB7lzfkayfaD1AcrkcERERSEpKMm7T6XRISkrCoEGDmu15ysrKcPbsWfj7+zfbMYnM3V8ZhRAEoKufK/yV/DCjm3N3kqNPe/3l8OwFIlsh6hBYXFwcVq1ahXXr1iE9PR0zZsxAeXk5YmNjAQCTJ09GfHy8sb1Go0FaWhrS0tKg0Whw8eJFpKWlmfTuzJ07F3/++SeysrLw999/44EHHoBMJsPEiRNb/fyIxGKo5eDl79RQrAMiWyPqBDkTJkxAQUEB5s+fj7y8PISHh2Pr1q3Gwujs7GxIpf/kaLm5uejTp4/x/pIlS7BkyRJERUUhOTkZAHDhwgVMnDgRRUVFaNOmDYYOHYo9e/agTRt+EJBt0OkE7DytX9uJsz9TQw3v0gbvbT+N3RlFqNbqWDhPVk8iCIIgdhDmRqVSQalUoqSkBG5ubmKHQ9Qoxy6W4L5lu+Asl+HQ/Hsgt+MHGd2aTieg/1u/o6hcg41PDcTAEC+xQyJqtMZ8fvOdkcjKGIYwBod6M/mhBpNKJcaCecMM4kTWjO+ORFaGl79TU/FyeLIlTICIrEhJZTUOZhcDYAE0Nd6wTm0gkQDpl1TIV1WJHQ5Ri2ICRGRFdmcUQqsTEOrjgnYeTmKHQxbG01mO3u3cAbAXiKwfEyAiK8LL3+l28XJ4shVMgIishFYnICld/6F1V1eu/k5NY/jb2Xm6kKvDk1VjAkRkJdJyrqKoXANXBzsMCPYUOxyyUL3bKuHjqkCZugZ7zl0ROxyiFsMEiMhKbD+h7/25s4sPJ7GjJpNKJbi7m34y2t9P5N+iNZHl4rskkZXYfiIPADCiu6/IkZClu6f2b+j39HxwrlyyVkyAiKzAuYIynC0oh71MwuUv6LYN6ugFJ7kMl0qqcDxXJXY4RC2CCRCRFfg9XT9UMTDEC24O9iJHQ5bOwV6GOzrpE+nfOAxGVooJEJEV+L22/ie6G4e/qHlEd2cdEFk3JkBEFu5KuQb7z+uv1olm/Q81k7u6+kAqAU5cUuHC1QqxwyFqdkyAiCzcHycvQycA3f3d0NbdUexwyEp4OsvRr4N+OgXD/FJE1oQJEJGF49Vf1FIMf1PbOQxGVogJEJEFq6rWYufpQgBMgKj5GYZU95wrgqqqWuRoiJoXEyAiC/b32UJUVmvhr3RAjwA3scMhKxPs7YxQHxfU6AQkn+LiqGRdmAARWbDt11z9JZFIRI6GrFE0Z4UmK8UEiMhC6XSCcf4fDn9RSzH8be04dRnVWp3I0RA1HyZARBbq8IViFJSq4aKwQ2QIFz+llhEe6A5vFzlKq2qQysVRyYowASKyUIben6gubaCwk4kcDVkrmVSCu7sargbLEzkaoubDBIjIAgmCgF+P6j+M7uHwF7UwwzDYtuP50Om4OCpZByZARBYo/VIpzhWWQ24nxd1c/oJa2LDO3nBV2CFPVYUD2VfFDoeoWTABIrJAPx/NBQDc2aUNXBR2IkdD1k5hJ8OIHvpE++cjl0SOhqh5MAEisjCCIBg/hO7tHSByNGQr7uvtDwD45eglaDkMRlaACRCRhTmeq0JWUQUUdlLc3dVH7HDIRgwNbQM3BztcLlVjfxavBiPLxwSIyML8VNv7c1dXHzhz+ItaidxOipgefgD++RsksmRMgIgsiCAIxvqf+zj8Ra3s3tphsF+PcRiMLB8TICILcvRiCXKuVMLRXoY7u7YROxyyMUNCveHuZI/CMg1SM4vEDofotjABIrIghuLnu7r5wEnO4S9qXfYyKUbWDoPxajCydEyAiCyEIAjG2ov7evmLHA3ZKsMw2NZjeajh2mBkwURPgJYvX46goCA4ODggMjISe/fuvWHb48eP48EHH0RQUBAkEgmWLl1628ckshRpOcW4WFwJJ7kMw7vw6i8Sx6AQL3g42aOoXIM9XBuMLJioCdCmTZsQFxeHhIQEHDx4EGFhYYiJicHly5frbV9RUYGQkBAsWrQIfn5+zXJMIkthGHKI7uYLRznX/iJx2MmkGNlT3wtkKMgnskSiJkDvvfcepk+fjtjYWHTv3h0rV66Ek5MTVq9eXW/7/v3745133sGjjz4KhULRLMcksgQ6nYBfjhomP+TwF4lrzDXDYNUcBiMLJVoCpNFocODAAURHR/8TjFSK6OhopKSkmM0xiczBoZyryC2pgrNchqjOvPqLxDUg2BPeLnJcrajG32d5NRhZJtESoMLCQmi1Wvj6mi7k6Ovri7y8vFY9plqthkqlMrkRmZMfD+t7f0Z094WDPYe/SFz6YbDaSREPcxiMLJPoRdDmIDExEUql0ngLDAwUOyQio2qtDj/WfsiMCePkh2QextROxPnrsTxUarQiR0PUeKIlQN7e3pDJZMjPzzfZnp+ff8MC55Y6Znx8PEpKSoy3nJycJj0/UUtIPlWAonINvF0UuIPDX2Qm+gd5or2nE8rUNdh2vGm99kRiEi0BksvliIiIQFJSknGbTqdDUlISBg0a1KrHVCgUcHNzM7kRmYstB/QJ+QN9AmAvY6ctmQepVIIH+7YDAGw5cEHkaIgaT9R307i4OKxatQrr1q1Deno6ZsyYgfLycsTGxgIAJk+ejPj4eGN7jUaDtLQ0pKWlQaPR4OLFi0hLS0NGRkaDj0lkSYrK1EhK10/h8GBEO5GjITI1vm9bAMDus4W4WFwpcjREjSPqXPoTJkxAQUEB5s+fj7y8PISHh2Pr1q3GIubs7GxIpf/kaLm5uejTp4/x/pIlS7BkyRJERUUhOTm5QccksiQ/HM5FjU5Ar7ZKdPVjzySZl0BPJwwK8ULKuSJ8e/ACZt3VSeyQiBpMIggCl/S9jkqlglKpRElJCYfDSFT3fvgXjueq8Pr9PTBlcJDY4RDV8b8DF/DC5sMI8nLCjrnDIZFIxA6JbFhjPr9ZUEBkpk7kqnA8VwV7mQT38+ovMlOjevnBWS5DVlEFDpy/KnY4RA3GBIjITP3voL6wNLqbLzyc5SJHQ1Q/J7kdRtcuzstiaLIkTICIzFC1VofvDl0EADzE4mcyc4a/0Z+OXOKcQGQxmAARmSHO/UOWhHMCkSViAkRkhjj3D1kSzglElojvrERmhnP/kCXinEBkaZgAEZkZzv1DlsgwJ5AgAN8eZC8QmT8mQERmRBAEfLU3GwCLn8nyGP5mN+7LgVbHKebIvDEBIjIjKeeKcDq/DE5yGcb1aSt2OESNcm9vf7g72ePC1Ur8cfKy2OEQ3RQTICIz8vnf5wEAD/RpC6WjvcjREDWOg70ME/oHAgA+T8kSNxiiW2ACRGQmLhZX4rcT+kuIJw8KEjcYoiaaFNkBUgnw15lCZFwuEzscohtiAkRkJr7ccx46ARgU4oUufq5ih0PUJIGeTri7m37x6fXsBSIzxgSIyAxUVWuxcZ9+7p8pgzuIHA3R7ZlS24O55cAFlFZVixsM0Q0wASIyAz8duYQr5RoEKB0QXfvtmchSDQn1Qsc2zijXaPHNwYtih0NULyZARCITBAHr/s4CADw+sAPsOPMzWTiJRIIpg4MAAOtSsiAIvCSezA/faYlEdiinGEcvlkBuJ8WjtVfQEFm68X3bwUVhh3MF5diVUSh2OER1MAEiEtnntb0/Y3oHwMtFIW4wRM3ERWGHB2uXx1hXO70DkTlhAkQkosulVfj56CUALH4m6/NEbTF00sl85FypEDcYouswASIS0ca9OajWCujT3h2927mLHQ5Rswr1ccGwTt4QBGD9HvYCkXlhAkQkkgpNDdbWDn9NrS0YJbI2hkviN6Rmo6SCl8ST+WACRCSSr/bm4Eq5BoGejri3l7/Y4RC1iLu6+qCLryvK1DVYx4kRyYwwASISQVW1Fp/uPAsAeHZ4KC99J6sllUow865QAMDq3ZkoU9eIHBGRHt91iUSw5cAF5KvU8Fc6YHxfrvpO1u3eXv4I9nZGcUU1vmQtEJkJJkBEraxaq8OKZH3vz9N3hEBhJxM5IqKWJZNK8OzwjgCAVX+dQ1W1VuSIiJgAEbW67w5dxMXiSni7yPHogPZih0PUKsb1aYu27o4oLNNg495sscMhYgJE1Jq0OgEf1/b+TB8WAgd79v6QbbCXSTGjthfok53noK5hLxCJiwkQUSv6+eglZBaWw93JHo8P5MSHZFseimgHXzcFLpVUcZFUEh0TIKJWotMJWP5HBgDgySHBcFHYiRwRUetysJfhqTv0vUAfJ2egRqsTOSKyZUyAiFrJ9vR8nMovhavCzrhSNpGtmTggEF7OcuRcqcQPh3PFDodsGBMgolag1Ql4f/tpAMDkwR2gdLQXOSIicTjJ7TBtWDAA4IOkM9DUsBeIxMEEiKgVbN6fg5N5pVA62uNfQ0PEDodIVFMGBaGNqwLniyrwOWeHJpGYRQK0fPlyBAUFwcHBAZGRkdi7d+9N22/evBldu3aFg4MDevXqhV9++cVk/9SpUyGRSExuI0eObMlTILqhMnUNlvym7/157u5O8HCWixwRkbicFXaYe09nAMCHSWdwtVwjckRki0RPgDZt2oS4uDgkJCTg4MGDCAsLQ0xMDC5fvlxv+7///hsTJ07EtGnTcOjQIYwbNw7jxo3DsWPHTNqNHDkSly5dMt6++uqr1jgdojo++fMsCsvUCPJywhO88osIAPBQRCC6+rlCVVWDD/84I3Y4ZINET4Dee+89TJ8+HbGxsejevTtWrlwJJycnrF69ut72H3zwAUaOHIkXX3wR3bp1w8KFC9G3b1989NFHJu0UCgX8/PyMNw8Pj9Y4HSITucWV+HTnOQDAy6O6QW4n+n85IrMgk0ow797uAID1KedxrqBM5IjI1oj6bqzRaHDgwAFER0cbt0mlUkRHRyMlJaXex6SkpJi0B4CYmJg67ZOTk+Hj44MuXbpgxowZKCoqav4TILqFd7adgrpGhwHBnojp4St2OERmZWgnb9zV1Qc1OgGJv54UOxyyMaImQIWFhdBqtfD1Nf1g8PX1RV5eXr2PycvLu2X7kSNH4vPPP0dSUhIWL16MP//8E6NGjYJWW//Mo2q1GiqVyuRGdLuOXCjGt4f0k73Nu7cbJBKJyBERmZ9XRneFTCrB9hP5SDnLL6rUeqyyP/7RRx/F/fffj169emHcuHH46aefsG/fPiQnJ9fbPjExEUql0ngLDAxs3YDJ6giCgDd/SgcAjO/TFr3buYsbEJGZCvVxxWO1a+K9+fMJ6HSCyBGRrRA1AfL29oZMJkN+fr7J9vz8fPj5+dX7GD8/v0a1B4CQkBB4e3sjIyOj3v3x8fEoKSkx3nJychp5JkSmth3Pw96sK3Cwl2JuTBexwyEya3OiO8FVYYfjuSp8c4hLZFDrEDUBksvliIiIQFJSknGbTqdDUlISBg0aVO9jBg0aZNIeALZv337D9gBw4cIFFBUVwd/fv979CoUCbm5uJjeipiqtqsYbP54AoF/wNMDdUeSIiMybl4sCM+8KBQAs+jUdV3hZPLUC0YfA4uLisGrVKqxbtw7p6emYMWMGysvLERsbCwCYPHky4uPjje2ff/55bN26Fe+++y5OnjyJBQsWYP/+/Zg1axYAoKysDC+++CL27NmDrKwsJCUlYezYsQgNDUVMTIwo50i2JfHXk8gtqUJ7Tyfj6tdEdHOxQ4LQ2dcFhWUavP7jcbHDIRsgegI0YcIELFmyBPPnz0d4eDjS0tKwdetWY6FzdnY2Ll26ZGw/ePBgbNiwAZ9++inCwsKwZcsWfPfdd+jZsycAQCaT4ciRI7j//vvRuXNnTJs2DREREfjrr7+gUChEOUeyHX9nFGJDajYAYPGDveEk54KnRA2hsJPhnYfCIJUA36flYvuJ/Fs/iOg2SARBYMXZdVQqFZRKJUpKSjgcRg1Wrq7ByA92IudKJSYNbI83x/USOyQii5P4azo++fMcfFwV2P7vKCiduG4eNVxjPr9F7wEishbvbDuFnCuVaOvuiJdHdRM7HCKL9O/ozghp44zLpWos/PmE2OGQFWMCRNQM9mZewdq/swAAieN7wUXBoS+ipnCwl+Gdh3pDIgG2HLiA5FP1L4tEdLuYABHdpkqNFv/53xEAwIR+gbijcxuRIyKybBEdPBE7OBgAEP/NUZRWVYscEVkjJkBEt+ntbSeRWVgOPzcHvHofh76ImsOLMV3QwcsJl0qqsPAnDoVR82MCRHQbfjqSizW7swAA/ze+J9wcWLBJ1Bwc5TIsflA/FPb1/gv4eh8nqKXmxQSIqInO5JfipS36oa+no0JwV1cudkrUnAaGeCEuujMAYN73x3D0QonIEZE1YQJE1ASlVdV4ev0BVGi0GNzRCy/ew+UuiFrCzDtDEd3NB5oaHZ754gCucpZoaiZMgIgaSRAEzN18GOcKy+GvdMCHE/vATsb/SkQtQSqV4N1HwtHBywkXiyvx3MZD0HLBVGoGfNcmaqSVf57DtuP5kMuk+PjxvvB24QzjRC1J6WiPlZMi4GAvxV9nCvH+9tNih0RWgAkQUSPsOlOId7adBAAk3N8dfdp7iBwRkW3o5u+GReN7AwA+2pGB347niRwRWTomQEQNdPRCCZ754gB0AvBQRDs8NqC92CER2ZRxfdpi6uAgAMBzGw9hX9YVcQMii8YEiKgBzuSXYvLqVJSpaxAZ7Ik3x/WERCIROywim/PK6G4Y3qUNqqp1eHLNPhy7yCvDqGmYABHdQs6VCkz6LBVXK6oR1k6J/07pBwd7mdhhEdkkuZ0UKx6PwIAgT5SqazB59V5kXC4VOyyyQEyAiG4iX1WFx/+binyVGp19XbA2dgBcOdkhkagc5TJ8NrUferVV4kq5BpP+uxc5VyrEDossDBMgohvQv7GmIvtKBdp7OuGLaZHwcJaLHRYRAXB1sMe6Jwegk48L8lRVmPRZKi6rqsQOiywIEyCielwsrsTET/fgzOUy+Lk54Mt/RcLHzUHssIjoGp7Ocnzxr0gEejrifFEFHvkkBVmF5WKHRRaCCRDRdY5dLMEDy3fjVH4p2rgq8MW/BiDQ00nssIioHr5uDtjwr4Fo6+6IrKIKjF/xNw6cvyp2WGQBmAARXWPHqcuY8EkKLpfqa36+mzkEoT6uYodFRDcR6OmEb2cONtYEPbZqD7YeuyR2WGTmmAAR1fpqbzb+tW4/ymvX99r8zGC0dXcUOywiagAfVwdsfGog7u7qA3WNDjO+PIjPdmWKHRaZMSZAZPPUNVos/OkE4r85Cq1OwPi+bbE2dgCUjrzai8iSOCvs8MkTEZg0sD0EAVj40wm88u1RVGq0YodGZogJENm00/mlGLf8b+M3xefv7oR3Hw6D3I7/NYgskZ1MioVje+KV0V0BABtSszHmo12cMJHq4Ls82SRBELB2dybGLNuF9EsqeDrLsWpyP/x7RGfO8Exk4SQSCZ66oyPWTxsAH1cFMi6X4YGPd2Pln2e5kjwZSQRB4F/DdVQqFZRKJUpKSuDm5iZ2ONTMLquq8OKWI/jzdAEAIKpzG7zzcG/4uPIydyJrc6Vcg/hvjmDb8XwAwMAQTyx5OAztPHhlpzVqzOc3E6B6MAGyTlXVWny2KxMf78hAuUYLuZ0Ur47uhsmDOrDXh8iKCYKAr/fnYMEPJ1BZrYWDvRRP3dERz0SFwEluJ3Z41IyYAN0mJkDWRRAE/HTkEhb9ehIXiysBAGHtlHjn4TB09uUl7kS2IrOwHC9tOYx9Wfp5gnzdFHgppise6NMWUim/BFkDJkC3iQmQdRAEAfuyruLtrSexv3ZiND83B/xnVBeMDeMbHpEtEgQBvxzNQ+Kv6bhwVf+FqHc7JV6K6YohoV7sDbZwTIBuExMgy1aj1eHXY3n471/ncPiC/soPR3sZnonqiKfuCIGjnCu5E9m6qmot1uzOwvIdGShT1wAAuvu74V/DgnFf7wBeCWqhmADdJiZAlklVVY3N+y9g9a5M41CX3E6KB/u2xfN3d4afkkXORGSqoFSNj/44g6/3X0BltX6+ID83B0wZHISJAwLh7sQFkC0JE6DbxATIclRVa5F86jK+T8tF0snL0NToAOgXSXxiYAc8MagDvF0UIkdJRObuarkGX6aex7qU8ygoVQMA7GUSDO/ig7HhAbi7qy97jy0AE6DbxATIvJWra7DnXBG2Hc/Dr8fyUFpVY9zXyccFsUOCMb5vWzjY882KiBpHXaPFD2m5WLM7CycuqYzbneUyxPTwQ0xPPwzu6AVXB84Ub46YAN0mJkDmRasTcOxiCXZlFGLn6QIczL6Kau0/f7b+SgfcHxaA+8MD0N3fjUWMdGNHjwLffAMUFwPu7sD48UCvXmJHRWbqVF4pvk+7iO/Tco3D6gAgk0rQJ9Adwzq1wbDO3ujdVgk7GWuGzAEToNvEBEg8giDgwtVKHL5QjMM5xTh8oQTHLpag4rq1fNp5OCKqcxuMCQvAgCBPXtFFN5eRAUyZAvz9NyCTAVIpoNMBWi0wZAiwdi0QGip2lGSmBEHAweyr+PHwJfx5ugCZheUm+x3spegZoETvdu4IC1QirJ07Ong58cuYCCwuAVq+fDneeecd5OXlISwsDMuWLcOAAQNu2H7z5s147bXXkJWVhU6dOmHx4sUYPXq0cb8gCEhISMCqVatQXFyMIUOGYMWKFejUqVOD4mEC1PJUVdXILa7E+aIKZFwuw9mCMpy9XIazBeXGKzKu5aqww6COXhjWuQ2GhXrzzYUaLiMDiIwESkr0Cc/1ZDJAqQRSU5kEUYPkXKnAX2cKsSujALvOFEJVVfc9y0kuQ8c2Lgj1cUHHNs7o2MYFHbyc0dbdEW6Odnz/aiEWlQBt2rQJkydPxsqVKxEZGYmlS5di8+bNOHXqFHx8fOq0//vvv3HHHXcgMTER9913HzZs2IDFixfj4MGD6NmzJwBg8eLFSExMxLp16xAcHIzXXnsNR48exYkTJ+DgcOsrgZgANZ4gCCjXaKGqrEZJZTWuVmhQVKZBUZkahWUaFJWrka9SI7e4EhevVqK0niTHwF4mQTd/N/Rup/8mFRbojo5tXCBjLw81xZAh+uSmvuTHQCYDBg4Edu1qvbjIKuh0As4VluPINb3WJ3JV0Gh1N3yMi8IOAe4OCHB3hK+rA7xd5fByVsDbVQFvZzncneRQOtnDzcEOLgomS41hUQlQZGQk+vfvj48++ggAoNPpEBgYiNmzZ+Pll1+u037ChAkoLy/HTz/9ZNw2cOBAhIeHY+XKlRAEAQEBAXjhhRcwd+5cAEBJSQl8fX2xdu1aPProo7eMyfALPJF1Ca63+AU29LdXXzsBQp19AvTJhOHnf/YLEATDfv1jdTr9v4JwzTYB0AkCBEH/s1YnQKcToK29r9MJ0OoE1Oh0qNEJqNEKtf/qUK3VQaMVUK3VobpGB41WB3WNDlXVWqirdVDXaFFZrUWFRotydY3+X00NyqpqoKqqafQigx5O9mjr4YjQNi7/fFPycUEHLyco7FjATM3g6FGgd++Gtz9yhDVBdNuqtbo6vdsZBWW4cLUSV8o1jTqWVAK4OdrDRWEHZ7kdnBQy/b9yGRzlMijspHCw/+dfuUwKezsp7GVSyGUS2MuksJNJYSeVwE4mgZ1UAplUf18i0dczySQSSKUSyKQSSCX6xWSlktqfoW8nqf1ZKr1mG/TbUXtf/1PtvxIJrk3b/tlfN5lrTH53q7alKhW6B/k3KAESdREUjUaDAwcOID4+3rhNKpUiOjoaKSkp9T4mJSUFcXFxJttiYmLw3XffAQAyMzORl5eH6Oho436lUonIyEikpKTUmwCp1Wqo1WrjfZVKX/kfs/QvSBVcMK8x7GUSKB3t4eZoD28XBbxd5PB2UcDLWYE2rgq09XBEW3cH+Csd4azgGjzUwr75Rt+7c7PeHwOZDPj2WyZAdNvsZVKE+ui/1F2vUqNFbom+Jzy3uBKXS9X6nvJyDQpL1SgsU6OksgaqympotDroBKC4ohrFFdUinInl0akrGtxW1E+gwsJCaLVa+Pr6mmz39fXFyZMn631MXl5eve3z8vKM+w3bbtTmeomJiXj99dfrbFfYSyGzv3Vlf30Zbb3trsuQ9dskdbZBYppFGx4rgWlWLTFk6Ndk6VKJPkOX1mbwEgkgkxgy+9p/pRLY12b7+m8E+m8D8tpvDfYyKeR2+m8ODvYyONhJoaj9hqGwl8FFIYOT3PTbiNLRHkpHezjYS9ldS+ajuFhf8NyQBEgqBa5ebfGQyLY51tYGdWxTNzm6liAIUNfoUFJbVlCmrkGFWt/rXqnRokxdo++dr9FBXftvVbUWGq0ATY2+R79aq4OmRt/br9Xpe/e1OgHVhpEBnQCdoP9XK+hHE3SCfptOZxhN+GekQSeYjlAIgmAclTDEbNiH60Y2rt1vuq3hvzsBt26s1TX8ajx+BQcQHx9v0qukUqkQGBiIA/NGsAaIyJK5u+uv9moInQ7w8GjRcIgaSiKR6L+A2svg68ZZ7BtKpVJB+U7D2oo6cYG3tzdkMhny8/NNtufn58PPz6/ex/j5+d20veHfxhxToVDAzc3N5EZEVmD8+Ib1/gD6duPHt2w8RGQ2RE2A5HI5IiIikJSUZNym0+mQlJSEQYMG1fuYQYMGmbQHgO3btxvbBwcHw8/Pz6SNSqVCamrqDY9JRFaqVy9g8GB9fc/NyGT6q8VqryQlIusn+hBYXFwcpkyZgn79+mHAgAFYunQpysvLERsbCwCYPHky2rZti8TERADA888/j6ioKLz77ru49957sXHjRuzfvx+ffvopAH234Zw5c/Dmm2+iU6dOxsvgAwICMG7cOLFOk4jEsm5dw+YBWru21UMjIvGIngBNmDABBQUFmD9/PvLy8hAeHo6tW7cai5izs7Mhlf7TUTV48GBs2LAB8+bNwyuvvIJOnTrhu+++M84BBAAvvfQSysvL8dRTT6G4uBhDhw7F1q1bGzQHEBFZmdBQ/TxAU6cCu3fXnQl64EDOBE1kg0SfB8gccSJEIit19Kj+UverV/UFz+PHc9iLyIo05vNb9B4gIqJW06sX5/khIgAiF0ETERERiYEJEBEREdkcJkBERERkc5gAERERkc1hAkREREQ2hwkQERER2RwmQERERGRzmAARERGRzeFEiPUwTI6tUqlEjoSIiIgayvC53ZBFLpgA1aO0tBQAEBgYKHIkRERE1FilpaVQKpU3bcO1wOqh0+mQm5sLV1dXSCQSscNpMpVKhcDAQOTk5HBNM5HxtTAffC3MB18L82Etr4UgCCgtLUVAQIDJQur1YQ9QPaRSKdq1ayd2GM3Gzc3Nov+grQlfC/PB18J88LUwH9bwWtyq58eARdBERERkc5gAERERkc1hAmTFFAoFEhISoFAoxA7F5vG1MB98LcwHXwvzYYuvBYugiYiIyOawB4iIiIhsDhMgIiIisjlMgIiIiMjmMAEiIiIim8MEyMao1WqEh4dDIpEgLS1N7HBsTlZWFqZNm4bg4GA4OjqiY8eOSEhIgEajETs0m7F8+XIEBQXBwcEBkZGR2Lt3r9gh2ZzExET0798frq6u8PHxwbhx43Dq1CmxwyIAixYtgkQiwZw5c8QOpcUxAbIxL730EgICAsQOw2adPHkSOp0On3zyCY4fP473338fK1euxCuvvCJ2aDZh06ZNiIuLQ0JCAg4ePIiwsDDExMTg8uXLYodmU/7880/MnDkTe/bswfbt21FdXY177rkH5eXlYodm0/bt24dPPvkEvXv3FjuUVsHL4G3Ir7/+iri4OPzvf/9Djx49cOjQIYSHh4sdls175513sGLFCpw7d07sUKxeZGQk+vfvj48++giAft2/wMBAzJ49Gy+//LLI0dmugoIC+Pj44M8//8Qdd9whdjg2qaysDH379sXHH3+MN998E+Hh4Vi6dKnYYbUo9gDZiPz8fEyfPh3r16+Hk5OT2OHQNUpKSuDp6Sl2GFZPo9HgwIEDiI6ONm6TSqWIjo5GSkqKiJFRSUkJAPD/gYhmzpyJe++91+T/h7XjYqg2QBAETJ06Fc888wz69euHrKwssUOiWhkZGVi2bBmWLFkidihWr7CwEFqtFr6+vibbfX19cfLkSZGiIp1Ohzlz5mDIkCHo2bOn2OHYpI0bN+LgwYPYt2+f2KG0KvYAWbCXX34ZEonkpreTJ09i2bJlKC0tRXx8vNghW62GvhbXunjxIkaOHImHH34Y06dPFylyInHNnDkTx44dw8aNG8UOxSbl5OTg+eefx5dffgkHBwexw2lVrAGyYAUFBSgqKrppm5CQEDzyyCP48ccfIZFIjNu1Wi1kMhkef/xxrFu3rqVDtXoNfS3kcjkAIDc3F8OHD8fAgQOxdu1aSKX8LtLSNBoNnJycsGXLFowbN864fcqUKSguLsb3338vXnA2atasWfj++++xc+dOBAcHix2OTfruu+/wwAMPQCaTGbdptVpIJBJIpVKo1WqTfdaECZANyM7OhkqlMt7Pzc1FTEwMtmzZgsjISLRr107E6GzPxYsXceeddyIiIgJffPGF1b65mKPIyEgMGDAAy5YtA6Affmnfvj1mzZrFIuhWJAgCZs+ejW+//RbJycno1KmT2CHZrNLSUpw/f95kW2xsLLp27Yr//Oc/Vj0syRogG9C+fXuT+y4uLgCAjh07MvlpZRcvXsTw4cPRoUMHLFmyBAUFBcZ9fn5+IkZmG+Li4jBlyhT069cPAwYMwNKlS1FeXo7Y2FixQ7MpM2fOxIYNG/D999/D1dUVeXl5AAClUglHR0eRo7Mtrq6udZIcZ2dneHl5WXXyAzABImpV27dvR0ZGBjIyMuokn+yMbXkTJkxAQUEB5s+fj7y8PISHh2Pr1q11CqOpZa1YsQIAMHz4cJPta9aswdSpU1s/ILJJHAIjIiIim8PKSyIiIrI5TICIiIjI5jABIiIiIpvDBIiIiIhsDhMgIiIisjlMgIiIiMjmMAEiIiIim8MEiMiCDB8+HHPmzBE7jFtasGABfH19IZFI8N1334kdTh0LFixAeHi42GE0q6ac061en6ysLEgkEqSlpd1WbETmiAkQUSsYM2YMRo4cWe++v/76CxKJBEeOHGnlqFpGeno6Xn/9dXzyySe4dOkSRo0aVaeN4YPVcPP09ERUVBT++usvESJuHQcOHIBEIsGePXvq3X/33Xdj/PjxTT7+3LlzkZSU1OTHt5QVK1bA3d0dOTk5Jttnz56Nzp07o6KiQqTIyNYxASJqBdOmTcP27dtx4cKFOvvWrFmDfv36oXfv3iJE1vzOnj0LABg7diz8/PygUChu2Pb333/HpUuXsHPnTgQEBOC+++5Dfn5+a4XaqiIiIhAWFobVq1fX2ZeVlYUdO3Zg2rRpjT6uIAioqamBi4sLvLy8miPUZvXMM89gwIABJueWlJSEFStWYO3atXBychIxOrJlTICIWsF9992HNm3aYO3atSbby8rKsHnzZkybNg1FRUWYOHEi2rZtCycnJ/Tq1QtfffXVTY9b3xCGu7u7yfPk5OTgkUcegbu7Ozw9PTF27FhkZWUZ9ycnJ2PAgAFwdnaGu7s7hgwZUmd16GsdPXoUd911FxwdHeHl5YWnnnoKZWVlAPTDMGPGjAEASKVSSCSSm8bv5eUFPz8/9OzZE6+88gpUKhVSU1ON+9evX49+/frB1dUVfn5+eOyxx3D58mWT2CUSCZKSktCvXz84OTlh8ODBOHXqlMnzLFq0CL6+vnB1dcW0adNQVVVlsl+n0+GNN95Au3btoFAojGuEGRh6rL7++msMGzYMjo6O6N+/P06fPo19+/ahX79+cHFxwahRo0wWuL3etGnTsGnTpjq9HmvXroW/vz9GjhzZ4HP+9ddfERERAYVCgV27dtUZAtu3bx9GjBgBb29vKJVKREVF4eDBg3ViMvTSOTo6IiQkBFu2bLlh/ABw7NgxjBo1Ci4uLvD19cUTTzyBwsLCG7aXSCT47LPPkJqaipUrV0KlUuHJJ59EXFwcBg8efNPnImpJTICIWoGdnR0mT56MtWvXmix6unnzZmi1WkycOBFVVVWIiIjAzz//jGPHjuGpp57CE088gb179zb5eaurqxETEwNXV1f89ddf2L17N1xcXDBy5EhoNBrU1NRg3LhxiIqKwpEjR5CSkoKnnnrqholLeXk5YmJi4OHhgX379mHz5s34/fffMWvWLAD6YZg1a9YA0H+wXrp0qUFxVlZW4vPPPwcAyOVyk/gXLlyIw4cP47vvvkNWVla9i2W++uqrePfdd7F//37Y2dnhySefNO77+uuvsWDBAvzf//0f9u/fD39/f3z88ccmj//ggw/w7rvvYsmSJThy5AhiYmJw//3348yZMybtEhISMG/ePBw8eBB2dnZ47LHH8NJLL+GDDz7AX3/9hYyMDMyfP/+G5/n4449DrVabJBmCIGDdunWYOnUqZDJZg8/55ZdfxqJFi5Cenl5v72FpaSmmTJmCXbt2Yc+ePejUqRNGjx6N0tJSk3avvfYaHnzwQRw+fBiPP/44Hn30UaSnp9cbf3FxMe666y706dMH+/fvx9atW5Gfn49HHnnkhucMAIGBgVi6dClefPFFTJo0CS4uLli4cOFNH0PU4gQiahXp6ekCAGHHjh3GbcOGDRMmTZp0w8fce++9wgsvvGC8HxUVJTz//PPG+wCEb7/91uQxSqVSWLNmjSAIgrB+/XqhS5cugk6nM+5Xq9WCo6OjsG3bNqGoqEgAICQnJzfoHD799FPBw8NDKCsrM277+eefBalUKuTl5QmCIAjffvutcKu3lszMTAGA4OjoKDg7OwsSiUQAIERERAgajeaGj9u3b58AQCgtLRUEQRB27NghABB+//13k3gACJWVlYIgCMKgQYOEZ5991uQ4kZGRQlhYmPF+QECA8NZbb5m06d+/v/Fxhnj/+9//Gvd/9dVXAgAhKSnJuC0xMVHo0qXLTc/90UcfFaKiooz3k5KSBADCmTNnGnXO3333nUm7hIQEk3O6nlarFVxdXYUff/zRuA2A8Mwzz5i0i4yMFGbMmGFy3ocOHRIEQRAWLlwo3HPPPSbtc3JyBADCqVOnbnregiAIAwcOFAAIqampt2xL1NLYA0TUSrp27YrBgwcba0AyMjLw119/GWsjtFotFi5ciF69esHT0xMuLi7Ytm0bsrOzm/ychw8fRkZGBlxdXeHi4gIXFxd4enqiqqoKZ8+ehaenJ6ZOnYqYmBiMGTMGH3zwwU17bdLT0xEWFgZnZ2fjtiFDhkCn09UZdmqITZs24dChQ/jf//6H0NBQrF27Fvb29sb9Bw4cwJgxY9C+fXu4uroiKioKAOr8Tq7tAfH39wcA47BReno6IiMjTdoPGjTI+LNKpUJubi6GDBli0mbIkCF1ekKufR5fX18AQK9evUy2XTtcVZ8nn3wSO3fuNNZKrV69GlFRUQgNDW3UOffr1++mz5Ofn4/p06ejU6dOUCqVcHNzQ1lZWZ3jXPu7MNy/UQ/Q4cOHsWPHDuPfkouLC7p27Qrgn9qvGzl8+DAOHjwIJycnqy52J8thJ3YARLZk2rRpmD17NpYvX441a9agY8eOxg+4d955Bx988AGWLl2KXr16wdnZGXPmzIFGo7nh8SQSicmQGqAfNjIoKytDREQEvvzyyzqPbdOmDQB9EfZzzz2HrVu3YtOmTZg3bx62b9+OgQMHNscp31RgYCA6deqETp06oaamBg888ACOHTsGhUJhHG6LiYnBl19+iTZt2iA7OxsxMTF1fifXJk2G4TudTtfs8db3PNdvu9Xz3n333Wjfvj3Wrl2LF198Ed988w0++eQTAGjUOV+bhNZnypQpKCoqwgcffIAOHTpAoVBg0KBBN/17upWysjKMGTMGixcvrrPPkHjWR6PRYPLkyXj88ccRFRWFZ555Bvfddx+6dOnS5FiIbhd7gIha0SOPPAKpVIoNGzbg888/x5NPPmn8IN29ezfGjh2LSZMmISwsDCEhITh9+vRNj9emTRuTHpszZ86YFNj27dsXZ86cgY+PD0JDQ01uSqXS2K5Pnz6Ij4/H33//jZ49e2LDhg31Pl+3bt1w+PBhlJeXG7ft3r0bUqn0tj/MHnroIdjZ2Rnrc06ePImioiIsWrQIw4YNQ9euXW/Zu3KjmK8trAZgcim6m5sbAgICsHv3bpM2u3fvRvfu3ZtwJjcnlUoRGxuLdevWYcOGDZDL5XjooYcANN85A/r4n3vuOYwePRo9evSAQqGot1j5+svy9+zZg27dutV7zL59++L48eMICgqq8/d0s4TsjTfewJUrV/D+++9jypQpGDFiBGJjY1skSSVqKCZARK3IxcUFEyZMQHx8PC5dumRS3NqpUyds374df//9N9LT0/H000/f8pLwu+66Cx999BEOHTqE/fv345lnnjHpkXj88cfh7e2NsWPH4q+//kJmZiaSk5Px3HPP4cKFC8jMzER8fDxSUlJw/vx5/Pbbbzhz5swNPwAff/xxODg4YMqUKTh27Bh27NiB2bNn44knnjAOCTWVRCLBc889h0WLFqGiogLt27eHXC7HsmXLcO7cOfzwww9NKpx9/vnnsXr1aqxZswanT59GQkICjh8/btLmxRdfxOLFi7Fp0yacOnUKL7/8MtLS0vD888/f1jndSGxsLC5evIhXXnkFEydOhKOjIwA02zkD+r+n9evXIz09HampqXj88ceNz3OtzZs3Y/Xq1cbfzd69e41F7debOXMmrly5gokTJ2Lfvn04e/Ystm3bhtjYWGi12nofs2/fPixevBifffaZMen+5JNPcOrUKbz//vtNOjeiZiF2ERKRrfn7778FAMLo0aNNthcVFQljx44VXFxcBB8fH2HevHnC5MmThbFjxxrbXF8EffHiReGee+4RnJ2dhU6dOgm//PKLSRG0IAjCpUuXhMmTJwve3t6CQqEQQkJChOnTpwslJSVCXl6eMG7cOMHf31+Qy+VChw4dhPnz5wtarfaG8R85ckS48847BQcHB8HT01OYPn26sUBXEBpXBG0orjUoLy8XPDw8hMWLFwuCIAgbNmwQgoKCBIVCIQwaNEj44YcfTB5nKAi+evWq8RiHDh0SAAiZmZnGbW+99Zbg7e0tuLi4CFOmTBFeeuklk4JhrVYrLFiwQGjbtq1gb28vhIWFCb/++utN463vudesWSMolcqbnrvBPffcIwAQ9u7da7K9KecsCHWLoA8ePCj069dPcHBwEDp16iRs3rxZ6NChg/D+++8b2wAQli9fLowYMUJQKBRCUFCQsGnTppue9+nTp4UHHnhAcHd3FxwdHYWuXbsKc+bMMSm0N6iqqhK6desmTJ8+vc6+L7/8UnBwcBBOnjzZoN8XUXOTCMJ1BQREREREVo5DYERERGRzmAARERGRzWECRERERDaHCRARERHZHCZAREREZHOYABEREZHNYQJERERENocJEBEREdkcJkBERERkc5gAERERkc1hAkREREQ2hwkQERER2Zz/B+6l0/Ywi5RMAAAAAElFTkSuQmCC","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["from scipy import stats\n","\n","snd = stats.norm(0, 1)\n","\n","#generates 100 values from -5 to 5, equally spaced\n","x = np.linspace(-5, 5, 100)\n","\n","plt.plot(x, snd.pdf(x))\n","plt.scatter(0, 0, color='red', s=60);\n","\n","plt.xlim(-5, 5)\n","plt.title('Normal Distribution')\n","plt.xlabel('Values of Random Variable X')\n","plt.ylabel('Probability')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"lMLzxQhPDN3x"},"source":["While there is not an easy formula to compute probabilities by hand, the normal curve itself can be written as a function $$f(x)=\\frac{1}{\\sigma \\sqrt{2\\pi}}e^{\\left(-\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^{2}\\right)},$$ where probabilites of interest are calculated by finding area under the curve.\n"]},{"cell_type":"markdown","metadata":{"id":"b_amsPoPFuY5"},"source":["## Standard Deviation and the Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"2Qd1emqtF1IZ"},"source":["Remember how we said standard deviation was a good measure of spread? One reason is because it can be used to bound the data. In particular, a majority of the data that is normally distributed falls within one standard deviation of the mean: about $68.27\\%$ of the data! About $95.45\\%$ of the data falls within two standard deviations, and roughly $99.73\\%$ falls within three standard deviations.\n","\n","![](normal_std_plot.png)"]},{"cell_type":"markdown","metadata":{"id":"OsTsmVkDYAdn"},"source":["The special case of the normal distribution is called the **standard normal** distribution and occurs when $\\mu = 0$ and $\\sigma = 1$.\n","Given a random variable and any values for $\\mu$ and $\\sigma$, that is $X ∼ N(\\mu, \\sigma)$, we can *transform* to a standard normal, by normalizing it! That is:\n","\n","$$\\frac{X-\\mu}{\\sigma}$$\n","\n","Note this may be useful if you are comparing values from multiple normal distributions."]},{"cell_type":"markdown","metadata":{"id":"aGmmlswknQdG"},"source":["## Central Limit Theorem"]},{"cell_type":"markdown","metadata":{"id":"EvrgC9pP1Rg4"},"source":["Recall the rolling of the die example from [the previous section](../../12/2/uniform.html). Now, suppose I am not interested in each roll but in the average value of all the dice rolls of students in my classroom. I have 50 students present and each student rolls 1 die. I then take the mean of all 50 dice rolls. What is the probability distribution for the average dice roll? This is another question can be easily answered through simulation!"]},{"cell_type":"markdown","metadata":{"id":"3-gnT0Dp0qqf"},"source":["Simulations use a computer to mimic real experiments. Returning to our dice-rolling example from the [the previous section](../../12/2/uniform.html), instead of asking all of my students to roll dice and take the mean 100s or 1000s of times to plot an empirical distribution (which would be both cumbersome and time consuming), I can have the computer do it for us. First, we can write code that does this experiment one time. We use `sample` to roll our die and `np.mean` to take the average."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"hKfpyHL90qqg","outputId":"dd3d4011-2fc9-4a26-dbef-80989804cd1b"},"outputs":[{"data":{"text/plain":["Face 3.6\n","dtype: float64"]},"execution_count":2,"metadata":{},"output_type":"execute_result"}],"source":["import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","%matplotlib inline\n","\n","die = pd.DataFrame(\n"," {\n"," 'Face': np.arange(1, 7),\n"," }\n",")\n","np.mean(die.sample(50, replace=True))"]},{"cell_type":"markdown","metadata":{"id":"jw3scddc0qqg"},"source":["The next step is to write a function that can repeat the experiment a certain number of times. We can do this using a `for loop` and saving the results of each experiment in a `numpy` array."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vWcmm54V0qqg"},"outputs":[],"source":["def face_mean_sim(nsim):\n"," \"\"\"Simulates nsim repetions of 50 dice rolls and returns their sample mean.\"\"\"\n"," np.random.seed(1234)\n"," means = np.array([])\n"," for i in np.arange(nsim):\n"," means = np.append(means, np.mean(die.sample(50, replace=True)))\n"," return means"]},{"cell_type":"markdown","metadata":{"id":"BLV1ElBdDYRC"},"source":["If we repeat the experiment 10 times we get an idea of what the means look like. Plotting a histogram we see the empirical distribution of these 10 experiments. In particular, we find that 3 of these 10 experiments have a mean of around 3.45, while all experiments have a mean in the range 3.22 to 3.76."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vdGI2hEGDTn-","outputId":"88008e86-b9bb-4869-c128-3242640e9180"},"outputs":[{"data":{"text/plain":["array([3.42, 3.5 , 3.24, 3.44, 3.22, 3.6 , 3.08, 3.76, 3.66, 3.46])"]},"execution_count":3,"metadata":{},"output_type":"execute_result"}],"source":["ten_runs = face_mean_sim(10)\n","ten_runs"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":295},"id":"hWV_0YWlD7C5","outputId":"ffff25a8-2fb5-48ff-d139-89c5f672febb"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["plt.hist(ten_runs);\n","plt.xlabel('Mean')\n","plt.ylabel('Frequency')\n","plt.title('Mean Dice Roll Simulation: Ten Runs')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"XFod8VdI0qqg"},"source":["It is difficult to determine what this distribution looks like with only 10 runs, so we experiment by ploting the empirical distributions of results from 100, 1000, and 10000 replications of the dice rolling experiment."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":585},"id":"2OAHXHU80qqg","outputId":"2121369d-e903-4d89-b726-5abf80360976"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["fig, axs = plt.subplots(3, figsize=(8, 8))\n","fig.suptitle('Mean Dice Roll Simulation: 100, 1000, and 10000', fontsize=16)\n","fig.tight_layout()\n","axs[0].hist(face_mean_sim(100), 30);\n","axs[1].hist(face_mean_sim(1_000), 30);\n","axs[2].hist(face_mean_sim(10_000),30);"]},{"cell_type":"markdown","metadata":{"id":"YXasPZ5g0qqg"},"source":["As we saw with our Uniform Distribution experiment, with larger numbers of experiments/samples our empirical distribution approaches the true probability distribution.\n","\n","Based on our empirical distribution with 10000 experiments, we can see that the average value of the dice rolls is symmetric and approximately bell-shaped with a mean of around 3.5. In fact, these properties of being approximately bell-shaped and symmetric are distinct to the empirical *normal distribution*.\n","\n","As we are plotting the distribution means of samples from a uniform distribution, the resulting probability distribution will always take on this shape, that is it will always be approximately normal, as long as the sample size is sufficiently large. This is due to an important mathematical theorem, the *Central Limit Theorem*[^***]. The Central Limit Theorem (CLT) states that if you take sufficiently large random samples from a population with replacement, the distribution of sample means will be approximately normally distributed. The CLT is a property of sample means and holds true for samples from *any* distribution, not just the uniform distribution of dice rolls. For example, the distribution of average heights, average weights, and average test scores of data science students would all be approximately normally distributed as long as we take large enough random samples from our population with replacement.\n","\n"]},{"cell_type":"markdown","metadata":{"id":"0VW8nyQG4Vot"},"source":["In the [the previous section](../../12/1/uniform.html) we calculated the mean and standard deviation of the uniform distribution of our dice rolls. The CLT allows us to use these to learn the mean (μ) and standard deviation (σ) of our distribution of sample means. According to the Central Limit Theorem, if the mean and standard deviation of the population you are sampling from are $\\mu$ and $\\sigma$ respectively, then the mean and standard deviation of the distribution of sample means are $\\mu$ and $\\frac{σ}{\\sqrt{n}}$ respectively where n is the sample size. Therefore, since we know from earlier that the mean of the uniform dice rolling distribution is 3.5 and the standard deviation is 1.71, the mean of the distribution of sample means is also 3.5 and the standard deviation is $\\frac{1.71}{\\sqrt{50}} = 0.24$. Let's investigate this further using our empirical distribution."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LhLQc4oD3zUB","outputId":"1c38e57a-04d1-4d1b-ddd3-9dace39f8bf0"},"outputs":[{"data":{"text/plain":["3.4967740000000007"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["np.mean(face_mean_sim(10_000))"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"05URqhM234nV","outputId":"8599cfc7-2f21-4e2c-93e5-a140323e1eba"},"outputs":[{"data":{"text/plain":["0.23814748707471173"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["np.std(face_mean_sim(10_000))"]},{"cell_type":"markdown","metadata":{"id":"cnPp3SB24KBQ"},"source":["Our empirical distribution matches what we expected to see mathematically according to the Central Limit Theorem!"]},{"cell_type":"markdown","metadata":{"id":"wrdpcFZg8BaL"},"source":["[^***]: For more information on the Central Limit Theorem, see the online Statistics Textbook at [OpenStax](https://cnx.org/contents/MBiUQmmY@25.39:MVbL0vFO@10/Introduction)"]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3.9.13 64-bit","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.9.13"},"vscode":{"interpreter":{"hash":"aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"}}},"nbformat":4,"nbformat_minor":0} +{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"tAzM3r78p08k","tags":["remove-cell"]},"outputs":[],"source":["import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","%matplotlib inline"]},{"cell_type":"markdown","metadata":{"id":"HtrRcRR0uFAM"},"source":["# Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"q0LoZTYHoCuw"},"source":["Let's consider another distribution by considering real data.\n","\n","Below we load in the Galton Height Data. This dataset was collected from families and contains heights of the father, mother, children. We focus on the father heights, and plot the distribution of heights in a histogram."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":235},"executionInfo":{"elapsed":188,"status":"ok","timestamp":1689610841357,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"UOdUEyhemMef","outputId":"79220073-def2-4067-bec0-293762a2f8a4"},"outputs":[{"data":{"text/html":["\n","\n","
\n","
\n","
\n","\n","\n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n"," \n","
familyfathermothermidparentHeightchildrenchildNumgenderchildHeight
0178.567.075.4341male73.2
1178.567.075.4342female69.2
2178.567.075.4343female69.0
3178.567.075.4344female69.0
4275.566.573.6641male73.5
5275.566.573.6642male72.5
\n","
\n"," \n","\n","\n","\n","
\n"," \n","
\n","\n","\n","\n"," \n","\n"," \n"," \n","\n"," \n","
\n","
\n"],"text/plain":[" family father mother midparentHeight children childNum gender \\\n","0 1 78.5 67.0 75.43 4 1 male \n","1 1 78.5 67.0 75.43 4 2 female \n","2 1 78.5 67.0 75.43 4 3 female \n","3 1 78.5 67.0 75.43 4 4 female \n","4 2 75.5 66.5 73.66 4 1 male \n","5 2 75.5 66.5 73.66 4 2 male \n","\n"," childHeight \n","0 73.2 \n","1 69.2 \n","2 69.0 \n","3 69.0 \n","4 73.5 \n","5 72.5 "]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["galton_df = pd.read_csv(\"../../data/galton.csv\")\n","galton_df.head(6)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":1567,"status":"ok","timestamp":1689610867384,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"6Mi-17cNm1oG","outputId":"93ce9d81-264e-49aa-c749-3c4867921b15"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["bin_size=np.arange(60, 80.5, 1)\n","plt.hist(galton_df[\"father\"], bins = bin_size, density = True)\n","plt.title('Father heights')\n","plt.xlabel('heights (in inches)')\n","plt.ylabel('Probabilities')\n","plt.scatter(galton_df['father'].mean(), 0, color='red', s=60);\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"MO3r-9W6moSJ"},"source":["This is another empirical distribution, but a special one!\n","An empirical *normal* distribution.\n","\n","The values for the normal distribution are continous variables - as heights can take on any real number in a given range."]},{"attachments":{},"cell_type":"markdown","metadata":{"id":"ja0QmiNunQY0"},"source":["## Normal Probability Distribution\n","\n","Arguably one of the most important continuous distributions, the normal distribution is a common distribution of heights, weights, and SAT scores, to name a few.\n","This distribution is symmetric and bell-shaped, giving it the nickname \"bell-curve\". The three measures of center: mode, median, and mean, are exactly the same for the normal distribution. Further, the distribution itself is defined entirely in terms of its mean and standard deviation. Notationally, given a random variable $X$ that is normally distributed, we can say $X \\sim N(\\mu,\\sigma)$, where $\\mu$ and $\\sigma$ are the mean and standard deviation of the distribution, respectively.\n","\n","\n","Below is a plot of a normal distribution, with the mean in red on the graph. We use the scipy library and the *normal* function by calling\n","\n","```python\n","stats.norm(µ, σ)\n","```\n","where the arguments correspond to the mean and standard deviation of the normal distribution. To get the corresponding $y$ values, we call the pdf method on a given array of x-values:\n","```python\n","stats.norm(µ, σ).pdf(x)\n","```"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"elapsed":480,"status":"ok","timestamp":1689622686716,"user":{"displayName":"Susanna Lange","userId":"00843628675540967552"},"user_tz":300},"id":"cFM9Aj9QAvxi","outputId":"3fe0093d-f87d-4ee2-a46a-bdd4555ffbff"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["from scipy import stats\n","\n","snd = stats.norm(0, 1)\n","\n","#generates 100 values from -5 to 5, equally spaced\n","x = np.linspace(-5, 5, 100)\n","\n","plt.plot(x, snd.pdf(x))\n","plt.scatter(0, 0, color='red', s=60);\n","\n","plt.xlim(-5, 5)\n","plt.title('Normal Distribution')\n","plt.xlabel('Values of Random Variable X')\n","plt.ylabel('Probability')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"lMLzxQhPDN3x"},"source":["While there is not an easy formula to compute probabilities by hand, the normal curve itself can be written as a function $$f(x)=\\frac{1}{\\sigma \\sqrt{2\\pi}}e^{\\left(-\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^{2}\\right)},$$ where probabilites of interest are calculated by finding area under the curve.\n"]},{"cell_type":"markdown","metadata":{"id":"b_amsPoPFuY5"},"source":["## Standard Deviation and the Normal Distribution"]},{"cell_type":"markdown","metadata":{"id":"2Qd1emqtF1IZ"},"source":["Remember how we said standard deviation was a good measure of spread? One reason is because it can be used to bound the data. In particular, a majority of the data that is normally distributed falls within one standard deviation of the mean: about $68.27\\%$ of the data! About $95.45\\%$ of the data falls within two standard deviations, and roughly $99.73\\%$ falls within three standard deviations.\n","\n","![](normal_std_plot.png)"]},{"cell_type":"markdown","metadata":{"id":"OsTsmVkDYAdn"},"source":["The special case of the normal distribution is called the **standard normal** distribution and occurs when $\\mu = 0$ and $\\sigma = 1$.\n","Given a random variable and any values for $\\mu$ and $\\sigma$, that is $X ∼ N(\\mu, \\sigma)$, we can *transform* to a standard normal, by normalizing it! That is:\n","\n","$$\\frac{X-\\mu}{\\sigma}$$\n","\n","Note this may be useful if you are comparing values from multiple normal distributions."]},{"cell_type":"markdown","metadata":{"id":"aGmmlswknQdG"},"source":["## Central Limit Theorem"]},{"cell_type":"markdown","metadata":{"id":"EvrgC9pP1Rg4"},"source":["Recall the rolling of the die example from [the previous section](../2/uniform.html). Now, suppose I am not interested in each roll but in the average value of all the dice rolls of students in my classroom. I have 50 students present and each student rolls 1 die. I then take the mean of all 50 dice rolls. What is the probability distribution for the average dice roll? This is another question can be easily answered through simulation!"]},{"cell_type":"markdown","metadata":{"id":"3-gnT0Dp0qqf"},"source":["Simulations use a computer to mimic real experiments. Returning to our dice-rolling example from the [the previous section](../2/uniform.html), instead of asking all of my students to roll dice and take the mean 100s or 1000s of times to plot an empirical distribution (which would be both cumbersome and time consuming), I can have the computer do it for us. First, we can write code that does this experiment one time. We use `sample` to roll our die and `np.mean` to take the average."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"hKfpyHL90qqg","outputId":"dd3d4011-2fc9-4a26-dbef-80989804cd1b"},"outputs":[{"data":{"text/plain":["Face 3.6\n","dtype: float64"]},"execution_count":2,"metadata":{},"output_type":"execute_result"}],"source":["import numpy as np\n","import pandas as pd\n","import matplotlib.pyplot as plt\n","%matplotlib inline\n","\n","die = pd.DataFrame(\n"," {\n"," 'Face': np.arange(1, 7),\n"," }\n",")\n","np.mean(die.sample(50, replace=True))"]},{"cell_type":"markdown","metadata":{"id":"jw3scddc0qqg"},"source":["The next step is to write a function that can repeat the experiment a certain number of times. We can do this using a `for loop` and saving the results of each experiment in a `numpy` array."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vWcmm54V0qqg"},"outputs":[],"source":["def face_mean_sim(nsim):\n"," \"\"\"Simulates nsim repetions of 50 dice rolls and returns their sample mean.\"\"\"\n"," np.random.seed(1234)\n"," means = np.array([])\n"," for i in np.arange(nsim):\n"," means = np.append(means, np.mean(die.sample(50, replace=True)))\n"," return means"]},{"cell_type":"markdown","metadata":{"id":"BLV1ElBdDYRC"},"source":["If we repeat the experiment 10 times we get an idea of what the means look like. Plotting a histogram we see the empirical distribution of these 10 experiments. In particular, we find that 3 of these 10 experiments have a mean of around 3.45, while all experiments have a mean in the range 3.22 to 3.76."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vdGI2hEGDTn-","outputId":"88008e86-b9bb-4869-c128-3242640e9180"},"outputs":[{"data":{"text/plain":["array([3.42, 3.5 , 3.24, 3.44, 3.22, 3.6 , 3.08, 3.76, 3.66, 3.46])"]},"execution_count":3,"metadata":{},"output_type":"execute_result"}],"source":["ten_runs = face_mean_sim(10)\n","ten_runs"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":295},"id":"hWV_0YWlD7C5","outputId":"ffff25a8-2fb5-48ff-d139-89c5f672febb"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["plt.hist(ten_runs);\n","plt.xlabel('Mean')\n","plt.ylabel('Frequency')\n","plt.title('Mean Dice Roll Simulation: Ten Runs')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"XFod8VdI0qqg"},"source":["It is difficult to determine what this distribution looks like with only 10 runs, so we experiment by ploting the empirical distributions of results from 100, 1000, and 10000 replications of the dice rolling experiment."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":585},"id":"2OAHXHU80qqg","outputId":"2121369d-e903-4d89-b726-5abf80360976"},"outputs":[{"data":{"image/png":"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","text/plain":["
"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["fig, axs = plt.subplots(3, figsize=(8, 8))\n","fig.suptitle('Mean Dice Roll Simulation: 100, 1000, and 10000', fontsize=16)\n","fig.tight_layout()\n","axs[0].hist(face_mean_sim(100), 30);\n","axs[1].hist(face_mean_sim(1_000), 30);\n","axs[2].hist(face_mean_sim(10_000),30);"]},{"cell_type":"markdown","metadata":{"id":"YXasPZ5g0qqg"},"source":["As we saw with our Uniform Distribution experiment, with larger numbers of experiments/samples our empirical distribution approaches the true probability distribution.\n","\n","Based on our empirical distribution with 10000 experiments, we can see that the average value of the dice rolls is symmetric and approximately bell-shaped with a mean of around 3.5. In fact, these properties of being approximately bell-shaped and symmetric are distinct to the empirical *normal distribution*.\n","\n","As we are plotting the distribution means of samples from a uniform distribution, the resulting probability distribution will always take on this shape, that is it will always be approximately normal, as long as the sample size is sufficiently large. This is due to an important mathematical theorem, the *Central Limit Theorem*[^***]. The Central Limit Theorem (CLT) states that if you take sufficiently large random samples from a population with replacement, the distribution of sample means will be approximately normally distributed. The CLT is a property of sample means and holds true for samples from *any* distribution, not just the uniform distribution of dice rolls. For example, the distribution of average heights, average weights, and average test scores of data science students would all be approximately normally distributed as long as we take large enough random samples from our population with replacement.\n","\n"]},{"cell_type":"markdown","metadata":{"id":"0VW8nyQG4Vot"},"source":["In the [the previous section](../2/uniform.html) we calculated the mean and standard deviation of the uniform distribution of our dice rolls. The CLT allows us to use these to learn the mean (μ) and standard deviation (σ) of our distribution of sample means. According to the Central Limit Theorem, if the mean and standard deviation of the population you are sampling from are $\\mu$ and $\\sigma$ respectively, then the mean and standard deviation of the distribution of sample means are $\\mu$ and $\\frac{σ}{\\sqrt{n}}$ respectively where n is the sample size. Therefore, since we know from earlier that the mean of the uniform dice rolling distribution is 3.5 and the standard deviation is 1.71, the mean of the distribution of sample means is also 3.5 and the standard deviation is $\\frac{1.71}{\\sqrt{50}} = 0.24$. Let's investigate this further using our empirical distribution."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"LhLQc4oD3zUB","outputId":"1c38e57a-04d1-4d1b-ddd3-9dace39f8bf0"},"outputs":[{"data":{"text/plain":["3.4967740000000007"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["np.mean(face_mean_sim(10_000))"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"05URqhM234nV","outputId":"8599cfc7-2f21-4e2c-93e5-a140323e1eba"},"outputs":[{"data":{"text/plain":["0.23814748707471173"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["np.std(face_mean_sim(10_000))"]},{"cell_type":"markdown","metadata":{"id":"cnPp3SB24KBQ"},"source":["Our empirical distribution matches what we expected to see mathematically according to the Central Limit Theorem!"]},{"cell_type":"markdown","metadata":{"id":"wrdpcFZg8BaL"},"source":["[^***]: For more information on the Central Limit Theorem, see the online Statistics Textbook at [OpenStax](https://cnx.org/contents/MBiUQmmY@25.39:MVbL0vFO@10/Introduction)"]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3.9.13 64-bit","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.9.13"},"vscode":{"interpreter":{"hash":"aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"}}},"nbformat":4,"nbformat_minor":0} diff --git a/textbook/data/galton.csv b/textbook/data/galton.csv new file mode 100644 index 00000000..8b348125 --- /dev/null +++ b/textbook/data/galton.csv @@ -0,0 +1 @@ +family,father,mother,midparentHeight,children,childNum,gender,childHeight 1,78.5,67,75.43,4,1,male,73.2 1,78.5,67,75.43,4,2,female,69.2 1,78.5,67,75.43,4,3,female,69 1,78.5,67,75.43,4,4,female,69 2,75.5,66.5,73.66,4,1,male,73.5 2,75.5,66.5,73.66,4,2,male,72.5 2,75.5,66.5,73.66,4,3,female,65.5 2,75.5,66.5,73.66,4,4,female,65.5 3,75,64,72.06,2,1,male,71 3,75,64,72.06,2,2,female,68 4,75,64,72.06,5,1,male,70.5 4,75,64,72.06,5,2,male,68.5 4,75,64,72.06,5,3,female,67 4,75,64,72.06,5,4,female,64.5 4,75,64,72.06,5,5,female,63 5,75,58.5,69.09,6,1,male,72 5,75,58.5,69.09,6,2,male,69 5,75,58.5,69.09,6,3,male,68 5,75,58.5,69.09,6,4,female,66.5 5,75,58.5,69.09,6,5,female,62.5 5,75,58.5,69.09,6,6,female,62.5 6,74,68,73.72,1,1,female,69.5 7,74,68,73.72,6,1,male,76.5 7,74,68,73.72,6,2,male,74 7,74,68,73.72,6,3,male,73 7,74,68,73.72,6,4,male,73 7,74,68,73.72,6,5,female,70.5 7,74,68,73.72,6,6,female,64 8,74,66.5,72.91,3,1,female,70.5 8,74,66.5,72.91,3,2,female,68 8,74,66.5,72.91,3,3,female,66 9,74.5,66,72.89,1,1,female,66 10,74,65.5,72.37,1,1,female,65.5 11,74,62,70.48,8,1,male,74 11,74,62,70.48,8,2,male,70 11,74,62,70.48,8,3,female,68 11,74,62,70.48,8,4,female,67 11,74,62,70.48,8,5,female,67 11,74,62,70.48,8,6,female,66 11,74,62,70.48,8,7,female,63.5 11,74,62,70.48,8,8,female,63 12,74,61,69.94,1,1,female,65 13,73,67,72.68,2,1,male,71 13,73,67,72.68,2,2,female,62 14,73,67,72.68,2,1,male,68 14,73,67,72.68,2,2,male,67 15,73,66.5,72.41,3,1,male,71 15,73,66.5,72.41,3,2,male,70.5 15,73,66.5,72.41,3,3,female,66.7 16,73,65,71.6,9,1,male,72 16,73,65,71.6,9,2,male,70.5 16,73,65,71.6,9,3,male,70.2 16,73,65,71.6,9,4,male,70.2 16,73,65,71.6,9,5,male,69.2 16,73,65,71.6,9,6,female,68.7 16,73,65,71.6,9,7,female,66.5 16,73,65,71.6,9,8,female,64.5 16,73,65,71.6,9,9,female,63.5 17,73,64.5,71.33,6,1,male,74 17,73,64.5,71.33,6,2,male,73 17,73,64.5,71.33,6,3,male,71.5 17,73,64.5,71.33,6,4,male,62.5 17,73,64.5,71.33,6,5,female,66.5 17,73,64.5,71.33,6,6,female,62.3 18,73,64,71.06,3,1,female,66 18,73,64,71.06,3,2,female,64.5 18,73,64,71.06,3,3,female,64 19,73.2,63,70.62,1,1,female,62.7 20,72.7,69,73.61,8,1,male,73.2 20,72.7,69,73.61,8,2,male,73 20,72.7,69,73.61,8,3,male,72.7 20,72.7,69,73.61,8,4,female,70 20,72.7,69,73.61,8,5,female,69 20,72.7,69,73.61,8,6,female,68.5 20,72.7,69,73.61,8,7,female,68 20,72.7,69,73.61,8,8,female,66 21,72,68,72.72,3,1,male,73 21,72,68,72.72,3,2,female,68.5 21,72,68,72.72,3,3,female,68 22,72,67,72.18,3,1,male,73 22,72,67,72.18,3,2,male,71 22,72,67,72.18,3,3,female,67 23,72,65,71.1,7,1,male,74.2 23,72,65,71.1,7,2,male,70.5 23,72,65,71.1,7,3,male,69.5 23,72,65,71.1,7,4,female,66 23,72,65,71.1,7,5,female,65.5 23,72,65,71.1,7,6,female,65 23,72,65,71.1,7,7,female,65 24,72,65.5,71.37,1,1,female,65.5 25,72,64,70.56,2,1,female,66 25,72,64,70.56,2,2,female,63 26,72,63,70.02,5,1,male,70.5 26,72,63,70.02,5,2,male,70.5 26,72,63,70.02,5,3,male,69 26,72,63,70.02,5,4,female,65 26,72,63,70.02,5,5,female,63 27,72,63,70.02,3,1,male,69 27,72,63,70.02,3,2,male,67 27,72,63,70.02,3,3,female,63 28,72,63,70.02,6,1,male,73 28,72,63,70.02,6,2,male,67 28,72,63,70.02,6,3,female,70.5 28,72,63,70.02,6,4,female,70 28,72,63,70.02,6,5,female,66.5 28,72,63,70.02,6,6,female,63 29,72.5,63.5,70.54,3,1,female,67.5 29,72.5,63.5,70.54,3,2,female,67.2 29,72.5,63.5,70.54,3,3,female,66.7 30,72,62,69.48,1,1,female,64 31,72.5,62,69.73,6,1,male,71 31,72.5,62,69.73,6,2,male,70 31,72.5,62,69.73,6,3,male,70 31,72.5,62,69.73,6,4,female,66 31,72.5,62,69.73,6,5,female,65 31,72.5,62,69.73,6,6,female,65 32,72,62,69.48,5,1,male,74 32,72,62,69.48,5,2,male,72 32,72,62,69.48,5,3,male,69 32,72,62,69.48,5,4,female,67.5 32,72,62,69.48,5,5,female,63.5 33,72,62,69.48,5,1,male,72 33,72,62,69.48,5,2,male,71.5 33,72,62,69.48,5,3,male,71.5 33,72,62,69.48,5,4,male,70 33,72,62,69.48,5,5,female,68 34,72,61,68.94,1,1,female,65.7 35,71,69,72.76,5,1,male,78 35,71,69,72.76,5,2,male,74 35,71,69,72.76,5,3,male,73 35,71,69,72.76,5,4,male,72 35,71,69,72.76,5,5,female,67 36,71,67,71.68,4,1,male,73.2 36,71,67,71.68,4,2,male,73 36,71,67,71.68,4,3,male,69 36,71,67,71.68,4,4,female,67 37,71,66,71.14,4,1,male,70 37,71,66,71.14,4,2,female,67 37,71,66,71.14,4,3,female,67 37,71,66,71.14,4,4,female,66.5 38,71,66,71.14,6,1,male,70 38,71,66,71.14,6,2,male,69 38,71,66,71.14,6,3,male,68.5 38,71,66,71.14,6,4,female,66 38,71,66,71.14,6,5,female,64.5 38,71,66,71.14,6,6,female,63 39,71,66,71.14,2,1,male,71 39,71,66,71.14,2,2,female,67 40,71,66,71.14,5,1,male,76 40,71,66,71.14,5,2,male,72 40,71,66,71.14,5,3,male,71 40,71,66,71.14,5,4,male,66 40,71,66,71.14,5,5,female,66 41,71.7,65.5,71.22,1,1,male,70.5 42,71,65.5,70.87,6,1,male,72 42,71,65.5,70.87,6,2,male,72 42,71,65.5,70.87,6,3,male,71 42,71,65.5,70.87,6,4,male,69 42,71,65.5,70.87,6,5,female,66 42,71,65.5,70.87,6,6,female,65 43,71.5,65.5,71.12,2,1,male,73 43,71.5,65.5,71.12,2,2,female,65.2 44,71.5,65,70.85,2,1,male,68.5 44,71.5,65,70.85,2,2,male,67.7 45,71,65,70.6,3,1,male,68 45,71,65,70.6,3,2,male,68 45,71,65,70.6,3,3,female,62 46,71,64,70.06,8,1,female,68 46,71,64,70.06,8,2,female,68 46,71,64,70.06,8,3,female,67.5 46,71,64,70.06,8,4,female,66.5 46,71,64,70.06,8,5,female,66.5 46,71,64,70.06,8,6,female,66 46,71,64,70.06,8,7,female,65.5 46,71,64,70.06,8,8,female,65 47,71.7,64.5,70.68,4,1,male,72 47,71.7,64.5,70.68,4,2,male,71 47,71.7,64.5,70.68,4,3,male,70.5 47,71.7,64.5,70.68,4,4,female,67 48,71,64,70.06,3,1,male,68 48,71,64,70.06,3,2,male,68 48,71,64,70.06,3,3,male,68 49,71.5,64.5,70.58,7,1,male,72 49,71.5,64.5,70.58,7,2,male,71 49,71.5,64.5,70.58,7,3,male,70 49,71.5,64.5,70.58,7,4,female,66 49,71.5,64.5,70.58,7,5,female,64.5 49,71.5,64.5,70.58,7,6,female,64.5 49,71.5,64.5,70.58,7,7,female,62 50,71,64.5,70.33,2,1,male,73 50,71,64.5,70.33,2,2,female,62 51,71.2,63,69.62,2,1,female,67.5 51,71.2,63,69.62,2,2,female,64.5 52,71,63.5,69.79,5,1,male,71 52,71,63.5,69.79,5,2,male,67 52,71,63.5,69.79,5,3,female,66 52,71,63.5,69.79,5,4,female,65 52,71,63.5,69.79,5,5,female,63.5 53,71,63,69.52,9,1,male,71 53,71,63,69.52,9,2,male,70 53,71,63,69.52,9,3,male,70 53,71,63,69.52,9,4,male,64 53,71,63,69.52,9,5,female,65 53,71,63,69.52,9,6,female,65 53,71,63,69.52,9,7,female,64 53,71,63,69.52,9,8,female,63 53,71,63,69.52,9,9,female,63 54,71,63,69.52,4,1,male,71 54,71,63,69.52,4,2,male,71 54,71,63,69.52,4,3,male,70 54,71,63,69.52,4,4,female,63.5 55,71,62,68.98,5,1,male,71 55,71,62,68.98,5,2,male,70 55,71,62,68.98,5,3,female,64.5 55,71,62,68.98,5,4,female,62.5 55,71,62,68.98,5,5,female,61.5 56,71,62,68.98,5,1,male,72 56,71,62,68.98,5,2,male,70.5 56,71,62,68.98,5,3,male,70.5 56,71,62,68.98,5,4,female,64.5 56,71,62,68.98,5,5,female,60 57,71,62.5,69.25,5,1,male,70 57,71,62.5,69.25,5,2,female,64 57,71,62.5,69.25,5,3,female,64 57,71,62.5,69.25,5,4,female,64 57,71,62.5,69.25,5,5,female,62.5 58,71,62,68.98,7,1,male,70.5 58,71,62,68.98,7,2,male,70 58,71,62,68.98,7,3,male,69 58,71,62,68.98,7,4,male,69 58,71,62,68.98,7,5,male,66 58,71,62,68.98,7,6,female,64.5 58,71,62,68.98,7,7,female,64 59,71,61,68.44,1,1,female,62 60,71,58,66.82,2,1,male,71.5 60,71,58,66.82,2,2,male,69 61,70,69,72.26,4,1,male,71 61,70,69,72.26,4,2,male,70 61,70,69,72.26,4,3,male,69 61,70,69,72.26,4,4,female,69 62,70,69,72.26,6,1,male,70 62,70,69,72.26,6,2,male,68.7 62,70,69,72.26,6,3,female,68 62,70,69,72.26,6,4,female,66 62,70,69,72.26,6,5,female,64 62,70,69,72.26,6,6,female,62 63,70,68,71.72,1,1,male,75 64,70,67,71.18,5,1,male,70 64,70,67,71.18,5,2,male,69 64,70,67,71.18,5,3,female,66 64,70,67,71.18,5,4,female,64 64,70,67,71.18,5,5,female,60 65,70,67,71.18,1,1,female,67.5 66,70,66.5,70.91,11,1,male,73 66,70,66.5,70.91,11,2,male,72 66,70,66.5,70.91,11,3,male,72 66,70,66.5,70.91,11,4,male,66.5 66,70,66.5,70.91,11,5,female,69.2 66,70,66.5,70.91,11,6,female,67.2 66,70,66.5,70.91,11,7,female,66.5 66,70,66.5,70.91,11,8,female,66 66,70,66.5,70.91,11,9,female,66 66,70,66.5,70.91,11,10,female,64.2 66,70,66.5,70.91,11,11,female,63.7 67,70.5,65,70.35,4,1,male,72 67,70.5,65,70.35,4,2,male,70.2 67,70.5,65,70.35,4,3,male,69 67,70.5,65,70.35,4,4,male,68.5 68,70.5,65,70.35,5,1,female,68 68,70.5,65,70.35,5,2,female,65 68,70.5,65,70.35,5,3,female,61.5 68,70.5,65,70.35,5,4,female,61 68,70.5,65,70.35,5,5,female,61 69,70,65,70.1,8,1,male,73 69,70,65,70.1,8,2,male,72 69,70,65,70.1,8,3,male,70.5 69,70,65,70.1,8,4,male,65 69,70,65,70.1,8,5,male,65 69,70,65,70.1,8,6,female,64.5 69,70,65,70.1,8,7,female,63 69,70,65,70.1,8,8,female,62 70,70,65,70.1,5,1,male,67 70,70,65,70.1,5,2,male,65 70,70,65,70.1,5,3,female,64.5 70,70,65,70.1,5,4,female,62.5 70,70,65,70.1,5,5,female,62.5 71,70,65,70.1,6,1,male,70 71,70,65,70.1,6,2,male,70 71,70,65,70.1,6,3,female,67 71,70,65,70.1,6,4,female,65 71,70,65,70.1,6,5,female,65 71,70,65,70.1,6,6,female,63 72,70,65,70.1,7,1,male,79 72,70,65,70.1,7,2,male,75 72,70,65,70.1,7,3,male,71 72,70,65,70.1,7,4,female,69 72,70,65,70.1,7,5,female,67 72,70,65,70.1,7,6,female,65.7 72,70,65,70.1,7,7,female,62 73,70,65,70.1,3,1,male,73 73,70,65,70.1,3,2,male,72.5 73,70,65,70.1,3,3,female,65 74,70,65,70.1,2,1,male,69 74,70,65,70.1,2,2,male,69 75,70,64.7,69.938,7,1,male,72 75,70,64.7,69.938,7,2,male,70 75,70,64.7,69.938,7,3,male,68.7 75,70,64.7,69.938,7,4,female,66.5 75,70,64.7,69.938,7,5,female,65.5 75,70,64.7,69.938,7,6,female,64.7 75,70,64.7,69.938,7,7,female,64.5 76,70,64,69.56,7,1,male,70.7 76,70,64,69.56,7,2,male,70 76,70,64,69.56,7,3,male,68 76,70,64,69.56,7,4,male,67 76,70,64,69.56,7,5,male,66 76,70,64,69.56,7,6,male,65 76,70,64,69.56,7,7,female,67 77,70,64,69.56,4,1,male,70 77,70,64,69.56,4,2,male,68 77,70,64,69.56,4,3,male,66.7 77,70,64,69.56,4,4,female,65.5 78,70,64.2,69.668,5,1,male,72 78,70,64.2,69.668,5,2,male,70 78,70,64.2,69.668,5,3,female,62.5 78,70,64.2,69.668,5,4,female,61.2 78,70,64.2,69.668,5,5,female,60.1 79,70.5,64,69.81,8,1,male,74 79,70.5,64,69.81,8,2,male,69.5 79,70.5,64,69.81,8,3,male,69 79,70.5,64,69.81,8,4,male,68 79,70.5,64,69.81,8,5,male,68 79,70.5,64,69.81,8,6,male,68 79,70.5,64,69.81,8,7,female,65.5 79,70.5,64,69.81,8,8,female,65 80,70.5,64.5,70.08,1,1,female,60 81,70,64,69.56,4,1,male,68 81,70,64,69.56,4,2,female,65 81,70,64,69.56,4,3,female,64 81,70,64,69.56,4,4,female,62 82,70,64,69.56,9,1,male,71 82,70,64,69.56,9,2,male,70 82,70,64,69.56,9,3,male,70 82,70,64,69.56,9,4,male,70 82,70,64,69.56,9,5,male,69.5 82,70,64,69.56,9,6,male,68.5 82,70,64,69.56,9,7,female,69 82,70,64,69.56,9,8,female,65 82,70,64,69.56,9,9,female,64 83,70,63.7,69.398,8,1,male,70 83,70,63.7,69.398,8,2,male,67 83,70,63.7,69.398,8,3,male,65.5 83,70,63.7,69.398,8,4,female,63.7 83,70,63.7,69.398,8,5,female,63.2 83,70,63.7,69.398,8,6,female,62.5 83,70,63.7,69.398,8,7,female,62.2 83,70,63.7,69.398,8,8,female,61 84,70.5,63,69.27,4,1,male,70 84,70.5,63,69.27,4,2,male,68.5 84,70.5,63,69.27,4,3,female,65.5 84,70.5,63,69.27,4,4,female,63.5 85,70.5,63,69.27,5,1,male,72.5 85,70.5,63,69.27,5,2,male,69 85,70.5,63,69.27,5,3,male,67 85,70.5,63,69.27,5,4,female,64.5 85,70.5,63,69.27,5,5,female,64 86,70,63.5,69.29,4,1,male,71 86,70,63.5,69.29,4,2,male,67.5 86,70,63.5,69.29,4,3,female,67.5 86,70,63.5,69.29,4,4,female,63.5 87,70,63,69.02,4,1,male,68 87,70,63,69.02,4,2,male,67 87,70,63,69.02,4,3,female,63.7 87,70,63,69.02,4,4,female,62 88,70,63,69.02,4,1,male,70 88,70,63,69.02,4,2,male,66.5 88,70,63,69.02,4,3,female,62 88,70,63,69.02,4,4,female,61 89,70.5,62,68.73,8,1,male,72 89,70.5,62,68.73,8,2,male,70 89,70.5,62,68.73,8,3,male,69.5 89,70.5,62,68.73,8,4,male,69.5 89,70.5,62,68.73,8,5,male,68 89,70.5,62,68.73,8,6,female,65 89,70.5,62,68.73,8,7,female,64 89,70.5,62,68.73,8,8,female,63 90,70.3,62.7,69.008,7,1,male,70.7 90,70.3,62.7,69.008,7,2,male,69.7 90,70.3,62.7,69.008,7,3,male,69.2 90,70.3,62.7,69.008,7,4,male,65.2 90,70.3,62.7,69.008,7,5,female,64 90,70.3,62.7,69.008,7,6,female,63.5 90,70.3,62.7,69.008,7,7,female,63.2 91,70.5,62,68.73,3,1,male,72 91,70.5,62,68.73,3,2,male,72 91,70.5,62,68.73,3,3,female,60 92,70,61,67.94,2,1,male,71.2 92,70,61,67.94,2,2,male,67 93,70,60,67.4,4,1,male,67 93,70,60,67.4,4,2,male,64.5 93,70,60,67.4,4,3,female,65 93,70,60,67.4,4,4,female,63 94,70,60,67.4,2,1,female,65 94,70,60,67.4,2,2,female,65 95,70,58.5,66.59,3,1,male,71.5 95,70,58.5,66.59,3,2,male,64.5 95,70,58.5,66.59,3,3,female,63 96,70,58,66.32,5,1,male,72 96,70,58,66.32,5,2,male,66 96,70,58,66.32,5,3,female,66 96,70,58,66.32,5,4,female,65 96,70,58,66.32,5,5,female,63 97,69,68.5,71.49,10,1,male,75 97,69,68.5,71.49,10,2,male,71 97,69,68.5,71.49,10,3,male,70 97,69,68.5,71.49,10,4,female,66 97,69,68.5,71.49,10,5,female,66 97,69,68.5,71.49,10,6,female,65.5 97,69,68.5,71.49,10,7,female,65 97,69,68.5,71.49,10,8,female,65 97,69,68.5,71.49,10,9,female,64 97,69,68.5,71.49,10,10,female,64 98,69,67,70.68,1,1,female,64 99,69,66,70.14,8,1,male,73 99,69,66,70.14,8,2,male,72 99,69,66,70.14,8,3,male,71.7 99,69,66,70.14,8,4,male,71.5 99,69,66,70.14,8,5,female,65.5 99,69,66,70.14,8,6,female,65 99,69,66,70.14,8,7,female,62.7 99,69,66,70.14,8,8,female,62.5 100,69,66,70.14,3,1,male,71.2 100,69,66,70.14,3,2,male,71 100,69,66,70.14,3,3,male,70 101,69,66.7,70.518,4,1,male,75 101,69,66.7,70.518,4,2,male,74 101,69,66.7,70.518,4,3,male,72 101,69,66.7,70.518,4,4,male,68.5 102,69,66,70.14,6,1,male,70 102,69,66,70.14,6,2,male,68.5 102,69,66,70.14,6,3,male,68 102,69,66,70.14,6,4,female,65 102,69,66,70.14,6,5,female,63 102,69,66,70.14,6,6,female,62.5 103,69,66.5,70.41,7,1,male,73 103,69,66.5,70.41,7,2,male,71 103,69,66.5,70.41,7,3,male,70.5 103,69,66.5,70.41,7,4,male,70.5 103,69,66.5,70.41,7,5,male,67 103,69,66.5,70.41,7,6,male,66 103,69,66.5,70.41,7,7,female,61 104,69.5,66.5,70.66,4,1,male,70.5 104,69.5,66.5,70.66,4,2,male,67.5 104,69.5,66.5,70.66,4,3,female,64.5 104,69.5,66.5,70.66,4,4,female,64 105,69,66.5,70.41,6,1,male,71 105,69,66.5,70.41,6,2,female,68.5 105,69,66.5,70.41,6,3,female,67.5 105,69,66.5,70.41,6,4,female,66 105,69,66.5,70.41,6,5,female,63 105,69,66.5,70.41,6,6,female,63 106,69.5,66,70.39,7,1,male,71 106,69.5,66,70.39,7,2,male,71 106,69.5,66,70.39,7,3,male,70.5 106,69.5,66,70.39,7,4,male,70.5 106,69.5,66,70.39,7,5,female,66.5 106,69.5,66,70.39,7,6,female,65.5 106,69.5,66,70.39,7,7,female,64.5 107,69,66,70.14,9,1,male,73 107,69,66,70.14,9,2,male,72 107,69,66,70.14,9,3,male,69 107,69,66,70.14,9,4,male,69 107,69,66,70.14,9,5,female,66.5 107,69,66,70.14,9,6,female,65.5 107,69,66,70.14,9,7,female,65.5 107,69,66,70.14,9,8,female,65 107,69,66,70.14,9,9,female,64 108,69,65,69.6,7,1,male,70 108,69,65,69.6,7,2,male,68.5 108,69,65,69.6,7,3,male,67 108,69,65,69.6,7,4,female,65 108,69,65,69.6,7,5,female,64 108,69,65,69.6,7,6,female,63.5 108,69,65,69.6,7,7,female,61 109,69.5,64.5,69.58,7,1,male,69.7 109,69.5,64.5,69.58,7,2,male,68 109,69.5,64.5,69.58,7,3,male,60 109,69.5,64.5,69.58,7,4,female,65.2 109,69.5,64.5,69.58,7,5,female,64.5 109,69.5,64.5,69.58,7,6,female,63.7 109,69.5,64.5,69.58,7,7,female,60 110,69.2,64,69.16,4,1,male,71.7 110,69.2,64,69.16,4,2,male,66.5 110,69.2,64,69.16,4,3,female,65 110,69.2,64,69.16,4,4,female,63.5 111,69,63.5,68.79,1,1,female,65.5 112,69,63,68.52,3,1,male,69 112,69,63,68.52,3,2,female,67.5 112,69,63,68.52,3,3,female,63.5 113,69,63,68.52,1,1,male,72 114,69,63,68.52,6,1,male,73 114,69,63,68.52,6,2,male,70 114,69,63,68.52,6,3,male,70 114,69,63,68.52,6,4,male,64 114,69,63,68.52,6,5,female,66 114,69,63,68.52,6,6,female,62 115,69,63.5,68.79,7,1,male,70.5 115,69,63.5,68.79,7,2,male,67 115,69,63.5,68.79,7,3,male,66 115,69,63.5,68.79,7,4,female,65 115,69,63.5,68.79,7,5,female,63 115,69,63.5,68.79,7,6,female,62 115,69,63.5,68.79,7,7,female,61 116,69,63.5,68.79,3,1,male,70.5 116,69,63.5,68.79,3,2,female,63.7 116,69,63.5,68.79,3,3,female,63 117,69.7,62,68.33,1,1,female,62.5 118,69.5,62,68.23,3,1,male,73 118,69.5,62,68.23,3,2,male,72 118,69.5,62,68.23,3,3,male,69 119,69,62,67.98,5,1,male,73 119,69,62,67.98,5,2,male,71 119,69,62,67.98,5,3,male,71 119,69,62,67.98,5,4,male,69 119,69,62,67.98,5,5,female,63 120,69.5,62,68.23,11,1,male,72 120,69.5,62,68.23,11,2,male,70 120,69.5,62,68.23,11,3,male,67.8 120,69.5,62,68.23,11,4,female,65.2 120,69.5,62,68.23,11,5,female,64.7 120,69.5,62,68.23,11,6,female,64.5 120,69.5,62,68.23,11,7,female,63.5 120,69.5,62,68.23,11,8,female,63.5 120,69.5,62,68.23,11,9,female,62.5 120,69.5,62,68.23,11,10,female,62 120,69.5,62,68.23,11,11,female,61.5 121,69,62.5,68.25,8,1,male,71 121,69,62.5,68.25,8,2,male,70 121,69,62.5,68.25,8,3,male,70 121,69,62.5,68.25,8,4,male,69 121,69,62.5,68.25,8,5,female,63.5 121,69,62.5,68.25,8,6,female,62.5 121,69,62.5,68.25,8,7,female,62.5 121,69,62.5,68.25,8,8,female,62 122,69,62,67.98,4,1,male,72 122,69,62,67.98,4,2,male,68 122,69,62,67.98,4,3,female,66 122,69,62,67.98,4,4,female,66 123,69.5,61,67.69,5,1,male,70 123,69.5,61,67.69,5,2,male,69.5 123,69.5,61,67.69,5,3,male,69 123,69.5,61,67.69,5,4,female,63 123,69.5,61,67.69,5,5,female,62 124,69,61,67.44,9,1,male,68 124,69,61,67.44,9,2,male,68 124,69,61,67.44,9,3,male,67.5 124,69,61,67.44,9,4,male,64 124,69,61,67.44,9,5,male,63 124,69,61,67.44,9,6,male,63 124,69,61,67.44,9,7,female,63.5 124,69,61,67.44,9,8,female,62 124,69,61,67.44,9,9,female,62 125,69,60,66.9,3,1,male,70.5 125,69,60,66.9,3,2,female,68 125,69,60,66.9,3,3,female,62.5 126,69,60,66.9,4,1,male,69 126,69,60,66.9,4,2,male,66 126,69,60,66.9,4,3,female,61.7 126,69,60,66.9,4,4,female,60.5 127,69,60.5,67.17,1,1,male,69.5 128,68.7,70.5,72.42,2,1,male,71 128,68.7,70.5,72.42,2,2,female,61.7 129,68.5,67,70.43,3,1,male,73 129,68.5,67,70.43,3,2,male,71 129,68.5,67,70.43,3,3,female,67 130,68.5,66.5,70.16,11,1,male,70 130,68.5,66.5,70.16,11,2,male,69 130,68.5,66.5,70.16,11,3,male,69 130,68.5,66.5,70.16,11,4,male,68.7 130,68.5,66.5,70.16,11,5,male,68.5 130,68.5,66.5,70.16,11,6,male,68.5 130,68.5,66.5,70.16,11,7,male,68 130,68.5,66.5,70.16,11,8,male,68 130,68.5,66.5,70.16,11,9,male,68 130,68.5,66.5,70.16,11,10,male,66.2 130,68.5,66.5,70.16,11,11,female,63.2 131,68,65,69.1,2,1,male,67.5 131,68,65,69.1,2,2,male,66 132,68,65.5,69.37,2,1,male,66 132,68,65.5,69.37,2,2,female,64 133,68,65.5,69.37,7,1,male,71.7 133,68,65.5,69.37,7,2,male,71.5 133,68,65.5,69.37,7,3,male,70.7 133,68,65.5,69.37,7,4,male,65.5 133,68,65.5,69.37,7,5,female,66.5 133,68,65.5,69.37,7,6,female,65.2 133,68,65.5,69.37,7,7,female,61.5 134,68,65,69.1,4,1,male,72 134,68,65,69.1,4,2,male,72 134,68,65,69.1,4,3,female,68 134,68,65,69.1,4,4,female,66 135,68.5,65,69.35,8,1,male,69.2 135,68.5,65,69.35,8,2,male,68 135,68.5,65,69.35,8,3,male,66 135,68.5,65,69.35,8,4,male,66 135,68.5,65,69.35,8,5,female,62 135,68.5,65,69.35,8,6,female,61.5 135,68.5,65,69.35,8,7,female,61 135,68.5,65,69.35,8,8,female,60 136A,68.5,65,69.35,8,1,male,72 136A,68.5,65,69.35,8,2,male,70.5 136A,68.5,65,69.35,8,3,male,68.7 136A,68.5,65,69.35,8,4,male,68.5 136A,68.5,65,69.35,8,5,male,67.7 136A,68.5,65,69.35,8,6,female,64 136A,68.5,65,69.35,8,7,female,63.5 136A,68.5,65,69.35,8,8,female,63 136,68,64,68.56,10,1,male,71 136,68,64,68.56,10,2,male,68 136,68,64,68.56,10,3,male,68 136,68,64,68.56,10,4,male,67 136,68,64,68.56,10,5,female,65 136,68,64,68.56,10,6,female,64 136,68,64,68.56,10,7,female,63 136,68,64,68.56,10,8,female,63 136,68,64,68.56,10,9,female,62 136,68,64,68.56,10,10,female,61 137,68,64,68.56,4,1,male,66 137,68,64,68.56,4,2,male,63 137,68,64,68.56,4,3,female,65.5 137,68,64,68.56,4,4,female,62 138,68,64,68.56,5,1,male,71.2 138,68,64,68.56,5,2,male,71.2 138,68,64,68.56,5,3,male,69 138,68,64,68.56,5,4,male,68.5 138,68,64,68.56,5,5,female,62.5 139,68,64.5,68.83,1,1,female,62 140,68,64,68.56,10,1,male,69 140,68,64,68.56,10,2,male,67 140,68,64,68.56,10,3,male,66 140,68,64,68.56,10,4,female,66 140,68,64,68.56,10,5,female,66 140,68,64,68.56,10,6,female,65 140,68,64,68.56,10,7,female,65 140,68,64,68.56,10,8,female,65 140,68,64,68.56,10,9,female,64 140,68,64,68.56,10,10,female,63 141,68,63,68.02,8,1,male,70.5 141,68,63,68.02,8,2,male,70 141,68,63,68.02,8,3,male,68 141,68,63,68.02,8,4,male,66 141,68,63,68.02,8,5,male,66 141,68,63,68.02,8,6,female,66 141,68,63,68.02,8,7,female,62 141,68,63,68.02,8,8,female,61.5 142,68.5,63.5,68.54,4,1,male,73.5 142,68.5,63.5,68.54,4,2,male,70 142,68.5,63.5,68.54,4,3,male,69.5 142,68.5,63.5,68.54,4,4,female,65.5 143,68,63,68.02,1,1,male,67 144,68,63,68.02,4,1,male,70 144,68,63,68.02,4,2,male,68 144,68,63,68.02,4,3,female,64.5 144,68,63,68.02,4,4,female,64 145,68,63,68.02,8,1,male,71 145,68,63,68.02,8,2,male,68 145,68,63,68.02,8,3,male,66 145,68,63,68.02,8,4,male,65.5 145,68,63,68.02,8,5,male,65 145,68,63,68.02,8,6,female,63 145,68,63,68.02,8,7,female,62 145,68,63,68.02,8,8,female,62 146,68,63,68.02,6,1,male,67 146,68,63,68.02,6,2,male,67 146,68,63,68.02,6,3,male,66 146,68,63,68.02,6,4,female,64 146,68,63,68.02,6,5,female,63.5 146,68,63,68.02,6,6,female,61 147,68.5,63.5,68.54,1,1,male,68.2 148,68,63,68.02,1,1,male,70 149,68.2,63.5,68.39,5,1,male,70 149,68.2,63.5,68.39,5,2,male,69 149,68.2,63.5,68.39,5,3,male,67 149,68.2,63.5,68.39,5,4,male,65.5 149,68.2,63.5,68.39,5,5,female,64.5 150,68,62.5,67.75,1,1,male,68.5 151,68.7,62,67.83,2,1,male,67.7 151,68.7,62,67.83,2,2,female,61.7 152,68,62.5,67.75,1,1,male,66.5 153,68,61,66.94,5,1,male,68.5 153,68,61,66.94,5,2,male,68 153,68,61,66.94,5,3,male,64 153,68,61,66.94,5,4,female,63.5 153,68,61,66.94,5,5,female,63 154,68,60.2,66.508,1,1,male,66.7 155,68,60,66.4,7,1,male,64 155,68,60,66.4,7,2,female,61 155,68,60,66.4,7,3,female,61 155,68,60,66.4,7,4,female,60 155,68,60,66.4,7,5,female,60 155,68,60,66.4,7,6,female,60 155,68,60,66.4,7,7,female,56 156,68,60,66.4,4,1,male,67.5 156,68,60,66.4,4,2,male,67 156,68,60,66.4,4,3,male,66.5 156,68,60,66.4,4,4,female,60 157,68.5,59,66.11,1,1,male,69 158,68,59,65.86,10,1,male,68 158,68,59,65.86,10,2,male,65 158,68,59,65.86,10,3,male,64.7 158,68,59,65.86,10,4,male,64 158,68,59,65.86,10,5,male,64 158,68,59,65.86,10,6,male,63 158,68,59,65.86,10,7,female,65 158,68,59,65.86,10,8,female,65 158,68,59,65.86,10,9,female,62 158,68,59,65.86,10,10,female,61 159,67,66.2,69.248,5,1,male,72.7 159,67,66.2,69.248,5,2,male,72.7 159,67,66.2,69.248,5,3,male,71.5 159,67,66.2,69.248,5,4,female,65.5 159,67,66.2,69.248,5,5,female,63.5 160,67,66.5,69.41,1,1,male,71 161,67,66,69.14,8,1,male,73 161,67,66,69.14,8,2,male,71 161,67,66,69.14,8,3,male,70.7 161,67,66,69.14,8,4,male,70 161,67,66,69.14,8,5,male,69 161,67,66,69.14,8,6,female,68 161,67,66,69.14,8,7,female,65.5 161,67,66,69.14,8,8,female,62 162,67,65,68.6,6,1,male,69.7 162,67,65,68.6,6,2,male,67.5 162,67,65,68.6,6,3,female,65.5 162,67,65,68.6,6,4,female,65 162,67,65,68.6,6,5,female,64.5 162,67,65,68.6,6,6,female,63.5 163,67,65.5,68.87,5,1,male,70 163,67,65.5,68.87,5,2,male,69 163,67,65.5,68.87,5,3,female,65.5 163,67,65.5,68.87,5,4,female,65.5 163,67,65.5,68.87,5,5,female,63 164,67,65.5,68.87,4,1,male,70 164,67,65.5,68.87,4,2,male,67.7 164,67,65.5,68.87,4,3,female,63 164,67,65.5,68.87,4,4,female,60 165,67,65,68.6,3,1,male,65 165,67,65,68.6,3,2,female,62 165,67,65,68.6,3,3,female,62 166,67.5,65,68.85,11,1,male,71 166,67.5,65,68.85,11,2,male,69 166,67.5,65,68.85,11,3,female,64 166,67.5,65,68.85,11,4,female,64 166,67.5,65,68.85,11,5,female,63 166,67.5,65,68.85,11,6,female,63 166,67.5,65,68.85,11,7,female,63 166,67.5,65,68.85,11,8,female,63 166,67.5,65,68.85,11,9,female,63 166,67.5,65,68.85,11,10,female,62.5 166,67.5,65,68.85,11,11,female,62 167,67,64,68.06,4,1,male,71.5 167,67,64,68.06,4,2,male,70 167,67,64,68.06,4,3,male,67 167,67,64,68.06,4,4,male,67 168,67,63.5,67.79,8,1,male,71 168,67,63.5,67.79,8,2,male,70.2 168,67,63.5,67.79,8,3,male,69.2 168,67,63.5,67.79,8,4,male,68.5 168,67,63.5,67.79,8,5,male,68 168,67,63.5,67.79,8,6,male,67 168,67,63.5,67.79,8,7,male,65.5 168,67,63.5,67.79,8,8,female,63.5 169,67,63,67.52,3,1,male,69 169,67,63,67.52,3,2,male,68 169,67,63,67.52,3,3,female,63 170,67.5,62,67.23,5,1,male,70 170,67.5,62,67.23,5,2,male,69.5 170,67.5,62,67.23,5,3,male,69 170,67.5,62,67.23,5,4,male,68.5 170,67.5,62,67.23,5,5,female,66 171,67,61,66.44,1,1,male,67 172,66,67,69.18,8,1,male,70.5 172,66,67,69.18,8,2,male,70.5 172,66,67,69.18,8,3,male,67 172,66,67,69.18,8,4,male,66 172,66,67,69.18,8,5,male,66 172,66,67,69.18,8,6,female,62 172,66,67,69.18,8,7,female,62 172,66,67,69.18,8,8,female,61.5 173,66,67,69.18,9,1,male,72 173,66,67,69.18,9,2,male,65 173,66,67,69.18,9,3,male,65 173,66,67,69.18,9,4,female,67 173,66,67,69.18,9,5,female,64 173,66,67,69.18,9,6,female,64 173,66,67,69.18,9,7,female,62 173,66,67,69.18,9,8,female,60 173,66,67,69.18,9,9,female,60 174,66,66,68.64,5,1,male,66 174,66,66,68.64,5,2,male,65 174,66,66,68.64,5,3,female,67 174,66,66,68.64,5,4,female,66.5 174,66,66,68.64,5,5,female,65.5 175,66,66,68.64,6,1,male,72 175,66,66,68.64,6,2,male,68 175,66,66,68.64,6,3,female,66 175,66,66,68.64,6,4,female,65 175,66,66,68.64,6,5,female,62 175,66,66,68.64,6,6,female,61 176,66.5,65,68.35,8,1,male,68.7 176,66.5,65,68.35,8,2,male,68.5 176,66.5,65,68.35,8,3,male,66.5 176,66.5,65,68.35,8,4,male,64.5 176,66.5,65,68.35,8,5,female,62.5 176,66.5,65,68.35,8,6,female,60.5 176,66.5,65,68.35,8,7,female,60.5 176,66.5,65,68.35,8,8,female,57.5 177,66,65.5,68.37,5,1,male,72 177,66,65.5,68.37,5,2,male,71 177,66,65.5,68.37,5,3,male,67 177,66,65.5,68.37,5,4,female,66 177,66,65.5,68.37,5,5,female,65 178,66,63,67.02,1,1,male,70 179,66,63.5,67.29,2,1,female,64.5 179,66,63.5,67.29,2,2,female,62 180,66.5,63,67.27,6,1,male,67.2 180,66.5,63,67.27,6,2,male,67 180,66.5,63,67.27,6,3,male,65 180,66.5,63,67.27,6,4,female,65 180,66.5,63,67.27,6,5,female,65 180,66.5,63,67.27,6,6,female,63 181,66.5,62.5,67,7,1,male,70 181,66.5,62.5,67,7,2,male,68 181,66.5,62.5,67,7,3,female,63.5 181,66.5,62.5,67,7,4,female,62.5 181,66.5,62.5,67,7,5,female,62.5 181,66.5,62.5,67,7,6,female,62.5 181,66.5,62.5,67,7,7,female,62.5 182,66,61.5,66.21,1,1,male,70 183,66,60,65.4,4,1,male,68 183,66,60,65.4,4,2,male,67 183,66,60,65.4,4,3,male,65 183,66,60,65.4,4,4,female,60 184,66,60,65.4,1,1,male,65 185,66,59,64.86,15,1,male,68 185,66,59,64.86,15,2,male,67 185,66,59,64.86,15,3,male,66.5 185,66,59,64.86,15,4,male,66 185,66,59,64.86,15,5,male,65.7 185,66,59,64.86,15,6,male,65.5 185,66,59,64.86,15,7,male,65 185,66,59,64.86,15,8,female,65 185,66,59,64.86,15,9,female,64 185,66,59,64.86,15,10,female,63 185,66,59,64.86,15,11,female,62 185,66,59,64.86,15,12,female,61 185,66,59,64.86,15,13,female,60 185,66,59,64.86,15,14,female,58 185,66,59,64.86,15,15,female,57 186,65,67,68.68,4,1,male,66.5 186,65,67,68.68,4,2,male,66 186,65,67,68.68,4,3,male,66 186,65,67,68.68,4,4,female,65 187,65,67,68.68,1,1,female,63 188,65,66,68.14,4,1,male,63 188,65,66,68.14,4,2,female,63 188,65,66,68.14,4,3,female,63 188,65,66,68.14,4,4,female,60 189,65,66,68.14,5,1,male,67 189,65,66,68.14,5,2,male,66 189,65,66,68.14,5,3,male,65 189,65,66,68.14,5,4,female,65 189,65,66,68.14,5,5,female,61 190,65,65,67.6,9,1,male,69 190,65,65,67.6,9,2,male,68 190,65,65,67.6,9,3,male,68 190,65,65,67.6,9,4,female,65 190,65,65,67.6,9,5,female,65 190,65,65,67.6,9,6,female,62 190,65,65,67.6,9,7,female,62 190,65,65,67.6,9,8,female,61 190,65,65,67.6,9,9,female,59 191,65,65.5,67.87,2,1,male,70.7 191,65,65.5,67.87,2,2,female,65.5 192,65,65,67.6,6,1,male,69.2 192,65,65,67.6,6,2,male,69 192,65,65,67.6,6,3,male,68 192,65,65,67.6,6,4,male,67.7 192,65,65,67.6,6,5,female,64.5 192,65,65,67.6,6,6,female,60.5 193,65,64,67.06,6,1,male,67 193,65,64,67.06,6,2,male,67 193,65,64,67.06,6,3,female,64 193,65,64,67.06,6,4,female,64 193,65,64,67.06,6,5,female,62.5 193,65,64,67.06,6,6,female,60.5 194,65,63,66.52,2,1,male,70 194,65,63,66.52,2,2,female,63 195,65,63,66.52,3,1,male,66 195,65,63,66.52,3,2,male,66 195,65,63,66.52,3,3,female,63 196,65.5,63,66.77,4,1,male,71 196,65.5,63,66.77,4,2,male,71 196,65.5,63,66.77,4,3,male,69 196,65.5,63,66.77,4,4,female,63.5 197,65.5,60,65.15,5,1,male,68 197,65.5,60,65.15,5,2,male,68 197,65.5,60,65.15,5,3,male,67 197,65.5,60,65.15,5,4,male,67 197,65.5,60,65.15,5,5,female,62 198,64,64,66.56,7,1,male,71.5 198,64,64,66.56,7,2,male,68 198,64,64,66.56,7,3,female,65.5 198,64,64,66.56,7,4,female,64 198,64,64,66.56,7,5,female,62 198,64,64,66.56,7,6,female,62 198,64,64,66.56,7,7,female,61 199,64,64,66.56,7,1,male,70.5 199,64,64,66.56,7,2,male,68 199,64,64,66.56,7,3,female,67 199,64,64,66.56,7,4,female,65 199,64,64,66.56,7,5,female,64 199,64,64,66.56,7,6,female,64 199,64,64,66.56,7,7,female,60 200,64,63,66.02,1,1,male,64.5 201,64,60,64.4,2,1,male,66 201,64,60,64.4,2,2,female,60 202,63,63.5,65.79,2,1,female,68.5 202,63,63.5,65.79,2,2,female,63.5 203,62,66,66.64,3,1,male,64 203,62,66,66.64,3,2,female,62 203,62,66,66.64,3,3,female,61 204,62.5,63,65.27,2,1,male,66.5 204,62.5,63,65.27,2,2,female,57 \ No newline at end of file From 7dd0f97a61469a32fd4001748cc49344835990a8 Mon Sep 17 00:00:00 2001 From: W Trimble Date: Wed, 23 Aug 2023 09:38:49 -0500 Subject: [PATCH 06/12] moved one more datafile; removed empty range() --- data | 1 - textbook/05/3/Control_Statements_Iteration.ipynb | 5 ++--- textbook/{13/3 => data}/diabetes.csv | 0 3 files changed, 2 insertions(+), 4 deletions(-) delete mode 100644 data rename textbook/{13/3 => data}/diabetes.csv (100%) diff --git a/data b/data deleted file mode 100644 index 8b348125..00000000 --- a/data +++ /dev/null @@ -1 +0,0 @@ -family,father,mother,midparentHeight,children,childNum,gender,childHeight 1,78.5,67,75.43,4,1,male,73.2 1,78.5,67,75.43,4,2,female,69.2 1,78.5,67,75.43,4,3,female,69 1,78.5,67,75.43,4,4,female,69 2,75.5,66.5,73.66,4,1,male,73.5 2,75.5,66.5,73.66,4,2,male,72.5 2,75.5,66.5,73.66,4,3,female,65.5 2,75.5,66.5,73.66,4,4,female,65.5 3,75,64,72.06,2,1,male,71 3,75,64,72.06,2,2,female,68 4,75,64,72.06,5,1,male,70.5 4,75,64,72.06,5,2,male,68.5 4,75,64,72.06,5,3,female,67 4,75,64,72.06,5,4,female,64.5 4,75,64,72.06,5,5,female,63 5,75,58.5,69.09,6,1,male,72 5,75,58.5,69.09,6,2,male,69 5,75,58.5,69.09,6,3,male,68 5,75,58.5,69.09,6,4,female,66.5 5,75,58.5,69.09,6,5,female,62.5 5,75,58.5,69.09,6,6,female,62.5 6,74,68,73.72,1,1,female,69.5 7,74,68,73.72,6,1,male,76.5 7,74,68,73.72,6,2,male,74 7,74,68,73.72,6,3,male,73 7,74,68,73.72,6,4,male,73 7,74,68,73.72,6,5,female,70.5 7,74,68,73.72,6,6,female,64 8,74,66.5,72.91,3,1,female,70.5 8,74,66.5,72.91,3,2,female,68 8,74,66.5,72.91,3,3,female,66 9,74.5,66,72.89,1,1,female,66 10,74,65.5,72.37,1,1,female,65.5 11,74,62,70.48,8,1,male,74 11,74,62,70.48,8,2,male,70 11,74,62,70.48,8,3,female,68 11,74,62,70.48,8,4,female,67 11,74,62,70.48,8,5,female,67 11,74,62,70.48,8,6,female,66 11,74,62,70.48,8,7,female,63.5 11,74,62,70.48,8,8,female,63 12,74,61,69.94,1,1,female,65 13,73,67,72.68,2,1,male,71 13,73,67,72.68,2,2,female,62 14,73,67,72.68,2,1,male,68 14,73,67,72.68,2,2,male,67 15,73,66.5,72.41,3,1,male,71 15,73,66.5,72.41,3,2,male,70.5 15,73,66.5,72.41,3,3,female,66.7 16,73,65,71.6,9,1,male,72 16,73,65,71.6,9,2,male,70.5 16,73,65,71.6,9,3,male,70.2 16,73,65,71.6,9,4,male,70.2 16,73,65,71.6,9,5,male,69.2 16,73,65,71.6,9,6,female,68.7 16,73,65,71.6,9,7,female,66.5 16,73,65,71.6,9,8,female,64.5 16,73,65,71.6,9,9,female,63.5 17,73,64.5,71.33,6,1,male,74 17,73,64.5,71.33,6,2,male,73 17,73,64.5,71.33,6,3,male,71.5 17,73,64.5,71.33,6,4,male,62.5 17,73,64.5,71.33,6,5,female,66.5 17,73,64.5,71.33,6,6,female,62.3 18,73,64,71.06,3,1,female,66 18,73,64,71.06,3,2,female,64.5 18,73,64,71.06,3,3,female,64 19,73.2,63,70.62,1,1,female,62.7 20,72.7,69,73.61,8,1,male,73.2 20,72.7,69,73.61,8,2,male,73 20,72.7,69,73.61,8,3,male,72.7 20,72.7,69,73.61,8,4,female,70 20,72.7,69,73.61,8,5,female,69 20,72.7,69,73.61,8,6,female,68.5 20,72.7,69,73.61,8,7,female,68 20,72.7,69,73.61,8,8,female,66 21,72,68,72.72,3,1,male,73 21,72,68,72.72,3,2,female,68.5 21,72,68,72.72,3,3,female,68 22,72,67,72.18,3,1,male,73 22,72,67,72.18,3,2,male,71 22,72,67,72.18,3,3,female,67 23,72,65,71.1,7,1,male,74.2 23,72,65,71.1,7,2,male,70.5 23,72,65,71.1,7,3,male,69.5 23,72,65,71.1,7,4,female,66 23,72,65,71.1,7,5,female,65.5 23,72,65,71.1,7,6,female,65 23,72,65,71.1,7,7,female,65 24,72,65.5,71.37,1,1,female,65.5 25,72,64,70.56,2,1,female,66 25,72,64,70.56,2,2,female,63 26,72,63,70.02,5,1,male,70.5 26,72,63,70.02,5,2,male,70.5 26,72,63,70.02,5,3,male,69 26,72,63,70.02,5,4,female,65 26,72,63,70.02,5,5,female,63 27,72,63,70.02,3,1,male,69 27,72,63,70.02,3,2,male,67 27,72,63,70.02,3,3,female,63 28,72,63,70.02,6,1,male,73 28,72,63,70.02,6,2,male,67 28,72,63,70.02,6,3,female,70.5 28,72,63,70.02,6,4,female,70 28,72,63,70.02,6,5,female,66.5 28,72,63,70.02,6,6,female,63 29,72.5,63.5,70.54,3,1,female,67.5 29,72.5,63.5,70.54,3,2,female,67.2 29,72.5,63.5,70.54,3,3,female,66.7 30,72,62,69.48,1,1,female,64 31,72.5,62,69.73,6,1,male,71 31,72.5,62,69.73,6,2,male,70 31,72.5,62,69.73,6,3,male,70 31,72.5,62,69.73,6,4,female,66 31,72.5,62,69.73,6,5,female,65 31,72.5,62,69.73,6,6,female,65 32,72,62,69.48,5,1,male,74 32,72,62,69.48,5,2,male,72 32,72,62,69.48,5,3,male,69 32,72,62,69.48,5,4,female,67.5 32,72,62,69.48,5,5,female,63.5 33,72,62,69.48,5,1,male,72 33,72,62,69.48,5,2,male,71.5 33,72,62,69.48,5,3,male,71.5 33,72,62,69.48,5,4,male,70 33,72,62,69.48,5,5,female,68 34,72,61,68.94,1,1,female,65.7 35,71,69,72.76,5,1,male,78 35,71,69,72.76,5,2,male,74 35,71,69,72.76,5,3,male,73 35,71,69,72.76,5,4,male,72 35,71,69,72.76,5,5,female,67 36,71,67,71.68,4,1,male,73.2 36,71,67,71.68,4,2,male,73 36,71,67,71.68,4,3,male,69 36,71,67,71.68,4,4,female,67 37,71,66,71.14,4,1,male,70 37,71,66,71.14,4,2,female,67 37,71,66,71.14,4,3,female,67 37,71,66,71.14,4,4,female,66.5 38,71,66,71.14,6,1,male,70 38,71,66,71.14,6,2,male,69 38,71,66,71.14,6,3,male,68.5 38,71,66,71.14,6,4,female,66 38,71,66,71.14,6,5,female,64.5 38,71,66,71.14,6,6,female,63 39,71,66,71.14,2,1,male,71 39,71,66,71.14,2,2,female,67 40,71,66,71.14,5,1,male,76 40,71,66,71.14,5,2,male,72 40,71,66,71.14,5,3,male,71 40,71,66,71.14,5,4,male,66 40,71,66,71.14,5,5,female,66 41,71.7,65.5,71.22,1,1,male,70.5 42,71,65.5,70.87,6,1,male,72 42,71,65.5,70.87,6,2,male,72 42,71,65.5,70.87,6,3,male,71 42,71,65.5,70.87,6,4,male,69 42,71,65.5,70.87,6,5,female,66 42,71,65.5,70.87,6,6,female,65 43,71.5,65.5,71.12,2,1,male,73 43,71.5,65.5,71.12,2,2,female,65.2 44,71.5,65,70.85,2,1,male,68.5 44,71.5,65,70.85,2,2,male,67.7 45,71,65,70.6,3,1,male,68 45,71,65,70.6,3,2,male,68 45,71,65,70.6,3,3,female,62 46,71,64,70.06,8,1,female,68 46,71,64,70.06,8,2,female,68 46,71,64,70.06,8,3,female,67.5 46,71,64,70.06,8,4,female,66.5 46,71,64,70.06,8,5,female,66.5 46,71,64,70.06,8,6,female,66 46,71,64,70.06,8,7,female,65.5 46,71,64,70.06,8,8,female,65 47,71.7,64.5,70.68,4,1,male,72 47,71.7,64.5,70.68,4,2,male,71 47,71.7,64.5,70.68,4,3,male,70.5 47,71.7,64.5,70.68,4,4,female,67 48,71,64,70.06,3,1,male,68 48,71,64,70.06,3,2,male,68 48,71,64,70.06,3,3,male,68 49,71.5,64.5,70.58,7,1,male,72 49,71.5,64.5,70.58,7,2,male,71 49,71.5,64.5,70.58,7,3,male,70 49,71.5,64.5,70.58,7,4,female,66 49,71.5,64.5,70.58,7,5,female,64.5 49,71.5,64.5,70.58,7,6,female,64.5 49,71.5,64.5,70.58,7,7,female,62 50,71,64.5,70.33,2,1,male,73 50,71,64.5,70.33,2,2,female,62 51,71.2,63,69.62,2,1,female,67.5 51,71.2,63,69.62,2,2,female,64.5 52,71,63.5,69.79,5,1,male,71 52,71,63.5,69.79,5,2,male,67 52,71,63.5,69.79,5,3,female,66 52,71,63.5,69.79,5,4,female,65 52,71,63.5,69.79,5,5,female,63.5 53,71,63,69.52,9,1,male,71 53,71,63,69.52,9,2,male,70 53,71,63,69.52,9,3,male,70 53,71,63,69.52,9,4,male,64 53,71,63,69.52,9,5,female,65 53,71,63,69.52,9,6,female,65 53,71,63,69.52,9,7,female,64 53,71,63,69.52,9,8,female,63 53,71,63,69.52,9,9,female,63 54,71,63,69.52,4,1,male,71 54,71,63,69.52,4,2,male,71 54,71,63,69.52,4,3,male,70 54,71,63,69.52,4,4,female,63.5 55,71,62,68.98,5,1,male,71 55,71,62,68.98,5,2,male,70 55,71,62,68.98,5,3,female,64.5 55,71,62,68.98,5,4,female,62.5 55,71,62,68.98,5,5,female,61.5 56,71,62,68.98,5,1,male,72 56,71,62,68.98,5,2,male,70.5 56,71,62,68.98,5,3,male,70.5 56,71,62,68.98,5,4,female,64.5 56,71,62,68.98,5,5,female,60 57,71,62.5,69.25,5,1,male,70 57,71,62.5,69.25,5,2,female,64 57,71,62.5,69.25,5,3,female,64 57,71,62.5,69.25,5,4,female,64 57,71,62.5,69.25,5,5,female,62.5 58,71,62,68.98,7,1,male,70.5 58,71,62,68.98,7,2,male,70 58,71,62,68.98,7,3,male,69 58,71,62,68.98,7,4,male,69 58,71,62,68.98,7,5,male,66 58,71,62,68.98,7,6,female,64.5 58,71,62,68.98,7,7,female,64 59,71,61,68.44,1,1,female,62 60,71,58,66.82,2,1,male,71.5 60,71,58,66.82,2,2,male,69 61,70,69,72.26,4,1,male,71 61,70,69,72.26,4,2,male,70 61,70,69,72.26,4,3,male,69 61,70,69,72.26,4,4,female,69 62,70,69,72.26,6,1,male,70 62,70,69,72.26,6,2,male,68.7 62,70,69,72.26,6,3,female,68 62,70,69,72.26,6,4,female,66 62,70,69,72.26,6,5,female,64 62,70,69,72.26,6,6,female,62 63,70,68,71.72,1,1,male,75 64,70,67,71.18,5,1,male,70 64,70,67,71.18,5,2,male,69 64,70,67,71.18,5,3,female,66 64,70,67,71.18,5,4,female,64 64,70,67,71.18,5,5,female,60 65,70,67,71.18,1,1,female,67.5 66,70,66.5,70.91,11,1,male,73 66,70,66.5,70.91,11,2,male,72 66,70,66.5,70.91,11,3,male,72 66,70,66.5,70.91,11,4,male,66.5 66,70,66.5,70.91,11,5,female,69.2 66,70,66.5,70.91,11,6,female,67.2 66,70,66.5,70.91,11,7,female,66.5 66,70,66.5,70.91,11,8,female,66 66,70,66.5,70.91,11,9,female,66 66,70,66.5,70.91,11,10,female,64.2 66,70,66.5,70.91,11,11,female,63.7 67,70.5,65,70.35,4,1,male,72 67,70.5,65,70.35,4,2,male,70.2 67,70.5,65,70.35,4,3,male,69 67,70.5,65,70.35,4,4,male,68.5 68,70.5,65,70.35,5,1,female,68 68,70.5,65,70.35,5,2,female,65 68,70.5,65,70.35,5,3,female,61.5 68,70.5,65,70.35,5,4,female,61 68,70.5,65,70.35,5,5,female,61 69,70,65,70.1,8,1,male,73 69,70,65,70.1,8,2,male,72 69,70,65,70.1,8,3,male,70.5 69,70,65,70.1,8,4,male,65 69,70,65,70.1,8,5,male,65 69,70,65,70.1,8,6,female,64.5 69,70,65,70.1,8,7,female,63 69,70,65,70.1,8,8,female,62 70,70,65,70.1,5,1,male,67 70,70,65,70.1,5,2,male,65 70,70,65,70.1,5,3,female,64.5 70,70,65,70.1,5,4,female,62.5 70,70,65,70.1,5,5,female,62.5 71,70,65,70.1,6,1,male,70 71,70,65,70.1,6,2,male,70 71,70,65,70.1,6,3,female,67 71,70,65,70.1,6,4,female,65 71,70,65,70.1,6,5,female,65 71,70,65,70.1,6,6,female,63 72,70,65,70.1,7,1,male,79 72,70,65,70.1,7,2,male,75 72,70,65,70.1,7,3,male,71 72,70,65,70.1,7,4,female,69 72,70,65,70.1,7,5,female,67 72,70,65,70.1,7,6,female,65.7 72,70,65,70.1,7,7,female,62 73,70,65,70.1,3,1,male,73 73,70,65,70.1,3,2,male,72.5 73,70,65,70.1,3,3,female,65 74,70,65,70.1,2,1,male,69 74,70,65,70.1,2,2,male,69 75,70,64.7,69.938,7,1,male,72 75,70,64.7,69.938,7,2,male,70 75,70,64.7,69.938,7,3,male,68.7 75,70,64.7,69.938,7,4,female,66.5 75,70,64.7,69.938,7,5,female,65.5 75,70,64.7,69.938,7,6,female,64.7 75,70,64.7,69.938,7,7,female,64.5 76,70,64,69.56,7,1,male,70.7 76,70,64,69.56,7,2,male,70 76,70,64,69.56,7,3,male,68 76,70,64,69.56,7,4,male,67 76,70,64,69.56,7,5,male,66 76,70,64,69.56,7,6,male,65 76,70,64,69.56,7,7,female,67 77,70,64,69.56,4,1,male,70 77,70,64,69.56,4,2,male,68 77,70,64,69.56,4,3,male,66.7 77,70,64,69.56,4,4,female,65.5 78,70,64.2,69.668,5,1,male,72 78,70,64.2,69.668,5,2,male,70 78,70,64.2,69.668,5,3,female,62.5 78,70,64.2,69.668,5,4,female,61.2 78,70,64.2,69.668,5,5,female,60.1 79,70.5,64,69.81,8,1,male,74 79,70.5,64,69.81,8,2,male,69.5 79,70.5,64,69.81,8,3,male,69 79,70.5,64,69.81,8,4,male,68 79,70.5,64,69.81,8,5,male,68 79,70.5,64,69.81,8,6,male,68 79,70.5,64,69.81,8,7,female,65.5 79,70.5,64,69.81,8,8,female,65 80,70.5,64.5,70.08,1,1,female,60 81,70,64,69.56,4,1,male,68 81,70,64,69.56,4,2,female,65 81,70,64,69.56,4,3,female,64 81,70,64,69.56,4,4,female,62 82,70,64,69.56,9,1,male,71 82,70,64,69.56,9,2,male,70 82,70,64,69.56,9,3,male,70 82,70,64,69.56,9,4,male,70 82,70,64,69.56,9,5,male,69.5 82,70,64,69.56,9,6,male,68.5 82,70,64,69.56,9,7,female,69 82,70,64,69.56,9,8,female,65 82,70,64,69.56,9,9,female,64 83,70,63.7,69.398,8,1,male,70 83,70,63.7,69.398,8,2,male,67 83,70,63.7,69.398,8,3,male,65.5 83,70,63.7,69.398,8,4,female,63.7 83,70,63.7,69.398,8,5,female,63.2 83,70,63.7,69.398,8,6,female,62.5 83,70,63.7,69.398,8,7,female,62.2 83,70,63.7,69.398,8,8,female,61 84,70.5,63,69.27,4,1,male,70 84,70.5,63,69.27,4,2,male,68.5 84,70.5,63,69.27,4,3,female,65.5 84,70.5,63,69.27,4,4,female,63.5 85,70.5,63,69.27,5,1,male,72.5 85,70.5,63,69.27,5,2,male,69 85,70.5,63,69.27,5,3,male,67 85,70.5,63,69.27,5,4,female,64.5 85,70.5,63,69.27,5,5,female,64 86,70,63.5,69.29,4,1,male,71 86,70,63.5,69.29,4,2,male,67.5 86,70,63.5,69.29,4,3,female,67.5 86,70,63.5,69.29,4,4,female,63.5 87,70,63,69.02,4,1,male,68 87,70,63,69.02,4,2,male,67 87,70,63,69.02,4,3,female,63.7 87,70,63,69.02,4,4,female,62 88,70,63,69.02,4,1,male,70 88,70,63,69.02,4,2,male,66.5 88,70,63,69.02,4,3,female,62 88,70,63,69.02,4,4,female,61 89,70.5,62,68.73,8,1,male,72 89,70.5,62,68.73,8,2,male,70 89,70.5,62,68.73,8,3,male,69.5 89,70.5,62,68.73,8,4,male,69.5 89,70.5,62,68.73,8,5,male,68 89,70.5,62,68.73,8,6,female,65 89,70.5,62,68.73,8,7,female,64 89,70.5,62,68.73,8,8,female,63 90,70.3,62.7,69.008,7,1,male,70.7 90,70.3,62.7,69.008,7,2,male,69.7 90,70.3,62.7,69.008,7,3,male,69.2 90,70.3,62.7,69.008,7,4,male,65.2 90,70.3,62.7,69.008,7,5,female,64 90,70.3,62.7,69.008,7,6,female,63.5 90,70.3,62.7,69.008,7,7,female,63.2 91,70.5,62,68.73,3,1,male,72 91,70.5,62,68.73,3,2,male,72 91,70.5,62,68.73,3,3,female,60 92,70,61,67.94,2,1,male,71.2 92,70,61,67.94,2,2,male,67 93,70,60,67.4,4,1,male,67 93,70,60,67.4,4,2,male,64.5 93,70,60,67.4,4,3,female,65 93,70,60,67.4,4,4,female,63 94,70,60,67.4,2,1,female,65 94,70,60,67.4,2,2,female,65 95,70,58.5,66.59,3,1,male,71.5 95,70,58.5,66.59,3,2,male,64.5 95,70,58.5,66.59,3,3,female,63 96,70,58,66.32,5,1,male,72 96,70,58,66.32,5,2,male,66 96,70,58,66.32,5,3,female,66 96,70,58,66.32,5,4,female,65 96,70,58,66.32,5,5,female,63 97,69,68.5,71.49,10,1,male,75 97,69,68.5,71.49,10,2,male,71 97,69,68.5,71.49,10,3,male,70 97,69,68.5,71.49,10,4,female,66 97,69,68.5,71.49,10,5,female,66 97,69,68.5,71.49,10,6,female,65.5 97,69,68.5,71.49,10,7,female,65 97,69,68.5,71.49,10,8,female,65 97,69,68.5,71.49,10,9,female,64 97,69,68.5,71.49,10,10,female,64 98,69,67,70.68,1,1,female,64 99,69,66,70.14,8,1,male,73 99,69,66,70.14,8,2,male,72 99,69,66,70.14,8,3,male,71.7 99,69,66,70.14,8,4,male,71.5 99,69,66,70.14,8,5,female,65.5 99,69,66,70.14,8,6,female,65 99,69,66,70.14,8,7,female,62.7 99,69,66,70.14,8,8,female,62.5 100,69,66,70.14,3,1,male,71.2 100,69,66,70.14,3,2,male,71 100,69,66,70.14,3,3,male,70 101,69,66.7,70.518,4,1,male,75 101,69,66.7,70.518,4,2,male,74 101,69,66.7,70.518,4,3,male,72 101,69,66.7,70.518,4,4,male,68.5 102,69,66,70.14,6,1,male,70 102,69,66,70.14,6,2,male,68.5 102,69,66,70.14,6,3,male,68 102,69,66,70.14,6,4,female,65 102,69,66,70.14,6,5,female,63 102,69,66,70.14,6,6,female,62.5 103,69,66.5,70.41,7,1,male,73 103,69,66.5,70.41,7,2,male,71 103,69,66.5,70.41,7,3,male,70.5 103,69,66.5,70.41,7,4,male,70.5 103,69,66.5,70.41,7,5,male,67 103,69,66.5,70.41,7,6,male,66 103,69,66.5,70.41,7,7,female,61 104,69.5,66.5,70.66,4,1,male,70.5 104,69.5,66.5,70.66,4,2,male,67.5 104,69.5,66.5,70.66,4,3,female,64.5 104,69.5,66.5,70.66,4,4,female,64 105,69,66.5,70.41,6,1,male,71 105,69,66.5,70.41,6,2,female,68.5 105,69,66.5,70.41,6,3,female,67.5 105,69,66.5,70.41,6,4,female,66 105,69,66.5,70.41,6,5,female,63 105,69,66.5,70.41,6,6,female,63 106,69.5,66,70.39,7,1,male,71 106,69.5,66,70.39,7,2,male,71 106,69.5,66,70.39,7,3,male,70.5 106,69.5,66,70.39,7,4,male,70.5 106,69.5,66,70.39,7,5,female,66.5 106,69.5,66,70.39,7,6,female,65.5 106,69.5,66,70.39,7,7,female,64.5 107,69,66,70.14,9,1,male,73 107,69,66,70.14,9,2,male,72 107,69,66,70.14,9,3,male,69 107,69,66,70.14,9,4,male,69 107,69,66,70.14,9,5,female,66.5 107,69,66,70.14,9,6,female,65.5 107,69,66,70.14,9,7,female,65.5 107,69,66,70.14,9,8,female,65 107,69,66,70.14,9,9,female,64 108,69,65,69.6,7,1,male,70 108,69,65,69.6,7,2,male,68.5 108,69,65,69.6,7,3,male,67 108,69,65,69.6,7,4,female,65 108,69,65,69.6,7,5,female,64 108,69,65,69.6,7,6,female,63.5 108,69,65,69.6,7,7,female,61 109,69.5,64.5,69.58,7,1,male,69.7 109,69.5,64.5,69.58,7,2,male,68 109,69.5,64.5,69.58,7,3,male,60 109,69.5,64.5,69.58,7,4,female,65.2 109,69.5,64.5,69.58,7,5,female,64.5 109,69.5,64.5,69.58,7,6,female,63.7 109,69.5,64.5,69.58,7,7,female,60 110,69.2,64,69.16,4,1,male,71.7 110,69.2,64,69.16,4,2,male,66.5 110,69.2,64,69.16,4,3,female,65 110,69.2,64,69.16,4,4,female,63.5 111,69,63.5,68.79,1,1,female,65.5 112,69,63,68.52,3,1,male,69 112,69,63,68.52,3,2,female,67.5 112,69,63,68.52,3,3,female,63.5 113,69,63,68.52,1,1,male,72 114,69,63,68.52,6,1,male,73 114,69,63,68.52,6,2,male,70 114,69,63,68.52,6,3,male,70 114,69,63,68.52,6,4,male,64 114,69,63,68.52,6,5,female,66 114,69,63,68.52,6,6,female,62 115,69,63.5,68.79,7,1,male,70.5 115,69,63.5,68.79,7,2,male,67 115,69,63.5,68.79,7,3,male,66 115,69,63.5,68.79,7,4,female,65 115,69,63.5,68.79,7,5,female,63 115,69,63.5,68.79,7,6,female,62 115,69,63.5,68.79,7,7,female,61 116,69,63.5,68.79,3,1,male,70.5 116,69,63.5,68.79,3,2,female,63.7 116,69,63.5,68.79,3,3,female,63 117,69.7,62,68.33,1,1,female,62.5 118,69.5,62,68.23,3,1,male,73 118,69.5,62,68.23,3,2,male,72 118,69.5,62,68.23,3,3,male,69 119,69,62,67.98,5,1,male,73 119,69,62,67.98,5,2,male,71 119,69,62,67.98,5,3,male,71 119,69,62,67.98,5,4,male,69 119,69,62,67.98,5,5,female,63 120,69.5,62,68.23,11,1,male,72 120,69.5,62,68.23,11,2,male,70 120,69.5,62,68.23,11,3,male,67.8 120,69.5,62,68.23,11,4,female,65.2 120,69.5,62,68.23,11,5,female,64.7 120,69.5,62,68.23,11,6,female,64.5 120,69.5,62,68.23,11,7,female,63.5 120,69.5,62,68.23,11,8,female,63.5 120,69.5,62,68.23,11,9,female,62.5 120,69.5,62,68.23,11,10,female,62 120,69.5,62,68.23,11,11,female,61.5 121,69,62.5,68.25,8,1,male,71 121,69,62.5,68.25,8,2,male,70 121,69,62.5,68.25,8,3,male,70 121,69,62.5,68.25,8,4,male,69 121,69,62.5,68.25,8,5,female,63.5 121,69,62.5,68.25,8,6,female,62.5 121,69,62.5,68.25,8,7,female,62.5 121,69,62.5,68.25,8,8,female,62 122,69,62,67.98,4,1,male,72 122,69,62,67.98,4,2,male,68 122,69,62,67.98,4,3,female,66 122,69,62,67.98,4,4,female,66 123,69.5,61,67.69,5,1,male,70 123,69.5,61,67.69,5,2,male,69.5 123,69.5,61,67.69,5,3,male,69 123,69.5,61,67.69,5,4,female,63 123,69.5,61,67.69,5,5,female,62 124,69,61,67.44,9,1,male,68 124,69,61,67.44,9,2,male,68 124,69,61,67.44,9,3,male,67.5 124,69,61,67.44,9,4,male,64 124,69,61,67.44,9,5,male,63 124,69,61,67.44,9,6,male,63 124,69,61,67.44,9,7,female,63.5 124,69,61,67.44,9,8,female,62 124,69,61,67.44,9,9,female,62 125,69,60,66.9,3,1,male,70.5 125,69,60,66.9,3,2,female,68 125,69,60,66.9,3,3,female,62.5 126,69,60,66.9,4,1,male,69 126,69,60,66.9,4,2,male,66 126,69,60,66.9,4,3,female,61.7 126,69,60,66.9,4,4,female,60.5 127,69,60.5,67.17,1,1,male,69.5 128,68.7,70.5,72.42,2,1,male,71 128,68.7,70.5,72.42,2,2,female,61.7 129,68.5,67,70.43,3,1,male,73 129,68.5,67,70.43,3,2,male,71 129,68.5,67,70.43,3,3,female,67 130,68.5,66.5,70.16,11,1,male,70 130,68.5,66.5,70.16,11,2,male,69 130,68.5,66.5,70.16,11,3,male,69 130,68.5,66.5,70.16,11,4,male,68.7 130,68.5,66.5,70.16,11,5,male,68.5 130,68.5,66.5,70.16,11,6,male,68.5 130,68.5,66.5,70.16,11,7,male,68 130,68.5,66.5,70.16,11,8,male,68 130,68.5,66.5,70.16,11,9,male,68 130,68.5,66.5,70.16,11,10,male,66.2 130,68.5,66.5,70.16,11,11,female,63.2 131,68,65,69.1,2,1,male,67.5 131,68,65,69.1,2,2,male,66 132,68,65.5,69.37,2,1,male,66 132,68,65.5,69.37,2,2,female,64 133,68,65.5,69.37,7,1,male,71.7 133,68,65.5,69.37,7,2,male,71.5 133,68,65.5,69.37,7,3,male,70.7 133,68,65.5,69.37,7,4,male,65.5 133,68,65.5,69.37,7,5,female,66.5 133,68,65.5,69.37,7,6,female,65.2 133,68,65.5,69.37,7,7,female,61.5 134,68,65,69.1,4,1,male,72 134,68,65,69.1,4,2,male,72 134,68,65,69.1,4,3,female,68 134,68,65,69.1,4,4,female,66 135,68.5,65,69.35,8,1,male,69.2 135,68.5,65,69.35,8,2,male,68 135,68.5,65,69.35,8,3,male,66 135,68.5,65,69.35,8,4,male,66 135,68.5,65,69.35,8,5,female,62 135,68.5,65,69.35,8,6,female,61.5 135,68.5,65,69.35,8,7,female,61 135,68.5,65,69.35,8,8,female,60 136A,68.5,65,69.35,8,1,male,72 136A,68.5,65,69.35,8,2,male,70.5 136A,68.5,65,69.35,8,3,male,68.7 136A,68.5,65,69.35,8,4,male,68.5 136A,68.5,65,69.35,8,5,male,67.7 136A,68.5,65,69.35,8,6,female,64 136A,68.5,65,69.35,8,7,female,63.5 136A,68.5,65,69.35,8,8,female,63 136,68,64,68.56,10,1,male,71 136,68,64,68.56,10,2,male,68 136,68,64,68.56,10,3,male,68 136,68,64,68.56,10,4,male,67 136,68,64,68.56,10,5,female,65 136,68,64,68.56,10,6,female,64 136,68,64,68.56,10,7,female,63 136,68,64,68.56,10,8,female,63 136,68,64,68.56,10,9,female,62 136,68,64,68.56,10,10,female,61 137,68,64,68.56,4,1,male,66 137,68,64,68.56,4,2,male,63 137,68,64,68.56,4,3,female,65.5 137,68,64,68.56,4,4,female,62 138,68,64,68.56,5,1,male,71.2 138,68,64,68.56,5,2,male,71.2 138,68,64,68.56,5,3,male,69 138,68,64,68.56,5,4,male,68.5 138,68,64,68.56,5,5,female,62.5 139,68,64.5,68.83,1,1,female,62 140,68,64,68.56,10,1,male,69 140,68,64,68.56,10,2,male,67 140,68,64,68.56,10,3,male,66 140,68,64,68.56,10,4,female,66 140,68,64,68.56,10,5,female,66 140,68,64,68.56,10,6,female,65 140,68,64,68.56,10,7,female,65 140,68,64,68.56,10,8,female,65 140,68,64,68.56,10,9,female,64 140,68,64,68.56,10,10,female,63 141,68,63,68.02,8,1,male,70.5 141,68,63,68.02,8,2,male,70 141,68,63,68.02,8,3,male,68 141,68,63,68.02,8,4,male,66 141,68,63,68.02,8,5,male,66 141,68,63,68.02,8,6,female,66 141,68,63,68.02,8,7,female,62 141,68,63,68.02,8,8,female,61.5 142,68.5,63.5,68.54,4,1,male,73.5 142,68.5,63.5,68.54,4,2,male,70 142,68.5,63.5,68.54,4,3,male,69.5 142,68.5,63.5,68.54,4,4,female,65.5 143,68,63,68.02,1,1,male,67 144,68,63,68.02,4,1,male,70 144,68,63,68.02,4,2,male,68 144,68,63,68.02,4,3,female,64.5 144,68,63,68.02,4,4,female,64 145,68,63,68.02,8,1,male,71 145,68,63,68.02,8,2,male,68 145,68,63,68.02,8,3,male,66 145,68,63,68.02,8,4,male,65.5 145,68,63,68.02,8,5,male,65 145,68,63,68.02,8,6,female,63 145,68,63,68.02,8,7,female,62 145,68,63,68.02,8,8,female,62 146,68,63,68.02,6,1,male,67 146,68,63,68.02,6,2,male,67 146,68,63,68.02,6,3,male,66 146,68,63,68.02,6,4,female,64 146,68,63,68.02,6,5,female,63.5 146,68,63,68.02,6,6,female,61 147,68.5,63.5,68.54,1,1,male,68.2 148,68,63,68.02,1,1,male,70 149,68.2,63.5,68.39,5,1,male,70 149,68.2,63.5,68.39,5,2,male,69 149,68.2,63.5,68.39,5,3,male,67 149,68.2,63.5,68.39,5,4,male,65.5 149,68.2,63.5,68.39,5,5,female,64.5 150,68,62.5,67.75,1,1,male,68.5 151,68.7,62,67.83,2,1,male,67.7 151,68.7,62,67.83,2,2,female,61.7 152,68,62.5,67.75,1,1,male,66.5 153,68,61,66.94,5,1,male,68.5 153,68,61,66.94,5,2,male,68 153,68,61,66.94,5,3,male,64 153,68,61,66.94,5,4,female,63.5 153,68,61,66.94,5,5,female,63 154,68,60.2,66.508,1,1,male,66.7 155,68,60,66.4,7,1,male,64 155,68,60,66.4,7,2,female,61 155,68,60,66.4,7,3,female,61 155,68,60,66.4,7,4,female,60 155,68,60,66.4,7,5,female,60 155,68,60,66.4,7,6,female,60 155,68,60,66.4,7,7,female,56 156,68,60,66.4,4,1,male,67.5 156,68,60,66.4,4,2,male,67 156,68,60,66.4,4,3,male,66.5 156,68,60,66.4,4,4,female,60 157,68.5,59,66.11,1,1,male,69 158,68,59,65.86,10,1,male,68 158,68,59,65.86,10,2,male,65 158,68,59,65.86,10,3,male,64.7 158,68,59,65.86,10,4,male,64 158,68,59,65.86,10,5,male,64 158,68,59,65.86,10,6,male,63 158,68,59,65.86,10,7,female,65 158,68,59,65.86,10,8,female,65 158,68,59,65.86,10,9,female,62 158,68,59,65.86,10,10,female,61 159,67,66.2,69.248,5,1,male,72.7 159,67,66.2,69.248,5,2,male,72.7 159,67,66.2,69.248,5,3,male,71.5 159,67,66.2,69.248,5,4,female,65.5 159,67,66.2,69.248,5,5,female,63.5 160,67,66.5,69.41,1,1,male,71 161,67,66,69.14,8,1,male,73 161,67,66,69.14,8,2,male,71 161,67,66,69.14,8,3,male,70.7 161,67,66,69.14,8,4,male,70 161,67,66,69.14,8,5,male,69 161,67,66,69.14,8,6,female,68 161,67,66,69.14,8,7,female,65.5 161,67,66,69.14,8,8,female,62 162,67,65,68.6,6,1,male,69.7 162,67,65,68.6,6,2,male,67.5 162,67,65,68.6,6,3,female,65.5 162,67,65,68.6,6,4,female,65 162,67,65,68.6,6,5,female,64.5 162,67,65,68.6,6,6,female,63.5 163,67,65.5,68.87,5,1,male,70 163,67,65.5,68.87,5,2,male,69 163,67,65.5,68.87,5,3,female,65.5 163,67,65.5,68.87,5,4,female,65.5 163,67,65.5,68.87,5,5,female,63 164,67,65.5,68.87,4,1,male,70 164,67,65.5,68.87,4,2,male,67.7 164,67,65.5,68.87,4,3,female,63 164,67,65.5,68.87,4,4,female,60 165,67,65,68.6,3,1,male,65 165,67,65,68.6,3,2,female,62 165,67,65,68.6,3,3,female,62 166,67.5,65,68.85,11,1,male,71 166,67.5,65,68.85,11,2,male,69 166,67.5,65,68.85,11,3,female,64 166,67.5,65,68.85,11,4,female,64 166,67.5,65,68.85,11,5,female,63 166,67.5,65,68.85,11,6,female,63 166,67.5,65,68.85,11,7,female,63 166,67.5,65,68.85,11,8,female,63 166,67.5,65,68.85,11,9,female,63 166,67.5,65,68.85,11,10,female,62.5 166,67.5,65,68.85,11,11,female,62 167,67,64,68.06,4,1,male,71.5 167,67,64,68.06,4,2,male,70 167,67,64,68.06,4,3,male,67 167,67,64,68.06,4,4,male,67 168,67,63.5,67.79,8,1,male,71 168,67,63.5,67.79,8,2,male,70.2 168,67,63.5,67.79,8,3,male,69.2 168,67,63.5,67.79,8,4,male,68.5 168,67,63.5,67.79,8,5,male,68 168,67,63.5,67.79,8,6,male,67 168,67,63.5,67.79,8,7,male,65.5 168,67,63.5,67.79,8,8,female,63.5 169,67,63,67.52,3,1,male,69 169,67,63,67.52,3,2,male,68 169,67,63,67.52,3,3,female,63 170,67.5,62,67.23,5,1,male,70 170,67.5,62,67.23,5,2,male,69.5 170,67.5,62,67.23,5,3,male,69 170,67.5,62,67.23,5,4,male,68.5 170,67.5,62,67.23,5,5,female,66 171,67,61,66.44,1,1,male,67 172,66,67,69.18,8,1,male,70.5 172,66,67,69.18,8,2,male,70.5 172,66,67,69.18,8,3,male,67 172,66,67,69.18,8,4,male,66 172,66,67,69.18,8,5,male,66 172,66,67,69.18,8,6,female,62 172,66,67,69.18,8,7,female,62 172,66,67,69.18,8,8,female,61.5 173,66,67,69.18,9,1,male,72 173,66,67,69.18,9,2,male,65 173,66,67,69.18,9,3,male,65 173,66,67,69.18,9,4,female,67 173,66,67,69.18,9,5,female,64 173,66,67,69.18,9,6,female,64 173,66,67,69.18,9,7,female,62 173,66,67,69.18,9,8,female,60 173,66,67,69.18,9,9,female,60 174,66,66,68.64,5,1,male,66 174,66,66,68.64,5,2,male,65 174,66,66,68.64,5,3,female,67 174,66,66,68.64,5,4,female,66.5 174,66,66,68.64,5,5,female,65.5 175,66,66,68.64,6,1,male,72 175,66,66,68.64,6,2,male,68 175,66,66,68.64,6,3,female,66 175,66,66,68.64,6,4,female,65 175,66,66,68.64,6,5,female,62 175,66,66,68.64,6,6,female,61 176,66.5,65,68.35,8,1,male,68.7 176,66.5,65,68.35,8,2,male,68.5 176,66.5,65,68.35,8,3,male,66.5 176,66.5,65,68.35,8,4,male,64.5 176,66.5,65,68.35,8,5,female,62.5 176,66.5,65,68.35,8,6,female,60.5 176,66.5,65,68.35,8,7,female,60.5 176,66.5,65,68.35,8,8,female,57.5 177,66,65.5,68.37,5,1,male,72 177,66,65.5,68.37,5,2,male,71 177,66,65.5,68.37,5,3,male,67 177,66,65.5,68.37,5,4,female,66 177,66,65.5,68.37,5,5,female,65 178,66,63,67.02,1,1,male,70 179,66,63.5,67.29,2,1,female,64.5 179,66,63.5,67.29,2,2,female,62 180,66.5,63,67.27,6,1,male,67.2 180,66.5,63,67.27,6,2,male,67 180,66.5,63,67.27,6,3,male,65 180,66.5,63,67.27,6,4,female,65 180,66.5,63,67.27,6,5,female,65 180,66.5,63,67.27,6,6,female,63 181,66.5,62.5,67,7,1,male,70 181,66.5,62.5,67,7,2,male,68 181,66.5,62.5,67,7,3,female,63.5 181,66.5,62.5,67,7,4,female,62.5 181,66.5,62.5,67,7,5,female,62.5 181,66.5,62.5,67,7,6,female,62.5 181,66.5,62.5,67,7,7,female,62.5 182,66,61.5,66.21,1,1,male,70 183,66,60,65.4,4,1,male,68 183,66,60,65.4,4,2,male,67 183,66,60,65.4,4,3,male,65 183,66,60,65.4,4,4,female,60 184,66,60,65.4,1,1,male,65 185,66,59,64.86,15,1,male,68 185,66,59,64.86,15,2,male,67 185,66,59,64.86,15,3,male,66.5 185,66,59,64.86,15,4,male,66 185,66,59,64.86,15,5,male,65.7 185,66,59,64.86,15,6,male,65.5 185,66,59,64.86,15,7,male,65 185,66,59,64.86,15,8,female,65 185,66,59,64.86,15,9,female,64 185,66,59,64.86,15,10,female,63 185,66,59,64.86,15,11,female,62 185,66,59,64.86,15,12,female,61 185,66,59,64.86,15,13,female,60 185,66,59,64.86,15,14,female,58 185,66,59,64.86,15,15,female,57 186,65,67,68.68,4,1,male,66.5 186,65,67,68.68,4,2,male,66 186,65,67,68.68,4,3,male,66 186,65,67,68.68,4,4,female,65 187,65,67,68.68,1,1,female,63 188,65,66,68.14,4,1,male,63 188,65,66,68.14,4,2,female,63 188,65,66,68.14,4,3,female,63 188,65,66,68.14,4,4,female,60 189,65,66,68.14,5,1,male,67 189,65,66,68.14,5,2,male,66 189,65,66,68.14,5,3,male,65 189,65,66,68.14,5,4,female,65 189,65,66,68.14,5,5,female,61 190,65,65,67.6,9,1,male,69 190,65,65,67.6,9,2,male,68 190,65,65,67.6,9,3,male,68 190,65,65,67.6,9,4,female,65 190,65,65,67.6,9,5,female,65 190,65,65,67.6,9,6,female,62 190,65,65,67.6,9,7,female,62 190,65,65,67.6,9,8,female,61 190,65,65,67.6,9,9,female,59 191,65,65.5,67.87,2,1,male,70.7 191,65,65.5,67.87,2,2,female,65.5 192,65,65,67.6,6,1,male,69.2 192,65,65,67.6,6,2,male,69 192,65,65,67.6,6,3,male,68 192,65,65,67.6,6,4,male,67.7 192,65,65,67.6,6,5,female,64.5 192,65,65,67.6,6,6,female,60.5 193,65,64,67.06,6,1,male,67 193,65,64,67.06,6,2,male,67 193,65,64,67.06,6,3,female,64 193,65,64,67.06,6,4,female,64 193,65,64,67.06,6,5,female,62.5 193,65,64,67.06,6,6,female,60.5 194,65,63,66.52,2,1,male,70 194,65,63,66.52,2,2,female,63 195,65,63,66.52,3,1,male,66 195,65,63,66.52,3,2,male,66 195,65,63,66.52,3,3,female,63 196,65.5,63,66.77,4,1,male,71 196,65.5,63,66.77,4,2,male,71 196,65.5,63,66.77,4,3,male,69 196,65.5,63,66.77,4,4,female,63.5 197,65.5,60,65.15,5,1,male,68 197,65.5,60,65.15,5,2,male,68 197,65.5,60,65.15,5,3,male,67 197,65.5,60,65.15,5,4,male,67 197,65.5,60,65.15,5,5,female,62 198,64,64,66.56,7,1,male,71.5 198,64,64,66.56,7,2,male,68 198,64,64,66.56,7,3,female,65.5 198,64,64,66.56,7,4,female,64 198,64,64,66.56,7,5,female,62 198,64,64,66.56,7,6,female,62 198,64,64,66.56,7,7,female,61 199,64,64,66.56,7,1,male,70.5 199,64,64,66.56,7,2,male,68 199,64,64,66.56,7,3,female,67 199,64,64,66.56,7,4,female,65 199,64,64,66.56,7,5,female,64 199,64,64,66.56,7,6,female,64 199,64,64,66.56,7,7,female,60 200,64,63,66.02,1,1,male,64.5 201,64,60,64.4,2,1,male,66 201,64,60,64.4,2,2,female,60 202,63,63.5,65.79,2,1,female,68.5 202,63,63.5,65.79,2,2,female,63.5 203,62,66,66.64,3,1,male,64 203,62,66,66.64,3,2,female,62 203,62,66,66.64,3,3,female,61 204,62.5,63,65.27,2,1,male,66.5 204,62.5,63,65.27,2,2,female,57 \ No newline at end of file diff --git a/textbook/05/3/Control_Statements_Iteration.ipynb b/textbook/05/3/Control_Statements_Iteration.ipynb index 63fb36f6..92907e0e 100644 --- a/textbook/05/3/Control_Statements_Iteration.ipynb +++ b/textbook/05/3/Control_Statements_Iteration.ipynb @@ -545,8 +545,7 @@ ], "source": [ "import numpy as np\n", - "np.arange(4)\n", - "range()" + "np.arange(4)\n" ] }, { @@ -643,7 +642,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.10.6" }, "vscode": { "interpreter": { diff --git a/textbook/13/3/diabetes.csv b/textbook/data/diabetes.csv similarity index 100% rename from textbook/13/3/diabetes.csv rename to textbook/data/diabetes.csv From d0dd2945c172027a9388b038943f7455175cf8ce Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Wed, 23 Aug 2023 15:26:06 -0500 Subject: [PATCH 07/12] Revert "Draft build" --- textbook/03/3/DataTypes.ipynb | 175 +-- textbook/04/3/Arrays-Intro.ipynb | 653 +-------- textbook/04/3/img/flowers_array3.png | Bin 26297 -> 0 bytes textbook/04/4/Arrays-Slicing.ipynb | 267 ++++ ...ro-to-Matplotlib.ipynb => Libraries.ipynb} | 33 +- textbook/09/2/Categorical_Data.ipynb | 920 ++++++++++++ textbook/09/2/Numerical_Data.ipynb | 1234 ----------------- textbook/09/2/img/boxandwhisker.png | Bin 0 -> 68181 bytes textbook/09/3/Categorical_Data.ipynb | 988 ------------- textbook/09/3/Numerical_Data.ipynb | 779 +++++++++++ textbook/09/4/img/BoxandWhisker.png | Bin 52323 -> 0 bytes textbook/09/4/img/median(even).png | Bin 46171 -> 0 bytes textbook/09/4/img/median(odd).png | Bin 55118 -> 0 bytes textbook/09/4/other-viz.ipynb | 1021 -------------- textbook/09/data-visualization.md | 2 +- textbook/15/1/ethics-and-law.ipynb | 4 +- textbook/15/2/img/lifecycleofdata.png | Bin 0 -> 453059 bytes textbook/15/{5 => 2}/img/trust.png | Bin textbook/15/2/pillar1.ipynb | 92 +- textbook/15/{2 => 5}/img/Dresseletal.png | Bin .../15/{2 => 5}/img/indiana-eugenics.jpeg | Bin textbook/15/5/img/lifecycleofdata.png | Bin 507162 -> 0 bytes .../15/{2 => 5}/img/virginia-eugenics.jpeg | Bin textbook/15/5/pillar4.ipynb | 109 +- textbook/_toc.yml | 22 +- 25 files changed, 2138 insertions(+), 4161 deletions(-) delete mode 100644 textbook/04/3/img/flowers_array3.png create mode 100644 textbook/04/4/Arrays-Slicing.ipynb rename textbook/09/1/{Intro-to-Matplotlib.ipynb => Libraries.ipynb} (91%) create mode 100644 textbook/09/2/Categorical_Data.ipynb delete mode 100644 textbook/09/2/Numerical_Data.ipynb create mode 100644 textbook/09/2/img/boxandwhisker.png delete mode 100644 textbook/09/3/Categorical_Data.ipynb create mode 100644 textbook/09/3/Numerical_Data.ipynb delete mode 100644 textbook/09/4/img/BoxandWhisker.png delete mode 100644 textbook/09/4/img/median(even).png delete mode 100644 textbook/09/4/img/median(odd).png delete mode 100644 textbook/09/4/other-viz.ipynb create mode 100644 textbook/15/2/img/lifecycleofdata.png rename textbook/15/{5 => 2}/img/trust.png (100%) rename textbook/15/{2 => 5}/img/Dresseletal.png (100%) rename textbook/15/{2 => 5}/img/indiana-eugenics.jpeg (100%) delete mode 100644 textbook/15/5/img/lifecycleofdata.png rename textbook/15/{2 => 5}/img/virginia-eugenics.jpeg (100%) diff --git a/textbook/03/3/DataTypes.ipynb b/textbook/03/3/DataTypes.ipynb index e385748f..c6ff0c73 100644 --- a/textbook/03/3/DataTypes.ipynb +++ b/textbook/03/3/DataTypes.ipynb @@ -8,7 +8,7 @@ "# Data Types\n", "*Evelyn Campbell, Ph.D.*\n", "\n", - "Python offers a number of different data types that can be manipulated and used by various functions. Some important built-in Python data types include **booleans**, **strings**, **integers**, and **floats**. These data types can be used to build various data structures, such as lists, dictionaries, arrays, and dataframes, which will be covered in Chapters [4](../4/DataStructures.ipynb) and [6](../6/DataFrames.ipynb). Here we will explore each data type and corresponding functions that are useful when working with these data types." + "Python offers a number of different data types that can be manipulated and used by various functions. Some important built-in Python data types include booleans, strings, integers, and floats. These data types can be used to build various data structures, such as lists, dictionaries, arrays, and dataframes, which will be covered in Chapters 4 and 6. Here we will explore each data type and corresponding functions that are useful when working with these data types." ] }, { @@ -18,12 +18,12 @@ "source": [ "## Booleans\n", "\n", - "Booleans are a data type that consist of two possible outcomes: `True` or `False`. Under the hood, these values take on a binary value, where `True` is equal to 1 and `False` is equal to 0. Booleans are very commonly used with comparison operators ([discussed more in section 3.4](../3/4/Comparisons.ipynb)), and because they also can have a numeric meaning, they can be used in calculations as well. Let's start with a simple example of a Boolean." + "Booleans are a data type that consists of two possible outcomes: `True` or `False`. Under the hood, these values take on a binary value, where `True` is equal to 1 and `False` is equal to 0. Booleans are very commonly used with comparison operators, and because they also can have a numeric meaning, they can be used in calculations as well. Let's start with a simple example of a Boolean." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "id": "0856f3c4", "metadata": {}, "outputs": [ @@ -33,29 +33,19 @@ "False" ] }, - "execution_count": 5, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "boolval = 5 < 3\n", + "boolval = 2 + 5 < 3 + 1\n", "boolval" ] }, - { - "cell_type": "markdown", - "id": "061f80a6", - "metadata": {}, - "source": [ - "Above, the variable `boolval` is equated to the expression `5 < 3`, which reads \"5 is less than 3.\" Because 5 is not in fact less than 3, the entire statement is `False`, and this Boolean value is assigned to `boolval`.\n", - "\n", - "Below, we add 5 to the value of `boolval`. Recall that `False` has a numerical value of 0, so essentially, `boolval + 5` is the same as 0 + 5:" - ] - }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "id": "9474bdc6", "metadata": {}, "outputs": [ @@ -65,7 +55,7 @@ "5" ] }, - "execution_count": 6, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -75,14 +65,6 @@ "boolval" ] }, - { - "cell_type": "markdown", - "id": "071ba5da", - "metadata": {}, - "source": [ - "Using the variable directly in a comparison expression, we can see that the value of `boolval` is less than 10, and thus returns another Boolean value of `True`:" - ] - }, { "cell_type": "code", "execution_count": 3, @@ -109,9 +91,7 @@ "id": "37df7040", "metadata": {}, "source": [ - "Python has built-in **functions** that use values and variables as input to perform a task and produce an output. We have already used some basic functions, such as the `print()` function, and we will learn about a few more that are associated with datatypes. Built-in functions will be further discussed in section [section 3.4](../3/5/IntroFunctions.ipynb). \n", - "\n", - "For now, we will use a few basic functions associated with data types. The `bool()` function converts an input (i.e. a numeric value, string, or even data structures) to a boolean value." + "The `bool()` function converts an input (i.e. a numeric value, string, or even data structures) to a boolean value." ] }, { @@ -147,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "96368899", "metadata": {}, "outputs": [ @@ -162,7 +142,7 @@ ], "source": [ "something = 6542\n", - "nothing = 0\n", + "nothing = 0 # an empty list\n", "print(bool(something))\n", "print(bool(nothing))" ] @@ -174,14 +154,12 @@ "source": [ "## Strings\n", "\n", - "A **string** a data type that can consist of **concatenated** alphanumeric and punctuation characters. According to the Merriam-Webster dictionary, to concatenate means *to link together in a series or chain*.\n", - "\n", - "Strings are recognized by Python through the use of single (' '), double (\" \"), or triple (''' ''') quotation marks. " + "Strings are a data type that can consist of concatenated alphanumeric and punctuation characters. Strings are recognized by Python through the use of single (' ') or double (\" \") quotation marks. " ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "9868b82e", "metadata": {}, "outputs": [ @@ -208,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "4e147421", "metadata": {}, "outputs": [ @@ -226,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "5b4ec625", "metadata": { "tags": [ @@ -236,10 +214,10 @@ "outputs": [ { "ename": "SyntaxError", - "evalue": "invalid syntax (3546504085.py, line 1)", + "evalue": "unterminated string literal (detected at line 1) (3546504085.py, line 1)", "output_type": "error", "traceback": [ - "\u001b[0;36m Input \u001b[0;32mIn [9]\u001b[0;36m\u001b[0m\n\u001b[0;31m print('This isn't easy.')\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + "\u001b[0;36m Cell \u001b[0;32mIn [8], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m print('This isn't easy.')\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unterminated string literal (detected at line 1)\n" ] } ], @@ -247,75 +225,17 @@ "print('This isn't easy.')" ] }, - { - "cell_type": "markdown", - "id": "101ed527", - "metadata": {}, - "source": [ - "The above error can be fixed by an **escape sequence**. Escape sequences are string modifiers that allow for the use of certain characters that would otherwise be misinterpreted by Python. Because strings are created by the use of quotes, the escape sequences `\\'` and `\\\"` allow for the use of quotes as part of a string:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "18da1844", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This isn't easy.\n" - ] - } - ], - "source": [ - "print('This isn\\'t easy.')" - ] - }, - { - "cell_type": "markdown", - "id": "2dae3eff", - "metadata": {}, - "source": [ - "Other useful escape sequences include `\\n` and `\\t`. These allow for a new line and tab spacing to be added to a string, respectively." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "241848e8", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This is the first sentence \n", - "This is the second sentence! \tThis is the third sentence?\n" - ] - } - ], - "source": [ - "sentences = '''This is the first sentence \\nThis is the second sentence! \\tThis is the third sentence?'''\n", - "print(sentences)" - ] - }, { "cell_type": "markdown", "id": "a46d5107", "metadata": {}, "source": [ - "Strings can be used in simple additive mathematical operations, like addition and multiplication, resulting in concatenation of the strings:" + "Strings can be used in simple additive mathematical operations, like addition and multiplication." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "3b40b622", "metadata": {}, "outputs": [ @@ -345,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "c57fbd1b", "metadata": {}, "outputs": [ @@ -363,45 +283,12 @@ "print(words, words)" ] }, - { - "cell_type": "markdown", - "id": "ca3e1bc1", - "metadata": {}, - "source": [ - "Escape sequences also can be used in the `print()` function as an argument or through concatenation:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "74b515d1", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This is a sentence. \t This isn't easy.\n", - "\n", - "\n", - "This isn't easy.\tThis is a sentence.\n" - ] - } - ], - "source": [ - "print(words, '\\t', 'This isn\\'t easy.') # Escape sequence used as an argument in the print function\n", - "print('\\n') # Escape sequence used to print a blank line\n", - "print('This isn\\'t easy.' + '\\t' + words) # Escape sequence concatenated to strings in the print function" - ] - }, { "cell_type": "markdown", "id": "396964f1", "metadata": {}, "source": [ - "When manipulating string variables, data scientists will often use what are called **methods**. A method is piece of code that is associated with a defined variable, as opposed to a **function** which uses defined variables as input arguments for parameters. Functions will be further discussed in the upcoming section.\n", + "When manipulating string variables, data scientist will often used what are called *methods*. A method is piece of code that is associated with a defined variable, as opposed to a *function* which uses defined variables as input parameters. Functions will be further discussed in the upcoming section.\n", "\n", "\n", "Some methods can be used on strings to quickly and efficiently alter them. A few include the `.upper()`, `.lower()`, `.capitalize()`, `.title()`, and `.swapcase()` methods. There are many others, but these few are great to start exploring the different ways string variables can be manipulated:" @@ -495,7 +382,7 @@ "id": "01d68864", "metadata": {}, "source": [ - "We can confirm that these are indeed strings by calling the `type()` function on these variables, which can be used on any variable to check its data type." + "We can confirm that these are indeed strings by calling these variables into the `type()` function, which can be used on any variable to check its data type." ] }, { @@ -525,7 +412,7 @@ "id": "c8160dd5", "metadata": {}, "source": [ - "Keep in mind that when a numerical value is converted to a string, it can no longer be used to perform certain mathematical calculations, such as division, subtraction, or exponentiation." + "Keep in mind that when a numerical value is converted to a string, it can no longer be used to perform advanced mathematical calculations, such as division, subtraction, or exponentiation." ] }, { @@ -598,7 +485,7 @@ "source": [ "## Integers & Floats\n", "\n", - "Integers and floats are numerical data types that are often used to perform mathematical operations. Integers consist of whole numbers, while floats consist of whole numbers with floating decimal places. Floats can hold up to 15 significant figures following the decimal point and can be used to obtain more accurate calculations. However, it is easier and faster for a computer to do calculations using integers. Thus, one must weigh the pros and cons of using these data types when doing calculations and writing functions to obtain outcomes that are most aligned with their end goals. Let's take a look at these data types in use.\n" + "Integers and floats are numerical data types that are often used to perform mathematical operations. Integers consists of whole numbers, while floats consists of whole numbers with floating decimal places. Floats can hold up to 15 significant figures following the decimal point and can be used to obtain more accurate calculations. However, it is easier and faster for a computer to do calculations using integers. Thus, one must weigh the pros and cons of using these data types when doing calculations and writing functions to obtain outcomes that are most aligned with their end goals. Let's take a look at these data types in use.\n" ] }, { @@ -709,7 +596,7 @@ "id": "0b7c63c9", "metadata": {}, "source": [ - "We can see that the conversion of an integer to a float simply adds one significant figure after the decimal place. Moreover, converting a float to an integer rounds the number *down* to the nearest whole number. We can also convert numerical values in strings and boolean data types to integers and floats" + "We can see that the conversion of an integer to a float simply adds one significant figure after the decimal place. Moreover, converting a float to an integer rounds the number down to the nearest whole number. We can also convert numerical values in strings and boolean data types to integers and floats" ] }, { @@ -775,16 +662,10 @@ "id": "e37e3887", "metadata": {}, "source": [ - "By understanding data types, we can begin to use them in other analyses and functionalities in Python. Next, we will learn how to use data types in comparisons, which can help further down the line in functions ([Chapter 3.5](../3/5/IntroFunctions.ipynb)), for loops ([Chapter 5.3](../../05/3/Control_Statements_Iteration.ipynb)), and subsetting data from DataFrames ([Chapter 5.3](../../06/6/Select_Condition.ipynb))." + "## Conclusions\n", + "\n", + "In this section, we learned about various different data types. These include the `boolean`, `string`, `int`, and `float` data types. As you become more acquainted with Python, you will see the ubiquity of these data types in many data structures, which we will discuss in upcoming chapters. For now, explore these data types and relevant functions to learn how and when these data types can be used. Happy coding!\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "23d5baaa", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -803,7 +684,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.10.6" } }, "nbformat": 4, diff --git a/textbook/04/3/Arrays-Intro.ipynb b/textbook/04/3/Arrays-Intro.ipynb index a07dea81..b9da0849 100644 --- a/textbook/04/3/Arrays-Intro.ipynb +++ b/textbook/04/3/Arrays-Intro.ipynb @@ -14,7 +14,7 @@ "id": "e72d9bce", "metadata": {}, "source": [ - "An *array* is a data structure that consists of a collection of elements organized into a grid-like shape. In Python, arrays can be one-dimensional, akin to a list, or multidimensional (2D, 3D, etc.). However, unlike a list, an array consists of elements that are all of the same data type. This makes arrays ideal for convenient storage of data elements. Arrays are offered through the `numpy` library, and are often used in conjunction with other Python libraries, such as `pandas`, `scipy`, and `scikit-learn` (linked below). We will explore arrays in this section, along with commonly used functions used with arrays." + "An *array* is a data structure that consists of a collection of elements organized into a grid-like shape. In Python, arrays can be one-dimensional, akin to a list, or multidimensional (2D, 3D, etc.). However, unlike a list, an array consists of elements that are all of the same data type. This makes arrays ideal for convienent for storage and fast manipulation of data elements. Arrays are offered through the `NumPy` library, and are often used in conjunction with other Python libraries, such as `pandas`, `SciPy`, and `Scikit-learn`. We will explore arrays in this section, along with commonly used functions used with arrays." ] }, { @@ -22,14 +22,12 @@ "id": "77369985", "metadata": {}, "source": [ - "## Constructing arrays\n", - "\n", - "To make an array, we first need to import `numpy`. We can then build an array from a list using the `np.array()` function." + "To make an array, we first need to import `NumPy`. We can then build an array from a list using the `np.array()` function." ] }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 2, "id": "ab8b729c", "metadata": {}, "outputs": [ @@ -39,7 +37,7 @@ "array([30, 50, 70, 90])" ] }, - "execution_count": 56, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -57,12 +55,12 @@ "id": "0b31777b", "metadata": {}, "source": [ - "Another way an array can be made is by using the `np.arange()` function. With this function, one can build an array with a given inclusive start value and exclusive stop value as well as a step, which by default is 1." + "Another way an array can be made is by using the `np.arange()` function. With this function, one can build an array with a given inclusive start value and exclusive stop value." ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 3, "id": "9f09fedf", "metadata": {}, "outputs": [ @@ -72,7 +70,7 @@ "array([ 4, 6, 8, 10])" ] }, - "execution_count": 57, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -87,7 +85,7 @@ "id": "ed9c9a2b", "metadata": {}, "source": [ - "Above, we made a one-dimensional array with four elements. We started the array at 4 and stopped it at 11. Because we specified the step as 2 (default is 1), our array gave us the values 4, 6, 8, and 10 because 11 is exclusive. Therefore, the `np.arange()` function will evenly space out the elements of our array just before the stop value." + "Above, we made a one-dimensional array with four elements. We started the array at 4 and stopped it at 11. Because we specified the spacing as 2, our array gave us the values 4, 6, 8, and 10 because 11 is exclusive. Therefore, the `np.arange()` function will evenly space out the elements of our array just before the stop value." ] }, { @@ -95,14 +93,12 @@ "id": "7e71b117", "metadata": {}, "source": [ - "## Mathematical operations with arrays\n", - "\n", - "Arrays also allow for convenient elementwise calculations. For example, we can easily multiply our two arrays to obtain a new array of values. " + "As previously stated, arrays are a data structure that allow for fast calculations. For example, we can easily multiply our two arrays to obtain a new array of values. " ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 4, "id": "a8c411f9", "metadata": {}, "outputs": [ @@ -112,7 +108,7 @@ "array([120, 300, 560, 900])" ] }, - "execution_count": 58, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -127,9 +123,7 @@ "id": "2c972b46", "metadata": {}, "source": [ - "The resulting array consists of the products of element-by-element multiplication of the first two arrays. Keep in mind that when performing calculations with multiple arrays, the dimensions of the arrays must be *compatible*. \n", - "\n", - "Performing elementwise operations on arrays of different shapes is called **broadcasting**, and a discussion on array shape compatibility in mathematical operations can be found in the referenced documentation on *Array broadcasting in numpy* below. " + "The resulting array consists of the products of element-by-element multiplication of the first two arrays. Keep in mind that when performing calculations with multiple arrays, the dimensions of the arrays must be compatible. A discussion on array shape compatibility in mathematical operations can be found in the referenced documentation on *Array Broadcasting in Numpy* below." ] }, { @@ -137,12 +131,12 @@ "id": "e7cefaca", "metadata": {}, "source": [ - "More simply, we can also perform a desired calculation on all elements of an array using scalar values:" + "More simply, we can also perform a desired calculation on all elements of an array" ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 5, "id": "1fa0c046", "metadata": {}, "outputs": [ @@ -152,7 +146,7 @@ "array([13., 22., 35., 52.])" ] }, - "execution_count": 59, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -166,14 +160,12 @@ "id": "5e772d89", "metadata": {}, "source": [ - "## Reshaping and combining arrays\n", - "\n", "Arrays can also be reshaped and combined. We can use the `np.reshape()` function to change the first two arrays from a 1-dimensional 1x4 array to a 2-dimensional 2x2 array." ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 6, "id": "63529f0f", "metadata": {}, "outputs": [], @@ -285,8 +277,6 @@ "id": "3b6bc94d", "metadata": {}, "source": [ - "## Array functions\n", - "\n", "Construction and reshaping of arrays is an important consideration if you wish to perform aggregate functions on them. Some useful aggregate functions that can be performed on arrays include `np.min()`, `np.max()`, `np.sum()`, and `np.average()`. These functions can be applied to the entire array or across rows and columns." ] }, @@ -393,608 +383,10 @@ }, { "cell_type": "markdown", - "id": "ec7f35b1", - "metadata": {}, - "source": [ - "## Indexing and Slicing\n", - "\n", - "1D arrays can be indexed similarly to how lists are indexed, as mentioned in the [section 4.1](../../1/Lists).\n", - "\n", - "\n", - "To begin in demonstrating this, let's make a new array of string elements called `flowers`:" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "c1f4ad88", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['orchid', 'rose', 'lilac', 'peony', 'tulip', 'dahlia', 'lily',\n", - " 'violet'], dtype='\n", - "\n", - "A single colon (:) can be used to slice a range of elements in an array. The format for simple slicing an array is as follows:\n", - "\n", - "```\n", - "array[start:end]\n", - "```\n", - "\n", - "\n", - "\n", - "If used between the indices *j* and *k*, slicing the elements of an array will return all elements between *j* and *k*, excluding k.\n", - "\n", - "In this case, we use 2:6 to slice from the third to the sixth element because we want to include the sixth element (which is located at index 5):\n" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "9935ef70", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['lilac', 'peony', 'tulip', 'dahlia'], dtype='Mathematical aggregate functions by numpy\n", - "- Array broadcasting in numpy\n", - "\n", - "- Scipy documentation\n", - "- scikit-learn documentation" + "- Mathematical aggregate functions by NumPy\n", + "- Array Broadcasting in Numpy" ] }, { "cell_type": "code", "execution_count": null, - "id": "e3b13b05", + "id": "0e5e643e", "metadata": {}, "outputs": [], "source": [] diff --git a/textbook/04/3/img/flowers_array3.png b/textbook/04/3/img/flowers_array3.png deleted file mode 100644 index 854ec91cac5cef94e7057bf4d88b39e66e8a73bd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 26297 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

~&3rLdjyWD=E-uU@Ii5Vu<%6zbMFyt5}-{?DQk! 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 Ub0r12`}@COJtJL=_PrPX16JBhd;kCd diff --git a/textbook/04/4/Arrays-Slicing.ipynb b/textbook/04/4/Arrays-Slicing.ipynb new file mode 100644 index 00000000..2d26fd71 --- /dev/null +++ b/textbook/04/4/Arrays-Slicing.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2eeb5048", + "metadata": {}, + "source": [ + "# Indexing and Slicing" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "89700eb9", + "metadata": {}, + "source": [ + "In this section, we will discuss common methods used to access data from arrays. Let's start by making an array of string elements called `flowers`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ac3fad2b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['orchid', 'rose', 'lilac', 'peony', 'tulip', 'dahlia', 'lily',\n", + " 'violet'], dtype='here.\n", + "The `seaborn` library is multifaceted because it offers many visualization style options. While it can be used to create many types of visualizations, data scientists sometimes use both `seaborn` and `matplotlib` to create graphs and charts that are suited for their visualization needs. Here, we will be using a combination of `matplotlib` and `seaborn` to create our visualizations.\n", "\n", - "Other visualization libraries, such as `seaborn` can be used as well and will be used later in the chapter.\n", + "A link to documentation for the visualization libraries used can be found at the end of this section.\n", "\n", - "For now, let's start by importing our libraries:" + "Let's start by importing our libraries:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "id": "85ee9e74-01e3-416f-8a12-bda151809cfd", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", + "import seaborn as sns\n", "\n", - "# Imports the pyplot module from matplotlib\n", "from matplotlib import pyplot as plt\n", "\n", - "# Sets the style for visualizations\n", - "plt.style.use('fast')" + "sns.set_style('whitegrid')" ] }, { @@ -46,12 +45,12 @@ "source": [ "To practice making these visualizations, we will be working with data from the World Bank. This data examines the military spending in each country in North America 1960-2020.\n", "\n", - "Let's again first take a look at this data in its comma-separated values format." + "Let's again first take a look at this data in its comma-separated values format. (Then we'll load it as a file.)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "id": "27a2775a-747a-41dd-a923-ef51efb68c31", "metadata": { "tags": [ @@ -140,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "id": "3fb13d36", "metadata": {}, "outputs": [ @@ -319,7 +318,7 @@ "[61 rows x 6 columns]" ] }, - "execution_count": 13, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -371,10 +370,14 @@ "## Resources\n", "\n", "- Matplotlib documentation\n", - "- Matplotlib visualization gallery\n", "- Pyplot documentation\n", + "- Seaborn documentation\n", + "- List of styles for plots in matplotlib\n", "- World Bank Data on Military Expenditure (in USD - MS.MIL.XPND.CD)\n", - "- World Bank Data on Military Expenditure (% of GDP - MS.MIL.XPND.GD.ZS)" + "- World Bank Data on Military Expenditure (% of GDP - MS.MIL.XPND.GD.ZS)\n", + "\n", + "\n", + "\n" ] } ], diff --git a/textbook/09/2/Categorical_Data.ipynb b/textbook/09/2/Categorical_Data.ipynb new file mode 100644 index 00000000..484b4d0d --- /dev/null +++ b/textbook/09/2/Categorical_Data.ipynb @@ -0,0 +1,920 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7ea83cf0", + "metadata": {}, + "source": [ + "# Categorical Data\n", + "\n", + "Categorical data consider numerical values (_i.e._ a quantitative variable) in the context of a category (_i.e._ a qualitative variable).\n", + "\n", + "Surveys, like the ones we see on the television show Family Feud or the frequency of people with various eye colors, are examples of categorical data. \n", + "\n", + "In this chapter, there are two types of categorical data that we consider: ordinal data and nominal data. \n", + "\n", + "**Ordinal data** consists of data that can be described as having a meaningful order, ranking, or relationship between categories. An inventory that quantifies the number of small, medium, and large shirts in stock is an example of ordinal data because there is a ranked relationship between shirt sizes.\n", + "\n", + "**Nominal data** can be described as named categories that have no meaningful relationship to one another. Counting the number of people with black, brunette, red, and blonde hair colors in a room is an example of nominal data because hair color has no inherit meaning amongst each other - one hair color is not greater than or less than the others.\n", + "\n", + "\n", + "Categorical data can be visualized using bar graphs, box and whisker plots, and pie charts, and in this section, we will practice making such visualizations.\n", + "\n", + "Let's load the necessary libraries and read in the data." + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "45d41791-b19e-48cf-917d-c411750c6122", + "metadata": { + "tags": [ + "hide_cell" + ] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "sns.set_style('whitegrid')\n", + "\n", + "NorthAmerica_Military_USD_PercentGDP_Combined_csv = '''\\\n", + "Year,CAN-PercentGDP,MEX-PercentGDP,USA-PercentGDP,CAN-USD,MEX-USD,USA-USD\n", + "1960,4.18525654,0.673508659,8.993124587,1.702442711,0.084,47.34655267\n", + "1961,4.128312243,0.651780326,9.1560315,1.677820881,0.0864,49.87977061\n", + "1962,3.999216389,0.689655172,9.331672945,1.671313753,0.0992,54.65094261\n", + "1963,3.620650112,0.718685832,8.831891186,1.610091701,0.112,54.56121578\n", + "1964,3.402062837,0.677506775,8.051281106,1.657457283,0.12,53.43232706\n", + "1965,2.930260659,0.591269841,7.587247177,1.57470454,0.1192,54.56179126\n", + "1966,2.683282422,0.576379066,8.435300286,1.614422827,0.1304,66.44275153\n", + "1967,2.74792677,0.545217107,9.417795933,1.775500366,0.1336,78.39844224\n", + "1968,2.54364188,0.548510764,9.268454275,1.797265817,0.1488,84.32903122\n", + "1969,2.27378467,0.600160043,8.633263795,1.770108751,0.18,84.99016543\n", + "1970,2.188979696,0.497411659,8.032743584,1.889157918,0.1768,83.407993\n", + "1971,2.131485639,0.48765558,6.943069609,2.077659711,0.1912,78.23797989\n", + "1972,2.011818438,0.536568089,6.519756924,2.233737031,0.2424,80.70807097\n", + "1973,1.832601818,0.544217687,5.893870591,2.363060955,0.3008,81.46979441\n", + "1974,1.783813085,0.565744137,5.954111197,2.809465529,0.4072,89.27892034\n", + "1975,1.863541853,0.57358422,5.622679096,3.18091549,0.5048,92.08092875\n", + "1976,1.765927978,0.598103574,5.191071429,3.581805735,0.531576968,94.71525108\n", + "1977,1.8057636,0.534256205,5.155617351,3.752174526,0.437692986,104.665219\n", + "1978,1.848887401,0.504834431,4.943087248,3.969158477,0.518287193,113.3820637\n", + "1979,1.711245918,0.505297474,4.951991535,4.084145738,0.679663588,126.8799271\n", + "1980,1.764448615,0.416107383,5.153537467,4.744402251,0.810422204,143.6883549\n", + "1981,1.709915638,0.513301014,5.646541256,5.141128191,1.284948561,176.5588753\n", + "1982,1.954343585,0.495419418,6.814057094,6.017321456,0.858130163,221.6735426\n", + "1983,2.081196249,0.522866314,6.32114426,6.947104072,0.778556797,223.427165\n", + "1984,2.117188855,0.65981906,6.23641653,7.349795764,1.155945373,245.1491683\n", + "1985,2.097376234,0.676313139,6.453219205,7.460563318,1.241863652,272.1632293\n", + "1986,2.109197118,0.634622463,6.626522658,7.78013674,0.817296612,295.5462238\n", + "1987,2.062576371,0.580341889,6.420274023,8.694447168,0.813391574,304.0866487\n", + "1988,1.986767119,0.536145374,6.071277702,9.897335684,0.981914646,309.6612693\n", + "1989,1.934614309,0.517255829,5.871206008,10.74713469,1.153375828,321.8665588\n", + "1990,1.958793742,0.433081035,5.605175294,11.41463185,1.210872502,325.129314\n", + "1991,1.895444339,0.435402301,4.883429398,11.3385033,1.459136041,299.3727791\n", + "1992,1.8616877,0.469454656,4.970466808,10.78880312,1.824550066,325.033736\n", + "1993,1.821753504,0.442785494,4.604350295,10.26882262,2.122980338,316.7194437\n", + "1994,1.696680257,0.518830327,4.215264675,9.57737764,2.635284079,308.084\n", + "1995,1.554090071,0.450891531,3.860245792,9.176903908,1.562615372,295.8530977\n", + "1996,1.403752581,0.476484778,3.554982206,8.615884471,1.882873103,287.9606687\n", + "1997,1.246243202,0.458095854,3.405562244,7.945140183,2.184061042,293.1678258\n", + "1998,1.256293902,0.450450487,3.201558499,7.748607984,2.263223453,290.9960551\n", + "1999,1.241703064,0.460988776,3.085676783,8.21077854,2.652912012,298.0948913\n", + "2000,1.11808088,0.44604782,3.112242147,8.299385231,3.031454509,320.0863242\n", + "2001,1.137368973,0.442657004,3.123809803,8.375571425,3.229469276,331.8056106\n", + "2002,1.120852292,0.421606002,3.447618099,8.495399281,3.172268734,378.4631388\n", + "2003,1.115878799,0.405916547,3.827161045,9.958245602,2.960496802,440.5320696\n", + "2004,1.107966027,0.364898723,4.016312736,11.33648983,2.854385965,492.9993762\n", + "2005,1.110669655,0.355958931,4.090034876,12.98813296,3.123454978,533.203\n", + "2006,1.125832408,0.311171936,4.041627237,14.8098928,3.035131019,558.335\n", + "2007,1.188901783,0.401163918,4.079655081,17.41713993,4.223037646,589.586\n", + "2008,1.248621382,0.390513227,4.463827356,19.3420584,4.334654124,656.756\n", + "2009,1.377555631,0.501556275,4.88559968,18.93622605,4.514233914,705.917\n", + "2010,1.194338338,0.452734493,4.922641677,19.31568883,4.789031339,738.005\n", + "2011,1.193291895,0.465777803,4.840173995,21.39372086,5.498458542,752.288\n", + "2012,1.118404598,0.475987281,4.477401219,20.45210711,5.717035575,725.205\n", + "2013,1.0023672,0.507919455,4.046678879,18.51573121,6.473144378,679.229\n", + "2014,0.989925299,0.513829957,3.69589465,17.85364048,6.758693845,647.789\n", + "2015,1.152709374,0.466676122,3.477845166,17.93764189,5.468837812,633.829639\n", + "2016,1.164161567,0.495064414,3.418942337,17.78277554,5.33687574,639.856443\n", + "2017,1.351602232,0.436510296,3.313381294,22.26969632,5.062076646,646.752927\n", + "2018,1.324681094,0.477517407,3.316248808,22.72932758,5.839521271,682.4914\n", + "2019,1.27894142,0.52348249,3.427080181,22.20440844,6.650808254,734.3441\n", + "2020,1.415055841,0.573651659,3.741160091,22.75484713,6.116376582,778.2322\n", + "'''\n", + "\n", + "from io import StringIO\n", + "\n", + "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", + "\n", + "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "markdown", + "id": "f26e1513", + "metadata": {}, + "source": [ + "## Bar graphs\n", + "\n", + "Bar graphs are a popular method to visualize categorical data. They're simple, concise, and can condense\n", + "large and complex datasets into a visual summary. Most bar graphs depict a categorical element as an\n", + "independent variable on the x-axis while the height of the bar corresponds to a numerical variable on the y-axis.\n", + "\n", + "We will practice making bar graphs using our military dataset in the context of an ordinal variable.\n", + "\n", + "First, let's create a graph to examine the percent of the GDP (Gross Domestic Product) spent on the military in Canada. We will look at the years 2018, 2019 and 2020.\n", + "\n", + "To do this, we must extract the data for the years of interest from the column containing the data pertaining to GDP percentage of military spending in Canada. We will call this `can_gdp`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "af3c0e6d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CAN-PercentGDP
Year
20181.324681
20191.278941
20201.415056
\n", + "
" + ], + "text/plain": [ + " CAN-PercentGDP\n", + "Year \n", + "2018 1.324681\n", + "2019 1.278941\n", + "2020 1.415056" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "can_gdp = military.loc[[2018, 2019, 2020], ['CAN-PercentGDP']]\n", + "\n", + "can_gdp" + ] + }, + { + "cell_type": "markdown", + "id": "62a27826-df76-4802-9414-f1a2b5931a96", + "metadata": {}, + "source": [ + "Next, we call `plt.bar()` to create a bar chart using this data. The `plt.bar()` function needs two arguments. The first argument, `x`, is an array of values to be plotted on the x-axis. \n", + "\n", + "The second argument, `height`, determines the height of the bars (the y-values). \n", + "\n", + "We will create a list of our years of interest and call it `year_labels` to input as the first argument and use the \"CAN-PercentGDP\" column of `can_gdp` as our second argument." + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "b2be1224", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD3CAYAAAAALt/WAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAASd0lEQVR4nO3cX2yT973H8U9sEzfF/CktWy9YOEtKulRchIAmVSiwIUWsRQjRbHLYlDBtE/ujrduaQVFHUpRlIYxOqpasvWBtaZG2BEW9aOhSTVnYImV/pEQkUzZTtMLJBKpWtoKG7cXB9e9ccOYen4Af4+CEL3m/ruLn8Z+f+VpvW8bPU+SccwIAmOWb7wUAAGaHkAOAcYQcAIwj5ABgHCEHAOMCc/2AY2NjCgaDc/2w8yKRSCyY53q3YGa2LKR5JRIJVVVV3XDfnIc8GAyqsrJyrh92XkQikQXzXO8WzMyWhTSvSCRy0318tQIAxhFyADCOkAOAcYQcAIwj5ABgHCEHAOMIOQAYR8gBwLicQj4+Pq6Ghoab7m9ubtZzzz132xYFAMidZ8iPHj2qAwcOKJFI3HB/d3e3zp49e9sXBmB+TF37YL6XkDNrR3UW6t/W8xD90tJSdXZ2at++fTP2nT59WuPj4wqHwzp37lxBFghgbt2zyK//2v/mfC/jrvTfHdsKcr+eId+6dasuXLgwY/t7772nrq4udXV1qb+/P+cHTCQSWc8ZcDeZmppaMM/1bsHM7H3KtaYQr6+8T5r11ltv6fLly9qzZ48uXbqkqakplZWV6Yknnsh6O06ahTsZM0Oh5fv6yvYGkHfIGxsb1djYKEl6/fXXde7cOc+IAwBuv1v++WFfX596enoKsRYAQB5y+kS+atUqnThxQpK0ffv2Gfv5JA4A84cDggDAOEIOAMYRcgAwjpADgHGEHACMI+QAYJypkFs6mY9k61Bna/+2AD6U95Gd84GT+RROoU7mA6DwTH0iBwDMRMgBwDhCDgDGEXIAMI6QA4BxhBwFZe1njfxkFBaZ+vkh7OEno4XDT0bxH3wiBwDjCDkAGEfIAcA4Qg4AxhFyADCOkAOAcYQcAIzLKeTj4+NqaGiYsf3kyZP63Oc+p/r6erW0tCiVSt32BQIAsvMM+dGjR3XgwAElEomM7VNTU3r++ef12muvqbu7W9FoVKdOnSrYQgEAN+Z5ZGdpaak6Ozu1b9++jO3FxcXq7u5WSUmJJCmZTCoYDHo+YCKRUCQSyWuxlg6ftijfuWTDzAqLmdlTiJl5hnzr1q26cOHCjO0+n08PPPCAJOn48eOKx+PauHGj5wMGg0FeKHco5mIPM7Mn35llewOY1blWUqmUjhw5ovPnz6uzs1NFRUWzuTsAQB5mFfKWlhYVFxfrhRdekM/HD2AAYD7ccsj7+voUj8e1du1a9fb2asOGDdq9e7ckqbGxUbW1tbd9kQCAm8sp5KtWrdKJEyckSdu3b09vP3PmTGFWBQDIGd+HAIBxhBwAjCPkAGAcIQcA4wg5ABhHyAHAOEIOAMYRcgAwjpADgHGEHACMI+QAYBwhBwDjCDkAGEfIAcA4Qg4AxhFyADCOkAOAcYQcAIwj5ABgHCEHAOMIOQAYl1PIx8fH1dDQMGP74OCg6urqFA6HdeLEidu+OACAt4DXFY4ePao33nhDJSUlGduvXbumQ4cOqbe3VyUlJdq1a5c+/elPa+XKlQVbLABgJs+Ql5aWqrOzU/v27cvY/s4776i0tFTLli2TJK1fv14jIyN67LHHst5fIpFQJBLJa7GVlZV53Q65yXcu2TCzwmJm9hRiZp4h37p1qy5cuDBjezQa1ZIlS9KXFy9erGg06vmAwWCQF8odirnYw8zsyXdm2d4A8v7PzlAopFgslr4ci8Uywg4AmBt5h7y8vFyTk5O6cuWKpqenNTIyonXr1t3OtQEAcuD51cr/19fXp3g8rnA4rP379+vLX/6ynHOqq6vTRz/60UKsEQCQRU4hX7VqVfrnhdu3b09v37Jli7Zs2VKYlQEAcsIBQQBgHCEHAOMIOQAYR8gBwDhCDgDGEXIAMI6QA4BxhBwAjCPkAGAcIQcA4wg5ABhHyAHAOEIOAMYRcgAwjpADgHGEHACMI+QAYBwhBwDjCDkAGEfIAcA4Qg4AxnmGPJVKqaWlReFwWA0NDZqcnMzY/8Ybb2jnzp2qq6vTz3/+84ItFABwYwGvKwwMDGh6elo9PT0aGxtTR0eHXnzxxfT+H/3oRzp58qTuvfdebdu2Tdu2bdOyZcsKumgAwIc8Qz46OqqamhpJUlVVlSYmJjL2P/zww7p69aoCgYCccyoqKirMSgEAN+QZ8mg0qlAolL7s9/uVTCYVCFy/6Zo1a1RXV6eSkhLV1tZq6dKlWe8vkUgoEonktdjKysq8bofc5DuXbJhZYTEzewoxM8+Qh0IhxWKx9OVUKpWO+JkzZ/Sb3/xGv/71r3Xvvfdq79696u/v12OPPXbT+wsGg7xQ7lDMxR5mZk++M8v2BuD5n53V1dUaGhqSJI2NjamioiK9b8mSJbrnnnsUDAbl9/u1YsUK/etf/8prkQCA/Hh+Iq+trdXw8LDq6+vlnFN7e7v6+voUj8cVDocVDof1+c9/XosWLVJpaal27tw5F+sGAPwvz5D7fD61trZmbCsvL0//vWvXLu3atev2rwwAkBMOCAIA4wg5ABhHyAHAOEIOAMYRcgAwjpADgHGEHACMI+QAYBwhBwDjCDkAGEfIAcA4Qg4AxhFyADCOkAOAcYQcAIwj5ABgHCEHAOMIOQAYR8gBwDhCDgDGEXIAMC7gdYVUKqWDBw/q7bffVnFxsdra2rR69er0/j/96U/q6OiQc04rV67UkSNHFAwGC7poAMCHPD+RDwwMaHp6Wj09PWpqalJHR0d6n3NOzc3NOnTokH7xi1+opqZGFy9eLOiCAQCZPD+Rj46OqqamRpJUVVWliYmJ9L7z589r+fLlevXVV3X27Flt3rxZZWVlhVstAGAGz5BHo1GFQqH0Zb/fr2QyqUAgoMuXL+v06dNqbm7W6tWr9bWvfU1r167Vo48+etP7SyQSikQieS22srIyr9shN/nOJRtmVljMzJ5CzMwz5KFQSLFYLH05lUopELh+s+XLl2v16tV66KGHJEk1NTWamJjIGvJgMMgL5Q7FXOxhZvbkO7NsbwCe35FXV1draGhIkjQ2NqaKior0vo997GOKxWKanJyUJI2MjGjNmjV5LRIAkB/PT+S1tbUaHh5WfX29nHNqb29XX1+f4vG4wuGwfvjDH6qpqUnOOa1bt06f+tSn5mDZAID/8Ay5z+dTa2trxrby8vL0348++qh6e3tv/8oAADnhgCAAMI6QA4BxhBwAjCPkAGAcIQcA4wg5ABhHyAHAOEIOAMYRcgAwjpADgHGEHACMI+QAYBwhBwDjCDkAGEfIAcA4Qg4AxhFyADCOkAOAcYQcAIwj5ABgHCEHAOMIOQAY5xnyVCqllpYWhcNhNTQ0aHJy8obXa25u1nPPPXfbFwgAyM4z5AMDA5qenlZPT4+amprU0dEx4zrd3d06e/ZsQRYIAMgu4HWF0dFR1dTUSJKqqqo0MTGRsf/06dMaHx9XOBzWuXPnPB8wkUgoEonktdjKysq8bofc5DuXbJhZYTEzewoxM8+QR6NRhUKh9GW/369kMqlAIKD33ntPXV1d6urqUn9/f04PGAwGeaHcoZiLPczMnnxnlu0NwDPkoVBIsVgsfTmVSikQuH6zt956S5cvX9aePXt06dIlTU1NqaysTE888UReCwUA3DrPkFdXV+vUqVN6/PHHNTY2poqKivS+xsZGNTY2SpJef/11nTt3jogDwBzzDHltba2Gh4dVX18v55za29vV19eneDyucDg8F2sEAGThGXKfz6fW1taMbeXl5TOuxydxAJgfHBAEAMYRcgAwjpADgHGEHACMI+QAYBwhBwDjCDkAGEfIAcA4Qg4AxhFyADCOkAOAcYQcAIwj5ABgHCEHAOMIOQAYR8gBwDhCDgDGEXIAMI6QA4BxhBwAjCPkAGBcwOsKqVRKBw8e1Ntvv63i4mK1tbVp9erV6f0nT57Uq6++Kr/fr4qKCh08eFA+H+8PADBXPIs7MDCg6elp9fT0qKmpSR0dHel9U1NTev755/Xaa6+pu7tb0WhUp06dKuiCAQCZPEM+OjqqmpoaSVJVVZUmJibS+4qLi9Xd3a2SkhJJUjKZVDAYLNBSAQA34vnVSjQaVSgUSl/2+/1KJpMKBALy+Xx64IEHJEnHjx9XPB7Xxo0bs95fIpFQJBLJa7GVlZV53Q65yXcu2TCzwmJm9hRiZp4hD4VCisVi6cupVEqBQCDj8pEjR3T+/Hl1dnaqqKgo6/0Fg0FeKHco5mIPM7Mn35llewPw/GqlurpaQ0NDkqSxsTFVVFRk7G9paVEikdALL7yQ/ooFADB3PD+R19bWanh4WPX19XLOqb29XX19fYrH41q7dq16e3u1YcMG7d69W5LU2Nio2tragi8cAHCdZ8h9Pp9aW1sztpWXl6f/PnPmzO1fFQAgZ/zgGwCMI+QAYBwhBwDjCDkAGEfIAcA4Qg4AxhFyADCOkAOAcYQcAIwj5ABgHCEHAOMIOQAYR8gBwDhCDgDGEXIAMI6QA4BxhBwAjCPkAGAcIQcA4wg5ABhHyAHAOM+Qp1IptbS0KBwOq6GhQZOTkxn7BwcHVVdXp3A4rBMnThRsoQCAG/MM+cDAgKanp9XT06OmpiZ1dHSk9127dk2HDh3Syy+/rOPHj6unp0eXLl0q6IIBAJk8Qz46OqqamhpJUlVVlSYmJtL73nnnHZWWlmrZsmUqLi7W+vXrNTIyUrjVAgBmCHhdIRqNKhQKpS/7/X4lk0kFAgFFo1EtWbIkvW/x4sWKRqNZ7y+RSCgSieS94P7dZXnfFjc3m5l4YWaFwczsmc3MEonETfd5hjwUCikWi6Uvp1IpBQKBG+6LxWIZYb+Rqqoqr4cEANwCz69WqqurNTQ0JEkaGxtTRUVFel95ebkmJyd15coVTU9Pa2RkROvWrSvcagEAMxQ551y2K6RSKR08eFBnz56Vc07t7e36y1/+ong8rnA4rMHBQf30pz+Vc051dXX6whe+MFdrBwAoh5ADAO5sHBAEAMYRcgAwjpADgHGePz9EpmvXrumZZ57RxYsXNT09ra9//et66KGHtH//fhUVFWnNmjV69tln5fNdf498//33VV9fr76+PgWDQV29elXf/e539e9//1uLFi3SkSNHtHLlynl+Vne32c7sypUr2rt3r6LRqJYvX662tjbdf//98/ys7l63Mq9jx47pzTfflCRt3rxZ3/zmNzU1NaW9e/fqn//8pxYvXqzDhw9rxYoV8/ysCszhlvT29rq2tjbnnHPvv/++27x5s/vqV7/q/vCHPzjnnGtubna/+tWvnHPODQ0NuR07drh169a5qakp55xzx44dc4cPH3bOOdfT0+MOHTo0D89iYZntzDo6OtyLL77onHNueHjYPfPMM/PwLBaOXOf1t7/9ze3cudMlk0n3wQcfuHA47CKRiHv55ZfdT37yE+eccydPnnQ/+MEP5u25zBW+WrlFn/nMZ/Ttb387fdnv9+vPf/6zPvnJT0qSNm3apN/97neSJJ/Pp1deeUXLly9PX7+ioiJ9EFU0Gk0fXIXCme3M/vrXv2rTpk2Srh9XMTo6OneLX4ByndeDDz6on/3sZ/L7/fL5fEomkwoGgxmnFdm0aZN+//vfz8vzmEuE/BYtXrxYoVBI0WhUTz75pL7zne/IOaeioqL0/qtXr0qSNm7cqPvuuy/j9vfdd5+Gh4f1+OOP66WXXtJnP/vZOX8OC81sZ1ZZWanBwUFJ18/2OTU1NbdPYIHJdV6LFi3SihUr5JzT4cOH9cgjj+jjH/94xqlD/u9s72aEPA/vvvuuGhsbtWPHDm3fvj393ap0/TQFS5cuveltu7q69JWvfEW//OUv9dJLL+lb3/rWXCx5wZvNzPbs2aOLFy/qi1/8ot599109+OCDc7HkBS3XeSUSCX3ve99TLBbTs88+Kynz1CFes71bEPJb9I9//ENf+tKXtHfv3vSn6UceeUR//OMfJUlDQ0PasGHDTW+/dOnS9KeF+++/P+NcNSiM2c5sZGREO3bs0LFjx7Rq1SpVV1fPyboXqlzn5ZzTN77xDT388MNqbW2V3++XdP3rr9/+9rfp665fv35+nsgc4sjOW9TW1qb+/n6VlX14drjvf//7amtr07Vr11RWVqa2trb0i0qStmzZov7+fgWDQf3973/XgQMHFI/HlUwm9eSTT2rjxo3z8VQWjNnObHJyUk8//bQk6SMf+Yja29szzgiK2yvXeQ0ODuqpp57KOBHfU089pU984hN6+umndenSJS1atEg//vGP7/pfhhFyADCOr1YAwDhCDgDGEXIAMI6QA4BxhBwAjCPkAGAcIQcA4/4H4jYYTfYaowAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "year_labels = ['2018', '2019', '2020']\n", + "plt.bar(year_labels, can_gdp[\"CAN-PercentGDP\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5748baf9", + "metadata": {}, + "source": [ + "The above code produced a plot, but this plot needs more descriptive labeling to help others understand the data. \n", + "\n", + "We need to add axis labels and a title to communicate what is being measured. Aesthetically, we can also reduce the width of each bar to give more room on the graph and more rest for our eyes." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "b66c30a8-e66a-4ad1-b6c5-cbe53ee5eef9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(year_labels, can_gdp[\"CAN-PercentGDP\"], width=0.25)\n", + "\n", + "\n", + "plt.title('Military Spending in Canada')\n", + "\n", + "plt.ylabel('Percentage of GDP')\n", + "plt.xlabel('Year')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "18931cc9", + "metadata": {}, + "source": [ + "This plot looks better and is a lot more descriptive.\n", + "\n", + "Let's add the data from Mexico and the United States.\n", + "\n", + "To do this, we use the `plt.subplots()` function. This function creates a `figure` object and an `axis` object, which we will name `fig` and `ax`, respectively. More information on the workings of `plt.subplots()` is linked at the end of this section.\n", + "\n", + "Using this function, we can add data for Canada, Mexico and the United States to the same plot, within the boundaries of the same axes. We do this by calling `ax.bar()`. Note that we want to group our bars by year. To do this we'll set precise positions on the x-axis.\n", + "\n", + "We will also use `plt.tight_layout()` to automatically adjust the subplot dimensions to give appropriate spacing between the bars and the axes boundaries." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "6833fd5b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "can_gdp = military.loc[[2018, 2019, 2020], ['CAN-PercentGDP']]\n", + "mex_gdp = military.loc[[2018, 2019, 2020], ['MEX-PercentGDP']]\n", + "usa_gdp = military.loc[[2018, 2019, 2020], ['USA-PercentGDP']]\n", + "\n", + "index = np.arange(len(year_labels))\n", + "\n", + "(fig, ax) = plt.subplots()\n", + "\n", + "ax.bar(index - 0.25, can_gdp[\"CAN-PercentGDP\"], width=0.25)\n", + "\n", + "ax.bar(index, mex_gdp[\"MEX-PercentGDP\"], width=0.25)\n", + "\n", + "ax.bar(index + 0.25, usa_gdp[\"USA-PercentGDP\"], width=0.25)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "21c5b1b1", + "metadata": {}, + "source": [ + "We were able to create a bar plot with all three data sets together. Now, let's add the appropriate titles, axis labels, and other details.\n", + "\n", + "To add a title to the entire graph, we can call the `plt.title()` function, just as we did before.\n", + "\n", + "In a subplot, to add axis labels, we have to use the `set_xlabel()` and `set_ylabel()` methods on the axis object, here `ax`.\n", + "\n", + "We can also label each individual bar with the associated numerical value by calling the `bar_label()` method on `ax`. In order to label the bars, the label must be specified when creating each each bar.\n", + "\n", + "The location of the legend within the subplot will be set using `ax.legend()`. The y-axis limits are set using `plt.ylim()`." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "61bdf283", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(fig, ax) = plt.subplots()\n", + "\n", + "# round(decimals=2): rounds to 2 places after decimal\n", + "\n", + "can_bar = ax.bar(index - 0.25, can_gdp[\"CAN-PercentGDP\"].round(decimals=2), width=0.25, label='Canada') \n", + "mex_bar = ax.bar(index, mex_gdp[\"MEX-PercentGDP\"].round(decimals=2), width=0.25, label='Mexico')\n", + "usa_bar = ax.bar(index + 0.25, usa_gdp[\"USA-PercentGDP\"].round(decimals=2), width=0.25, label='USA')\n", + "\n", + "# Add labels, title, custom x-axis tick labels, etc.\n", + "\n", + "plt.title(\"Military Spending in North America\", pad=10)\n", + "\n", + "ax.set_ylabel('Percentage of GDP')\n", + "ax.set_xlabel('Year')\n", + "\n", + "ax.set_xticks(index, year_labels)\n", + "\n", + "ax.bar_label(can_bar, label_type=\"edge\", padding=4)\n", + "ax.bar_label(mex_bar, label_type=\"edge\", padding=4)\n", + "ax.bar_label(usa_bar, label_type=\"edge\", padding=4)\n", + "\n", + "ax.legend(loc=4, bbox_to_anchor=(1.3, 0.5))\n", + "\n", + "plt.ylim(0, 5)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c0a52a3c", + "metadata": {}, + "source": [ + "Great! Now we have a well annotated, visually appealing graph that depicts an important message about the data: the percentage of the GDP spent on the military for each country for the years 2018-2020.\n", + "\n", + "From this graph, we can easily see that during this time period, Canada and Mexico contribute a smaller proportion of their GDP to military spending than the United States. This may not have been easily discernable by just looking at our large data table." + ] + }, + { + "cell_type": "markdown", + "id": "fbb08191", + "metadata": {}, + "source": [ + "## Box and whisker plots\n", + "\n", + "Box and whisker plots are another visualization method for displaying categorical data that is often used in the social sciences and biological sciences.\n", + "\n", + "Box and whisker plots are a useful data visualization method because they intrinsically display multiple summary statistics simultaneously. The central line of each box within a box and whisker plot is the *median*. The median (also known as the second quartile, $Q_2$) is a value within a dataset that lies within the middle, separating the higher half and the lower half of the dataset. The median is a valuable measure of center for a distribution because it is not greatly affected by outliers, as opposed to the *mean*.\n", + "\n", + "Box and whisker plots also show the *lower quartile*, *the upper quartile*, the *interquartile range*, *outliers*, the *minimum*, and the *maximum*. The lower quartile $\\left( Q_1\\right)$ is the value where the lowest 25% of the data points within a distribution lie. It is represented by the lower end of the box. \n", + "\n", + "On the other side, the upper quartile $\\left( Q_3\\right)$ is the value in which the highest 25% of the data resides. It is represented by the higher end of a box.\n", + "\n", + "\n", + "The interquartile range (IQR), is the difference between the upper quartile and the lower quartile. The IQR is used to make the length of a box and is represented by the equation:\n", + "\n", + " > $IQR=Q_3-Q_1$\n", + " \n", + "\n", + "Outliers are data points that are less than $Q_1-1.5×IQR$ or greater than $Q_3+1.5×IQR$. These data points are shown beyond the extremity of the whiskers.\n", + "\n", + "Lastly, the minimum and maximum values are represented by the lowest and highest values, respectively, that are within the range $Q_1-1.5×IQR$ and $Q_3+1.5×IQR$. Essentially, they are the lowest and highest values that do not qualify as outliers. The lower whisker represents the minimum value, while the upper whisker represents the maximum value.\n", + "\n", + "Below is a pictorial summary of the major components of a box and whisker plot with an accompanying set of numbers, *A*:\n", + "\n", + "![](./img/boxandwhisker.png)" + ] + }, + { + "cell_type": "markdown", + "id": "d4da5c77", + "metadata": {}, + "source": [ + "We will use a box and whisker plot to examine the percentage GDP spending on the military for each country in the '60s as a way to examine nominal data.\n", + "\n", + "First, we extract the data of interest:" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "76dfd2bc", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CAN-PercentGDPMEX-PercentGDPUSA-PercentGDP
Year
19604.1852570.6735098.993125
19614.1283120.6517809.156031
19623.9992160.6896559.331673
19633.6206500.7186868.831891
19643.4020630.6775078.051281
19652.9302610.5912707.587247
19662.6832820.5763798.435300
19672.7479270.5452179.417796
19682.5436420.5485119.268454
19692.2737850.6001608.633264
\n", + "
" + ], + "text/plain": [ + " CAN-PercentGDP MEX-PercentGDP USA-PercentGDP\n", + "Year \n", + "1960 4.185257 0.673509 8.993125\n", + "1961 4.128312 0.651780 9.156031\n", + "1962 3.999216 0.689655 9.331673\n", + "1963 3.620650 0.718686 8.831891\n", + "1964 3.402063 0.677507 8.051281\n", + "1965 2.930261 0.591270 7.587247\n", + "1966 2.683282 0.576379 8.435300\n", + "1967 2.747927 0.545217 9.417796\n", + "1968 2.543642 0.548511 9.268454\n", + "1969 2.273785 0.600160 8.633264" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "the60s = military.loc[1960:1969, ['CAN-PercentGDP', 'MEX-PercentGDP', 'USA-PercentGDP']]\n", + "\n", + "the60s" + ] + }, + { + "cell_type": "markdown", + "id": "c3849183", + "metadata": {}, + "source": [ + "Next, let's plot the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "2f74054c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.boxplot(the60s);" + ] + }, + { + "cell_type": "markdown", + "id": "1bf41ad3", + "metadata": {}, + "source": [ + "If we plot this dataframe, the bare minimum graph plots the data within the columns of interest, but doesn't automatically use the column names as categorical indicators on the x-axis. This doesn't allow for easy interpretation of the data. \n", + "\n", + "Furthermore, while the current plot does the job of displaying the median and interquartile range, adding individual data points will allow for viewers to more easily see the spread of the data. The addition of axis labels, a title, and some color will also enhance this plot and make it more aesthetically pleasing. \n", + "\n", + "We can accomplish this using a combination of functions from `matplotlib` and `seaborn`:" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "948bde16", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.boxplot(data=the60s, palette=\"Set2\", linewidth=1)\n", + "ax = sns.swarmplot(data=the60s, palette=\"Set2\", linewidth=0.5, edgecolor = \"black\")\n", + "plt.xticks(ticks = [0,1,2], labels = ['Canada', 'Mexico', 'United States'])\n", + "plt.ylabel(\"Percent of GDP\")\n", + "plt.title(\"% GDP spent on the military in North America from 1960-1969\")\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a21d621d", + "metadata": {}, + "source": [ + "Now that we have proper labeling, we can see the median, upper quartile, and lower quartile of the percentage of the each country's GDP spent on the military. A noticeable observation this plot shows is that Mexico not only spent a small percentage of their GDP on the military (less than 2%), but the percentage of spending during this decade had very little variability. This makes it hard to see what the median, upper quartile, and lower quartile are for Mexico. The issue of being able to visually resolve displays of data is a common one that data scientists encounter. In the next section, we will offer one potential solution for this." + ] + }, + { + "cell_type": "markdown", + "id": "d28b66ff", + "metadata": {}, + "source": [ + "## Pie charts\n", + "\n", + "Pie charts are a commonly used visualization method to represent proportions in datasets. Pie charts use *wedges* to represent the numerical value of a proportion corresponding to a categorial variable.\n", + "\n", + "While pie charts are very common and can be easily interpreted by a layperson audience, they may not be the best way to represent data in certain cases. Firstly, because pie charts use the area of a circle to represent the proportion of a categorical variable, it can be difficult to gauge the numerical value that a wedge represents if the area doesn't appear as an easily discernible fraction (_e.g._ ½, ⅓, ¼). This can be aided with the help of labels and legends that explicitly show the numerical values associated with the wedges of the pie chart. Secondly, if you want to visualize many categorical variables or variables that make up a significantly small proportion of the dataset, it may be difficult to see the variable on a pie chart. Overall, pie charts can be a simple and effective way to communicate proportional categorical data, but before using them, consider what attributes of the data need to be highlighted to help decide if a pie chart is the most appropriate visualization method. \n", + "\n", + "Now, let's look at the total amount of money spent on the military in the entire North American continent for the year of 2000 and determine what proportion of this total amount came from each country. Because we are looking at a single year (2000), a pie chart is a good way to visualize the proportions of military spending contributed by each country. To do this, we will extract data for the year 2000; we'll call it `usd_2000`. Then, we will make a pie chart using the `plt.pie()` function. We will use `usd_2000` to determine the wedge sizes and the argument `normalize=True` to normalize the data to 1. We'll also set the figure size, in inches, using `plt.figure()`." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "90158219", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CAN-USD 8.299385\n", + "MEX-USD 3.031455\n", + "USA-USD 320.086324\n", + "Name: 2000, dtype: float64" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "usd_2000 = military.loc[2000, ['CAN-USD', 'MEX-USD', 'USA-USD']]\n", + "\n", + "usd_2000" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "cdde5f79-2c19-49e8-b883-0e3121fccb57", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 6))\n", + "\n", + "plt.pie(usd_2000, normalize=True);" + ] + }, + { + "cell_type": "markdown", + "id": "7e7cc03f", + "metadata": {}, + "source": [ + "Now that we have a pie chart, let's add some more detail to it to make it more descriptive.\n", + "\n", + "We can label the sectors of the chart so that we know which country corresponds to which color. Likewise, we can label the percentage of each sector to know the definitive proportion of each country's contribution to the total amount of money spent on the military in North America.\n", + "\n", + "To do this, we will create a list called `countries`, containing the strings \"Canada\", \"Mexico\", and \"USA\". We then assign the `labels` argument within `plt.pie()` to `countries` and add the `autopct` argument, which labels the wedges using the printf style format. More information on that format is linked at the end of this section." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "a4f10620", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 6))\n", + "\n", + "countries = ['Canada', 'Mexico', 'USA']\n", + "\n", + "plt.pie(usd_2000, normalize=True, labels=countries, autopct='%.1f')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0d8962d3", + "metadata": {}, + "source": [ + "This plot is okay, but it can be better.\n", + "\n", + "Because the sectors of Mexico and Canada are a lot smaller than the sector for the United States, overlaying the percentages on top of the sector creates spatial issues that can be visually displeasing. Instead, let's add the percentages into a legend along with the labels of each sector. Let's also add a title so others can know what they are looking at when they view this chart." + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "d09a15ca", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 6))\n", + "\n", + "\n", + "patches, text = plt.pie(usd_2000, normalize = True)\n", + "labels = ['Canada (2.8 %)', 'Mexico (0.9 %)', 'USA (96.4 %)']\n", + "total = usd_2000.sum().round(decimals=1) #finds the sum of usd_2000 and rounds it to 1 position after the decimal\n", + "\n", + "plt.legend(patches, labels, loc=4, bbox_to_anchor=(0.8, -0.2), fontsize=15)\n", + "plt.title(\"Military Spending in North America in 2000\" + \" (\" + str(total) + \" Billion USD)\", loc = 'center',\n", + " fontsize = 15)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9c5fa589", + "metadata": {}, + "source": [ + "Above, we used `plt.pie()` in a way that we had not used it before.\n", + "\n", + "Under the hood, the `plt.pie()` function returns two default outputs, which we named: `patches` and`text`. `patches` is an object that dictates the size of each wedge. `text` consists of a list of labels for our data. Here, we needed to specifically assign `patches` and `text` objects so we could use `patches` as an argument for the `plt.legend()` function. \n", + "\n", + "The `plt.legend()` function has two required arguments. The first argument dictates **what** is being labeled. In our case, the wedges of the pie chart (*i.e.* the `patches` object) are being labeled. The second argument dictates **how** things are labeled. Here, we simply created a variable called labels, which consists of the three strings:" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "d430985c-cfee-49e0-ae4d-4fc69e193f36", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Canada (2.8 %)', 'Mexico (0.9 %)', 'USA (96.4 %)']" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels" + ] + }, + { + "cell_type": "markdown", + "id": "ee88547d-89be-493c-b49d-64fbfb03bb72", + "metadata": {}, + "source": [ + "The other arguments, `bbox_to_anchor` and `fontsize`, are optional when using the `plt.legend()` function.\n", + "\n", + "The argument `bbox_to_anchor` designates the position in the plotting area where the legend will be, while the `fontsize` argument dictates the font size, in points, of the legend text." + ] + }, + { + "cell_type": "markdown", + "id": "e64c6b88", + "metadata": {}, + "source": [ + "## Conclusions\n", + "\n", + "In this section, we were introduced to the `plt.bar()` and `plt.pie()` functions to construct bar plots and pie charts, respectively.\n", + "\n", + "The `plt.bar()` function requires `x` and `height` arguments, which can be an array of number values, but other parameters can be included.\n", + "\n", + "The use of the `plt.boxplot()` function allows us to make a basic box and whisker plot, but does not offer preferred labeling and coloring by default. The `sns.boxplot()` and `sns.swarmplot()` functions are good alternatives that have more customization and flexibility.\n", + "\n", + "The `plt.pie()` function only requires an `x` argument as an array of values and has other arguments that can be included as well.\n", + "\n", + "Both of these types of visualizations are used for depicting categorical data.\n", + "\n", + "As a reminder, when deciding on whether to use a pie chart, consider certain attributes of the data, such as the number of categorical variables or the size of the proportions to be plotted. Below is a list of functions with linked documentation for your reference and further reading:\n", + "\n", + "- plt.bar( )\n", + "- plt.pie( )\n", + "- plt.boxplot( ) \n", + "- plt.subplots( )\n", + "- plt.title( )\n", + "- plt.ylim( )\n", + "- plt.xlim( )\n", + "- plt.ylabel( )\n", + "- plt.xlabel( )\n", + "- plt.xticks( )\n", + "- ax.bar( )\n", + "- ax.legend( )\n", + "- plt.tight_layout( )\n", + "- plt.figure( )\n", + "- plt.show( )\n", + "- sns.boxplot( )\n", + "- sns.swarmplot( )\n", + "- Formatted String Literals" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "253ed247", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/textbook/09/2/Numerical_Data.ipynb b/textbook/09/2/Numerical_Data.ipynb deleted file mode 100644 index f7e3fa47..00000000 --- a/textbook/09/2/Numerical_Data.ipynb +++ /dev/null @@ -1,1234 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "0fb30d10", - "metadata": {}, - "source": [ - "# Numerical Data\n", - "\n", - "Numerical data consists of *discrete* and *continuous* number values. Discrete data values can be integers or rational numbers, such as the number of marbles in a jar or shoe sizes. Continuous data values can be rational and irrational numbers, such as height recordings or temperature collections. In this section, we will practice making histograms, scatter plots, and line graphs to represent numerical data.\n", - "\n", - "Let's load the necessary libraries and read in the data." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3e479dc7-ce8e-4ca7-ae35-79038cf4bf99", - "metadata": { - "tags": [ - "hide_cell" - ] - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "\n", - "from matplotlib import pyplot as plt\n", - "plt.style.use('fivethirtyeight')\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_csv = '''\\\n", - "Year,CAN-PercentGDP,MEX-PercentGDP,USA-PercentGDP,CAN-USD,MEX-USD,USA-USD\n", - "1960,4.18525654,0.673508659,8.993124587,1.702442711,0.084,47.34655267\n", - "1961,4.128312243,0.651780326,9.1560315,1.677820881,0.0864,49.87977061\n", - "1962,3.999216389,0.689655172,9.331672945,1.671313753,0.0992,54.65094261\n", - "1963,3.620650112,0.718685832,8.831891186,1.610091701,0.112,54.56121578\n", - "1964,3.402062837,0.677506775,8.051281106,1.657457283,0.12,53.43232706\n", - "1965,2.930260659,0.591269841,7.587247177,1.57470454,0.1192,54.56179126\n", - "1966,2.683282422,0.576379066,8.435300286,1.614422827,0.1304,66.44275153\n", - "1967,2.74792677,0.545217107,9.417795933,1.775500366,0.1336,78.39844224\n", - "1968,2.54364188,0.548510764,9.268454275,1.797265817,0.1488,84.32903122\n", - "1969,2.27378467,0.600160043,8.633263795,1.770108751,0.18,84.99016543\n", - "1970,2.188979696,0.497411659,8.032743584,1.889157918,0.1768,83.407993\n", - "1971,2.131485639,0.48765558,6.943069609,2.077659711,0.1912,78.23797989\n", - "1972,2.011818438,0.536568089,6.519756924,2.233737031,0.2424,80.70807097\n", - "1973,1.832601818,0.544217687,5.893870591,2.363060955,0.3008,81.46979441\n", - "1974,1.783813085,0.565744137,5.954111197,2.809465529,0.4072,89.27892034\n", - "1975,1.863541853,0.57358422,5.622679096,3.18091549,0.5048,92.08092875\n", - "1976,1.765927978,0.598103574,5.191071429,3.581805735,0.531576968,94.71525108\n", - "1977,1.8057636,0.534256205,5.155617351,3.752174526,0.437692986,104.665219\n", - "1978,1.848887401,0.504834431,4.943087248,3.969158477,0.518287193,113.3820637\n", - "1979,1.711245918,0.505297474,4.951991535,4.084145738,0.679663588,126.8799271\n", - "1980,1.764448615,0.416107383,5.153537467,4.744402251,0.810422204,143.6883549\n", - "1981,1.709915638,0.513301014,5.646541256,5.141128191,1.284948561,176.5588753\n", - "1982,1.954343585,0.495419418,6.814057094,6.017321456,0.858130163,221.6735426\n", - "1983,2.081196249,0.522866314,6.32114426,6.947104072,0.778556797,223.427165\n", - "1984,2.117188855,0.65981906,6.23641653,7.349795764,1.155945373,245.1491683\n", - "1985,2.097376234,0.676313139,6.453219205,7.460563318,1.241863652,272.1632293\n", - "1986,2.109197118,0.634622463,6.626522658,7.78013674,0.817296612,295.5462238\n", - "1987,2.062576371,0.580341889,6.420274023,8.694447168,0.813391574,304.0866487\n", - "1988,1.986767119,0.536145374,6.071277702,9.897335684,0.981914646,309.6612693\n", - "1989,1.934614309,0.517255829,5.871206008,10.74713469,1.153375828,321.8665588\n", - "1990,1.958793742,0.433081035,5.605175294,11.41463185,1.210872502,325.129314\n", - "1991,1.895444339,0.435402301,4.883429398,11.3385033,1.459136041,299.3727791\n", - "1992,1.8616877,0.469454656,4.970466808,10.78880312,1.824550066,325.033736\n", - "1993,1.821753504,0.442785494,4.604350295,10.26882262,2.122980338,316.7194437\n", - "1994,1.696680257,0.518830327,4.215264675,9.57737764,2.635284079,308.084\n", - "1995,1.554090071,0.450891531,3.860245792,9.176903908,1.562615372,295.8530977\n", - "1996,1.403752581,0.476484778,3.554982206,8.615884471,1.882873103,287.9606687\n", - "1997,1.246243202,0.458095854,3.405562244,7.945140183,2.184061042,293.1678258\n", - "1998,1.256293902,0.450450487,3.201558499,7.748607984,2.263223453,290.9960551\n", - "1999,1.241703064,0.460988776,3.085676783,8.21077854,2.652912012,298.0948913\n", - "2000,1.11808088,0.44604782,3.112242147,8.299385231,3.031454509,320.0863242\n", - "2001,1.137368973,0.442657004,3.123809803,8.375571425,3.229469276,331.8056106\n", - "2002,1.120852292,0.421606002,3.447618099,8.495399281,3.172268734,378.4631388\n", - "2003,1.115878799,0.405916547,3.827161045,9.958245602,2.960496802,440.5320696\n", - "2004,1.107966027,0.364898723,4.016312736,11.33648983,2.854385965,492.9993762\n", - "2005,1.110669655,0.355958931,4.090034876,12.98813296,3.123454978,533.203\n", - "2006,1.125832408,0.311171936,4.041627237,14.8098928,3.035131019,558.335\n", - "2007,1.188901783,0.401163918,4.079655081,17.41713993,4.223037646,589.586\n", - "2008,1.248621382,0.390513227,4.463827356,19.3420584,4.334654124,656.756\n", - "2009,1.377555631,0.501556275,4.88559968,18.93622605,4.514233914,705.917\n", - "2010,1.194338338,0.452734493,4.922641677,19.31568883,4.789031339,738.005\n", - "2011,1.193291895,0.465777803,4.840173995,21.39372086,5.498458542,752.288\n", - "2012,1.118404598,0.475987281,4.477401219,20.45210711,5.717035575,725.205\n", - "2013,1.0023672,0.507919455,4.046678879,18.51573121,6.473144378,679.229\n", - "2014,0.989925299,0.513829957,3.69589465,17.85364048,6.758693845,647.789\n", - "2015,1.152709374,0.466676122,3.477845166,17.93764189,5.468837812,633.829639\n", - "2016,1.164161567,0.495064414,3.418942337,17.78277554,5.33687574,639.856443\n", - "2017,1.351602232,0.436510296,3.313381294,22.26969632,5.062076646,646.752927\n", - "2018,1.324681094,0.477517407,3.316248808,22.72932758,5.839521271,682.4914\n", - "2019,1.27894142,0.52348249,3.427080181,22.20440844,6.650808254,734.3441\n", - "2020,1.415055841,0.573651659,3.741160091,22.75484713,6.116376582,778.2322\n", - "'''\n", - "\n", - "from io import StringIO\n", - "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", - "\n", - "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')" - ] - }, - { - "cell_type": "markdown", - "id": "1af7e1d3", - "metadata": {}, - "source": [ - "## Scatter plots\n", - "\n", - "Scatter plots can be used to visualize the relationship between two numerical variables. They are most commonly used to visualize two continous numerical variables against each other (in other words, the data takes on values that are between whole number integers). These plots can also be used when data takes on a large number of different discrete integers. We will use a scatter plot to visualize the percentage of the GDP (Gross Domestic Product) of Mexico spent on the military versus the absolute dollar amount (in USD) over 1960-2020.\n", - "\n", - "We'll simply extract the columns for this data and assign them to `mex_gdp` and `mex_usd`, respectively. Then, we can plot this data using the `plt.scatter()` function and use `plt.show()` to display the plot." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "deb40aae", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mex_gdp = military[['MEX-USD']]\n", - "\n", - "mex_usd = military[['MEX-PercentGDP']]\n", - "\n", - "plt.scatter(mex_gdp, mex_usd) # mex_gdp on the x-axis, mex_usd on the y-axis\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "4fba0f1f", - "metadata": {}, - "source": [ - "Looking at this scatter plot out of context, it would be hard to understand what the data means. Let's add some important details to make it clear.\n", - "\n", - "Firstly, we can add a title using the `plt.title()` function. This function accepts a string argument to be used as the text for the title. It also has an optional `pad` parameter, which dictates the space between the title and the plotting area.\n", - "\n", - "We can also use `plt.ylabel()` and `plt.xlabel()` to label the y- and x-axes, respectively." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "eccd1b1a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(mex_gdp, mex_usd)\n", - "\n", - "plt.title(\"% GDP vs. Absolute Spending on Military in Mexico 1960 - 2020\", pad=10)\n", - "\n", - "plt.ylabel('Spending in USD (Billions)')\n", - "plt.xlabel('Percentage of GDP')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "cd5d171b", - "metadata": {}, - "source": [ - "Now we have a better understanding of the data. \n", - "\n", - "In addition to this information, we can add a color scheme that will color each data point based on the year of collection. This adds another dimension of analysis, using year as a feature; the context of the spending relationship can be examined over time.\n", - "\n", - "The `plt.scatter()` function minimally needs two arguments - *x* and *y* - which are array-like variables. Other optional arguments include `c`, which determines how to color the data points; `alpha`, which sets the opacity of the data points; and `cmap` which sets the Colormap used to color the data points. \n", - "\n", - "The `plt.colorbar()` function displays a scale of the Colormap based on the feature used to color the data, which in our case is the year of collection." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "23a45386", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mex_years = mex_gdp.index\n", - "\n", - "plt.scatter(mex_gdp, mex_usd, c=mex_years, alpha=0.4, cmap='winter')\n", - "\n", - "plt.title(\"% GDP vs. Absolute Spending on Military in Mexico 1960 - 2020\", pad=10)\n", - "\n", - "plt.ylabel('Spending in USD (Billions)')\n", - "plt.xlabel('Percentage of GDP')\n", - "\n", - "plt.colorbar()\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "20146a6e", - "metadata": {}, - "source": [ - "We used the years of the dataset (which we defined as the index earlier in this chapter) as our `c` argument to color the data points based on the year of collection. We used the *winter* Colormap as our `cmap` argument, but many other Colormaps are available for your choosing. A list of other possible Colormaps to explore can be found here." - ] - }, - { - "cell_type": "markdown", - "id": "30ba35e7", - "metadata": {}, - "source": [ - "## Line graphs\n", - "\n", - "Next, we'll examine the use of a line graph as another visualization tool for numerical data. Line graphs are used to visualize sequential numerical data. By using line graphs, we can easily see trends within data over time.\n", - "\n", - "Let's examine the spending (in USD) on the military in Canada in the 21st century (2000-2020). We can extract this data and call it `can_usd`.\n", - "\n", - "In Python, visualizations can be made using dataframe methods or by directly calling functions from the `pyplot` library in `matplotlib`. We can quickly create a line graph using `plot()` method on the `can_usd` dataframe:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "b26501e3-def6-48f3-80e5-d238e8220f9f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CAN-USD
Year
20008.299385
20018.375571
20028.495399
20039.958246
200411.336490
\n", - "
" - ], - "text/plain": [ - " CAN-USD\n", - "Year \n", - "2000 8.299385\n", - "2001 8.375571\n", - "2002 8.495399\n", - "2003 9.958246\n", - "2004 11.336490" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "can_usd = military[['CAN-USD']].loc[2000:2020]\n", - "\n", - "can_usd.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "e9499c29", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "can_usd.plot()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "9d2ccd60", - "metadata": {}, - "source": [ - "The same plot can be made using the `pyplot` function `plt.plot()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "d5f4f198", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(can_usd)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "e199c81c", - "metadata": {}, - "source": [ - "Notice how the `plot()` method automatically uses the `Year` column to label the x-axis, while the `plt.plot()` function does not. This can simply be remedied using the `plt.xlabel()` function. We can add a y-label as well using `plt.ylabel()`.\n", - "\n", - "Also notice the increments of the x-axis for both plots. To change these increments to integers, we can create an array consisting of years of the desired increments and then use it as an argument for the `plt.xticks()` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "ab3bb392-3509-4adc-b1ae-4460db515862", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([2000, 2005, 2010, 2015, 2020])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "years = np.arange(2000, 2021, 5)\n", - "\n", - "years" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "88bcffa6-027e-4208-aeab-9c61649b913c", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(can_usd)\n", - "plt.xlabel('Year')\n", - "plt.ylabel('USD (Billions)')\n", - "plt.xticks(years)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d90f500d", - "metadata": {}, - "source": [ - "We can see from the graph that Canada's spending on the military has increased overall since 2000. The country had a period of time (around 2011 to 2017) where military spending was decreasing consistently.\n", - "\n", - "### Visualizing multiple trends using line graphs\n", - "\n", - "We can view trends for multiple variables at once. Let's add the data for Mexico as well to see the country's spending in the 21st century." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "3eff4b2a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "mex_usd = military[['MEX-USD']].loc[2000:2020]\n", - "\n", - "plt.plot(can_usd)\n", - "plt.plot(mex_usd)\n", - "\n", - "plt.xlabel('Year')\n", - "plt.ylabel('USD (Billions)')\n", - "plt.xticks(years)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "81e3e39f", - "metadata": {}, - "source": [ - "We can now see that the military spending for both Mexico and Canada is vastly different. However, just looking at this graph out of context, we wouldn't be able to tell which line corresponds to which country. Let's add some descriptive details, such as a legend and a title:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "50c364ea", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(can_usd, label='Canada')\n", - "plt.plot(mex_usd, label='Mexico')\n", - "\n", - "plt.xlabel('Year')\n", - "plt.ylabel('USD (Billions)')\n", - "plt.xticks(years)\n", - "\n", - "plt.legend(loc=\"best\") # Adds a legend to the figure\n", - "plt.title(\"Military Spending in Mexico and Canada in the 21st Century\", pad=10)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "3ab35d3c", - "metadata": {}, - "source": [ - "We can see that the overall trend of military spending in Mexico also increased from 2000 to 2020. However, this increase was a lot less drastic than observed in Canada. Mexico's military spending was a steady rise from about \\$3 billion to \\$6 billion over the course of 20 years, while Canada's spending rose from \\$8 billion to about \\$23 billion over the same period of time.\n", - "\n", - "Let's add data from the United States to see the trends in all North American countries." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "18c12059", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "usa_usd = military[['USA-USD']].loc[2000:2020]\n", - "\n", - "plt.plot(can_usd, label='Canada')\n", - "plt.plot(mex_usd, label='Mexico')\n", - "plt.plot(usa_usd, label='United States')\n", - "\n", - "plt.xlabel('Year')\n", - "plt.ylabel('USD (Billions)')\n", - "plt.xticks(years)\n", - "\n", - "plt.legend(loc=\"best\")\n", - "plt.title(\"Military Spending in North America in the 21st Century\", pad=10)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ae241382", - "metadata": {}, - "source": [ - "With the addition of the data from the United States, it's difficult to discern the data from Canada and Mexico. Because the spending on the military in the United States was a lot higher, plotting all three datasets on the same graph with the same axis does not allow us to clearly see trends in the other countries.\n", - "\n", - "To address this, we can graph the data for each country separately with axis limits that are tailored to each country. If we graph this data side by side, we can see the trends in each country while acknowledging that the axis intervals for each country provides a numerical context for cross-comparisons.\n", - "\n", - "To do this, we use the `plt.subplots()` function. This function creates a `figure` object and `axis` objects, which we will name `fig` and `ax`, respectively. More information on the workings of `plt.subplots()` is linked at the end of this section.\n", - "\n", - "By using `plt.subplots()`, we can add data for Canada, Mexico and the United States to the same figure by specifying the data assigned to each `ax` object. Here, we will define three `ax` objects: `ax1`, `ax2`, and `ax3`. This will allow us to create three separate plotting areas, bounded by three different axes, that are contained within one figure.\n", - "\n", - "Once the figure and axes are defined, we can create a title for the entire figure using `fig.suptitle()`. Using the `.plot()` method for each `ax` object, we can specify which data to plot in each axis. We can also specify other plotting features about each axis by using various methods on each axis object, such as the `set_title()`, `set_xlabel()`, `set_ylim()`, and `set_xticks()` methods:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "af08cad2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Defines a figure object and three axis objects\n", - "# Sets the dimensions of the figure (1 x 3 axes)\n", - "# Sets the figure size (15in x 3in)\n", - "(fig, (ax1, ax2, ax3)) = plt.subplots(1, 3, figsize=(15, 3))\n", - "\n", - "\n", - "# Sets title for entire figure\n", - "fig.suptitle('Military Spending in North America in the 21st Century', y=1.1, fontsize=15)\n", - "\n", - "\n", - "# Makes plots for each axis\n", - "ax1.plot(can_usd, color='blue') # Plots Canada data to ax1 \n", - "ax1.set_title('Canada') # Sets title for ax1\n", - "ax1.set_ylim([8, 24]) # Sets y-axis limits for ax1\n", - "ax1.set_xlabel('Years') # Sets x-axis labels for ax1\n", - "ax1.set_ylabel('USD (Billions)') # Sets y-axis labels for ax1\n", - "ax1.set_xticks(years) # Sets x-ticks for ax1\n", - "\n", - "ax2.plot(mex_usd, color='red') # Plots Mexico data to ax2\n", - "ax2.set_title('Mexico') # Sets title for ax2\n", - "ax2.set_ylim([2.5, 7]) # Sets y-axis limits for ax2\n", - "ax2.set_xlabel('Years') # Sets x-axis labels for ax2\n", - "ax2.set_ylabel('USD (Billions)') # Sets y-axis labels for ax2\n", - "ax2.set_xticks(years) # Sets x-ticks for ax2\n", - "\n", - "ax3.plot(usa_usd, color='orange') # Plots U.S. data to ax3\n", - "ax3.set_title('United States') # Sets title for ax3\n", - "ax3.set_ylim([300, 800]) # Sets y-axis limits for ax3\n", - "ax3.set_xlabel('Years') # Sets x-axis labels for ax3\n", - "ax3.set_ylabel('USD (Billions)') # Sets y-axis labels for ax3\n", - "ax3.set_xticks(years) # Sets x-ticks for ax3\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "efee0c99", - "metadata": {}, - "source": [ - "Now that we've created separate subplots, we can see the trends for all three countries over the last 20 years. All three countries seem to have decreased spending around 2011 and 2018. By observing the difference in scale, we can also see that while the trends are similar, the magnitude of spending was very different between Canada, Mexico, and the United States." - ] - }, - { - "cell_type": "markdown", - "id": "5190be46", - "metadata": {}, - "source": [ - "## Histograms\n", - "\n", - "Histograms are a great way to view a **distribution** of numerical data. A distribution of a dataset is a visual display of all the values within the dataset when plotted on a graph, showing the frequency of occurence of said values.\n", - "\n", - "\n", - "In histogram plots, a numerical component of data is divided into what are called **bins**. As data points are assigned to their respective bins, the total number of data points in each bin is quantified and plotted, visualizing a distribution of frequencies. In the upcoming exercise, we will explore how to visualize distributions of values in our dataset.\n", - "\n", - "\n", - "Let's examine military spending in the United States from 1960 to 2020. We can look at multiple ranges of dollar amounts spent on the military as our independent variable and organize them into bins. After, we can determine how many fiscal years fall into each of these bins and visualize the distribution.\n", - "\n", - "First, we will need to extract the data pertaining to the military spending in the United States. We will call it `hist_data`. Then, we will need to determine the minimum and maximum values of this subset of data so that we can determine the range of values." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "a45eb875", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "min: 47.34655267\n", - "max: 778.2322\n" - ] - } - ], - "source": [ - "hist_data = military[\"USA-USD\"]\n", - "\n", - "print('min:', hist_data.min())\n", - "print('max:', hist_data.max())" - ] - }, - { - "cell_type": "markdown", - "id": "b21d2e3e", - "metadata": {}, - "source": [ - "We see that the minimum amount the United States spent on the military between the years of 1960 and 2020 was about \\$47 billion, while the maximum amount was about \\$780 billion.\n", - "\n", - "With this information, we will create a range for our bins, named `binnum`, with integers between 0 and 801, so that it is inclusive of all the data values. We make the interval of the range 100, giving us eight evenly spaced bins." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "ccfb3ade", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0, 100, 200, 300, 400, 500, 600, 700, 800]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "binnum = np.arange(0, 801, 100)\n", - "\n", - "list(binnum)" - ] - }, - { - "cell_type": "markdown", - "id": "55e62707", - "metadata": {}, - "source": [ - "To graph the distribution of military spending, a histogram can be made by using the `hist()` dataframe method. We can specify the bins so that they are evenly distributed on the x-axis. We can do this by inputting `binnum` as our `bins` argument. If we do not specify the `bin` argument, the data will be divided into 10 bins by default." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "90028e2d", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hist_data.hist(bins=binnum)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "43e31df5", - "metadata": {}, - "source": [ - "We can also use the `plt.hist()` funtion to make the same graph:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "daae9915", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.hist(hist_data, bins=binnum)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d7d71458", - "metadata": {}, - "source": [ - "When determining the bins for a histogram, the bin size controls the number of bins that will show. A smaller bin size will result in more bins, which will show more granularity of the data, but could make it difficult to see patterns in the data. A larger bin size decreases the visible detail of the data, but could also make it hard to discern useful take aways from the data. While exploring data, it's important to try different bins sizes out to see which display provides the most useful information for your analysis needs.\n", - "\n", - "Consider the different bin sizes below:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "a2713731", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.hist(hist_data, bins=range(0, 801, 200))\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "5844a254", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.hist(hist_data, bins=range(0, 801, 50))\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "73ece7f2", - "metadata": {}, - "source": [ - "Both histograms show the same data in different ways. The top histogram has a larger bin size and from it, we can see that it shows most of the values in the data fall within the range of 0-200. The second one has a smaller bin size, and we can see that most of the values of the data fall within the range of 50-100. The latter gives us a more specific range of where most of the data lie, which can be useful down the line.\n", - "\n", - "For now, let's stick with the bin size in the latter graph. Now that we have our plot, let's add additional details to make it more informative:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "942043f1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.hist(hist_data, bins=range(0, 801, 50))\n", - "plt.title(\"Distribution of Military Spending in the United States from 1960 to 2020\")\n", - "plt.ylabel('Counts of Fiscal Years')\n", - "plt.xlabel(\"Dollar Amount (USD)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "5e52c962", - "metadata": {}, - "source": [ - "Awesome! From this plot, we can see that the United States had the highest frequency of fiscal years where \\$50 - \\$100 billion was spent on the military, while the \\$400 - \\$550 billion and \\$150 - \\$200 bins had the lowest frequencies with only 1 year spending those ranges of money." - ] - }, - { - "cell_type": "markdown", - "id": "778960f9", - "metadata": {}, - "source": [ - "### Visualizing multiple distributions using histograms\n", - "\n", - "We can also view multiple distributions on one plot on using multiple plots. Let's look at the distributions of the percentage of GDP spent on the military in Canada and the United States from 1960 to 2020." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "ea5e0162", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CAN-PercentGDPUSA-PercentGDP
Year
19604.1852578.993125
19614.1283129.156031
19623.9992169.331673
19633.6206508.831891
19643.4020638.051281
.........
20161.1641623.418942
20171.3516023.313381
20181.3246813.316249
20191.2789413.427080
20201.4150563.741160
\n", - "

61 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " CAN-PercentGDP USA-PercentGDP\n", - "Year \n", - "1960 4.185257 8.993125\n", - "1961 4.128312 9.156031\n", - "1962 3.999216 9.331673\n", - "1963 3.620650 8.831891\n", - "1964 3.402063 8.051281\n", - "... ... ...\n", - "2016 1.164162 3.418942\n", - "2017 1.351602 3.313381\n", - "2018 1.324681 3.316249\n", - "2019 1.278941 3.427080\n", - "2020 1.415056 3.741160\n", - "\n", - "[61 rows x 2 columns]" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "perc_gdp = military[['CAN-PercentGDP', 'USA-PercentGDP']]\n", - "perc_gdp" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "fb06b325", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CAN-PercentGDP 0.989925\n", - "USA-PercentGDP 3.085677\n", - "dtype: float64\n", - "CAN-PercentGDP 4.185257\n", - "USA-PercentGDP 9.417796\n", - "dtype: float64\n" - ] - } - ], - "source": [ - "print(perc_gdp.min())\n", - "print(perc_gdp.max())" - ] - }, - { - "cell_type": "markdown", - "id": "5aab7d8f", - "metadata": {}, - "source": [ - "We see that the minimum values for these two countries is about 0.98%, while the maximum value is about 9.4%. To plot both of these distributions on a single plot, we can create another array called `binnum2` that can include all of the values.\n", - "\n", - "\n", - "We can then make histograms for each country, specifying the labeling and colors for each. We'll also add a legend to show which color corresponds to which country, as well as proper titles and labeling:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "64136357", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "binnum2 = np.arange(1,11, step = 0.5)\n", - "\n", - "# plotting histograms\n", - "\n", - "plt.hist(perc_gdp['CAN-PercentGDP'], label='Canada', alpha=0.6, color = 'blue', bins=binnum2)\n", - "plt.hist(perc_gdp['USA-PercentGDP'], label='United States', alpha=0.6, color = 'orange', bins=binnum2)\n", - "\n", - "# labeling\n", - "plt.legend(bbox_to_anchor=(1, 1))\n", - "plt.title('Distribution of the Percentage of Military Spending from 1960 to 2020')\n", - "plt.xlabel('% of GDP')\n", - "plt.ylabel('Counts of Fiscal Years')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "8b901d2d", - "metadata": {}, - "source": [ - "Additionally, we can use the `plt.subplots()` function to create two separate plots in one figure. By specifying `ax1` and `ax2`, we can use the `hist()` method to create a histogram and set titles and axis labels for each axis." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "3b1fef90", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "(fig, (ax1, ax2)) = plt.subplots(1, 2, figsize=(12, 3))\n", - "\n", - "plt.suptitle('Distribution of the Percentage of Military Spending from 1960 to 2020', y=1.1)\n", - "\n", - "ax1.hist(perc_gdp['CAN-PercentGDP'], color = 'blue')\n", - "ax1.set_title('Canada')\n", - "ax1.set_xlabel('Dollar Amount (USD)')\n", - "ax1.set_ylabel('Counts of Fiscal Years')\n", - "\n", - "ax2.hist(perc_gdp['USA-PercentGDP'], color = 'orange')\n", - "ax2.set_title('United States')\n", - "ax2.set_xlabel('Dollar Amount (USD)')\n", - "ax2.set_ylabel('Counts of Fiscal Years')\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "6e35bfce", - "metadata": {}, - "source": [ - "Notice with the above use of the `hist()` method, we did not specify the bins for each axis. Thus, each subplot created 10 bins by default to fit the range of the data." - ] - }, - { - "cell_type": "markdown", - "id": "886787a1", - "metadata": {}, - "source": [ - "## Conclusions\n", - "\n", - "In this section, we learned functions and methods to create histograms, scatter plots, and line graphs as a means of visualizing numerical data.\n", - "\n", - "The `plt.scatter()` and `plt.plot()` functions require numerical arrays that serve as `x` and `y` arugments. The `plt.hist()` function requires one numerical array of values for plotting distributions of data.\n", - "\n", - "The `hist()` and `plot()` methods can also be used directly on dataframes to create histograms and line plots, respectively.\n", - "\n", - "We can also create subplots within a figure using `plt.subplots()`.\n", - "\n", - "Lastly, we learned about a number of other functions that can be used to enhance and annotate our plots. Documentation for the functions used in this section, and related functions, are listed below:\n", - "\n", - "- plt.hist( )\n", - "\n", - "- DataFrame hist method\n", - "- plt.scatter( )\n", - "- plt.plot( )\n", - "- DataFrame plot method\n", - "- plt.subplots( )\n", - "- fig.suptitle( )\n", - "- ax.set_title( )\n", - "- ax.set_ylim( )\n", - "- ax.set_xlim( )\n", - "- ax.set_ylabel( )\n", - "- ax.set_xlabel( )\n", - "- plt.colorbar( )" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/textbook/09/2/img/boxandwhisker.png b/textbook/09/2/img/boxandwhisker.png new file mode 100644 index 0000000000000000000000000000000000000000..96ce884b4161f800ec2c82f5ef5a25d2a414900d GIT binary patch literal 68181 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 b7TD?ZJ)e?$x!^la-<>^ecZzn>EBb!{>vINF literal 0 HcmV?d00001 diff --git a/textbook/09/3/Categorical_Data.ipynb b/textbook/09/3/Categorical_Data.ipynb deleted file mode 100644 index 54bcb069..00000000 --- a/textbook/09/3/Categorical_Data.ipynb +++ /dev/null @@ -1,988 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7ea83cf0", - "metadata": {}, - "source": [ - "# Categorical Data\n", - "\n", - "Categorical data considers numerical quantities in the context of categorical variables. Surveys, like the ones we see on the television show Family Feud or the frequency of people with various eye colors, are examples of categorical data. \n", - "\n", - "\n", - "In this chapter, there are two types of categorical data that we consider: ordinal data and nominal data. \n", - "\n", - "**Ordinal data** consists of data that can be described as having a meaningful order, ranking, or relationship between categories. An inventory that quantifies the number of small, medium, and large shirts in stock is an example of ordinal data because there is a ranked relationship between shirt sizes.\n", - "\n", - "**Nominal data** can be described as named categories that have no meaningful relationship to one another. Counting the number of people with black, brunette, red, and blonde hair colors in a room is an example of nominal data because hair color has no inherit meaning amongst each other - one hair color is not greater than or less than the others.\n", - "\n", - "\n", - "Categorical data can be visualized using bar graphs and pie charts, and in this section, we will practice making such visualizations.\n", - "\n", - "Again, we'll load the necessary libraries and data." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "45d41791-b19e-48cf-917d-c411750c6122", - "metadata": { - "tags": [ - "hide_cell" - ] - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "\n", - "from matplotlib import pyplot as plt\n", - "\n", - "plt.style.use('fast')\n", - "\n", - "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_csv = '''\\\n", - "Year,CAN-PercentGDP,MEX-PercentGDP,USA-PercentGDP,CAN-USD,MEX-USD,USA-USD\n", - "1960,4.18525654,0.673508659,8.993124587,1.702442711,0.084,47.34655267\n", - "1961,4.128312243,0.651780326,9.1560315,1.677820881,0.0864,49.87977061\n", - "1962,3.999216389,0.689655172,9.331672945,1.671313753,0.0992,54.65094261\n", - "1963,3.620650112,0.718685832,8.831891186,1.610091701,0.112,54.56121578\n", - "1964,3.402062837,0.677506775,8.051281106,1.657457283,0.12,53.43232706\n", - "1965,2.930260659,0.591269841,7.587247177,1.57470454,0.1192,54.56179126\n", - "1966,2.683282422,0.576379066,8.435300286,1.614422827,0.1304,66.44275153\n", - "1967,2.74792677,0.545217107,9.417795933,1.775500366,0.1336,78.39844224\n", - "1968,2.54364188,0.548510764,9.268454275,1.797265817,0.1488,84.32903122\n", - "1969,2.27378467,0.600160043,8.633263795,1.770108751,0.18,84.99016543\n", - "1970,2.188979696,0.497411659,8.032743584,1.889157918,0.1768,83.407993\n", - "1971,2.131485639,0.48765558,6.943069609,2.077659711,0.1912,78.23797989\n", - "1972,2.011818438,0.536568089,6.519756924,2.233737031,0.2424,80.70807097\n", - "1973,1.832601818,0.544217687,5.893870591,2.363060955,0.3008,81.46979441\n", - "1974,1.783813085,0.565744137,5.954111197,2.809465529,0.4072,89.27892034\n", - "1975,1.863541853,0.57358422,5.622679096,3.18091549,0.5048,92.08092875\n", - "1976,1.765927978,0.598103574,5.191071429,3.581805735,0.531576968,94.71525108\n", - "1977,1.8057636,0.534256205,5.155617351,3.752174526,0.437692986,104.665219\n", - "1978,1.848887401,0.504834431,4.943087248,3.969158477,0.518287193,113.3820637\n", - "1979,1.711245918,0.505297474,4.951991535,4.084145738,0.679663588,126.8799271\n", - "1980,1.764448615,0.416107383,5.153537467,4.744402251,0.810422204,143.6883549\n", - "1981,1.709915638,0.513301014,5.646541256,5.141128191,1.284948561,176.5588753\n", - "1982,1.954343585,0.495419418,6.814057094,6.017321456,0.858130163,221.6735426\n", - "1983,2.081196249,0.522866314,6.32114426,6.947104072,0.778556797,223.427165\n", - "1984,2.117188855,0.65981906,6.23641653,7.349795764,1.155945373,245.1491683\n", - "1985,2.097376234,0.676313139,6.453219205,7.460563318,1.241863652,272.1632293\n", - "1986,2.109197118,0.634622463,6.626522658,7.78013674,0.817296612,295.5462238\n", - "1987,2.062576371,0.580341889,6.420274023,8.694447168,0.813391574,304.0866487\n", - "1988,1.986767119,0.536145374,6.071277702,9.897335684,0.981914646,309.6612693\n", - "1989,1.934614309,0.517255829,5.871206008,10.74713469,1.153375828,321.8665588\n", - "1990,1.958793742,0.433081035,5.605175294,11.41463185,1.210872502,325.129314\n", - "1991,1.895444339,0.435402301,4.883429398,11.3385033,1.459136041,299.3727791\n", - "1992,1.8616877,0.469454656,4.970466808,10.78880312,1.824550066,325.033736\n", - "1993,1.821753504,0.442785494,4.604350295,10.26882262,2.122980338,316.7194437\n", - "1994,1.696680257,0.518830327,4.215264675,9.57737764,2.635284079,308.084\n", - "1995,1.554090071,0.450891531,3.860245792,9.176903908,1.562615372,295.8530977\n", - "1996,1.403752581,0.476484778,3.554982206,8.615884471,1.882873103,287.9606687\n", - "1997,1.246243202,0.458095854,3.405562244,7.945140183,2.184061042,293.1678258\n", - "1998,1.256293902,0.450450487,3.201558499,7.748607984,2.263223453,290.9960551\n", - "1999,1.241703064,0.460988776,3.085676783,8.21077854,2.652912012,298.0948913\n", - "2000,1.11808088,0.44604782,3.112242147,8.299385231,3.031454509,320.0863242\n", - "2001,1.137368973,0.442657004,3.123809803,8.375571425,3.229469276,331.8056106\n", - "2002,1.120852292,0.421606002,3.447618099,8.495399281,3.172268734,378.4631388\n", - "2003,1.115878799,0.405916547,3.827161045,9.958245602,2.960496802,440.5320696\n", - "2004,1.107966027,0.364898723,4.016312736,11.33648983,2.854385965,492.9993762\n", - "2005,1.110669655,0.355958931,4.090034876,12.98813296,3.123454978,533.203\n", - "2006,1.125832408,0.311171936,4.041627237,14.8098928,3.035131019,558.335\n", - "2007,1.188901783,0.401163918,4.079655081,17.41713993,4.223037646,589.586\n", - "2008,1.248621382,0.390513227,4.463827356,19.3420584,4.334654124,656.756\n", - "2009,1.377555631,0.501556275,4.88559968,18.93622605,4.514233914,705.917\n", - "2010,1.194338338,0.452734493,4.922641677,19.31568883,4.789031339,738.005\n", - "2011,1.193291895,0.465777803,4.840173995,21.39372086,5.498458542,752.288\n", - "2012,1.118404598,0.475987281,4.477401219,20.45210711,5.717035575,725.205\n", - "2013,1.0023672,0.507919455,4.046678879,18.51573121,6.473144378,679.229\n", - "2014,0.989925299,0.513829957,3.69589465,17.85364048,6.758693845,647.789\n", - "2015,1.152709374,0.466676122,3.477845166,17.93764189,5.468837812,633.829639\n", - "2016,1.164161567,0.495064414,3.418942337,17.78277554,5.33687574,639.856443\n", - "2017,1.351602232,0.436510296,3.313381294,22.26969632,5.062076646,646.752927\n", - "2018,1.324681094,0.477517407,3.316248808,22.72932758,5.839521271,682.4914\n", - "2019,1.27894142,0.52348249,3.427080181,22.20440844,6.650808254,734.3441\n", - "2020,1.415055841,0.573651659,3.741160091,22.75484713,6.116376582,778.2322\n", - "'''\n", - "\n", - "from io import StringIO\n", - "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", - "\n", - "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')" - ] - }, - { - "cell_type": "markdown", - "id": "f26e1513", - "metadata": {}, - "source": [ - "## Bar graphs\n", - "\n", - "Bar graphs are a popular method to visualize categorical data. They're simple, concise, and can condense\n", - "large and complex datasets into a simple visual summary. Most bar graphs depict a categorical element as an\n", - "independent variable on the x-axis while the height of the bar corresponds to a numerical value on the y-axis.\n", - "\n", - "We will practice making bar graphs using our military dataset in the context of an ordinal variable.\n", - "\n", - "First, let's create a graph to examine the percent of the GDP spent on the military in Canada. We will look at the years 2018, 2019 and 2020.\n", - "\n", - "To do this, we must extract the data for the years of interest from the column containing the data pertaining to GDP percentage of military spending in Canada. We will call this `can_gdp`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "af3c0e6d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CAN-PercentGDP
Year
20181.324681
20191.278941
20201.415056
\n", - "
" - ], - "text/plain": [ - " CAN-PercentGDP\n", - "Year \n", - "2018 1.324681\n", - "2019 1.278941\n", - "2020 1.415056" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "can_gdp = military.loc[[2018, 2019, 2020], ['CAN-PercentGDP']]\n", - "\n", - "can_gdp" - ] - }, - { - "cell_type": "markdown", - "id": "62a27826-df76-4802-9414-f1a2b5931a96", - "metadata": {}, - "source": [ - "To make a bar graph from a dataframe, the `plot.bar()` method can be used. We will use this method on `can_gdp`:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7669818c", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "can_gdp.plot.bar()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "c53841ab", - "metadata": {}, - "source": [ - "We can also use `plt.bar()` to create a bar graph using the `pyplot` library. The `plt.bar()` function needs two arguments. The first argument, `x`, is an array of values to be plotted on the x-axis. \n", - "\n", - "The second argument, `height`, determines the height of the bars (the y-values). \n", - "\n", - "We will create a list of our years of interest and call it `year_labels` to input as the first argument and use the \"CAN-PercentGDP\" column of `can_gdp` as our second argument." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "b2be1224", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "year_labels = ['2018', '2019', '2020']\n", - "plt.bar(year_labels, can_gdp[\"CAN-PercentGDP\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "5748baf9", - "metadata": {}, - "source": [ - "The above code produced a plot, but this plot needs more descriptive labeling to help others understand the data. \n", - "\n", - "We need to add axis labels and a title to communicate what is being measured. Aesthetically, we can also reduce the width of each bar to give more room on the graph and more rest for our eyes." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "b66c30a8-e66a-4ad1-b6c5-cbe53ee5eef9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.bar(year_labels, can_gdp[\"CAN-PercentGDP\"], width=0.25)\n", - "\n", - "\n", - "plt.title('Military Spending in Canada')\n", - "\n", - "plt.ylabel('Percentage of GDP')\n", - "plt.xlabel('Year')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "18931cc9", - "metadata": {}, - "source": [ - "This plot looks better and is a lot more descriptive.\n", - "\n", - "Let's add the data from Mexico and the United States.\n", - "\n", - "To do this, we will once again use the `plt.subplots()` function. This time, we will specify our figure with a single axis called `ax`. Because we want to group our data by year, we can call `ax.bar()` to set precise positions on the x-axis for each country.\n", - "\n", - "We will also use `plt.tight_layout()` to automatically adjust the subplot dimensions to give appropriate spacing between the bars and the axes boundaries." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6833fd5b", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQn0lEQVR4nO3cX4xcZ3nH8e+vtvkjgUiLV8Ry7BhELgqkkLAyQZGqKBQppChBIq3MBcSIyJQSARI3CZVCyRX0AiQaRGqRCAehEBQQGOoIpSIVcBHDxnLs2IbWoKLYSpvFAQcL6sr06cWeoO2wm5n1zu683vP9SKM9f56d87w+tn97zrx7UlVIktSaP5p0A5IkLcSAkiQ1yYCSJDXJgJIkNcmAkiQ1af2kDrxx48batm3bpA4vSVpFjz322C+qamop3zOxgNq2bRszMzOTOrwkaRUl+flSv8dbfJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJk3sUUeSpNFcvufyiR7/8M2HJ3Jcr6AkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTRoaUElelOSHSR5PciTJJxao2ZlkNsnB7nXLyrQrSeqLUR4Wexa4tqrOJNkA/CDJQ1X16EDdA1V16/hblCT10dCAqqoCznSrG7pXrWRTkiSN9BlUknVJDgJPAw9X1f4Fyt6Z5FCSB5NsGWeTkqT+GSmgqup3VfUG4BJge5LXDZR8C9hWVX8GPAzsWeh9kuxKMpNkZnZ2dhltS5LWuiXN4quqXwGPANcNbD9VVWe71S8Ab1zk+3dX1XRVTU9NTZ1Hu5KkvhhlFt9Ukou65RcDbwV+PFCzad7qDcCxMfYoSeqhUWbxbQL2JFnHXKB9taq+neROYKaq9gIfSnIDcA54Bti5Ug1LkvphlFl8h4ArFth+x7zl24Hbx9uapEGX77l8osc/fPPhiR5f/eKTJCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0a5feg1CCnG0ta67yCkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1aWhAJXlRkh8meTzJkSSfWKDmhUkeSHI8yf4k21akW0lSb4xyBXUWuLaqXg+8AbguyVUDNe8DfllVrwY+A3xqrF1KknpnaEDVnDPd6obuVQNlNwJ7uuUHgbckydi6lCT1zkifQSVZl+Qg8DTwcFXtHyjZDDwJUFXngNPAyxd4n11JZpLMzM7OLqtxSdLaNlJAVdXvquoNwCXA9iSvO5+DVdXuqpququmpqanzeQtJUk8saRZfVf0KeAS4bmDXSWALQJL1wMuAU2PoT5LUU6PM4ptKclG3/GLgrcCPB8r2Ajd3yzcB362qwc+pJEka2foRajYBe5KsYy7QvlpV305yJzBTVXuBe4AvJTkOPAPsWLGOJUm9MDSgquoQcMUC2++Yt/zfwF+NtzVJUp/5JAlJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSk4YGVJItSR5JcjTJkSQfXqDmmiSnkxzsXnesTLuSpL5YP0LNOeCjVXUgyUuBx5I8XFVHB+q+X1VvH3+LkqQ+GnoFVVVPVdWBbvnXwDFg80o3JknqtyV9BpVkG3AFsH+B3W9O8niSh5K8dpHv35VkJsnM7Ozs0ruVJPXGyAGV5CXA14CPVNWzA7sPAJdW1euBfwS+sdB7VNXuqpququmpqanzbFmS1AcjBVSSDcyF05er6uuD+6vq2ao60y3vAzYk2TjWTiVJvTLKLL4A9wDHqurTi9Rc3NWRZHv3vqfG2agkqV9GmcV3NfBu4HCSg922jwFbAarqbuAm4ANJzgG/BXZUVY2/XUlSXwwNqKr6AZAhNXcBd42rKUmSfJKEJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUkGlCSpSQaUJKlJBpQkqUlDAyrJliSPJDma5EiSDy9QkySfTXI8yaEkV65Mu5Kkvlg/Qs054KNVdSDJS4HHkjxcVUfn1bwNuKx7vQn4fPdVkqTzMvQKqqqeqqoD3fKvgWPA5oGyG4H7as6jwEVJNo29W0lSbyzpM6gk24ArgP0DuzYDT85bP8EfhhhJdiWZSTIzOzu7xFYlSX0yckAleQnwNeAjVfXs+RysqnZX1XRVTU9NTZ3PW0iSemKkgEqygblw+nJVfX2BkpPAlnnrl3TbJEk6L6PM4gtwD3Csqj69SNle4D3dbL6rgNNV9dQY+5Qk9cwos/iuBt4NHE5ysNv2MWArQFXdDewDrgeOA78B3jv2TiVJvTI0oKrqB0CG1BTwwXE1JUmST5KQJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDXJgJIkNcmAkiQ1yYCSJDVpaEAluTfJ00meWGT/NUlOJznYve4Yf5uSpL5ZP0LNF4G7gPuep+b7VfX2sXQkSRIjXEFV1feAZ1ahF0mSfm9cn0G9OcnjSR5K8toxvackqcdGucU3zAHg0qo6k+R64BvAZQsVJtkF7ALYunXrGA4tSVqrln0FVVXPVtWZbnkfsCHJxkVqd1fVdFVNT01NLffQkqQ1bNkBleTiJOmWt3fveWq57ytJ6reht/iS3A9cA2xMcgL4OLABoKruBm4CPpDkHPBbYEdV1Yp1LEnqhaEBVVXvGrL/LuamoUuSNDbjmCQhSStu223/PNHj/8cn/3Kix+8jH3UkSWqSASVJapIBJUlqkgElSWqSASVJatIFP4tvkjN7nNUjSSvHKyhJUpMMKElSky74W3zqH39hU+oHr6AkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0yoCRJTTKgJElNMqAkSU0aGlBJ7k3ydJInFtmfJJ9NcjzJoSRXjr9NSVLfjHIF9UXguufZ/zbgsu61C/j88tuSJPXd0ICqqu8BzzxPyY3AfTXnUeCiJJvG1aAkqZ/G8RnUZuDJeesnum1/IMmuJDNJZmZnZ8dwaEnSWrWqkySqandVTVfV9NTU1GoeWpJ0gRlHQJ0Etsxbv6TbJknSeRtHQO0F3tPN5rsKOF1VT43hfSVJPbZ+WEGS+4FrgI1JTgAfBzYAVNXdwD7geuA48BvgvSvVrCSpP4YGVFW9a8j+Aj44to4kScInSUiSGmVASZKaZEBJkppkQEmSmmRASZKaZEBJkppkQEmSmmRASZKaZEBJkppkQEmSmmRASZKaZEBJkppkQEmSmmRASZKaZEBJkppkQEmSmmRASZKaZEBJkppkQEmSmmRASZKaZEBJkpq0ftINSNIF4e9fNrljv3Lr5I49QV5BSZKaNFJAJbkuyU+SHE9y2wL7dyaZTXKwe90y/lYlSX0y9BZfknXA54C3AieAHyXZW1VHB0ofqKpbV6BHSVIPjfIZ1HbgeFX9DCDJV4AbgcGAkvrBzyKkVTHKLb7NwJPz1k902wa9M8mhJA8m2bLQGyXZlWQmyczs7Ox5tCtJ6otxzeL7FnB/VZ1N8n5gD3DtYFFV7QZ2A0xPT9eYjj05/iQtSStmlCuok8D8K6JLum2/V1Wnqupst/oF4I3jaU+S1FejBNSPgMuSvDLJC4AdwN75BUk2zVu9ATg2vhYlSX009BZfVZ1LcivwHWAdcG9VHUlyJzBTVXuBDyW5ATgHPAPsXMGeJUk9MNJnUFW1D9g3sO2Oecu3A7ePtzVJUp/5JAlJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSkwwoSVKTDChJUpMMKElSk0YKqCTXJflJkuNJbltg/wuTPNDt359k29g7lST1ytCASrIO+BzwNuA1wLuSvGag7H3AL6vq1cBngE+Nu1FJUr+McgW1HTheVT+rqv8BvgLcOFBzI7CnW34QeEuSjK9NSVLfrB+hZjPw5Lz1E8CbFqupqnNJTgMvB34xvyjJLmBXt3omyU+AjYN1F4oxJPAyxv7E8o++DNm57NF73s+L531SljnyZY77gj7vz4390qV+4ygBNTZVtRvYPX9bkpmqml7NPlrh2B173/R17H0dNyxv7KPc4jsJbJm3fkm3bcGaJOuBlwGnzqchSZJgtID6EXBZklcmeQGwA9g7ULMXuLlbvgn4blXV+NqUJPXN0Ft83WdKtwLfAdYB91bVkSR3AjNVtRe4B/hSkuPAM8yF2Kh2Dy9Zsxx7Pzn2/unruGEZY48XOpKkFvkkCUlSkwwoSVKTVj2gkvxJkoeT/Hv39Y8XqftdkoPda3BSxgWjz4+JGmHsO5PMzjvPt0yiz5WQ5N4kTydZ8BdYMuez3Z/NoSRXrnaPK2WEsV+T5PS8837Have4EpJsSfJIkqNJjiT58AI1a/K8jzj2pZ/3qlrVF/APwG3d8m3ApxapO7Pava3AWNcBPwVeBbwAeBx4zUDN3wJ3d8s7gAcm3fcqjn0ncNeke12h8f85cCXwxCL7rwceYu73P68C9k+651Uc+zXAtyfd5wqMexNwZbf8UuDfFvg7vybP+4hjX/J5n8QtvvmPRdoDvGMCPayWPj8mapSxr1lV9T3mZrQu5kbgvprzKHBRkk2r093KGmHsa1JVPVVVB7rlXwPHmHvKznxr8ryPOPYlm0RAvaKqnuqW/xN4xSJ1L0oyk+TRJO9YndbGbqHHRA2etP/3mCjgucdEXehGGTvAO7tbHQ8m2bLA/rVq1D+fterNSR5P8lCS1066mXHrbtVfAewf2LXmz/vzjB2WeN5X5FFHSf4FuHiBXX83f6WqKsli89wvraqTSV4FfDfJ4ar66bh71UR9C7i/qs4meT9zV5LXTrgnrbwDzP37PpPkeuAbwGWTbWl8krwE+Brwkap6dtL9rKYhY1/yeV+RK6iq+ouqet0Cr28C//XcJW339elF3uNk9/VnwL8yl8gXmj4/Jmro2KvqVFWd7Va/ALxxlXprwSh/N9akqnq2qs50y/uADUk2TritsUiygbn/oL9cVV9foGTNnvdhYz+f8z6JW3zzH4t0M/DNwYIkf5zkhd3yRuBq4OiqdTg+fX5M1NCxD9x7v4G5+9Z9sRd4Tzer6yrg9Lxb32takouf+5w1yXbm/h+64H8o68Z0D3Csqj69SNmaPO+jjP18zvuqPs2880ngq0neB/wc+GuAJNPA31TVLcCfAv+U5H+ZG8Qnq+qCC6ha+cdENWvEsX8oyQ3AOebGvnNiDY9ZkvuZm7W0MckJ4OPABoCquhvYx9yMruPAb4D3TqbT8Rth7DcBH0hyDvgtsGON/FB2NfBu4HCSg922jwFbYc2f91HGvuTz7qOOJElN8kkSkqQmGVCSpCYZUJKkJhlQkqQmGVCSpCYZUJKkJhlQkqQm/R941RXcVaXjEAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "can_gdp = military.loc[[2018, 2019, 2020], ['CAN-PercentGDP']]\n", - "mex_gdp = military.loc[[2018, 2019, 2020], ['MEX-PercentGDP']]\n", - "usa_gdp = military.loc[[2018, 2019, 2020], ['USA-PercentGDP']]\n", - "\n", - "index = np.arange(len(year_labels))\n", - "\n", - "(fig, ax) = plt.subplots()\n", - "\n", - "# Offsets the bars for Canada by -0.25in\n", - "ax.bar(index - 0.25, can_gdp[\"CAN-PercentGDP\"], width=0.25) \n", - "\n", - "# Plots the bars for Mexico in the middle\n", - "ax.bar(index, mex_gdp[\"MEX-PercentGDP\"], width=0.25)\n", - "\n", - "# Offsets the bars for the U.S. by +0.25in\n", - "ax.bar(index + 0.25, usa_gdp[\"USA-PercentGDP\"], width=0.25)\n", - "\n", - "plt.tight_layout()\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "21c5b1b1", - "metadata": {}, - "source": [ - "We were able to create a bar plot with all three data sets together. Now, let's add the appropriate titles, axis labels, and other details using previously described functions.\n", - "\n", - "If we assign each country's bar to a variable, we can also label each individual bar with the associated numerical value by calling the `bar_label()` method on `ax`. In order to label the bars, the label must be specified when creating each each bar." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "61bdf283", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZoAAAEYCAYAAABlfjCwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwLElEQVR4nO3deXwV1fnH8c8DYRUB2ZS1IBKFsESJsmipWFdQKpUqqIgL0hatpWjF9lf3WrF1qbjUtQVcQAUVhJZqQVSqggGDARFFibIECftOSPL8/riT9ALh5iZksvF9v155ce/MmTPPnYT7zJlz5oy5OyIiImGpVt4BiIhI1aZEIyIioVKiERGRUCnRiIhIqJRoREQkVEo0IiISKiWaUmZmT5nZ7cHrM81sddS6pWZ2ZnnFVlGYWYaZnR28/r2ZPRfSfnaY2fFh1F0aDvz7qOjM7Aoze7u845DKR4kmTsGXY7aZNTlg+adm5mbWFsDdf+Hu9xZWh7snufvcYLu7zOzFsOOOFnyprwy+gFeb2Stluf/CuPuf3H14SHXXc/dvirudmbUNfqf/PGD5i2Z2V0njCeo8oaTbR9Uz3sxyzKz54dZVHO7+krufW5b7lKpBiaZ4VgJD8t+YWRegbnkEYmYJxSw/DBgKnO3u9YAUYHYYsVUhPcys9+FWUtzfVRF1HQVcAmwFriyteuPYb6l9BjnyKNEUzwvAVVHvhwETowsEZ5t/LGzj/EtGZnY+8HvgsqB1sThYf42ZLTOz7Wb2jZn9PGrbM4NWyBgzWwf8w8yWmNlFUWVqmNkGMzu5kN2fCvzb3b8GcPd17v5M1LZzzex+M1tgZtvMbJqZNYpa39PMPjSzLWa2OPoSYLDtvWb23yD2t6NbfmY21My+NbONZvZ/BxyTgpZdVEtimJl9F3yW/4sqW8fMJpjZ5uA43Rrr0lN0CyL4vTxhZjODGOebWftDbRv4M3BfjPqvN7MVZrbJzKabWYsD9n2DmX0FfGVm7werFge/88uiyt5sZuvNLNPMrikipkuALcA9RP7+ouO5y8xeC1pe280s3cwSzex3Qf2rzOzcqPINzOz5YL9rzOyPZlY9WHd18Pt8xMw2AncFy+ZFbZ9kZu8En/97M/t9sPw0M/so+FvJNLPHzaxmEZ9LqjAlmuL5GKhvZh2D/5CDgWJf/nL3WcCfgFeCyzvdglXrgQuB+sA1wCNmdkrUpscBjYAfACOIJLnos9p+QKa7f3qI2K8ys9+aWUr+F8oBrgKuBZoDOcA4ADNrCcwE/hjs/xZgqpk1jdr28iDmZkDNoAxm1gn4G5HWVAugMdAq5gGCM4ATgR8Dd5hZx2D5nUBb4HjgHIp/Rj8YuBs4BlhBjCQSeBJItKA/KZqZnQXcD1xK5Hh9C0w+oNjFQA+gk7v3CZZ1C37n+ZctjwMaAC2B64AnzOyYGDENAyYF+zrJzLofsP4iIidExwCfAv8m8v+8JZHk9HRU2fFEfs8nACcD5wLRlzF7AN8Ax3LAsTKzo4H/ALOI/F5P4H8t5FzgN0AToBeR3+PIGJ9JqjglmuLLb9WcAywD1pRWxe4+092/9oj3gLeBH0YVyQPudPe97r6bSJLrZ2b1g/VDg/gKq/tF4FfAecB7wHozG3NAsRfcfYm77wRuBy4NEtKVwD/d/Z/unufu7wCpRBJbvn+4+5dBXK8CycHyQcAMd3/f3fcG9eYVcSjudvfd7r4YWAzkJ+JLgT+5+2Z3X02QCIvhDXdf4O45wEtRMR7KbiJfsIW1UK8A/u7ui4LP9TuglwV9dYH73X1TcEwOZR9wj7vvc/d/AjuIJNmDmFkboC/wsrt/T+SL/aoDin3g7v8OPuNrQFNgrLvvI5Kc2ppZQzM7lsjvb5S773T39cAjRJJxvrXu/pi75xTyGS4E1rn7Q+6+x923u/t8AHdf6O4fB9tlEEluP4pxDKSKU6IpvheInL1fzQGXzQ6XmV1gZh8HlyK2EPkiiB58kOXue/LfuPta4L/AJWbWELiAyBdooYLO3LOBhsAvgHvN7LyoIquiXn8L1Aj2/wPgZ8GlkC1BbGcQOZPPty7q9S6gXvC6RXS9QRLbeKgYi1PXAa/jcah6Y3kOONaiLlFGxfJt/ht330Hkc7UsZnwbg6QQT1xDgWXunha8fwm43MxqRJX5Pur1bmCDu+dGvSeo/wdEfr+ZUb/Tp4m0SOOJvzXwdWErgst1M8xsnZltI9J6b1JYWTkyKNEUk7t/S2RQQD/g9cOpKvqNmdUCpgIPAse6e0Pgn4AdapvABCItjp8BH7l7kS2s4Oz5NeAzoHPUqtZRr9sQOdveQOQL5wV3bxj1c5S7jy1qX0BmdL1mVpfI5bOSyGT/y26tD1WwtLh7NpHLbfey/+9iLZEva6Cgk74x+7dwS3tq9KuA44Mv8HXAw0S+wPvF3qxQq4C9QJOo32l9d0+KKhMr/lVELmEW5m/AF0AHd69PpD/SDlFWjgBKNCVzHXBWcHZeUt8TuYyR/zuoCdQCsoAcM7uAyDXzorwJnAL8mhgtrKAjt7+ZHW1m1YL6k4D5UcWuNLNOQTK4B5gSnA2/CFxkZueZWXUzq22RwQlF9bUATAEuNLMzgg7heyj5392rwO/M7Jig3+jGEtZTXC8AtYHzo5ZNAq4xs+TgJOFPwPzgUtGhfM+hv5xjMrNeQHvgNCKX/JKJnCS8zMGXz4rk7plELs0+ZGb1g7+J9mYW7yWuGUBzMxtlZrWCv6sewbqjgW3ADjM7CfhlceOTqkWJpgSCfpTUw6zmteDfjWa2yN23AzcR+TLdTOTy3PQ4YtlNpCXUjtgtrG1Eziy/IzJq6c/AL919XlSZF4h0EK8j8sV6U7CPVcBPgu2ziJzN/pY4/n7cfSlwA5EvxMzgs5X0JsV7gm1XEumInkLkrDxUQbK9g8hAiPxl/yHS3zSVyOdqz/79G4W5C5gQXKq6tJhhDAOmuXt6MGJwnbuvAx4lksgbFbF9Ya4icoLzOZHfyxT2vxx6SMHf6zlEBh+sA74i0n8EkYEglwPbgWeBcr9fS8qX6cFnlZ+Z3QEkunuJ76sws7nAi+4eyl36YTCzXwKD3V0dzSIVmFo0lVxwJnsd8ExRZSs7M2tuZqcHl3lOBG4G3ijvuEQkNiWaSszMridyGetf7v5+UeWrgJpERkZtB+YA04jc6yIiFZgunYmISKjUohERkVAp0YiISKhCnZHVzDKIXE/PBXLcPSXM/YmISMVTFlN/93X3DWWwHxERqYB06UxEREIV6qgzM1tJ5I5jB56Ofv5JVJkRRKa856ijjup+0kknhRaPiEhhFi5cuMHdmxZdUkoi7ETT0t3XmFkz4B3gV7Hu90hJSfHU1MOd2UVEpHjMbKH6kMMT6qWz/JmEg2ddvEFkQkARETmChJZozOyo4Cl8+VOonwssCWt/IiJSMYU56uxY4A0zy9/Py8EjjEVE5AgSWqJx92/43yN4RUTkCKXhzSIiEiolGhERCZUSjYiIhEqJRkREQqVEIyIioVKiERGRUCnRiIhIqJRoREQkVEo0IiISKiUaEREJlRKNiIiESolGRERCpUQjIiKhUqIREZFQKdGIiEiolGhERCRUSjQiIhIqJRoREQmVEo2IiIRKiUZEREKlRCMiIqFSohERkVAp0YiISKiUaEREJFRKNCIiEiolGhERCZUSjYiIhEqJRkREQqVEIyIioVKiERGRUCnRiIhIqJRoREQkVEo0IiISKiUaEREJVeiJxsyqm9mnZjYj7H2JiEjFUxYtml8Dy8pgPyJSiezZs4fTTjuNbt26kZSUxJ133nlQmd/85jckJyeTnJxMYmIiDRs23G/9tm3baNWqFTfeeGMZRS0lkRBm5WbWCugP3AeMDnNfIlK51KpVizlz5lCvXj327dvHGWecwQUXXEDPnj0LyjzyyCMFrx977DE+/fTT/eq4/fbb6dOnT5nFLCUTdovmr8CtQN6hCpjZCDNLNbPUrKyskMMRkYrCzKhXrx4A+/btY9++fZjZIctPmjSJIUOGFLxfuHAh33//Peeee27oscrhCS3RmNmFwHp3XxirnLs/4+4p7p7StGnTsMIRkQooNzeX5ORkmjVrxjnnnEOPHj0KLfftt9+ycuVKzjrrLADy8vK4+eabefDBB8syXCmhMFs0pwMDzCwDmAycZWYvhrg/EalkqlevTlpaGqtXr2bBggUsWbKk0HKTJ09m0KBBVK9eHYAnn3ySfv360apVq7IMV0ootD4ad/8d8DsAMzsTuMXdrwxrfyJSeTVs2JC+ffsya9YsOnfufND6yZMn88QTTxS8/+ijj/jggw948skn2bFjB9nZ2dSrV4+xY8eWZdgSp1AHA4iIHEpWVhY1atSgYcOG7N69m3feeYcxY8YcVO6LL75g8+bN9OrVq2DZSy+9VPB6/PjxpKamKslUYGVyw6a7z3X3C8tiXyJSOWRmZtK3b1+6du3KqaeeyjnnnMOFF17IHXfcwfTp0wvKTZ48mcGDB8ccKCAVm7l7ecdQICUlxVNTU8s7DBE5wpjZQndPKe84qipNQSMiIqFSohERkVAp0YiISKiUaEREJFRKNCIiEirdRyNHtD179tCnTx/27t1LTk4OgwYN4u677y607NSpUxk0aBCffPIJKSkpLFiwgBEjRgDg7tx1110MHDiwLMOvlLpM6BJq/enD0ku1voULFzZLSEh4DuiMTs4LkwcsycnJGd69e/f1hRVQopEjWjwzCANs376dRx99dL+5uDp37kxqaioJCQlkZmbSrVs3LrroIhIS9N+qKklISHjuuOOO69i0adPN1apVqzj3g1QQeXl5lpWV1WndunXPAQMKK6PsLEe0eGcQvv322xkzZgy1a9cuWFa3bt2CpLJnzx7dUFh1dW7atOk2JZnCVatWzZs2bbqVSIuv8DJlGI9IhVTUDMKLFi1i1apV9O/f/6Bt58+fT1JSEl26dOGpp55Sa6ZqqqYkE1twfA6ZT5Ro5IgXawbhvLw8Ro8ezUMPPVTotj169GDp0qV88skn3H///ezZs6eswhapNHT6VQHE0yH91FNP8cQTT1C9enXq1avHM888Q6dOnXjnnXe47bbbyM7OpmbNmvzlL38peGaHFE9hMwhv376dJUuWcOaZZwKwbt06BgwYwPTp00lJ+d+MJR07dqRevXosWbJkv+VS9bS9bWb30qwvY2z/mM/syvfdd98ljBw5ss3ixYvr1q9fP7dJkyb7HnvssVVdu3bdW5rx5Ktbt+7Ju3bt+rTokkVTi6YCyO+QXrx4MWlpacyaNYuPP/54vzKXX3456enppKWlceuttzJ6dOTJ2E2aNOGtt94iPT2dCRMmMHTo0PL4CJVWVlYWW7ZsASiYQfikk04qWN+gQQM2bNhARkYGGRkZ9OzZsyDJrFy5kpycHCDyYK4vvviCtm3blsOnkKouLy+PAQMGnNCnT5/tq1atWrJ06dJlY8eOXbN27doa5R1bPJRoKoB4OqTr169f8Hrnzp0F608++WRatGgBQFJSErt372bv3lBOcKqkeGcQLsy8efPo1q0bycnJDBw4kCeffJImTZqUUeRyJJkxY8bRCQkJfuuttxY8775Xr167e/XqtatXr16JnTp16piYmNjpxRdfbAiwfPnymscff3zS4MGDf3DCCScknX766R127NhhAA899FCTzp07dzzxxBM7nXfeee23b99eDeCLL76omZycfFJiYmKnm266qUX+frZu3VqtsH0UR5GXzsysibtvKG7FUjy5ubl0796dFStWcMMNNxT6SNsnnniChx9+mOzsbObMmXPQ+qlTp3LKKadQq1atsgi5SujatSuffnrw1YF77rmn0PJz584teD106FC1IKVMfPbZZ3W6deu268DldevWzZs5c+aKRo0a5WVmZib06NHjpMsvv3wLwHfffVf7xRdf/KZ3797f9uvX7/iJEyceM3LkyE1XXHHF5ptvvnkDwE033dRi3LhxTf7v//5v/ciRI9sMHz4868Ybb9x4//33Ny1qH9Wqxd9OOWRJM7vIzLKAdDNbbWa9i3FcpJjieaTtDTfcwNdff80DDzzAH//4x/3WLV26lDFjxvD000+XVcgiUs7y8vJs1KhRrRITEzv17ds3cf369TVXr16dANCyZcu9vXv33g1w8skn78rIyKgFsHDhwjrdu3c/MTExsdPUqVMbL126tDbAokWL6l1//fWbAH7+859vjGcf8YqVku4DfujuzYFLgPuLU7GUTHSH9KEMHjyYN998s+D96tWrGThwIBMnTqR9+/ZlEKWIlKUuXbrsXrx4cd0Dlz/99NONNm7cmJCenr7siy+++Lxx48b7du/eXQ2gZs2aBUOyq1ev7jk5OQYwYsSIdo8//vh3X3755edjxoxZu3fv3oI8UNgw7lj7iFeswjnu/gWAu88Hji5OxRK/ojqkAb766quC1zNnzqRDhw4AbNmyhf79+zN27FhOP/30MotZRMrORRddtD07O9sefPDBgk7A+fPn1/n2229rNmnSZF+tWrX8rbfeOnrt2rU1i6pr165d1dq0abNv7969Nnny5Eb5y0855ZQdzz77bCOAZ599tnH+8q1bt1Yv7j4OFKv508zMRh/qvbs/XNydSeEyMzMZNmwYubm55OXlcemllxZ0SKekpDBgwAAef/xx/vOf/1CjRg2OOeYYJkyYAMDjjz/OihUruOeeewr6Fd5++22aNWtWnh9JpMqKdzhyaapWrRrTp0//euTIka0fffTR42rVquWtWrXae/fdd6/99a9/3SYxMbFT165dd7Vr167IG7luu+22taeddlrHRo0a5Zxyyik7duzYUR3gySef/G7w4MHH//Wvfz3u/PPP35Jffvjw4ZsuuOCCE4qzjwMd8lHOZnZnrA3dvfCZBw+DHuUsZaWyTexYlVTEYx/rUc6LFy/O6NatmwZEFWHx4sVNunXr1rawdYds0YSRSERE5MgTs0PHzPqa2VQzWxr8TDGzM8smNBERqQpiDW/uD/wdmAFcDlwB/BP4u5n1K5vwRESksos1GOC3wMXuvjhqWZqZpQKPEUk6IiIiMcVKNMcdkGQAcPfPzOzYEGM6YlTETlERkdIWq49mZwnXiYiIFIjVomlvZoXNKmjA8SHFIyJSsd3VoFQfE8BdW4u8L8fMug8YMGDTtGnTVkJk8t1mzZp1S05O3vnuu++uKO4u//znPzetW7du3o033rix6NKHL1ai+UmMdQ+WdiAiIlK4OnXq5C1fvrzOjh07rF69ev7GG2/UP/bYY/eVtL7oWaDLwiEvnbn7e7F+yjJIEZEj3dlnn731tddeawgwadKkRpdccsmm/HXbtm2r9rOf/axtly5dOnbs2LFgKv9rrrmm9S233NIcYOrUqfVTUlJOzM3NZfTo0S3uuOOOYwGWLFlSq3fv3oknnnhip06dOnVcunRprby8PH7+85+36tChQ1JiYmKnZ5999pjDiT3W8OafmNkNUe/nm9k3wc+gw9mpiIgUz9ChQze98sorx+zatcuWLVtWt1evXgV95b///e+b9+3bd1t6evqyDz74YPkf/vCHVtu2bas2bty4NW+++Wajt9566+ibb765zYQJEzKqV6++X72XX355u1/84hfrly9f/nlqauoXbdq02Tdx4sSG6enpdZYtW7Z09uzZX95xxx2tvv322xI/ZC3WYIBbgeg+mlrAqcCZwC9LukMRESm+Hj167F69enWtZ599ttHZZ5+9NXrd3Llz6z/yyCPNTzrppE5nnHHGiXv37rUVK1bUPProo/P+9re/ZQwcODDx+uuvX5+UlLTfUxE3b95c7fvvv6951VVXbQGoW7euH3300XkffPDB0ZdeeummhIQEWrdundOjR48d8+bNO2j26HjF6qOp6e6rot7Pc/eNwEYzO6qkOxQRkZI5//zzt9x5552t33777eXr168v+P52d6ZMmbKiW7duBz1eNy0trU6DBg1yyvOxz7FaNPtdk3P3G6PeNkVERMrUL3/5yw233HLL2tNOO2139PK+fftue+ihh47Ny8sD4L///W8dgC+//LLmE088cdzChQs/nz17doM5c+bs10g45phj8o477rjsF154oSHA7t27bfv27dX69OmzfcqUKY1ycnJYu3ZtwoIFC+r98Ic/LPFtLbFaNPPN7Hp3fzZ6oZn9HFhQ0h2KiFRqcQxHDkv79u33/eEPf1h/4PKxY8euHTFiRJuTTjqpU15enrVu3Xrv7NmzV1x99dVt77vvvlVt27bd9+yzz2Zcd911bdPS0pZFb/viiy+uvP76639w7733tqhRo4a/9tprXw8dOnTLhx9+WK9jx45JZuZ333336jZt2uSUNO5YjwloBrwJ7AUWBYu7E+mrudjdv49ZsVlt4P2gfAIwxd1jPnrgSHtMgGYGKD869uWnIh57PSbg8JX0MQHrgd5mdhaQFCye6e5z4tzvXuAsd99hZjWAeWb2L3f/uBixi4hIJRfr0hkAQWKJN7lEb+fAjuBtjeCn8OaTiIhUWTGfR3O4zKy6maUB64F33H1+mPsTEZGKJ9YNm7UOt3J3z3X3ZKAVcJqZdS5kPyPMLNXMUrOyynRWBBERKQOxWjQfAZjZC4e7E3ffArwLnF/IumfcPcXdU5o21ahpEZGqJuYNm2Z2OZEBAT89cKW7vx6rYjNrCuxz9y1mVgc4B3jgsKIVEZFKJ1ai+QWRxzc3BC46YJ0DMRMN0ByYYGbVibScXnX3GSWMU0SkQugyoUupPiYgfVh6kfflLF++vOaFF17Y4auvvlqav2z06NEt6tWrl/ujH/1ox29+85vW2dnZ1bKzs+3iiy/e/PDDD6/NL3fttde2njFjxjGZmZmfHTjPWVmJNbx5HpEhyanu/nxxK3b3z4CTDyc4ERGJ7brrrms3adKkr3v16rU7JyeHxYsX185fl5uby6xZsxo2b948+5///OfRF1100fbyiDGeUWcvmNlNZjYl+PlVcF+MiIiUs02bNiW0adNmH0BCQgLdu3ffk79u5syZR3fo0GH38OHDs15++eVG5RVjPInmSSIzAjwZ/JwC/C3MoEREJD4jRoz4vmPHjp3POeec9n/5y1+a7Nq1y/LXvfzyy40uvfTSTVdcccXm2bNnN9i7d6/Fqiss8SSaU919mLvPCX6uIfK4ABERKQNmhecHM+PBBx/M/Oijj5adffbZ21599dXGZ555ZiLAnj17bM6cOQ0uv/zyLY0aNcpLTk7e+frrr9cv08ADRc4MAOSaWXt3/xrAzI4HcsMNS0RE8h177LE5W7du3a8nf9OmTdXbtWu3FyApKWlvUlJS1ujRo7MaN26cvG7duupz5sypt3379uqdO3dOAti9e3e12rVr5w0ZMmRrYfsIUzwtmt8C75rZXDN7j8h0NDeHG5aIiORr0KBBXrNmzfZNnz79aIDvv/+++ty5cxucddZZOyZPntwg//EA6enptatXr+5NmjTJnTRpUqO//vWv365ZsyZ9zZo16RkZGenz5s2rv3379lBnhClMPHOdzTazDsCJwaLl7n7Qw3VERI4E8QxHDsOECRNWjhw5ss2tt97aGmDMmDFrk5KS9o4ZM6blbbfd1rp27dp5CQkJ/txzz63cvXt3tffff7/BhAkTvs3fvn79+nkpKSk7Jk+e3OD666/fXJaxx3PpjCCxfBZyLCIicgjdu3ffM3/+/C8PXD5jxoxvCiu/devWtAOXvf3221+HEFqRyrwJJSIiRxYlGhERCVWRicYirjSzO4L3bczstPBDExGpEPLy8vLK5f6TyiI4PnmHWh/vDZu9gCHB++3AE4cfmohIpbAkKyurgZJN4fLy8iwrK6sBsORQZeIZDNDD3U8xs08B3H2zmdUsrSBFRCqynJyc4evWrXtu3bp1nVF3Q2HygCU5OTnDD1UgnkSzL5iB2aFg+v9DNpFERKqS7t27rwcGlHcclVk82Xkc8AbQzMzuA+YBfwo1KhERqTLiuWHzJTNbCPwYMOBid18WemQiIlIlFJlozKwRsB6YFLWshrvvCzMwERGpGuK5dLYIyAK+BL4KXmeY2SIzK9UnzYmISNUTT6J5B+jn7k3cvTFwATADGElk6LOIiMghxZNoerr7v/PfuPvbQC93/xioFVpkIiJSJcQzvDnTzMYAk4P3lwHfB0OeNcxZRERiiqdFcznQCngz+GkTLKsOXBpWYCIiUjXEM7x5A/CrQ6xeUbrhiIhIVRPP8OamwK1AElA7f7m7nxViXCIiUkXEc+nsJeALoB1wN5ABfBJiTCIiUoXEk2gau/vzwD53f8/drwXUmhERkbjENalm8G+mmfUH1gKNwgtJRESqkngSzR/NrAFwM/AYUB8YFWZQIiJSdcSTaDa7+1ZgK9AXwMxODzUqERGpMuLpo3kszmUiIiIHOWSLxsx6Ab2BpmY2OmpVfSI3a4qIiBQp1qWzmkC9oMzRUcu3AYPCDEpERKqOQyYad38PeM/Mxrv7t2UYk4iIVCHxDAaoZWbPAG2jy2tmABERiUc8ieY14CngOSA33HBERKSqiSfR5Lj734pbsZm1BiYCxwIOPOPujxa3HhERqdziGd78lpmNNLPmZtYo/yeO7XKAm929E9ATuMHMOh1WtCIiUunE06IZFvz726hlDhwfayN3zwQyg9fbzWwZ0BL4vARxiohIJRXP82jaHe5OzKwtcDIw/3DrEhGRyqXIS2dmVtfM/hCMPMPMOpjZhfHuwMzqAVOBUe6+rZD1I8ws1cxSs7KyihO7iIhUAvH00fwDyCYySwDAGuCP8VRuZjWIJJmX3P31wsq4+zPunuLuKU2bNo2nWhERqUTiSTTt3f3PBI8LcPddgBW1kZkZ8DywzN0fPqwoRUSk0oon0WSbWR0iAwAws/bA3ji2Ox0YCpxlZmnBT7+ShyoiIpVRPKPO7gRmAa3N7CUiCeTqojZy93nE0fIREZGqLZ5RZ++Y2SIi98IY8Gt33xB6ZCIiUiXEM+psIJHZAWa6+wwgx8wuDj0yERGpEuLpo7kzeMImAO6+hcjlNBERkSLFk2gKKxNP346IiEhciSbVzB42s/bBz8PAwrADExGRqiGeRPMrIjdsvgJMBvYAN4QZlIiIVB0xE42ZVQdmuPttwd37p7r77919ZxnFJyIxXHvttTRr1ozOnTvHLPfJJ5+QkJDAlClTAEhLS6NXr14kJSXRtWtXXnnllbIIV45QMRONu+cCeWbWoIziEZFiuPrqq5k1a1bMMrm5uYwZM4Zzzz23YFndunWZOHEiS5cuZdasWYwaNYotW7aEHK0cqeLp1N8BpJvZO0BBS8bdbwotKhGJS58+fcjIyIhZ5rHHHuOSSy7hk08+KViWmJhY8LpFixY0a9aMrKwsGjZsGFKkciSLJ9G8HvyISCWzZs0a3njjDd599939Ek20BQsWkJ2dTfv27cs4OjlSxDMzwIRgrrM27r68DGISkVIyatQoHnjgAapVK/wqeWZmJkOHDmXChAmHLCNyuOKZGeAiII3IfGeYWbKZTQ85rmIrqlN02rRpdO3aleTkZFJSUpg3bx6gTlGp2lJTUxk8eDBt27ZlypQpjBw5kjfffBOAbdu20b9/f+677z569uxZvoFKlRbPKcxdwGnAFgB3T6OIxziXh6I6RX/84x+zePFi0tLS+Pvf/87w4cMBdYqWhqKS/EsvvUTXrl3p0qULvXv3ZvHixQXrHnnkEZKSkujcuTNDhgxhz549ZRX2EWHlypVkZGSQkZHBoEGDePLJJ7n44ovJzs5m4MCBXHXVVQwaNKi8w5QqLp5Esy96CppAXhjBHI4+ffrQqFGjQ66vV68ekUfkwM6dOwteJyYm0qFDB2D/TlGJX1FJvl27drz33nukp6dz++23M2LECCDSfzBu3DhSU1NZsmQJubm5TJ48uazCrhKGDBlCr169WL58Oa1ateL555/nqaee4qmnnoq53auvvsr777/P+PHjSU5OJjk5mbS0tLIJWo448QwGWGpmlwPVzawDcBPwYbhhheONN97gd7/7HevXr2fmzJkHrVenaMkUNfKpd+/eBa979uzJ6tWrC97n5OSwe/duatSowa5du2jRokWYoVY5kyZNirvs+PHjC15feeWVXHnllSFEJHKweGcGSCLysLOXga3AqBBjCs3AgQP54osvePPNN7n99tv3W5ffKfqPf/xDnaIhev7557ngggsAaNmyJbfccgtt2rShefPmNGjQYL97PUSkajjkN6qZ1TazUcCfge+AXsHMAH9w90p9Ib1Pnz588803bNgQeayOOkXLxrvvvsvzzz/PAw88AMDmzZuZNm0aK1euZO3atezcuZMXX3yxnKMUkdIW69R9ApACpAMXAA+WSUQhWbFiBe4OwKJFi9i7dy+NGzdWp2gZ+eyzzxg+fDjTpk2jcePGAPznP/+hXbt2NG3alBo1avDTn/6UDz+slFdlRSSGWH00ndy9C4CZPQ8sKJuQSmbIkCHMnTuXDRs20KpVK+6++2727dsHwC9+8QumTp3KxIkTqVGjBnXq1OGVV17BzAo6RTdu3FhwDTu/g1RKx3fffcdPf/pTXnjhhf3uSG/Tpg0ff/wxu3btok6dOsyePZuUlJRyjFREwhAr0ezLf+HuOfmjtCqqojpFx4wZw5gxYw5ark7Rw1dUkr/nnnvYuHEjI0eOBCAhIYHU1FR69OjBoEGDOOWUU0hISODkk08uGJEmIlWH5V9OOmiFWS7/m9vMgDrAruC1u3v90g4mJSXFU1NTS7vaCqvLhC6h1p8+LD3U+iuzyn7s29528KjJ0pQxtn9odVfEY29mC91dzemQHLJF4+7VyzIQERGpmjSOV0REQqVEIyIioYpnZoAKLcxr1WFepxYROVKoRSMiIqGq9C0aKT9qTYpIPNSiERGRUCnRiIhIqJRoREQkVEo0IiISKiUaEREJlRKNiIiESolGRERCpUQjIiKhCi3RmNnfzWy9mS0Jax8iIlLxhdmiGQ+cH2L9IiJSCYSWaNz9fWBTWPWLiEjlUO59NGY2wsxSzSw1KyurvMMREZFSVu6Jxt2fcfcUd09p2rRpeYcjIiKlrNwTjYiIVG1KNCIiEqowhzdPAj4CTjSz1WZ2XVj7EhGRiivMUWdD3L25u9dw91bu/nxY+xKRcMyaNYsTTzyRE044gbFjxx60fvz48TRt2pTk5GSSk5N57rnnAHj33XcLliUnJ1O7dm3efPPNMo5eKgo9YVNECpWbm8sNN9zAO++8Q6tWrTj11FMZMGAAnTp12q/cZZddxuOPP77fsr59+5KWlgbApk2bOOGEEzj33HPLKnSpYNRHIxVeSc+q09LS6NWrF0lJSXTt2pVXXnmlrEOv1BYsWMAJJ5zA8ccfT82aNRk8eDDTpk0rdj1TpkzhggsuoG7duiFEKZWBEo1UaPln1f/617/4/PPPmTRpEp9//vlB5S677DLS0tJIS0tj+PDhANStW5eJEyeydOlSZs2axahRo9iyZUsZf4LKa82aNbRu3brgfatWrVizZs1B5aZOnUrXrl0ZNGgQq1atOmj95MmTGTJkSKixSsWmRBOnos6q802dOhUzIzU1FYB9+/YxbNgwunTpQseOHbn//vvLKuQq4XDOqhMTE+nQoQMALVq0oFmzZuim4NJ10UUXkZGRwWeffcY555zDsGHD9lufmZlJeno65513XjlFKBWBEk0c4j2r3r59O48++ig9evQoWPbaa6+xd+9e0tPTWbhwIU8//TQZGRllGH3lVlpn1QsWLCA7O5v27duHGm9V0rJly/2O5erVq2nZsuV+ZRo3bkytWrUAGD58OAsXLtxv/auvvsrAgQOpUaNG+AFLhaVEE4d4z6pvv/12xowZQ+3atQuWmRk7d+4kJyeH3bt3U7NmTerXr1+W4Vd58ZxVDx06lH/84x9Uq6Y/+XideuqpfPXVV6xcuZLs7GwmT57MgAED9iuTmZlZ8Hr69Ol07Nhxv/WTJk3SZTNRoolHPGfVixYtYtWqVfTv33+/5YMGDeKoo46iefPmtGnThltuuYVGjRqVSdxVweGeVW/bto3+/ftz33330bNnz7IJuopISEjg8ccf57zzzqNjx45ceumlJCUlcccddzB9+nQAxo0bR1JSEt26dWPcuHGMHz++YPuMjAxWrVrFj370o3L6BFJRaHhzKcjLy2P06NH7/SfLt2DBAqpXr87atWvZvHkzP/zhDzn77LM5/vjjyz7QSij6rLply5ZMnjyZl19+eb8ymZmZNG/eHNj/rDo7O5uBAwdy1VVXMWjQoDKPvSro168f/fr122/ZPffcU/D6/vvvP2S/Y9u2bQu9zClHHiWaOBR1Vr19+3aWLFnCmWeeCcC6desYMGAA06dP5+WXX+b888+nRo0aNGvWjNNPP53U1FQlmjhFn1Xn5uZy7bXXFpxVp6SkMGDAAMaNG8f06dNJSEigUaNGBQn/1Vdf5f3332fjxo0Fy8aPH09ycnK5fR6RI5ESTRyKOqtu0KABGzZsKHh/5pln8uCDD5KSksLs2bOZM2cOQ4cOZefOnXz88ceMGjWqHD5F5VXSs+orr7ySK6+8MvT4RCQ29dHEIZ5r1Ydyww03sGPHDpKSkjj11FO55ppr6Nq1axlFLiJS/tSiiVNRZ9XR5s6dW/C6Xr16vPbaa2GGJiJSoSnRiMjB7moQXt3t2oRXt1RIunQmIiKhUotGKqYwz6hBZ9UiZUgtGhERCZVaNLHorFpE5LCpRSMiIqFSohERkVAp0YiISKiUaEREJFRKNCIiEiolGhERCZUSjYiIhEqJRkREQqVEIyIioVKiERGRUCnRiIhIqJRoREQkVEo0IiISKiUaEREJlRKNiIiESolGRERCpUQjIiKhCjXRmNn5ZrbczFaY2W1h7ktERCqm0BKNmVUHngAuADoBQ8ysU1j7ExGRiinMFs1pwAp3/8bds4HJwE9C3J+IiFRACSHW3RJYFfV+NdDjwEJmNgIYEbzdYWbLQ4ypWKz4mzQBNsRffEnx91AMdnUJPkEFoWNfvooZfVU49j8o7Tjkf8JMNHFx92eAZ8o7jtJgZqnunlLecRyJdOzLj469FCXMS2drgNZR71sFy0RE5AgSZqL5BOhgZu3MrCYwGJge4v5ERKQCCu3SmbvnmNmNwL+B6sDf3X1pWPurIKrEJcBKSse+/OjYS0zm7uUdg4iIVGGaGUBEREKlRCMiIqFSoonBzFqb2btm9rmZLTWzXwfLG5nZO2b2VfDvMcHyk8zsIzPba2a3HFDXb4I6lpjZJDOrXR6fqbIo5WP/6+C4LzWzUeXwcSqdEhz/K8zsMzNLN7MPzaxbVF2aiuoIp0QTWw5ws7t3AnoCNwTT6NwGzHb3DsDs4D3AJuAm4MHoSsysZbA8xd07ExkcMbhsPkKlVVrHvjNwPZGZKroBF5rZCWXzESq14h7/lcCP3L0LcC/BAAFNRSWgRBOTu2e6+6Lg9XZgGZEZD34CTAiKTQAuDsqsd/dPgH2FVJcA1DGzBKAusDbc6Cu3Ujz2HYH57r7L3XOA94Cfhv8JKrcSHP8P3X1zsPxjIvfNgaaiEpRo4mZmbYGTgfnAse6eGaxaBxwba1t3X0PkTPs7IBPY6u5vhxdt1XI4x57IfCc/NLPGZlYX6Mf+NxJLEUpw/K8D/hW8LmwqqpbhRCoVlRJNHMysHjAVGOXu26LXeWR8eMwx4sF17J8A7YAWwFFmdmVI4VYph3vs3X0Z8ADwNjALSANyQwm2Ciru8TezvkQSzZgyC1IqPCWaIphZDSL/0V5y99eDxd+bWfNgfXNgfRHVnA2sdPcsd98HvA70DivmqqKUjj3u/ry7d3f3PsBm4MuwYq5Kinv8zawr8BzwE3ffGCzWVFSiRBOLmRnwPLDM3R+OWjUdGBa8HgZMK6Kq74CeZlY3qPPHRK55yyGU4rHHzJoF/7Yh0j/zculGW/UU9/gHx/Z1YKi7RydyTUUlmhkgFjM7A/gASAfygsW/J3Kt+lWgDfAtcKm7bzKz44BUoH5QfgfQyd23mdndwGVERvN8Cgx3971l+Xkqk1I+9h8AjYkMFBjt7rPL9MNUQiU4/s8BlwTLAHLyZ3Q2s37AX/nfVFT3ldXnkIpBiUZEREKlS2ciIhIqJRoREQmVEo2IiIRKiUZEREKlRCMiIqFSopEKzSLmmdkFUct+ZmazyjMuEYmfhjdLhRfMwPwakfm2Eojch3S+u39dgroSgsk1RaSMKNFIpWBmfwZ2AkcF//4A6AzUAO5y92nB5I8vBGUAbnT3D83sTCJT128GTnL3xLKNXuTIpkQjlYKZHQUsArKBGcBSd3/RzBoCC4i0dhzIc/c9ZtYBmOTuKUGimQl0dveV5RG/yJEsobwDEImHu+80s1eITC1zKXBR1JM0axOZEmUt8LiZJROZoTm65bJASUakfCjRSGWSF/wYcIm7L49eaWZ3Ad8TeZJmNWBP1OqdZRSjiBxAo86kMvo38KtghmHM7ORgeQMg093zgKFEJnEUkXKmRCOV0b1EBgF8ZmZLg/cATwLDzGwxcBJqxYhUCBoMICIioVKLRkREQqVEIyIioVKiERGRUCnRiIhIqJRoREQkVEo0IiISKiUaEREJ1f8DjtSHodtVnUoAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "(fig, ax) = plt.subplots()\n", - "\n", - "\n", - "# Creates variable for each country and offsets as appropriate\n", - "# Annotates bar with the associated value, rounded to 2 places after the demical\n", - "can_bar = ax.bar(index - 0.25, can_gdp[\"CAN-PercentGDP\"].round(decimals=2), width=0.25, label='Canada') \n", - "mex_bar = ax.bar(index, mex_gdp[\"MEX-PercentGDP\"].round(decimals=2), width=0.25, label='Mexico')\n", - "usa_bar = ax.bar(index + 0.25, usa_gdp[\"USA-PercentGDP\"].round(decimals=2), width=0.25, label='USA')\n", - "\n", - "\n", - "# Add labels and titles for entire figure\n", - "plt.title(\"Military Spending in North America\", pad=10)\n", - "plt.ylabel('Percentage of GDP')\n", - "plt.xlabel('Year')\n", - "plt.xticks(index, year_labels)\n", - "plt.ylim(0, 5)\n", - "\n", - "\n", - "# Creates legend for the entire figure\n", - "plt.legend(loc=4, bbox_to_anchor=(1.3, 0.5))\n", - "\n", - "\n", - "# Add labels for individual bars; gives spacing (padding) between the value and the bar\n", - "ax.bar_label(can_bar, label_type=\"edge\", padding=4)\n", - "ax.bar_label(mex_bar, label_type=\"edge\", padding=4)\n", - "ax.bar_label(usa_bar, label_type=\"edge\", padding=4)\n", - "\n", - "\n", - "plt.tight_layout()\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "c0a52a3c", - "metadata": {}, - "source": [ - "Great! Now we have a well annotated, visually appealing graph that depicts an important message about the data: the percentage of the GDP spent on the military for each country for the years 2018-2020.\n", - "\n", - "From this graph, we can easily see that during this time period, Canada and Mexico contribute a smaller proportion of their GDP to military spending than the United States. This may not have been easily discernable by just looking at our large data table." - ] - }, - { - "cell_type": "markdown", - "id": "19fadd76", - "metadata": {}, - "source": [ - "### Horizontal Bar Graphs\n", - "\n", - "There may be times when you want to present data as a horizontal bar graph. Using the dollar amounts spent in 2020 for each North American country, we can create a horiztonal bar graph to represent nomimal data. First, we need to extract the data for the year of 2020:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "f1baccac", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "year2020 = military.loc[[2020]][['CAN-USD', 'MEX-USD', 'USA-USD']]" - ] - }, - { - "cell_type": "markdown", - "id": "b06712a1", - "metadata": {}, - "source": [ - "From this, we obtain a dataframe with a single row of data with values for three variables. To format this data for plotting, we can tranpose the dataframe using the `transpose()` method:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "2acad7b4", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Year2020
CAN-USD22.754847
MEX-USD6.116377
USA-USD778.232200
\n", - "
" - ], - "text/plain": [ - "Year 2020\n", - "CAN-USD 22.754847\n", - "MEX-USD 6.116377\n", - "USA-USD 778.232200" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "year2020 = year2020.transpose()\n", - "year2020" - ] - }, - { - "cell_type": "markdown", - "id": "286d0d9e", - "metadata": {}, - "source": [ - "The dataframe in this format can directly be used for plotting. To create a horiztonal bar graph, we can use the `plt.barh()` function. This function requires arguments for the `y` and `width` parameters. The `y` parameter is the categorical variables to be plotted, which are usually displayed on the x-axis of a regular bar graph. The `width` parameter corresponds to the numerical values that are associated with each categorical variable.\n", - "\n", - "We will use the index of the `year2020` dataframe as the an argument for the `y` parameter and the values in the `2020` column as an argument for the `width` parameter:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "6d4d4be5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.barh(y = year2020.index, width = year2020[2020])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "245f26fe", - "metadata": {}, - "source": [ - "In the above graph, the index is used to label the categories on the y-axis. If desired, this can be changed by using a list of the same size as an argument for the `tick_label` parameter. Additional titling and labeling can be added to this graph as well:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "f9d97586", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.barh(y = year2020.index, width = year2020[2020], tick_label = ['Canada', 'Mexico', 'USA'])\n", - "plt.title('Military Spending in North American in 2020 (USD)')\n", - "plt.xlabel('USD')\n", - "plt.ylabel('Country')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "9d60ec90", - "metadata": {}, - "source": [ - "For further customization, the bars can be colored too. To do this, the bar graph will need to be defined as a variable and then each bar color can be set by calling for the index of the bar and using the `set_color()` method like so:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "6643a16c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZoAAAEWCAYAAABfdFHAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAd3UlEQVR4nO3debxd873/8ddbIolEiIieouqYW0ODpjXUbVGK4JZLTSG0Sidu3VZbOpivan966eBHdeKGooaUqppKqf7akJAQ1FSzDChFqq3E5/fH97tlZTvDPsn+nr1zvJ+Px36cddb42Xutvd/ru9baaysiMDMzK2WZVhdgZmYDm4PGzMyKctCYmVlRDhozMyvKQWNmZkU5aMzMrCgHTT+TdI6kb+TubSU9VRl2r6RtW1Vbu5D0mKQdcvdXJf240HJekbR2iXk3Q/320e4kTZB0fT8vs9j20Z8kbShpqiT14zKPlPStfllYRPjRhAfwGPAvYExd/7uAADq7mGZb4Klu5ncCcEE/P4evAo8CrwBPAZe08LXcodXrtIf6OvM6vaau/wXACUsw3wDWbWT76GU+5wHzgVVb/Vq18wP4EjATeDlv91/qYj3fDPwd+HN1mwQOBqYBL+X3yreBwZXho4HJwDzgceCAXmq5HNivu20h91vkM6Gn9yvwO+Af+bm9lGs9BhhaGWdYnu5tpV9rt2ia61Fg/9o/kjYBhreiEEmD+zj+wcBBpDfT8sA44LclahtAtpC09ZLOpK/rqpd5jQD2Av4GHNis+Taw3KY9h34kYCKwErAzcISk/SrDLyLtKK4MfA24TNIqedhw4ChgDLAF8GHg6Mq0Z5F2PDuACcDZkjbqsghpVWA74JcNF97Y+/WIiBgJrAp8EdgPuKbWaoqIfwC/ya9BWa3eqxgoD9Je+NeBOyr9TidtoG+0aEh7m6fk7m2p7LHmeexA2uj/BbxG2luZkYd/HLiftJfyF+BTlWm3Je2dfAWYDUwi7a3tXhlnWeA5YLMu6v8BcGYPz+93wDeB20l7SFcCoyvDtwT+H/AiMAPYtm7ak4E/5Nqvp9LyI71hHgeez6/XY+S9Ryp7cSxsSRwMPJGfy9cq81kOOB94Ib9OX6aHFgGVvca8Xs4Cfp1rnAKs0810tTq+Atxc6b9IiwY4DHgY+CtwFbBa3bI/BzxE2kG5Nfebl9f5vpV1+kVgLjAL+Hgv2+FE4Eng88DMumEnAJfmOl8G7gHWB47N838S+Ehl/BWBn+TlPg2cAgzKww7J6/OMvN5Oyf1uq0y/EXBDfv5zgK/m/u8H/pi3lVmkbW9I3Wvz6fzavJjXi7p5vg1vHw28h78HfD93rw/8ExhZGf574NPdTPsF4Fe5ewTp/bt+Zfgk4LQe1tmN3W2b3TzXRt6vn6zr905S62y3Sr8JVLbhUg+3aJrrT8AKkt4taRBpD+KCvs4kIq4FTiU1hZePiLF50FxgN2AFUuicIWnzyqRvJzXZ1wQOB/6XRfdqxwOzIuKubmqfKOlLksbl+utNBD5B2kOaT3pjIml10gf0KXn5RwOXV/b+AA7INb8NGJLHQdKGwNmksFmNtPf4jh5fINgG2IC0F3mcpHfn/seTPmzWBnak73v0+wEnkvZwHwb+u5fx/y+wfu18UpWk7UnBvA/p9XocuLhutD1Ie8MbRsQHc7+xeZ1fkv9/O+kDf3XgUOAsSSv1UNPBpD3xi4F3SXpv3fDdSR96K5H21q8jnatdHTgJ+GFl3PNI63ldYDPgI8AnK8O3IO3wdFD3WkkaCdwIXEtar+uycI97AfBfpNbAVqT1+Nm6OncD3ge8h/Qa7tTDc67X3fbRrbyX/2/AvbnXRsBfIuLlymgzcv+ufLAy7frA/Ih4sMFpNwEe6K3GOo28XxcREU8AU0nPs+Z+YGzXUzSPg6b5JpE+kHckrcSnmzXjiPh1RDwSyS2klkF1o3kdOD4i/hkRr5JCbrykFfLwg3J9Xc37AuBI0hv6FmCupK/UjTYpImZGxDzgG8A+eQM/kHS+4pqIeD0ibiBt0OMr0/4sIh7Mdf0C2DT33xu4OiJujYh/5vm+3stLcWJEvBoRM0hv4NobZR/g1Ih4ISKeIgdhH0yOiNsjYj5wYaXG7rxK+oA9pYthE4CfRsSd+XkdC2wlqbMyzjcj4q/5NenOa8BJEfFaRFxDau1s0NWIkt5JOgTz84iYQ/pgrz8s8vuIuC4/x0uBVUh72q+RwqlT0ihJHaT1d1REzIuIuaTWS/XQ0jMR8f2ImN/Fc9gNmB0R34mIf0TEyxExBSAipkXEn/J0j5HC7UN1058WES/mD8eb6X1dVHW3ffTkBNLn4c/y/8uTDj9W/Q0YWT+hpE+QDl2dXpn2pUamzUaRWpgNa/D92pVnSDuDNS+TdmSKctA03yTS3vshpBZF00jaRdKfJP1V0oukD4IxlVGejXTcFYCIeIZ0eGMvSaOAXUgfoF2KiAsjYgfShv9p4GRJ1T3JJyvdj5MOxY0htaA+JunF2oO0V7lqZfzZle6/k96MkPZ235hvDrHnu6uxL/Oq625Ed/PtyY+BDkm71/VfjfQaARARr5Ce1+p9rO/5HAqN1HUQcH9ETM//XwgcIGnZyjhzKt2vAs9FxILK/+T5r0lav7Mq6/SHpBZpI/WvATzS1QBJ60u6WtJsSS+RWu9j6kZbnHWxWNNKOoIUyLvmnQJIgb5C3agrUBcIkvYgtVx3iYjn+jJtxQu8OYQWkF7/qmVJOx5AQ+/XrqxOOpRZM5I3B2rTOWiaLCIeJx1zHw9csSSzqv4jaSjpypTTgY6IGAVcQzqh2eU02fmkFsfHgD9GRK8trLz3fClwN7BxZdAale53kjb650gfOJMiYlTlMSIiTuttWaRj9G/MV9Jw0uGzxTGLRQ+7rdHdiM0SEf8iHW47mUXXxTOkD2vgjZP0K7NoC7fZt06fCKydP8BnA/9D+gAf3/NkXXqSdI5iTGWdrhAR1cM/PdX/JOkQZlfOJl3FtV5ErEC6eqrfLuutyq2RY4AP51Zwzb2k17IaAGNZeHgMSTsDPyKdB72nMt6DwGBJ63U3bZ27SYfbqp4gHQauWovKzktND+/XRUhaA3gv6VxTzbtJrb6iHDRlHApsn/fOF9cc0mGM2joaAgwFngXmS9qFdMy8N78ENiedHO62hSXpEEm7ShopaZk8/41IJ8VrDszX+w8nHc+/LO8NXwDsLmknSYMkDcvfAentXAvAZcBukraRNCTPd3G3y18Ax0paKZ83OmIx59NXk0iXiu5c6XcR8HFJm+adhFOBKflQUXfm0P2Hc48kbQWsQzrRvml+bAz8nMW4qigiZpEOzX5H0gp5m1hHUv0hru5cDawq6ShJQ/N2tUUeNpJ0aOkVSe8CPtPX+ppB0gTSetkxIv5SHZbPr0wHjs/b856k80WX52m3J7UY94qI2+umnUfayTxJ0ghJHwA+SjeHrUkXTGwuaVil3yXA1yW9I7/2O5DOr12Wl9/I+7X2PIfn9XYl6WKeayqDP0S68qwoB00B+TzK1CWczaX57/OS7swnJf+T9GH6Aunw3FUN1PIq6c2xFj23sF4i7Vk+QbrS59vAZyLitso4k0gniGeTPlj/My/jSdIb6aukIHyS9B2FXreviLiXdPXVz0ktkhdIV1otjpPytI+STkRfRtorLyqH7XFUjn1HxI2k802Xk57XOix6fqMrJwDn50NV+/SxjIOBKyPinoiYXXsA3yUF+ehepu/KRNIOzn2k9XIZix4O7VbeXnckfTjOJl1Btl0efDRp+32Z1CK4pKt59INTSK3MO5S+vPuKpHMqw/cjnXt5ATgN2Dsins3DvkE6t3FNZdrqB/ZnSVdBziXtdHwmb+tvks+n3UR6D9WcRLqK87a8/G8DEyJiZh7eyPv1B5JeJu3AnEnaFneOiNcBcrCNJx31KEoRzW69W7uRdBzpUsvF/l6FpN+RLq1car6FLekzpC/BNboXbtYS+erL84H3Rz99KEs6ElgjIr5cellL45esrA/ynuyhpBPFA5rSF9/WJn1HYz3S909+0NKizBoQEfeRLufuz2V+v7+W5UNnA5ikw0iHsX4TEbe2up5+MIR0ZdTLpEMRV5K+62JmLeRDZ2ZmVpRbNGZmVpTP0WRjxoyJzs7OVpdhZrZUmTZt2nMRsUpP4zhoss7OTqZOXdIrks3M3lokvelLpPV86MzMzIpy0JiZWVEOGjMzK8pBY2ZmRTlozMysKAeNmZkV5aAxM7OiHDRmZlaUv7CZzZgBaslv/JmZtU5HB8ye3ft4S8Itmmz+/N7HMTMbaObMKb8MB42ZmRXloDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWjMzKwoB42ZmRXloDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWjMzKwoB42ZmRXloDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFtXXQSOqUNLOu3wmSjpa0paQpkqZLul/SCXXjnSnpaUlt/RzNzAa6wa0uYAmcD+wTETMkDQI2qA3I4bIn8CTwIeDm1pRoZmZL897+24BZABGxICLuqwzbFrgXOBvYv/9LMzOzmqU5aM4AHpA0WdKnJA2rDNsfuAiYDOwqadmuZiDpcElTJU2FZ/uhZDOzt552D5rorn9EnASMA64HDgCuBZA0BBgP/DIiXgKmADt1M5NzI2JcRIyDVZpevJmZtf85mueBler6jQYeBYiIR4CzJf0IeFbSysDWwCjgHkkAw4FXgav7qWYzM6to6xZNRLwCzJK0PYCk0cDOwG2SdlVOEmA9YAHwIumw2ScjojMiOoG1gB0lDe/v+s3MrM2DJpsIfEPSdOAm4MTckjmIdI5mOjAJmAAMJQXRr2sTR8Q84DZg9/4t28zMABTR3WmQtxZpXMDUVpdhZtbvliQGJE1L57m7tzS0aMzMbCnmoDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWjMzKwoB42ZmRXloDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWjMzKwoB42ZmRXloDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWiywYNbXYGZWf/r6Ci/DH+8ZmPHwtSpra7CzGzgcYvGzMyKctCYmVlRDhozMyvKQWNmZkU5aMzMrCgHjZmZFeWgMTOzohw0ZmZWlIPGzMyKctCYmVlRDhozMyvKQWNmZkX5pprZjDkz0IkCoGNEB7OPnt3iiszMBga3aLL5C+a/0T1n3pwWVmJmNrA4aMzMrCgHjZmZFeWgMTOzohw0ZmZWlIPGzMyKctCYmVlRDhozMyvKQWNmZkU5aMzMrKiGgkbSyqULMTOzganRFs2fJF0qabwkFa3IzMwGlEaDZn3gXOAg4CFJp0pav1xZZmY2UDQUNJHcEBH7A4cBBwO3S7pF0lZFKzQzs6VaQz8TkM/RHEhq0cwBjgSuAjYFLgXWKlSfmZkt5Rr9PZo/ApOAPSLiqUr/qZLOaX5ZZmY2UPQaNJIGAb+KiJO7Gh4R32p6VWZmNmD0eo4mIhYAW/dDLWZmNgA1euhsuqSrSOdj5tV6RsQVRaoyM7MBo9GgGQY8D2xf6ReAg8bMzHrUaND8OCL+UO0h6QMF6jEzswGm0S9sfr/BfmZmZovosUWTv4y5NbCKpC9UBq0ADCpZmJmZDQy9HTobAiyfxxtZ6f8SsHeposzMbODoMWgi4hbgFknnRcTji7sQSQFcGBEH5v8HA7OAKRGx22LM79PA3yPifxe3JjMz6x+NXgwwVNK5QGd1mojYvtspFjUP2FjSchHxKrAj8HRfCq2KCN+NwMxsKdHoxQCXAncBXwe+VHn0xTXArrl7f+Ci2gBJIyT9VNLtku6S9NHc/7uSjsvdO0m6VdIykk6QdHTuv66kGyXNkHSnpHWU/B9JMyXdI2nfPtZqZmZN0miLZn5EnL2Ey7oYOE7S1cB7gJ8C/5aHfQ24KSI+IWkU6c7QNwLHAndI+j3wPWB8RLxe95M4FwKnRcRkScNI4fkfpBt+jgXG5HncGhGzqhNKOhw4HIAVl/DZmZlZlxpt0fxK0mclrSppdO3RlwVFxN2kQ2/7k1o3VR8BjpE0Hfgd6Qui74yIv5N+luAG4AcR8Uh1IkkjgdUjYnJexj/yNNsAF0XEgoiYA9wCvK+Lms6NiHERMY7hfXk2ZmbWqEZbNAfnv9XDZQGs3cflXQWcDmwLVH8eWsBeEfFAF9NsQrorwWp9XJaZmbWBRn/4bK0uHn0NGUiHy06MiHvq+l8HHFn7mWhJm+W/awJfBDYDdpG0RV1dLwNPSdojjz9U0nDg98C+kgZJWgX4IHD7YtRrZmZLqNEfPpvYVf++Xl6cf8vme10MOhk4E7hb0jLAo5J2B34CHB0Rz0g6FDhPUv0hsIOAH0o6CXgN+BgwGdgKmEFqeX05Imb3pVYzM2sORUTvI0nV280MAz4M3BkRA+ZLm1pNwacW/h/H9/66mJm91UmaFhHjehqnoRZNRBxZN+NRpKvIzMzMetToVWf15gFrNbMQMzMbmBo9R/Mr0rkOSDfTfDfwi1JFmZnZwNHo5c2nV7rnA4/nE/tmZmY9avTy5luAP5Pu4LwS8K+SRZmZ2cDRUNBI2of0PZSPAfsAUyQNmCvOzMysnEYPnX0NeF9EzAXIX4K8EbisVGFmZjYwNHrV2TK1kMme78O0Zmb2FtZoi+ZaSdex8Nb++/LmG2OamZm9SY9BI2ldoCMiviTpP0h3RQb4I+n2/GZmZj3qrUVzJuk3YYiIK4ArACRtkoftXrA2MzMbAHo7z9LRxZ2Wyf06i1RkZmYDSm9BM6qHYcs1sQ4zMxugeguaqZIOq+8p6ZPAtDIlmZnZQNLbOZqjgMmSJrAwWMYBQ4A9C9ZlZmYDRI9BExFzgK0lbQdsnHv/OiJuKl6ZmZkNCI3+Hs3NwM2FazEzswHI3+43M7OiHDRmZlaUg8bMzIpy0JiZWVEOGjMzK8pBkw0etPACvI4RHS2sxMxsYGn0ZwIGvLEdY5l6/NRWl2FmNuC4RWNmZkU5aMzMrCgHjZmZFeWgMTOzohw0ZmZWlIPGzMyKctCYmVlRDhozMyvKQWNmZkU5aMzMrCgHjZmZFeWgMTOzohw0NTNmgNT74+1vb3WlZmZLFQdNzfz5jY03Z07ZOszMBhgHjZmZFeWgMTOzohw0ZmZWlIPGzMyKctCYmVlRDhozMyvKQWNmZkU5aMzMrCgHjZmZFeWgMTOzohw0ZmZWlIPGzMyKctCYmVlRDhozMyvKQWNmZkU5aMzMrCgHjZmZFeWgMTOzohw0ZmZWlIPGzMyKctCYmVlRDhozMyvKQWNmZkU5aMzMrKiiQSPp7ZIulvSIpGmSrpG0fsHlvVJq3mZmtngGl5qxJAGTgfMjYr/cbyzQATxYarlmZtZeSrZotgNei4hzaj0iYgZwl6TfSrpT0j2SPgogqVPS/ZJ+JOleSddLWi4PO0zSHZJmSLpc0vDcfy1Jf8zzOaW2HEnLd7UMMzPrfyWDZmNgWhf9/wHsGRGbk8LoO7n1A7AecFZEbAS8COyV+18REe+LiLHA/cChuf93gbMjYhNgVoPLeIOkwyVNlTT12SV5pmZm1q1WXAwg4FRJdwM3AquTDqcBPBoR03P3NKAzd28s6feS7gEmABvl/h8ALsrdkxpcxhsi4tyIGBcR41ZpxjMzM7M3KXaOBrgX2LuL/hOAVYD3RsRrkh4DhuVh/6yMtwBYLnefB+wRETMkHQJsWxkv+rgMMzPrRyVbNDcBQyUdXush6T3AmsDcHADb5f97MxKYJWlZUojU/AHYL3dX+6+4GMswM7MCigVNRASwJ7BDvrz5XuCbwDXAuHwYbCLw5wZm9w1gCilYquN/Hvhcntfqlf4XLsYyzMysAKU8sHFSTG10ZL9mZmYASJoWEeN6Gsd3BjAzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWjMzKwoB42ZmRXloDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWjMzKwoB42ZmRXloDEzs6IcNGZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWhqBg9ubLyOjrJ1mJkNMA6amrFjIaL3x+zZra7UzGyp4qAxM7OiHDRmZlaUg8bMzIpy0JiZWVEOGjMzK8pBY2ZmRTlozMysKAeNmZkVpYhodQ1tQdLLwAOtrqMXY4DnWl1EL1xjc7jG5nCNzdFTjWtGxCo9TdzgfVfeEh6IiHGtLqInkqa6xiXnGpvDNTbHW6FGHzozM7OiHDRmZlaUg2ahc1tdQANcY3O4xuZwjc0x4Gv0xQBmZlaUWzRmZlaUg8bMzIpy0ACSdpb0gKSHJR3Twjp+KmmupJmVfqMl3SDpofx3pdxfkr6Xa75b0ub9UN8akm6WdJ+keyV9vg1rHCbpdkkzco0n5v5rSZqSa7lE0pDcf2j+/+E8vLN0jZVaB0m6S9LV7VijpMck3SNpuqSpuV/brOu83FGSLpP0Z0n3S9qqnWqUtEF+/WqPlyQd1U415uX+V36/zJR0UX4fNW97jIi39AMYBDwCrA0MAWYAG7aolg8CmwMzK/2+DRyTu48BvpW7xwO/AQRsCUzph/pWBTbP3SOBB4EN26xGAcvn7mWBKXnZvwD2y/3PAT6Tuz8LnJO79wMu6cf1/QXg58DV+f+2qhF4DBhT169t1nVe7vnAJ3P3EGBUu9VYqXUQMBtYs51qBFYHHgWWq2yHhzRze+y3F7ldH8BWwHWV/48Fjm1hPZ0sGjQPAKvm7lVJXywF+CGwf1fj9WOtVwI7tmuNwHDgTmAL0reaB9evc+A6YKvcPTiPp36o7R3Ab4HtgavzB0u71fgYbw6atlnXwIr5A1LtWmNdXR8B/tBuNZKC5klgdN6+rgZ2aub26ENnC1/kmqdyv3bRERGzcvdsoCN3t7Tu3FzejNRiaKsa8yGp6cBc4AZSi/XFiJjfRR1v1JiH/w1YuXSNwJnAl4HX8/8rt2GNAVwvaZqkw3O/dlrXawHPAj/LhyB/LGlEm9VYtR9wUe5umxoj4mngdOAJYBZp+5pGE7dHB81SJNIuRMuvR5e0PHA5cFREvFQd1g41RsSCiNiU1Gp4P/CuVtZTT9JuwNyImNbqWnqxTURsDuwCfE7SB6sD22BdDyYdaj47IjYD5pEOQ72hDWoEIJ/f+Hfg0vphra4xnx/6KCm4VwNGADs3cxkOGngaWKPy/ztyv3YxR9KqAPnv3Ny/JXVLWpYUMhdGxBXtWGNNRLwI3Exq9o+SVLu3X7WON2rMw1cEni9c2geAf5f0GHAx6fDZd9usxtqeLhExF5hMCu12WtdPAU9FxJT8/2Wk4GmnGmt2Ae6MiDn5/3aqcQfg0Yh4NiJeA64gbaNN2x4dNHAHsF6+wmIIqXl7VYtrqroKODh3H0w6L1LrPzFfpbIl8LdKU7wISQJ+AtwfEf/TpjWuImlU7l6OdA7pflLg7N1NjbXa9wZuynuYxUTEsRHxjojoJG1vN0XEhHaqUdIISSNr3aTzCzNpo3UdEbOBJyVtkHt9GLivnWqs2J+Fh81qtbRLjU8AW0oant/jtdexedtjf50Ia+cH6UqPB0nH8r/WwjouIh0jfY20t3Yo6djnb4GHgBuB0XlcAWflmu8BxvVDfduQmvh3A9PzY3yb1fge4K5c40zguNx/beB24GHS4Yuhuf+w/P/Defja/bzOt2XhVWdtU2OuZUZ+3Ft7X7TTus7L3RSYmtf3L4GV2rDGEaQ9/hUr/dqtxhOBP+f3zCRgaDO3R9+CxszMivKhMzMzK8pBY2ZmRTlozMysKAeNmZkV5aAxM7OiHDRmLSSpU5W7ded+J0g6WtKW+e6405XuTHxCHn6IpGfzbVceknSdpK1b8gTMGjC491HMrEXOB/aJiBmSBgEbVIZdEhFHAEjaDrhC0nYRcX8rCjXriVs0Zu3rbaQv8BLp/m33dTVSRNxM+k33w7sabtZqDhqz9nUG8ICkyZI+JWlYD+PeSZvdPNSsxkFj1lrd3ZojIuIkYBxwPXAAcG0P81GzCzNrFgeNWWs9T7o/V9Vo0o9JERGPRMTZpBsdjpXU3e9+bEa6eahZ23HQmLVQRLwCzJK0PYCk0aTfArlN0q75broA6wELgBfr5yHpQ6TzMz/ql6LN+shXnZm13kTgLEm1n144MSIekfTfwBmS/g7MByZExIKcPftK2ob0c9WPAnv5ijNrV757s5mZFeVDZ2ZmVpSDxszMinLQmJlZUQ4aMzMrykFjZmZFOWjMzKwoB42ZmRX1/wEqgJkCG9d6fgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "barh = plt.barh(y = year2020.index, width = year2020[2020], tick_label = ['Canada', 'Mexico', 'USA'])\n", - "\n", - "barh[0].set_color('red')\n", - "barh[1].set_color('green')\n", - "barh[2].set_color('blue')\n", - "\n", - "plt.title('Military Spending in North American in 2020 (USD)')\n", - "plt.xlabel('USD')\n", - "plt.ylabel('Country')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ed7a75f6", - "metadata": {}, - "source": [ - "The same can be done for regular bar graphs made using `plt.bar()`. Depending on your visualization preferences, `plt.bar()` and `plt.barh()` provide multiple options for constructing a bar graph." - ] - }, - { - "cell_type": "markdown", - "id": "d28b66ff", - "metadata": {}, - "source": [ - "## Pie charts\n", - "\n", - "Pie charts are a commonly used visualization method to represent proportions in datasets. Pie charts use *wedges* to represent the numerical value of a proportion corresponding to a categorial variable.\n", - "\n", - "While pie charts are very common and can be easily interpreted by a layperson audience, they may not be the best way to represent data in certain cases. Firstly, because pie charts use the area of a circle to represent the proportion of a categorical variable, it can be difficult to gauge the numerical value that a wedge represents if the area doesn't appear as an easily discernible fraction (_e.g._ ½, ⅓, ¼). This can be aided with the help of labels and legends that explicitly show the numerical values associated with the wedges of the pie chart. Secondly, if you want to visualize many categorical variables or variables that make up a significantly small proportion of the dataset, it may be difficult to see the variable on a pie chart. Overall, pie charts can be a simple and effective way to communicate proportional categorical data, but before using them, consider what attributes of the data need to be highlighted to help decide if a pie chart is the most appropriate visualization method. \n", - "\n", - "Now, let's look at the total amount of money spent on the military in Mexico from 1970 - 1975 and determine the proportion of the total amount for each year. To do this, we will extract data from the years 1970-1975 and call it `mex70s`. Then, we will make a pie chart using the `plt.pie()` function. We will use `mex70s` to determine the wedge sizes. We'll also set the figure size, in inches, using `plt.figure()`." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "63c723fa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
MEX-USD
Year
19700.1768
19710.1912
19720.2424
19730.3008
19740.4072
19750.5048
\n", - "
" - ], - "text/plain": [ - " MEX-USD\n", - "Year \n", - "1970 0.1768\n", - "1971 0.1912\n", - "1972 0.2424\n", - "1973 0.3008\n", - "1974 0.4072\n", - "1975 0.5048" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mex_70s = military.loc[np.arange(1970, 1976), ['MEX-USD']]\n", - "\n", - "mex_70s" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "b156e98f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 6))\n", - "\n", - "plt.pie(x = mex_70s['MEX-USD'])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "e12d0bf4", - "metadata": {}, - "source": [ - "Now that we have a pie chart, let's add some more detail to it to make it more descriptive.\n", - "\n", - "We can label the sectors of the chart so that we know which year corresponds to which color. Likewise, we can label the percentage of each sector to know the definitive proportion of each years's contribution to the total amount of money spent on the military in Mexico from 1970-1975.\n", - "\n", - "To do this, we will create an array called `years`, containing the integers 1970, 1971, 1972, 1973, 1974, and 1975. We then use `years` as an argument for the `labels` parameter within `plt.pie()` and specify formatting for the `autopct` parameter, which labels the wedges using the printf style format. More information on that format can be found here." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "db7549c6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 6))\n", - "\n", - "years = np.arange(1970, 1976)\n", - "\n", - "plt.pie(x = mex_70s['MEX-USD'], labels=years, autopct='%.1f')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "e2b162dd", - "metadata": {}, - "source": [ - "This plot is okay, but it can be better.\n", - "\n", - "The percentages may be difficult to see as the labeling competes with the color of the wedge. Instead, let's add the percentages into a legend along with the labels of each sector. Let's also add a title so others can know what they are looking at when they view this chart." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "0d310f32", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(10, 6))\n", - "\n", - "\n", - "patches, text = plt.pie(x = mex_70s['MEX-USD'])\n", - "labels = ['1970 (9.7 %)', '1971 (10.5 %)', '1972 (13.3 %)', '1973 (16.5 %)', '1974 (22.3 %)', '1975 (27.7%)']\n", - "\n", - "# Finds the sum of usd_2000 and rounds it to 1 position after the decimal\n", - "total = mex_70s['MEX-USD'].sum().round(decimals=1) \n", - "\n", - "plt.legend(patches, labels, loc=4, bbox_to_anchor=(1.5, 0.3), fontsize=15)\n", - "plt.title(\"Military Spending in Mexico from 1970-1975\" + \" (\" + str(total) + \" Billion USD)\", loc = 'center',\n", - " fontsize = 15)\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "71eb38e3", - "metadata": {}, - "source": [ - "Above, we used `plt.pie()` in a way that we had not used it before.\n", - "\n", - "Under the hood, the `plt.pie()` function returns two default outputs, which we named: `patches` and`text`. The size of each wedge is dictated by the `patches` object. The `text` object consists of a list of labels for our data. Here, we needed to specifically assign `patches` and `text` objects so we could use `patches` as an argument for the `plt.legend()` function. \n", - "\n", - "The `plt.legend()` function has two required arguments. The first argument dictates **what** is being labeled. In our case, the wedges of the pie chart (*i.e.* the `patches` object) are being labeled. The second argument dictates **how** things are labeled. Here, we simply created a variable called labels, which consists of the six strings for the six wedges:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "b4eb218d", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "['1970 (9.7 %)',\n", - " '1971 (10.5 %)',\n", - " '1972 (13.3 %)',\n", - " '1973 (16.5 %)',\n", - " '1974 (22.3 %)',\n", - " '1975 (27.7%)']" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "labels" - ] - }, - { - "cell_type": "markdown", - "id": "9721e589", - "metadata": {}, - "source": [ - "The other arguments, `bbox_to_anchor` and `fontsize`, are optional when using the `plt.legend()` function.\n", - "\n", - "The argument `bbox_to_anchor` designates the position in the plotting area where the legend will be, while the `fontsize` argument dictates the font size, in points, of the legend text.\n", - "\n", - "As mentioned previously, labeling can greatly enhance the efficiency of of a pie chart's ability to communicate information. Because some of the wedges are very similar in size, it can be hard to discern the numeric value associated with each year. Labeling each wedge with the percentage and associated category or making a legend that depicts this information leaves less room for ambiguity when it comes to the data." - ] - }, - { - "cell_type": "markdown", - "id": "e64c6b88", - "metadata": {}, - "source": [ - "## Conclusions\n", - "\n", - "In this section, we were introduced to the `plt.bar()` and `plt.pie()` functions to construct bar plots and pie charts, respectively.\n", - "\n", - "The `plt.bar()` function requires `x` and `height` arguments, which can be an array of number values, but other parameters can be included.\n", - "\n", - "The `plt.pie()` function only requires an `x` argument as an array of values and has other parameters that can be utilized well.\n", - "\n", - "Both of these types of visualizations are used for depicting categorical data.\n", - "\n", - "As a reminder, when deciding on whether to use a pie chart, consider certain attributes of the data, such as the number of categorical variables or the size of the proportions to be plotted. Below is a list of functions with linked documentation for your reference and further reading:\n", - "\n", - "- plt.bar( )\n", - "- plt.pie( )\n", - "- plt.boxplot( ) \n", - "- plt.title( )\n", - "- plt.ylim( )\n", - "- plt.xlim( )\n", - "- plt.ylabel( )\n", - "- plt.xlabel( )\n", - "- plt.xticks( )\n", - "- ax.bar( )\n", - "- ax.legend( )\n", - "- plt.tight_layout( )\n", - "- plt.figure( )\n", - "- plt.show( )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "69a868f4", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/textbook/09/3/Numerical_Data.ipynb b/textbook/09/3/Numerical_Data.ipynb new file mode 100644 index 00000000..430a0480 --- /dev/null +++ b/textbook/09/3/Numerical_Data.ipynb @@ -0,0 +1,779 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0fb30d10", + "metadata": {}, + "source": [ + "# Numerical Data\n", + "\n", + "Numerical data consists of values including integers and rational numbers. Temperature collections, height recordings, and numerical grades in a class are examples of numerical data. In this section, we will practice making histograms, scatter plots, and line graphs to represent numerical data.\n", + "\n", + "Again, we'll load the necessary libraries and data." + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "3e479dc7-ce8e-4ca7-ae35-79038cf4bf99", + "metadata": { + "tags": [ + "hide_cell" + ] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "sns.set_style('whitegrid')\n", + "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "NorthAmerica_Military_USD_PercentGDP_Combined_csv = '''\\\n", + "Year,CAN-PercentGDP,MEX-PercentGDP,USA-PercentGDP,CAN-USD,MEX-USD,USA-USD\n", + "1960,4.18525654,0.673508659,8.993124587,1.702442711,0.084,47.34655267\n", + "1961,4.128312243,0.651780326,9.1560315,1.677820881,0.0864,49.87977061\n", + "1962,3.999216389,0.689655172,9.331672945,1.671313753,0.0992,54.65094261\n", + "1963,3.620650112,0.718685832,8.831891186,1.610091701,0.112,54.56121578\n", + "1964,3.402062837,0.677506775,8.051281106,1.657457283,0.12,53.43232706\n", + "1965,2.930260659,0.591269841,7.587247177,1.57470454,0.1192,54.56179126\n", + "1966,2.683282422,0.576379066,8.435300286,1.614422827,0.1304,66.44275153\n", + "1967,2.74792677,0.545217107,9.417795933,1.775500366,0.1336,78.39844224\n", + "1968,2.54364188,0.548510764,9.268454275,1.797265817,0.1488,84.32903122\n", + "1969,2.27378467,0.600160043,8.633263795,1.770108751,0.18,84.99016543\n", + "1970,2.188979696,0.497411659,8.032743584,1.889157918,0.1768,83.407993\n", + "1971,2.131485639,0.48765558,6.943069609,2.077659711,0.1912,78.23797989\n", + "1972,2.011818438,0.536568089,6.519756924,2.233737031,0.2424,80.70807097\n", + "1973,1.832601818,0.544217687,5.893870591,2.363060955,0.3008,81.46979441\n", + "1974,1.783813085,0.565744137,5.954111197,2.809465529,0.4072,89.27892034\n", + "1975,1.863541853,0.57358422,5.622679096,3.18091549,0.5048,92.08092875\n", + "1976,1.765927978,0.598103574,5.191071429,3.581805735,0.531576968,94.71525108\n", + "1977,1.8057636,0.534256205,5.155617351,3.752174526,0.437692986,104.665219\n", + "1978,1.848887401,0.504834431,4.943087248,3.969158477,0.518287193,113.3820637\n", + "1979,1.711245918,0.505297474,4.951991535,4.084145738,0.679663588,126.8799271\n", + "1980,1.764448615,0.416107383,5.153537467,4.744402251,0.810422204,143.6883549\n", + "1981,1.709915638,0.513301014,5.646541256,5.141128191,1.284948561,176.5588753\n", + "1982,1.954343585,0.495419418,6.814057094,6.017321456,0.858130163,221.6735426\n", + "1983,2.081196249,0.522866314,6.32114426,6.947104072,0.778556797,223.427165\n", + "1984,2.117188855,0.65981906,6.23641653,7.349795764,1.155945373,245.1491683\n", + "1985,2.097376234,0.676313139,6.453219205,7.460563318,1.241863652,272.1632293\n", + "1986,2.109197118,0.634622463,6.626522658,7.78013674,0.817296612,295.5462238\n", + "1987,2.062576371,0.580341889,6.420274023,8.694447168,0.813391574,304.0866487\n", + "1988,1.986767119,0.536145374,6.071277702,9.897335684,0.981914646,309.6612693\n", + "1989,1.934614309,0.517255829,5.871206008,10.74713469,1.153375828,321.8665588\n", + "1990,1.958793742,0.433081035,5.605175294,11.41463185,1.210872502,325.129314\n", + "1991,1.895444339,0.435402301,4.883429398,11.3385033,1.459136041,299.3727791\n", + "1992,1.8616877,0.469454656,4.970466808,10.78880312,1.824550066,325.033736\n", + "1993,1.821753504,0.442785494,4.604350295,10.26882262,2.122980338,316.7194437\n", + "1994,1.696680257,0.518830327,4.215264675,9.57737764,2.635284079,308.084\n", + "1995,1.554090071,0.450891531,3.860245792,9.176903908,1.562615372,295.8530977\n", + "1996,1.403752581,0.476484778,3.554982206,8.615884471,1.882873103,287.9606687\n", + "1997,1.246243202,0.458095854,3.405562244,7.945140183,2.184061042,293.1678258\n", + "1998,1.256293902,0.450450487,3.201558499,7.748607984,2.263223453,290.9960551\n", + "1999,1.241703064,0.460988776,3.085676783,8.21077854,2.652912012,298.0948913\n", + "2000,1.11808088,0.44604782,3.112242147,8.299385231,3.031454509,320.0863242\n", + "2001,1.137368973,0.442657004,3.123809803,8.375571425,3.229469276,331.8056106\n", + "2002,1.120852292,0.421606002,3.447618099,8.495399281,3.172268734,378.4631388\n", + "2003,1.115878799,0.405916547,3.827161045,9.958245602,2.960496802,440.5320696\n", + "2004,1.107966027,0.364898723,4.016312736,11.33648983,2.854385965,492.9993762\n", + "2005,1.110669655,0.355958931,4.090034876,12.98813296,3.123454978,533.203\n", + "2006,1.125832408,0.311171936,4.041627237,14.8098928,3.035131019,558.335\n", + "2007,1.188901783,0.401163918,4.079655081,17.41713993,4.223037646,589.586\n", + "2008,1.248621382,0.390513227,4.463827356,19.3420584,4.334654124,656.756\n", + "2009,1.377555631,0.501556275,4.88559968,18.93622605,4.514233914,705.917\n", + "2010,1.194338338,0.452734493,4.922641677,19.31568883,4.789031339,738.005\n", + "2011,1.193291895,0.465777803,4.840173995,21.39372086,5.498458542,752.288\n", + "2012,1.118404598,0.475987281,4.477401219,20.45210711,5.717035575,725.205\n", + "2013,1.0023672,0.507919455,4.046678879,18.51573121,6.473144378,679.229\n", + "2014,0.989925299,0.513829957,3.69589465,17.85364048,6.758693845,647.789\n", + "2015,1.152709374,0.466676122,3.477845166,17.93764189,5.468837812,633.829639\n", + "2016,1.164161567,0.495064414,3.418942337,17.78277554,5.33687574,639.856443\n", + "2017,1.351602232,0.436510296,3.313381294,22.26969632,5.062076646,646.752927\n", + "2018,1.324681094,0.477517407,3.316248808,22.72932758,5.839521271,682.4914\n", + "2019,1.27894142,0.52348249,3.427080181,22.20440844,6.650808254,734.3441\n", + "2020,1.415055841,0.573651659,3.741160091,22.75484713,6.116376582,778.2322\n", + "'''\n", + "\n", + "from io import StringIO\n", + "\n", + "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", + "\n", + "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')" + ] + }, + { + "cell_type": "markdown", + "id": "5190be46", + "metadata": {}, + "source": [ + "## Histograms\n", + "\n", + "Histograms are a great way to view distributions of numerical data. In histogram plots, a numerical component of data is divided into what are called *bins*. As data points are assigned to their respective bins, the total number of data points in each bin is quantified and plotted, visualizing a distribution of frequencies. In the upcoming exercise, we will explore how to visualize a distribution of values in our dataset.\n", + "\n", + "\n", + "Let's examine military spending in the United States from 1960 to 2020. We can look at multiple ranges of dollar amounts spent on the military as our independent variable and organize them into bins. After, we can determine how many fiscal years fall into each of these bins and visualize the distribution.\n", + "\n", + "First, we will need to extract the data pertaining to the military spending in the United States. We will call it `hist_data`. Then, we will need to determine the minimum and maximum values of this subset of data so that we can determine the range of values." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a45eb875", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'min': 47.34655267, 'max': 778.2322}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hist_data = military[\"USA-USD\"]\n", + "\n", + "{\n", + " 'min': hist_data.min(),\n", + " 'max': hist_data.max(),\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "b21d2e3e", + "metadata": {}, + "source": [ + "We see that the minimum amount the United States spent on the military between the years of 1960 and 2020 was about \\$47 billion, while the maximum amount was about \\$780 billion.\n", + "\n", + "With this information, we will create a range for our bins, named `binnum`, with integers between 0 and 801, so that it is inclusive of all the data values. We make the interval of the range 100, giving us eight evenly spaced bins." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ccfb3ade", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 100, 200, 300, 400, 500, 600, 700, 800]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "binnum = range(0, 801, 100)\n", + "\n", + "list(binnum)" + ] + }, + { + "cell_type": "markdown", + "id": "55e62707", + "metadata": {}, + "source": [ + "To graph the distribution of military spending, we will make a histogram by calling the `plt.hist()` funtion.\n", + "\n", + "Minimally, this function needs an input set of values. Additionally, we will specify the bins, so that they are evenly distributed on the x-axis. We do this by inputting `binnum` as our `bins` argument. If we do not specify the `bin` argument, the data will be divided into 10 bins." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "daae9915", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(hist_data, bins=binnum)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6043632d", + "metadata": {}, + "source": [ + "Now that we have our plot, let's add additional details to make it more understandable:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "942043f1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(hist_data, bins=binnum)\n", + "plt.title(\"Distribution of Military Spending in the United States from 1960 to 2020\")\n", + "plt.ylabel('Counts of Fiscal Years')\n", + "plt.xlabel(\"Dollar Amount (USD)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5e52c962", + "metadata": {}, + "source": [ + "Awesome! From this plot, we can see that the United States had the highest frequency of fiscal years where \\$0 - \\$100 billion was spent on the military. We can also see that the \\$400 - \\$500 billion bin had the lowest frequency with only two years spending that range of money." + ] + }, + { + "cell_type": "markdown", + "id": "1af7e1d3", + "metadata": {}, + "source": [ + "## Scatter plots\n", + "\n", + "Next, we'll examine the use of a scatter plot as another visualization tool for numerical data.\n", + "\n", + "Scatter plots visualize the relationship between two numerical variables. For this exercise, let's examine the percentage of the GDP of Mexico spent on the military versus the absolute dollar amount (in USD) over 1960-2020.\n", + "\n", + "We'll simply extract the columns for this data and assign them to `mex_gdp` and `mex_usd`, respectively. Then, we can plot this data using the `plt.scatter()` function." + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "deb40aae", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mex_gdp = military[['MEX-USD']]\n", + "\n", + "mex_usd = military['MEX-PercentGDP']\n", + "\n", + "plt.scatter(mex_gdp, mex_usd) # mex_gdp on the x-axis, mex_usd on the y-axis\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4fba0f1f", + "metadata": {}, + "source": [ + "Looking at this scatter plot out of context, it would be hard to understand what the data means. Let's add the important details to make it clear:" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "bc576939", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(fig, ax) = plt.subplots()\n", + "\n", + "plt.scatter(mex_gdp, mex_usd)\n", + "\n", + "plt.title(\"% GDP vs. Absolute Spending on Military in Mexico 1960 - 2020\", pad=10)\n", + "\n", + "ax.set_ylabel('Spending in USD (Billions)')\n", + "ax.set_xlabel('Percentage of GDP')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cd5d171b", + "metadata": {}, + "source": [ + "Now, we have a better understanding of the data, which depicts the relationship between the percentage of the Mexican GDP spent on the military and the total amount spent in USD from the years 1960 to 2020. \n", + "\n", + "In addition to this information, we can add a color scheme that will color each data point based on the year of collection. This adds another dimension of analysis, using year as a feature; the context of the spending relationship can be examined over time:" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "23a45386", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(fig, ax) = plt.subplots()\n", + "plt.title(\"% GDP vs. Absolute Spending on Military in Mexico 1960 - 2020\", pad=10)\n", + "ax.set_ylabel('Spending in USD (Billions)')\n", + "ax.set_xlabel('Percentage of GDP')\n", + "\n", + "\n", + "mex_years = mex_gdp.index\n", + "\n", + "plt.scatter(mex_gdp, mex_usd, c=mex_years, alpha=0.4, cmap='winter')\n", + "\n", + "plt.colorbar()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "20146a6e", + "metadata": {}, + "source": [ + "The `plt.scatter()` function minimally needs two arguments - *x* and *y* - which are array-like variables. Other optional arguments include `c`, which determines how to color the data points; `alpha`, which sets the opacity of the data points; and `cmap` which sets the Colormap used to color the data points. \n", + "\n", + "We used the years of the dataset (which we defined as the index earlier in this chapter) as our `c` argument to color the data points based on the year of collection. We used used the 'winter' Colormap as our `cmap` argument, but many other Colormaps are available for your choosing. A list of other possible Colormaps to explore is linked at the end of this section.\n", + "\n", + "The `plt.colorbar()` function displays a scale of the Colormap based on the feature used to color the data, which in our case is the year of collection." + ] + }, + { + "cell_type": "markdown", + "id": "30ba35e7", + "metadata": {}, + "source": [ + "## Line graphs\n", + "\n", + "Line graphs are used to visualize sequential numerical data. Using line graphs, we can easily see trends within data over time.\n", + "\n", + "Let's examine the spending (in USD) on the military in Canada in the 21st century (2000-2020).\n", + "\n", + "This can be done most quickly through the pandas Series." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b26501e3-def6-48f3-80e5-d238e8220f9f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Year\n", + "2000 8.299385\n", + "2001 8.375571\n", + "2002 8.495399\n", + "2003 9.958246\n", + "2004 11.336490\n", + "2005 12.988133\n", + "2006 14.809893\n", + "2007 17.417140\n", + "2008 19.342058\n", + "2009 18.936226\n", + "2010 19.315689\n", + "2011 21.393721\n", + "2012 20.452107\n", + "2013 18.515731\n", + "2014 17.853640\n", + "2015 17.937642\n", + "2016 17.782776\n", + "2017 22.269696\n", + "2018 22.729328\n", + "2019 22.204408\n", + "2020 22.754847\n", + "Name: CAN-USD, dtype: float64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "can_usd = military.loc[2000:2020, 'CAN-USD']\n", + "\n", + "can_usd" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2f9a252d", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "can_usd.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "22bd9379-07f0-4900-99b2-bcafee5b2728", + "metadata": {}, + "source": [ + "To use matplotlib directly, we first extract the years of interest and assign it to the variable `years`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ab3bb392-3509-4adc-b1ae-4460db515862", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Int64Index([2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,\n", + " 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020],\n", + " dtype='int64', name='Year')" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "years = can_usd.index\n", + "\n", + "years" + ] + }, + { + "cell_type": "markdown", + "id": "148a691a-3fd4-4501-800d-f926099108db", + "metadata": {}, + "source": [ + "Then, we call `plt.plot()` and specifiy the years on the x-axis and the spending on the y-axis." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "88bcffa6-027e-4208-aeab-9c61649b913c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(years, can_usd);" + ] + }, + { + "cell_type": "markdown", + "id": "d90f500d", + "metadata": {}, + "source": [ + "We can see from the graph that Canada's spending on the military has increased overall since 2000. The country had a period of time (around 2011 to 2017) where military spending was decreasing consistently.\n", + "\n", + "Let's add the data for Mexico as well to see the country's spending in the 21st century." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3eff4b2a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mex_usd = military.loc[2000:2099, 'MEX-USD']\n", + "\n", + "plt.plot(years, can_usd)\n", + "plt.plot(years, mex_usd);" + ] + }, + { + "cell_type": "markdown", + "id": "81e3e39f", + "metadata": {}, + "source": [ + "We can now see that the military spending for both Mexico and Canada is vastly different. However, just looking at this graph out of context, we wouldn't be able to tell which line corresponds to which country. Let's add some descriptive details, such as line labels, a title, and axis labels. Let's also fix the x-axis ticks to set an interval for every five years." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "50c364ea", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(years, can_usd, label='Canada')\n", + "plt.plot(years, mex_usd, label='Mexico')\n", + "\n", + "plt.title(\"Military Spending in Mexico and Canada in the 21st Century\", pad=10)\n", + "plt.ylabel('USD (Billions)')\n", + "plt.xlabel('Year')\n", + "plt.xticks(range(2000, 2025, 5))\n", + "\n", + "plt.legend(loc=\"best\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3ab35d3c", + "metadata": {}, + "source": [ + "We can see that the overall trend of military spending in Mexico also increased from 2000 to 2020. However, this increase was a lot less drastic than observed in Canada. Mexico's military spending was a steady rise from about \\$3 billion to \\$6 billion over the course of 20 years, while Canada's spending rose from \\$8 billion to about \\$23 billion over the same period of time.\n", + "\n", + "Let's add data from the United States to see the trends in all North American countries." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "18c12059", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "usa_usd = military.loc[2000:2099, 'USA-USD']\n", + "\n", + "plt.plot(years, can_usd, label='Canada')\n", + "plt.plot(years, mex_usd, label='Mexico')\n", + "plt.plot(years, usa_usd, label='United States')\n", + "\n", + "plt.title(\"Military Spending in North America in the 21st Century\", pad=10)\n", + "plt.ylabel('USD (Billions)')\n", + "plt.xlabel('Year')\n", + "plt.xticks(range(2000, 2025, 5))\n", + "\n", + "plt.legend(loc=\"best\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ae241382", + "metadata": {}, + "source": [ + "With the addition of the data from the United States, it's diffiult to discern the data from Canada and Mexico. Because the spending on the military in the United States was a lot higher, plotting all three datasets on the same graph with the same axis does not allow us to clearly see trends in the other countries.\n", + "\n", + "To address this, we can graph the data for each country separately with axis limits that are tailored to each country. If we graph this data side by side, we can see the trends in each country while acknowledging that the axis intervals for each country provides a numerical context for cross-comparisons." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "af08cad2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(fig, (ax1, ax2, ax3)) = plt.subplots(1, 3, figsize=(15, 3))\n", + "\n", + "fig.suptitle('Military Spending in North America in the 21st Century', y=1.1, fontsize=15)\n", + "\n", + "ax1.plot(years, can_usd)\n", + "ax1.set_title('Canada')\n", + "ax1.set_ylim([8, 24])\n", + "ax1.set_xlabel('Years')\n", + "ax1.set_ylabel('USD (Billions)')\n", + "\n", + "ax2.plot(years, mex_usd, color='orange')\n", + "ax2.set_title('Mexico')\n", + "ax2.set_ylim([2.5, 7])\n", + "ax2.set_xlabel('Years')\n", + "ax2.set_ylabel('USD (Billions)')\n", + "\n", + "ax3.plot(years, usa_usd, color='green')\n", + "ax3.set_title('United States')\n", + "ax3.set_ylim([300, 800])\n", + "ax3.set_xlabel('Years')\n", + "ax3.set_ylabel('USD (Billions)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "efee0c99", + "metadata": {}, + "source": [ + "Now that we've created separate plots, we can see the trends for all three countries over the last 20 years. All three countries seem to have decreased spending around 2011 and 2018. By observing the difference in scale, we can also see that while the trends are similar, the magnitude of spending was very different between Canada, Mexico, and the United States.\n", + "\n", + "In creating these plots, we used `plt.subplots()` in a way that we had not used it before. Here, we defined our `fig` argument, as well as three `axes` arguments, `ax1`, `ax2`, and `ax3`. This allowed us to create three separate plotting areas, bounded by three different axes, that are contained within one figure." + ] + }, + { + "cell_type": "markdown", + "id": "886787a1", + "metadata": {}, + "source": [ + "## Conclusions\n", + "\n", + "In this section, we learned how to use `plt.hist()`, `plt.scatter()`, and `plt.plot()` to create histograms, scatter plots, and line graphs as a means of visualizing numerical data.\n", + "\n", + "The `plt.scatter()` and `plt.plot()` functions require numerical arrays that serve as `x` and `y` arugments.\n", + "\n", + "The `plt.hist()` function requires an array of values for plotting distributions of data.\n", + "\n", + "We also learned about a number of other functions that can be used to enhance and annotate our plots. Documentation for the functions used in this section, and related functions, are listed below:\n", + "\n", + "- plt.hist( )\n", + "- plt.scatter( )\n", + "- plt.plot( )\n", + "- fig.suptitle( )\n", + "- ax.set_title( )\n", + "- ax.set_ylim( )\n", + "- ax.set_xlim( )\n", + "- ax.set_ylabel( )\n", + "- ax.set_xlabel( )\n", + "- plt.colorbar( )\n", + "- Colormap options" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37ae5ff6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/textbook/09/4/img/BoxandWhisker.png b/textbook/09/4/img/BoxandWhisker.png deleted file mode 100644 index b983606276c6805f4602206ad057f56e047142e0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 52323 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%0DZ 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

^{vvE$w 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 F{s(U-y1f7Z diff --git a/textbook/09/4/img/median(odd).png b/textbook/09/4/img/median(odd).png deleted file mode 100644 index 0cd600ed3c6dad03a48504d7a70897ead31a3d77..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 55118 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 diff --git a/textbook/09/4/other-viz.ipynb b/textbook/09/4/other-viz.ipynb deleted file mode 100644 index 36644a6b..00000000 --- a/textbook/09/4/other-viz.ipynb +++ /dev/null @@ -1,1021 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "02ee0b6e", - "metadata": {}, - "source": [ - "# Other Visualization Techniques\n", - "\n", - "In this section, we will introduce other data visualizations that can be used to represent categorical or numerical data. We will discuss another visualization library called `seaborn`. While the `matplotlib` library can be used to create most data visualizations in Python, there are some restrictions when it comes to customization. The `seaborn` library provides many flexible options when creating visualizations. In the upcoming exercises, we will use a combination of `seaborn` and `matplotlib` to make visualizations, including box and whisker plots, heatmaps, and area plots.\n", - "\n", - "Along with the previous data and libraries we have been using, we will import `seaborn` as a common convention: `sns`." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "41e82e0c", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "from matplotlib import pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "plt.style.use('fast')\n", - "\n", - "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_csv = '''\\\n", - "Year,CAN-PercentGDP,MEX-PercentGDP,USA-PercentGDP,CAN-USD,MEX-USD,USA-USD\n", - "1960,4.18525654,0.673508659,8.993124587,1.702442711,0.084,47.34655267\n", - "1961,4.128312243,0.651780326,9.1560315,1.677820881,0.0864,49.87977061\n", - "1962,3.999216389,0.689655172,9.331672945,1.671313753,0.0992,54.65094261\n", - "1963,3.620650112,0.718685832,8.831891186,1.610091701,0.112,54.56121578\n", - "1964,3.402062837,0.677506775,8.051281106,1.657457283,0.12,53.43232706\n", - "1965,2.930260659,0.591269841,7.587247177,1.57470454,0.1192,54.56179126\n", - "1966,2.683282422,0.576379066,8.435300286,1.614422827,0.1304,66.44275153\n", - "1967,2.74792677,0.545217107,9.417795933,1.775500366,0.1336,78.39844224\n", - "1968,2.54364188,0.548510764,9.268454275,1.797265817,0.1488,84.32903122\n", - "1969,2.27378467,0.600160043,8.633263795,1.770108751,0.18,84.99016543\n", - "1970,2.188979696,0.497411659,8.032743584,1.889157918,0.1768,83.407993\n", - "1971,2.131485639,0.48765558,6.943069609,2.077659711,0.1912,78.23797989\n", - "1972,2.011818438,0.536568089,6.519756924,2.233737031,0.2424,80.70807097\n", - "1973,1.832601818,0.544217687,5.893870591,2.363060955,0.3008,81.46979441\n", - "1974,1.783813085,0.565744137,5.954111197,2.809465529,0.4072,89.27892034\n", - "1975,1.863541853,0.57358422,5.622679096,3.18091549,0.5048,92.08092875\n", - "1976,1.765927978,0.598103574,5.191071429,3.581805735,0.531576968,94.71525108\n", - "1977,1.8057636,0.534256205,5.155617351,3.752174526,0.437692986,104.665219\n", - "1978,1.848887401,0.504834431,4.943087248,3.969158477,0.518287193,113.3820637\n", - "1979,1.711245918,0.505297474,4.951991535,4.084145738,0.679663588,126.8799271\n", - "1980,1.764448615,0.416107383,5.153537467,4.744402251,0.810422204,143.6883549\n", - "1981,1.709915638,0.513301014,5.646541256,5.141128191,1.284948561,176.5588753\n", - "1982,1.954343585,0.495419418,6.814057094,6.017321456,0.858130163,221.6735426\n", - "1983,2.081196249,0.522866314,6.32114426,6.947104072,0.778556797,223.427165\n", - "1984,2.117188855,0.65981906,6.23641653,7.349795764,1.155945373,245.1491683\n", - "1985,2.097376234,0.676313139,6.453219205,7.460563318,1.241863652,272.1632293\n", - "1986,2.109197118,0.634622463,6.626522658,7.78013674,0.817296612,295.5462238\n", - "1987,2.062576371,0.580341889,6.420274023,8.694447168,0.813391574,304.0866487\n", - "1988,1.986767119,0.536145374,6.071277702,9.897335684,0.981914646,309.6612693\n", - "1989,1.934614309,0.517255829,5.871206008,10.74713469,1.153375828,321.8665588\n", - "1990,1.958793742,0.433081035,5.605175294,11.41463185,1.210872502,325.129314\n", - "1991,1.895444339,0.435402301,4.883429398,11.3385033,1.459136041,299.3727791\n", - "1992,1.8616877,0.469454656,4.970466808,10.78880312,1.824550066,325.033736\n", - "1993,1.821753504,0.442785494,4.604350295,10.26882262,2.122980338,316.7194437\n", - "1994,1.696680257,0.518830327,4.215264675,9.57737764,2.635284079,308.084\n", - "1995,1.554090071,0.450891531,3.860245792,9.176903908,1.562615372,295.8530977\n", - "1996,1.403752581,0.476484778,3.554982206,8.615884471,1.882873103,287.9606687\n", - "1997,1.246243202,0.458095854,3.405562244,7.945140183,2.184061042,293.1678258\n", - "1998,1.256293902,0.450450487,3.201558499,7.748607984,2.263223453,290.9960551\n", - "1999,1.241703064,0.460988776,3.085676783,8.21077854,2.652912012,298.0948913\n", - "2000,1.11808088,0.44604782,3.112242147,8.299385231,3.031454509,320.0863242\n", - "2001,1.137368973,0.442657004,3.123809803,8.375571425,3.229469276,331.8056106\n", - "2002,1.120852292,0.421606002,3.447618099,8.495399281,3.172268734,378.4631388\n", - "2003,1.115878799,0.405916547,3.827161045,9.958245602,2.960496802,440.5320696\n", - "2004,1.107966027,0.364898723,4.016312736,11.33648983,2.854385965,492.9993762\n", - "2005,1.110669655,0.355958931,4.090034876,12.98813296,3.123454978,533.203\n", - "2006,1.125832408,0.311171936,4.041627237,14.8098928,3.035131019,558.335\n", - "2007,1.188901783,0.401163918,4.079655081,17.41713993,4.223037646,589.586\n", - "2008,1.248621382,0.390513227,4.463827356,19.3420584,4.334654124,656.756\n", - "2009,1.377555631,0.501556275,4.88559968,18.93622605,4.514233914,705.917\n", - "2010,1.194338338,0.452734493,4.922641677,19.31568883,4.789031339,738.005\n", - "2011,1.193291895,0.465777803,4.840173995,21.39372086,5.498458542,752.288\n", - "2012,1.118404598,0.475987281,4.477401219,20.45210711,5.717035575,725.205\n", - "2013,1.0023672,0.507919455,4.046678879,18.51573121,6.473144378,679.229\n", - "2014,0.989925299,0.513829957,3.69589465,17.85364048,6.758693845,647.789\n", - "2015,1.152709374,0.466676122,3.477845166,17.93764189,5.468837812,633.829639\n", - "2016,1.164161567,0.495064414,3.418942337,17.78277554,5.33687574,639.856443\n", - "2017,1.351602232,0.436510296,3.313381294,22.26969632,5.062076646,646.752927\n", - "2018,1.324681094,0.477517407,3.316248808,22.72932758,5.839521271,682.4914\n", - "2019,1.27894142,0.52348249,3.427080181,22.20440844,6.650808254,734.3441\n", - "2020,1.415055841,0.573651659,3.741160091,22.75484713,6.116376582,778.2322\n", - "'''\n", - "\n", - "from io import StringIO\n", - "\n", - "NorthAmerica_Military_USD_PercentGDP_Combined_file = StringIO(NorthAmerica_Military_USD_PercentGDP_Combined_csv)\n", - "\n", - "military = pd.read_csv(NorthAmerica_Military_USD_PercentGDP_Combined_file, index_col='Year')\n", - "\n", - "import warnings\n", - "warnings.filterwarnings('ignore')" - ] - }, - { - "cell_type": "markdown", - "id": "589f64b7", - "metadata": {}, - "source": [ - "## Box and Whisker Plots\n", - "\n", - "Box and whisker plots are a useful data visualization method because they intrinsically display multiple summary statistics simultaneously. The central line of each box within a box and whisker plot is the *median*. The median (also known as the second quartile, $Q_2$) is a value within a dataset that lies within the middle, separating the higher half and the lower half of the dataset. The median is a valuable measure of center for a dataset because it is not greatly affected by outliers, as opposed to the *mean*.\n", - "\n", - "If *A* represents a dataset with the values listed below, the median of *A* can be determined by sorting the numbers from low to high and determining the value that falls into the middle (which in this case is 109):\n", - "\n", - "\n", - "\n", - "\n", - "In the case of a dataset with an even number of values, the median can be calculated as the mean of the middle two values, as shown in the example dataset *B* below:\n", - "\n", - "\n", - "\n", - "\n", - "Box and whisker plots also show the *lower quartile*, *the upper quartile*, the *interquartile range*, *outliers*, the *minimum*, and the *maximum*. The lower quartile $\\left( Q_1\\right)$ is the value where the lowest 25% of the data points within a dataset lie. It is represented by the lower end of the box. \n", - "\n", - "On the other side, the upper quartile $\\left( Q_3\\right)$ is the value in which the highest 25% of the dataset resides. It is represented by the higher end of a box.\n", - "\n", - "\n", - "The interquartile range (IQR), is the difference between the upper quartile and the lower quartile. The IQR is used to make the length of a box and is represented by the equation:\n", - "\n", - " > $IQR=Q_3-Q_1$\n", - " \n", - "\n", - "Outliers are data points that are less than $Q_1-1.5×IQR$ or greater than $Q_3+1.5×IQR$. These data points are shown beyond the extremity of the whiskers.\n", - "\n", - "Lastly, the minimum and maximum values are represented by the lowest and highest values, respectively, that are within the range $Q_1-1.5×IQR$ and $Q_3+1.5×IQR$. Essentially, they are the lowest and highest values that do not qualify as outliers. The lower whisker represents the minimum value, while the upper whisker represents the maximum value.\n", - "\n", - "Below is a pictorial summary of the major components of a box and whisker plot with an accompanying set of numbers, *A*:\n", - "\n", - "" - ] - }, - { - "cell_type": "markdown", - "id": "0b21bf29", - "metadata": {}, - "source": [ - "We will use a box and whisker plot to examine the percentage GDP spending on the military for each country in the '60s as a way to examine multiple statistics for each country in this time period.\n", - "\n", - "First, we extract the data of interest:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3f2494b4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "

\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CAN-PercentGDPMEX-PercentGDPUSA-PercentGDP
Year
19604.1852570.6735098.993125
19614.1283120.6517809.156031
19623.9992160.6896559.331673
19633.6206500.7186868.831891
19643.4020630.6775078.051281
19652.9302610.5912707.587247
19662.6832820.5763798.435300
19672.7479270.5452179.417796
19682.5436420.5485119.268454
19692.2737850.6001608.633264
\n", - "
" - ], - "text/plain": [ - " CAN-PercentGDP MEX-PercentGDP USA-PercentGDP\n", - "Year \n", - "1960 4.185257 0.673509 8.993125\n", - "1961 4.128312 0.651780 9.156031\n", - "1962 3.999216 0.689655 9.331673\n", - "1963 3.620650 0.718686 8.831891\n", - "1964 3.402063 0.677507 8.051281\n", - "1965 2.930261 0.591270 7.587247\n", - "1966 2.683282 0.576379 8.435300\n", - "1967 2.747927 0.545217 9.417796\n", - "1968 2.543642 0.548511 9.268454\n", - "1969 2.273785 0.600160 8.633264" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "the60s = military.loc[1960:1969, ['CAN-PercentGDP', 'MEX-PercentGDP', 'USA-PercentGDP']]\n", - "\n", - "the60s" - ] - }, - { - "cell_type": "markdown", - "id": "097daad0", - "metadata": {}, - "source": [ - "It is possible to make boxplots using using `pyplot` or the dataframe method `plot.box()`, as shown below:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "34aca023", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAJhklEQVR4nO3dQYit91nH8d9jbqRN2qQzZBYxLd6uuunCyCBqoEiqILWoCxcuWlCE7GwqithVbvZSdCVcWgUx1EWSlQuxixQpaHRujNrc25XampqSKbl6GzfV+LiYiYTrbebce8+Z95k5nw8cmJnzznse5oUvL/9533OquwPAXD+w9AAAvDuhBhhOqAGGE2qA4YQaYLgLm9jpQw891BcvXtzErgHOpStXrnynu/du9dxGQn3x4sUcHBxsYtcA51JVfeP7PWfpA2A4oQYYTqgBhhNqgOGEGmA4oQYYTqgBhhNqgOE2csMLwO2qqrXs5zy+x75QAyOsEtiqOpchPomlD4DhhBpgOKEGTsXu7m6q6q4eSe7q93d3dxf+K9wZa9TAqbh+/fri68vr+oflaXNGDTCcUAMMJ9QAwwk1wHBCDTCcUAMM5/I84FT0Uw8klx5cfoYzSKiBU1FP3xhxHXVfWnSEO2LpA2A4oQYYTqgBhhNqgOGEGmA4oQYYTqgBhnMdNXBqln4/6J2dnUVf/04JNXAq1nGziw+3BWAkoQYYTqgBhhNqgOGEGmA4oQYYbqVQV9VvVNUrVfW1qvpSVb1n04MBcOTEUFfVI0k+k2S/uz+a5J4kv7zpwQA4surSx4Uk762qC0nuS/JvmxsJgHc6MdTd/a0kv5vkm0leS/If3f0XN29XVU9U1UFVHRweHq5/UoAttcrSx06SX0jy4SQ/lOT+qvrUzdt19+Xu3u/u/b29vfVPCrClVln6+Okk/9zdh939X0meT/KTmx0LgLetEupvJvnxqrqvjt766uNJrm12LADetsoa9YtJnk3yUpJ/PP6dyxueC4BjK73NaXc/leSpDc8CwC24MxFgOKEGGE6oAYbzUVzACKt+nuJJ253Hj+oSamCE8xjYdbH0ATCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMt1Koq+oDVfVsVX29qq5V1U9sejAAjlxYcbvfT/Ln3f1LVfWDSe7b4EwAvMOJoa6qB5N8LMmvJEl3fy/J9zY7FgBvW2Xp48NJDpP8UVX9XVV9oaruv3mjqnqiqg6q6uDw8HDtgwJsq1VCfSHJjyb5g+5+NMl/Jvmdmzfq7svdvd/d+3t7e2seE2B7rRLqV5O82t0vHn//bI7CDcApODHU3f3tJP9aVR85/tHHk1zd6FQA/J9Vr/r49STPHF/x8U9JfnVzIwHwTiuFurtfTrK/2VEAuBV3JgIMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHAXlh5gmqpay366ey37AVg51FV1T5KDJN/q7k9ubqRlnRTYqhJh4FTdztLHk0mubWoQAG5tpVBX1QeT/FySL2x2HAButuoZ9e8l+e0k//P9NqiqJ6rqoKoODg8P1zEbAFkh1FX1ySSvd/eVd9uuuy9393537+/t7a1tQIBtt8oZ9WNJfr6q/iXJnyZ5vKr+ZKNTbdDu7m6q6o4fSe7q96squ7u7C/8VgLPkxKs+uvtzST6XJFX1U0l+q7s/tdmxNuf69euLX7WxrksAge3ghheA4W7rhpfu/kqSr2xkEgBuyRk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHBCDTCcUAMMJ9QAwwk1wHC39e5550E/9UBy6cHlZwBY0daFup6+MeKDA/rSoiMAZ4ilD4DhhBpgOKEGGE6oAYYTaoDhhBpgOKEGGE6oAYbbuhtekqMbTpa0s7Oz6OsDZ8vWhfpu70qsqsXvbAS2i6UPgOGEGmA4oQYYTqgBhhNqgOGEGmA4oQYYbuuuoz7JKjfDrLKNa62BdRHqmwgsMI2lD4DhTgx1VX2oql6oqqtV9UpVPXkagwFwZJWlj/9O8pvd/VJVvT/Jlar6cndf3fBsAGSFM+rufq27Xzr++rtJriV5ZNODAXDkttaoq+pikkeTvLiRaQD4f1YOdVW9L8lzST7b3Tdu8fwTVXVQVQeHh4frnBFgq60U6qq6N0eRfqa7n7/VNt19ubv3u3t/b29vnTMCbLVVrvqoJF9Mcq27P7/5kQB4p1XOqB9L8ukkj1fVy8ePT2x4LgCOnXh5Xnd/NcmyHzIIsMXcmQgwnFADDCfUAMMJNcBwQg0wnFADDCfUAMMJNcBwQg0wnFADDCfUAMMJNcBwQg0wnFADDCfUAMMJNcBwQg0wnFADDCfUAMMJNcBwQg0wnFADDCfUAMNdWHoAWKequut9dPcaJoH1cUbNmbG7u5uqetfHOpz0Gru7u2t5HViVM2rOjDc+81aSB5YeI8lbSw/AlhFqzox6+sbSIyRJdnZ28salpadgmwg1Z8Yqa8fWqDmPhJpzRWQ5j/wzEWA4oQYYTqgBhhNqgOGEGmA4oQYYTqgBhhNqgOFqEzcIVNVhkm+sfcczPJTkO0sPwR1z/M6283z8fri79271xEZCfZ5V1UF37y89B3fG8TvbtvX4WfoAGE6oAYYT6tt3eekBuCuO39m2lcfPGjXAcM6oAYYTaoDhhHpFVfWHVfV6VX1t6Vm4fVX1oap6oaquVtUrVfXk0jOxmqp6T1X9TVX9/fGxe3rpmU6bNeoVVdXHkryZ5I+7+6NLz8PtqaqHkzzc3S9V1fuTXEnyi919deHROEEdfb7a/d39ZlXdm+SrSZ7s7r9eeLRT44x6Rd39l0neWHoO7kx3v9bdLx1//d0k15I8suxUrKKPvHn87b3Hj606wxRqtk5VXUzyaJIXFx6FFVXVPVX1cpLXk3y5u7fq2Ak1W6Wq3pfkuSSf7e4bS8/Darr7re7+kSQfTPJjVbVVy49CzdY4Xt98Lskz3f380vNw+7r735O8kORnFx7lVAk1W+H4H1JfTHKtuz+/9Dysrqr2quoDx1+/N8nPJPn6okOdMqFeUVV9KclfJflIVb1aVb+29EzclseSfDrJ41X18vHjE0sPxUoeTvJCVf1Dkr/N0Rr1ny0806lyeR7AcM6oAYYTaoDhhBpgOKEGGE6oAYYTaoDhhBpguP8F2A3cPgSlflYAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Creates a boxplot using pyplot from matplotlib\n", - "plt.boxplot(the60s)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "adda1f5f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQdklEQVR4nO3de5BedX3H8fdHEiRcDCjR1ktdilRFbmK0FmpFRbzgBSodxdvYmYo61js6wUuBqmM6Ot7GFqSowygjtioVRQsMiHejGySEEO0MggqldbUa0YkS4ds/zll43Oxmn5B9dn/Jvl8zO9k953fO+Z7n9zyf55zfc06eVBWSpHbdY6ELkCRtm0EtSY0zqCWpcQa1JDXOoJakxi0ZxUr333//GhsbG8WqJWmXtHbt2p9V1Yrp5o0kqMfGxhgfHx/FqiVpl5TkRzPNc+hDkhpnUEtS4wxqSWqcQS1JjTOoJalxBrUkNc6glqTGGdSS1LiR3PAiSdtrbNXFc7KeG1cfPyfraYlBLakJwwTs2KqLd8kgno1DH5LUOINakhrn0IekeXH4mZeyafOWHV7PjoxlL1+2lHWnH7fDNcw3g1rSvNi0ecuCjy/P1QeW882hD0lqnEEtSY0zqCWpcQa1JDXOoJakxhnUktQ4L8+TNC/2efgqDj1v1QLXALDz3YJuUEuaF7duXO111HeTQx+S1DiDWpIaZ1BLUuMMaklqnEEtSY0zqCWpcQa1JDXO66glzZuFvo55+bKlC7r9u8ugljQv5uJmF7/cVpLUJINakhpnUEtS4wxqSWqcQS1JjTOoJalxQwV1ktcl2ZDk2iSfTLLHqAuTJHVmDeokDwBeDaysqkOA3YDnjbowSVJn2KGPJcCyJEuAPYH/Hl1JkqRBswZ1Vd0MvAf4MXALsKmqLp3aLskpScaTjE9MTMx9pZK0SA0z9LEf8GzgAOD+wF5JXji1XVWdU1Urq2rlihUr5r5SSVqkhhn6OBa4oaomqmoL8FngqNGWJUmaNExQ/xh4bJI9kwR4ErBxtGVJkiYNM0a9Bvg0cBWwvl/mnBHXJUnqDfXfnFbV6cDpI65FkjQN70yUpMYZ1JLUOINakhrnV3FJasKw36c4W7td8au6DGpJTdgVA3auOPQhSY0zqCWpcQa1JDXOoJakxhnUktQ4g1qSGmdQS1LjDGpJapxBLUmNM6glqXEGtSQ1zqCWpMYZ1JLUOINakhpnUEtS4wxqSWqcQS1JjTOoJalxBrUkNc6glqTGGdSS1DiDWpIaZ1BLUuMMaklqnEEtSY0zqCWpcQa1JDXOoJakxhnUktQ4g1qSGjdUUCfZN8mnk3w/ycYkfzHqwiRJnSVDtvsA8J9VdVKS3YE9R1iTJGnArEGdZDnwV8BLAKrqNuC20ZYlSZo0zNDHAcAE8LEk30tybpK9pjZKckqS8STjExMTc16oJC1WwwT1EuBI4KyqeiTwG2DV1EZVdU5VrayqlStWrJjjMiVp8RomqG8CbqqqNf3fn6YLbknSPJg1qKvqf4CfJHloP+lJwHUjrUqSdKdhr/p4FXB+f8XHD4G/HV1JkqRBQwV1VV0NrBxtKZKk6XhnoiQ1zqCWpMYZ1JLUOINakhpnUEtS4wxqSWqcQS1JjTOoJalxBrUkNc6glqTGGdSS1DiDWpIaZ1BLUuMMaklqnEEtSY0zqCWpcQa1JDXOoJakxhnUktQ4g1qSGmdQS1LjDGpJapxBLUmNM6glqXEGtSQ1zqCWpMYZ1JLUOINakhpnUEtS4wxqSWqcQS1JjTOoJalxBrUkNc6glqTGGdSS1LglC11Aa8ZWXTwn67lx9fFzsh5JGjqok+wGjAM3V9UzRlfSwpotYMdWXWwIS5pX2zP08Rpg46gKkSRNb6igTvJA4Hjg3NGWI0maatgj6vcDbwLumKlBklOSjCcZn5iYmIvaJEkMEdRJngH8tKrWbqtdVZ1TVSurauWKFSvmrEBJWuyG+TDxaOBZSZ4O7AHcK8knquqFoy1tNA4/81I2bd6yQ+vY0StDli9byrrTj9uhdUhaPGYN6qo6DTgNIMkxwKk7a0gDbNq8ZcGv2pirSwAlLQ7e8CJJjduuG16q6krgypFUIkmalkfUktQ4g1qSGmdQS1LjDGpJapxBLUmNM6glqXEGtSQ1zqCWpMYZ1JLUOINakhpnUEtS4wxqSWqcQS1Jjduu/z1vV7DPw1dx6HmrFrgG6L6CUpJmt+iC+taNq/3iAEk7FYc+JKlxBrUkNc6glqTGGdSS1DiDWpIaZ1BLUuMMaklqnEEtSY1bdDe8wMLfcLJ82dIF3b6kncuiC+odvStxbNXFC35no6TFxaEPSWqcQS1JjTOoJalxBrUkNc6glqTGGdSS1DiDWpIat+iuo57NMDfDDNPGa60lzRWDegoDVlJrHPqQpMbNGtRJHpTky0muS7IhyWvmozBJUmeYoY/fA2+oqquS7AOsTXJZVV034tokSQxxRF1Vt1TVVf3vtwIbgQeMujBJUme7xqiTjAGPBNaMpBpJ0laGDuokewOfAV5bVb+aZv4pScaTjE9MTMxljZK0qA0V1EmW0oX0+VX12enaVNU5VbWyqlauWLFiLmuUpEVtmKs+AnwE2FhV7x19SZKkQcMcUR8NvAh4YpKr+5+nj7guSVJv1svzqurrQOahFknSNLwzUZIaZ1BLUuMMaklqnEEtSY0zqCWpcQa1JDXOoJakxhnUktQ4g1qSGmdQS1LjDGpJapxBLUmNM6glqXEGtSQ1zqCWpMYZ1JLUOINakhpnUEtS4wxqSWqcQS1JjTOoJalxBrUkNc6glqTGLVnoAqS5NLbq4h1ex42rj5+DSqS5Y1Brp3H4mZeyafOWkW9ntrBfvmwp604/buR1SJMMau007hh7A/ssdBHAHQCsX+AqtJgY1Npp3Lpx9UKXAHRH1NJ8Mqi10xhm7Ngxau2KDGrtUgxZ7Yq8PE+SGmdQS1LjDGpJapxBLUmNM6glqXEGtSQ1zqCWpMYZ1JLUuFTV3K80mQB+NOcrbsP+wM8Wugjdbfbfzm1X7r8HV9WK6WaMJKh3ZUnGq2rlQtehu8f+27kt1v5z6EOSGmdQS1LjDOrtd85CF6AdYv/t3BZl/zlGLUmN84hakhpnUEtS45oL6iR/lOSCJNcnWZvki0n+rJ/32iS/TbJ8oP0xSSrJMwemfSHJMdOseyzJ5iRXJ7kuydlJ5v0xSHJCkoOnTHt9ku8nWZ9kXZL3Jlnaz7uxn76+r/sdSfZoaZ/6WirJJwb+XpJkIskX+r9f0v999cDPwUlWJtmQZPe+3YFJfpjkXlPW38S+7sL9N5bk2inTzkhyapLHJlnT17kxyRlT2r0/yc3bqj3J7f3y1yb59yR7jmhXZtTnxVFTpr0wyTX9c3BdknOT7NvPuzLJD/r530/yocl5/fx52aemgjpJgAuBK6vqwKp6FHAacL++ycnAd4G/nrLoTcBbhtzM9VV1BHAYcDBwwpC1zeW34ZzQb3ty3S8HjgMeW1WHAo8GfgosG1jmCf28xwB/Cnx4YN7d2qcR+A1wSJLJup8M3Dylzaeq6oiBn+uqahz4CnBq3+afgbdU1a+m2Yb9tzDOA07p6zwE+LfJGX04nwj8BHj8Ntaxue/zQ4DbgJcPs+E57rtjgDuDOslTgdcBT6uqRwBHAt/krswBeEFVHUbXP78DPjcw727t0/ZqKqiBJwBbqursyQlVta6qvpbkQGBv4K10gT1oHbApyZOH3VBV/Z6uQx6SZEWSzyT5bv9zNNx5NPHxJN8APp7kfkku7N91102+M/fvyN/p31k/nGS3fvqvk7yzb/vtfvmjgGcB7+7bH0j3JvOKqvplX9ttVbV6uqCqql/TPRlOSHLvmfZp2MdhBL4ITH4f1snAJ4dc7s3AS5O8CVhSVdtczv6bd/cFbgGoqtur6rqBeccAG4Cz2Pq1OZOv0fXdXkk+2j/+30vybLjz7OuiJFcAlyfZO8nH0p2VXJPkOX2745J8K8lV/RHt3v30G5Oc2U9fn+RhScboHvvX9X33OLq+O7Wqbh7Yt49W1Q+mFlxVtwFvAv4kyeEz7dOQ+79dWgvqQ4C1M8x7HnAB3YPx0CT3mzL/nXQhPpT+FOVJwHrgA8D7qurRwHOAcweaHgwcW1UnAx8EvlJVh9O9825I8nDgucDR/dHG7cAL+mX3Ar7dt/8q8NKq+iZwEfDGvv0EsHdV3TBs7X0A3AActI19WigXAM9Ld2p/GLBmyvzn5g+HPpYB9CG3GngX8MrZNmL/zbv3AT/o3+he1vfvpMk35AuB49MP+cykP0J+Gt1+vgW4oqoeQ3eg9u4ke/VNjwROqqrHA28DNlXVof3R7RVJ9qd7zR9bVUcC48DrBzb1s376WXRhfCNwNt1z5Yiq+hrwCOCqYR+Eqrqd7sDwYdvYpzm3M3257cnAiVV1R5LPAH8DfGhyZlV9NQlJ/nKW9RyY5GqggM9V1ZeSnAcc3I28AHCvyXdm4KKq2tz//kTgxf32bqc7in8R8Cjgu/3yy+hOe6E7FfpC//tauqGAbUryFOCfgH2B5/fBMG3Tbe3TbNsZlaq6pj9yOZnu6HqqT1XV38+w+NOA/6UL162OaHr23+jMdK1uVdU/Jjmfbojn+XT9e0y6zxWeDry+qm5NsgZ4Cnc9boOW9fsJ3QHXR+jOIJ6VZHLYaw/gT/rfL6uq/+t/P5buYG2yoF8keQbdc+Ubfd/tDnxrYHuf7f9dy9bDpVtJcijwcWAf4M1V9amZms6yT3OutaDeAJw0dWL/AB4EXDbQITcwENS9yaPq3/fL/Tl3jQX+A3ANd40HDroH3fjib6dsF7px120JcF5VnTbNvC1114XqtzPN411Vv+pPsQ+oqhuq6hLgknQfwO0+7QaTfYAx4L+A5TPs00K6CHgP3SnxfYZZoH/RLad7kV+Y5BLgUOy/+fRzYL8p0+5N91qjqq4Hzkryr8BEkvvQjffuC6zvH+89gc1J1gGf79dxdj+cuXnqfqZb6DlThxr61+4wfXdZf7Y0nd/1/07bd70NdEfuX66q9cARST7EH36+MFjXbnTPy439pK32aRRaG/q4ArhnklMmJyQ5jO6U9YyqGut/7g/cP8mDBxeuqkvpnmiH9X+vGfjQ6qJtbPdS4FUD2zxihnaXA6/o2+yW7uqTy4GTkty3n37vqXVN41a6d+1J76J7AezbryN0RxZb6Y8U/wX4j6r6xSzbWSgfBc7sn/iz6oc/3gu8sl/mc3QfJtp/86gfP78lyROheyyApwJfT3J87jplOYgu/H5Jd2T9d5OvTeAAujOPnw/03dnM7BLgVZPrTvLIGdpdxsCQWJL9gG8DRyd5SD9tr/RXiG3DdH33niQPHJg2U0gv7dv/pKqumWU7c6qpoO6PXk4Ejk13ed4GugfmGLrxr0EXMnAqNOCdwIO2c9OvBlam+5DiOmb+5PY1wBOSrKc7nTq4/1DlrcClSa6he0L98SzbuwB4Y7oPTw6kG0O7HFjTr+MbwPf6n0lfTnfp1HeAHwMv2859nDdVdVNVfXCG2VPHqI+iG3+8cOADqjOAk5McNMM6prL/5s6Lgbf1p/NX0L3hXg+8iG6M+mq64YEXAPekC/KLJxeuqt8AXweeyXDeDiwFrulf72+fod07gP3SXQa3ju4qmgngJcAn+8f9W0wZO57G54ET++fe46rqi3QHgl9Kd3nkN+nehC4ZWOb8fv3X0n1u8ewh923OeAu5JDWuqSNqSdLWDGpJapxBLUmNM6glqXEGtSQ1zqCWpMYZ1JLUuP8HqFtZ8v9CMB0AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Creates a boxplot using the dataframe method plot.box()\n", - "the60s.plot.box()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a12f1be2", - "metadata": {}, - "source": [ - "Plotting using these approaches, the graphs show data within the columns of interest, but depending on the approach used, we see that the column title may or may not be used as categorical indicators on the x-axis. Furthermore, while these plots do the job of displaying the median and interquartile range, adding individual data points will allow for viewers to more easily see the spread of the data. The addition of axis labels, a title, and some color would also enhance this plot and make it more aesthetically pleasing. \n", - "\n", - "We can accomplish this using a combination of functions from `matplotlib` and `seaborn`. Using the `sns.boxplot()` and `sns.swarmplot()` functions will allow us to create a boxplot with data points overlayed on top:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f5f1e20c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ax = sns.boxplot(data=the60s, palette=\"Set2\", linewidth=1)\n", - "ax = sns.swarmplot(data=the60s, palette=\"Set2\", linewidth=0.5, edgecolor = \"black\")\n", - "plt.xticks(ticks = [0,1,2], labels = ['Canada', 'Mexico', 'United States'])\n", - "plt.ylabel(\"Percent of GDP\")\n", - "plt.title(\"% GDP spent on the military in North America from 1960-1969\")\n", - "\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "62687a9d", - "metadata": {}, - "source": [ - "Now that we have proper labeling, we can see the median, upper quartile, and lower quartile of the percentage of the each country's GDP spent on the military from 1960 to 1969. A noticeable observation this plot shows is that Mexico not only spent a small percentage of their GDP on the military (less than 2%), but the percentage of spending during this decade had very little variability. This makes it hard to see what the median, upper quartile, and lower quartile are for Mexico. The issue of being able to visually resolve displays of data is a common one that data scientists encounter." - ] - }, - { - "cell_type": "markdown", - "id": "913ed316", - "metadata": {}, - "source": [ - "## Heatmaps\n", - "\n", - "A heatmap is a matrix of data points depicted through a color gradient. Heatmaps are a great way to visualize data when you want to look at a multidimensional comparison of many variables. Heatmaps can be made from `matplotlib`, but this process may not be as straightforward to some. On the other hand, `seaborn` has a function dedicated to generations of heatmaps called `sns.heatmap()`. For your reference, both the `matplotlib` and `seaborn` approaches for constructing heatmaps are listed below.\n", - "\n", - "\n", - "We can use a heatmap to visualize variables that have a large number of values, such as the percentage of a country's GDP spent on the military from 1960 to 2020. Because Mexico has not spent over 1% of its GDP on the military in this time frame, we will look at these numbers for the U.S. and Canada. We will do this using the `seaborn` library.\n", - "\n", - "\n", - "To do this, we will first subset our data:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1ab14198", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CAN-PercentGDPUSA-PercentGDP
Year
19604.1852578.993125
19614.1283129.156031
19623.9992169.331673
19633.6206508.831891
19643.4020638.051281
.........
20161.1641623.418942
20171.3516023.313381
20181.3246813.316249
20191.2789413.427080
20201.4150563.741160
\n", - "

61 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " CAN-PercentGDP USA-PercentGDP\n", - "Year \n", - "1960 4.185257 8.993125\n", - "1961 4.128312 9.156031\n", - "1962 3.999216 9.331673\n", - "1963 3.620650 8.831891\n", - "1964 3.402063 8.051281\n", - "... ... ...\n", - "2016 1.164162 3.418942\n", - "2017 1.351602 3.313381\n", - "2018 1.324681 3.316249\n", - "2019 1.278941 3.427080\n", - "2020 1.415056 3.741160\n", - "\n", - "[61 rows x 2 columns]" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "perc_gdp = military[['CAN-PercentGDP', 'USA-PercentGDP']]\n", - "perc_gdp" - ] - }, - { - "cell_type": "markdown", - "id": "93db9fb9", - "metadata": {}, - "source": [ - "Next, we will use the `sns.heatmap()` function to generate a heatmap for the subsetted data. We will use the dataframe `perc_gdp` as an argument for the `data` parameter. Other parameters such as `cmap`, `linewidth`, and `linecolor` allow for customization of heatmap. The `cbar_kws` parameter alters components of the color bar, and the `vmin` and `vmax` parameters set the minimum and maximum values of the colorbar, respectively." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "4125b38d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(6,15)) \n", - "\n", - "sns.heatmap(data = perc_gdp, cmap='BuGn', linewidth=2, linecolor=\"grey\", # colormap, line width, and color specified,\n", - " cbar_kws={'label': 'Percentage of GDP'}, vmin=0, vmax=10) # color bar labeled, min and max values set\n", - "plt.title('Births per year in each state') # title added\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "0a5f744d", - "metadata": {}, - "source": [ - "Above, we see the matrix of values of the percentage of the GDP spent on the military in the U.S. and Canada from 1960 to 2020. Interestingly, Canada's percentage of the GDP going toward the military appeared to decrease steadily over the years." - ] - }, - { - "cell_type": "markdown", - "id": "334804bf", - "metadata": {}, - "source": [ - "## Area Plots\n", - "\n", - "An area plot is a specialized line graph that can be used to show trends of multiple variables in a dataset over a period of time. In an area plot, data points over time are connected to create a trend line and the region formed under the line is filled with a solid color. A useful adaption of an area plot is that it can be constructed in a way that shows the a proportional relationship of each variable to all variables over time, which can be a great alternative to using multiple pie charts to examine temporal trends.\n", - "\n", - "We will use an area plot to examine the proportion of USD spent between Canada and Mexico from 1960 to 2020. To do this, we will need to extract the data of interest and then calculate the proportion of money spent for each country. The following code takes the USD spent on the military for Canada and Mexico:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4be3c8fe", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CAN-USDMEX-USD
Year
19601.7024430.084000
19611.6778210.086400
19621.6713140.099200
19631.6100920.112000
19641.6574570.120000
.........
201617.7827765.336876
201722.2696965.062077
201822.7293285.839521
201922.2044086.650808
202022.7548476.116377
\n", - "

61 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " CAN-USD MEX-USD\n", - "Year \n", - "1960 1.702443 0.084000\n", - "1961 1.677821 0.086400\n", - "1962 1.671314 0.099200\n", - "1963 1.610092 0.112000\n", - "1964 1.657457 0.120000\n", - "... ... ...\n", - "2016 17.782776 5.336876\n", - "2017 22.269696 5.062077\n", - "2018 22.729328 5.839521\n", - "2019 22.204408 6.650808\n", - "2020 22.754847 6.116377\n", - "\n", - "[61 rows x 2 columns]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "usd = military[['CAN-USD', 'MEX-USD']]\n", - "usd" - ] - }, - { - "cell_type": "markdown", - "id": "8b013073", - "metadata": {}, - "source": [ - "Now that we have this data, we can begin to calculate the proportion of USD for each country. First, let's find the total between the two countries. We can do this by using the `apply()` method that we learned about in [Chapter 7](../7/1/Functions_to_DataFrames.ipynb). Because we want to find the total for each year, we need to apply the `np.sum()` function across columns (in other words, `axis=1`):" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b4eb14b0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CAN-USDMEX-USDTotalCAN-PropMEX-Prop
Year
19601.7024430.0840001.7864430.9529790.047021
19611.6778210.0864001.7642210.9510270.048973
19621.6713140.0992001.7705140.9439710.056029
19631.6100920.1120001.7220920.9349630.065037
19641.6574570.1200001.7774570.9324880.067512
..................
201617.7827765.33687623.1196510.7691630.230837
201722.2696965.06207727.3317730.8147920.185208
201822.7293285.83952128.5688490.7955980.204402
201922.2044086.65080828.8552170.7695110.230489
202022.7548476.11637728.8712240.7881500.211850
\n", - "

61 rows × 5 columns

\n", - "
" - ], - "text/plain": [ - " CAN-USD MEX-USD Total CAN-Prop MEX-Prop\n", - "Year \n", - "1960 1.702443 0.084000 1.786443 0.952979 0.047021\n", - "1961 1.677821 0.086400 1.764221 0.951027 0.048973\n", - "1962 1.671314 0.099200 1.770514 0.943971 0.056029\n", - "1963 1.610092 0.112000 1.722092 0.934963 0.065037\n", - "1964 1.657457 0.120000 1.777457 0.932488 0.067512\n", - "... ... ... ... ... ...\n", - "2016 17.782776 5.336876 23.119651 0.769163 0.230837\n", - "2017 22.269696 5.062077 27.331773 0.814792 0.185208\n", - "2018 22.729328 5.839521 28.568849 0.795598 0.204402\n", - "2019 22.204408 6.650808 28.855217 0.769511 0.230489\n", - "2020 22.754847 6.116377 28.871224 0.788150 0.211850\n", - "\n", - "[61 rows x 5 columns]" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "usd['Total'] = usd.apply(np.sum, axis=1)\n", - "usd['CAN-Prop'] = usd['CAN-USD']/usd['Total']\n", - "usd['MEX-Prop'] = usd['MEX-USD']/usd['Total']\n", - "usd" - ] - }, - { - "cell_type": "markdown", - "id": "8868b9a1", - "metadata": {}, - "source": [ - "Now we can begin to make the area plot with the calculated proportions. To do these, we will use the `plt.stackplot()` function. This function first takes an array-like object for the x-values, followed by arrays of the y-values that are to be stacked. The `labels` parameter dictates how each y-value is to be labeled, which can be visualized in the legend using `plt.legend()`:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "f005d3c1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.stackplot(usd.index, usd['CAN-Prop'], usd['MEX-Prop'], labels=['Canada','Mexico'])\n", - "plt.legend(loc='lower left')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "dfad8561", - "metadata": {}, - "source": [ - "Now that we have made the plot, we can improve it by adding a descriptive title. As an aesthetic feature, we can also make this graph so that it takes up the entire plotting area by using `plt.margins`. This function accepts an x and y value, respectively, to indicate where the margins begin on each axis. To get rid of the margins, we will use 0 for each value. " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "01ade042", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.stackplot(usd.index, usd['CAN-Prop'], usd['MEX-Prop'], labels=['Canada','Mexico'])\n", - "plt.legend(loc='lower left')\n", - "plt.margins(0,0)\n", - "plt.title('Proportion of Total Military Spending Between Canada and Mexico from 1960 to 2020')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ca499c7e", - "metadata": {}, - "source": [ - "We can now see the changes in the proportion of military spending between Canada and Mexico from 1960 to 2020. We see that the proportion of spending by Mexico increased over time." - ] - }, - { - "cell_type": "markdown", - "id": "b90364f6", - "metadata": {}, - "source": [ - "## Conclusions\n", - "\n", - "In this section, we were introduced to a new data visualization library: `seaborn`. The `seaborn` library can make many of the same visualizations available in `matplotlib` and can be used as an alternative in cases where more flexibility is needed. \n", - "\n", - "We learned how to make box and whisker plots and the multiiple statistics that these plots innately show. Box and whisker plots can be made in both `matplotlib` and `seaborn`, but using `seaborn` to construct these plots allows for an easy way to overlay data points upon the box and whisker plot.\n", - "\n", - "We also learned about heatmaps and their ability to show multidimensional data.\n", - "\n", - "Lastly, we learned how to construct area plots as another way to show proportional trends overtime, combining benefits of both a line graph and pie chart.\n", - "\n", - "Documentation to functions introduced in this section can be found below:\n", - "\n", - "\n", - "- Seaborn documentaion and user guide\n", - "- Seaborn data visualization gallery\n", - "- DataFrame.plot.box( )\n", - "- plt.boxplot( )\n", - "- sns.boxplot( )\n", - "- sns.swarmplot( )\n", - "- Heatmaps in Matplotlib\n", - "- sns.heatmap( )\n", - "- plt.stackplot( )\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "31d3ff63", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/textbook/09/data-visualization.md b/textbook/09/data-visualization.md index d75e8d3d..13791d38 100644 --- a/textbook/09/data-visualization.md +++ b/textbook/09/data-visualization.md @@ -6,4 +6,4 @@ Distilling large and complex sets of data into more easily digestible forms is a The visual that we choose is dependent on the type of data. Two major data types that can be visualized graphically are **numerical data** and **categorical data**. -Numerical data is commonly visualized using histograms, scatter plots and line graphs. Categorical data can be depicted using bar graphs and pie charts. There are a vast number of other methods to visualize these data types, (e.g. box and whisker plots, heatmaps, etc.), but the aforementioned graphs can greatly distill complex datasets and are commonly used throughout multiple disciplines. +Numerical data is commonly visualized using histograms, scatter plots and line graphs. Categorical data can be depicted using bar graphs, box and whisker plots, and pie charts. There are a vast number of other methods to visualize these data types, (e.g. cartograms, heatmaps, etc.), but the aforementioned graphs are the most commonly used among data scientists. diff --git a/textbook/15/1/ethics-and-law.ipynb b/textbook/15/1/ethics-and-law.ipynb index 99231100..a3a17132 100644 --- a/textbook/15/1/ethics-and-law.ipynb +++ b/textbook/15/1/ethics-and-law.ipynb @@ -28,10 +28,10 @@ "Many legal and ethical concerns surrounding data-centered conduct and decision-making involves maximizing human benefits while minimizing unintended damage. Using a synopsis of the major emphasized topics outlined in state-level, federal, and international guides (see references below and throughout the chapter), this approach can be summarized into 4 major pillars that may serve as the basis of decisions, research, and usage of data involving human subjects:\n", "\n", "\n", - "1. Communication, interpretation, and application of human data should be accurate and consider social, political, and economic contexts and ramifications, especially when involving vulnerable populations. \n", + "1. The attainment, usage, storage, analysis, and maintenance of human data should be as transparent, accountable, and honest as possible and intended for some sort of human benefit.\n", "2. Collected human data should be shared and maintained in a way that protects the privacy of subjects.\n", "3. Acquisition and collection of data should involve volition and informed consent from human subjects. \n", - "4. The attainment, usage, storage, analysis, and maintenance of human data should be as transparent, accountable, and honest as possible and intended for some sort of human benefit.\n", + "4. Communication, interpretation, and application of human data should be accurate and consider social, political, and economic contexts and ramifications, especially when involving vulnerable populations. \n", "\n", "While these pillars have not been adopted by government agencies verbatim, they serve as a basis for data science students to consider as they explore and move throughout data science courses and professional opportunities." ] diff --git a/textbook/15/2/img/lifecycleofdata.png b/textbook/15/2/img/lifecycleofdata.png new file mode 100644 index 0000000000000000000000000000000000000000..ec3843f7eaf199ca29dc8a4285795f40c2019f2d GIT binary patch literal 453059 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
i14D^VyxYgcK|J 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 z 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\n", + "The aforementioned practices may help to facilitate trust between human subjects/users and technologies that rely on data acquired from them [^**], [^***]. The establishment of trust within communities can have several advantages, including increased use of a product or technology, expanded collection of data, improved productivity and efficiency in tasks, and other benefits [^****]. However, with the occurence of numerous malevolent incidences, including massive data breaches that revealed sensitive financial information [^*****] or the use of \"synthetic\" media that has contributed to social and political confusion and misinformation [^******], it is unsurprising that some of the population has a level of distrust and concern when it comes to collection of personal data \n", + "[^*******] and emergent technologies [^********] such as artificial intelligence (AI), machine learning (ML), and natural language processing (NLP), in the public and private sectors.\n", "\n", - "
Pamphlet of the Virginia Health Bulletin reporting passing of the Racial Integrity Act of 1924. “Virginia Health Bulletin: The New Virginia Law To Preserve Racial Integrity, March 1924,” Document Bank of Virginia, accessed August 1, 2023, https://edu.lva.virginia.gov/dbva/items/show/226.
\n", "\n", - "
\n", - "
\n", - "While we as a society have evolved our moral compass, remnants of previous ethical shortcomings creep into scientific and technological practices in the digital age. As the rapid utilization of rich datasets drive discoveries in the fields of medicine, physics, engineering, artificial intelligence, and other sciences, few are slowing down to ask the questions that weigh innovation against morality. Most of the time, such ethical considerations are not acknowledged until cumulative damage is done. A well-known example is the report published by ProPublica[^******] in 2016, which described how a recidivism algorithm called COMPAS exhibited racial biases toward offenders, rating Black offenders as more likely to re-offend than White offenders. This algorithm has been used in several states in judicial decision-making processes.\n", "\n", - "Surprisingly, the reported analysis showed that of those deemed “high risk” to reoffend by COMPAS, 28.0% of Black offenders and 47.7% of White offenders did in fact reoffend. On the other hand, 44.9% of Black offenders and 23.5% of White offenders actually did not reoffend. How may an algorithm exhibit such suboptimal predictions and biases in its outputs? This would depend on the lens of what is considered \"suboptimal\" or even \"fair.\" According to a report published by Northpointe Incorporated [^*******], the creator of COMPAS, the algorithm does not confer biases with the statistical measures they used to assess accuracy and fairness. Affiliates of the United States Courts have also criticized the Propublica report [^********], stating that the study did not apply appropriate calculations in determining recidivism rates. Since the publishing of the original Propublica report, representatives of the academic, government, and private sectors have been in debate about what the appropriate measures of fairness are and the importance of these measures for crucial decisions such as recidivism[^*********][^**********].\n", + "In 2015, the Harvard Business Review published an article surveying consumers across several countries on sentiments around data privacy and security[^**********]. Interestingly, the entities people trusted most with their data were healthcare providers and financial institutions, while the least trusted were entertainment companies and social media firms. Arguably, the level of trust may coincide with mechanisms of accountability, such as HIPPA legislations and financial privacy laws like the Gramm–Leach–Bliley Act, which may not apply to entertainment and social media platforms in the same way. While legal obligation is a strong way to enforce accountability, providing open and accessible information on conduct around data security, privacy, and collection and protocols for when someone has questions or ailments about them shows an organization’s intrinsic commitment to transparent practices, which can enhance trust between the organization and customers, users, and other subjects from which data may be collected. \n", "\n", - "Following up on this report, Dressel and Farid (2018)[^***********] compared the accuracy of COMPAS’s prediction of recidivism to predictions made by human participants using an online survey. They found that human prediction was slightly more accurate than COMPAS (67% vs 65.2%) but was not significantly different. Using a developed classifier, they determined that age and total number of previous convictions yielded a similar racial bias as was reported in the Propublica report. Out of context, this could be viewed at most as a major flaw of the data inputs and outputs for this algorithm (garbage in, garbage out). A more contextual interpretation of how either of these factors lead to a racial bias in recidivism ratings could be supported by the numerous studies documenting racial bias arrests and confrontations with law enforcement[^************], as well as the track record of controversial police encounters in America. Thus, it is important to understand the greater macrocosm from which this data is derived to garner understanding of what the data may mean. Furthermore, it is imperative to acknowledge the strengths and limitations of statistical models and measures in relevant applications involving human behavior.\n", + "\n", "\n", + "As laws relevant to companies outside of the healthcare and financial sectors are still developing, accountability for such entities is currently nebulous. The data lifecycle is a pipeline that considers the past, present, and future of data and its application in technologies by said companies. This pipeline involves numerous steps, such as data collection, processessing, analysis, dissemination, and maintenance, which can be lead by numerous teams or organizations of people. Thus, for terminal applications of data, how do we determine accountability when things go wrong? While assignment of accountability is complex and multifaceted, Virginia Dignum, an AI ethicist and researcher, suggests that when thinking about accountability in the data lifecycle, the larger sociotechnical ecosystem must be considered within a *Accountability-Responsibility-Transparency* (ART) framework [^***********]. Those involved throughout various phases of the data lifecycle should be able to explain and justify their decisions around data (*accountability*), acknowledge the role that they play in the data lifecyle (*responsibility*), and describe, inspect and reproduce mechanisms contributing to end products of the life cycle (*transparency*). Utilizing this framework requires a level of open discussion with stakeholders, whether they be clients, users, or society. Such discussions facilitate iterative modification and reworking to improve products and services from an ethical and technological standpoint.\n", "\n", - "\n", + "\n", "\n", - "
Human (no-race condition) versus COMPAS algorithmic predictions. Adapted from Dressel and Farrid, 2018.
\n", + "
The data lifecycle. Adapted from Communications of the ACM, July 2020, Vol. 63 No. 7, Pages 58-66\n", + "10.1145/3360646
\n", "\n", - "
\n", "\n", - "While the use of tools like COMPAS is still an ongoing debate, important questions and considerations have emerged from this discussion. Particularly, how do tools like COMPAS affect decisions made by judges presented with recidivism predictions? Do these tools significantly impact one's right to due process? Does automation bias work in concert with implicit biases that are already prominent in the justice system[^*************]? Should we be using algorithmic predictions about human behavior in these circumstances at all?\n", "\n", - "Past ethical faults within the science and technology sectors may not have fully considered the damaging ramifications of certain studies, methods, and drawn conclusions on society. Moreover, it is impossible to anticipate the myriad of ways scientific findings may positively or negatively influence society. However, when it comes to working with human-derived data, or even data that can greatly affect human lives, these damages can be mitigated by staying well informed about the populations from which the data are collected and using ethical and contextual discernment when interpreting, communicating, and utilizing these data. As data scientists, it is our job to have ethics and morality as a basis by which we make these decisions around data." + "## The Trade-Off Between Transparency and Accuracy\n", + "\n", + "The development of artificial intelligence algorithms has aided, informed, and/or influenced human decision-making processes in a number of low-stakes and high-stakes scenarios. Because of this, conversation around the transparency of these algorithms has highlighted important perspectives and viewpoints regarding the implications of these technologies. \n", + "\n", + "Some algorithms disclose the use of parameters and models applied (i.e., \"white-box\" algorithms), while others may not readily explain the parameters and models used or may utilize another model that approximates the original model(s) (i.e., \"black-box algorithms). Some black-box algorithms also may utilize more sophistocated and complex methods, such as random forests and neural networks, which may not be readily explainable. Depending on the context of use, the methods backing white-box and black-box algorithms can influence the accuracy, and thus impact terminal services, decisions, products, or actions. \n", + "\n", + "Explainable AI (XAI) and ML (XML) explores the intersection of transparency and technical applicability in AI and ML. While transparency can help promote accountability and trust, limitations to prioritizing transparency may present in the use of AI/ML. Some of these include malicous and unintended misuse of developed AI/ML tools [^***********], exposure of trade secrets [^************], domain and technical knowledge requirements for full comprehension, and several others. In high-stakes situations, such as the use of AI/ML in healthcare decisions, some argue that accuracy should be more important than transperancy [^*************], while others suggest the use of *interpretable* models instead of black-box algorithms where possible [^**************]. Sometimes, black-box algorithms can be replaced with more simpler and transparent ones with little compromise of accuracy [^***************], [^****************]. In cases where black-box methods must be used, attempts to provide transparency through justification as opposed to explanation may be the best case scenario [^*****************]. An evalulation of the situation and associated risks and rewards, as well as testing of multiple black-box, white-box, and interpretable options, is important in determining the the best way to balance transparency and accuracy. \n", + "\n", + "\n", + "## Honest Statistical Practices\n", + "\n", + "A part of getting accurate insights from data includes using honest and appropriate statistical methods during data analysis. Doing such can enhance reproducibility, allowing for economical allocation of time and resources toward follow up studies. Some common pitfalls in research and analysis include hypothesizing after results are known (HARKing), p-hacking, and cherry-picking. Below is a discussion of each and how they impact research and knowledge generation.\n", + "\n", + "#### HARKing\n", + "As the acroynm states, HARKing is developing a hypothesis about data after knowing the results that the data depict and then reporting conclusions as if they were hypothesized *a priori*. HARKing does not fully disclose the process leading to the hypothesis and conclusions from data and thus can be seen as dishonest in nature. HARKing may or may not include performing statistical analysis and determining significant variables in a dataset; plotting and cross-examining variables can also be a part of HARKing. When performing exploratory studies, examining the relationships between multiple variables from a dataset can be a useful process to generate new hypotheses, but these hypotheses should be tested with a new dataset to confirm previous observations.\n", + "\n", + "#### P-hacking\n", + "\n", + "P-hacking can involve the use of multiple testing, various kinds of statistical tests, and/or specific subsetting of data in order to generate a significant p-value. Like HARKing, p-hacking does not fully account for the process leading up to a significant result. Because hypothesis testing reports the probability of an observed outcome occuring given that the null hypothesis is true, testing multiple hypothesis on the same data will give a false positive at some point. To address this, multiple testing corrections can be used [^******************].\n", + "\n", + "#### Cherry-picking\n", + "Cherry-picking involves biased selection of data for analysis or reporting conclusions. Cherry-picking can be used to fuel p-hacking or paint an incomplete picture of a research process. Reporting only data that aligns with a hypothesis can be an impediment to those trying to repeat a reported experiment because it can lead researchers down an avoidable rabbit hole. Furthermore, not reporting null data that is not in alignment with a hypothesis can similarly hinder the scientific process. When outliers are found within data, it is only appropriate to exclude it if there is sound justification based on the data collection process or statistical backing.\n", + "\n", + "All-in-all, when it comes to data, especially when derived from humans, centering honesty as much as possible is the best policy.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "[^*]: General Assembly. \"Preservation of Racial Integrity (1924)\" Encyclopedia Virginia. Virginia Humanities, (07 Dec. 2020). Web. 01 Dec. 2022\n", + "[^*]: Andrade, Chittaranjan. “HARKing, Cherry-Picking, P-Hacking, Fishing Expeditions, and Data Dredging and Mining as Questionable Research Practices.” The Journal of Clinical Psychiatry, vol. 82, no. 1, Feb. 2021, p. 20f13804, https://doi.org/10.4088/JCP.20f13804.\n", + "\n", + "[^**]: Lin, D., Crabtree, J., Dillo, I. et al. The TRUST Principles for digital repositories. Sci Data 7, 144 (2020). https://doi.org/10.1038/s41597-020-0486-7\n", + "\n", + "[^***]: Atske, Sara. “2. Americans Concerned, Feel Lack of Control over Personal Data Collected by Both Companies and the Government.” Pew Research Center: Internet, Science & Tech, 15 Nov. 2019, https://www.pewresearch.org/internet/2019/11/15/americans-concerned-feel-lack-of-control-over-personal-data-collected-by-both-companies-and-the-government/.\n", + "\n", + "[^****]: Robles, Pedro, and Daniel J. Mallinson. “Artificial Intelligence Technology, Public Trust, and Effective Governance.” Review of Policy Research, May 2023, p. ropr.12555, https://doi.org/10.1111/ropr.12555.\n", + "\n", + "[^*****]: Mathews, Lee. “Equifax Data Breach Impacts 143 Million Americans.” Forbes, https://www.forbes.com/sites/leemathews/2017/09/07/equifax-data-breach-impacts-143-million-americans/. Accessed 31 July 2023.\n", + "\n", + "[^******]: U.S. Department of Homeland Security. Increasing Threat of DEEPFAKE Identities. Accessed 31 July 2023. https://www.dhs.gov/sites/default/files/publications/increasing_threats_of_deepfake_identities_0.pdf\n", "\n", - "[^**]: BUCK v. BELL. 2 May 1927, https://www.loc.gov/item/usrep274200/.\n", + "[^*******]: “Americans Widely Distrust Facebook, TikTok and Instagram with Their Data, Poll Finds.” Washington Post, 22 Dec. 2021, https://www.washingtonpost.com/technology/2021/12/22/tech-trust-survey/.\n", "\n", - "[^***]: Laws of Indiana, 1907, pp. 377-78 (B050823). https://www.in.gov/history/state-historical-markers/find-a-marker/1907-indiana-eugenics-law/\n", + "[^********]: Nadeem, Reem. “Public Awareness of Artificial Intelligence in Everyday Activities.” Pew Research Center Science & Society, 15 Feb. 2023, https://www.pewresearch.org/science/2023/02/15/public-awareness-of-artificial-intelligence-in-everyday-activities/.\n", "\n", - "[^****]: Reilly, Philip R. “Eugenics and Involuntary Sterilization: 1907-2015.” Annual Review of Genomics and Human Genetics, vol. 16, 2015, pp. 351–68, https://doi.org/10.1146/annurev-genom-090314-024930.\n", + "[^**********]: Morey, Timothy, et al. “Customer Data: Designing for Transparency and Trust.” Harvard Business Review, 1 May 2015, https://hbr.org/2015/05/customer-data-designing-for-transparency-and-trust.\n", "\n", - "[^*****]: Office of the New York State Attorney General. Investigative Report on the role of online platforms in the tragic mass shooting in Buffalo on May 14, 2022. Published OCTOBER 18, 2022. https://ag.ny.gov/sites/default/files/buffaloshooting-onlineplatformsreport.pdf\n", + "[^***********]: Virginia Dignum. The role and challenges of education for responsible AI. London Review of Education. 2021. Vol. 19(1). DOI: 10.14324/LRE.19.1.01\n", "\n", - "[^******]: Angwin, Julia, et al. “Machine bias: There’s software used across the country to predict future criminals. And it’s biased against blacks,” ProPublica, 23 May 2016, www.propublica.org/article/machine-bias-risk-assessments-in-criminal-sentencing.\n", + "[^***********]: Umang Bhatt, Alice Xiang, Shubham Sharma, Adrian Weller, Ankur Taly, Yunhan Jia, Joydeep Ghosh, Ruchir Puri, José M. F. Moura, and Peter Eckersley. 2020. Explainable machine learning in deployment. In Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency (FAT* '20). Association for Computing Machinery, New York, NY, USA, 648–657. https://doi.org/10.1145/3351095.3375624\n", "\n", - "[^*******]: Dieterich, William, et al. \"COMPAS Risk Scales: Demonstrating\n", - "Accuracy Equity and Predictive Parity,\" 8 July 2016, https://go.volarisgroup.com/rs/430-MBX-989/images/ProPublica_Commentary_Final_070616.pdf.\n", + "[^************]: Burrell, J. (2016). How the machine ‘thinks’: Understanding opacity in machine learning algorithms. Big Data & Society, 3(1). https://doi.org/10.1177/2053951715622512\n", "\n", - "[^********]: Flores, Anthony, et al. \"False Positives, False Negatives, and False Analyses: A Rejoinder to 'Machine Bias: There's Software Used Across the Country to Predict Future Criminals. And It's Biased Against Blacks.'\" Federal Probation, Vol. 80 Number 2, September 2016, https://www.uscourts.gov/federal-probation-journal/2016/09/false-positives-false-negatives-and-false-analyses-rejoinder.\n", + "[^*************]: Ghassemi M, Oakden-Rayner L, Beam AL. The false hope of current approaches to explainable artificial intelligence in health care. Lancet Digit Health. 2021 Nov;3(11):e745-e750. doi: 10.1016/S2589-7500(21)00208-9. PMID: 34711379.\n", "\n", - "[^*********]: Corbett-Davies, Sam, and Sharad Goel. The Measure and Mismeasure of Fairness: A Critical Review of Fair Machine Learning. arXiv, 14 Aug. 2018, https://arxiv.org/abs/1808.00023.\n", + "[^**************]: Rudin C. Stop Explaining Black Box Machine Learning Models for High Stakes Decisions and Use Interpretable Models Instead. Nat Mach Intell. 2019 May;1(5):206-215. doi: 10.1038/s42256-019-0048-x. Epub 2019 May 13. PMID: 35603010; PMCID: PMC9122117.\n", "\n", - "[^**********]: Pleiss, Geoff, et al. “On Fairness and Calibration.” Advances in Neural Information Processing Systems, vol. 30, Curran Associates, Inc., 2017, https://papers.nips.cc/paper/2017/hash/b8b9c74ac526fffbeb2d39ab038d1cd7-Abstract.html.\n", + "[^***************]: Chaofan Chen, Oscar Li, Chaofan Tao, Alina Jade Barnett, Jonathan Su, and Cynthia Rudin. 2019. This looks like that: deep learning for interpretable image recognition. Proceedings of the 33rd International Conference on Neural Information Processing Systems. Curran Associates Inc., Red Hook, NY, USA, Article 801, 8930–8941.\n", "\n", - "[^***********]: Dressel, Julia and Farid, Hany. “The Accuracy, Fairness, and Limits of Predicting Recidivism.” Science Advances, vol. 4, no. 1, Jan. 2018, p. eaao5580, https://doi.org/10.1126/sciadv.aao5580.\n", + "[^****************]: Barnett, A.J., Schwartz, F.R., Tao, C. et al. A case-based interpretable deep learning model for classification of mass lesions in digital mammography. Nat Mach Intell 3, 1061–1070 (2021). https://doi.org/10.1038/s42256-021-00423-x\n", "\n", - "[^************]: Eberhardt, Jennifer. L. “Strategies for change: Research initiatives and recommendations to improve police- community relations in Oakland, Calif.” 2016. Stanford University, SPARQ: Social Psychological Answers to Real-world Questions. \n", + "[^*****************]: Biran, Or and Courtenay V. Cotton. “Explanation and Justification in Machine Learning : A Survey Or.” (2017).\n", "\n", - "[^*************]: Jeffrey J. Rachlinski & Sheri L. Johnson, Does Unconscious Racial Bias Affect Trial Judges, 84 Notre Dame L. Rev. 1195 (2009). Available at: http://scholarship.law.nd.edu/ndlr/vol84/iss3/4.\n" + "[^******************]: Andrade C. Multiple Testing and Protection Against a Type 1 (False Positive) Error Using the Bonferroni and Hochberg Corrections. Indian Journal of Psychological Medicine. 2019;41(1):99-100. doi:10.4103/IJPSYM.IJPSYM_499_18\n" ] }, { diff --git a/textbook/15/2/img/Dresseletal.png b/textbook/15/5/img/Dresseletal.png similarity index 100% rename from textbook/15/2/img/Dresseletal.png rename to textbook/15/5/img/Dresseletal.png diff --git a/textbook/15/2/img/indiana-eugenics.jpeg b/textbook/15/5/img/indiana-eugenics.jpeg similarity index 100% rename from textbook/15/2/img/indiana-eugenics.jpeg rename to textbook/15/5/img/indiana-eugenics.jpeg diff --git a/textbook/15/5/img/lifecycleofdata.png b/textbook/15/5/img/lifecycleofdata.png deleted file mode 100644 index 53eaa8db71c4208ec65c59a0b2f9e93150b87f55..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 507162 zcmdRW2UJsA)MjiT=mSxjND*ux?V*U&APOibAiaZv3eq8T2%v~Ws!CG`gd!~n5s=n6tLJvgx*B5tnZ~n!~#|i?0 z{?fXoZU6!ueFp-ukPkBf-^g9i3I=|#c-%6FfIw1b=zsS4=c@XGK&L@k>S{**@TIXy z&#A8iOcTA9X`oa4PwZ!#pnVb^1pb>icKYCnFY*TsH_qL={GbMpmM0*V zjQsCDeoUIO27c|vBo#$5JU_6_Kc5e%CMlJFuIRr|G}P!6{_}|yy|wS33lJ!i-uER7r0iOQ-bitl-{(A)i@#(+Z{~xZeonZyU@bAa*C*d|b<8p%2Kzka- z%M}_N1-t*v63ZbYP78Vqv4ID=?A;Dc@xr7C9-v=c6F1P-D;2vQptyFo9A+k}yAMB1IF--XpMBrj3dGdNH*S5{XH+LGtNB7fQW7~`2*wcn!a zQWDF(&!HI-+sm09OghFPB$nHK5*!_;E%ujzHi~0aFwO4VM9h0N#zS-5zXf^?^)9iE zWA!AS{S3RkVd5n)5#O^ir|q^kw3fO|H$Z`typgUptr^lR$0V^qx6S@ zw04|=7!6X3m%$lolOCd{Den@;&s-NiZUwt?n6cZ~yWi@Xi(qOMZHK+V!|_!9t9WH` z8YI~u5C+rg^Rp$JbLL8r$VUU+{pa_6iY;ei=sz=@R=dtv1GE58s&5-p76-$_iDQke zqPQ72&I{wmv1&jZP*dMl{(1TLji8bzds6H*&~7e}rkQEBe2x&saakL#IFHNS5z`sj zQvQ8wSmT~$c#p}-321$nh$;~+l2et%*TZ1w)GD2*rziJrOxv@#IY5s$)Rm3uAHIc@ zEI#o104G|i*Z0-CdLcW1YZ^3naZk1>I^s5#H=)c4IWuqv4*h=Uj8@8?T}}+_8MvZY z?m8!jafG0>0v>t&m7EH;-lo5G&$uTR_U@{6GFTnHgjZI@Uh~34!^}+TXXdT!_dI0o zX_NGCZwey-=3B55=T&K!=#C&;tPTI2E9+8Ze_Q)8Z(50X0*p5};IaO8y#Uo*EH`ox zKCPeV=l@otMNxzs*!?Ly;g(peh@I7TX^A~%b5vdZ2L!Wd7`Mz%@rb2Nwb$^YQ3@Ml z=A935v!oPg;SxXQj2)NclAi2zMz;{ul4PlYtyN2m52&Mc`Ys!4k9?US5W#ka>f64U zRk|2I6>BTtZ^tvpp13NO`#90>mN_22tAO_x5i!sXhi%2^%y|l=O}PGqI|R|Fp6c}k z|HnxX+Ug860rqCa^Q(q>y)27G2#X{EvQ024WocR2fU+Au^Qrp0U@u{Rd0eygwpcDn zRNBmOiu_Uv46W9Ldj7Oh{8m%HzD>Inci&~RT=gfsw~7>JcUdUyee^^1A6^)D=9uMo z&L8Zg;|7-sZ`u+?>TOLvRb$5|GCWmk%T}UG6N`6nv&O6AYA$V~-lI3;%kOwfA+pUK zYE@@LI`|r-6{i_21#K<%FaiT;FzceD|BDq-edV{?GI+QbW*1=S!r`K(Hri*LXE@0% zIvAX`o#y_WLqeqq8w>8yQ{f5i~!puvS*z6oRh6;t(Kc1wLv4g-4Kwub4{OoM&dT*D_CL|GRT zEE^rx)oiiQ7I){S1;0|L3p$`rK{V+bj39` z=$PcQ9`Z~w;Uu&R>m#&^0}sy*Rvpq}_R+pbvrdDo70%HZ8u_Tc7bCA2XSF`W1VAfa z!8?V8DOE^_{=wuC|1SYa`YuninH7Gq?4sxT61u5$i$5s5V9m#s%Mkb)r}IpMyd1jj zTac#Ey3g3nk2bK){?lx{4*K=$g8fZAf_BH3eY)vsCM+#~FWjXfKdtrq+ zekj_q2Hgjb#KR%3s|i7xyWY^TP=)bE=TLz(a&70hLL6oP>xQOKnaBm!luZj%P~376 z6;8aueT{AipS0%oEKhUw=Qi@fM*{I64Q#2Q@j+fh1YiH2g5?&M!_@^}86g9HVG`kMoBG`MjEEPeNF>pcYg5p+_QnmmM&2c!*B7{C(=z*w9CQdr zg5S_Hwl*m72vH>{jc0dFNy({gUJCMgdtdshC!h~;D^fIUtNR|oswMBXZvSwo<1eyt z`lEr;x1=DhcrN>*w0OD#K0Vn(HP!|^1@)Ux6YJ9kmSN?|r)R7w-%XGr zeTWo$I>|Q5poHwF#h^fGFLWWSAh2J>5%!4@^4M;J)0Kz4lOqx%#d1CSo20MLJ$%wv zHN~>%I_DIb2pE@OAw{sKuc1~`z%Q=Li&Jmf-3s1KB#&9B z>0!u{xgX=ktT{^V3)=iB9=lA*#4m;v#X5)HQPVche+x^VeJCTulO@VV-@_v7#_w!# zN-TFW7wsW}W{N(8IX1POC*h%ZF{8c{VU@FKw0y|*eZJ*@Z$YDr8+(brp6V6SQQiCf z1{Z3P_I<_Vvi-Rak7$_Lrq}v2V4&OcKNb`hfb>OFtTwcNX>~nxXII{>)tTqW+x)}~ z1MLLZR&^im#cIuE1;00qCor;2Bj8YD;WgyqEd^4{DX%uFg=JH?z~xYF{0s+rRAW+v zPVdKm5qxy*vFX1{${llKf4Q5(Aa4x5OY%3p(1!~znIH77%FCzKbB~T*QOqg>Q7P*8 zDdlw&+hB)Zmcn1|k6te6iy%1j?Cc=(>lP*Yk%_*y z6c$DK=Dux%HPrO_uhhJ~{!FS=C|yr)0BQ=aJDpojIznG-?!=ylV2xBtEnu6hxrv$_ zGB0%Q@x*o4u!&WHn@DrPhfMJU*c}!)^0$gT-uwT1$^td zw(bKJSUi9ktG0)trB#I_g{Y}k5B?fsC7$A|iQ4&E%K*!6ul9uM%w5WopR6JS<>zq6 zpTf9nw<@0GN=&_GvZ%O;@B+)?Pz0tOJiJedHLnZbQ}lN`}x-Z^UwCmDdLGef`dT zH?3<{X8p1b&-V&#<}{m=^6iD_s4Oh*57yAe1f&~SsJGnsW+`RA#$;P%&=W<#(A%-^F1q(Y>Ez)gCdH01SlY-KX)b1U|)&_?i> zpGLoeJZYQ}7M8U3z=cM;sPwIXTVf4X1;27!?r?Cl-{#8s2{+ZKO19R-^WRRNVj=XV zR!Q2Q=u(*#+ev3l-JIv!P&Zfmu7RR*{UE4mKkizyF}X5O!u4zHAXUGvlhx90Ua4g@|UW)bQBiibrKUxz9@JjW{1X5fUlqszX= zwk7&P61Qm~FAZuReBI)k^&9z2Ku#xFqZ=1*bd81dWjLFWcuafG&2k&c=SN{@foz-%&cBTdD3Zn&up^(gPs^!_=B~do z_%4?FEd^2Lv3}(T!KBmHD86DranoE#(R?s|81mO*qxkpPha*&qB>XmgEBPaP=4xu} zqjfSb5xGCJ_+o92QG_tgDPsxBW}MD6%=Sj;-QiW!Llq;e%bMPot4GMreP@jEWy{V@ z>E*rBstB=Mge}fngIHH#&ok!qeRi`<6uk7hl2xm=dNxp0AkWTczYWx7_GZEvmI~ zjqEM@l2@D&%|tJVvKOo>HwB`J#=h2#JXzN5+aZpgQYPt5w|$b37X_6mK|J^p_J{+U zIlflywS*|-^+Gv(`;{MzN^S1o9_J|?7i~_dw{%8fEngX=YWhrg>vMKm8DRoW&ZsS_ zsec^M&l5d3EJzRw@rm6sKN!c(Vqe8QtRtqA9X>fKUags~|E#|KX}hcMT_kJRRdW(F z4d@r+?nbt%PSt3^27ox{ov_Yl#5 zptXS}P(2w!LpVUitVTE0>){JT_PhOsxgBwrdZVx=8eKJoCQmChKGdwFS{oox`dA|_ zS$-Af#)!El%c~OVizC|^{7O90JLOBf(Qt@y{_BK7^5~>YD~E>ZD;v&toJ%+J`>T9# zT*kz*68kamuspp71-g58kAg9Xk?O->xBh)Ee zmqO(|jv8Y5^hU|g zl}8aQDncu-Ftb~W8&fxB4xK}JZoQHE9O7N?Y(cWtzjC3imEgcEwsHh&kwYh_E8us3 zC`?y8RWKGtVC@|pGs^n!ZY0%6CltpVEMe1g;%I=U*=(M(?e=l zeU7t|QGUoTb?9ez&>X8A)I&OHOhN667iHNF`vJwAmZwzFz(jABh8SSCr9-CQw>{Z{ zl$+XProyrl?cN)w7Xi@|xguBhv6AVC@tA7{TTKclBoFy38?tm0UH8Q&)U%ZUH742_ z{3zCpqN*VjdFfH^n)IJ`f;3(^dM8TN#!wr<%*4gqYFMRuCVS<@>>{jM`b)j_<@mK< zzAfhmDcwK$xil12?VI9ceDLos9tLZRT?rHk)qZRgv#heo{vn+!! z(5{)vKce>*rIe!A3Lh4~Yx^TVzCcRi4cC)->ypPIH(fTr#6$4`G7d#i`XX}Hs9~=; zzW24d9BDz{Y!;<+WykF?-fws2{IQiQbra{DSfQILC|lN8E{426vFuSFD2(4e&Ouc+ z4&_bDw9^%9$V)u`@cuf`aapAV0WGNwYyC<=@%{5W#?OL;NdAkP{5s!j_i>_jVsu{V zS`P;5bF%dp2JzA4<;L8!4@_!+f(@R1VrO}J^)D$?>qP{v)0X4Blw{c4=PL`bDxEWx z1yc?HHyP;of|VEp?8(A-Vi01wfoGDS+P3|$ezz^;(Bbw2ZC#suR(<@J?aFE3Xu_uD zVAJ7hcT{)Kwt~ZezU_Js%Vv&=)pTuBft}3&7YeF^3jOhID!8#NB%+OOOrM?@V8}i8 z^j|@PmK;*`eTF62QZdcP{IXIRQ?>&N6S>Rx+&D17uEaN7CLEsF2`v)Alj1Qa=h5g~ z@*aZOT?)z+xn{-lakpeM)tAhtv2>+T$Xe`&VsFi;uO?EWV6J&vs+Ki4xxPNG*W1$U zC!D}ej?6a;zmRb`zVz*Zx{^)^rlut9v&wW@3E?KxjKopl9GU?E*M{q-Av`CBacE^Z zth1?b=ZF`^{l4sjn?Lfv*U8ZMh*n#7NhL@K)m$2XZ)uA)Kj zq{l_K=FU2Q*vddZAH$ZCOBy6KhsuNmR`>vf$K|{@2&r54_VYQUPnV5{)?R$FX;%Pr zt7_MKGOPISU$QkqzI zr~7T@V{Yr0!B*)%2H7!UDXc7&&^8Eb!~)?crLB55s!OXE;1A^wbxV!-4)MWzZ}AD(JvmawfSe%jy;2#JX`uc17)OqD=(+8`te)*Ks-R4zKeGxS!N#3{fLHpU zK}NX`QoQjSd4cXatSxuC^PD^sw)e>8Kab?nJNYu(YoR#s& zRC^&;HU@@;@rDM?&+KpB=k{iAjWqAQiHdIkOtl$zdF*i5kq>+HzWiuusM2W{aqG8qI`zJvucB+h-%G{fOJ4PV+gv6e|MZmXhGVpLj zr^0Wjnu++cHA8U!^)Tn(fcg6YQ0C45%@zL0>-Y2jyW^lebhx)U=>P33>i=+aTI2d} zy2BP<(?=_SOL6ViwclQCiiQ){Bn}*qf4%b;{f-G9f!{+g$FsSzcf@91Be1vQ#J zeB=5SebG$4J;{&${rUE=!L#vDP2&C&V+X=?%bVzt0JN0%yM;2r#HIK5F6^)#2Jfh0 z78LkN)fx{sb&Y4vl-#^ZzcI{fZ${^KOZ)LlgTPoA3C3$3sJw2g{g^W{qT-Cmvx+B} zvfry3?O|AtGg0~VyT2z_rZaD(l%fYT_jQ4(r|2tQJM=rFfUcg-T^Ed0oe}T_idT`T ztXbD`SarKXK1!8i^~}M_CvkhL_EG)JnvBJjrjOr`pM?^ux4xtC=bQNU%770i` zq8}I*dWh^Txrd5D@aLc8Jc^gx>Gy*E+{?HCg+2c-4E>+DAg`|d*kBuPsD9M1e&!s| z>r_@6$@Kj*?s0i<89jAD#4ZD3gYa^}(`RxWq)-^FJFco;qvaB#qL0Jssg&r;R9Zjc zD2;<@U;+Y4N})*x!x?p2>PH*vKc-)GSHSn5Yx8x(%k$W7z9}Q~=`UUO{2Wkf9OHKk z=*5p+irVn`I!y7B%Hu-Y0JFPPL8`^NCrVH3FT2YFWex61O{kR+?`4XYtx{VGbe;-5 zJ%w%TYbP*@1nBF3=B}S?qCOD}S9@F9Nna8Zdkodjr+dc528x&lhF)Fn#>c#^^l?hq*zY2Vpc4R6I|n z5e+Qgyavj*a;S?ne_eNmk2V+aV)lc0XOE@ml?_~*L51{g<#-fHH)lxMR=s5j-ue{p z6}MBo1uxq*+?>NHMNRwdG;()iQk^M56GEh?sm>vxu|&qqTz3YwH=Mo)OmwlZE!ZqD z(c$P#>~Y|Dt^78zr$Cg644Xdiog?i+8hvi0tFmb*ia|TLd@0qTgK<4y1UIhXy;5t| zbZXoAYUnM;t5euPnqI6#|tb`JZk88$NbCR{6;|JZ#Pz4 z#r78ql`0U>yshVN1+E83UjONO=<6A|Nh-bGmlPndx7Iraj^T7=l5Z>Z*T{b!RteD8 zl$o{1k3BHe*Dmd>zeyA+Lm?HSx4RBRj8u{SdEMr4GwqFY4K5~BmfmTjxl6QCQ%q@=0E>|mRW!7+b zb7Qu@pX(ib!3yrb>=sTf_Dv9tVjboq{&c?j%x<}oYf#YG=l*;Sn6M$)nWpB#>Yx~^ zTKfoEkGkUX6n6ko;%dtn7Tx|+e;aT-4UV5ya#>m%9`Iye8uo}OQ5_57&p$am(KXH8 zdQ^3~I*#2(vpeJ_>_$}JIM9VmMt2`7Mnq>WJW zq`*e3kVTgV&E2J!{d=4G#{O3Ni+5 zNaDAv@eVh&=T)3A4`mw5x)w;&u1ZEmv8yupdei&2x|8e>7rLbF4S$rEPosSS^h4Mr zk5+O<9DS&^Bcy3>Z4x#rVsuJx z&1}1RxHVaDqD$(Zx26`bz6VAMyRzF$1AW0Hyb37~L)iEWuhT*!bq%bbp}n&-6Modv zZlbGfXkdu#h+jwlvN#8|bJCTR4^=82C6tpGDdv>o@8dDnM*R&B1kyfC*i2&K#InPA zRl^F|hj&d5CEBJkCH|gkg;{Y8^79C9l~}gT7S2$;RbPlG2l4dlx!|aUvl=gJ7k0|w z#GS^hF&IqbCGZylY&nmCcJWgS|Ieo!!x3$;QL-rV*b> z&>m8*%MoTi6}3iD*#cI-t1MNfTyhOdy~TDZ*`P`A_vT`seVch1MXZ0j{m{o}585JU zJC|NgJ%#OFAM+WLK+Zlm(SAPtsfb9F%45XF*1$SHC$7QC)~);)eze3D@?w0pkkT2KN zo^%NySsiO>vXt;6%u$(-`+bm-w+h8v6cyEN{A1R_d@VnZ%?KYdGeyQi^i8ci`i94H zPJFA*brWXh>QIN~7t}ueaM2i>w@5Wkavokpus1|<@0Ki3D~(+=UWnJC`U|Zfk>kvb zoVlXE=)LNH!(Gl{r<8~a9?1yFc(!BtiA?%nOjVw>+Qs#X8{e}dzC5vSUVivwz~>{U zi1e4@hY+tf22MHR>el-{ODZf_aZ+#hUwQ0o^CLTuW)e|MDwWUv8?}P#h@ZO#@i`=B zT8WkR!rb&>5vM_id;~euCFRqdYfwoS2dsujRux^Z9Jyw2jPp_d4i%A4_HegELkx*$Hg;?GiUV7ARGDsecV^!fnJ|!kiZi;kS$fXP)eRb0)6f5_%t~O`e zYpJH7R*;yC*D#(S4@w+&@$>(_wMTjm+-+0D_qdO?o@L0fvZoSL!w-Z4hbsY zeYEE#eLKhGW(Tv<|1Qxzg3rDvft#fr2inQnkImQKh9~yS!3dDDr-}B8r)J=$V!1bV z1M;mu+cY_4IUB13xIz1|Kpkn)kVky9tf&UnUof0MlG?nO*dr20Fkz7NjE!;P?OIjh zA&!xiaQA6Z-{A}6w06&8E zZ(96s)>N5RFV%E`QDRHD68>C+Py^*l$ET=yFx#+DR+Xel;(H~I}R3TN5tx`ct z8^8BxFPUjHL5lKA^!naky9f+8o1+gfIu1|w`ZnTH`Y*k_#B$Ztm7(M!&(-F6Z?SuU zKg>A)S=?YN0b*l%FoXTCWpRUr0x80V0=|;;+R%G9%OVA{SlH&Z0eXI?kMy&>|4wVA)6Fhf3V*uum`y2evMcFV*8EWUi-n5*DA3c_p^R0h=(k668q2P3c zp}g_$iQB}jy(%Lv(ExyQnMZLf4mdf$-&$9|NnJY61?}?Ls>f zdwzYjC)TCFiAz1<6M2ctm-mnD^xzw4qZ<0Nn*n3rp*o&IbOCuM{*gQK`uqIDB7$5X zU0_yWel38zsd3u<{sW9==7z8FvUI)#lc-WObmjg+L&3aiIvJ-$JJ-87aeilrI!(xNBrRJ?}ldP_NpmC)1W5a z5{dZE9tGue-P`zICkL=Y@zAf}-hoaTsv}~Pf(#(iXycBO13P!lCt%AuDO+1xL$eOn zYxx~O-7xeRQ9*ZUBpD8oN^b@TPdE|dgC{&`-C}Rdpliazc~6GvfAb!-lO5j4B(&Of zFE|JU)sus5D8s$IhDHy}PMJ%k6!YT;5<7A>0+-?A1(P1U;h$F`C#xEoT#P#^%1XN= zv1QmQ=yur^Lmwf$d=*ffVF^#L-i%WT6Fq-6DGh+p5Ce-o^$iUbn+oWIr%a2C-?lgY+xgA#5saVk3&;b_9i8JQ9D;TR;>6~EL~h5 zZ|+S!PfoAOKX0DIV1dWP_kBr8Ny&-V&+7(`u(55Yz2wWX^fR&uYY`sUcL* z35+o1?i?iO5=>T{jS;105^)sk6*8IZ6iQ%(oZEjY4~(~>B-FLSqIGP{`Ujra5LfZn zWTk%0@luvV(?dz|WO%C`ho7HcP{g^k=WmLlf=jyZ{auiLlSCph`;8Wgd+;4)+CMC? zzP@fm_TD82hj{3Jw=1O+`kiFdp;eoU3W6rhc$q8R^eeRFnO-%+BQ941O7M_>zYQO9 z@xAMig~#I?LjCAD3bgs>g&}fjJERO`K2#_h+5B1V z*T_$n(e{~3fa<4dv=G8CPfOvMjX>yn0<8{-9MNq-P34{cJm6{?Ui&xY!KK2ZPCXB-(wg3LqbaaqNpk>&&Bmz#(u=QyGGyNOveH0s?e~AwWC1HrTl6Zds7S%RmXbdp+YWE&9?~?J%9Yey6mz1s_2J0u;=*KCG}z zMz@NDY;SP@OXg;E0m3XFl2}<;nOa#X@$A0S`@yZhCO9~Fd)i7er9B)`HqI6P`E&?v z+nm}6*#0fCRu?((^vl3AbT-lPLKRpiWkK|VOA3xZ;Ny<6$iKSWqyJhV5bWjBmaW|P z90CzaD;#rv-hAIx_~=+Kx*c9Id$F2HXo$?rE zI?KNEe$}79dD6q7tL$;*AvG@(J3R5bJ#CxaA{x{uM6n z*|PHqT0l%0{;&gBORJq{Ur6a+FBjkRszOH>{lx0<4Gj&gBO@c9r$Yh*4TAml0d5rJ z??1Rms#valye5Fi$gnFln`>c|SCUf3lxc`g!2Cc|vJ=wZx@Mjqd>vc~0&Iv|jI z1Y^!5` zjGTOQD*64zw!+1gU;U1q-q-tAXD}=S*GCJ;HbcVuJ5a`Q>hTXALm>yZ668xby-ruAFF# z##8j*tm+>a7zKQRyWVWPZwg2{b6da`u}^c0`jOqMb#8$9;PDQN>HBSLZ4X%mxmEO@!qP2#vg#|>TA3m2`XJVKIRE9?#j_8 z$z2-NefdOr6$%fxS4^jIBi~>A=*VX@>gz$Koz%IL-@CQF9Ro;MH4aG1+D9G(kv%8- z)p7z*B5Ko|Dxx+58%V3vdw=t`0EPni0>8kIaSW<5{1Y7KE3mswCQe8l&*`3Ps&LV@ zLV%YyeC)T#M2G2nyWWbi0CK3>_@W!$8m z6hUuTESF4tp#z^h~%1cfgDO!&NS!a@ZMrkM=poQ@FO>sNEE z{+Ww;xGiqfu3y<_29ie+1T03Q>23|8O#bsCiStO!&&f$)%^ZDT;X(k!6o+8EY9yep z)EdyI`C{xMZlyhnG4TXZ{=_*2cX#*I&CSgbTtib6+F#jiW{WNa96KPiqfEuYOrX02 z>W_}+oimO&OSLFASzTK*pwu3d0Kq$fWB}-Hm!{0mHujsBz(41R!~h70$6>h=`pk<> zJVQfmE&49;9;I(_w376b984R*>E-txiDgUx!*2Y^zq#*EpR?;dH$$V*s`3j7_Fx1W z$bvIXX?M=Y#<76-XP1{HxuaX%L$AKQ!}**sN?5=1UBNbxp_@+u+tMO5LQnW05SLY* zqICrY1p$Q8N;e^`bKP`ds^9kRy6yMPOcWVna=`pzA`CFABw}`zeqql9^6L^;Hw=wAH@c7FB)KyH^ z#3%s4J^BnIqk}-zD*rYG@vBX+t)|=T*?$2UO+;jTeB7?aY9+Yy-rrlOUw|#DT?MAU z!>{*VPMh2RyF~U-qVbqAjuG z!7!P)y&XKCwXX|s!}|4*GBXJ&mHM=a5XPb7DxJOg_a2x37w4`MyF*HK&i$SbW0MK; zEdG(7Sf6n1e+Cl1cKFxe&ZFyLz?+PR?{j<+d8Wg(OuZN5BK)mPGW;({h8n3dM0@5s z;;LeC8G|aP)h1J=J^KFqXg;IUYg+f`3IvjV_KXw6t2n#c^D0HNUqC?T`*N_7ybFH! z{`n{o)F#+yv)J*j!%}T&K~(syYBT?hBb?EZ^8Vg@J@A6dA-xLsorck7^#($L{0kJr zI$KkUf4Re>^wsXjEJ@1O;Vky``%cl|GT*ra&^N=`@$ao8DU7|t0^e03#@?%%Ar_Z) zbf~;X2JjnbO`+%X8|Rk0m??i(Xb71rtv>Dy%M`tWEo)b^+~Mu?xi=i8#NDEa3lS zeNW3z9kuSe92-X-aY=#f1ursHA9qx9iVPPLcopd_x~q9 zXlcCHR3`xq{3oA+Ll@qGK7EqOpVg!wqWTLrnN?0ziYUqHY)A}m;|jAX24+`ElFzx! z`v@6!ipW)6O18Au=VG=r_f#jCnN6KOewsVPQ#7S7CgNtB_o7)}O!zILnGrh6L*^EA z5C`J8Bczvp0_g^$+&bcZ8DL;~`~>ttLs#TN1h@}2cV;mHY$Uy&rKv7tjyg^8VEZla zq&d|R^Ux3As{vmq_3Q5I!mjvdhbh(ZFTj0o=5E9S>JD7bYEu_-vRZ%DpTmCTJmu~* zpn971#_F6D$QuN(^q+jLNy-D@lu0M>wr#AD+DSuS=by;;avUlThGxxMBCK#x2d#pV zKfH~UnA%@xf)|L6lHYpkfzDQBi#JJY`@$FLl^gIf86qO?d@4H7Q?zO|Cc=+@N$?=z zgvOZzJ&}uYeLjN<_epI=I1k-7Oe~u}Bq}w9TDj+LR9q86a?urd09xR@o>kI)(^ufS z(BB8;(qdsSel}(WL}#0v)@vB->w`}w?S>SkVy5A|2pIKib$4-Z2mk5 ze6PiimWI;S56NOPwh7AC&LSc}>G!DI+fP*NknAH+UZJ=d zq)nU1JJ*JN6y8}l-Nenie@FqMvN_*{w$Bmnc){LvQxpJ27l%T1M4?miY<8iS-YO3Q zoewn^l!rG*%HrwOH<(A4a~hDHj&GMC- zK=oHmXzg6}cX4S#eSE7#_WL;IW=XwQF689qR%N-!+eq`f(&XAH!y$v&tz05eGgoOl zI~$Gou1*Ai-N~cfFQy0O$6e%z3pnPEztRy1A-o@fN_w$ab8I1CR~veCa>&jZH%lOj zsH&A%~f6uQ%ck0Y3uyyU>Ok-De(^zb)MkY_PzAS8me=0@K@< zmuFpvmVMjSzCD<7oel=Kdn+aZ4Zf`q>6GaASZ6X3AK#z{K&Jm4QO4k z3;^C{78i?3b)!2G=ZRgLeqk^wIL%9*Ur=}Q*Q&I`gV9vz*Be5^=2j5Wd5@OA7GNcp8TdX=(E{j z&l)SfbJ=r%%z+-}lln`&JkX=7L&u*sPaZRJN90}k6A!~2u3u*b9X(~~TO2O?9o)Sf ziWJ!$<#P-lEqAJzO_p_y&KbhXgkuT5-_P_dz1J6DW;u2QD*%|yh&=2g;)JkWw=CO? z-2GYgDvHOL+MGgnE;yUb?tWZz*M@%Cxn(`EXzY=)k z(E}Y{T~A!G+8J^4s&st~zjNLuO>PnXkwdGsq@>VyGU=Hxk?*@$sZ zcVGkUt4^KkEXh%}ETa)pWA(K0Ev|xP%+$HY?fQiv*n`eCK;{<2-lP_uOZ!@UolKJ0 z9ZOUKj^5~~8FRzV=giVXO>bF zK*U#g^U0_7Qde&ms&6n>bGCW1%L!7tC^=;;k~&|Zf&Y~SIB@J8f^T^PS$mPOvgzrM~=#luRn{21Duli z6%n1ft_#)MY;Rvq1+LTuUxO@H+n_%0f{%YY&T}2Z{%UeQN3S#an2TH*=6I|ZSa=_! z)}d>2;_ZKDoaoI>_gAxNlAUVa+h^?R@n^Mu5^zm^xHz=^{JSS5a-}Bca$+=ds_tk4zMYgdkZ=}= zqk^+Ksd;N8g00r;mc^j?Ktm72VVNfDZ>CwtyR5VVOHP2jg7qk05kTBiWrxi9D{H?# zJCINu)kpz{X85o^b8X)7SFQw$cL5m|=;B_|=0~?Fq@X)Dcb?t(I#&dK{>z1BCOn?0 zZMyUdZDe_%9oO;bgz~=_c*0(02QeMI^=tBSW<1X>7dUXa*DfTE3c_CPhizHml_p#e74$uiw2w0o){kW6{&={>p*mRT2T`U21l) zp%ciTkEKaOKx~*G0l=;U)5d`OFpTbYOa#i;KpgQU(6lJFGyRFjqaW+3_W+4P+OmXj zR_pcoD#|C{x{A0`dg3{07gD!gjU$}G0dM9GO;fD_2ggJ8&YvI`cB(DTo5vTWgJ2;O6gy z%Po*rApKl#0t4KZfeD}Cr@2+4|5pUVgLxsla{;;|XbKJLhVsJX0ks|bnEqykdTYZKU+K{MwU%BsSV|0kIGpn+~n~3!#JasvLp?Iyv-Pk=}NTeho0Fb*&)riIB8sRIK_=r`g!|)GxtQfDb ztYgrl8r?0?O&{_Hi()6lMcK5DiwN_@jp4c zdO;B_dyQVJw3U8w!A30I`P5-Pq6&LP}GwMe>2vGpS>z(hb4Irf_=&LU&!lnmXJm6ymV&;QO zrI@C?Z$1k7z29mBh8+?r7f-%C`{Jxt&sUUk;it``O;%Di-$F|q<~9Od(+lnsKPMdq zMCmEd4?jgCQGvGBYx%f`O*m$~*K>7X%C-y36LA^l1{VSd#}n0HAfUR zzV9smPnlfLq5uG0h;kR&{aYHz@}N(Kr++t!8D8xNJ%dwXd*_Xm;?4t&jtlPjsO*a;A1Vtr`CN*EnO!{^kDfMRxt{Q? zg_54pi8ncw9;pcv&XgE5h6(n9|H4(d_69{D$H-6Q0bMY4yL7Eh7w*h=p6SGx0`%;$w)%NllRVV zSeC?e$NZ;{{p3mJb^SAJ0t?NTJ{*i~Rbd;OZ^p|R+5Qg#`|r%BN>_ps?mBHh_E&gb zOZ2w~cEPuO3!ZUe^Jano{ z7}C4Pl-Io;HX1PUa#{E6`Vnk-{(@53M(niwAQA231e6b}wWJc=Cmv&=2?YKQ<7w^J z^njM2e0}ii$tW;o3$TQCQomFGa3to$C$msaN*UM`Faw7jhPeX_yxO=yH+MkeHwW11 z=1#YNb5%NHbo+m>^TV?s=r*Y9=<$F5^`XqGZ;orKmvy8zo(cmXlqV#|^~Th^_u6=j ze}heINQ>vvor9jPl~xkmYA3|3PI*IdUsk4u@^iM%=hQbdtz2{=4Q?)Pi44_i^%_-< z6a)Rq??3bW&b6q-Yn~}e&(q>62{C5js&ud$zxoqkGxaIqc|b~R9&vPYsYr2WU&odF z1wz9y3GV2DPMYw1jysTft3Pt0JwMdEMoX%`lF~XpL?F2*fEZ^B=$7zH`_`>}VO1ik zC=q}GT$~{gxv^P#hQ>cunB|T$_i_@ojz}#}>Ore6#?s?Q> zKy~>HreUn3APndwc)F_)%zxBN*SmlnF?<)2eH-c+F_$wTLOHgsFQqPYh^IR;Gu}&> zB3catAA}|zInb7^T0P#jT=#Y;@g7hWK2R34JYf^;IwE()v_WGu>COqK@`rKDXL&h- zuImW6RMv$(NW4@+g?HlBbU%^3uXng(HCN8RxbLdF<)MPRe&Jg6_9_%pyORHn-@SZN zu;U7P!%wFmz%=RTLbKBR^bjBmgU3iNz|bIW~L-GB}ZOv5t61_$v1!p@bjQE zqh{FT``xf$V)P_XWKL*b{W*~1;s2OJ#E0DmWL=+jxDJnducW=ZPt0=aMHbugqtnm& zSIe1G+PV*Z6Gi1ZWpv;n0Ez}6bjHu_AP%pPy4QUR=VhvOk9nlS5{WS_VIn2?_njZ?)k9L%EbA#Semlec{D0S8~f%|!0 zJXpo@`md#DnQr%XRvnWz6c!<47XdhYz6en5oJlu;;){U-^?n&0D7$gd(J_*$3(7nN zc)*{a7-lmWNcHQV7p%M*!*lgYs+_zH3j5vAAl1$3zcKgb@lf~Q`?%^Z6`6`uw#ibI zC6#Pxlr@DYYnDRUmtPc4(q?NS`;vX9$P(FiV;6?8o3V`TdtSQl``!IsKEHo| z9yP-ZGq2}z&hwn>y3QG|azcqgs5mJ?NbTq0T}L#(^Ko^a_Z;_~mb6QTLkI?N2NQXP zNq+GqTi1^VF2~5L3?UjuR_ER+7m6+tB5dGr{K&U^9kQD&Y~wD7C#}kWtDH%HFfu;> zqhzt`SRlP7S~OxAR@o-yoBgW2QtV$>MI-wd05DfZfzC{e6Bd?ryW1R$rkUq{_VcZD zq~D#y$h}Ulym!`jUX&-8{Mv8T6}@mOs|}TQw~|v?Kv~PFudCwY35H1%^}~Kg(&7&K zB_-GjRCf$EBx98C;3?{>#`%qk_D`nB`0D)TO75?e0nZg0>gSdFnCf@bQ zkBwMcG-RD*P)B3kvLAhM+TV5e)|yeiSsU0&&3|6izg=bENmd$3pWiS;B6~I?CPDPZ z`*BJ@NOr($Ap){L(UZn7HK=4RSZC!0qIqWY=YqoE^x@7BC-N=$q5Mg071 zn9Bb${R1ZZy13`d6V~-dwM!L(I3s^FE-*c*8Ez5}QlqVH9qQb5T*Zb#7oF;r{ixJQ zraDna=*`u02R21v$TIe`Bd6^SmG`D-g44S9(wlR4#xmRVJM_wB*Um4C*3f!6D$wuB z%ck!MRzh*;jeE5O0^qv4Of>Lu(HGHIw8O78?S(^H1Lft}WGX%y209n%ELGsIV>J%m zn5ug$!4N(kHPeIAMK3$Op$cQs+i4pWN7$%p3?EU$N2pa{vgqoIWIUT3`kez&R^kcf zl~0yQquH^SPwmePQrxp_Gc#MqLZ2u`1Lgrw~fZUPO5M8i$6=P0z15O7|T~fQlipJm-s zAxh9qmv~h3qJ7R|%;|GP*-jaBH8Ztp;sfdq9hOfIrpE{KN|21VcB?SH)FCS06)dY9 z`qC!!tcubJQP%8x?WPTw83rX5$XOs-;88MG`J88%nyxPtIRTTdd@Q|hdU$bBJD6wJ zg4Xh8to>@w+?LPhYZ8KCC+8PSd+4{Qys~oNE%%0Xs*%l6o)7CenDJ@DbAjqZ$um+$ z%#Csi@tgow6U+JoL;|*NdWPNYMA;BLZesH^z*p~xL(#Z0{Dv}IIQdTbSVir-(fQ7| z)<#{P7FVRwIz?@ofNQOorLHsE>&aBBsj7a5s6SmLT`5?Hz`@{GEmm4`E~@boWKydj zmJ_QcjFg-Nw>dKJb_6B;rqkNAHJm@bRI7dD5f1QxOYdW@u0e!!1CuXWMTn^7TKHKC z%Do#0<@*}+vA)3q5`SRHl+OKI_hh7SH()F(P3I9dB24GuCAEv;dDcO9lf0^KN)uaZrQ zV?vUEoF~&ezpq7b&~6*MtWCUJSCFdq&+nFmvGh;H1H)N^C|1qKvqw7(Tev=3iJL(tGu?N z-6Rsiqhwk1)SDPOv~r;*dN*O$4#>}5`x@A&)YoFJEi&zF_gygyr?y=3GsOBtBFXX*hb6JUA{NrCpp^GmV@Y03!B%P2A%eqID`WZpO z6?Ee6;i<6R$}T+xJD&aW!-WRtO>!|n0kr}Jq-Fg?c10%>=kt9!+oAM!hDNusDj#iW zr406@!C0AyzB%@lY5NC?`kk>xI&h~5%(l1{%SVeKghdz7)mvcw9ZzCZ(AaWknPM@-^w$W#WqfWp`fa!IWygK- zs?NtDXip0LV6#9N?7Fm)u%{CbgQ#1w6AgV+tcx`Vx(AYtdr}|&mD~YCvrF%-e5Q}zwy`+p*LM+}>JDdrNFkGZ z3V`7dT0s;&6^SSPjUawNAqb+Kul9K66Q=o_^U@(J3c;p%nXlz^u{_$U$tUXFHBHxg z{cDO_YX}to$LApkGD2SoXcT4k$_$V+CSQ%vMX!Ag)g+s zrbE<|RKJCA20yk7EmZ3g!gP?Oy=diI%9!s8-ZBLxMVc5m{!-0;L=zk6a(#*q}i_%I~sEnCFx{0!Q z@UJVS(U3*Jf0pYhNtZN&y4@37x}q(3EN=V=ZJjr#(BBcPX?v?-RacAsL2Ye#)~v_y zndCKIS;`J^?`LMY{TSwKai-@Y&mXrQE_>4}!rW_bet@oC+%Xb&=gETk5I?1{ak~}-&}`dnj2u+Mi&b^tshoUTBU{r*Hd^>MD6NPL6?l1 zhZ;Ux2yZahERJ>EH7o~!*)|v4{Y4WG5V9;d7xbJD0vQqP{p68{FjY3HKbj7wk5KRP zpAu>5^8jn2%n$ca8i$ejlIt`s>>6ycURg0)Gdg(-n?kq^1Q8jzd>Poc(+?1;8n(ed zA23=<-}2$iKm58$m%v*)8Bv>la*zI@%CxlP+7zpy1pkCRks$NPR$&B8DQ|2peE&5$ zIeo_^1|HN`DQUr3LDGLrpyo;;gic4eo2 ziHb~^^T=iEv^9o5g+Q<=ybi})2KVwXx2>OGl+qXYVb2%PC(OLCB7EnXn7@3F_>&ggV>>p< zR==Xhk0Kc@`x~ft`xHA6is-V5V+=0+EZNBX0Vb)HSayS7Ws}kmRX|sZP}O1@6-`;N ze9d+VIJ_|-$-FC$=uXJqb)De3EjAU6$pyvsXd9~)@Q2M6u2NnFDsLdp3Fb*_15wwJ zP~DXat$M4n)<2w&VwZlfznSXdc?AZNBQaUwJoxfbj8U_LVl?)&ZfnduaFdc1p|us` zB{&qOWAHO!@}XTW`r!yQkbePU+jk$-<*Pg;EY_jq%9Vni6!mM>o){O~K@P5z=-rHP=r?{>mLC*%#%vSXBor%nJFP`o z&F)=ftGp=cMX=6QZM4WhHV6r##Hzz(wWiH{z96>=eb)2$MX|xJaX#yM$75s{C(%7enm98?wMW-L5S4+)J%&dO~k{ zL+fE0;KV9100M1Ir5~>keymv;l}7UJy(v9BS|&%Z`QL(dKi zbgM%n;^l$Ad9ZE$_K}Ohbc0k;Y8rbh%}L;g*vwu(=CqlBvVKaCuYbA8N@WC~yZw<~ z2h3F+<8gECz?D|ka#5?2@TfccuzdcIu=rwL$wNN(5%=SU8kQc_m!l)5R5&xn$b~nN z;?R!JxQB_nBN<)|G<&V7Nq2MsVe)p7A##eG5E}_ph^l@RfWLmA9ae9g$ER40!t53_ z(c%j65s);uEr9Z%=uS1RpapDdjQ9LHE{&7F$ zNmI)z#4v~cSWcxQP5Tngq%4_44ck3mO*<@~Pq(9NnOijdz#G=?RDre2CB!KkuF0

LSY7mjfb^Q)45+`-22vRpC(!6Qu)?f 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�q<}=!%;8L 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

Y-R2^l! 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

6Ju@Oikp|(O;GV5XE}l7>v3JmN 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

SVbmg{9d&2vLTTKFMKLys_ALX~N ztFoge6#*?ZKs1nf*ytuBOIO%oLaXD3my(?fXOksN$!FFd>b96h< z3lzX3tGL-cBa0G*e8$4huQ}G`Idg! zt@W`hnzP{ktyF?+(YKZ~MwdT-*i%rxs<8aIb+3E1!P)&-*%@)7hXB09eB8Nk+@O-X z@iG%Mvk2d*7}AfEIuDWR3`s!kl+PY_X}n$m`U zfaJVxKIHH6S}lQhYCes8Z*!?3MFc$7)^~zqRBW3e)ul7}yo$(!@l=MGx^mP!N0 z*WZU`WvRWia$wIMQK={_Y1|w@y<&fxKfJyIfJ=C(ab9nsY72q$o}ebsF??w=!4cql6c)E5*yiN#sO=1^$@A!4FZ082Y9)i%LIFj*!h$6v^i5 zj|4!1ku!x`ExLkX`S`2L3NQ!C+wxoq`=kP+71-frr2brz2&zv?yi4fizp__A*V{@%0xxDezYDvV+x} zw9_8f6eL;(W_n62ttfNEfd@fecDdMeuksQhNz2E@lsuOovRZaGD6<#^-0nFm_0~ra zx1eHdBOV5giVI~BUn_np>(SWhlNY7m5ZnBmZ&jC4@)kbbcDvOpPs6r;?K{~Ul7fdK zpPp$4eq~cw{I9H<(12lC*X?%!%h2gIb^Co%5`-(y=9aHO`p4B5fC}tBo1!djDcnqS z2Y27`MC!3nhVG#b?umLcC0%92!OUAWe8w~Duz;L`FkU zMwP~l>I7#|%)WNg1TLPOXaeWE$b`R0I&j4>pe$-{YVFLo-P)uRc*G?jscB@aq6;&? zr>#LeJ~nAfJqWG8294}tzyh}vl8q$P-aE#<7^%YdXDN1UgW>7Vu*Ir;5h1;qaQU8v z893|Vd5j`qaj6uVSu)@kM$XXzyE$JRh@qxY+%LG*4>ns~)tV}@7_yhcW$nO05!I=p zke1&P4dDvg^%wyJWAylkHXNt|fk_unKncEFy6bq>E||TuXO?J?jM)J=8oB710Q7b; zPL#7ft~N!h7qr75vx48$ULGoE_)d)Mx{IDn`J2yg-s;509Mus)4qFk_!Kk$F>B~sV z`$F!geceFhPYVjqdq^dD^0-#{D_$B5U2g`g%53)Xu32dnN&U=~8UwW(c*u;|M$0ig zp}#NdGZExiE2! zUzK%4FW0ztxtiDtw}!NW0g3KHR0JGE6jJ|U72PakB&mwD7TF0l1}+ z8ponyJaIf;AZ^r!#r;yyS>;ChiCq|uY?H{Y*P5%|YLuSS*yJd3w=W)UPP&5HqAJEa z(tV^fUY;rB!hVIaia_dtNCF>qpFoBUW11qPR78x<;1Vcq*%vNhSzhs{IA)RmR7UGQ zd$?3=y?b+HH@>E7Y*}<4`%+S5rjxAv2`5U0-s#`S+7pv_1Jh*d&%Hc!QZ}u+&IWs6 z$wIjj7Sy)gtFMb;m26{MC7Pv^py-lUN7+7@-g0#_+@0_L;;rj478uiKQ(9_Aa>@y_?i2%cyTk3H7^gQ`3i6uX0=ZdfjB z*d^!!f-LzpTnNf+Ckg;CEuN!FMCO>|lLXcS&D{GkQVa`lc{K);7*H{%d6Dm*4+21^ zBf=g4zq|H8r&W2_19BQt8upZJ_uNbqMJ{AVI2u?-h9bgxkR0yL{5Zma6sN24p-N+Z z(1#xGB5(GuxAs~1YF{3*pa)SsthbiQ_-fDbp`V2ptDtQ~BIbx>SQ2_LAt_?lP+yjb zjJ0eImWfbEpTpfzu}vTr^<1Xj%@DsIS2qV#lS*d^UBuuxhPD2-8g#!$!v1ETT7^)4 zEx8lWrt;)JK;de*g>fQ|1B>s#TuwB>g=x{`>ygG+ZH}+T^!^ln{df`+uhl{8RnWeS z>=@egRIc}d130A3Wd(OHwOWt6ya!9K%2D~(jcA9|y z7l8XPs2csaliFd=CKm%)J-5}J6pC;#_y?s;}S~?*%q~a6fxfddzm^Gh9 z!cbc#rCb);Bh# z=c`fgwo0r3~5C;H!sEw0L#(9cM0Ynsx5&kinB0vlr{PR^t0q5H4cJO zc4-kw9&0V$QW}x7$>B3Lt;MRm5m&B%HTxIYkf|F<{vMxnKtL^Nqvp&c(Z#Y$iftAb&aF zm{gy{-0&9w!`NT}kLs3O9rk%<%gA2TQQqXGjW@3?kuU%cgrkD%_duWS=+qs8s_%7Wr3b?TSb`rB* zO)0G2`t((q=;M%AfwxS*#yro!`D2zb*dZ`r_->?;Z8hrORiGyrJuPCBKSu9gcOx=gG0oAocBZ1Y;2geSb_p?&CTW;&ySLR72kDz-zxX+VLAR~$^jJSEzgSQ zk3b5#J0M2VY$VPr|DSI}S(rOJyu&2Thm%$3{WmA4QCXH4{L}Ni;&M0q2xnDF(*f2+LhiMyyP#+Weu*%;*f3D< zwsm${=F{UDb?y8cmz5~4^qo20Cbnsf9TDuEyAx6|z4vgcT4;)@C&kT2t>emj*EVE( zr+SwJYoLJ96AG{qx~Y7#%41fR_*%mkZ16)^=mc+~yWgUe%0iO0)pA0gnH)NFoj287 znw6w$?wtrZp!MDM!TKTNi}NCc(WKJuioZDyG+e)U1VLxh=Q4mq=oJ#nZ;0v`)h4=A zRMG&OoQVB3yFaC~%t`+z8_|ouuA*)Q*WDiGH9oVPt87 z>DS2T`xau?=1vDkjh=(J=U3T_zW4?O~Oo#DYtRvrDifwx@`z$}q zbuj|yxTA9sdYgToe{nw1mJBac*yW}>(#)llIhS~UK#uLbq1k?8#agu~Kdkq)SRyN~4`0@B^bqjb>mA2|nvUv(6kdCtQ~HygT%x-;-`N0- z6YgvC9VAmClc8XH#DUB4QMi50J2hIH?YtTd9H>_WAyfPDes^Jc(_R~P%n$e?7+%{0 zhqANIS6rRdQBg9zF9_bwQ$N?iRnM}iFTL&n6bP5By}vlzzu~Ea-f+Gm4)_u*0cT@ku4Ptmm@>HGIdW% zZxC6wM~REk^n5x$(Ur{SZ2wLgGI7JYFIqMgy~xX0axRgA9vlsGK0R+VbWI5poJ}1a z+spGhe+H87@`>@{A14ovn3BA&iUeIr=|>vZ#BDhKbs)RhqdKkuvxkYs1eiDJwa1*V zE+mOVuaC0*r_P{x1MndL%JCtmH08SYQ^4y9$)pe0Jz4UpPB+~IT%bGvo*$KOYQQ)= zcfyzcRic4<+s7hd?^BuO4EQHe~$Dd-O@hIx%+CjC`?|H3uCs+;J%SYw}oII@MwgijiD_&JAUZ|Bn(+b?-F%6g({OY;yj7;9-je!=o zB;c~}9x-aB+shGd%zVKnsy9>ICA7~{YnyHAoKl^_D9TYV)}F4hm2UHh;Ht7MK3I6Q z>E>OM2tHfn+f&AOnrtCuqe*+L;(tn=drJ4ZHB%&=2S}f73iC`oG`)|$STq2TWAzD` z@Tkx`D%R9Gn)U=c%$z4Vpf9Jbd;z9x*DbRORnF@hgW@;Ji_i~^9OIGHL=wK*h8e%w z@9u8KU3>rX+L9K2L=jU*!_lhuv}M&go0Sr6?qh>8O~y;AC4xLz9YD5tM48b6->5KY zB>>+E9H|Neg)k120?;Q&76xw^&u`2-i`1tYDL2kCy zaR7d9Yflx%_D&1amft-uqZ&t#@}NH!Uk`2I-_2YXrC{A``~eDKk&9J;qNZRa#87st zRpg8;>{e`QEg!l>V(sS6@>cZpR*p2rJ^W(S7*#h-UVxcsj2>Nq_qq-Q5hV#;e>0}B za(YvZ+D8v5a=BqGiJFa8U{vObyD-jZpyIz0xx?6x>ySg+E|4_TTq-qK!*ZCD3>GQn zLranQ&iFq~^doH*9nWO4`_?&q4xIr&i|7l*knLk;5x@6vMGz0`+1f?luo38Y`*bh; zmll8!={r0PSRld=~bh8o+EJ?|P>#eA4AecnxO8mI+9;}!d^7DN z%tca7S~_{>V&d~&-tLG`zN$cONGozDY1z=$_IB2eldQ3G7Ak)6n5HR|e=W%7{lg$5 zt>287Y)Vi#*hc=_$o}2Kr8{e>ct*t!6B+)KWEs(vjG(_Ybz;JuAWN-sh~C{|y7d0# zkGP8716*fWjaH6HvGPK=Pk}WeZ?JJ~Z7p`>rkOg}(visnY)a$5VNA;NtVkmz%YqQF znuLWau}}we*CJ}?*o0eag_;s3r34d~f!$0m{uA3n&03LriJR*D3pd4cj2p2ehI8bi zp9D{s$9lHiNGUcH^!y-sC1Kk0_c$+q!QPBorS-bcL?)2g7?LKm_}>*LmL&Nbbfg@4 zb$(%3s`Z>&tFlgnd7L=rb^GauG_|z`rY|e!;ktb(=;wmn#e-rzK6l;q`uDzbQr?Zi z=o3yccr9erhZ-QiU2-aeampZ_N-BNwZC;Q6 z$Jb{y>XNDO>v^be{{9tAoMyfKAt+zT4vWbOS(!tRU4d|+=zY;_adqv12j%gj_66cR z&P=vCm}G7J@{k(z(|qbkANo1Jp$ENPB(LS_u3kQgy8_91pTp4{BYX2{OCL0%Pm+6{ zSg!pAfx6yEEqWsu6wBXk7h3q;WoG%VsIV^PJ$(+nZP=#9fqWLTls9Ti(YNw~j!66J zU3^=980@+mc&<$?H{bc>tAPFpekp9#1I)&qi!lGZpB#d+u~=v5EpDs$zLK5$CoZ{M zJF4)MZlQX7XY&f=gfsp#!NPW-Z0Iee-vuaC#A?qt!AbL2vokzfIk{S83TV{GM>bKH zE$hbNV;^MwdI#Tj{FYTm*W7Q7S_){VAJH_*5V0a+N9_wejbW& zt^|cQ<3LcQq30S?bZxv`Swp}f{en{BNZ_q-#h}w*;C-o^qkBo8>VGQ~ zYTJ{k(uJ)xm~j8IUj19DQ)l;t&fWlkmI2j*6ybN;{)E9>6>;upt!$l4&7{}^Kb%fS z;JALB5YZx>T9}{z(^Zc@g7i_r;2J25*UBt91s4y$4nK& zOSWHei|Q#jWC{0ewapj*{>rcx_9^cBy_nS1#4wpty#x9 zc(?o%Dnn8FdbA!{E-!2nUgVcQX_r1J`p)ePFE%a?U~L571B>yzR5-SiUsR2goNF?t z(q%9pZEZq&s0Hqf=y_-H$`Chi{MBD+Iy7^1!Y(w}eiI(yZr{$^jW`gV3gx|(MXA6${=$lZuxr2P-P1d)!D}?_er4bpGyOyB_dgj!?BY)XDNyM}2o!I~>*Jrjf%|yhcBO?`3fO#U zQ@o+pn*PJHpHy7SD7i>DGC%emckM`aONSoIC1~YEA{3_%tEH;*J_L&7a_hpI>y`7> z$kws4yizbf(q|fn1H~fNJOKnt4oYM<(bX5bt@k6+`wlayhH+OdvI(f z8GY7e$9=PoF3jraacNXq%NB8r5o4^GO|}moZt47Vc=xj(?QaEJ1H<5opoeF~F=b_& z^L>F2Zg5SWoA`v*vkt|H9&~VRCzL%ch?%I2cf!oHDT`T86_-9cYZuNAQvIY1^Ab=X z*skBIz<~}fPW+&sq;g`gyyz6MPs4I(I2+$35kp`2G|%_e#R`aFH4)SI?5#7Z;gjAs zp_yf@4y)TGmJ8HdX7fyMxC`Tv%SaVVfeDiL=3stHJ&&1ue5-KqVNtGSvbI3Gaz~oq z7mmrVMlN&j2l^h_#5G`YRYnjwX2v6GSoiJJ8Bh85{D75ytn$two3N{ z^@g4HdtbonqzYKG5CrrV^*=iN+91gYOs&Q?%S*#RYYuMsS074zusP~1vRk$bz+dDS zzsE0k80*SO`lt=CZTi}0@rA6mhB+qos!r5ubLr$B#-~907g!QqWItUe(TZ%Cp@@GN z70^v{1#inUorE6`#^WcseX=!)6*16X+7e*IRjU`cck4=E1x64!R%Jx|ld1BefK-s| zGDcWmJCeyJ?RV~@%bkqFL_aV&1fmX{7wBKBRL|4;i`bZ1!UHk3-GjJHv zlSiBuUH|k$U&#Xqn3&0B(VzZIjc${D89QNEFW{1rWR06d(lR+!B!U%u?RHQ18i5SB z#8cL5s@!(}Ors69)cXkt5x-k=Cy?bbf>{VQw0q~SdpZEDi`cAZ-5ZrR_XmJ}ilF}` zSo~eJSekHzX^*7icalV)ZO3B;?IgRpLvvG82P;bfvQ~BeuHN`VA)P$IG-pnH_P_N} zCH|NC5Tmb#efIgQ|M1gptINBp7`%^hm|aZ2aEMs$lc0B{Jl({9?KL4_3>w>i$BW4q zBEt#-XfpDzDb`uZ=AAlpf^a2EVKkXqT4YPqp)QcsFCNvALpu!`80}Z(G3~DX@CR2R zVZ(|G)LCH4noKupsOp14)3r0H>!$3xH0Mvs2L=)pX9)Dq?ry$$h~EL{Y7@8Moh^(oZIbwOD|IU7~pG>Mu@rC?SPS8e4;}>x>xg zp3@N5x+f?kyEWW=`v>q7+a9aG0<{|KxIfc6JFCZqFykFM&5Jw6S9skpBMN^510S24 zNET{l(VH@?1q5qpH80s4?Vw`NvcYkLO}DgbpP|KMfKWQy4F zf(d*HRk_!XEr_k~-S|ARyRz5j*)Uh9Q9C`|u{uG$+%_KPtw{1R*`95%hk4GDyZ0%d zgI`&_x=f8Peepvl?u0j&ZDtJczIwN$ac8b4?5_4VbrbO!aO4~Y9E}L1OS%gu2BUsw zwYbsDtZAzA(*xl^PiF?|m*E@u zDeZ#bY&A#jU{}n^*|{jd{X9$FyLP_*ydpLK=ISQh9JS7vOvD%ULPl7&xhMA5CO+w! z^M_^R!bzBKR?ZzM?_*ku@Ed}6l0{rrh(9#V7o&cU$&`$e#j;B+a^>n)^h z5w|l<3y3jS^K=!0_r z2d+@{BV*Fkr50c1C5-A09cgGMhVo~$n|x&$|MiksQu_bYSmHO8+X9)|Y!%S=H@tZ$ z%-B^zvXb_5o%~>JRgb|P^GoV#oD?hWpG}9~HoVR!v?s|Mjggk#C5#O$j2<`_+ zN6)fch5qd$J_ZRNu)Qm#P(82eAQNcW&Y+*}A*1+Is_jmfXj&|1-LUfeN$%1k%%9tp z%i;c=m~iRmW9YE9dDUJ4S^y8AwzSe%5KkyxBnK!k$tf*;HF!1JpH?JmyqGqot9(u? zPQ3c{Qv0oG!8Wx!*j)1T))1-WH8~IIy#ObY4;c>zN#YDb?Sq=BM_&8IJQYz-W$4O} z3XuNqL4yJ3m-C)xrA5)sFZ(^s_EkHp%s@#%k5q)Aj}t(ltiN;|=_NX5cd|^^0r%dS z#(~aC*LVAwDf7wt6skLIbuVMCJ(ZJ2ISqv%{<2N4th+TpIu-cr)* zV+4BXGGwHE4Jq(VDWsNxOJL@E-l_V)|aVXWE|Hez@zLZ(_g!)dn z4}${0d;1h0ni*g>fS`QeEgeTRL@#++|d+=l#ke?(?T;5zt}adm(AaG=H13(&!B zg{A@&v7K_7IM#LC6&@aQ-Xmmx71G_y;=2MJ)^|-aFDC7sC*y%;-yFp{r4i~G^sQ387Bm_u50@^%`KE|BmZ}b;Jn*U0WdVhX>{+d1HW(iO>j39G zpC0zvJm}nb|L9W-$M^^5fyk{ey6R=iR;1!`{O@m#<(sQ^1jJnpQ;S_Mvf>mTOxnfO zC_Yve7+A;6@MR@ti{RVjySB1n><&~WOG>dqB7?#MPkxgU-b}8e{NJ3nn3jtm7y^fiXx?k=P~P?_UGywP5%gTclL1 z-JE7h3GA%DivTJCJ3IT2WM$Rw&buFU`J65yz-U19we-Gy>8@0?+tf=FuK4%+Eq3AE zo?rtq2rcH-AWVUuX~sA2oWmUqkQaGFZ$=G(6X%r<)Gw;z;tKCwa<(bEa0`5NS&{W& z$SG$}>4Pt!BNMyC{u2(mbl`iCJCtjm<^iSqm1@K7Y7Meu|FX6CI^c z$N4W-g6U(Im=(~Fi-^WA3uo8ye(yz#;t_r}`8C2F8k&U}xpt1Bh6y&jyg4Zz^QDzw zHL6F>9p8JX^S6mE*hJF=Vx?*gc^$@>F%5<63HOXeUE z71u6ZrsD)y_(q&l$hSD-qQfE*FW0<-4UPnQcsSiZ)+SfdEbTYc1`zG>GY5~q3=nL+xU@= z$6TLOV_=8;J;o5hM^JLrn@gE_wT8Z3=na`LI1Fu;-mK-UsGm{Iy6=(>%|KbYED{p9|DeQ3KIfeiwecP9TE#VF=aF5Sy@a zZrOToek^$AZ0ev63k{T@i*5I{y?Wh%#*@s+7irMV6wqXN%`WoM(Y9ZlWI82M`Y8=C zpQRSf`Fp+oTFBtiCstci&F>4-d_t)(R{{CIicN5$X}LZI7N)m4dkqMH(e@C)pfk#Q z)*Lj19_O={i6Y|1!v2U({7KCB+=fLe=6C@B1(^ei)M?t8I>2dsla(3cg(JR~yeIVT zQ~J~t%3KFZvzv4V=M;JX)J_^4L=EJXLm-M1$4H1zVY2WYwe8yjrLXk|*QYqDa3WIW<-HP7Li+-xPhH_!c*djjl*#B)nUWc{iA-#-_ zYca9wTsE+GPS;IZjq4kPd#e&(fevjRf@rblt_~vQL$4OI%`p@7br48F1Eb&iqc2Em z?wft&@_U|!ot>1|Hru5XYF|H}kQ!IjKW}#xo-`nkKPW~j=490VbS4DaUx`fLqKa|` zv3B#I2!%?A0m&)&1IVctt95v8x!dK>)jKKO6%c*%ZHvd8ymK){Jca{njJ+hqdxhw@KWE>GLUNqXbTLR7&CB^h6;oc80vS^0hx>-Igy&k$<9y zwXlChE=lgV*m>tZ8HZ;}bi+iAA1|-3xB2^BQfREnb4VbLY1J(SLq*SLnlfsxsdlOU z^#_YJw@Lely4QV-dYhGd73W?~q4K}X@mn%;7P`v*b`B_dMLxyAY^qm9YtiPegOM!6 z$cc=&(6c;yxq2>piYf=I1D49sl=TT+%%0}LgOa}jl1m~50kQLbN*f?0szj6H`U{?l zj5b#YIGV?z=)MWV-;in5CuV z%mFZ>&*Y1dy%au|X>awFww4~*qM@fplQNh316)k?gkqNH+Jbxm@7R*^XO?_DJ+{?b&OE|858iMrzXR$nKm|2+@d39bzTZk8%L+OkToX za2|b1IWoW;Bpc;=s9h)CF737Z7UClv#_)zo5{0`{)~L!-vvkMn?faE&zv`Dv0nvX1 zMyO?ijrCQ=k%Q+{eCLN5us0p|-x%8jP`zaLXNkGG)5Z4Xku@m~I>8XAO#-N#jVags zHre%d`v7ac`asX>HOWYTGTpTjq^4kI?_nD27ep6-4!KEWo1uD}Hzv(VX2$UXq^j`P z3Gym{ia7-8Q71~u6+q>F3W~Gyn_Z?gBhQe{h@I^zH}QN~JyPX>=n(zmTarOXSgN82 zcd!Y&PjetZ*Yu`VANgh9#g-!0_*ro->8V$Ke!j8Re7rxQWMIigsy;FSg6_;F zi7?Q6hxv_HJA71B&5P?1<`NillO9wYE3*S%N9#Mx=-QRFMy)r?cUA*tadzKFlG-+C zG@oj6^UERT*kWXX7&GRwIQ0aXF5&Orzt_ktVx5kc9FyYt?>@hK6HxopGDbh}t8O&k zGvwYl>Yh$X49}qJlNu`nhW%k)7`1Q#b$g?5Q<#$=!@A9VP1ZL`ygJf0SMmN-yLmty zElxMiw`FY*XydlOWB51yJF8*7u~kY}8#dv5&iLSm^`oNCvG)RJ0X!NQPr#na2ofTD1FJSNMlGLN#k2|ss#&}FC0+@?RyPO&H&1| znqP{WX@X}fL@Y_{c~NnMz;J1?0N_b)I6ckgdK}?LC5lFuu1DES$O^9aXCBDII0&d87!b7tzN9G0w*UOC80QDYUP^*ipIV_p`Q5X)w)*YLi$QH1MT8P7Ff8ZeJm8 zp&x44U;-@x*x%Mp$VMTCkKaQ8$Mo=fsDr`}eW2*d{{A z%|DJ_r4&Y4bNoyEv$to##h5Wuu5r<`^YtvwJ9NpGUdTMy?tly2BN6NP0>An)lVzCN zh`LE2LxPR?_GMC<_##-IvF6{$C?U6}vXUjz&FLjkEWIB~oXn@bYQ(-JomZA2IR*Aa z#QTDz#v1&Ojf5GEOiUiRsD=P8l|`vw)Y5GbDnLiVytedjaqYaXK)o3z20M6O zg2lNd5Vt+(^P6$;Z4b%R-+tTyv*LYF zYBPc2dqZ$IwoEd-FJzd-w68!@I`V%@@la_5YafAvPRcUtxr%p=$N39nV9V(567U(O z?by@jL`?J%aku!wKp{1=eLwtih~?XlwTo^A4NPFAi>bZR9gseOcA0ykz(DT72dfeMz0mpwd7i^RpCk$}3rL3yMa^+n#L=ZcD7TvMdY5gq@Zt7~Ql!yB z&4^B=PPbuBar_{~MIs*n2%Em>P8RO(ErnSonY55~pkyJRw~|+uIf?&^3&0a>rS!4s ziK37jQ}tY?WM%&_D*u`f+;qA?5J2}R)Gc|OGwSXMndTn#$J--JSf-3jV;n2+Jb?<9 zJkzcR>rW~@?fAiru@Ga1^5Oj{tv&UlYGApulaL&fxX@&lG7;qX%YPPZJ(CkYFKc?xh5nxB zbCN|%K{}WFbo6gYK6QBUUh;L?9*VqU<`G(GJ#n-0#QALZuWQMs?Zh$^y{G_!(wa9C zt4h@@F3ijF0#AK@XB&V25ey zVB$|`hC4>4KNlnlQj{2IUvCUSC^al!WH-}|=FJ2DCB(j?p%ad3GqksOf^!=yJ>C!; zxaH0I)l6hzHlG%#LwE<5~F z9Zm$XIqkjDRLYrv_z>Xsr?AAyJyM0m#~+2fvRMs=*|uy#p;sy%AXob=g6` zI`I8&<<<&5db=Uu&(E!{S|{ND?fGJ78?f8R1581=sS~h4#Wmw0s`WW~_WC;$Hb+AN zjfa|h)i|w!%h)C5=vcXzeh&qSWK8Tl`6a;Klt_BC0yu0NF~3Q7Q{*`%_Vb+5bvS?& zAJG3nQtw;`qv@Mq9!;>8-Y2xZ=V{+3q+W^)Z(9?W7gKj&Tfh8mnH}^JpwQ_B(%w>k zn{v91vZvN^c~gA?JjIzs0DTe86(1~(;99(a5c5O{yi3{2PJ+*{i>wJMV0J+ywZ!}pB=hv$`hTF z7iT&5m;wbpgEN2a(cI75ZcEu+2AZ*9v&q7@C(_$>qn%}2XGw*&gq5mxcs|(22XSBX zTVIQ$E^~FH(Z+#eEY{w2%UYPMcrxYLlb@^IR*?=R;ll1EteyR@e82`nmCf*{9sZb5 zP5uROTy zTxviSYH68ce?`EO=PsxzCC^s!u4~={-T}YL%1p~Xs7D_Rj&>UBbHo)@RV93Q_{tCX zfM{z|a*(Sp55DKoI-Ih{Qh<(f-TD0AJ7}!NKF{%Q33Enm*jySWy${+MC;e&u?$7J2 zjY)siY}uAl3TeH2MiePEU6L*wKYI_p0#lnkZ?{Gyd!t@UUt6LLw`ufB`&G0v$mUpB zV=vy^?uHWh8%y;PF84b@$M>G8&w|@EjGnK|%U_9CpgYPESL!dmP@4B4=Vw%9I&EYHhH`7#u`q=O!U0kPkOQF@iben(TYuOXoo?YR&nBd*XZiDhK?}F{e0>^jndEZpI zl3j&$YhZYDVM5El`3_)KeS0$!Ae-fDKZ3l~=3W7mwEvp80mW>K(z|%|gG)B(Ti(;t zA5LB{_Ul$AHQ7%405Jv4!h2c)g1hR~J=QvvDb@nUE`z)VH$c_M zzZj`;-avr)MH&pqkyz!Z%dF`{A0`TN{vv1tneBqJAOqNA^x(=RoWXlA@chEz!xy&k zTH;P9=q}xQi^En@7w^PO27RDs;q?OD0oYW(#kfa6EXxJCVLCv@HfiJ6;)u%%e-J+R zuq=cD*^;K?xNfXHn2n&|?m;j;rJGm*JIM`-w~u1@ZL*o%Ls{!HGp#1xHIB~~|DfYw zw@qLxhTWLoS`sHC0!Q=A`N{GrT)mVTT%iQi`qbL(_zZ2Bhhl=y9S?yPc8)_QI z_@(}p2c)ILc;GU{d0hnz^x0%-`j!SOP2N2YST>oDXu=gC&vpZ+a`vY7q#y&y%1r7v zAcsf~uot2CaF>i2(v3I{*I+Og%RcFtLeKz0-_k|MbgJ*fjbRh(Plzo9b0MV~7yBNL zV*Yuw|1g|&coRb^HoDFjAX_q9Yb8s#?NQ`Wwd{J` zq2W)*Qbh^mBbjFy)f^?|y&G#l28Skw95$;f0>kdh5aGjpkV)&Du?zs@nsR4{_$xwq zykOrETU&Dhx;s-U!UvB;uRvT+3s1Ga{;iw7V0WLp1nHp!T$m1DoJ%39!Az$HmU8sw z%yS{k_L}0rIVI6*0(7|W9vkSCAmT2h*Zag0h?32te&e8Br zFh_z9e1EOW)do@;|E^BdqPis9J5({WVd|3V=B#Du-FA?GhxNZzTUWakN%jSdB6yDSoiUH#7@xAk;UB?DGtJcktf*U2-fswq1*6P zF1LNC&k&q0sqw-cS1h%KN*B*gW56ug#3mCFsu+lw0gOKgKmG8AX*d*fduo?v`Uou< ztKO~?JTe+EMXS|6Whj^RW|$>WK$(iqYkrx1*mefBuO+XPjZp>rR80Zj8Iq&mbn#<& z^g%nFO8s%}h;Zfx-JwOor6sKeAp$UtWFA}j25I0ulg?p>tBN#kcxTd65Za+>~sd|OuL(=kvX){o^ z7kX2S#y8w=y7W5c=6pUP1^Y^!K|A*OC$TG!V`M9aRrqFzeNGL09;}zy6TSauVB_^W z-}B4B>VB_qCQafTzZ6*jti8%y!cirFN;lfkO~Af+uE?3L4n(S%r(v77egO}j8d1%5 z!zG&7mVKEXV1}ceBOUCI2?f2ZRmDVyg+Q|I%cWfdwBV#2)us@U*mvdaRQ@@ZJ)H&gf1uYZMe zKxgNfG67!5KT$=3(k#WY|6FQzxRV{<3U7s%1tSJmw_l(_W+TLKk#%9lQ0BJx#|CCA z`@}1CAJ-l@F`&4xeQ-$4(1o9`bHFFbdHzZI{@!4f>ZT0daq8x%mKUad(xF9s?|QN5 zN3@)D?yvUGLh+Dg`ZtSp$)8Etj3Df8HL_0K0>=%~#Ydk5Km+7{;^R1z$9mT-eXW&f zsKNXnygFb-c7?3|W0hA6^^3ac=c9TPOj<2=_SVVY9h?Om7UgqWHzYY3ho0aRs(a&R zR+U9!7@r7M1rlOp9}UC?3o>YFYpZO0L4n@WakhQ-!==OPqpSN>Tw!fE9vOH%N`rQ$yW0DL;k{6r@|LiDCw`BGAezUC(c_ z^O!sEK_8Zt6GNPjwtj5{O_O1$&aigL=TNBdek&Txb(Z{rq9gG`a5i0e{8aC#K6 zzAlvmAfH9ZM`@i4979?GEXUsS1QhD&lKm$G&vybgi4fz)psZ31l}Eo^qdWIMXH zP6eArhPVj%p!n;(sAcM%Cy5K5d+*SqgdMYUdB%9E9+&}RGp&x*LZKh?P2WLLn{<{? z)Em$cFn5_l({bFqf8m)~e~@=q{6DrQ4HzoF4&RY-RTT5J=A!fCmF7lQ6ZX`f^TzTp${tv!* zVyv7hy3=kbB$|pue*mhl&*l0=ki$v8D2@B_G@|>t>O|xM>3=#xc%@Swo29Y|YV_7H zc`<;ogSNGoWDm3n?)}~3l|#y!xSeCTQ$xN$$UEqq@(bc&$34QZAg(C6g{;n2 z!z_FXsJxZ6C*hOVfGRLBzBp4!j9ltFJ;Pq%yk?pQDl5M zwgMTPNmu#By3UiSSx;m3m@~*Zw&{n@=EHQYr$0t{BczLl=peiP@xtl{gda4;xvvGv zfZ$B0o7D%srB*7V_9!*X$65i_V3#BxlJwDV|Go0-wl7aMx=XOgk=M%~3Nb1i zH8#LVgGP_I4zWZ7;0P`x3^c77DHQfq6E-$2)snq(D*b{P5WMaSNM=HuRSdj{WP<5` zQpV3K-!eFG2A6x^@^ z6np*3oZq`O+2`ZRowq+1VX{I_6`J&B>F<*qzGkR=qwI7T`J>{JkUh0&I;V57r@zPvg4fVhfdA&1S9pnohyDHRl@}X^75~b zoZ}PWb29rLJa>OP>1Jg#*8KVx5u^gy;yU7!0KV?4mjG*#P zD|(Cn!{nH!0lYkBcL$DQ9`S!qu~b9@4(8S!rk3Xp3eIBiGfGUnbN3UDzFAV%c2d%0 zk2>g+gWdqJL#kpYrVyMEhn-jr<*BM&UPyg_{(5TRSr0p)P!FG|)=@-0_La%dDd~N! z_A>J!r;OP)YP!+Qo{L5|f>vku7NL9LW=7bK@t7v zbw0HG!Bl-dv}6z0*9P_k^W;ysGhm?$5aT$&Z0WPqk{}%7CiHJA?dxw!PkOEWE-u17 z)6{X@egyF`{l$H4)!~-4O37r&l(C8a@od~5c+VtOy30j$`zoZq%lm}(bbDYxAxLE7 zZX=Azysa8|GHDxf(=h*va{YylBzJaVh3@$Net?|H!h89k7sS`#{rI zPp&JH!n8ynV$1o&E}x&nFGIMmfsBLMOH z62Jp!g$2}jy9$ptfwtts*V*h8QJ14V!X&#nvf__qDN>s8STX;ZrW4boUSnmp8cVwW z;W+Ku@m8zLvGWw6@a!(34u?Ej@;-C%t~sh&-CW_jc^ev6q%T>7xKv0934?~1LVHgA z0o6W5^8^inc<3J+N{VM#{Y3n7P#T@vd`cM2D+EmAGaoc%`vWuI1Fny-jpMK0r>FJd z7Qjm%QZIlN<#=-mfCF>@J7s;%lHIa&)o{#%dk;^NcO`@5f)0(Y1;pfz$!)z6AMSDY6g8AnEluNj;x_aL2XM}BKY z_+;=G!9Lvb4SE)qufq|AkWl=Bu(BmU$~F&wpLywV#66G%PbyjI67G>0J~$sQjBCW2 zh;K|k-4ZVRUO>UM8If++aC>3m_oI8|b6x2r0})IOogMVa%&bd-R%5XoVxV`q9X1Gm z{@5&1HtS961x(F#X*Z=!)>5s4r#+i)6Za*{o?^<@$5COiG15qyOG8dyVPF0N3TtKv zQWrzb@z6zAedK5Qh8^HfaD?hbCqF+&A(eYb1WFUySw=!Z(4hn`ynzF_><=$RX37k= zHnnBSklrW%x4)mEN3Q^l{u@d3a{vKCl1cY(0%iyukw7MS<+iZxtXs;ZZ=_SNzJ>kZ z7K_aLwVVH5-Cv!)#|+Mvji@T6=)8|Odp zTg_!W+!d8PYf*ZV(1ePe-(({kY##L36TEj5F(woFHjK1(dB$pcV(PVwPk5^&yCngb z{^rR_?D{D&)fh)TCLRpR^P|=!R5?0$D@Q&56HgX!bMm6t>n~YLcP#l22UQypW}(bh zjS{%sDPCou(iGUReAU0|(m`X}0vmQ1{;tqBm+hb+hiXE(C6Ab-#fhUP9h`+3A-%`F zfH~l(e`E>RVv1adyeMKbui>@{uu6!|J!pjr!T)*Vv6o{E16TrYm8ywpsB zX^6sxuDYdi4ux#_4FoOwH?=1KpZ7Gq{1%gErDW`C&)F>z$(W#T-+s}5L>Qm<#;2+0 zmvc`317>YwCd?t+IZ93NO+hDK|D(^kJT#=mww1uQ2< zGu&FLg$vwRHZXM?FkWRZ5u7m#UQifQ?>&4*M>yQ3tpzIGHqIfC)zE8PkowBs+{kdI zwFe%lY(l&ur|hbzEX_ zKvVS6-W{$_ML5Lv96Geod7mB3=2UFYxfOaof*71p+lH|`O&Mq-bZOS0xoqR)Ssu1g z44EBOlwvz~5f-zU*XwVhiRE@#hOxzqxk*#liby1;$E2Q<(s8 zTlaZEK1RPn2SOGv z(ue6a$C^{H{_Ikf29iOW+sVor%TA7AQUu)m{%)jmT;1xuC;_(yY*=??Wh zEUT5f>z@>>QUCNcnQ`EnKf$Uhmx5$9X-N zDm@Y$43={n&jnTsk+5TAg29J{e(ce+}T%S|&_hlzk#7a(@;+A>)0?Lt= z7km{kcK9>1&8|jRUc1Lx&rj^+)6)K&Avx~vd&@S){lmKc(>^4+mq?YlUQ5m@0D0eI zu7ulJ*XS>7PdZZH-BbvbrGAxkD@<3a>Ah+$MDk@suFVzltZGv35?0-?dpy7{`(P7U ziY>+#D-8*}o$A@;$-#|U)~-%$YEG5n;A^F7QmMCBA@4+kS01RR-u}VWb3lz6o58b= znKk1zD+<4>L1%JzN`nlv-p)zK!jqzW&`kK&7Ez-5`9v?M&lTrx|Mrueq7#Vcjslvv zK9BQE6q4kK6R3NIO?MxU5vEkTu|sRTe@c=Jh(u*4PA|sa`X8rX5jPnJEayhD(V5*z z^-WLQC$+pVTiT$5BIm)WJ^oL@v7wS`^uBKG%}g%zVzjC-8cjQrMK-#SeEy5OCG;Vm z_`l+-rJ*i*wrYP*a*I(m742J}8t2MzL?4QZx!dpG5z07(ogCVg6j$-r7uK#9ilw@E z?Mgvx(A~#9rBKi9yY>2R-N}Shxr&uP30Xd>^EyVCU4f4 zg?tu2b!<2pG6MX&t@sX(O9lrwxfMUZ7*kkcSIdVpC7SR!Z`gZYO|N2kJAt6rCz%g}sN$de9c@X9x5- zH*dP-D0(f7K=MW05r=|I%(=%1z7_Q^==H-Bi<9ibz9cO!Er`N@3 zPyI%gcQkvZ3@iqB1EPLnk&3RTy}NElyw3<{$H@_1Tb0YLm;6!o_{7N@^_Sw#6u|4A zyv;fFiaF5ZK0}x~Y&f5u{eB-KC*WmF2@ROOb5gfTF9+>!x%RhZX^B-uMP<_02JGPu z4G(Xg4?TE^kASP8;3&;XeCr0?E&45(9P}mB*Q`nxDi(-KyULcH@e9VzztgfAsg^X) zw~!mpPhnQvDS@=v<|bQ+yM6F#r@-dY!4>@ri&(6Y`ii1p)vak9KxuT{$v;0)swF~2)LnyrzuJ{+;A#1fGmkdo5f zE6!5J9Vt&e)h4@~lgD^4a4ggRYEeu%pJmso34W`4cVUV|!JlBgqX?uA&t z>~_cR*;#n54W)9wVWbUHB`GE`Q$uRZ$(xl2K^4VEMik9MXzZ)q zhS2z;rA+5a?=wT!{oxCZkpyD3H?ZKcASNMXg%fX5jQ3n?!nCp)v~+ZI5Z=e^4fDNN zh`xoG&wP%^L_$sW`c%bLVEuFCiRH%n%K53RG$HABByrE1Np*K`Kqm3f)GO1)>NQt< zwBfjCIiECVid)zYhYoZu*Ux$HU{ksVya-|U$87TRWk@{ewI_pLDEz(_hpdk9vr*3B z5_%J)J#WyD8KV5jgfF;q;(*to&tlQP@?q)0A=w{Q0O#f&)nGvkvr6{4_;5%{dqqOg| zm3n2}(1k5SFIsjMlCfy>lu>vTrQy_K${tjDG?*kBMp6X$7?~JF@{zuN3A;6CAbca{ z$=&lXMsM*P1hqgmRQ`ebl@!+tK8bK^{EtE#@4~hX-IP7Mb>{(FMAuO$eu63>dg}F; zjptd&>|EJDOzfn;Mq7|ZWl5Lo&AT_CIVmR2#=<+_GsJNH?^n=TH8~_l@!yazsIZU% z!qnbI^ydso;Z(&{pAMUvJ3e`n$JG$wr8WCyuT=CndaAf|uIG%z2UD|Z58kR;u44!v<)F|GAh2OEBU1mwWXs~!zN9I#qhbw(CbEr|X-MDzBZsWFY z8I<9fdS}b_syF)as2Rt>+1XO&c7}FJPjUY~!KOZTkAjT_QId=N{rlx*&Wd}#-K)s@ zrKdIUTLWql@Xod&0k0dRdiB%Om#D(TlT4N$MEv!~lZ(M_CPXle${Ji~zqdXXmO(wb zO*3y%rg=5i^F!YUugcOj?F&C;F6d&}f4)NL|3AR}d zh#Gh7nE!0Et-_y)ma&ZYR-pWlOdVSDsTF2mruMtBl$4b6 zN=n!#gLio;peG@(f+f>`v|e0U>Rj$lUemEo^m%MFV=Aw=|2SwZE=lEQVS~n>Aqy2r z7?YEh^;i1HZ)EKAC6Xy2G8UAX`_K;G%B31SSoU7@#Qtb6GKE`o9V2a+_^rxoAo#ei zXkzQuYXz8rtfxzl*d{{hk1jA7DJ6DG`2kd^+VH1i=2&jhlK4K_|oWAeHvAYkWl^? zs~}ktgKXW&e~~*b44lXp*Na*MiB-u%c$enlluj@B#FN!PeI~#<9JaW8Om$njyIZp_4Ly4ZfgaUP5l{ctbqJ?Mj}LTj*yy{q=tH)4 zMDg4Zz1cPUA6O)?q$M%S-#W_pkVrzMx88#lttK#nx#Pmrg{@YGDVJ{M)j1b9*VX!1 z%qJHqO>?yV!aDbJuZJz^;6%mE9*N^glA_@9ReLiza?n$O<;F}os26yY3ZBGY8;u#USe@=_FrlE3=Z4jJj_j0_D8D6`}t{_XrU(kd~s zmJD!h5XHvIj`F!PFsS1p><+b+Avm6CY4=Ud%!;{bzoF4n1Plffx0V_sN@~v2CB=f5 zHk+;eHD;f z?EX7qXSz`dkEibM_0UzU9a%`&PGM}H7vf>_{h>n7;R*%#k(jo&q=~t?iJ_#9K7|Kd zogU?9JgZlBUePX7x+MrnRxcwT<_<_3-h6dHrEtYRU&=}?4Y{|OCqsYjfcl9!uRg4O z>47bbk)c+DR`7z} zIGWArt+DuCEn6J527@P5R8=!*3h-T2rnYFzs-Kf`^UDzLJvjSftX3~7%aBPAV8%C8wla+AJ03u$8FChfHcIh7p6paT(! zUD+&T^l;^bVE9i4$m+I^4h1vGmKy;X9smA0&GLbI%7e7krN7&A{@61bNKTRm2ZSZn zi3SqDSj0T*Ex3*4-e5mZO=F=4B|{#;(=WkJBk`nUwzFA>?4G2$V-biab`HAFEjikx z0ObUdKdia~c3^HKY8!N8%i_>+rGzqT#m-{D|EHU$uT#g~B9STyg9ki*%^Al>0)mq2o zU(ee{qiLUHaGFVBMaKFB(@)*o>TH|zTXEJ(^72#(pucETY1* zLIe28q7cPmM+qGZ=CpS64ASCGs*EA88)f%PEfAUe?|@SpPib?Q|DEzVa~O{SopqnI zMe6OPxCEm}U2UndS-i~mAG&ywv$s0Xf=QK6D;ms*Pdyw{CquEAy30PLsV7VjXzfxL zM0o%E6s7_=quI9{5FM^*gQ7?MWZ@AcX)m|9(Z=1I{swexX7z^ju?w@b&DxkcVt}~k z%OrkKuRnNfsSEYeCd2e)l8wp2=9)RsaC&btL4k4V?_`(j$ZVVVrJ<5W%3|OKL>2=C zC`IoC_@w^3d%=LaHL0(ApriuvoD+v$o~}Pdq@nr)_WIoLth6DX2kK9n4X^IoEmfHj zZ>96q5c#N--E=hxciDiFY8QXzk)2YxSeUVekgW3v{t$jh2v$5kvFIJCTpx~7#G$;r z))?MhSB#(N=7>WcA1Xp7xAcm`M~ac&dVkJ7Ot_zJ^_`#Uo{2XFt8n04xvwViQ%Sk#}=vrqV`FNWWedj$noN}(RNM*#!p z`B5erI(jb>-F5B0mNZCM9sELZp=QR3E%L(gt*voVBUh=+Z6B3eVq(q@iFHfa`sWzW z#*ymiy3EKjVp$=zT~5p5zV}agd1DiD%FE+GrE2yZUy=AsC|mXUX=zBwrkR(Q*HsbC zI}a78G`crM)`e^^8y7S=gIpd@qz5QknWZBf<*GZ+^IcO@ldQ|dSC+f4_P;BgFUkJD z^D68)C~b2Mp3WVAvL0KuZ7h!~;k(P8JPr!Zf=h`Lv)DI%_q_V$TQ@5zQCC?KM*mobSd z#{7mN)={(U`0jyjTu$v4dJy0Gu)0THAUQ(gXCY|N^rbCe{TxF5j)`LuI$blX?Hf78 zv*ha1p7zVUGp4VCB#qKu+S=Nh;AIk*`c@~rKb;g{_?Tnkrv#vtNfvvN&bG6-ppl~Y z%x|w11qtj^q?sW8&~yWkikf3o-7x~*Pp{{@{lGSH_}5Ur<8c|M_e~$l=igo2iv3ONaq=B zAVwN&82&)S=WK`nP}B%D*`MJ(^69A)jKX(?@`9$*p!VMpe?4Mf)Ee%0<}#u&A1>Z1 zwU4hb!?+MtEP5xtJ>GQLxStTCiBj-6FMGq_!OiKNCvRsoR11+t`c`VwQ^z}T#JwJM zBNQel*}1?_iH6)Jt5Ihy*}VugwXR%U=Y51np^=%f=F=B4k?s6r&B{ z|8;wkZL`P&{0dQM+xD7cDtg&@fBQ@@Doef&wM*??rXZ;Sp@Y$wwnu6hR{xg~$> z#-8w~(qZ-6RAEBz;mbEW7M^e=*;u%5b{3hDB!273D`?%L%Q#G}0 zkniQhm7HnrbKOxC;Cnk`9Q}rp)oM)dp&Lrt+s!4n6a!NI{Z~cbHDiY;qRfE`c{;22 zX>oCJ%-^Bl+8=p2w|Z`pktMdVQuhYsjj$j@Lqb9rmTg(0c#kqxaFZBJfQhEOyu9n# ztX}s|%xVxNRW7d01lv9Dtg^5{vi^;3?^pEtT1g$;-M)moPp>LXcQI`R7jKp>t%HAa z5M=Jj$7-~>5Fn5n~X8bcz(Vl4o)t}3Dfo(Hc71qvH zolvpn=4MbP8MlNp+^0J^IVqaj2A2cg;=O}|7PVA9nm+!Ar7Z6!OYiAu8#k4FEq-Oq z)NOdn+?q*&jGIV=hfwZ_AJ(c!eiW63WLm$`FeOdnhVOjsPJ~d!nBjwd;AQe!1yTo@ z#mbnRs`hX;3hOx&ynQx^KaT>W8bdWIgd$YakWEb|L6kC}Y9po;Nf?vZfET52KPXTd zA04yAmwnR6q--5(!w25CO}!&X`-3~XYvAseX=`kGU{p8Odw#c*O76CZXQ}1#bP*{BGDWwU? zmOkMP_4t#a-nM40ynAR zIe>&5QrH%C9x4m9@8y(Y>PUT_bhDftY!V&z@!4K9m?_(YY}Imlx3O0P{8@v$v?_$( zBZNn2%B>haJ0|fpRO8`tqrG*x3iOk;`=>d`+doXeB2Ti2mCuX3Y*{&9;nOMZ*g^pc z&@6hNv*YRmH@CXoBBZ~)I-l2J$=&Oq^p+Wr9yu?GhHWq>F-mV>iYNP17Y%mrN`+ANke9TS=eB^w_cZC>Je;^veRQI0B}YWo{)D_yVF+O_Kb5^9{0>F zN6t1NS0)~S7f8r>dB>XLi3JwE9fdB$JCY2Kvt#4F}=Gg*#ju7q}oWVuMH92DLkprVK0+I(dejJ^MNNZu23v^2181 z%qGJ@RK9H7M4hYg#g3JC#`A`@S;r-DFkL*M{836`g6w2`CP|o7MoB?Q8|zG*mNtv^ z{(e)_<7(gI3eL&qXV0D~SL#1_G^WfKLDTWL(9YdmaN8qjjQXDWEy*FTkLGi)5@g4o z{ZNr1kQQ1cGQy;!r0iGIRL0`pL**uw^mS@<7w;D+yfyDgUP}0cm-v5FA^^vJlg{u) zLg>fZO|cG?R9lMUmq6>WVj#^9Onot+-?#B#?n&(CUD3D;V`W$sL*+*K-1yd%i{mAZ zuLnZMtBEP$>6D@z7Z(>7#W>%(=iSw$IXNK)@cb|>mzkN_(OP&<0`*C);DFhNyY$ET z>6McofBrC8+t`BD%*jfLPASGMVNEgWdhvLspC;O-{xyI2UyKVcxEe(s_x<=w#0}z1 z&{Piy4JuJ8V5Y!Z8kDJ#=~nhDVm!RwR(ewQqsf@WFPV=Te+baO(&JW6d_UB*r9maJ zrpUjM`D12g1^~P_yJdCk)*my|6c=Nj3(fp0KtmIM!7pFALiwEQxk=rWd+nq>4Az+$ z_HfpDgQSJ2a(^BZz!1gwoTgLhyMpn`?;!OQjXy_sge@}n@;=-z@0u{(BQGklu~rjG zGVln=T|A&Z;SRH)6>(# zp2uExc>4nxZP9Qfx16Dq8o#JJS;r(qN_5taqxQ!K{RM_OrMD5$NJ&q6QW3+jxH;dB zv&%kVoX^-Fd!OpYUDz6|L;R$Ktf7H}sPl23BxLXO6xes+>842PL6^OuIzk_?^jN}q z&*RnY)f3*nxp~p0c_c{B7~LaQdpL?I&ulF0ol;2>q4slK#D_1mUM^ix(^U&RO#qW# z)UgEBj~^T8b-3mr1{bb8Nb%;cxM+Qqyp1wDK7 z*{L=}?>GT-N%#M7_8w48cHOpc5ETIh5do=DP!K_?QUsD$iXc@$dJ~W)y?26&(usid zrXWRWB1j8ODWM}EHS}H+dME+zj^F#8bMAlN@BU+4hhv!W#5`@Uz4lyl&9(MY=28BD zU_k1Am`-w!aM$AM#GXg-+hbo4nFLQ(k_5hSoTO;LItGvi=I%)`eaY1DuY{6~@5_%? zGIx}(G*T=gn|`fqu7WK9b<3(ZIh+{pqBFBMIZXZpW){ut8L+zA*?x$h1;7+)=L5D^ ze$)z}cZozDyG?ex$5BdX&$RmNxRQghvN4&Z|55amrw@cVggheu@^c zVF@u7H1p8*?k%qUSVbX)5L><*0mU9f=<+UZ2d9HgCpkOCU3d1?pd?fJR>32_j&*G% zbdx#-m`a+!3ctA*kU_@@Wud!!bUXw+Pb9Pu{B2?9rrP9=`kY$w3x|5S4e*W3p#Zus z7y+D@y#jOrFzh`_(7H>@jVz0O!Iv|QK>My<)jK0TKfVydlL9p4V^F{%LucS)^&{-C;(IA(^~doO&0!v-D68gFrFq}<4Q zFVMX7n~{8VbI&caFt-dVCQs4S1mW?xSE(c49inoQiZ7>rNx47GfxR`d)HxnKO;eOw zDdg;q|411;Tw*T2BscWwpyK4LQR&wH@Njl$-7SVa^OEv--n4@QZ@_Xc;h+~XE_69W zslK6d#gAX&t8vQ9Zo4bDzz*v97W9_XNu$LsQk%R#yt36$McUbExLTGKQqsgdZQ5Rz zb=!M12p3Q1%mYkzm!{%kAmYV-rYR>Ur&&GjQPz*v)(f$*u`~=@h(;TJMQUnl(dM7E z=|3pX)0#x2XJjDvweHbdibh69N6StEOk-{W;s2KPh(#_8(_LR6A}A@;soOsH`Q=Lz z%c8W<$%i*`VOvW#3XLvOQwuv==u4o6k6;~39QkPnZ~Jz7BN$2hj=~n=pkbmhHU4tg z0QUFsACNVl__(ip7J4TsDVds;kxs7CqOg6JkG|?~IY{jJz~Z;c%GO`ME(;3_16o)b zHW%8swr2N&C5H38++Av_g(ceJ}aPoK@`JJ#c6fFM1dJzE{3{WfcQZUS##pdfPZ!6Gi!XGcGOf4 z`MTj=+JUJu$DNrP)>L!97##0HAu*G>Qj+O>2`L^=r|K9bvr%~<5%&4p0j4B1PH){Q z<*V?Yh3)jNYZD{z8*x9=}bm7)4A9ew|^8>CULIh#h za(ZxxsUj&&pzeeky3sD_0k9TX>Q4vWD0l5gi2h*M#fH&cd9L5%x9~bl@EY8Pg^XqJ z=LDnumM0S^Pk)BM7J@y5cg#*(eA2biF1GMV+z)X2UtyRj^rS)DgMh9ap~DYc*+!Rh zkzZL&s>x)sr5AzTB0|oR#V^akT>T!^!qZ;ePv{@}I;v1#{2Iv={B*AtXzCj;r8nQ! zLbC@Du0PMW<^|+z)_a(~9qoeQzOW-Nm4TJVU%tJ}-DJ;ZZ7hd=9u5{lB!vaAT-0gf z2ZWN}z`X86;wzec!=85xOqkT}*(1(1wDfoS&*YvEdLUje>PtJavyiz^40VG$P8emp zUbp!O((Q|uknFcjcYWGgu9KY(Pc_rl{OI6wVjU)vDkzl^oJt-AtvErA0I)R)Bi~O} zWP<-2lcs#8pb0PfNt^$E*6J0#aN%3sQ8@0z!PNIAOJj-i( zvl72Q8NtyTa%Dln-0bTrJAJg*c{^6f7D6%-X>Q?y;^ry{%2KZJ78dp5R3KeZ%4|*M1#- z{{AeOJfE|b6>YMkMn?3&moA0p>nrPrgW^8XO?4>yeI9sW*RvmR{(Sd(h{x|`P%-#O z)8lM%a6_+rPcNeen`qMqbju(9Yi8!i4)xoeZzdm1Wv& zy?^w8qrn~uG+F|bH*0SU+3F2m6fnbh>=~>ETIkg_Sci3qxu__V*!zxtD_FjWi3Qv- zDQ$zFTW~@H_LjYGV-1KE*>ePjE+2_}lo&BT+84{p%IexSF}I`@W%3jTgjlu4gNCIg z>y_tGQx_+QDO@r#P5Y>b2tby#0Le$KLE1ngsiqefCnqR7tKurU=`Hho!5M)-WSS74 z5|NZUa}f?X%2(%NhID18Pz`cB#)x-u*H6HXuxS>tn!wHEZ{E%Y3#IZQcd-RgC;npNSS zKrfpI1f)lYmtsa*o=GV6%Ci9KptIXJAxlb3^_-oms*1C7`^^+7O3FG%@uSYQfS>TB z5uKY;5NFdas0lfn>=W>z;)sq zx+39AP{{e_8Ch6WI7WI%oQ?-{NH0`?|7`62xXLNLVc z0scOu=FZowUo_ocP`$eMBJZm(+HsBev6cN~7^BslAMofN>BjfYjymb|L={-i6_&k_ zS4C<0hC6VrHX`LfCM>t};o`8-Magebp2{q*s2&N=hXaQv&A?pOL?}@}%G@q=BMM9k zirsjHW-hmD2+_k&m(@rro%_}tTtGIC(n$Mjflj^a)<8lnS)e_+#G7W_5OE6V`*j`w z>Q?4pv=7V(VgViW5D~GAMZ!lLQZ@MIS%@cY^xR+O-D{Pliw2ftabzA7^aATEje4;^yY-q%?#3w{Ka~b zKp83nS{H>L==d%HqypZxEoCo6G%NbU5L3Ywq#Kb40$K4}d2FSWhNBpLu!Mx1$v*Yz z1ps}$EN(M=91}d2U1Fd8T+kE2owaGc8wCw;A*&$&X6S(UNURw|mi+2{?mgCI&tIp`D;iJHUHo^OyQS8F; z79&3ps)riNTTAqCOjxN>`xEUtC3MSD2`|7vS4`ql6BD0VTZcq4i(1yDj!sTyR7)dR zbW~J1i+-+uTdMgb?u3PCBi~pYoNm=D>Afw`ngkK(NSQMS_ye%y&4r}I#1F;A$hx{Z z=~(qZLsZ_`$KkWUVQZ!Wb(yBgz2bovYr`cRr4y>w@@cB+y2<0Ns^->9Kbu76TS|(H z`FBzIL#tJ0!x&7*{@#w(!Q$egxaYG#SF-apRrvb_d!?Bmt$Nj_kc*o9l0d>~V{ znZ)7)4mav^O3iKdj%V8d7+jlXBqlp)Gf*Zh>UhQCkju0cqsCyHkP=^*;c$;BRYIU4 zuzyn489m^>I%uK#h>?|5Wqk8y)WpO@XPP3oRYoz-z?ZK5M@>qo8nyS9|0rRxhQ_lR zy2ysah@n2r>0POzvlOJgH#1RWQfBXKWGoYJF(625;<8?#5h&Ox`%Wy!4x?&(BKcNz zum4*?z%$OaI(y8fBUwVzw*u2=k0)Hf19f(dKPp_f_qnxfWNxJCgaQj(SKQ$}7%YAN z=gP*0K&*}mr`qawPzgu^kT9*#QyByT4g!e1Hv{^GEp`4!$q615C>zyi$M5^MXEAA7 z+nPC|YAQLnzcg;``lMB17V-*}-Z?7s5?|!wkz1ywrZ-&sVoTQja>_z~Z-12B%r{n1 zF-lvpr2}hjQCiZ+9)B8%;7KsL_DREZi(e-&26-KzcfYQU4N%)5xyNZ0gT?F z!fdWK^x}IvIzYgDwNrV{gXd#$NceJVv(gCHg9q)`;A68RN$<<=!@8GlWlhgG&xOd@ zbXg8$_!bnZLiPMD2amP*43f?(&b5tj#!$)RD79p^!(4Gc*&s0CLn;VJXJkC75Qohv zAgsRDiJrh9^*$%7T~&>Z`B)JnKQHGMvlE7hH}w?iRLMf}gHP@C?YXy5u{w1&Dx-hp zgqeX%U==YF_~aHq)@;E~?CDlHYFsVPN9#%+e;WBQ<7-lLKClXL{OR#2pndgI>{*6T zbb*vy6J!mCD${iR23TR!$A=V=Q1Pt_8-iE+$U~5#Fp?m#CT_F7Ry9%(bkfjWrC_vf zN2}dhHa>?S?9*6f*_oK$ABbCUBtvI5>~F3pOJ!;cDLeRGj6AGaRV~eC4LROx23^gmMUu~oi zZgbo6(^h@&BEQYb`|WulI-1!Nl=UN;XOW5Hyp9LIxgeFtt{IVS4A5|f^wSi`#ag^0 ziP%mEM<1)n#~vsX{0cS7gJ2EIxElPIetyY2*co?spyrv6hIM)qB?cWF{)r$Q-=Rs6 zKNMI@kb~+#61e8*rJn{7k(%I{r>FGkJs|Z*dJ}g|qm-8i|LGE@ocXWhTA`;f@;^bi z9VY!}S!uaO@laAyRlI)T7|V6d0M5xzFH1O<-bow#7unX!P(Jjb+_ zjg5_%HA~RWsLCTJl`TFqZTFP-#-rbTGH zYs-)SqL#Wm3{y|0`=|6~roXjxSYA*=Q|On;3H`I@?Jyn*_f=C8)tBrg0Eze#_N@Ao zBVTyK6BMU6$i^zY6z0xmUB4*6&)ePA^<6UQ6G*^TRaM2CC>Q>5$XWAkx1St`SMXt} z=&_WuHYGgYqkFQyaxz z8^cv-n$+;MYb;Hd)9(s^i5SJ2*55r!#N8Ep{ls6m)zeuxIei6}0zTqDJJnPBD%Q(9 zWZ*IGb}&IWU*4HeO!>LCK$GexkP=f5y?t-wXNlBvJ#Dz9v{EnQS=z*LgVE{;7a|)x zTrLIB`J-p4uVUZzCDy!%nT|f|8eKR;Sf7lkfV*+Uc6N6Q0R+0^R&pQ{(I1MKk7vr^SA9`CW z9zFp%9Hh+k&-L{gZ{C~(AeKVqJ!q@s5;Gmnr&s`63vYX3$Dm>Ox*8X1Ug; z1Mf8b<0GZ+5~i`WwYjr9$G!J}n4xj$TU#=hS6jFkbIDNXL3{a00AEpF?a-?GBYs8| zEZ6ng;;$)1oH>N8ve5FC8`Z)xiuH`_SHeM{Ku=Fkyy35DMs$4?7(HldlC3(Z z2TR1}=H|}hLhqxnhS1(#^~0kh9uyhaRD!5A$JWJo5;ich7t7O%RTd-U4t&F|u8NP6 zmdQiA<|!kf=Z?b04i!qZDphp5tn#DeUOp6I3g1l;IkPc%x-SVCGV;F<0evi>BwjAg zCV7N@_$2Q5xDZJo1zTS)GeL|GgCEIorTMEi!E?1GvQ(N3^Kgzg=^fHvPYbDQ2C4Zj zdt8@yMTNZIwR_Yp-#0EYEgE^%|0*$X|1b|y9yjbtn{{tCljtLX4)W}(N?7yXdJr!t zL=C>@nrrA6L1j?UeRNc#)cN2hKlCuo$wEc7Y}o4j7BA*lEBS6Dw5~8_7Hw)f=#{JL z)10)h-KmotRPQ4J`6C|=_Qak4An3^q@pY&g@q1uD(l4)8x$v3FN@v0@(=DffAk!|rE4+5m3VvY7(kwt>_=Fy(YY z&3YAWW)amb?~-%-HaTjI%0@YrlXpy`B%VUW&7G~gB8L9unrAOUM0P+4#!gOG`trAW z8~2}}|2-nE>53%ceQj4!gc!On~iPjsK|6V&&T?mf@n+3!v3SyY1`P(teP84I4Fj{Zxp zIZgJ3%y&y1vh>Clhxifvmn+eGW;CnPvBEs-2Qst48Fd;h)WuIH#1fT1y1p^L;eXan zfk=vSco`pl*b<@ncFSK@h07oT=7M<-J5&CNTJr_tZgiv64cT*mFIDF*x9`D}kCR2H z2QY*SKFhMlaP*R2?RM@ucw7S}AZ?>|OOExognL?w>zjiP~IODAZQ+3-$2u5W$Ckn8K~Zcxr6} z>@j0@;*hJIFDNeFHa2Fcg!%;S*dJvR+P!1Hrw^hWCXZ4>*(k|#(RLWV3PX=(us(>Fka#Go^;_SoMD;2d zJ_cnS-uz{Icsy7A?Ull_SB-0nDs^tE72mBiG|Vb#Xo*ZQ>xo1ngN=XRHS+N(fS5MlAH$^carm1fl!j4Uj~RcCtI6nAS|s5CV<&Et1o zCaWBGFDJ;UNeA%q^2%~vpFb+^C{j(d1Vt=ZEadT|Uac|S*wVqLx8`f(0cC_lfWL>& z1CNBjDLk{CTBuf^v`KV@%BOj5yL*VDF`vq&CR96J*^vh@UKAUZcEU|bS9GsMzYNwcy<~)iX=vvPL8rp4s_e|Ml z{M8@Qw6vD)zn0&_He-6#d4&#}2wLS6oXXQXl5~@rbNAAaS^@!cIi$F%@T*}9qxB$U zKlPsXfYhBH^voA+wl2b;fx;)h*2+BFM~+olqbF_0+Se4MH$2nQt+>fAAMQ}OuXd1FSV)z=eEBZPFc4hXmElQX7+w2r` zXv>WJ5Xg>qo!Yg`WlVZznExDbuPNq#a4JgTb-a{4@%j7ekf@RVubz1}cso5PYPzXY zawoxzu;2D-V(I~5?=D1g;~3|yhxf+QPN$voQ-5>Z*(VRE=yyX{=R*qA^9=I4 zJ9NE@F*8%l`I7Vx{l!YW*0T|p8pN@D<%}#|V{6IV+0=}v@-g%!Jezv^1_-d#Wk7H(Un;oFv0;VUApwYzLHJJ4?RJEL16fmhOVYEx zfmmgVm~t&SuDhjUcLNq$j8w*64Kqli(#q20^u5J@`!k9}w|3!NrVnk51&Vg|V6skH zhfgHF%)HDyJ6`hubtL39^PJWit&;#GF80ip9@i&DKaj?u@)<7Pfx`^spipH{Cg$%xvw%%pLx=rP)JlfH&y2{rn? zZ+%#qzlOE2b5Q*#0MQF$@Kf{0?oH@l_`B%vsdMJ)VpK1ctITQ4c^}Yl*GNzlqCs}- zmx%v8u<8!VYq0!0(aJ}Dh$~;t>OAVrSAZtDmB5nA>P=-nU~hsGfh8f5Vkg@8;S~RJ zW6zh(#+$`w{0p`=8^_0|@h4auN#!CQl*HYCspSbBb~k7(U;n+ESeoB7bTV4-;BXyL z#T1xu{8De=_)}?*VDs33Pul7Z=U?ZIoMoowmz`;)hoZ||D(H?m#~OdF$QGSC9Bbbm z-v(mEG8NewK=;4K-hbqQ?}`BRO412Wg@}~Up}G(;>tF-K9w5QWAG_Mk>;Rdh*^F>t%+uqFXtSfsEC6e1d<+spp0{u^JEbM$*n;i<1v2c-*S1ik*5SO1_v8 zoK8au_SXZ3%F_rcUgLSFc26L8ZMu;-|7`FTd9;Z0lJFqJ>4!;*GYYp`Pu1`pdUzdz zD$akL{9mj*$w}9aG)Y&sov9rq;9mA);@?5pMMS! zN%cq;_c$z<87c^M=j=6#gudKny$r-If4P_Fn&NfPj)M41$75uVuMMhh%K`$!V>=*X zQxTZnx|zBZ$1_tCjwwBh^}ojj=er;*i))FQi%1rK%cwG$IHDef~D z$-aY|{QKjh#*)Hj-9K7eXKEg;~83y><4ZmYV0-M*K@@>f*E zMKfHeme}BLde+u>Nl8gBQc->TJ{0ubxLEk=u-*rX1y4@I-P&3kliVe3dIpB1417I4 zr|q_M2wi9y|Nki+B~GhMgRg6e11dqfHfK3~ngpL=_UwLEW$vzV1mL6J+GChq-{UCY z5)pfzW}(8K$K>43V66tK2l&%_Bi24!)$XghhK6?EKy0a}tE=E%uc2Y4{z$3xE;J%FA8PeV(GwGy2B<%;*Q?uNZP~%DeE-Jn*YL$=*4! zvykjj+44OdHQv6`yR|T|cLB3#%Ooez$O(&!C)vv$ZuIU?m!8>CC(r*2I(f`rx`Nd? z!5%}_Y}d%s@O)A;lhHj=Y=IM^$#Dm2lD^E4V3q(`P1eT=3x$I#MQ5-@*M65>u??81 z`*Ls0?<8}&=#3>;jM=pK#4Mlxdt)69mJijspma>YktoQ7+(ol91)IP&DIo!Fjqb)1 z2R(iifoN>4XkCl~>-TC#ev@Mz9OPMttx1A@(PbvM-@Slq)z1lDc3?*|wo(6t148u3 z<80@SE-*n>LAl)beQQm<)4mzsRPCeAsn6Zl;6g>h&98hHYKTNe`Si5YV2r)lqE6l1 z@$nnaI@&-kJWkjf^B~}Tc(Y3cw4;~vr+wL=U5X4$8c}tvKK=ge%>( zJVCw(nzpS>LD!Ti(}F}JK>LZw+677oVT!4AyQd$yj+~1?4w5e>PBI*x?(jo~ry}@E ztO)|v1mak5_+R@(4P9;o?1TbQ?S$MheFyXVM4i#T`-84wzOedMkU}n(MEGT%SC87O z6w4F9zI}=NkJ;WKhNAzJ!4(=p4X5kq08?kil@;hAuh#|$)}Sado(XsP3%yASNB_hN zfMeC?K(b!@k`3w=#J}7gUB8*p$_XyI3C# z==18QTu(<-@3l5_D66P=KTeXEo+Fl^o$YxF4Ofg8Zf!MrJ|C=AM9m{yGP|Q*8N=6y zZdD*zSAx#-aDS#Qm1)n>jm1)N_XW2g2fiRHYnb3aKmQPR7~R!Lft@l#4=!KUwUOEq zR{6bkL%!(T6sUVS58;QM`tjq0(__Ced9>;dGoRkpNGW}qKYw?C!efVNd@_zDMJg)t zwJMA!rpIL~d!_MlXV|&uSTUkjliKLM8<98^S{wE9qmf7cQqu6=qyk(Umd59`X#ZcME&7;kis6#H<3 zBK4lPDwYx1tEuC>{C<;UkUYn6CXZWPT|4 zIxXRFNEOF>Oc9Zhapf56d)KaAQ%H@_$R8+kIibh`B?C^_zn0#(fn0K5AA__Ti35Uv zo$?>kv_VUpWiny9_jTj%UsTR{o^AwL6nOymrsb%w8#R#3nwHmrpTPEQZl*b;5O0LKX@$RVv-A zK#w?Jdg_+VK@PvrUaITpfng*2pFNn!Ljj3Tb`esG*mvyyb5cX8Y9N-bVBU>(xX&Y1 zM|jbP?gtsaZIcsr$fOhJZLIB@U{#v#j_!0H_Rg60lxNyv?an+Tb!%nl%oF(WMaT&X zby#HE7=`B(r}~jf#!;0iqWqc7>e5vS?)v&vuYx!+wXi03!>oBPY=)y0{j#%wg?^-* z56g7~Z@|GEKg4?MkQL%^x{^Rrc^aR>lG3I_yPLUC@Z~7E!USlvtm>`=643)UE10v- z^Yxb7MD7I?)NMA-V*x?!H9VqavH1hEZ*9<%JNk&jo|$TsE2Y)ZfYX$(?WJ@_&$oz9 zp!{a#UHzR!d{Tu9BcR1~Yf=z9)Dk-yx3@gYuH8J%S?e7(c!`*MUHMKS;HQ)NFN~QU=oY_{qiUm`X6g?*;sOfOUZ6A`{46 z;l%*o$Py*6#((BbER0Y?*EB-`O!%_BJlJ7Z>$N>b^RLmHQ320@oDArzBK70xB)l6z z!f25I>uicHd(5^i$3pkU_yd48 zG`O;W+#x55l@^#(7uIw$SLj~?QDjmj zxG1Z%MVfAZ!AR>*g|1SY<10Ywe(};Jt$D>efPw+^^6$q2g_lKb>lAo@2J5L+o!I|d z3s9Oi+kSJ{@O)TBXre}yxoKanr?Rm7F0uUsxW5+f65g^*&v@hif~H*y*5y|$3thI+Il{26dz$cSSHrf}-^E~Kb{?LyXD@oXh&Ib!&AQMR ztftLdhmSiwGnJ34zY-{)#;WPE+;|{1*UCXMT(fQn5lJ`Io-C}NyT~>9kju9+6|bpo zn3vo)24~Oj=DeHb_DjlwIjHYfJt1#2yu-yk^h6j5!j@%?2taZ&?$rd!~qO z1dVVnPop}c*r;)J{T-XXd%7HqC@Yd-v%S99^Uq8g52^(6i$nI3)S<5zlMlOsq*aa` z_GOb{-M)(`lBIfUF*{%Koy{!A@e2)$r=x3q--=5v*G1Gghe*VU(gW>d6}pdQR$d!r zU8V9@2Pjh^EyxErUXMA749K`tNj`Y2IYU@V+t$3kO^j^L{kk8F7OO7%7kRro61A5LemY zG3kx3a+KiV7EL7jQDAN1;GwT~!*ASv*)`6lR>;+j-qj!f2ueIwN?coP3Sw%LjVRCo%A45nAf z0?rG-_{Nlo8Q-KS$47voxoq``rK;e0r;A5056`BM<_jBf`hl*CJ!S9B=>kE>1fuKH z2e*l9u*GOLvMla=SV_TQ2?${RU#jK89XMB+n z#BY@rN;-99vTvv3P15JJl{Z$>0J5DZ1TcGRea$+!x^U~n&4o?^Tk={ zS`mpG^w>VGiJ3BSjO&XGqTffG2cG86U(vfAR2DA9JzE3{6Zt=!`pxF) zWiG_@@$uAp1?g9(Z55Dy>|P6UnJPi2emfWqVh%O|)di3#x_Z1NKW>wM!pzR?D{Sk- zCdWivnKFp&kbF@1);o)3E>u_1o%;PZ%Lr_`FpoEM|DcD&YidsdGVF;PU+5p9yZQST zsLxV8d?=bXk4A3u34>M9cJ#)rv^%?-WwiMzuwzGv-@M}_fX0A0=xrwH-<}w@QeW$=FnetoY|9ZTA?GHXKH#q>T0M zM>mGGAfKF%gcj)guN@Zi6O|b!T>L#U+pd2_FH$!OXLw3NxKfYrKvueo642=`FDhNE zG28O6EvfK0W;g{5SoROR2v!Izol^&6q0O{#-?M>aV^$R@b>t1{#r^}8dS6vo^nK&; z`0yTt6a@3=70|d zQp=mmNq`?OxdXIiXRb9Ux97zG5Oee;nW(v=$N&i%OUo~l<7R$-sZ~|t>k;h#9Lo{| zg{2Ebi{2#yql;&bZ>jK}q3xcFE(hn~BlRGd_LpJoC`09D?Du)jwP1+A$HymmWMpKn zS`#!dGZgY62idYv_fMJv^v=0FVRAE1SI#^ij8-3YzCK-Py*Ia&#v0z;8{GC=pZ7tg zN>G?v7EB}Is{%heFl4qbEG)y}N_R|J{eY8c`oGtAUD8YMnqGYnO zHFn5dN^x|8>KY~WFvKYRD4g9-s67*?QtWjLf=)eT=kF;+!eJ$4A8o`(pA;=wjP|ZM zCykwTJeTWKoiJ`>-&Qg(TShKQ^&_LfuQ>CEbGz7bdgK^9P2hK2gxlgrg=(HF|Rv zXr(9v?HMBHw)%U1)rm~E%)q(INq?ku6JlU@qq5KKsJjtbebs0RvX*qKyY=2Jj-XK} z*%V3xJV>TLk=PUC$4&S6orlOf!g}Z2%}SFkQb4EvjwSJG zagCygu0m8$Ga-tnM(ZEpXE~a`v|#vRGyO_JP>NXQ(t3N{I~}*1n!D;Z--^T zi-*=`+!vr=Z*i{LEnfbfkG6w1zc^a+)Wo4G?*7bK~&CTpnsw;`c zUyL4AH>*txOG z9(yWZ{trDjz(gq!A>yn|Oen5NQCYIPGoj+IF#C$0?*&U2C&qGIhvGzKqN~G+Wfo72 zcwOT1Z_}$dx2or*jLJqIc9e%!7NlJZpZ_g?k4o;C+px&!P}kJoGWswZnOO6uo(b?) z-r3Z#YKM8UP+x}571Si5iKuyick$g(!+L5@y2o37zrvO~_N)2$`5dRzDKRTo#XmvO zP%4_lDjFqq@DxI2Z*rvOE|uyoxaxkeTed2RaQ=O@4R3hZ z?~5gwvg+=(hr6ebvpLbHAGNVgQj43CtzBhR%9vlf>``42KF-D z_tifXv>?YAKOtw_!5slu4vbX|80*ZIB9t?OD3_iuRDd?n#akGqXT7)~OS$vhisnCX zFMs>rp8&iAA||bM>#_D+s}yT#kY=V_u5#zv=2HfZOI+Q}U5igYa<_|{N87eL50ofK zn7H#MFTP5MlA9I_vgPrpdu4OV$S9Ey5?jm9{LkVts`a7T%3&ZO4DL<_+*^z==m#fX zu`&ykiKKxNMJTF3sYwDSi(yPk9!|E2F@twUyYzKf{v6Y*E5IpsIITAga zB%d^3lu`R*Ezf1{)QbutFL@+x3@ReL-;BAaVNB&?wSDn?H?2h+^(1D(>0rcmd7!W< z7A}hRoLsjUC#JaIm}7HDfJ?Am)oB6}N9`^D-2LD+wp~j~dtb;J=4M{v@LEp=FIVg< z1z}c`UdslE zvwa5F;EKp>^7&WapHJwBEf;$O@?C5(6MoU+J&e$qZv^B)$-;`zfQ7gmBqU3=&HZ}ZU*HW5ju=j!PRGBHVQO0wEt?(sT{V6FVpbl>e*@N#~hu|lDT*b_Hz6hZk z=X6kkX|^Kh{N4bk-wR)e84{wF$h_K^k49 zA;K>6nayHr;^a#j=HGjS|suk;A3 zE-c>9D@N`wG|(bRf6WdLAIX$BkE17Vpj z%;E8Gx`xCnfz`H*xNz`=?@Zt1FN9G^nrfp@w~mU>PQ@b;o!lA@1gC^srPPPUcwKF= z;?lkVY{_q|b9*oc4Mj=Hz++c*-;#f`EuSv~(eX(0eL^m*fs|Azh`y|-*%Y9vC2=2- zz8>pmr-DTdsT;5qy(`=D>6^2yi%CXWQIgooclAAn2wsS7+PGHDCdaHe zuUDVSawyEz`+m~Sk;giP5z=7e#BuT}!sv(cE%WGmQEcT7X*!JyrQPSJeuGxOd5(e- zJuKd3sM&}eny#!(AeU&N7S#i@*z6m)jc-H`^E?`s`kcrCw6XhF8otbC)d;c{1;iO~ z9sAE_a#fmE zD@|}`?A_5Q%au7@H?x%6%ksvfbm4{xy^;2rLC`A9SvMWtPsl!)0#w`%ZLyT2s{qaR ze+P3Jj_UZOQlk6uPsfAWdVHrpSzvI0SFrd=%Mgjzi^+{4T#CP@%rg-#K766~h znnWwuV;1kjI*WGcwZe*=uC`5OOXPD`@km)PMs>vr&<&|d zb>@A1HhtE-%{fF^{~ib}FU)Z>hR4rdzO7lV@<}H_lzx8Za<`^RN}$IIM`0RGcfU)@ z?I&VCbUj#JJ<1;p9`O4@xf^X9w-db{vD0fO>|%Tv(#7Y0lP%}>bz&y&J_t+w%3*uB zamt296etG!2t94}n=tjz5Z@R!hYzf08Xu|~A~bn$m;m(}jJuR96B z37%l0y4WyOX?x#LT5<_PD&#Zd-C?+37Vn!NSM%HhHnLQZ?mH*AN|ILyf1q#Bl(*Bn ze%LBID<3Nel9m6;(tBArB%fS`3`MDdjjCqqoZc2V-+Pz4Lo69>(Nkbj63wu0>6k_w z=t`%l%l!QtKvg?GK6C={RgNy$sI#{_8N^TtUX%}RN$RnAhK&q>&579>be`9pwhZ#-sFD$b~(2xNxsQ>(tUb^`6)YM4yjc-L(ddz?wsW4otwUP*ice#Gw` zELrVc+{4-6ooGX!@2lpg6B%CIM{EJt0&}4VmcZb&G(jWHaB7$}3|Bw&Ni-7rHaC^^ z9xfw8Y3Jzc=mSWUs|SB*wT(QV-7F(NWddSB7$UY1L`x!eO-u(l{2s>6^-2NC$apV6 z0oq3FL7TxtLWh? z56M$7ykD$TJ$FB^_@I2TPbGRvTRT%V-M=i1`B<^*;ePAY+&BmM?>~VdqMslY4!zVR z0oz`vqscC7$(k+k`!lGF+AR1yYCN@mZboTnpNRo0gXoz69)k z=f^XwPyQs|a;^#VV@aLD%NLsR&&}>T%*ntwu{SxO!CZT-XhzCHtN-7luFMBs`V;TY zPtsdYWYXbx|zx#B^vPeAaR9@L(yG8@eggj*e-Z z%aY)L-h!s-9f%QJPM;lw6bpXO@hgi3k1%ImV=VC)20pc{evd7RLqZ9-)2CVkL#HbP zMN^}SFoO%OqjZiA$aJ4WAFTtfaiOw8K;x|M1#?A3wU|aj&P~yZKx7|U83Jk z(JiRw+^hrl!8>H5#oO#Tb6rK)+^kcQDfhv(_!#N~F+)pm1bi_&xV1U$i__5>V1OT| z0AuMAoqQl^?b$bOppw4MX*{g5HtC34HT~QuC(`p4+2i48#E4+{rSPzzrZY3oklX~gkv>gueFdv=A3-jidZp}SS z-!S0!S~1=S|NPT5t+`nnZy5?nF))SxhY4Muxy0R2h+*@q{BR;M{>7-;qqs!kgi(TN z(%~=|$#)+?HdH9>>5I0)HGlRWPCztqqxkV<(dSlpw(>=Tc z7xcKk-D%x#EfTH^W7|$jL=~?fJLKDf{qAk`wxZ`M{nlW>OSH;!KqLK>qdL&o*M6;N zYBku&?7Abco&5SuTkyulJtrAiomY~E{kNns`KS&!%EZ)FtmMd16EnWQSihSQj`Ixj z>rA~1%_0FtlLZE;F%X>9@d@lL2^gS>4}KR(w{AddA0Avg4{XQh^_Jj8aNV8r#c9-z z3NIIb{L?hDM1+hVM_}xt41Rbb{Be0o66#d2;xsA814Y;M1q-}$4FlJnDelVZL^y$M zrdI4bwU!Phe8a@uZO1)5bh^}_8x*Q{ezQ$GP<}ezZY*gA6FI0y&(+H1x5}R?5O1q@ z%Xxoy>*yV_mTt~mOdmE%vDK^n4moXoV9nDiZ}1TIHfuhs@H*7~jeIBC0I`Jz?*fU~ zCj9sf6BW?Yt?5Wl7 zacbk}eP4JLgHGl5Sl^OY{)tQ}MspN+K`Cd_o~9FahKWW(Q{$Q(4)YEYPq@oi;r143}^xU#C6rxzvc`u8J>TR^$-`^TrxrPVL*%c=TE? zLo_%Mu)J3EPWGP*9%_I~Yzg{rZ4Tfb|6JXD!oJelG80%6>E zEc@`O-+z61^I(6kzFt#H3voP>kpE>R4Y5D!)av1v@mj5JPZYR{nb?d79CrUafLM|T zx<2;xaK5S-zqO1T(DjQ4)>gn3L=dkQ58lT9KOaCJ!}t2XbSZ_ak#>W1@qaT3fH5j< zFh+5^c?S;+LdR7mj_=ov2cw|DDQ!&aq3P>dOurWmy~kb{`)mq1aB&e%i$jMbgzQAWF{b1!8;+Y52Y#4qRs7$!~eCn z!2Gk*zvj^q-4n+zw$xl%`~2|x{+*$~64%Y{R!_~ANMQE=h=;x@efId}RaKeqybe4? zYgwJ>xB14)5R-H#eee67=fswovjgv@;)~vNeD2MYtG_Paovo8Gu{7SJ2#wmw}f z`%&=h@yYQ&jsm^iIsfNPAoXi?eIziQ{GU19{rU}HY6BT?)!iIeKKk4_1Z*6fIDXHk zJi^WjSWc9+)bKn8W{Jhw;lKn^vQAh2EyquZW580`?fN=kZS*3h`smLW>se!F1N&k~ zK;UN1_S=`;8P{Ab3s0S^v+-TsvE1)`J2rf%`kuVmwETTuVjyd!iOt2Tc{wuq{r0x2 z1pM#)e0R7c*=lQre%iaYkM?$aPyB!9>zkvGYG2H${ugKS$nMOY`&WSlhxAN~^qP0S z=5;2%D*L?gf4%9`HQydfyrdcd6<&VrcWOq z{(f)$s#W~=>VYJ%dPsR>11j%#%D=5y^K0geo%TO1WaO3s3xH|BMk|r59pAUCire+a zufY=72|)@4ha;E`DI{qI!B!Dut`Zk&oQb60%Wwv9Ic&@%SiNY&uEc3T4atEnMgULp<}ej94#`D5(L9&kvUpP z44F#e|NVWk+@RFU^J%->;eVev5Ggr95M{(Oq6H\n", "\n", + "

Pamphlet of the Virginia Health Bulletin reporting passing of the Racial Integrity Act of 1924. “Virginia Health Bulletin: The New Virginia Law To Preserve Racial Integrity, March 1924,” Document Bank of Virginia, accessed August 1, 2023, https://edu.lva.virginia.gov/dbva/items/show/226.
\n", "\n", + "
\n", + "
\n", + "While we as a society have evolved our moral compass, remnants of previous ethical shortcomings creep into scientific and technological practices in the digital age. As the rapid utilization of rich datasets drive discoveries in the fields of medicine, physics, engineering, artificial intelligence, and other sciences, few are slowing down to ask the questions that weigh innovation against morality. Most of the time, such ethical considerations are not acknowledged until cumulative damage is done. A well-known example is the report published by ProPublica[^******] in 2016, which described how a recidivism algorithm called COMPAS exhibited racial biases toward offenders, rating Black offenders as more likely to re-offend than White offenders. This algorithm has been used in several states in judicial decision-making processes.\n", "\n", - "In 2015, the Harvard Business Review published an article surveying consumers across several countries on sentiments around data privacy and security[^**********]. Interestingly, the entities people trusted most with their data were healthcare providers and financial institutions, while the least trusted were entertainment companies and social media firms. Arguably, the level of trust may coincide with mechanisms of accountability, such as HIPPA legislations and financial privacy laws like the Gramm–Leach–Bliley Act, which may not apply to entertainment and social media platforms in the same way. While legal obligation is a strong way to enforce accountability, providing open and accessible information on conduct around data security, privacy, and collection and protocols for when someone has questions or ailments about them shows an organization’s intrinsic commitment to transparent practices, which can enhance trust between the organization and customers, users, and other subjects from which data may be collected. \n", + "Surprisingly, the reported analysis showed that of those deemed “high risk” to reoffend by COMPAS, 28.0% of Black offenders and 47.7% of White offenders did in fact reoffend. On the other hand, 44.9% of Black offenders and 23.5% of White offenders actually did not reoffend. How may an algorithm exhibit such suboptimal predictions and biases in its outputs? This would depend on the lens of what is considered \"suboptimal\" or even \"fair.\" According to a report published by Northpointe Incorporated [^*******], the creator of COMPAS, the algorithm does not confer biases with the statistical measures they used to assess accuracy and fairness. Affiliates of the United States Courts have also criticized the Propublica report [^********], stating that the study did not apply appropriate calculations in determining recidivism rates. Since the publishing of the original Propublica report, representatives of the academic, government, and private sectors have been in debate about what the appropriate measures of fairness are and the importance of these measures for crucial decisions such as recidivism[^*********][^**********].\n", "\n", - "\n", + "Following up on this report, Dressel and Farid (2018)[^***********] compared the accuracy of COMPAS’s prediction of recidivism to predictions made by human participants using an online survey. They found that human prediction was slightly more accurate than COMPAS (67% vs 65.2%) but was not significantly different. Using a developed classifier, they determined that age and total number of previous convictions yielded a similar racial bias as was reported in the Propublica report. Out of context, this could be viewed at most as a major flaw of the data inputs and outputs for this algorithm (garbage in, garbage out). A more contextual interpretation of how either of these factors lead to a racial bias in recidivism ratings could be supported by the numerous studies documenting racial bias arrests and confrontations with law enforcement[^************], as well as the track record of controversial police encounters in America. Thus, it is important to understand the greater macrocosm from which this data is derived to garner understanding of what the data may mean. Furthermore, it is imperative to acknowledge the strengths and limitations of statistical models and measures in relevant applications involving human behavior.\n", "\n", - "As laws relevant to companies outside of the healthcare and financial sectors are still developing, accountability for such entities is currently nebulous. The data lifecycle is a pipeline that considers the past, present, and future of data and its application in technologies by said companies. This pipeline involves numerous steps, such as data collection, processessing, analysis, dissemination, and maintenance, which can be lead by numerous teams or organizations of people. Thus, for terminal applications of data, how do we determine accountability when things go wrong? While assignment of accountability is complex and multifaceted, Virginia Dignum, an AI ethicist and researcher, suggests that when thinking about accountability in the data lifecycle, the larger sociotechnical ecosystem must be considered within a *Accountability-Responsibility-Transparency* (ART) framework [^***********]. Those involved throughout various phases of the data lifecycle should be able to explain and justify their decisions around data (*accountability*), acknowledge the role that they play in the data lifecyle (*responsibility*), and describe, inspect and reproduce mechanisms contributing to end products of the life cycle (*transparency*). Utilizing this framework requires a level of open discussion with stakeholders, whether they be clients, users, or society. Such discussions facilitate iterative modification and reworking to improve products and services from an ethical and technological standpoint.\n", "\n", - "\n", + "\n", "\n", - "
The data lifecycle. Adapted from Communications of the ACM, July 2020, Vol. 63 No. 7, Pages 58-66\n", - "10.1145/3360646
\n", + "
Human (no-race condition) versus COMPAS algorithmic predictions. Adapted from Dressel and Farrid, 2018.
\n", "\n", + "
\n", "\n", + "While the use of tools like COMPAS is still an ongoing debate, important questions and considerations have emerged from this discussion. Particularly, how do tools like COMPAS affect decisions made by judges presented with recidivism predictions? Do these tools significantly impact one's right to due process? Does automation bias work in concert with implicit biases that are already prominent in the justice system[^*************]? Should we be using algorithmic predictions about human behavior in these circumstances at all?\n", "\n", - "## The Trade-Off Between Transparency and Accuracy\n", - "\n", - "The development of artificial intelligence algorithms has aided, informed, and/or influenced human decision-making processes in a number of low-stakes and high-stakes scenarios. Because of this, conversation around the transparency of these algorithms has highlighted important perspectives and viewpoints regarding the implications of these technologies. \n", - "\n", - "Some algorithms disclose the use of parameters and models applied (i.e., \"white-box\" algorithms), while others may not readily explain the parameters and models used or may utilize another model that approximates the original model(s) (i.e., \"black-box\" algorithms). Some black-box algorithms also may utilize more sophistocated and complex methods, such as random forests and neural networks, which may not be readily explainable. Depending on the context of use, the methods backing white-box and black-box algorithms can influence the accuracy, and thus impact terminal services, decisions, products, or actions. \n", - "\n", - "Explainable AI (XAI) and ML (XML) explores the intersection of transparency and technical applicability in AI and ML. While transparency can help promote accountability and trust, limitations to prioritizing transparency may present in the use of AI/ML. Some of these include malicous and unintended misuse of developed AI/ML tools [^***********], exposure of trade secrets [^************], domain and technical knowledge requirements for full comprehension, and several others. In high-stakes situations, such as the use of AI/ML in healthcare decisions, some argue that accuracy should be more important than transperancy [^*************], while others suggest the use of *interpretable* models instead of black-box algorithms where possible [^**************]. Sometimes, black-box algorithms can be replaced with more simpler and transparent ones with little compromise of accuracy [^***************], [^****************]. In cases where black-box methods must be used, attempts to provide transparency through justification as opposed to explanation may be the best case scenario [^*****************]. An evalulation of the situation and associated risks and rewards, as well as testing of multiple black-box, white-box, and interpretable options, is important in determining the the best way to balance transparency and accuracy. \n", - "\n", - "\n", - "## Dishonest Statistical Practices\n", - "\n", - "A part of getting accurate insights from data includes using honest and appropriate statistical methods during data analysis. Doing such can enhance reproducibility, allowing for economical allocation of time and resources toward follow up studies. Some common pitfalls in research and analysis include hypothesizing after results are known (HARKing), p-hacking, and cherry-picking. Below is a discussion of each and how they impact research and knowledge generation.\n", - "\n", - "### HARKing\n", - "As the acroynm states, HARKing is developing a hypothesis about data after knowing the results that the data depict and then reporting conclusions as if they were hypothesized *a priori*. HARKing does not fully disclose the process leading to the hypothesis and conclusions from data and thus can be seen as dishonest in nature. HARKing may or may not include performing statistical analysis and determining significant variables in a dataset; plotting and cross-examining variables can also be a part of HARKing. When performing exploratory studies, examining the relationships between multiple variables from a dataset can be a useful process to generate new hypotheses, but these hypotheses should be tested with a new dataset to confirm previous observations.\n", - "\n", - "### P-hacking\n", - "\n", - "P-hacking can involve the use of multiple testing, various kinds of statistical tests, and/or specific subsetting of data in order to generate a significant p-value. Like HARKing, p-hacking does not fully account for the process leading up to a significant result. Analyzing data in various ways with the specific intent to show a significant p-value, rather than analyzing in an objective fashion, can lead to erroneous conclusions, misguided research directions, and retraction of scientific papers, as seen in the research of Dr. Brian Wansink [^******************]. Because hypothesis testing reports the probability of an observed outcome occuring given that the null hypothesis is true, testing multiple hypothesis on the same data will give a false positive at some point. To address this, multiple testing corrections and adjustments should be used [^*******************], [^********************].\n", - "\n", - "### Cherry-picking\n", - "Cherry-picking involves biased selection of data for analysis or reporting conclusions. Cherry-picking can be used to fuel p-hacking or paint an incomplete picture of a research process. Reporting only data that aligns with a hypothesis can be an impediment to those trying to repeat a reported experiment because it can lead researchers down an avoidable rabbit hole. Furthermore, not reporting null data that is not in alignment with a hypothesis can similarly hinder the scientific process. \n", - "\n", - "### Data manipulation\n", - "Data manipulation includes practices of fabrication and falsification that can be fueled by the omission, addition, and/or alteration of raw data. According to the National Science Foundation's policy (45 CFR 689)[^*********************], fabrication means “making up data or results and recording or reporting them”, while falsification means “manipulating research materials, equipment, or processes, or changing or omitting data or results such that the research is not accurately represented in the research record.” \n", - "\n", - "Data manipulation is one of the most blatantly dishonest research and statistical practices an investigator can do. It is greatly frowned upon within the scientific community and can reduce one's credibility as a researcher, as seen with Dr. Francesca Gino[^**********************] and Dr. Dan Ariely.[^***********************] During the research process, it may be tempting to exclude perceived outliers within a dataset, but this should be avoided unless there is sound justification based on the data collection process or statistical backing; otherwise, keeping data points that deviate highly from others within the dataset is the most honest thing to do.\n", - "\n", - "\n", - "All-in-all, when it comes to data, especially when derived from humans, centering honesty as much as possible is the best policy.\n" + "Past ethical faults within the science and technology sectors may not have fully considered the damaging ramifications of certain studies, methods, and drawn conclusions on society. Moreover, it is impossible to anticipate the myriad of ways scientific findings may positively or negatively influence society. However, when it comes to working with human-derived data, or even data that can greatly affect human lives, these damages can be mitigated by staying well informed about the populations from which the data are collected and using ethical and contextual discernment when interpreting, communicating, and utilizing these data. As data scientists, it is our job to have ethics and morality as a basis by which we make these decisions around data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "[^*]: Andrade, Chittaranjan. “HARKing, Cherry-Picking, P-Hacking, Fishing Expeditions, and Data Dredging and Mining as Questionable Research Practices.” The Journal of Clinical Psychiatry, vol. 82, no. 1, Feb. 2021, p. 20f13804, https://doi.org/10.4088/JCP.20f13804.\n", - "\n", - "[^**]: Lin, D., Crabtree, J., Dillo, I. et al. The TRUST Principles for digital repositories. Sci Data 7, 144 (2020). https://doi.org/10.1038/s41597-020-0486-7\n", - "\n", - "[^***]: Atske, Sara. “2. Americans Concerned, Feel Lack of Control over Personal Data Collected by Both Companies and the Government.” Pew Research Center: Internet, Science & Tech, 15 Nov. 2019, https://www.pewresearch.org/internet/2019/11/15/americans-concerned-feel-lack-of-control-over-personal-data-collected-by-both-companies-and-the-government/.\n", - "\n", - "[^****]: Robles, Pedro, and Daniel J. Mallinson. “Artificial Intelligence Technology, Public Trust, and Effective Governance.” Review of Policy Research, May 2023, p. ropr.12555, https://doi.org/10.1111/ropr.12555.\n", - "\n", - "[^*****]: Mathews, Lee. “Equifax Data Breach Impacts 143 Million Americans.” Forbes, https://www.forbes.com/sites/leemathews/2017/09/07/equifax-data-breach-impacts-143-million-americans/. Accessed 31 July 2023.\n", - "\n", - "[^******]: U.S. Department of Homeland Security. Increasing Threat of DEEPFAKE Identities. Accessed 31 July 2023. https://www.dhs.gov/sites/default/files/publications/increasing_threats_of_deepfake_identities_0.pdf\n", - "\n", - "[^*******]: “Americans Widely Distrust Facebook, TikTok and Instagram with Their Data, Poll Finds.” Washington Post, 22 Dec. 2021, https://www.washingtonpost.com/technology/2021/12/22/tech-trust-survey/.\n", - "\n", - "[^********]: Nadeem, Reem. “Public Awareness of Artificial Intelligence in Everyday Activities.” Pew Research Center Science & Society, 15 Feb. 2023, https://www.pewresearch.org/science/2023/02/15/public-awareness-of-artificial-intelligence-in-everyday-activities/.\n", - "\n", - "[^**********]: Morey, Timothy, et al. “Customer Data: Designing for Transparency and Trust.” Harvard Business Review, 1 May 2015, https://hbr.org/2015/05/customer-data-designing-for-transparency-and-trust.\n", - "\n", - "[^***********]: Virginia Dignum. The role and challenges of education for responsible AI. London Review of Education. 2021. Vol. 19(1). DOI: 10.14324/LRE.19.1.01\n", - "\n", - "[^***********]: Umang Bhatt, Alice Xiang, Shubham Sharma, Adrian Weller, Ankur Taly, Yunhan Jia, Joydeep Ghosh, Ruchir Puri, José M. F. Moura, and Peter Eckersley. 2020. Explainable machine learning in deployment. In Proceedings of the 2020 Conference on Fairness, Accountability, and Transparency (FAT* '20). Association for Computing Machinery, New York, NY, USA, 648–657. https://doi.org/10.1145/3351095.3375624\n", - "\n", - "[^************]: Burrell, J. (2016). How the machine ‘thinks’: Understanding opacity in machine learning algorithms. Big Data & Society, 3(1). https://doi.org/10.1177/2053951715622512\n", + "[^*]: General Assembly. \"Preservation of Racial Integrity (1924)\" Encyclopedia Virginia. Virginia Humanities, (07 Dec. 2020). Web. 01 Dec. 2022\n", "\n", - "[^*************]: Ghassemi M, Oakden-Rayner L, Beam AL. The false hope of current approaches to explainable artificial intelligence in health care. Lancet Digit Health. 2021 Nov;3(11):e745-e750. doi: 10.1016/S2589-7500(21)00208-9. PMID: 34711379.\n", + "[^**]: BUCK v. BELL. 2 May 1927, https://www.loc.gov/item/usrep274200/.\n", "\n", - "[^**************]: Rudin C. Stop Explaining Black Box Machine Learning Models for High Stakes Decisions and Use Interpretable Models Instead. Nat Mach Intell. 2019 May;1(5):206-215. doi: 10.1038/s42256-019-0048-x. Epub 2019 May 13. PMID: 35603010; PMCID: PMC9122117.\n", + "[^***]: Laws of Indiana, 1907, pp. 377-78 (B050823). https://www.in.gov/history/state-historical-markers/find-a-marker/1907-indiana-eugenics-law/\n", "\n", - "[^***************]: Chaofan Chen, Oscar Li, Chaofan Tao, Alina Jade Barnett, Jonathan Su, and Cynthia Rudin. 2019. This looks like that: deep learning for interpretable image recognition. Proceedings of the 33rd International Conference on Neural Information Processing Systems. Curran Associates Inc., Red Hook, NY, USA, Article 801, 8930–8941.\n", + "[^****]: Reilly, Philip R. “Eugenics and Involuntary Sterilization: 1907-2015.” Annual Review of Genomics and Human Genetics, vol. 16, 2015, pp. 351–68, https://doi.org/10.1146/annurev-genom-090314-024930.\n", "\n", - "[^****************]: Barnett, A.J., Schwartz, F.R., Tao, C. et al. A case-based interpretable deep learning model for classification of mass lesions in digital mammography. Nat Mach Intell 3, 1061–1070 (2021). https://doi.org/10.1038/s42256-021-00423-x\n", + "[^*****]: Office of the New York State Attorney General. Investigative Report on the role of online platforms in the tragic mass shooting in Buffalo on May 14, 2022. Published OCTOBER 18, 2022. https://ag.ny.gov/sites/default/files/buffaloshooting-onlineplatformsreport.pdf\n", "\n", - "[^*****************]: Biran, Or and Courtenay V. Cotton. “Explanation and Justification in Machine Learning : A Survey Or.” (2017).\n", + "[^******]: Angwin, Julia, et al. “Machine bias: There’s software used across the country to predict future criminals. And it’s biased against blacks,” ProPublica, 23 May 2016, www.propublica.org/article/machine-bias-risk-assessments-in-criminal-sentencing.\n", "\n", - "[^******************]: “More Evidence That Nutrition Studies Don’t Always Add Up.” The New York Times, 29 Sept. 2018, https://www.nytimes.com/2018/09/29/sunday-review/cornell-food-scientist-wansink-misconduct.html.\n", + "[^*******]: Dieterich, William, et al. \"COMPAS Risk Scales: Demonstrating\n", + "Accuracy Equity and Predictive Parity,\" 8 July 2016, https://go.volarisgroup.com/rs/430-MBX-989/images/ProPublica_Commentary_Final_070616.pdf.\n", "\n", + "[^********]: Flores, Anthony, et al. \"False Positives, False Negatives, and False Analyses: A Rejoinder to 'Machine Bias: There's Software Used Across the Country to Predict Future Criminals. And It's Biased Against Blacks.'\" Federal Probation, Vol. 80 Number 2, September 2016, https://www.uscourts.gov/federal-probation-journal/2016/09/false-positives-false-negatives-and-false-analyses-rejoinder.\n", "\n", - "[^*******************]: Benjamini, Yoav, and Yosef Hochberg. “Controlling the False Discovery Rate: A Practical and Powerful Approach to Multiple Testing.” Journal of the Royal Statistical Society. Series B (Methodological), vol. 57, no. 1, 1995, pp. 289–300. JSTOR, http://www.jstor.org/stable/2346101. Accessed 22 Aug. 2023.\n", + "[^*********]: Corbett-Davies, Sam, and Sharad Goel. The Measure and Mismeasure of Fairness: A Critical Review of Fair Machine Learning. arXiv, 14 Aug. 2018, https://arxiv.org/abs/1808.00023.\n", "\n", - "[^********************]: Zbyněk Šidák (1967) Rectangular Confidence Regions for the Means of Multivariate Normal Distributions, Journal of the American Statistical Association, 62:318, 626-633, DOI: 10.1080/01621459.1967.10482935\n", + "[^**********]: Pleiss, Geoff, et al. “On Fairness and Calibration.” Advances in Neural Information Processing Systems, vol. 30, Curran Associates, Inc., 2017, https://papers.nips.cc/paper/2017/hash/b8b9c74ac526fffbeb2d39ab038d1cd7-Abstract.html.\n", "\n", - "[^*********************]: Code of Federal Regulations. Title 45, Part 689 - Research Misconduct. 18 Mar. 2002. https://www.ecfr.gov/current/title-45/subtitle-B/chapter-VI/part-689#.\n", + "[^***********]: Dressel, Julia and Farid, Hany. “The Accuracy, Fairness, and Limits of Predicting Recidivism.” Science Advances, vol. 4, no. 1, Jan. 2018, p. eaao5580, https://doi.org/10.1126/sciadv.aao5580.\n", "\n", - "[^**********************]: \"Professor accused of faking data in studies on dishonesty sues Harvard.\" Washington Post, 3 Aug. 2023, https://www.washingtonpost.com/education/2023/08/03/harvard-honesty-lawsuit-research-misconduct/.\n", + "[^************]: Eberhardt, Jennifer. L. “Strategies for change: Research initiatives and recommendations to improve police- community relations in Oakland, Calif.” 2016. Stanford University, SPARQ: Social Psychological Answers to Real-world Questions. \n", "\n", - "[^***********************]: \"An Influential Study Of Dishonesty Was Dishonest.\" Forbes, 30 Aug. 2021. https://www.forbes.com/sites/christianmiller/2021/08/30/an-influential-study-of-dishonesty-was-dishonest/?sh=6e9e992c2c72." + "[^*************]: Jeffrey J. Rachlinski & Sheri L. Johnson, Does Unconscious Racial Bias Affect Trial Judges, 84 Notre Dame L. Rev. 1195 (2009). Available at: http://scholarship.law.nd.edu/ndlr/vol84/iss3/4.\n" ] }, { diff --git a/textbook/_toc.yml b/textbook/_toc.yml index 8d595612..1e70df33 100644 --- a/textbook/_toc.yml +++ b/textbook/_toc.yml @@ -40,6 +40,8 @@ parts: file: 04/2/Dictionaries - title: "4.3 Arrays" file: 04/3/Arrays-Intro + - title: "4.4 Array Indexing and Slicing" + file: 04/4/Arrays-Slicing - title: "4.5 Assignment for Mutable Data Types" file: 04/5/assignment @@ -98,16 +100,12 @@ parts: - title: "9. Data Visualization" file: 09/data-visualization sections: - - title: "9.1 Introduction to Matplotlib & Pyplot" - file: 09/1/Intro-to-Matplotlib - - title: "9.2 Numerical Data" - file: 09/2/Numerical_Data - - title: "9.3 Categorical Data" - file: 09/3/Categorical_Data - - title: "9.4 Other Visualization Techniques" - file: 09/4/other-viz - - + - title: "9.1 Libraries" + file: 09/1/Libraries + - title: "9.2 Categorical Data" + file: 09/2/Categorical_Data + - title: "9.3 Numerical Data" + file: 09/3/Numerical_Data - title: "10. Data Collection" file: 10/data-collection @@ -174,13 +172,13 @@ parts: sections: - title: "15.1 Data Ethics and the Law" file: 15/1/ethics-and-law - - title: "15.2 Pillar 1: Mitigating Unintended Consequences" + - title: "15.2 Pillar 1: Data Transparency & Accountability" file: 15/2/pillar1 - title: "15.3 Pillar 2: Data Privacy" file: 15/3/pillar2 - title: "15.4 Pillar 3: Informed Consent" file: 15/4/pillar3 - - title: "15.5 Pillar 4: Data Transparency & Accountability" + - title: "15.5 Pillar 4: Mitigating Unintended Consequences" file: 15/5/pillar4 - title: "16. Traffic Stops Case Study" From 7373a0afd8bfc18da14f254193f456c8ef4723eb Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Thu, 24 Aug 2023 14:03:58 -0500 Subject: [PATCH 08/12] adding ci and hypothesis test --- textbook/16/2/investigation.ipynb | 6134 ++++++++++++++++++++++++++++- 1 file changed, 6129 insertions(+), 5 deletions(-) diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index a33f9734..0fc08395 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -1976,18 +1976,25 @@ "We see a slightly taller bar for White drivers in the previous barchart. It would be interesting to know if contraband is found on White drivers significantly more often than Black drivers. Let's add a confidence interval to the point estimates shown in the plot. We will focus on the three most common races in our data: Black, Hispanic, and White." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create 5000 bootstrap samples and calculate hit proportions for white, black, and hispanic drivers in each sample." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 72, "metadata": {}, "outputs": [], "source": [ "props_white = np.array([])\n", "props_black = np.array([])\n", "props_hispanic = np.array([])\n", - "for i in np.arange(1000):\n", - " bootstrap_sample = original_sample.sample(len(original_sample),replace=True)\n", - " searched = original_sample.groupby(\"driver_race\")[[\"any_search\",\"search_hit\"]].sum().reset_index().rename(columns={\"any_search\":\"num_searched\", \"search_hit\":\"num_hit\"})\n", + "for i in np.arange(5000):\n", + " bootstrap_sample = idot_20_abbrv.sample(len(idot_20_abbrv),replace=True)\n", + " searched = bootstrap_sample.groupby(\"driver_race\")[[\"any_search\",\"search_hit\"]].sum().reset_index().rename(columns={\"any_search\":\"num_searched\", \"search_hit\":\"num_hit\"})\n", " searched['prop_hit'] = searched['num_hit'] / searched['num_searched']\n", " resampled_white = searched[searched.driver_race == \"white\"][\"prop_hit\"]\n", " resampled_black = searched[searched.driver_race == \"black\"][\"prop_hit\"]\n", @@ -1996,12 +2003,6129 @@ " props_black = np.append(props_black, resampled_black)\n", " props_hispanic = np.append(props_hispanic, resampled_hispanic)\n", "\n", - "plt.bar(searched['driver_race'], searched[\"prop_hit\"])\n", + "white_ci = np.percentile(props_white, [2.5,97.5])\n", + "black_ci = np.percentile(props_black, [2.5,97.5])\n", + "hispanic_ci = np.percentile(props_hispanic, [2.5,97.5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have our 3 95% bootstrap confidence intervals, we need to get them in the correct format to make error bars on our graph. The method `.T` transposes a 2-D array or matrix. In this case, we needed all lower limits in one row and all upper limits in another, so we transposed our array and then made it back into a list. The argument that creates error bars also needs the upper and lower limits in the format of distances from the top of the bar in a barchart so we subtract to find those distances." + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2 0.017515\n", + "3 0.005375\n", + "5 0.076838\n", + "Name: prop_hit, dtype: float64" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "searched3 = searched.loc[searched.driver_race.isin(['white','black','hispanic'])]\n", + "\n", + "errors = np.array([black_ci, hispanic_ci, white_ci]).T.tolist()\n", + "low = searched3[\"prop_hit\"] - errors[0]\n", + "high = errors[1] - searched3[\"prop_hit\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we can plot our barchart and include the confidence interval we calculated." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(searched3['driver_race'], searched3[\"prop_hit\"], yerr=[low,high], capsize=10)\n", "plt.xlabel(\"Driver's Race\")\n", "plt.ylabel(\"Proportion of Successful Searches\")\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The 95% bootstrap confidence intervals for black and hispanic and hispanic and white seem to overlap, but those for black and white don't indicating there is a significant difference between the two. Let's double check this with a hypothesis test for the difference in proportion of successful searches between black and white drivers." + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "differences = np.array([])\n", + "for i in np.arange(5000):\n", + " shuffled_dat = idot_20_abbrv.loc[idot_20_abbrv.driver_race.isin(['white','black'])]\n", + " shuffled_dat.loc['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + " shuffle_searched = shuffled_dat.groupby(\"shuffled_races\")[[\"any_search\",\"search_hit\"]].sum().reset_index().rename(columns={\"any_search\":\"num_searched\", \"search_hit\":\"num_hit\"})\n", + " shuffle_searched['prop_hit'] = shuffle_searched['num_hit'] / shuffle_searched['num_searched']\n", + " diff = shuffle_searched.loc[shuffle_searched['shuffled_races'] == 'white','prop_hit'].iloc[0] - shuffle_searched.loc[shuffle_searched['shuffled_races'] == 'black','prop_hit'].iloc[0]\n", + " differences = np.append(differences, diff)\n", + "\n", + "data_diff = searched3.loc[searched3['driver_race'] == 'white','prop_hit'].iloc[0] - searched3.loc[searched3['driver_race'] == 'black','prop_hit'].iloc[0]\n", + "plt.hist(differences)\n", + "plt.scatter(data_diff, -5, color='red', s=30)\n", + "plt.title('5000 simulated datasets');\n", + "plt.xlabel(\"Difference in proportions of hits\");\n", + "plt.ylabel(\"Frequency\");" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our permutation test shows that the difference in proportions we see in our data is not consistent with what we would expect if there was no difference between the two groups. In fact, the red dot does not overlap with our histogram at all indicating our p-value is 0. So, we can reject the null hypothesis that black and white drivers have similar proportions of search hits, and conclude that contraband is found on black drivers at a significantly lower rate than white drivers!" + ] + }, { "cell_type": "markdown", "metadata": {}, From 25608112277d4b786062e1356a9354c8d97f4e79 Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Thu, 24 Aug 2023 14:11:02 -0500 Subject: [PATCH 09/12] small changes --- textbook/16/2/investigation.ipynb | 15 +++++++++++---- textbook/_toc.yml | 4 ++-- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index 0fc08395..c6dff3e7 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -836,7 +836,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now, we can see that approximately 62% of drivers stopped were Black, 24% were Hispanic, and 11% were White." + "From this figure, we can see that approximately 62% of drivers stopped were Black, 24% were Hispanic, and 11% were White." ] }, { @@ -1349,6 +1349,13 @@ "pop_total" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `.replace` method can be used along with a dictionary to map values from a series onto different values. In this case, we are mapping all occurrences of 'native' to 'am_indian'." + ] + }, { "cell_type": "code", "execution_count": 22, @@ -1980,7 +1987,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "First, we create 5000 bootstrap samples and calculate hit proportions for white, black, and hispanic drivers in each sample." + "First, we create 5000 bootstrap samples and calculate hit proportions for White, Black, and Hispanic drivers in each sample." ] }, { @@ -2076,7 +2083,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The 95% bootstrap confidence intervals for black and hispanic and hispanic and white seem to overlap, but those for black and white don't indicating there is a significant difference between the two. Let's double check this with a hypothesis test for the difference in proportion of successful searches between black and white drivers." + "The 95% bootstrap confidence intervals for Black and Hispanic and Hispanic and White seem to overlap, but those for Black and White don't, indicating there is a significant difference between the two. Let's double check this with a hypothesis test for the difference in proportion of successful searches between Black and White drivers." ] }, { @@ -8123,7 +8130,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Our permutation test shows that the difference in proportions we see in our data is not consistent with what we would expect if there was no difference between the two groups. In fact, the red dot does not overlap with our histogram at all indicating our p-value is 0. So, we can reject the null hypothesis that black and white drivers have similar proportions of search hits, and conclude that contraband is found on black drivers at a significantly lower rate than white drivers!" + "Our permutation test shows that the difference in proportions we see in our data is not consistent with what we would expect if there was no difference between the two groups. In fact, the red dot does not overlap with our histogram at all indicating our p-value is 0. So, we can reject the null hypothesis that Black and White drivers have similar proportions of search hits, and conclude that contraband is found on Black drivers at a significantly lower rate than White drivers!" ] }, { diff --git a/textbook/_toc.yml b/textbook/_toc.yml index 1e70df33..fa057717 100644 --- a/textbook/_toc.yml +++ b/textbook/_toc.yml @@ -3,7 +3,7 @@ format: jb-book root: intro parts: -- caption: "Data Science I" +- caption: "Part I: Exploring Data" chapters: - title: "1. What is Data Science?" @@ -189,7 +189,7 @@ parts: - title: "16.2 Investigating Traffic Stops" file: 16/2/investigation -- caption: "Data Science II" +- caption: "Part II: Using Data to Understand Our World" chapters: - title: "17. Prediction and Correlation" file: 17/prediction-and-correlation From d89d1c7f371edd7ba8ab1c997e0db2ce1e2de289 Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Thu, 24 Aug 2023 14:12:07 -0500 Subject: [PATCH 10/12] change file path --- textbook/16/2/investigation.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index c6dff3e7..50809238 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -132,7 +132,7 @@ } ], "source": [ - "idot = pd.read_csv('./idot_abbrv.csv')\n", + "idot = pd.read_csv('../../data/idot_abbrv.csv')\n", "idot.head()" ] }, From 1dbe9fb0fd16605e4fa998ed69be0f0149f3ae95 Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Thu, 24 Aug 2023 14:35:52 -0500 Subject: [PATCH 11/12] fixing copy warning --- textbook/16/2/investigation.ipynb | 6017 +---------------------------- textbook/intro.md | 4 +- 2 files changed, 8 insertions(+), 6013 deletions(-) diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index 50809238..0eb21f9b 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -1837,7 +1837,7 @@ "source": [ "We can see from this barchart that Black drivers are searched much more often than drivers of any other race. Over 70% of searches conducted in 2020 were of Black drivers!\n", "\n", - "Are these searches successful? If these were necessary searches, offices should be finding contraband more often when searching Black drivers." + "Are these searches successful? If these were necessary searches, officers should be finding contraband more often when searching Black drivers." ] }, { @@ -2088,6018 +2088,12 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 127, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", - "/var/folders/7y/y408wxbx78zfvr0rb_zlw55r0000gn/T/ipykernel_15946/1942707544.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -8110,9 +2104,10 @@ ], "source": [ "differences = np.array([])\n", + "shuffled_dat = idot_20_abbrv.loc[idot_20_abbrv.driver_race.isin(['white','black'])].copy()\n", + "\n", "for i in np.arange(5000):\n", - " shuffled_dat = idot_20_abbrv.loc[idot_20_abbrv.driver_race.isin(['white','black'])]\n", - " shuffled_dat.loc['shuffled_races'] = np.random.permutation(shuffled_dat.driver_race)\n", + " shuffled_dat['shuffled_races'] = np.random.permutation(shuffled_dat[\"driver_race\"])\n", " shuffle_searched = shuffled_dat.groupby(\"shuffled_races\")[[\"any_search\",\"search_hit\"]].sum().reset_index().rename(columns={\"any_search\":\"num_searched\", \"search_hit\":\"num_hit\"})\n", " shuffle_searched['prop_hit'] = shuffle_searched['num_hit'] / shuffle_searched['num_searched']\n", " diff = shuffle_searched.loc[shuffle_searched['shuffled_races'] == 'white','prop_hit'].iloc[0] - shuffle_searched.loc[shuffle_searched['shuffled_races'] == 'black','prop_hit'].iloc[0]\n", diff --git a/textbook/intro.md b/textbook/intro.md index 49d85e69..cd33ca46 100644 --- a/textbook/intro.md +++ b/textbook/intro.md @@ -1,6 +1,6 @@ -# Introduction to Data Science I & II +# Introduction -[Dan L. Nicolae](https://www.stat.uchicago.edu/~nicolae/), [Michael J. Franklin](https://cs.uchicago.edu/people/michael-franklin/), [Amanda R. Kube Jotte](https://amandakube.github.io/), Evelyn Campbell, Susanna Lange, Jesse London, and Will Trimble +[Dan L. Nicolae](https://www.stat.uchicago.edu/~nicolae/), [Michael J. Franklin](https://cs.uchicago.edu/people/michael-franklin/), [Amanda R. Kube Jotte](https://amandakube.github.io/), Evelyn Campbell, Susanna Lange, Will Trimble, and Jesse London Forthcoming... From f98bb8533f9b8c5c588e38b9b0195ba8f6233e3c Mon Sep 17 00:00:00 2001 From: Amanda Kube Date: Thu, 24 Aug 2023 14:49:36 -0500 Subject: [PATCH 12/12] fixing plot --- textbook/16/2/investigation.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/textbook/16/2/investigation.ipynb b/textbook/16/2/investigation.ipynb index 0eb21f9b..42048a3a 100644 --- a/textbook/16/2/investigation.ipynb +++ b/textbook/16/2/investigation.ipynb @@ -2088,12 +2088,12 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 128, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2115,7 +2115,7 @@ "\n", "data_diff = searched3.loc[searched3['driver_race'] == 'white','prop_hit'].iloc[0] - searched3.loc[searched3['driver_race'] == 'black','prop_hit'].iloc[0]\n", "plt.hist(differences)\n", - "plt.scatter(data_diff, -5, color='red', s=30)\n", + "plt.scatter(data_diff, -1, color='red', s=30)\n", "plt.title('5000 simulated datasets');\n", "plt.xlabel(\"Difference in proportions of hits\");\n", "plt.ylabel(\"Frequency\");"