From 5cf650e9dcb36f4a3da53f6007b2c64326785d9a Mon Sep 17 00:00:00 2001 From: Supermjork Date: Mon, 15 May 2023 21:16:35 +0300 Subject: [PATCH] DUMDUM PYDOR --- dwarves/Mining_HQ.ipynb | 256 ++++++++++++++++++++++++++++------------ 1 file changed, 181 insertions(+), 75 deletions(-) diff --git a/dwarves/Mining_HQ.ipynb b/dwarves/Mining_HQ.ipynb index 43f4840..f89ac97 100644 --- a/dwarves/Mining_HQ.ipynb +++ b/dwarves/Mining_HQ.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -10,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -38,7 +39,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -99,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -121,34 +122,36 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "report_year 2828\n", - "agency_code 2828\n", - "agency_jurisdiction 2828\n", - "population 2828\n", - "violent_crimes 2828\n", - "homicides 2828\n", - "rapes 2828\n", - "assaults 2828\n", - "robberies 2828\n", - "months_reported 2828\n", - "crimes_percapita 2828\n", - "homicides_percapita 2828\n", - "rapes_percapita 2828\n", - "assaults_percapita 2828\n", - "robberies_percapita 2828\n", + "report_year 2829\n", + "agency_code 2829\n", + "agency_jurisdiction 2829\n", + "population 2829\n", + "violent_crimes 2829\n", + "homicides 2829\n", + "rapes 2829\n", + "assaults 2829\n", + "robberies 2829\n", + "months_reported 2829\n", + "crimes_percapita 2829\n", + "homicides_percapita 2829\n", + "rapes_percapita 2829\n", + "assaults_percapita 2829\n", + "robberies_percapita 2829\n", + "sum_violence 2829\n", "dtype: int64\n", "year 4664\n", "location 4664\n", "type_of_crime 4664\n", "incidents 4664\n", "rate_per_100k 4664\n", + "incident_sum 4664\n", "dtype: int64\n" ] } @@ -171,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -188,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -487,14 +490,14 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_16036\\2254464593.py:4: DtypeWarning: Columns (1,2,3,4,5,6) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_7948\\2916340334.py:4: DtypeWarning: Columns (1,2,3,4,5,6) have mixed types. Specify dtype option on import or set low_memory=False.\n", " gammas = pd.read_csv(\"../datasets/videogames/games_merged.csv\")\n" ] }, @@ -514,43 +517,43 @@ "8 1.157204\n", "9 2.335800\n", "Name: Critic_Score_Norm, dtype: float64\n", - " Rank Name Genre ESRB_Rating \\\n", - "23952 23953.0 Basha Card Game Collection Misc NaN \n", - "41756 41757.0 Project Phoenix Misc NaN \n", - "29167 29168.0 Dragon Scroll: Yomigaerishi Maryuu Role-Playing NaN \n", - "10152 10153.0 Super Sanctum TD Strategy NaN \n", - "27228 27229.0 Crazy Pinball Misc E \n", + " Rank Name Genre ESRB_Rating Platform \\\n", + "53206 53207.0 Capcom Beat 'Em Up Bundle Fighting T XOne \n", + "3500 3501.0 Napoleon: Total War Strategy T PC \n", + "5916 5917.0 Tom Clancy's HAWX 2 Action T X360 \n", + "10144 10145.0 Hot Wheels: Battle Force 5 Racing E10 DS \n", + "13424 13425.0 Wordfish Puzzle E DS \n", "\n", - " Platform Publisher Developer Critic_Score \\\n", - "23952 PSN Unknown Quirkat 6.671642 \n", - "41756 PSV Unknown Unknown 7.734043 \n", - "29167 NES Konami Konami 8.147059 \n", - "10152 PC Unknown Coffee Stain Studios 5.223529 \n", - "27228 DSiW DTP Entertainment dtp entertainment AG 5.000000 \n", + " Publisher Developer Critic_Score User_Score \\\n", + "53206 Capcom Capcom 8.053846 5.000000 \n", + "3500 Sega The Creative Assembly 8.500000 8.437968 \n", + "5916 Ubisoft Ubisoft Bucharest 4.750000 9.131273 \n", + "10144 Activision Sidhe Interactive 5.033333 7.557451 \n", + "13424 Ubisoft Ubisoft 5.563636 3.463415 \n", "\n", - " User_Score Total_Shipped NA_Sales PAL_Sales Year \\\n", - "23952 9.747917 0.03 0.000 0.0 2011.0 \n", - "41756 9.000278 0.03 0.000 0.0 2020.0 \n", - "29167 7.332155 0.03 0.000 0.0 1987.0 \n", - "10152 7.558887 0.15 0.125 0.0 2007.0 \n", - "27228 8.129441 0.03 0.000 0.0 2010.0 \n", + " Total_Shipped NA_Sales Year bin_Critic_Score bin_value \\\n", + "53206 0.030000 0.00 2018.0 larg 8.5 \n", + "3500 0.667833 0.02 2010.0 larg 8.5 \n", + "5916 0.360000 0.24 2010.0 epik 5.5 \n", + "10144 0.150000 0.12 2009.0 epik 5.5 \n", + "13424 0.080000 0.07 2008.0 epik 5.5 \n", "\n", - " bin_Critic_Score bin_value Critic_Score_Norm \n", - "23952 NaN 5.5 -0.466193 \n", - "41756 NaN 8.5 0.428194 \n", - "29167 NaN 8.5 0.775893 \n", - "10152 NaN 5.5 -1.685293 \n", - "27228 NaN 5.5 -1.873472 \n", - " | Entry 1 | Entry 2 | Entry 3 | Entry 4 | Entry 5 |\n", - "Entry 1 | 0.00000 | 9.61705 | 24.3835 | 4.94015 | 2.89729 |\n", + " Critic_Score_Norm \n", + "53206 0.697422 \n", + "3500 1.073018 \n", + "5916 -2.083936 \n", + "10144 -1.845410 \n", + "13424 -1.398972 \n", + " Dissim | Entry 1 | Entry 2 | Entry 3 | Entry 4 | Entry 5 |\n", + "Entry 1 | 0.00000 | 8.75026 | 10.4348 | 10.5905 | 11.0438 |\n", "\n", - "Entry 2 | 9.61705 | 0.00000 | 33.0465 | 13.8158 | 11.0694 |\n", + "Entry 2 | 8.75026 | 0.00000 | 5.80109 | 5.62036 | 7.26823 |\n", "\n", - "Entry 3 | 24.3835 | 33.0465 | 0.00000 | 20.5836 | 23.5703 |\n", + "Entry 3 | 10.4348 | 5.80109 | 0.00000 | 1.91640 | 6.11254 |\n", "\n", - "Entry 4 | 4.94015 | 13.8158 | 20.5836 | 0.00000 | 3.07261 |\n", + "Entry 4 | 10.5905 | 5.62036 | 1.91640 | 0.00000 | 4.27189 |\n", "\n", - "Entry 5 | 2.89729 | 11.0694 | 23.5703 | 3.07261 | 0.00000 |\n", + "Entry 5 | 11.0438 | 7.26823 | 6.11254 | 4.27189 | 0.00000 |\n", "\n" ] } @@ -569,8 +572,10 @@ "print(gammas['Critic_Score_Norm'].head(10))\n", "\n", "# Saving all into a file\n", + "gammas = gammas.dropna(how=\"any\", axis=0) # nuke them empty poopers\n", "gammas.to_csv(\"../datasets/videogames/games_cleanish.csv\", index=False)\n", "\n", + "\n", "# Need similarity and dissimialrity, scipy time\n", "# Selecting 5 random rows\n", "chosen_idx = np.random.choice(len(gammas), replace = False, size = 5)\n", @@ -581,6 +586,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -629,6 +635,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -644,7 +651,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_16036\\2832375763.py:2: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n", + "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_7948\\2832375763.py:2: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n", " games_fig_pre = sns.histplot(data = games_pre, x = \"Year\", palette = sns.color_palette(\"flare\"), kde = True)\n" ] }, @@ -667,6 +674,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -697,6 +705,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -704,6 +713,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -734,6 +744,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -801,7 +812,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -829,20 +840,20 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_16036\\2268265722.py:1: SettingWithCopyWarning: \n", + "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_7948\\2268265722.py:1: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", " games_dur['Violent_US'] = crime_US['violent_crimes']\n", - "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_16036\\2268265722.py:2: SettingWithCopyWarning: \n", + "C:\\Users\\hellom\\AppData\\Local\\Temp\\ipykernel_7948\\2268265722.py:2: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -866,7 +877,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -887,6 +898,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -895,7 +907,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -926,7 +938,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -939,21 +951,21 @@ { "data": { "text/plain": [ - "0 2\n", - "1 2\n", - "2 2\n", - "3 2\n", - "4 2\n", + "19 2\n", + "20 2\n", + "21 2\n", + "23 2\n", + "24 2\n", " ..\n", - "23596 1\n", - "23597 1\n", - "23598 1\n", - "23599 1\n", - "23600 1\n", + "55778 1\n", + "55779 1\n", + "55788 1\n", + "55789 1\n", + "55790 1\n", "Name: Kmean_Labels, Length: 23601, dtype: int32" ] }, - "execution_count": 75, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -978,6 +990,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -986,7 +999,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -1006,7 +1019,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 53, "metadata": {}, "outputs": [ { @@ -1028,6 +1041,99 @@ "print(\"Number of mislabeled points out of a total %d points : %d\"\n", " % (gammas_test.shape[0], (y_test != prediction).sum()))\n" ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# L'Arbre De Decisions\n", + "\n", + "Making tree" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.tree import DecisionTreeClassifier # Import Decision Tree Classifier\n", + "from sklearn.model_selection import train_test_split # Import train_test_split function\n", + "from sklearn import metrics #Import scikit-learn metrics module for accuracy calculation\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.compose import make_column_transformer" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "no supported conversion for types: (dtype('float64'), dtype('O'))", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[62], line 12\u001b[0m\n\u001b[0;32m 8\u001b[0m predikt_col \u001b[39m=\u001b[39m gammas[\u001b[39m\"\u001b[39m\u001b[39mNA_Sales\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[0;32m 10\u001b[0m transformer \u001b[39m=\u001b[39m make_column_transformer((OneHotEncoder(), [\u001b[39m\"\u001b[39m\u001b[39mGenre\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mESRB_Rating\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mPlatform\u001b[39m\u001b[39m\"\u001b[39m]), remainder \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mpassthrough\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m---> 12\u001b[0m predikt_transform \u001b[39m=\u001b[39m transformer\u001b[39m.\u001b[39;49mfit_transform(gammas)\n\u001b[0;32m 14\u001b[0m predikt_df \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39mDataFrame(predikt_transform, columns\u001b[39m=\u001b[39mtransformer\u001b[39m.\u001b[39mget_feature_names_out())\n\u001b[0;32m 16\u001b[0m \u001b[39m# Checking dimensions\u001b[39;00m\n", + "File \u001b[1;32mc:\\Python311\\Lib\\site-packages\\sklearn\\utils\\_set_output.py:140\u001b[0m, in \u001b[0;36m_wrap_method_output..wrapped\u001b[1;34m(self, X, *args, **kwargs)\u001b[0m\n\u001b[0;32m 138\u001b[0m \u001b[39m@wraps\u001b[39m(f)\n\u001b[0;32m 139\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mwrapped\u001b[39m(\u001b[39mself\u001b[39m, X, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m--> 140\u001b[0m data_to_wrap \u001b[39m=\u001b[39m f(\u001b[39mself\u001b[39;49m, X, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[0;32m 141\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(data_to_wrap, \u001b[39mtuple\u001b[39m):\n\u001b[0;32m 142\u001b[0m \u001b[39m# only wrap the first output for cross decomposition\u001b[39;00m\n\u001b[0;32m 143\u001b[0m \u001b[39mreturn\u001b[39;00m (\n\u001b[0;32m 144\u001b[0m _wrap_data_with_container(method, data_to_wrap[\u001b[39m0\u001b[39m], X, \u001b[39mself\u001b[39m),\n\u001b[0;32m 145\u001b[0m \u001b[39m*\u001b[39mdata_to_wrap[\u001b[39m1\u001b[39m:],\n\u001b[0;32m 146\u001b[0m )\n", + "File \u001b[1;32mc:\\Python311\\Lib\\site-packages\\sklearn\\compose\\_column_transformer.py:751\u001b[0m, in \u001b[0;36mColumnTransformer.fit_transform\u001b[1;34m(self, X, y)\u001b[0m\n\u001b[0;32m 748\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_validate_output(Xs)\n\u001b[0;32m 749\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_record_output_indices(Xs)\n\u001b[1;32m--> 751\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_hstack(\u001b[39mlist\u001b[39;49m(Xs))\n", + "File \u001b[1;32mc:\\Python311\\Lib\\site-packages\\sklearn\\compose\\_column_transformer.py:840\u001b[0m, in \u001b[0;36mColumnTransformer._hstack\u001b[1;34m(self, Xs)\u001b[0m\n\u001b[0;32m 834\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mValueError\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[0;32m 835\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 836\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mFor a sparse output, all columns should \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 837\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mbe a numeric or convertible to a numeric.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 838\u001b[0m ) \u001b[39mfrom\u001b[39;00m \u001b[39me\u001b[39;00m\n\u001b[1;32m--> 840\u001b[0m \u001b[39mreturn\u001b[39;00m sparse\u001b[39m.\u001b[39;49mhstack(converted_Xs)\u001b[39m.\u001b[39mtocsr()\n\u001b[0;32m 841\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m 842\u001b[0m Xs \u001b[39m=\u001b[39m [f\u001b[39m.\u001b[39mtoarray() \u001b[39mif\u001b[39;00m sparse\u001b[39m.\u001b[39missparse(f) \u001b[39melse\u001b[39;00m f \u001b[39mfor\u001b[39;00m f \u001b[39min\u001b[39;00m Xs]\n", + "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\scipy\\sparse\\_construct.py:535\u001b[0m, in \u001b[0;36mhstack\u001b[1;34m(blocks, format, dtype)\u001b[0m\n\u001b[0;32m 505\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mhstack\u001b[39m(blocks, \u001b[39mformat\u001b[39m\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, dtype\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m 506\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 507\u001b[0m \u001b[39m Stack sparse matrices horizontally (column wise)\u001b[39;00m\n\u001b[0;32m 508\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 533\u001b[0m \n\u001b[0;32m 534\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[1;32m--> 535\u001b[0m \u001b[39mreturn\u001b[39;00m bmat([blocks], \u001b[39mformat\u001b[39;49m\u001b[39m=\u001b[39;49m\u001b[39mformat\u001b[39;49m, dtype\u001b[39m=\u001b[39;49mdtype)\n", + "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\scipy\\sparse\\_construct.py:682\u001b[0m, in \u001b[0;36mbmat\u001b[1;34m(blocks, format, dtype)\u001b[0m\n\u001b[0;32m 680\u001b[0m \u001b[39mif\u001b[39;00m dtype \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m 681\u001b[0m all_dtypes \u001b[39m=\u001b[39m [blk\u001b[39m.\u001b[39mdtype \u001b[39mfor\u001b[39;00m blk \u001b[39min\u001b[39;00m blocks[block_mask]]\n\u001b[1;32m--> 682\u001b[0m dtype \u001b[39m=\u001b[39m upcast(\u001b[39m*\u001b[39;49mall_dtypes) \u001b[39mif\u001b[39;00m all_dtypes \u001b[39melse\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[0;32m 684\u001b[0m row_offsets \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mappend(\u001b[39m0\u001b[39m, np\u001b[39m.\u001b[39mcumsum(brow_lengths))\n\u001b[0;32m 685\u001b[0m col_offsets \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mappend(\u001b[39m0\u001b[39m, np\u001b[39m.\u001b[39mcumsum(bcol_lengths))\n", + "File \u001b[1;32m~\\AppData\\Roaming\\Python\\Python311\\site-packages\\scipy\\sparse\\_sputils.py:53\u001b[0m, in \u001b[0;36mupcast\u001b[1;34m(*args)\u001b[0m\n\u001b[0;32m 50\u001b[0m _upcast_memo[\u001b[39mhash\u001b[39m(args)] \u001b[39m=\u001b[39m t\n\u001b[0;32m 51\u001b[0m \u001b[39mreturn\u001b[39;00m t\n\u001b[1;32m---> 53\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mTypeError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39mno supported conversion for types: \u001b[39m\u001b[39m%r\u001b[39;00m\u001b[39m'\u001b[39m \u001b[39m%\u001b[39m (args,))\n", + "\u001b[1;31mTypeError\u001b[0m: no supported conversion for types: (dtype('float64'), dtype('O'))" + ] + } + ], + "source": [ + "# Columnising dataset\n", + "node_cols = [\"Genre\", \"ESRB_Rating\", \"Platform\", \"Critic_Score\", \"User_Score\"]\n", + "\n", + "# Columns to be considered as nodes\n", + "to_be_nodes = gammas[node_cols]\n", + "\n", + "# Attribute to be predicted\n", + "predikt_col = gammas[\"NA_Sales\"]\n", + "\n", + "transformer = make_column_transformer((OneHotEncoder(), [\"Genre\", \"ESRB_Rating\", \"Platform\"]), remainder = 'passthrough')\n", + "\n", + "predikt_transform = transformer.fit_transform(gammas)\n", + "\n", + "predikt_df = pd.DataFrame(predikt_transform, columns=transformer.get_feature_names_out())\n", + "\n", + "# Checking dimensions\n", + "print(to_be_nodes.shape)\n", + "\n", + "predikt_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Found input variables with inconsistent numbers of samples: [18880, 23601]", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[50], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[39m# Chopping down trees\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m node_train, node_test, predikt_train, predikt_test \u001b[39m=\u001b[39m train_test_split(to_be_nodes, predikt_col, test_size \u001b[39m=\u001b[39;49m \u001b[39m0.2\u001b[39;49m, random_state \u001b[39m=\u001b[39;49m\u001b[39m69\u001b[39;49m)\n", + "File \u001b[1;32mc:\\Python311\\Lib\\site-packages\\sklearn\\model_selection\\_split.py:2559\u001b[0m, in \u001b[0;36mtrain_test_split\u001b[1;34m(test_size, train_size, random_state, shuffle, stratify, *arrays)\u001b[0m\n\u001b[0;32m 2556\u001b[0m \u001b[39mif\u001b[39;00m n_arrays \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[0;32m 2557\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mAt least one array required as input\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m-> 2559\u001b[0m arrays \u001b[39m=\u001b[39m indexable(\u001b[39m*\u001b[39;49marrays)\n\u001b[0;32m 2561\u001b[0m n_samples \u001b[39m=\u001b[39m _num_samples(arrays[\u001b[39m0\u001b[39m])\n\u001b[0;32m 2562\u001b[0m n_train, n_test \u001b[39m=\u001b[39m _validate_shuffle_split(\n\u001b[0;32m 2563\u001b[0m n_samples, test_size, train_size, default_test_size\u001b[39m=\u001b[39m\u001b[39m0.25\u001b[39m\n\u001b[0;32m 2564\u001b[0m )\n", + "File \u001b[1;32mc:\\Python311\\Lib\\site-packages\\sklearn\\utils\\validation.py:443\u001b[0m, in \u001b[0;36mindexable\u001b[1;34m(*iterables)\u001b[0m\n\u001b[0;32m 424\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Make arrays indexable for cross-validation.\u001b[39;00m\n\u001b[0;32m 425\u001b[0m \n\u001b[0;32m 426\u001b[0m \u001b[39mChecks consistent length, passes through None, and ensures that everything\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 439\u001b[0m \u001b[39m sparse matrix, or dataframe) or `None`.\u001b[39;00m\n\u001b[0;32m 440\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 442\u001b[0m result \u001b[39m=\u001b[39m [_make_indexable(X) \u001b[39mfor\u001b[39;00m X \u001b[39min\u001b[39;00m iterables]\n\u001b[1;32m--> 443\u001b[0m check_consistent_length(\u001b[39m*\u001b[39;49mresult)\n\u001b[0;32m 444\u001b[0m \u001b[39mreturn\u001b[39;00m result\n", + "File \u001b[1;32mc:\\Python311\\Lib\\site-packages\\sklearn\\utils\\validation.py:397\u001b[0m, in \u001b[0;36mcheck_consistent_length\u001b[1;34m(*arrays)\u001b[0m\n\u001b[0;32m 395\u001b[0m uniques \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39munique(lengths)\n\u001b[0;32m 396\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(uniques) \u001b[39m>\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[1;32m--> 397\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 398\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mFound input variables with inconsistent numbers of samples: \u001b[39m\u001b[39m%r\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[0;32m 399\u001b[0m \u001b[39m%\u001b[39m [\u001b[39mint\u001b[39m(l) \u001b[39mfor\u001b[39;00m l \u001b[39min\u001b[39;00m lengths]\n\u001b[0;32m 400\u001b[0m )\n", + "\u001b[1;31mValueError\u001b[0m: Found input variables with inconsistent numbers of samples: [18880, 23601]" + ] + } + ], + "source": [ + "# Chopping down trees\n", + "node_train, node_test, predikt_train, predikt_test = train_test_split(to_be_nodes, predikt_col, test_size = 0.2, random_state =69)" + ] } ], "metadata": { @@ -1046,7 +1152,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.11.0" }, "orig_nbformat": 4, "vscode": {