diff --git a/your-code/lab_imbalance.ipynb b/your-code/lab_imbalance.ipynb index dbb15e1..0a804fb 100644 --- a/your-code/lab_imbalance.ipynb +++ b/your-code/lab_imbalance.ipynb @@ -1,147 +1,659 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Inbalanced Classes\n", - "## In this lab, we are going to explore a case of imbalanced classes. \n", - "\n", - "\n", - "Like we disussed in class, when we have noisy data, if we are not careful, we can end up fitting our model to the noise in the data and not the 'signal'-- the factors that actually determine the outcome. This is called overfitting, and results in good results in training, and in bad results when the model is applied to real data. Similarly, we could have a model that is too simplistic to accurately model the signal. This produces a model that doesnt work well (ever). \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### First, download the data from: https://www.kaggle.com/datasets/chitwanmanchanda/fraudulent-transactions-data?resource=download . Import the dataset and provide some discriptive statistics and plots. What do you think will be the important features in determining the outcome?\n", - "### Note: don't use the entire dataset, use a sample instead, with n=100000 elements, so your computer doesn't freeze." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### What is the distribution of the outcome? " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your response here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Clean the dataset. Pre-process it to make it suitable for ML training. Feel free to explore, drop, encode, transform, etc. Whatever you feel will improve the model score." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run a logisitc regression classifier and evaluate its accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Now pick a model of your choice and evaluate its accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Which model worked better and how do you know?" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Your response here" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "mXdNsj7EsqR8" + }, + "source": [ + "# Inbalanced Classes\n", + "## In this lab, we are going to explore a case of imbalanced classes.\n", + "\n", + "\n", + "Like we disussed in class, when we have noisy data, if we are not careful, we can end up fitting our model to the noise in the data and not the 'signal'-- the factors that actually determine the outcome. This is called overfitting, and results in good results in training, and in bad results when the model is applied to real data. Similarly, we could have a model that is too simplistic to accurately model the signal. This produces a model that doesnt work well (ever).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kj35dszdsqR9" + }, + "source": [ + "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bmmIMKbZsqR-" + }, + "source": [ + "### First, download the data from: https://www.kaggle.com/datasets/chitwanmanchanda/fraudulent-transactions-data?resource=download . Import the dataset and provide some discriptive statistics and plots. What do you think will be the important features in determining the outcome?\n", + "### Note: don't use the entire dataset, use a sample instead, with n=100000 elements, so your computer doesn't freeze." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "id": "XffSo2GisqR-" + }, + "outputs": [], + "source": [ + "# Your code here\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "\n", + "# Load the dataset (assuming the zip is already extracted and csv is in Colab)\n", + "data = pd.read_csv('Fraud.csv')\n", + "\n", + "# Extract a sample of n=100,000 elements\n", + "sample_data = data.sample(n=100000, random_state=42)" + ], + "metadata": { + "id": "ABQkeBxVti9K" + }, + "execution_count": 33, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Display basic information and descriptive statistics\n", + "print(sample_data.info())\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LMG28xIetjFx", + "outputId": "f78df981-f87b-45c1-ddd2-1fc29fb4af3c" + }, + "execution_count": 34, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Index: 100000 entries, 3737323 to 6142173\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 step 100000 non-null int64 \n", + " 1 type 100000 non-null object \n", + " 2 amount 100000 non-null float64\n", + " 3 nameOrig 100000 non-null object \n", + " 4 oldbalanceOrg 100000 non-null float64\n", + " 5 newbalanceOrig 100000 non-null float64\n", + " 6 nameDest 100000 non-null object \n", + " 7 oldbalanceDest 100000 non-null float64\n", + " 8 newbalanceDest 100000 non-null float64\n", + " 9 isFraud 100000 non-null int64 \n", + " 10 isFlaggedFraud 100000 non-null int64 \n", + "dtypes: float64(5), int64(3), object(3)\n", + "memory usage: 9.2+ MB\n", + "None\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(sample_data.describe())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oGBx_iJAtjMl", + "outputId": "1aff4167-8a44-4c38-ac54-7dd31917d56d" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " step amount oldbalanceOrg newbalanceOrig \\\n", + "count 100000.000000 1.000000e+05 1.000000e+05 1.000000e+05 \n", + "mean 243.709070 1.805811e+05 8.366804e+05 8.582234e+05 \n", + "std 142.518613 5.586699e+05 2.901104e+06 2.936799e+06 \n", + "min 1.000000 9.200000e-01 0.000000e+00 0.000000e+00 \n", + "25% 156.000000 1.350821e+04 0.000000e+00 0.000000e+00 \n", + "50% 240.000000 7.603086e+04 1.393850e+04 0.000000e+00 \n", + "75% 335.000000 2.091130e+05 1.070771e+05 1.464169e+05 \n", + "max 736.000000 3.697390e+07 3.359321e+07 3.388709e+07 \n", + "\n", + " oldbalanceDest newbalanceDest isFraud isFlaggedFraud \n", + "count 1.000000e+05 1.000000e+05 100000.000000 100000.000000 \n", + "mean 1.104193e+06 1.230055e+06 0.001410 0.000010 \n", + "std 3.223011e+06 3.475326e+06 0.037524 0.003162 \n", + "min 0.000000e+00 0.000000e+00 0.000000 0.000000 \n", + "25% 0.000000e+00 0.000000e+00 0.000000 0.000000 \n", + "50% 1.387482e+05 2.185786e+05 0.000000 0.000000 \n", + "75% 9.605963e+05 1.126011e+06 0.000000 0.000000 \n", + "max 2.362896e+08 2.724047e+08 1.000000 1.000000 \n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "\n" + ], + "metadata": { + "id": "arfvD1rAtjSX" + }, + "execution_count": 35, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "''' following features could be important for predicting fraud:\n", + "Transaction Amount (amount): Fraudulent transactions often involve unusually high or low values.\n", + "Type of Transaction (type): Certain transaction types, like cash withdrawal, might be more prone to fraud.\n", + "Origin and Destination Balances (oldbalanceOrg, newbalanceOrig, oldbalanceDest, newbalanceDest):\n", + "These balances can indicate if a transaction is suspicious.'''" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 87 + }, + "id": "3w5MGTLRtjXb", + "outputId": "b9d56c7b-798d-4e1e-cc3d-b3b827b09527" + }, + "execution_count": 36, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "' following features could be important for predicting fraud:\\nTransaction Amount (amount): Fraudulent transactions often involve unusually high or low values.\\nType of Transaction (type): Certain transaction types, like cash withdrawal, might be more prone to fraud.\\nOrigin and Destination Balances (oldbalanceOrg, newbalanceOrig, oldbalanceDest, newbalanceDest): \\nThese balances can indicate if a transaction is suspicious.'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZIuZGQbmsqR_" + }, + "source": [ + "### What is the distribution of the outcome?" + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# Plot the distribution of the target variable ('isFraud')\n", + "plt.figure(figsize=(6, 4))\n", + "sns.countplot(x='isFraud', data=sample_data)\n", + "plt.title('Distribution of Fraudulent vs Non-Fraudulent Transactions')\n", + "plt.show()\n", + "\n", + "# Descriptive Statistics\n", + "# Example histogram for numerical features like 'amount'\n", + "plt.figure(figsize=(10, 6))\n", + "sns.histplot(sample_data['amount'], kde=True)\n", + "plt.title('Distribution of Transaction Amounts')\n", + "plt.xlabel('Amount')\n", + "plt.ylabel('Frequency')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 957 + }, + "id": "3TkrslZdthwL", + "outputId": "b0a0126c-2691-4ca6-e2ae-d62777657515" + }, + "execution_count": 37, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 70 + }, + "id": "mJQDrglRsqR_", + "outputId": "87d26286-b9f1-4b30-8e1d-9a750a9e98bb" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'The distribution of the outcome variable (isFraud) is highly imbalanced:\\n\\nNon-Fraudulent Transactions (0): The majority of the transactions are non-fraudulent, with almost all data points belonging to this class.\\nFraudulent Transactions (1): A very small number of transactions are fraudulent, making it a minority class.'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 38 + } + ], + "source": [ + "# Your response here\n", + "'''The distribution of the outcome variable (isFraud) is highly imbalanced:\n", + "\n", + "Non-Fraudulent Transactions (0): The majority of the transactions are non-fraudulent, with almost all data points belonging to this class.\n", + "Fraudulent Transactions (1): A very small number of transactions are fraudulent, making it a minority class.'''" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HOjXORphsqR_" + }, + "source": [ + "### Clean the dataset. Pre-process it to make it suitable for ML training. Feel free to explore, drop, encode, transform, etc. Whatever you feel will improve the model score." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xRIOM3iMsqR_", + "outputId": "530c9bd2-2500-4e3f-88c2-acbe46adf787" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Series([], dtype: int64)\n" + ] + } + ], + "source": [ + "# Your code here\n", + "# Check for missing values\n", + "missing_values = sample_data.isnull().sum()\n", + "print(missing_values[missing_values > 0])\n", + "\n", + "# If there are any missing values, decide how to handle them\n", + "sample_data = sample_data.dropna() # Dropping rows with missing values for simplicity\n", + "\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# Drop irrelevant columns, such as 'nameOrig' and 'nameDest', which are identifiers\n", + "sample_data = sample_data.drop(columns=['nameOrig', 'nameDest'])\n" + ], + "metadata": { + "id": "UJy4ebBJw5Ue" + }, + "execution_count": 40, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Convert 'type' to numeric using One-Hot Encoding\n", + "sample_data = pd.get_dummies(sample_data, columns=['type'], drop_first=True)\n" + ], + "metadata": { + "id": "NVv7pRS8w5Z6" + }, + "execution_count": 41, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# Standardize numerical features\n", + "numerical_cols = ['amount', 'oldbalanceOrg', 'newbalanceOrig', 'oldbalanceDest', 'newbalanceDest']\n", + "scaler = StandardScaler()\n", + "sample_data[numerical_cols] = scaler.fit_transform(sample_data[numerical_cols])\n" + ], + "metadata": { + "id": "PgMfVg_ow5fi" + }, + "execution_count": 42, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Your code here\n", + "from imblearn.over_sampling import SMOTE\n", + "\n", + "# Separate features and target\n", + "X = sample_data.drop(columns=['isFraud'])\n", + "y = sample_data['isFraud']\n", + "\n", + "# Use SMOTE to oversample the minority class\n", + "smote = SMOTE(random_state=42)\n", + "X_resampled, y_resampled = smote.fit_resample(X, y)\n" + ], + "metadata": { + "id": "OL-o8g-WxDUF" + }, + "execution_count": 43, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Split data into training (80%) and testing (20%) sets\n", + "X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2, random_state=42)\n" + ], + "metadata": { + "id": "BvY4R2yJxjG7" + }, + "execution_count": 44, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Check the distribution of target after resampling\n", + "print(\"Distribution after resampling:\")\n", + "print(y_resampled.value_counts())\n", + "\n", + "# Print a few rows to verify\n", + "print(sample_data.head())\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CXCNQMORxjMx", + "outputId": "71daa0c9-9a39-4afa-c44e-07a36d1ff94e" + }, + "execution_count": 45, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Distribution after resampling:\n", + "isFraud\n", + "0 99859\n", + "1 99859\n", + "Name: count, dtype: int64\n", + " step amount oldbalanceOrg newbalanceOrig oldbalanceDest \\\n", + "3737323 278 0.267847 -0.281210 -0.172685 -0.202226 \n", + "264914 15 -0.302388 -0.277934 -0.285857 -0.342598 \n", + "85647 10 -0.050687 -0.251661 -0.204091 -0.280140 \n", + "5899326 403 2.454376 -0.288402 -0.292232 0.649758 \n", + "2544263 206 -0.183309 0.718575 0.729124 -0.213581 \n", + "\n", + " newbalanceDest isFraud isFlaggedFraud type_CASH_OUT type_DEBIT \\\n", + "3737323 -0.318779 0 0 False False \n", + "264914 -0.353941 0 0 False False \n", + "85647 -0.339831 0 0 False False \n", + "5899326 1.012879 0 0 False False \n", + "2544263 -0.256785 0 0 False False \n", + "\n", + " type_PAYMENT type_TRANSFER \n", + "3737323 False False \n", + "264914 True False \n", + "85647 False False \n", + "5899326 False True \n", + "2544263 False False \n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Tz45oB29sqR_" + }, + "source": [ + "### Run a logisitc regression classifier and evaluate its accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZCtFeYEEsqSA", + "outputId": "f21286ed-e4e7-474c-eb0f-3b1d8d5143cd" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Accuracy Score: 0.9756408972561587\n", + "\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0 0.96 0.99 0.98 19913\n", + " 1 0.99 0.96 0.98 20031\n", + "\n", + " accuracy 0.98 39944\n", + " macro avg 0.98 0.98 0.98 39944\n", + "weighted avg 0.98 0.98 0.98 39944\n", + "\n" + ] + } + ], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.metrics import accuracy_score, classification_report\n", + "\n", + "# Step 1: Create and train Logistic Regression model\n", + "logistic_model = LogisticRegression(max_iter=1000, random_state=42)\n", + "logistic_model.fit(X_train, y_train)\n", + "\n", + "# Step 2: Predict on test data\n", + "y_test_pred = logistic_model.predict(X_test)\n", + "\n", + "# Step 3: Calculate accuracy\n", + "accuracy = accuracy_score(y_test, y_test_pred)\n", + "\n", + "# Print the accuracy and classification report\n", + "print(\"Accuracy Score:\", accuracy)\n", + "print(\"\\nClassification Report:\")\n", + "print(classification_report(y_test, y_test_pred))\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F4_ygW3osqSA" + }, + "source": [ + "### Now pick a model of your choice and evaluate its accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ti8B6Vn5sqSA", + "outputId": "4d45db79-a136-4736-cbeb-a4163a6515f7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Random Forest Classifier - Accuracy Score: 0.9997246144602443\n", + "\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " 0 1.00 1.00 1.00 19913\n", + " 1 1.00 1.00 1.00 20031\n", + "\n", + " accuracy 1.00 39944\n", + " macro avg 1.00 1.00 1.00 39944\n", + "weighted avg 1.00 1.00 1.00 39944\n", + "\n" + ] + } + ], + "source": [ + "# Your code here\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.metrics import accuracy_score, classification_report\n", + "\n", + "# Step 1: Create and train Random Forest Classifier\n", + "rf_model = RandomForestClassifier(n_estimators=100, random_state=42)\n", + "rf_model.fit(X_train, y_train)\n", + "\n", + "# Step 2: Predict on test data\n", + "y_rf_pred = rf_model.predict(X_test)\n", + "\n", + "# Step 3: Calculate accuracy\n", + "rf_accuracy = accuracy_score(y_test, y_rf_pred)\n", + "\n", + "# Print the accuracy and classification report\n", + "print(\"Random Forest Classifier - Accuracy Score:\", rf_accuracy)\n", + "print(\"\\nClassification Report:\")\n", + "print(classification_report(y_test, y_rf_pred))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TBQ0RtossqSA" + }, + "source": [ + "### Which model worked better and how do you know?" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 105 + }, + "id": "ezKAr18usqSA", + "outputId": "b10ee0f0-851c-4e68-b24e-ffd74c99e065" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'\\nLogistic Regression: 97.56%\\nRandom Forest: 99.97%\\nSeems like rf is better than lr.\\nRandom Forest Classifier performed significantly better, achieving almost perfect accuracy and F1-score.\\nWhy It’s Better:\\nRandom Forest, as an ensemble model, uses multiple decision trees to make decisions, capturing more complex relationships within the data, which is crucial for this type of problem.\\nHigh accuracy, precision, recall, and F1-score show that Random Forest is capable of distinguishing between fraudulent and non-fraudulent transactions almost perfectly.\\nBased on these metrics, Random Forest Classifier clearly outperformed Logistic Regression in terms of overall performance.\\n'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 50 + } + ], + "source": [ + "# Your response here\n", + "'''\n", + "Logistic Regression: 97.56%\n", + "Random Forest: 99.97%\n", + "Seems like rf is better than lr.\n", + "Random Forest Classifier performed significantly better, achieving almost perfect accuracy and F1-score.\n", + "Why It’s Better:\n", + "Random Forest, as an ensemble model, uses multiple decision trees to make decisions, capturing more complex relationships within the data, which is crucial for this type of problem.\n", + "High accuracy, precision, recall, and F1-score show that Random Forest is capable of distinguishing between fraudulent and non-fraudulent transactions almost perfectly.\n", + "Based on these metrics, Random Forest Classifier clearly outperformed Logistic Regression in terms of overall performance.\n", + "'''" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8qrxYCEwsqSA" + }, + "source": [ + "### Note: before doing the first commit, make sure you don't include the large csv file, either by adding it to .gitignore, or by deleting it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + }, + "colab": { + "provenance": [] + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file