diff --git a/Day-1/Priya_Mohankar.ipynb b/Day-1/Priya_Mohankar.ipynb new file mode 100644 index 0000000..6919bf4 --- /dev/null +++ b/Day-1/Priya_Mohankar.ipynb @@ -0,0 +1,966 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_fJLfdEpHP9d", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "8b48015e-6769-47a9-dfe9-6667bde0530c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "fatal: destination path 'Machine-Learning-Simplified' already exists and is not an empty directory.\n" + ] + } + ], + "source": [ + "!git clone https://github.com/IEEE-CISCodeCraft/Machine-Learning-Simplified.git" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "91bMnvq8oqbp" + }, + "source": [ + "#Replace the None instances pesent in the code." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6DNQ2HHJHjYZ" + }, + "outputs": [], + "source": [ + "!cp \"/content/Machine-Learning-Simplified/Day-1/LRTestCases.py\" \"/content/\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dG5rIH8KHUOT" + }, + "outputs": [], + "source": [ + "from LRTestCases import *" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1tOdDoSwZeIE" + }, + "outputs": [], + "source": [ + "def error(yhat, y):\n", + " error = yhat - y #Subtract y from yhat\n", + " return error" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "D7yM32C_Xz-g", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b6c36cd3-fdf0-4943-82bf-e9e7f3954c63" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_error_function(error)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Nnoygph2er5y" + }, + "outputs": [], + "source": [ + "def error_square(error):\n", + " square = error **2 #Square the error claculated above\n", + " return square" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "MHGCiEXJX_AR", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3d180942-8203-4e59-dd81-5151270f77b7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_error_square_function(error_square)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wgwOEQK9fMqA" + }, + "outputs": [], + "source": [ + "def total_squared_error(error, num):\n", + " total_squared_error = 0\n", + " for i in range(num):\n", + " total_squared_error = total_squared_error + error #Add the \"error\" to the \"total_sqared_error\"\n", + " return total_squared_error" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ilzjasT4YJAh", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "185ad238-afa6-4cb8-a75d-c64410d89dd5" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_total_squared_error_function(total_squared_error)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oS7bM8mBjJ-u" + }, + "source": [ + "$\\text{Mean Squared Error}=\\frac{1}{2*m}\\sum\\limits_{i = 0}^{m-1}(y-ŷ)^2$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Q6sFN7i2piR8" + }, + "outputs": [], + "source": [ + "def mse(total_squared_error, num):\n", + " denominator = 2*num #Multipy num with 2\n", + " mse = total_squared_error/denominator #Divide \"total_sqaured_error\" by \"denominator\"\n", + " return num" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "fZ816KtRYsoj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a63327bc-f1c6-442b-aa9d-b832c0bb3fa5" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_mse_function(mse)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3Uqj2E0BlU_U" + }, + "source": [ + "**Finding the predicted value**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oiwBU-fSjp5C" + }, + "outputs": [], + "source": [ + "def predicted_value(w, x, b):\n", + " yhat = w*x+b #Multiply 'w' with 'x' and add 'b'\n", + " return yhat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "MXs2kadnreTF", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "902b0bf6-feea-458b-98de-69097eefc495" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "#TEST YOUR IMPLEMENTATION\n", + "test_predicted_value(predicted_value)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qW9qAdiUwOrk" + }, + "source": [ + "## Cost Function\n", + "The equation for cost with one variable is:\n", + "$$J(w,b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)})^2$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RCCqRXf-wNoI" + }, + "outputs": [], + "source": [ + "def compute_cost(x, y, w, b):\n", + " # number of training examples\n", + " m = x.shape[0]\n", + " total_squared_error = 0\n", + " for i in range(m):\n", + " yhat = w * x[i] + b\n", + " error = yhat - y[i] #Subtract \"y[i]\" from \"yhat\"\n", + " squared_error = error**2 #Square the error\n", + " total_squared_error = total_squared_error + squared_error #Add the \"error\" to the \"total_sqared_error\"\n", + " denominator = m*2 #Multiply m by 2\n", + " total_cost = total_squared_error / denominator #Divide total_cost by denominator\n", + " return total_cost" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OGswOCVFzR7W" + }, + "source": [ + "# Gradient Descent\n", + "## 1. Compute Gradient\n", + "The gradient is defined as:\n", + "$$\n", + "\\begin{align}\n", + "\\frac{\\partial J(w,b)}{\\partial w} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)})x^{(i)} \\\\\n", + " \\frac{\\partial J(w,b)}{\\partial b} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (ŷ - y^{(i)}) \\\\\n", + "\\end{align}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VMBk0PnA0wK3" + }, + "outputs": [], + "source": [ + "def compute_gradient(x, y, w, b):\n", + " # Number of training examples\n", + " m = x.shape[0]\n", + " dj_dw = 0\n", + " dj_db = 0\n", + "\n", + " for i in range(m):\n", + " yhat = w * x[i] + b\n", + " dj_dw_i = (yhat - y[i]) * x[i]\n", + " dj_db_i = yhat - y[i]\n", + " dj_db += dj_db_i\n", + " dj_dw += dj_dw_i\n", + " dj_dw = dj_dw / m\n", + " dj_db = dj_db / m\n", + "\n", + " return dj_dw, dj_db" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3U-qZNSFE1QK", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "29b30e80-eca2-4a85-fa75-e04cb884ca4e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "test_compute_gradient(compute_gradient)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AhWGXBq82p6P" + }, + "source": [ + "## 2. Update the parameters num_iterations times\n", + "$$\\begin{align*} \\text{repeat}&\\text{ until convergence:} \\; \\lbrace \\newline\n", + "\\; w &= w - \\alpha \\frac{\\partial J(w,b)}{\\partial w} \\; \\newline\n", + " b &= b - \\alpha \\frac{\\partial J(w,b)}{\\partial b} \\newline \\rbrace\n", + "\\end{align*}$$\n", + "where, parameters $w$, $b$ are updated simultaneously." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OlNwBvu52cUv" + }, + "outputs": [], + "source": [ + "def gradient_descent(x, y, learning_rate, num_iterations):\n", + " # Initialize weights and bias\n", + " w = 0\n", + " b = 0\n", + " # Number of training examples\n", + " m = x.shape[0]\n", + " for _ in range(num_iterations):\n", + " # Compute gradients using the compute_gradient function\n", + " dj_dw, dj_db = compute_gradient(x, y, w, b)\n", + "\n", + " # Update weights and bias\n", + " w = w - learning_rate * dj_dw\n", + " b = b - learning_rate * dj_db\n", + " # Compute the cost for monitoring\n", + " cost = compute_cost(x, y, w, b)\n", + " print(f'Iteration {_+1}/{num_iterations}, Cost: {cost:.6f}')\n", + " return w, b" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dpmvXbs4lmHO", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "36f30e58-06dd-48cb-bb69-f0472c3727a3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Iteration 1/10, Cost: 6.810072\n", + "Iteration 2/10, Cost: 5.418381\n", + "Iteration 3/10, Cost: 4.336271\n", + "Iteration 4/10, Cost: 3.494823\n", + "Iteration 5/10, Cost: 2.840462\n", + "Iteration 6/10, Cost: 2.331539\n", + "Iteration 7/10, Cost: 1.935677\n", + "Iteration 8/10, Cost: 1.627707\n", + "Iteration 9/10, Cost: 1.388062\n", + "Iteration 10/10, Cost: 1.201534\n", + "Final parameters: w = 0.7955, b = 0.2545\n", + "Final cost: 1.201534\n", + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "test_gradient_descent(gradient_descent, compute_cost, compute_gradient)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NknHm9DGGonf" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_Vb4kNxkG_Ml" + }, + "source": [ + "# **Project:** Melanoma Tumor Size Prediction" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ibTpczTtGokE" + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.metrics import mean_squared_error, mean_absolute_error\n", + "from sklearn.model_selection import train_test_split\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "eqAMMJ9lGohp" + }, + "outputs": [], + "source": [ + "#Read the dataset\n", + "train = pd.read_csv(\"/content/Machine-Learning-Simplified/Day-1/melanoma_dataset.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Q14KncK6GofO", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 423 + }, + "outputId": "19dc1109-8f2f-4fac-c65c-2c38abc63d28" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " mass_npea tumor_size\n", + "0 18.159306 7.490802\n", + "1 39.693228 19.014286\n", + "2 32.659956 14.639879\n", + "3 27.556925 11.973170\n", + "4 9.800536 3.120373\n", + ".. ... ...\n", + "995 5.343260 1.831641\n", + "996 39.080774 18.346272\n", + "997 8.435708 2.736373\n", + "998 40.580192 19.004747\n", + "999 20.147810 8.920115\n", + "\n", + "[1000 rows x 2 columns]" + ], + "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", + "
mass_npeatumor_size
018.1593067.490802
139.69322819.014286
232.65995614.639879
327.55692511.973170
49.8005363.120373
.........
9955.3432601.831641
99639.08077418.346272
9978.4357082.736373
99840.58019219.004747
99920.1478108.920115
\n", + "

1000 rows × 2 columns

\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + "\n", + "\n", + "\n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 82 + } + ], + "source": [ + "#Display the dataset\n", + "train" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "P9ipnJ_iKF42", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "67e70581-0762-49c5-e7b7-99bfef7c3d8d" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 83 + } + ], + "source": [ + "#Gain insights of dataset\n", + "train.describe" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ItVOltUuLE-T", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 466 + }, + "outputId": "24e73ab7-df45-4a3c-cc1e-19234dc59230" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 84 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "#Plot a graph to check linearity\n", + "sns.scatterplot(x='mass_npea', y='tumor_size', data=train)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mQ5YOGJFLE63" + }, + "outputs": [], + "source": [ + "#Extract X and Y from data\n", + "x = train[['mass_npea']]\n", + "y = train['tumor_size']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "M1Jpn6TCLE4s", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 74 + }, + "outputId": "a69bb3b6-894e-4b74-8398-c7330c31ca40" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "LinearRegression()" + ], + "text/html": [ + "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 86 + } + ], + "source": [ + "#Train a Linear Regression Model\n", + "model = LinearRegression()\n", + "# Fit the model to the data\n", + "model.fit(x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "E4sxQ9G4LE2v", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "88892829-5c92-4454-c964-fef628493ccc" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mean Squared Error: 0.24388273258319765\n" + ] + } + ], + "source": [ + "#Evaluate the Model\n", + "#Make predictions\n", + "y_pred = model.predict(x)\n", + "#Calculate Mean Squared Error\n", + "mse = mean_squared_error(y,y_pred)\n", + "print(\"Mean Squared Error:\", mse)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "F5p0Zr1_LSIP", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "outputId": "e10d5c81-8932-4cc3-f470-cbe059534859" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# Plot the data and regression line\n", + "plt.scatter(x,y,label='Data')\n", + "plt.plot(x,y_pred,color='red', label='Regression Line')\n", + "plt.xlabel('Tumor Size')\n", + "plt.ylabel('Melanoma Score')\n", + "plt.title('Melanoma Tumor Size Detection')\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/Day-2/Submission/Priya Mohankar 2.ipynb b/Day-2/Submission/Priya Mohankar 2.ipynb new file mode 100644 index 0000000..06fd9d9 --- /dev/null +++ b/Day-2/Submission/Priya Mohankar 2.ipynb @@ -0,0 +1,105 @@ +Google Colab
Google Account
vaibhav kannoji
vaibhavkannoji@gmail.com
\ No newline at end of file diff --git a/Day-3/Priya Mohankar.ipynb b/Day-3/Priya Mohankar.ipynb new file mode 100644 index 0000000..9b7e7a6 --- /dev/null +++ b/Day-3/Priya Mohankar.ipynb @@ -0,0 +1,2121 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9f8ffdc3-8341-443f-b42e-27af46c6bd5c", + "metadata": { + "id": "9f8ffdc3-8341-443f-b42e-27af46c6bd5c" + }, + "source": [ + "# **Distances**" + ] + }, + { + "cell_type": "markdown", + "id": "5311ed70-e831-4a3c-a35e-d06d2e131197", + "metadata": { + "id": "5311ed70-e831-4a3c-a35e-d06d2e131197" + }, + "source": [ + "## **Euclidean Distance**\n", + "\n", + "\"Euclidean" + ] + }, + { + "cell_type": "markdown", + "id": "f5f58d9c-e969-48ea-a43f-54671f1f84d9", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "id": "f5f58d9c-e969-48ea-a43f-54671f1f84d9" + }, + "source": [ + "### **Euclidean Distance in 3D Space**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d9ff994b-76a7-4f2a-859e-3ef436876625", + "metadata": { + "id": "d9ff994b-76a7-4f2a-859e-3ef436876625" + }, + "outputs": [], + "source": [ + "# Numpy for linear algebra and mathematical functions\n", + "import numpy as np\n", + "\n", + "# Import the test case functions from the file\n", + "from LRTestCases import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6525786b-dc6c-4927-a32a-decf7428193d", + "metadata": { + "id": "6525786b-dc6c-4927-a32a-decf7428193d" + }, + "outputs": [], + "source": [ + "# Function to caluclate euclidean distance\n", + "def euclidean_distance_3d(point_1, point_2):\n", + " # Extract x, y and z value from each point\n", + " x1, y1, z1 = point_a\n", + " x2, y2, z2 = point_b\n", + "\n", + " # Now we apply the formula for euclidean distance\n", + " distance = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2) # Write the formula here\n", + "\n", + " # Return the distance\n", + " return distance" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fb714693-c4df-4e59-aaf2-b73a7830ac83", + "metadata": { + "id": "fb714693-c4df-4e59-aaf2-b73a7830ac83" + }, + "outputs": [], + "source": [ + "# Initialize points for calculating distance\n", + "point_a = (1, 2, 3)\n", + "point_b = (4, 5, 6)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4edd1d87-467f-4217-8101-e8e27f7ef060", + "metadata": { + "id": "4edd1d87-467f-4217-8101-e8e27f7ef060", + "outputId": "8860fecc-243f-4ff0-b95a-d5ff2152623c", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "5.196152422706632\n" + ] + } + ], + "source": [ + "# Calculate the distance\n", + "distance = euclidean_distance_3d(point_a, point_b)\n", + "\n", + "# Print the distance\n", + "print(distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a5524e66-0a2c-4998-abf5-3faf7541ddfe", + "metadata": { + "id": "a5524e66-0a2c-4998-abf5-3faf7541ddfe", + "outputId": "8492a279-3bf5-4407-ab5b-cbc8e9dab227", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "# Call the test case function and check for correctness of code\n", + "test_euclidean_distance_3d(euclidean_distance_3d, point_a, point_b)" + ] + }, + { + "cell_type": "markdown", + "id": "71da7499-ab7b-4b98-9ebc-61fb43e7518c", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "id": "71da7499-ab7b-4b98-9ebc-61fb43e7518c" + }, + "source": [ + "### **Euclidean Distance in 2D Space**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "76620eea-fb52-4815-8aa1-768e5642a553", + "metadata": { + "id": "76620eea-fb52-4815-8aa1-768e5642a553" + }, + "outputs": [], + "source": [ + "# Numpy for linear algebra and mathematical functions\n", + "import numpy as np\n", + "\n", + "# Import the test case functions from the file\n", + "from LRTestCases import *" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3bcfc557-5c5c-48ad-8b66-997d4f2f56be", + "metadata": { + "id": "3bcfc557-5c5c-48ad-8b66-997d4f2f56be" + }, + "outputs": [], + "source": [ + "# Function to caluclate euclidean distance\n", + "def euclidean_distance_2d(point_1, point_2):\n", + " # Extract x and y value from each point\n", + " x1, y1 = point_a\n", + " x2, y2 = point_b\n", + "\n", + " # Now we apply the formula for euclidean distance\n", + " distance = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) # Write the formula here\n", + "\n", + " # Return the distance\n", + " return distance" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4e07853a-9f2d-41eb-8a71-0a54b88e1296", + "metadata": { + "id": "4e07853a-9f2d-41eb-8a71-0a54b88e1296" + }, + "outputs": [], + "source": [ + "# Initialize points for calculating distance\n", + "point_a = (1, 2)\n", + "point_b = (3, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "13e149ca-7000-4954-8fcb-70f594e3406c", + "metadata": { + "id": "13e149ca-7000-4954-8fcb-70f594e3406c", + "outputId": "62585fad-8125-4b50-b6d8-4e88a0acdc8a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.8284271247461903\n" + ] + } + ], + "source": [ + "# Calculate the distance\n", + "distance = euclidean_distance_2d(point_a, point_b)\n", + "\n", + "# Print the distance\n", + "print(distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bf1739be-42af-42ff-9d97-dbbcde300089", + "metadata": { + "id": "bf1739be-42af-42ff-9d97-dbbcde300089", + "outputId": "b297e8d0-8eb2-40d4-d80a-c1d1f66e3780", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "# Call the test case function and check for correctness of code\n", + "test_euclidean_distance_2d(euclidean_distance_2d, point_a, point_b)" + ] + }, + { + "cell_type": "markdown", + "id": "e88bcf1d-3141-4781-90f3-e22af86e279a", + "metadata": { + "id": "e88bcf1d-3141-4781-90f3-e22af86e279a" + }, + "source": [ + "## **Manhattan Distance**\n", + "\n", + "\"Euclidean" + ] + }, + { + "cell_type": "markdown", + "id": "6d691669-0a77-49f6-800a-eb62d4f07a79", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "id": "6d691669-0a77-49f6-800a-eb62d4f07a79" + }, + "source": [ + "### **Manhattan Distance in 3D Space**" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "09258d4c-2b6a-471f-8083-82356ac59c4b", + "metadata": { + "id": "09258d4c-2b6a-471f-8083-82356ac59c4b" + }, + "outputs": [], + "source": [ + "# Function to caluclate manhattan distance\n", + "def manhattan_distance_3d(point_1, point_2):\n", + " # Extract x, y and z value from each point\n", + " x1, y1, z1 = point_a\n", + " x2, y2, z2 = point_b\n", + "\n", + " # Now we apply the formula for manhattan distance\n", + " distance = abs(x2 - x1) + abs(y2 - y1) + abs(z2 - z1) # Write the formula here\n", + "\n", + " # Return the distance\n", + " return distance" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a99662a5-f569-449b-b131-9470c0fa3b85", + "metadata": { + "id": "a99662a5-f569-449b-b131-9470c0fa3b85" + }, + "outputs": [], + "source": [ + "# Initialize points for calculating distance\n", + "point_a = (1, 2, 3)\n", + "point_b = (4, 5, 6)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "db1bda63-18b2-49e4-8e18-4641a08853c3", + "metadata": { + "id": "db1bda63-18b2-49e4-8e18-4641a08853c3", + "outputId": "6dff2291-2047-4530-9890-8a39d4c579dc", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "9\n" + ] + } + ], + "source": [ + "# Calculate the distance\n", + "distance = manhattan_distance_3d(point_a, point_b)\n", + "\n", + "# Print the distance\n", + "print(distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3a14718a-7f1b-4864-8936-73965b7ee53b", + "metadata": { + "id": "3a14718a-7f1b-4864-8936-73965b7ee53b", + "outputId": "e9987157-87b5-4326-cec8-0f8b35540ca5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "# Call the test case function and check for correctness of code\n", + "test_manhattan_distance_3d(manhattan_distance_3d, point_a, point_b)" + ] + }, + { + "cell_type": "markdown", + "id": "3ef4e7bc-e680-4476-b644-1a7e6dc43e5e", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "id": "3ef4e7bc-e680-4476-b644-1a7e6dc43e5e" + }, + "source": [ + "### **Manhattan Distance in 2D Space**" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "19378654-3ee9-45ff-b3f6-7ea234e2f91c", + "metadata": { + "id": "19378654-3ee9-45ff-b3f6-7ea234e2f91c" + }, + "outputs": [], + "source": [ + "# Function to caluclate manhattan distance\n", + "def manhattan_distance_2d(point_1, point_2):\n", + " # Extract x and y value from each point\n", + " x1, y1 = point_a\n", + " x2, y2 = point_b\n", + "\n", + " # Now we apply the formula for manhattan distance\n", + " distance = abs(x2 - x1) + abs(y2 - y1) # Write the formula here\n", + "\n", + " # Return the distance\n", + " return distance" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "0499fd7e-3369-4835-8cec-60f7cde2bbb0", + "metadata": { + "id": "0499fd7e-3369-4835-8cec-60f7cde2bbb0" + }, + "outputs": [], + "source": [ + "# Initialize points for calculating distance\n", + "point_a = (1, 2)\n", + "point_b = (3, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "5d62e2d9-1f5b-4aca-819c-bd428256dd15", + "metadata": { + "id": "5d62e2d9-1f5b-4aca-819c-bd428256dd15", + "outputId": "abc934b7-669d-4cba-97b7-9c0c9f6b8768", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "4\n" + ] + } + ], + "source": [ + "# Calculate the distance\n", + "distance = manhattan_distance_2d(point_a, point_b)\n", + "\n", + "# Print the distance\n", + "print(distance)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b34b390e-9aae-4c84-b316-f4b26edecead", + "metadata": { + "id": "b34b390e-9aae-4c84-b316-f4b26edecead", + "outputId": "de4eb355-dff9-405a-ab3b-f11f977e4eb3", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "# Call the test case function and check for correctness of code\n", + "test_manhattan_distance_2d(manhattan_distance_2d, point_a, point_b)" + ] + }, + { + "cell_type": "markdown", + "id": "875363e4-c034-40a6-bb5c-0c4a9d794f25", + "metadata": { + "id": "875363e4-c034-40a6-bb5c-0c4a9d794f25" + }, + "source": [ + "## **Cosine Similarity**\n", + "\n", + "\"Euclidean" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "cba2a2d2-b684-43e6-b0bb-bf33f1e32d56", + "metadata": { + "id": "cba2a2d2-b684-43e6-b0bb-bf33f1e32d56" + }, + "outputs": [], + "source": [ + "# Numpy for linear algebra and mathematical functions\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "1aeaf4aa-38f2-4823-8525-ff878a6b1229", + "metadata": { + "id": "1aeaf4aa-38f2-4823-8525-ff878a6b1229" + }, + "outputs": [], + "source": [ + "# Function to calculate cosine similarity\n", + "def cosine_similarity(vector1, vector2):\n", + " # Get the dot of vectors -> Numerator\n", + " dot_product = np.dot(vector1, vector2)\n", + "\n", + " # Calculate magnitude for each vector\n", + " magnitude1 = np.linalg.norm(vector1)\n", + " magnitude2 = np.linalg.norm(vector2)\n", + "\n", + " # Get the product of magnitude -> Denominator\n", + " magnitude_product = magnitude1 * magnitude2 # Write the formula here\n", + "\n", + " # Calculate the similarity\n", + " similarity = dot_product / magnitude_product # Write the formula here\n", + "\n", + " # Return the similarity value\n", + " return similarity" + ] + }, + { + "cell_type": "markdown", + "id": "5ba129eb-4a2c-44fe-a050-4bce1ea8ef0f", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "id": "5ba129eb-4a2c-44fe-a050-4bce1ea8ef0f" + }, + "source": [ + "### **Cosine Similarity in 3D Space**" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "b2e6c5e2-eedb-40b9-96f8-0f43ebd9dfef", + "metadata": { + "id": "b2e6c5e2-eedb-40b9-96f8-0f43ebd9dfef" + }, + "outputs": [], + "source": [ + "# Initialize points for calculating similarity\n", + "point_a = np.array([1, 2, 3])\n", + "point_b = np.array([4, 5, 6])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "cdcb4627-32c7-46e9-851a-9eaba7d6c720", + "metadata": { + "id": "cdcb4627-32c7-46e9-851a-9eaba7d6c720", + "outputId": "00a2a577-217e-4842-f98c-9e8705bec3f0", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.9746318461970762\n" + ] + } + ], + "source": [ + "# Calculate the similarity\n", + "similarity = cosine_similarity(point_a, point_b)\n", + "\n", + "# Print the similarity\n", + "print(similarity)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "c56d60cb-c952-4d3a-b04b-9a0b41d96623", + "metadata": { + "id": "c56d60cb-c952-4d3a-b04b-9a0b41d96623", + "outputId": "9926886f-2b82-4723-ad15-ca6331373075", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "# Call the test case function and check for correctness of code\n", + "test_cosine_similarity(cosine_similarity, point_a, point_b)" + ] + }, + { + "cell_type": "markdown", + "id": "d6050bfc-5f37-497a-bc73-a44cba0f1d25", + "metadata": { + "id": "d6050bfc-5f37-497a-bc73-a44cba0f1d25" + }, + "source": [ + "### **Cosine Similarity in 2D Space**" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "94890201-abd5-4da7-8062-58111228e896", + "metadata": { + "id": "94890201-abd5-4da7-8062-58111228e896" + }, + "outputs": [], + "source": [ + "# Initialize points for calculating similarity\n", + "point_a = np.array([1, 2])\n", + "point_b = np.array([3, 4])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "7ca6dbca-eb6a-4cd9-bdf5-a6b46449d1ac", + "metadata": { + "id": "7ca6dbca-eb6a-4cd9-bdf5-a6b46449d1ac", + "outputId": "b6546ff5-26b1-45a6-9d6c-eb65ed3d8fd2", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0.9838699100999074\n" + ] + } + ], + "source": [ + "# Calculate the similarity\n", + "similarity = cosine_similarity(point_a, point_b)\n", + "\n", + "# Print the similarity\n", + "print(similarity)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "2000d524-e5b8-440d-9865-8026b0cc1424", + "metadata": { + "id": "2000d524-e5b8-440d-9865-8026b0cc1424", + "outputId": "c9f39838-993e-4255-b0cd-f6fbcef8cd48", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[92mTest passed!\u001b[0m\n" + ] + } + ], + "source": [ + "# Call the test case function and check for correctness of code\n", + "test_cosine_similarity(cosine_similarity, point_a, point_b)" + ] + }, + { + "cell_type": "markdown", + "id": "b32c78fe-2b38-485e-8d91-6fc4ec605b1c", + "metadata": { + "id": "b32c78fe-2b38-485e-8d91-6fc4ec605b1c" + }, + "source": [ + "# **KMeans Clustering**" + ] + }, + { + "cell_type": "markdown", + "id": "6e4361e5-7acc-4a71-81c9-0055d182283a", + "metadata": { + "id": "6e4361e5-7acc-4a71-81c9-0055d182283a" + }, + "source": [ + "## **Data**" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "c5d5e4f3-f8e8-4f03-9b94-d172d5c02f69", + "metadata": { + "id": "c5d5e4f3-f8e8-4f03-9b94-d172d5c02f69", + "outputId": "1c5882dd-17e9-4eaf-a81d-7ade7266f56a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " mass_npea size_npear malign_ratio damage_size exposed_area \\\n", + "0 6930.90 2919.02 0.42116 51.8298 9.888294e+05 \n", + "1 10376.20 2613.88 0.25191 127.3370 1.434676e+06 \n", + "2 13093.80 4510.06 0.34444 155.4400 1.812195e+06 \n", + "3 7545.21 2882.36 0.38201 85.1237 1.043918e+06 \n", + "4 6851.09 2195.18 0.32041 72.8283 9.484467e+05 \n", + "\n", + " std_dev_malign err_malign malign_penalty damage_ratio \n", + "0 109.4870 2758.76 72 39.3620 \n", + "1 160.0930 4635.26 73 29.9963 \n", + "2 173.0150 5273.87 32 28.1354 \n", + "3 124.4140 3263.35 57 35.0200 \n", + "4 97.1881 3688.57 40 36.3481 " + ], + "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", + "
mass_npeasize_npearmalign_ratiodamage_sizeexposed_areastd_dev_malignerr_malignmalign_penaltydamage_ratio
06930.902919.020.4211651.82989.888294e+05109.48702758.767239.3620
110376.202613.880.25191127.33701.434676e+06160.09304635.267329.9963
213093.804510.060.34444155.44001.812195e+06173.01505273.873228.1354
37545.212882.360.3820185.12371.043918e+06124.41403263.355735.0200
46851.092195.180.3204172.82839.484467e+0597.18813688.574036.3481
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ], + "source": [ + "# Import pandas for tabular dataframe management\n", + "import pandas as pd\n", + "\n", + "# Import pandas for tabular dataframe management\n", + "df = pd.read_csv(\"melanoma_tumor_full_data.csv\")\n", + " # Write the code to load the data\n", + "\n", + "# View the top 5 records of the dataset\n", + "df.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "06cfce6f-c863-4250-8b27-582374e240c2", + "metadata": { + "id": "06cfce6f-c863-4250-8b27-582374e240c2", + "outputId": "dae80656-3cc5-4c9a-814e-4f6af201434c", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(39569, 9)" + ] + }, + "metadata": {}, + "execution_count": 29 + } + ], + "source": [ + "# View the shape of data\n", + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6bdfd380-eeb6-412b-901f-27e2f567688b", + "metadata": { + "id": "6bdfd380-eeb6-412b-901f-27e2f567688b", + "outputId": "e34ce40f-9580-447b-c5a2-6e52f8e5493a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " mass_npea size_npear malign_ratio damage_size exposed_area \\\n", + "0 6226.40 1255.14 0.20158 56.3463 8.636718e+05 \n", + "1 10453.50 4105.60 0.39274 109.6710 1.439393e+06 \n", + "2 8354.90 2318.73 0.27752 99.4267 1.133609e+06 \n", + "3 4066.38 1175.19 0.28900 31.3757 5.558418e+05 \n", + "4 7485.04 2406.51 0.32150 63.2253 1.055941e+06 \n", + "\n", + " std_dev_malign err_malign malign_penalty damage_ratio \n", + "0 78.0144 2495.84 20 39.4342 \n", + "1 174.5610 5494.89 65 32.2169 \n", + "2 128.3220 3513.42 116 35.4680 \n", + "3 49.8146 1408.75 17 44.2712 \n", + "4 99.7315 2854.70 28 38.0020 " + ], + "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", + "
mass_npeasize_npearmalign_ratiodamage_sizeexposed_areastd_dev_malignerr_malignmalign_penaltydamage_ratio
06226.401255.140.2015856.34638.636718e+0578.01442495.842039.4342
110453.504105.600.39274109.67101.439393e+06174.56105494.896532.2169
28354.902318.730.2775299.42671.133609e+06128.32203513.4211635.4680
34066.381175.190.2890031.37575.558418e+0549.81461408.751744.2712
47485.042406.510.3215063.22531.055941e+0699.73152854.702838.0020
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ], + "source": [ + "# We will select 5000 row at random for faster computing\n", + "# Also we will reset the indexing of our data and drop the old index\n", + "df = df.sample(5000, random_state = 42).reset_index(drop = True)\n", + "\n", + "# View the top 5 records of the dataset\n", + "df.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b022f9d-207c-4cfc-a0a2-611fe0175fef", + "metadata": { + "id": "8b022f9d-207c-4cfc-a0a2-611fe0175fef", + "outputId": "5cac6049-0ece-4c2b-de67-ca7bcf54b128", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(5000, 9)" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ], + "source": [ + "# View the shape of data\n", + "df.shape" + ] + }, + { + "cell_type": "markdown", + "id": "a9e379d5-cfc6-41f5-9d61-116c638648c0", + "metadata": { + "id": "a9e379d5-cfc6-41f5-9d61-116c638648c0" + }, + "source": [ + "## **Clustering - 3 Principal Components**" + ] + }, + { + "cell_type": "markdown", + "id": "850360bf-84ae-425a-951a-27ee109edd6d", + "metadata": { + "id": "850360bf-84ae-425a-951a-27ee109edd6d" + }, + "source": [ + "### **Dimensionality Reduction - PCA**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40ada939-dbb0-40ea-81d8-7db97b9734e9", + "metadata": { + "id": "40ada939-dbb0-40ea-81d8-7db97b9734e9" + }, + "outputs": [], + "source": [ + "# Import PCA for dimensionality reduction\n", + "from sklearn.decomposition import PCA\n", + "\n", + "# Initialize PCA with 3 principal components\n", + "pca_3_components = PCA(n_components=3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6747022-e0f3-4445-984b-a2ba412b2ad6", + "metadata": { + "id": "f6747022-e0f3-4445-984b-a2ba412b2ad6", + "outputId": "362eb39f-2183-4919-9c6f-b7b74f167751", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[-3.79677868e+05, -5.93361735e+02, -4.57623283e+02],\n", + " [ 1.96068326e+05, 1.03476770e+03, 1.37032463e+03],\n", + " [-1.09728677e+05, -1.08318535e+02, 3.86344448e+01],\n", + " ...,\n", + " [ 8.22121799e+05, -8.47540979e+02, 5.34043740e+02],\n", + " [ 1.10408081e+04, -9.16724427e+02, 1.95192236e+02],\n", + " [ 8.93764571e+05, -1.68176374e+02, -1.47018428e+02]])" + ] + }, + "metadata": {}, + "execution_count": 48 + } + ], + "source": [ + "# Get the decomposed data with 3 components\n", + "df_3_components = pca_3_components.fit_transform(df)\n", + "# View the data\n", + "df_3_components" + ] + }, + { + "cell_type": "markdown", + "id": "5912b255-e878-40af-9aa3-6edffd63c112", + "metadata": { + "id": "5912b255-e878-40af-9aa3-6edffd63c112" + }, + "source": [ + "### **Plotting Decomposed Data**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aad931fe-e384-4001-8193-6e1d73bbf912", + "metadata": { + "id": "aad931fe-e384-4001-8193-6e1d73bbf912" + }, + "outputs": [], + "source": [ + "# Import plotly for interactive plots\n", + "import plotly.express as px\n", + "import plotly.graph_objects as go" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66f3de4b-8abf-4d35-b727-b0bfe13377ab", + "metadata": { + "id": "66f3de4b-8abf-4d35-b727-b0bfe13377ab", + "outputId": "1ce9b24b-dfbf-41a9-e277-4792c1eac146", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 517 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + "\n", + "" + ] + }, + "metadata": {} + } + ], + "source": [ + "# Build the plot\n", + "fig = px.scatter_3d(\n", + " x = df_3_components[:, 0],\n", + " y = df_3_components[:, 1],\n", + " z = df_3_components[:, 2],\n", + ")\n", + "\n", + "# Customizing the plot\n", + "fig.update_layout(\n", + " title = \"PCA - 3D Visualization\",\n", + " width = 700,\n", + " height = 500,\n", + ")\n", + "\n", + "# Show the figure\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9f0ee778-46ea-4807-813b-7a758ef305d4", + "metadata": { + "id": "9f0ee778-46ea-4807-813b-7a758ef305d4" + }, + "source": [ + "### **Finding Optimal Clusters**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d2993e1-27ef-4991-ae57-a5d78827ff2f", + "metadata": { + "id": "8d2993e1-27ef-4991-ae57-a5d78827ff2f" + }, + "outputs": [], + "source": [ + "# Install `yellowbrick` for finding optimal cluster value\n", + "!pip install yellowbrick --quiet\n", + "\n", + "# Import KElbowVisualizer for ploting elbow method\n", + "from yellowbrick.cluster import KElbowVisualizer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8ff90f8-adc0-4a05-bfc2-b10539fcb601", + "metadata": { + "id": "c8ff90f8-adc0-4a05-bfc2-b10539fcb601" + }, + "outputs": [], + "source": [ + "# Import KMeans from scikit-learn\n", + "from sklearn.cluster import KMeans\n", + "\n", + "# Initialize KMeans model\n", + "kmeans_model = KMeans(n_init = \"auto\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0fcf8f3a-df06-4d5a-8bfe-7587f3de58de", + "metadata": { + "id": "0fcf8f3a-df06-4d5a-8bfe-7587f3de58de", + "outputId": "2d6f4e53-b477-4904-9411-d5ad4fb1bba8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 541 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 53 + } + ], + "source": [ + "# Initialize KElbowVisualizer with the model\n", + "visualizer = KElbowVisualizer(kmeans_model, k = (2, 10))\n", + "\n", + "# Train the visualizer with the data\n", + "visualizer.fit(df_3_components)\n", + "\n", + "# Plot the elbow plot\n", + "visualizer.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3a934a6b-58e9-4d15-b843-ce2b47e41cbd", + "metadata": { + "id": "3a934a6b-58e9-4d15-b843-ce2b47e41cbd" + }, + "source": [ + "### **Clustering**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a48f4ac0-ba69-4726-9189-adf59784a816", + "metadata": { + "id": "a48f4ac0-ba69-4726-9189-adf59784a816" + }, + "outputs": [], + "source": [ + "# Initialize KMeans model with optimal clusters\n", + "kmeans_model = KMeans(n_clusters = 4, n_init = \"auto\")\n", + "\n", + "# Train the KMeans model and get the predicted cluster labels for the data\n", + "df_3_components_labels = kmeans_model.fit_predict(df_3_components)" + ] + }, + { + "cell_type": "markdown", + "id": "c1d54d85-a260-4398-993b-5e5c1ae01203", + "metadata": { + "id": "c1d54d85-a260-4398-993b-5e5c1ae01203" + }, + "source": [ + "### **Plotting Clustered Data**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99313a97-81fd-450f-84fb-ceb68df10092", + "metadata": { + "id": "99313a97-81fd-450f-84fb-ceb68df10092", + "outputId": "bf5944ff-46b6-45d2-e4ab-972ddd27f4d9", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 517 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + "\n", + "" + ] + }, + "metadata": {} + } + ], + "source": [ + "# Initialize figure\n", + "fig = go.Figure()\n", + "\n", + "# Add a trace for data points\n", + "fig.add_trace(\n", + " go.Scatter3d(\n", + " x = df_3_components[:, 0],\n", + " y = df_3_components[:, 1],\n", + " z = df_3_components[:, 2],\n", + " mode = \"markers\",\n", + " marker_color = df_3_components_labels,\n", + " marker = dict(\n", + " showscale = True,\n", + " size = 5\n", + " ),\n", + " )\n", + ")\n", + "\n", + "# Add trace for cluster center\n", + "fig.add_trace(\n", + " go.Scatter3d(\n", + " x = kmeans_model.cluster_centers_[:, 0],\n", + " y = kmeans_model.cluster_centers_[:, 1],\n", + " z = kmeans_model.cluster_centers_[:, 2],\n", + " mode = \"markers\",\n", + " marker_color = \"black\",\n", + " marker = dict(\n", + " showscale = True,\n", + " size = 20,\n", + " ),\n", + " )\n", + ")\n", + "\n", + "# Update figure layout\n", + "fig.update_layout(\n", + " title = \"PCA 3D - Clusted Data\",\n", + " width = 700,\n", + " height = 500,\n", + ")\n", + "\n", + "# Show the figure\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "id": "513259c8-a4d5-418a-ae18-faaf40a1da9c", + "metadata": { + "id": "513259c8-a4d5-418a-ae18-faaf40a1da9c" + }, + "source": [ + "## **Clustering - 2 Principal Components**" + ] + }, + { + "cell_type": "markdown", + "id": "42b22983-1fec-47f0-ab89-d1a2621a41cf", + "metadata": { + "id": "42b22983-1fec-47f0-ab89-d1a2621a41cf" + }, + "source": [ + "### **Dimensionality Reduction - PCA**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5a45a35-d14f-4fdd-9918-36237227ac79", + "metadata": { + "id": "d5a45a35-d14f-4fdd-9918-36237227ac79" + }, + "outputs": [], + "source": [ + "# Import PCA for dimensionality reduction\n", + "from sklearn.decomposition import PCA\n", + "\n", + "# Initialize PCA with 2 principal components\n", + "pca_2_components = PCA(n_components=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6c98907-bae2-44df-8446-e124192a758b", + "metadata": { + "id": "a6c98907-bae2-44df-8446-e124192a758b", + "outputId": "fdcbb725-fd1d-4b6f-9211-fadd310e1cae", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[-3.79677868e+05, -5.93361735e+02, -4.57623283e+02],\n", + " [ 1.96068326e+05, 1.03476770e+03, 1.37032463e+03],\n", + " [-1.09728677e+05, -1.08318535e+02, 3.86344448e+01],\n", + " ...,\n", + " [ 8.22121799e+05, -8.47540979e+02, 5.34043740e+02],\n", + " [ 1.10408081e+04, -9.16724427e+02, 1.95192236e+02],\n", + " [ 8.93764571e+05, -1.68176374e+02, -1.47018428e+02]])" + ] + }, + "metadata": {}, + "execution_count": 57 + } + ], + "source": [ + "# Get the decomposed data with 2 components\n", + "df_2_components = pca_3_components.fit_transform(df)\n", + "\n", + "# View the data\n", + "df_2_components" + ] + }, + { + "cell_type": "markdown", + "id": "4d83b9ec-8138-422f-bfac-4273b534dcfd", + "metadata": { + "id": "4d83b9ec-8138-422f-bfac-4273b534dcfd" + }, + "source": [ + "### **Plotting Decomposed Data**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29036ba6-6404-4286-8d5f-1761f87541d0", + "metadata": { + "id": "29036ba6-6404-4286-8d5f-1761f87541d0" + }, + "outputs": [], + "source": [ + "# Import plotly for interactive plots\n", + "import plotly.express as px\n", + "import plotly.graph_objects as go" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0eb6cd6-49e9-4c84-b2ed-9fdb12cb488e", + "metadata": { + "id": "d0eb6cd6-49e9-4c84-b2ed-9fdb12cb488e", + "outputId": "556aae7b-cc4d-4c8b-ee06-c9c4b39b8577", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 517 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + "\n", + "" + ] + }, + "metadata": {} + } + ], + "source": [ + "# Build the plot\n", + "fig = px.scatter(\n", + " x = df_2_components[:, 0],\n", + " y = df_2_components[:, 1],\n", + ")\n", + "\n", + "# Customizing the plot\n", + "fig.update_layout(\n", + " title = \"PCA - 2D Visualization\",\n", + " width = 700,\n", + " height = 500,\n", + ")\n", + "\n", + "# Show the figure\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c8015a4a-7eae-49b0-a704-65f0abd14814", + "metadata": { + "id": "c8015a4a-7eae-49b0-a704-65f0abd14814" + }, + "source": [ + "### **Finding Optimal Clusters**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e25aae2d-6298-4f05-b1a9-5191f0f2f1d0", + "metadata": { + "id": "e25aae2d-6298-4f05-b1a9-5191f0f2f1d0" + }, + "outputs": [], + "source": [ + "# Install `yellowbrick` for finding optimal cluster value\n", + "!pip install yellowbrick --quiet\n", + "\n", + "# Import KElbowVisualizer for ploting elbow method\n", + "from yellowbrick.cluster import KElbowVisualizer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46e75f99-3b77-4283-b593-172c6812ad99", + "metadata": { + "id": "46e75f99-3b77-4283-b593-172c6812ad99" + }, + "outputs": [], + "source": [ + "# Import KMeans from scikit-learn\n", + "from sklearn.cluster import KMeans\n", + "\n", + "# Initialize KMeans model\n", + "kmeans_model = KMeans(n_init = \"auto\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1a963bf-c07a-4a35-a480-5b72a6c35bd1", + "metadata": { + "id": "e1a963bf-c07a-4a35-a480-5b72a6c35bd1", + "outputId": "a3aacab8-2adb-4ca7-c563-263d9dcd8837", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 541 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 62 + } + ], + "source": [ + "# Initialize KElbowVisualizer with the model\n", + "visualizer = KElbowVisualizer(kmeans_model, k = (2, 10))\n", + "\n", + "# Train the visualizer with the data\n", + "visualizer.fit(df_2_components)\n", + "\n", + "# Plot the elbow plot\n", + "visualizer.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6d681265-7270-4c91-bee7-9548ca96b7e6", + "metadata": { + "id": "6d681265-7270-4c91-bee7-9548ca96b7e6" + }, + "source": [ + "### **Clustering**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6626d2d0-cc05-4f8e-b669-8dbdddcc46c6", + "metadata": { + "id": "6626d2d0-cc05-4f8e-b669-8dbdddcc46c6" + }, + "outputs": [], + "source": [ + "# Initialize KMeans model with optimal clusters\n", + "kmeans_model = KMeans(n_clusters = 4, n_init = \"auto\")\n", + "\n", + "# Train the KMeans model and get the predicted cluster labels for the data\n", + "df_2_components_labels = kmeans_model.fit_predict(df_2_components)" + ] + }, + { + "cell_type": "markdown", + "id": "05a974e5-82b4-40de-957e-a3b94ad2d8da", + "metadata": { + "id": "05a974e5-82b4-40de-957e-a3b94ad2d8da" + }, + "source": [ + "### **Plotting Clustering Data**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "957d6972-527b-42f6-be9e-1412358006f4", + "metadata": { + "id": "957d6972-527b-42f6-be9e-1412358006f4", + "outputId": "e1bc0284-d78a-4a5a-e25a-61a6becfc245", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 517 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + "\n", + "" + ] + }, + "metadata": {} + } + ], + "source": [ + "# Initialize figure\n", + "fig = go.Figure()\n", + "\n", + "# Add a trace for data points\n", + "fig.add_trace(\n", + " go.Scatter(\n", + " x = df_2_components[:, 0],\n", + " y = df_2_components[:, 1],\n", + " mode = \"markers\",\n", + " marker_color = df_2_components_labels,\n", + " marker = dict(\n", + " showscale = True,\n", + " size = 5\n", + " ),\n", + " )\n", + ")\n", + "\n", + "# Add trace for cluster center\n", + "fig.add_trace(\n", + " go.Scatter(\n", + " x = kmeans_model.cluster_centers_[:, 0],\n", + " y = kmeans_model.cluster_centers_[:, 1],\n", + " mode = \"markers\",\n", + " marker_color = \"black\",\n", + " marker = dict(\n", + " showscale = True,\n", + " size = 20,\n", + " ),\n", + " )\n", + ")\n", + "\n", + "# Update figure layout\n", + "fig.update_layout(\n", + " title = \"PCA 2D - Clusted Data\",\n", + " width = 700,\n", + " height = 500,\n", + ")\n", + "\n", + "# Show the figure\n", + "fig.show()" + ] + } + ], + "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.10.12" + }, + "colab": { + "provenance": [] + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/Day-4/Submission/Priya Mohankar .ipynb b/Day-4/Submission/Priya Mohankar .ipynb new file mode 100644 index 0000000..c06708f --- /dev/null +++ b/Day-4/Submission/Priya Mohankar .ipynb @@ -0,0 +1,1947 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "cd4408fec38b4cd58bbdf75169635baa": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_dd11204366dc458fbbbf6a551aeb8fb5", + "IPY_MODEL_162f80cf3c4c4fd2adfe1e4bf10ed33d", + "IPY_MODEL_e667f35cb351432abe7cba1bdc6c51fd" + ], + "layout": "IPY_MODEL_e893b2ce1cad4bbd969bec2a03f954b9" + } + }, + "dd11204366dc458fbbbf6a551aeb8fb5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3f491d27aedd40169512b7f114e854cd", + "placeholder": "​", + "style": "IPY_MODEL_0c50ecb56e7349bdbdda4ad02f4922b5", + "value": "Processing: 100%" + } + }, + "162f80cf3c4c4fd2adfe1e4bf10ed33d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_79bddc6d4e2a48e5be2e6bf081da9cf4", + "max": 81, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_509c2bbbf818486ca41fcc476dc13bc0", + "value": 81 + } + }, + "e667f35cb351432abe7cba1bdc6c51fd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_46aada310d3541e39661f84fc6b4d002", + "placeholder": "​", + "style": "IPY_MODEL_432a0dee68ec4a7fb281bf9a63858c97", + "value": " 81/81 [00:32<00:00, 2.89it/s]" + } + }, + "e893b2ce1cad4bbd969bec2a03f954b9": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3f491d27aedd40169512b7f114e854cd": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c50ecb56e7349bdbdda4ad02f4922b5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "79bddc6d4e2a48e5be2e6bf081da9cf4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "509c2bbbf818486ca41fcc476dc13bc0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "46aada310d3541e39661f84fc6b4d002": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "432a0dee68ec4a7fb281bf9a63858c97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e6f4de1b663f4d08a7cf9458002de81a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8ae78bebcd9f4f1c8fc0e048594f0d33", + "IPY_MODEL_77c506f32b6f4e92ab4213d77bfa07ee", + "IPY_MODEL_ed372efbd151430f82fbaf35db71d1ac" + ], + "layout": "IPY_MODEL_7735d98e67b849d3b091c4966b3086c2" + } + }, + "8ae78bebcd9f4f1c8fc0e048594f0d33": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3373e4c35c884db8addf92400b412d03", + "placeholder": "​", + "style": "IPY_MODEL_b81f3f537e874ae2a27dda7bb339e989", + "value": "Processing: 100%" + } + }, + "77c506f32b6f4e92ab4213d77bfa07ee": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_60645dd8895b4e228a533ba20a82a288", + "max": 7, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7099154a923c4240a9367eb2bb475206", + "value": 7 + } + }, + "ed372efbd151430f82fbaf35db71d1ac": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_fdea54d07e3645d9a5bc9c9d7ba63d0c", + "placeholder": "​", + "style": "IPY_MODEL_46e5126a6db64a8f9654aac0b8da9e9c", + "value": " 7/7 [00:11<00:00, 1.30s/it]" + } + }, + "7735d98e67b849d3b091c4966b3086c2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": null + } + }, + "3373e4c35c884db8addf92400b412d03": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b81f3f537e874ae2a27dda7bb339e989": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "60645dd8895b4e228a533ba20a82a288": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7099154a923c4240a9367eb2bb475206": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "fdea54d07e3645d9a5bc9c9d7ba63d0c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "46e5126a6db64a8f9654aac0b8da9e9c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6_rhnXkbMqmi", + "outputId": "bca90403-7299-44e8-bc65-5ddba96f702c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting pycaret\n", + " Downloading pycaret-3.0.4-py3-none-any.whl (484 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m484.4/484.4 kB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: ipython>=5.5.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (7.34.0)\n", + "Requirement already satisfied: ipywidgets>=7.6.5 in /usr/local/lib/python3.10/dist-packages (from pycaret) (7.7.1)\n", + "Requirement already satisfied: tqdm>=4.62.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (4.66.1)\n", + "Requirement already satisfied: numpy<1.24,>=1.21 in /usr/local/lib/python3.10/dist-packages (from pycaret) (1.23.5)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.3.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (1.5.3)\n", + "Requirement already satisfied: jinja2>=1.2 in /usr/local/lib/python3.10/dist-packages (from pycaret) (3.1.2)\n", + "Requirement already satisfied: scipy<2.0.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (1.10.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (1.3.2)\n", + "Requirement already satisfied: scikit-learn<1.3.0,>=1.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (1.2.2)\n", + "Collecting pyod>=1.0.8 (from pycaret)\n", + " Downloading pyod-1.1.0.tar.gz (153 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m153.4/153.4 kB\u001b[0m \u001b[31m17.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: imbalanced-learn>=0.8.1 in /usr/local/lib/python3.10/dist-packages (from pycaret) (0.10.1)\n", + "Collecting category-encoders>=2.4.0 (from pycaret)\n", + " Downloading category_encoders-2.6.2-py2.py3-none-any.whl (81 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m81.8/81.8 kB\u001b[0m \u001b[31m9.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: lightgbm>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (4.0.0)\n", + "Requirement already satisfied: numba>=0.55.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (0.56.4)\n", + "Requirement already satisfied: requests>=2.27.1 in /usr/local/lib/python3.10/dist-packages (from pycaret) (2.31.0)\n", + "Requirement already satisfied: psutil>=5.9.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (5.9.5)\n", + "Requirement already satisfied: markupsafe>=2.0.1 in /usr/local/lib/python3.10/dist-packages (from pycaret) (2.1.3)\n", + "Requirement already satisfied: importlib-metadata>=4.12.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (6.8.0)\n", + "Requirement already satisfied: nbformat>=4.2.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (5.9.2)\n", + "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.10/dist-packages (from pycaret) (2.2.1)\n", + "Collecting deprecation>=2.1.0 (from pycaret)\n", + " Downloading deprecation-2.1.0-py2.py3-none-any.whl (11 kB)\n", + "Collecting xxhash (from pycaret)\n", + " Downloading xxhash-3.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (194 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m20.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: matplotlib>=3.3.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (3.7.1)\n", + "Collecting scikit-plot>=0.3.7 (from pycaret)\n", + " Downloading scikit_plot-0.3.7-py3-none-any.whl (33 kB)\n", + "Requirement already satisfied: yellowbrick>=1.4 in /usr/local/lib/python3.10/dist-packages (from pycaret) (1.5)\n", + "Requirement already satisfied: plotly>=5.0.0 in /usr/local/lib/python3.10/dist-packages (from pycaret) (5.15.0)\n", + "Collecting kaleido>=0.2.1 (from pycaret)\n", + " Downloading kaleido-0.2.1-py2.py3-none-manylinux1_x86_64.whl (79.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.9/79.9 MB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting schemdraw==0.15 (from pycaret)\n", + " Downloading schemdraw-0.15-py3-none-any.whl (106 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m106.8/106.8 kB\u001b[0m \u001b[31m10.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting plotly-resampler>=0.8.3.1 (from pycaret)\n", + " Downloading plotly_resampler-0.9.1-py3-none-any.whl (73 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m73.4/73.4 kB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: statsmodels>=0.12.1 in /usr/local/lib/python3.10/dist-packages (from pycaret) (0.14.0)\n", + "Collecting sktime!=0.17.1,!=0.17.2,!=0.18.0,>=0.16.1 (from pycaret)\n", + " Downloading sktime-0.22.0-py3-none-any.whl (17.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m17.5/17.5 MB\u001b[0m \u001b[31m64.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting tbats>=1.1.3 (from pycaret)\n", + " Downloading tbats-1.1.3-py3-none-any.whl (44 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.0/44.0 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting pmdarima!=1.8.1,<3.0.0,>=1.8.0 (from pycaret)\n", + " Downloading pmdarima-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl (1.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m50.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting wurlitzer (from pycaret)\n", + " Downloading wurlitzer-3.0.3-py3-none-any.whl (7.3 kB)\n", + "Requirement already satisfied: patsy>=0.5.1 in /usr/local/lib/python3.10/dist-packages (from category-encoders>=2.4.0->pycaret) (0.5.3)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from deprecation>=2.1.0->pycaret) (23.1)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from imbalanced-learn>=0.8.1->pycaret) (3.2.0)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.10/dist-packages (from importlib-metadata>=4.12.0->pycaret) (3.16.2)\n", + "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (67.7.2)\n", + "Collecting jedi>=0.16 (from ipython>=5.5.0->pycaret)\n", + " Downloading jedi-0.19.0-py2.py3-none-any.whl (1.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m60.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: decorator in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (4.4.2)\n", + "Requirement already satisfied: pickleshare in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (0.7.5)\n", + "Requirement already satisfied: traitlets>=4.2 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (5.7.1)\n", + "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (3.0.39)\n", + "Requirement already satisfied: pygments in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (2.16.1)\n", + "Requirement already satisfied: backcall in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (0.2.0)\n", + "Requirement already satisfied: matplotlib-inline in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (0.1.6)\n", + "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.10/dist-packages (from ipython>=5.5.0->pycaret) (4.8.0)\n", + "Requirement already satisfied: ipykernel>=4.5.1 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=7.6.5->pycaret) (5.5.6)\n", + "Requirement already satisfied: ipython-genutils~=0.2.0 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=7.6.5->pycaret) (0.2.0)\n", + "Requirement already satisfied: widgetsnbextension~=3.6.0 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=7.6.5->pycaret) (3.6.5)\n", + "Requirement already satisfied: jupyterlab-widgets>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from ipywidgets>=7.6.5->pycaret) (3.0.8)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3.0->pycaret) (1.1.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3.0->pycaret) (0.11.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3.0->pycaret) (4.42.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3.0->pycaret) (1.4.4)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3.0->pycaret) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3.0->pycaret) (3.1.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib>=3.3.0->pycaret) (2.8.2)\n", + "Requirement already satisfied: fastjsonschema in /usr/local/lib/python3.10/dist-packages (from nbformat>=4.2.0->pycaret) (2.18.0)\n", + "Requirement already satisfied: jsonschema>=2.6 in /usr/local/lib/python3.10/dist-packages (from nbformat>=4.2.0->pycaret) (4.19.0)\n", + "Requirement already satisfied: jupyter-core in /usr/local/lib/python3.10/dist-packages (from nbformat>=4.2.0->pycaret) (5.3.1)\n", + "Requirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba>=0.55.0->pycaret) (0.39.1)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas<2.0.0,>=1.3.0->pycaret) (2023.3)\n", + "Requirement already satisfied: tenacity>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from plotly>=5.0.0->pycaret) (8.2.3)\n", + "Collecting dash<3.0.0,>=2.11.0 (from plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading dash-2.12.1-py3-none-any.whl (10.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.4/10.4 MB\u001b[0m \u001b[31m90.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting orjson<4.0.0,>=3.8.0 (from plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading orjson-3.9.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (139 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m139.9/139.9 kB\u001b[0m \u001b[31m12.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting trace-updater>=0.0.8 (from plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading trace_updater-0.0.9.1-py3-none-any.whl (185 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m185.2/185.2 kB\u001b[0m \u001b[31m16.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting tsdownsample==0.1.2 (from plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading tsdownsample-0.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.3/2.3 MB\u001b[0m \u001b[31m61.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: Cython!=0.29.18,!=0.29.31,>=0.29 in /usr/local/lib/python3.10/dist-packages (from pmdarima!=1.8.1,<3.0.0,>=1.8.0->pycaret) (0.29.36)\n", + "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from pmdarima!=1.8.1,<3.0.0,>=1.8.0->pycaret) (2.0.4)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from pyod>=1.0.8->pycaret) (1.16.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.27.1->pycaret) (3.2.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.27.1->pycaret) (3.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.27.1->pycaret) (2023.7.22)\n", + "Collecting scikit-base<0.6.0 (from sktime!=0.17.1,!=0.17.2,!=0.18.0,>=0.16.1->pycaret)\n", + " Downloading scikit_base-0.5.1-py3-none-any.whl (118 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m118.7/118.7 kB\u001b[0m \u001b[31m8.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: Flask<2.3.0,>=1.0.4 in /usr/local/lib/python3.10/dist-packages (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret) (2.2.5)\n", + "Collecting Werkzeug<2.3.0 (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading Werkzeug-2.2.3-py3-none-any.whl (233 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m233.6/233.6 kB\u001b[0m \u001b[31m19.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting dash-html-components==2.0.0 (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading dash_html_components-2.0.0-py3-none-any.whl (4.1 kB)\n", + "Collecting dash-core-components==2.0.0 (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading dash_core_components-2.0.0-py3-none-any.whl (3.8 kB)\n", + "Collecting dash-table==5.0.0 (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading dash_table-5.0.0-py3-none-any.whl (3.9 kB)\n", + "Requirement already satisfied: typing-extensions>=4.1.1 in /usr/local/lib/python3.10/dist-packages (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret) (4.7.1)\n", + "Collecting retrying (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading retrying-1.3.4-py3-none-any.whl (11 kB)\n", + "Collecting ansi2html (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret)\n", + " Downloading ansi2html-1.8.0-py3-none-any.whl (16 kB)\n", + "Requirement already satisfied: nest-asyncio in /usr/local/lib/python3.10/dist-packages (from dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret) (1.5.7)\n", + "Requirement already satisfied: jupyter-client in /usr/local/lib/python3.10/dist-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.5->pycaret) (6.1.12)\n", + "Requirement already satisfied: tornado>=4.2 in /usr/local/lib/python3.10/dist-packages (from ipykernel>=4.5.1->ipywidgets>=7.6.5->pycaret) (6.3.2)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.3 in /usr/local/lib/python3.10/dist-packages (from jedi>=0.16->ipython>=5.5.0->pycaret) (0.8.3)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6->nbformat>=4.2.0->pycaret) (23.1.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6->nbformat>=4.2.0->pycaret) (2023.7.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6->nbformat>=4.2.0->pycaret) (0.30.2)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6->nbformat>=4.2.0->pycaret) (0.9.2)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.10/dist-packages (from pexpect>4.3->ipython>=5.5.0->pycaret) (0.7.0)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.10/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=5.5.0->pycaret) (0.2.6)\n", + "Requirement already satisfied: notebook>=4.4.1 in /usr/local/lib/python3.10/dist-packages (from widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (6.5.5)\n", + "Requirement already satisfied: platformdirs>=2.5 in /usr/local/lib/python3.10/dist-packages (from jupyter-core->nbformat>=4.2.0->pycaret) (3.10.0)\n", + "Requirement already satisfied: itsdangerous>=2.0 in /usr/local/lib/python3.10/dist-packages (from Flask<2.3.0,>=1.0.4->dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret) (2.1.2)\n", + "Requirement already satisfied: click>=8.0 in /usr/local/lib/python3.10/dist-packages (from Flask<2.3.0,>=1.0.4->dash<3.0.0,>=2.11.0->plotly-resampler>=0.8.3.1->pycaret) (8.1.6)\n", + "Requirement already satisfied: pyzmq<25,>=17 in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (23.2.1)\n", + "Requirement already satisfied: argon2-cffi in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (23.1.0)\n", + "Requirement already satisfied: nbconvert>=5 in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (6.5.4)\n", + "Requirement already satisfied: Send2Trash>=1.8.0 in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.8.2)\n", + "Requirement already satisfied: terminado>=0.8.3 in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.17.1)\n", + "Requirement already satisfied: prometheus-client in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.17.1)\n", + "Requirement already satisfied: nbclassic>=0.4.7 in /usr/local/lib/python3.10/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.0.0)\n", + "Requirement already satisfied: jupyter-server>=1.8 in /usr/local/lib/python3.10/dist-packages (from nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.24.0)\n", + "Requirement already satisfied: notebook-shim>=0.2.3 in /usr/local/lib/python3.10/dist-packages (from nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.2.3)\n", + "Requirement already satisfied: lxml in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (4.9.3)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (4.11.2)\n", + "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (6.0.0)\n", + "Requirement already satisfied: defusedxml in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.7.1)\n", + "Requirement already satisfied: entrypoints>=0.2.2 in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.4)\n", + "Requirement already satisfied: jupyterlab-pygments in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.2.2)\n", + "Requirement already satisfied: mistune<2,>=0.8.1 in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.8.4)\n", + "Requirement already satisfied: nbclient>=0.5.0 in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.8.0)\n", + "Requirement already satisfied: pandocfilters>=1.4.1 in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.5.0)\n", + "Requirement already satisfied: tinycss2 in /usr/local/lib/python3.10/dist-packages (from nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.2.1)\n", + "Requirement already satisfied: argon2-cffi-bindings in /usr/local/lib/python3.10/dist-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (21.2.0)\n", + "Requirement already satisfied: anyio<4,>=3.1.0 in /usr/local/lib/python3.10/dist-packages (from jupyter-server>=1.8->nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (3.7.1)\n", + "Requirement already satisfied: websocket-client in /usr/local/lib/python3.10/dist-packages (from jupyter-server>=1.8->nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.6.1)\n", + "Requirement already satisfied: cffi>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.15.1)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.10/dist-packages (from beautifulsoup4->nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (2.4.1)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->nbconvert>=5->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (0.5.1)\n", + "Requirement already satisfied: sniffio>=1.1 in /usr/local/lib/python3.10/dist-packages (from anyio<4,>=3.1.0->jupyter-server>=1.8->nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.3.0)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio<4,>=3.1.0->jupyter-server>=1.8->nbclassic>=0.4.7->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (1.1.3)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.6.0->ipywidgets>=7.6.5->pycaret) (2.21)\n", + "Building wheels for collected packages: pyod\n", + " Building wheel for pyod (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for pyod: filename=pyod-1.1.0-py3-none-any.whl size=185329 sha256=a6e309f0efcea5dd4d88003a4c81b5df7ebaa2cdaee62dbf20df47b6b8c3494e\n", + " Stored in directory: /root/.cache/pip/wheels/36/8e/e2/e932956b10b843eb6be9eefa70b5c1bee7b561be14c423b136\n", + "Successfully built pyod\n", + "Installing collected packages: trace-updater, kaleido, dash-table, dash-html-components, dash-core-components, xxhash, wurlitzer, Werkzeug, tsdownsample, scikit-base, schemdraw, retrying, orjson, jedi, deprecation, ansi2html, sktime, scikit-plot, pyod, dash, pmdarima, plotly-resampler, category-encoders, tbats, pycaret\n", + " Attempting uninstall: Werkzeug\n", + " Found existing installation: Werkzeug 2.3.7\n", + " Uninstalling Werkzeug-2.3.7:\n", + " Successfully uninstalled Werkzeug-2.3.7\n", + "Successfully installed Werkzeug-2.2.3 ansi2html-1.8.0 category-encoders-2.6.2 dash-2.12.1 dash-core-components-2.0.0 dash-html-components-2.0.0 dash-table-5.0.0 deprecation-2.1.0 jedi-0.19.0 kaleido-0.2.1 orjson-3.9.5 plotly-resampler-0.9.1 pmdarima-2.0.3 pycaret-3.0.4 pyod-1.1.0 retrying-1.3.4 schemdraw-0.15 scikit-base-0.5.1 scikit-plot-0.3.7 sktime-0.22.0 tbats-1.1.3 trace-updater-0.0.9.1 tsdownsample-0.1.2 wurlitzer-3.0.3 xxhash-3.3.0\n" + ] + } + ], + "source": [ + "!pip install pycaret" + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.datasets import load_iris\n", + "iris = load_iris()" + ], + "metadata": { + "id": "JWYUnuO5NAlM" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "X = pd.DataFrame(iris.data, columns = iris.feature_names)\n", + "y = pd.Series(iris.target, name = 'Flower')\n", + "df = pd.concat([X,y],axis=1)" + ], + "metadata": { + "id": "AX_QtYX5OEwz" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 423 + }, + "id": "mcRWIWmXPokC", + "outputId": "3d3be764-8c12-4950-c4fe-c6f34c7fafc6" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm) \\\n", + "0 5.1 3.5 1.4 0.2 \n", + "1 4.9 3.0 1.4 0.2 \n", + "2 4.7 3.2 1.3 0.2 \n", + "3 4.6 3.1 1.5 0.2 \n", + "4 5.0 3.6 1.4 0.2 \n", + ".. ... ... ... ... \n", + "145 6.7 3.0 5.2 2.3 \n", + "146 6.3 2.5 5.0 1.9 \n", + "147 6.5 3.0 5.2 2.0 \n", + "148 6.2 3.4 5.4 2.3 \n", + "149 5.9 3.0 5.1 1.8 \n", + "\n", + " Flower \n", + "0 0 \n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + ".. ... \n", + "145 2 \n", + "146 2 \n", + "147 2 \n", + "148 2 \n", + "149 2 \n", + "\n", + "[150 rows x 5 columns]" + ], + "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", + "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)Flower
05.13.51.40.20
14.93.01.40.20
24.73.21.30.20
34.63.11.50.20
45.03.61.40.20
..................
1456.73.05.22.32
1466.32.55.01.92
1476.53.05.22.02
1486.23.45.42.32
1495.93.05.11.82
\n", + "

150 rows × 5 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from pycaret.regression import*\n", + "table = setup(data=df, target = 'Flower')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 645 + }, + "id": "ypbN15cPP6Ol", + "outputId": "391cdb94-9af7-4a7c-9390-8a15cabebd6f" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "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", + "
 DescriptionValue
0Session id6694
1TargetFlower
2Target typeRegression
3Original data shape(150, 5)
4Transformed data shape(150, 5)
5Transformed train set shape(105, 5)
6Transformed test set shape(45, 5)
7Numeric features4
8PreprocessTrue
9Imputation typesimple
10Numeric imputationmean
11Categorical imputationmode
12Fold GeneratorKFold
13Fold Number10
14CPU Jobs-1
15Use GPUFalse
16Log ExperimentFalse
17Experiment Namereg-default-name
18USI5319
\n" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "model = compare_models()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 645, + "referenced_widgets": [ + "cd4408fec38b4cd58bbdf75169635baa", + "dd11204366dc458fbbbf6a551aeb8fb5", + "162f80cf3c4c4fd2adfe1e4bf10ed33d", + "e667f35cb351432abe7cba1bdc6c51fd", + "e893b2ce1cad4bbd969bec2a03f954b9", + "3f491d27aedd40169512b7f114e854cd", + "0c50ecb56e7349bdbdda4ad02f4922b5", + "79bddc6d4e2a48e5be2e6bf081da9cf4", + "509c2bbbf818486ca41fcc476dc13bc0", + "46aada310d3541e39661f84fc6b4d002", + "432a0dee68ec4a7fb281bf9a63858c97" + ] + }, + "id": "Ne-RYiEnQTfu", + "outputId": "99cc0025-402f-404e-9396-c0bfb30c68ae" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 ModelMAEMSERMSER2RMSLEMAPETT (Sec)
knnK Neighbors Regressor0.07020.03430.14950.93200.06010.07250.1600
etExtra Trees Regressor0.07000.04100.15890.90990.06400.07290.2900
ridgeRidge Regression0.17450.05190.22090.90190.10170.17230.0680
brBayesian Ridge0.17510.05190.22080.90160.10230.17170.0720
huberHuber Regressor0.17530.05210.22110.90140.10220.17070.1470
lrLinear Regression0.17600.05180.22060.90130.10320.17100.0670
larLeast Angle Regression0.17600.05180.22060.90130.10320.17100.0840
rfRandom Forest Regressor0.06710.04530.15650.89920.06270.07070.3700
lightgbmLight Gradient Boosting Machine0.10700.04840.18880.89820.08040.10890.3430
xgboostExtreme Gradient Boosting0.07300.05290.17130.88390.06790.07790.1790
adaAdaBoost Regressor0.07110.05770.18120.87830.07330.08240.1460
ompOrthogonal Matching Pursuit0.20330.07050.26090.87260.11120.20640.0770
gbrGradient Boosting Regressor0.08600.06150.19360.86340.08110.08940.1630
dtDecision Tree Regressor0.05820.05820.14970.85880.06080.06390.1100
parPassive Aggressive Regressor0.28650.14250.35660.75600.16720.22770.0720
enElastic Net0.38690.19610.43590.68410.25240.21320.0670
lassoLasso Regression0.53160.40140.62500.35480.36260.23250.0740
llarLasso Least Angle Regression0.53160.40140.62500.35480.36260.23250.0770
dummyDummy Regressor0.66770.66490.8080-0.08630.45720.25990.0830
\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Processing: 0%| | 0/81 [00:00" + ], + "text/html": [] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "tuned_model = tune_model(model)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 474, + "referenced_widgets": [ + "e6f4de1b663f4d08a7cf9458002de81a", + "8ae78bebcd9f4f1c8fc0e048594f0d33", + "77c506f32b6f4e92ab4213d77bfa07ee", + "ed372efbd151430f82fbaf35db71d1ac", + "7735d98e67b849d3b091c4966b3086c2", + "3373e4c35c884db8addf92400b412d03", + "b81f3f537e874ae2a27dda7bb339e989", + "60645dd8895b4e228a533ba20a82a288", + "7099154a923c4240a9367eb2bb475206", + "fdea54d07e3645d9a5bc9c9d7ba63d0c", + "46e5126a6db64a8f9654aac0b8da9e9c" + ] + }, + "id": "gmhqkRQXQr9s", + "outputId": "cd444848-d737-4b5f-f0f2-f74a5cd7826b" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 MAEMSERMSER2RMSLEMAPE
Fold      
00.06010.01680.12950.98150.04560.0551
10.14900.05180.22760.88390.09590.1486
20.03570.00530.07280.99240.02690.0305
30.02500.00690.08300.99010.02900.0229
40.16100.06570.25620.88320.10220.1374
50.02040.00420.06460.99450.02230.0146
60.00710.00050.02250.99920.01100.0142
70.07670.03300.18160.88620.08070.0852
80.08650.02700.16440.95570.06460.1279
90.14770.10580.32530.81100.13270.1648
Mean0.07690.03170.15280.93780.06110.0801
Std0.05490.03220.09140.06290.03860.0570
\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Processing: 0%| | 0/7 [00:00" + ], + "text/html": [] + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file