diff --git a/.gitignore b/.gitignore index 295f9e6..4493311 100644 --- a/.gitignore +++ b/.gitignore @@ -178,3 +178,4 @@ Cargo.lock *.csv +.vscode/* diff --git a/python/Assignment_tutorial_4.ipynb b/python/Assignment_tutorial_4.ipynb index 6dd8a77..36755a0 100644 --- a/python/Assignment_tutorial_4.ipynb +++ b/python/Assignment_tutorial_4.ipynb @@ -1,260 +1,826 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "1k2vhsMVv0Pk" + }, + "source": [ + "# Tutorial 4 Assignment - Logistic Regression\n", + "\n", + "We have provided you with a preprocessed dataset, the first cell will load and set everything up for you.\n", + "The objectives for you to complete are as follows:\n", + "1. Code up the commented functions on your own.\n", + "2. Every step that you must code are explained as comments, use them as hints.\n", + "\n", + "The last cell has the code set up for training the model. We expect each one to have trained the model, and note down the best accuracy that they can achieve, and the conditions required to do the same." + ] }, - "cells": [ + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nj3rHkttqucf", + "outputId": "0ff8d346-148a-4dd9-df8c-4696d2a002c3" + }, + "outputs": [], + "source": [ + "# !wget -O rainDataset.csv \"https://docs.google.com/spreadsheets/d/1RNtDIvisrnOmjJxS7aPm-45NtOH3qd5-mgd2bHeSOGA/export?format=csv&gid=1727131321\"\n", + "import pandas as pd\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.model_selection import train_test_split\n", + "import numpy as np\n", + "import math\n", + "import matplotlib.pyplot as plt\n", + "df=pd.read_csv('rainDataset.csv')\n", + "%matplotlib inline\n", + "df.head()\n", + "X = df.drop(['RainTomorrow'], axis=1)\n", + "y = df['RainTomorrow']\n", + "scaler = StandardScaler()\n", + "X_scaled = scaler.fit_transform(X)\n", + "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42, stratify=y)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kiZ4TBA6wFea" + }, + "source": [ + "# CODE BELOW" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "2A-RJ6Rscyoa" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "def sigmoid(z):\n", + " \"\"\"\n", + " Compute the sigmoid function.\n", + "\n", + " Parameters:\n", + " z : numpy array\n", + " Linear combination of weights and input features.\n", + "\n", + " Returns:\n", + " numpy array\n", + " Sigmoid of input z.\n", + " \"\"\"\n", + " return 1 / (1 + math.e**(-z))\n", + "\n", + "def initialize_weights(n_features):\n", + " \"\"\"\n", + " Initialize weights and bias to zero.\n", + "\n", + " Parameters:\n", + " n_features : int\n", + " Number of features in the dataset.\n", + "\n", + " Returns:\n", + " tuple\n", + " Initialized weights and bias.\n", + " \"\"\"\n", + " # initialize the weights and bias to zero (hint: make sure dimentions are correct)\n", + " w = np.zeros(n_features)\n", + " b = np.array([0])\n", + " return w, b\n", + "\n", + "def compute_cost(y, y_pred):\n", + " \"\"\"\n", + " Compute the cost function for logistic regression.\n", + "\n", + " Parameters:\n", + " y : numpy array\n", + " Actual labels.\n", + " y_pred : numpy array\n", + " Predicted probabilities.\n", + "\n", + " Returns:\n", + " float\n", + " The cost value.\n", + " \"\"\"\n", + " # compute the cost\n", + " # Cross Entropy Loss:\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + " return cost\n", + "\n", + "def compute_gradients(X, y, y_pred):\n", + " \"\"\"\n", + " Compute the gradients for weights and bias.\n", + "\n", + " Parameters:\n", + " X : numpy array\n", + " Feature matrix.\n", + " y : numpy array\n", + " Actual labels.\n", + " y_pred : numpy array\n", + " Predicted probabilities.\n", + "\n", + " Returns:\n", + " tuple\n", + " Gradients of weights and bias.\n", + " \"\"\"\n", + " m = X.shape[0]\n", + "\n", + " # compute dw\n", + " dw = np.mean(np.dot(X.T, (y-y_pred)))\n", + " # compute db\n", + " db = np.mean(y-y_pred)\n", + " return dw, db\n", + "\n", + "\n", + "def optimize(X, y, weights, bias, learning_rate, num_iterations):\n", + " \"\"\"\n", + " Perform gradient descent to optimize weights and bias.\n", + "\n", + " Parameters:\n", + " X : numpy array\n", + " Feature matrix.\n", + " y : numpy array\n", + " Actual labels.\n", + " weights : numpy array\n", + " Weights of the model.\n", + " bias : float\n", + " Bias of the model.\n", + " learning_rate : float\n", + " Learning rate for gradient descent.\n", + " num_iterations : int\n", + " Number of iterations for gradient descent.\n", + "\n", + " Returns:\n", + " tuple\n", + " Optimized weights, bias, and the list of costs.\n", + " \"\"\"\n", + " costs = []\n", + "\n", + " for i in range(num_iterations):\n", + " # Compute linear model\n", + " logits = computePred(X, weights, bias)\n", + " # Apply sigmoid function\n", + " yPred = sigmoid(logits)\n", + " # Compute cost\n", + " cost = compute_cost(y, yPred)\n", + " costs.append(cost)\n", + " # Compute gradients\n", + " dw, db = compute_gradients(X, y, yPred)\n", + " # Update weights and bias\n", + " weights = weights - learning_rate * dw\n", + " bias = bias - learning_rate * db\n", + " return weights, bias, costs\n", + "\n", + "def predict(X, weights, bias):\n", + " \"\"\"\n", + " Predict the binary labels for a dataset.\n", + "\n", + " Parameters:\n", + " X : numpy array\n", + " Feature matrix.\n", + " weights : numpy array\n", + " Weights of the model.\n", + " bias : float\n", + " Bias of the model.\n", + "\n", + " Returns:\n", + " numpy array\n", + " Predicted binary labels (0 or 1).\n", + " \"\"\"\n", + " z = computePred(X, weights, bias)\n", + " y_pred = sigmoid(z)\n", + " predictions = [1 if i > 0.5 else 0 for i in y_pred]\n", + " return np.array(predictions)\n", + "\n", + "def computePred(X, weights, bias):\n", + " return np.dot(X, weights) + bias" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "v9rwH83Rwrfk" + }, + "source": [ + "# COMPUTE ACCURACY" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "eyGEV4mWB-rW", + "scrolled": true + }, + "outputs": [ { - "cell_type": "markdown", - "source": [ - "# Tutorial 4 Assignment - Logistic Regression\n", - "\n", - "We have provided you with a preprocessed dataset, the first cell will load and set everything up for you.\n", - "The objectives for you to complete are as follows:\n", - "1. Code up the commented functions on your own.\n", - "2. Every step that you must code are explained as comments, use them as hints.\n", - "\n", - "The last cell has the code set up for training the model. We expect each one to have trained the model, and note down the best accuracy that they can achieve, and the conditions required to do the same." - ], - "metadata": { - "id": "1k2vhsMVv0Pk" - } + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n" + ] }, { - "cell_type": "code", - "source": [ - "!wget -O dataset.csv \"https://docs.google.com/spreadsheets/d/1RNtDIvisrnOmjJxS7aPm-45NtOH3qd5-mgd2bHeSOGA/export?format=csv&gid=1727131321\"\n", - "import pandas as pd\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "df=pd.read_csv('/content/dataset.csv')\n", - "\n", - "df.head()\n", - "X = df.drop(['RainTomorrow'], axis=1)\n", - "y = df['RainTomorrow']\n", - "scaler = StandardScaler()\n", - "X_scaled = scaler.fit_transform(X)\n", - "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42, stratify=y)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "nj3rHkttqucf", - "outputId": "0ff8d346-148a-4dd9-df8c-4696d2a002c3" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--2024-08-30 09:47:10-- https://docs.google.com/spreadsheets/d/1RNtDIvisrnOmjJxS7aPm-45NtOH3qd5-mgd2bHeSOGA/export?format=csv&gid=1727131321\n", - "Resolving docs.google.com (docs.google.com)... 74.125.132.138, 74.125.132.139, 74.125.132.113, ...\n", - "Connecting to docs.google.com (docs.google.com)|74.125.132.138|:443... connected.\n", - "HTTP request sent, awaiting response... 307 Temporary Redirect\n", - "Location: https://doc-00-c8-sheets.googleusercontent.com/export/54bogvaave6cua4cdnls17ksc4/p30qcagdcmtcqd8ure4jdd8ec0/1725011230000/112261653790527273724/*/1RNtDIvisrnOmjJxS7aPm-45NtOH3qd5-mgd2bHeSOGA?format=csv&gid=1727131321 [following]\n", - "Warning: wildcards not supported in HTTP.\n", - "--2024-08-30 09:47:10-- https://doc-00-c8-sheets.googleusercontent.com/export/54bogvaave6cua4cdnls17ksc4/p30qcagdcmtcqd8ure4jdd8ec0/1725011230000/112261653790527273724/*/1RNtDIvisrnOmjJxS7aPm-45NtOH3qd5-mgd2bHeSOGA?format=csv&gid=1727131321\n", - "Resolving doc-00-c8-sheets.googleusercontent.com (doc-00-c8-sheets.googleusercontent.com)... 74.125.201.132, 2607:f8b0:4001:c01::84\n", - "Connecting to doc-00-c8-sheets.googleusercontent.com (doc-00-c8-sheets.googleusercontent.com)|74.125.201.132|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: unspecified [text/csv]\n", - "Saving to: ‘dataset.csv’\n", - "\n", - "dataset.csv [ <=> ] 12.04M 5.00MB/s in 2.4s \n", - "\n", - "2024-08-30 09:47:17 (5.00 MB/s) - ‘dataset.csv’ saved [12621972]\n", - "\n" - ] - } - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.41052779633601744\n" + ] }, { - "cell_type": "markdown", - "source": [ - "# CODE BELOW" - ], - "metadata": { - "id": "kiZ4TBA6wFea" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "2A-RJ6Rscyoa" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "def sigmoid(z):\n", - " \"\"\"\n", - " Compute the sigmoid function.\n", - "\n", - " Parameters:\n", - " z : numpy array\n", - " Linear combination of weights and input features.\n", - "\n", - " Returns:\n", - " numpy array\n", - " Sigmoid of input z.\n", - " \"\"\"\n", - " pass\n", - "\n", - "def initialize_weights(n_features):\n", - " \"\"\"\n", - " Initialize weights and bias to zero.\n", - "\n", - " Parameters:\n", - " n_features : int\n", - " Number of features in the dataset.\n", - "\n", - " Returns:\n", - " tuple\n", - " Initialized weights and bias.\n", - " \"\"\"\n", - " # initialize the weights and bias to zero (hint: make sure dimentions are correct)\n", - "\n", - " return weights, bias\n", - "\n", - "def compute_cost(y, y_pred):\n", - " \"\"\"\n", - " Compute the cost function for logistic regression.\n", - "\n", - " Parameters:\n", - " y : numpy array\n", - " Actual labels.\n", - " y_pred : numpy array\n", - " Predicted probabilities.\n", - "\n", - " Returns:\n", - " float\n", - " The cost value.\n", - " \"\"\"\n", - " # compute the cost\n", - "\n", - " return cost\n", - "\n", - "def compute_gradients(X, y, y_pred):\n", - " \"\"\"\n", - " Compute the gradients for weights and bias.\n", - "\n", - " Parameters:\n", - " X : numpy array\n", - " Feature matrix.\n", - " y : numpy array\n", - " Actual labels.\n", - " y_pred : numpy array\n", - " Predicted probabilities.\n", - "\n", - " Returns:\n", - " tuple\n", - " Gradients of weights and bias.\n", - " \"\"\"\n", - " m = X.shape[0]\n", - "\n", - " # compute dw\n", - "\n", - " # compute db\n", - "\n", - " return dw, db\n", - "\n", - "\n", - "def optimize(X, y, weights, bias, learning_rate, num_iterations):\n", - " \"\"\"\n", - " Perform gradient descent to optimize weights and bias.\n", - "\n", - " Parameters:\n", - " X : numpy array\n", - " Feature matrix.\n", - " y : numpy array\n", - " Actual labels.\n", - " weights : numpy array\n", - " Weights of the model.\n", - " bias : float\n", - " Bias of the model.\n", - " learning_rate : float\n", - " Learning rate for gradient descent.\n", - " num_iterations : int\n", - " Number of iterations for gradient descent.\n", - "\n", - " Returns:\n", - " tuple\n", - " Optimized weights, bias, and the list of costs.\n", - " \"\"\"\n", - " costs = []\n", - "\n", - " for i in range(num_iterations):\n", - " # Compute linear model\n", - "\n", - " # Apply sigmoid function\n", - "\n", - " # Compute cost\n", - "\n", - " # Compute gradients\n", - "\n", - " # Update weights and bias\n", - " pass\n", - " return weights, bias, costs\n", - "\n", - "def predict(X, weights, bias):\n", - " \"\"\"\n", - " Predict the binary labels for a dataset.\n", - "\n", - " Parameters:\n", - " X : numpy array\n", - " Feature matrix.\n", - " weights : numpy array\n", - " Weights of the model.\n", - " bias : float\n", - " Bias of the model.\n", - "\n", - " Returns:\n", - " numpy array\n", - " Predicted binary labels (0 or 1).\n", - " \"\"\"\n", - " z = np.dot(X, weights) + bias\n", - " y_pred = sigmoid(z)\n", - " predictions = [1 if i > 0.5 else 0 for i in y_pred]\n", - " return np.array(predictions)\n" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# COMPUTE ACCURACY" - ], - "metadata": { - "id": "v9rwH83Rwrfk" - } - }, - { - "cell_type": "code", - "source": [ - "weights, bias,costs = optimize()\n", - "y_pred = predict(X_test,weights,bias)\n", - "matches = np.sum(y_test == y_pred)\n", - "mismatches = np.sum(y_test != y_pred)\n", - "print(f\"Accuracy: {matches/(matches+mismatches)}\")" - ], - "metadata": { - "id": "eyGEV4mWB-rW" - }, - "execution_count": null, - "outputs": [] + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n", + "/tmp/ipykernel_2559765/2227838026.py:50: RuntimeWarning: divide by zero encountered in log\n", + " cost = -np.mean(y * np.log(y_pred) + (1-y) * np.log((1-y_pred)))\n", + "/tmp/ipykernel_2559765/2227838026.py:15: RuntimeWarning: overflow encountered in power\n", + " return 1 / (1 + math.e**(-z))\n" + ] } - ] -} \ No newline at end of file + ], + "source": [ + "weights, bias = initialize_weights(len(X_train[0]))\n", + "weights, bias,costs = optimize(X_train, y_train, weights, bias, 0.01, 100)\n", + "y_pred = predict(X_test,weights,bias)\n", + "matches = np.sum(y_test == y_pred)\n", + "mismatches = np.sum(y_test != y_pred)\n", + "print(f\"Accuracy: {matches/(matches+mismatches)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(costs)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.6931471805599452,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf,\n", + " inf]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "costs" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/python/Tutorial_02.ipynb b/python/Tutorial_02.ipynb index 3e7485a..3a51185 100644 --- a/python/Tutorial_02.ipynb +++ b/python/Tutorial_02.ipynb @@ -1910,9 +1910,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "ai511", + "display_name": "Python 3 (ipykernel)", "language": "python", - "name": "ai511" + "name": "python3" }, "language_info": { "codemirror_mode": { diff --git a/python/Tutorial_03_Assignment.ipynb b/python/Tutorial_03_Assignment.ipynb index a72bf8c..508d895 100644 --- a/python/Tutorial_03_Assignment.ipynb +++ b/python/Tutorial_03_Assignment.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 41, "metadata": { "id": "mkIYsNGPtEfb" }, @@ -16,12 +16,12 @@ "from sklearn.metrics import mean_squared_error\n", "from sklearn.metrics import mean_absolute_error\n", "import matplotlib.pyplot as plt\n", - "import seaborn as sns" + "import seaborn as sns\n", + "from copy import deepcopy" ] }, { - "cell_type": "code", - "execution_count": 11, + "cell_type": "markdown", "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -29,31 +29,21 @@ "id": "ZazUCR02tMH0", "outputId": "4e3a1d0d-163b-41e2-d6f3-799556908a66" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "\u001b7\u001b[1A\u001b[1G\u001b[27G[Files: 0 Bytes: 0 [0 B/s] Re]\u001b8\u001b7\u001b[2A\u001b[1G\u001b[27G[https://docs.google.com/spread]\u001b8\u001b7\u001b[2A\u001b[1G0 files 100% [=============================>] 354 --.-KB/s\u001b8\u001b7\u001b[1A\u001b[1G\u001b[27G[Files: 0 Bytes: 354 [654 B/s]\u001b8\u001b7\u001b[2A\u001b[1G\u001b[27G[https://doc-08-1k-sheets.googl]\u001b8\u001b7\u001b[2A\u001b[1G0 files 100% [=============================>] 354 --.-KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [<=> ] 12.36K --.-KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 55.91K 348.35KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 123.69K 296.08KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 187.58K 349.73KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 283.42K 432.99KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 411.97K 532.09KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 583.28K 651.72KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 813.84K 800.67KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 1.11M 1001KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 1.24M 1008KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 1.40M 1.01MB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 1.51M 1.00MB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 1.61M 1012KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 0% [ <=> ] 1.73M 1006KB/s\u001b8\u001b7\u001b[2A\u001b[1GmuseumDataset.csv 100% [=============================>] 1.81M 1016KB/s\u001b8\u001b7\u001b[1A\u001b[1G\u001b[27G[Files: 1 Bytes: 1.81M [486.82]\u001b8\u001b[m\u001b[m\u001b[m\u001b[m" - ] - } - ], "source": [ "!wget -O museumDataset.csv \"https://docs.google.com/spreadsheets/d/1lS9HEz8FreAkCpR_w_ykAHy3oWeQBqiuc_RJyr3dfbE/export?format=csv&gid=1322780754\"" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 89, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 930 }, "id": "jxUFPkPs8oTT", - "outputId": "1b1b8c1a-4597-4738-a79c-dc7615e4cecc" + "outputId": "1b1b8c1a-4597-4738-a79c-dc7615e4cecc", + "scrolled": true }, "outputs": [ { @@ -73,81 +63,66 @@ "33070 HISTORY MUSEUM \n", "33071 HISTORIC PRESERVATION \n", "\n", - " Zip Code (Administrative Location) City (Physical Location) \\\n", - "0 99502 NaN \n", - "1 99507 NaN \n", - "2 99611 NaN \n", - "3 99611 NaN \n", - "4 99503 NaN \n", - "... ... ... \n", - "33067 82801 SHERIDAN \n", - "33068 82001 CHEYENNE \n", - "33069 82072 NaN \n", - "33070 82003 CHEYENNE \n", - "33071 82190 NaN \n", + " State (Physical Location) Latitude Longitude Locale Code (NCES) \\\n", + "0 NaN 61.17925 -149.97254 1.0 \n", + "1 NaN 61.16890 -149.76708 4.0 \n", + "2 NaN 60.56149 -151.21598 3.0 \n", + "3 NaN 60.56280 -151.26597 3.0 \n", + "4 NaN 61.17925 -149.97254 1.0 \n", + "... ... ... ... ... \n", + "33067 WY 44.82345 -106.87592 4.0 \n", + "33068 WY 41.13941 -104.81813 1.0 \n", + "33069 NaN 41.32276 -105.57686 3.0 \n", + "33070 WY 41.13010 -104.81916 1.0 \n", + "33071 NaN 44.91303 -110.41584 4.0 \n", "\n", - " State (Physical Location) Zip Code (Physical Location) Latitude \\\n", - "0 NaN NaN 61.17925 \n", - "1 NaN NaN 61.16890 \n", - "2 NaN NaN 60.56149 \n", - "3 NaN NaN 60.56280 \n", - "4 NaN NaN 61.17925 \n", - "... ... ... ... \n", - "33067 WY 82801.0 44.82345 \n", - "33068 WY 82001.0 41.13941 \n", - "33069 NaN NaN 41.32276 \n", - "33070 WY 82003.0 41.13010 \n", - "33071 NaN NaN 44.91303 \n", + " County Code (FIPS) State Code (FIPS) Region Code (AAM) Tax Period \\\n", + "0 20.0 2.0 6 201312.0 \n", + "1 20.0 2.0 6 201312.0 \n", + "2 122.0 2.0 6 201312.0 \n", + "3 122.0 2.0 6 201412.0 \n", + "4 20.0 2.0 6 201312.0 \n", + "... ... ... ... ... \n", + "33067 33.0 56.0 5 NaN \n", + "33068 21.0 56.0 5 201404.0 \n", + "33069 1.0 56.0 5 201312.0 \n", + "33070 21.0 56.0 5 201309.0 \n", + "33071 29.0 56.0 5 201312.0 \n", "\n", - " Longitude Locale Code (NCES) County Code (FIPS) State Code (FIPS) \\\n", - "0 -149.97254 1.0 20.0 2.0 \n", - "1 -149.76708 4.0 20.0 2.0 \n", - "2 -151.21598 3.0 122.0 2.0 \n", - "3 -151.26597 3.0 122.0 2.0 \n", - "4 -149.97254 1.0 20.0 2.0 \n", - "... ... ... ... ... \n", - "33067 -106.87592 4.0 33.0 56.0 \n", - "33068 -104.81813 1.0 21.0 56.0 \n", - "33069 -105.57686 3.0 1.0 56.0 \n", - "33070 -104.81916 1.0 21.0 56.0 \n", - "33071 -110.41584 4.0 29.0 56.0 \n", + " Income Revenue \n", + "0 602912.0 550236.0 \n", + "1 1379576.0 1323742.0 \n", + "2 740030.0 729080.0 \n", + "3 0.0 0.0 \n", + "4 602912.0 550236.0 \n", + "... ... ... \n", + "33067 NaN NaN \n", + "33068 0.0 0.0 \n", + "33069 208508.0 83981.0 \n", + "33070 0.0 0.0 \n", + "33071 127496.0 126762.0 \n", "\n", - " Region Code (AAM) Tax Period Income Revenue \n", - "0 6 201312.0 602912.0 550236.0 \n", - "1 6 201312.0 1379576.0 1323742.0 \n", - "2 6 201312.0 740030.0 729080.0 \n", - "3 6 201412.0 0.0 0.0 \n", - "4 6 201312.0 602912.0 550236.0 \n", - "... ... ... ... ... \n", - "33067 5 NaN NaN NaN \n", - "33068 5 201404.0 0.0 0.0 \n", - "33069 5 201312.0 208508.0 83981.0 \n", - "33070 5 201309.0 0.0 0.0 \n", - "33071 5 201312.0 127496.0 126762.0 \n", - "\n", - "[33072 rows x 14 columns]\n" + "[33072 rows x 11 columns]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_79886/482214211.py:2: DtypeWarning: Columns (9,14,21) have mixed types. Specify dtype option on import or set low_memory=False.\n", + "/tmp/ipykernel_2545563/3140390142.py:2: DtypeWarning: Columns (9,14,21) have mixed types. Specify dtype option on import or set low_memory=False.\n", " df = pd.read_csv(file_path)\n" ] }, { "data": { "text/plain": [ - "Index(['Museum Type', 'Zip Code (Administrative Location)',\n", - " 'City (Physical Location)', 'State (Physical Location)',\n", - " 'Zip Code (Physical Location)', 'Latitude', 'Longitude',\n", + "Index(['Museum Type', 'State (Physical Location)', 'Latitude', 'Longitude',\n", " 'Locale Code (NCES)', 'County Code (FIPS)', 'State Code (FIPS)',\n", " 'Region Code (AAM)', 'Tax Period', 'Income', 'Revenue'],\n", " dtype='object')" ] }, - "execution_count": 14, + "execution_count": 89, "metadata": {}, "output_type": "execute_result" } @@ -155,7 +130,7 @@ "source": [ "file_path = 'museumDataset.csv'\n", "df = pd.read_csv(file_path)\n", - "for i in [\"Museum ID\", \"Museum Name\", \"Legal Name\", \"Alternate Name\", \"Institution Name\", \"Phone Number\", \"Employer ID Number\", \"Street Address (Administrative Location)\", \"Street Address (Physical Location)\", \"State (Administrative Location)\", \"City (Administrative Location)\"]:\n", + "for i in [\"Zip Code (Physical Location)\", \"Museum ID\", \"Museum Name\", \"Legal Name\", \"Alternate Name\", \"Institution Name\", \"Phone Number\", \"Employer ID Number\", \"Street Address (Administrative Location)\", \"Street Address (Physical Location)\", \"State (Administrative Location)\", \"City (Administrative Location)\", \"City (Physical Location)\", \"Zip Code (Administrative Location)\"]:\n", " df=df.drop(i, axis=1)\n", "print(df)\n", "df.columns" @@ -178,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 90, "metadata": {}, "outputs": [ { @@ -187,7 +162,7 @@ "array([5, 8, 9, 8, 5])" ] }, - "execution_count": 95, + "execution_count": 90, "metadata": {}, "output_type": "execute_result" } @@ -201,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 91, "metadata": { "id": "RSrcX_7N8Drv" }, @@ -212,13 +187,13 @@ "" ] }, - "execution_count": 3, + "execution_count": 91, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -256,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 92, "metadata": { "id": "yqWZAUjO9kRd" }, @@ -291,69 +266,62 @@ " \n", " \n", " 0\n", - " Zip Code (Physical Location)\n", - " 4.780564e+04\n", - " 47448.00000\n", - " 74743.00000\n", - " \n", - " \n", - " 1\n", " Latitude\n", " 3.892537e+01\n", " 39.83164\n", " 40.79792\n", " \n", " \n", - " 2\n", + " 1\n", " Longitude\n", " -9.081676e+01\n", " -86.77684\n", " -77.86267\n", " \n", " \n", - " 3\n", + " 2\n", " Locale Code (NCES)\n", " 2.505834e+00\n", " 2.00000\n", " 4.00000\n", " \n", " \n", - " 4\n", + " 3\n", " County Code (FIPS)\n", " 8.570193e+01\n", " 61.00000\n", " 1.00000\n", " \n", " \n", - " 5\n", + " 4\n", " State Code (FIPS)\n", " 2.906583e+01\n", " 29.00000\n", " 6.00000\n", " \n", " \n", - " 6\n", + " 5\n", " Region Code (AAM)\n", " 3.670083e+00\n", " 4.00000\n", " 4.00000\n", " \n", " \n", - " 7\n", + " 6\n", " Tax Period\n", " 2.013475e+05\n", " 201312.00000\n", " 201312.00000\n", " \n", " \n", - " 8\n", + " 7\n", " Income\n", " 1.069682e+08\n", " 8781.00000\n", " 0.00000\n", " \n", " \n", - " 9\n", + " 8\n", " Revenue\n", " 2.097605e+07\n", " 3307.00000\n", @@ -364,20 +332,19 @@ "" ], "text/plain": [ - " name mean median mode\n", - "0 Zip Code (Physical Location) 4.780564e+04 47448.00000 74743.00000\n", - "1 Latitude 3.892537e+01 39.83164 40.79792\n", - "2 Longitude -9.081676e+01 -86.77684 -77.86267\n", - "3 Locale Code (NCES) 2.505834e+00 2.00000 4.00000\n", - "4 County Code (FIPS) 8.570193e+01 61.00000 1.00000\n", - "5 State Code (FIPS) 2.906583e+01 29.00000 6.00000\n", - "6 Region Code (AAM) 3.670083e+00 4.00000 4.00000\n", - "7 Tax Period 2.013475e+05 201312.00000 201312.00000\n", - "8 Income 1.069682e+08 8781.00000 0.00000\n", - "9 Revenue 2.097605e+07 3307.00000 0.00000" + " name mean median mode\n", + "0 Latitude 3.892537e+01 39.83164 40.79792\n", + "1 Longitude -9.081676e+01 -86.77684 -77.86267\n", + "2 Locale Code (NCES) 2.505834e+00 2.00000 4.00000\n", + "3 County Code (FIPS) 8.570193e+01 61.00000 1.00000\n", + "4 State Code (FIPS) 2.906583e+01 29.00000 6.00000\n", + "5 Region Code (AAM) 3.670083e+00 4.00000 4.00000\n", + "6 Tax Period 2.013475e+05 201312.00000 201312.00000\n", + "7 Income 1.069682e+08 8781.00000 0.00000\n", + "8 Revenue 2.097605e+07 3307.00000 0.00000" ] }, - "execution_count": 4, + "execution_count": 92, "metadata": {}, "output_type": "execute_result" } @@ -439,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 93, "metadata": {}, "outputs": [], "source": [ @@ -454,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 94, "metadata": {}, "outputs": [ { @@ -462,7 +429,6 @@ "output_type": "stream", "text": [ "NaNs in df\n", - "Zip Code (Physical Location): 23851\n", "Latitude: 65\n", "Longitude: 65\n", "Locale Code (NCES): 77\n", @@ -481,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 95, "metadata": {}, "outputs": [ { @@ -489,7 +455,6 @@ "output_type": "stream", "text": [ "NaNs in df\n", - "Zip Code (Physical Location): 0\n", "Latitude: 0\n", "Longitude: 0\n", "Locale Code (NCES): 0\n", @@ -511,7 +476,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 96, "metadata": { "id": "B1aC4Lv--eqR" }, @@ -520,11 +485,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "['Museum Type', 'Zip Code (Administrative Location)', 'City (Physical Location)', 'State (Physical Location)']\n", - "9\n", - "15522\n", - "4481\n", - "52\n" + "Unique data points in Museum Type: 9\n", + "Unique data points in State (Physical Location): 52\n", + "['HISTORY MUSEUM', 'ZOO, AQUARIUM, OR WILDLIFE CONSERVATION', \"CHILDREN'S MUSEUM\", 'HISTORIC PRESERVATION', 'ART MUSEUM', 'SCIENCE & TECHNOLOGY MUSEUM OR PLANETARIUM', 'ARBORETUM, BOTANICAL GARDEN, OR NATURE CENTER', 'GENERAL MUSEUM', 'NATURAL HISTORY MUSEUM']\n", + "['HI', 'ND', 'WY', 'NM', 'CA', 'VA', 'IA', 'RI', 'MI', 'SC', 'NE', 'MA', 'AL', 'GA', 'WV', 'MN', 'NH', 'IL', 'PA', 'VT', nan, 'ID', 'SD', 'MD', 'DC', 'WI', 'MT', 'TN', 'DE', 'CT', 'NC', 'ME', 'LA', 'WA', 'AZ', 'AK', 'FL', 'MO', 'UT', 'CO', 'AR', 'KY', 'MS', 'NJ', 'OR', 'TX', 'KS', 'IN', 'NV', 'NY', 'OH', 'OK']\n" ] } ], @@ -534,46 +498,37 @@ "\n", "categoricalColumns= df.select_dtypes(include=[\"object\", \"category\"]).columns\n", "categoricalColumns=categoricalColumns.to_list()\n", - "print(categoricalColumns)\n", + "# print(categoricalColumns)\n", "\n", "for i in categoricalColumns:\n", " uniq = set(df[i])\n", - " print(len(uniq))" + " print(f\"Unique data points in {i}:\", len(uniq))\n", + "\n", + "for i in categoricalColumns:\n", + " res=[]\n", + " rowUniq = list(set(df[i]))\n", + " print(rowUniq)\n", + " rowLen = len(rowUniq)\n", + " for j in df[i]:\n", + " tempRow = deepcopy([0]*rowLen)\n", + " tempRow[rowUniq.index(j)]=1\n", + " res.append(tempRow)\n", + " df=df.drop(i, axis=1)\n", + " # print(len(res), len(res[0]))\n", + " res = pd.DataFrame(res, columns=rowUniq)\n", + " # print(res.head())\n", + " df = pd.concat([df, res], axis=1)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "_l2tFo0RBlZ9" - }, - "outputs": [], - "source": [ - "# Any other preprocessing...?\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 930 - }, - "id": "CdPfPeMg-gTG", - "outputId": "1554caf7-37c2-4135-bbdc-aeea16a7a9d2" - }, + "execution_count": 97, + "metadata": {}, "outputs": [ { "data": { - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "variable_name": "df" - }, "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" + "

33072 rows × 70 columns

\n", + "" ], "text/plain": [ - " Museum ID Museum Name \\\n", - "0 8400200098 ALASKA AVIATION HERITAGE MUSEUM \n", - "1 8400200117 ALASKA BOTANICAL GARDEN \n", - "2 8400200153 ALASKA CHALLENGER CENTER FOR SPACE SCIENCE TEC... \n", - "3 8400200143 ALASKA EDUCATORS HISTORICAL SOCIETY \n", - "4 8400200027 ALASKA HERITAGE MUSEUM \n", - "... ... ... \n", - "33067 8405600184 WYOMING STATE HISTORICAL SOCIETY \n", - "33068 8405600061 WYOMING STATE MUSEUM \n", - "33069 8405600158 WYOMING TERRITORIAL PARK HISTORIC ASSOCIATION \n", - "33070 8405600137 WYOMING TRANSPORTATION MUSEUM \n", - "33071 8405600199 YELLOWSTONE NATIONAL PARK \n", + " Latitude Longitude Locale Code (NCES) County Code (FIPS) \\\n", + "0 61.17925 -149.97254 1.0 20.0 \n", + "1 61.16890 -149.76708 4.0 20.0 \n", + "2 60.56149 -151.21598 3.0 122.0 \n", + "3 60.56280 -151.26597 3.0 122.0 \n", + "4 61.17925 -149.97254 1.0 20.0 \n", + "... ... ... ... ... \n", + "33067 44.82345 -106.87592 4.0 33.0 \n", + "33068 41.13941 -104.81813 1.0 21.0 \n", + "33069 41.32276 -105.57686 3.0 1.0 \n", + "33070 41.13010 -104.81916 1.0 21.0 \n", + "33071 44.91303 -110.41584 4.0 29.0 \n", "\n", - " Legal Name Alternate Name \\\n", - "0 ALASKA AVIATION HERITAGE MUSEUM NaN \n", - "1 ALASKA BOTANICAL GARDEN INC NaN \n", - "2 ALASKA CHALLENGER CENTER FOR SPACE SCIENCE TEC... NaN \n", - "3 ALASKA EDUCATORS HISTORICAL SOCIETY NaN \n", - "4 ALASKA AVIATION HERITAGE MUSEUM NaN \n", - "... ... ... \n", - "33067 WYOMING STATE HISTORICAL SOCIETY NaN \n", - "33068 WYOMING STATE MUSEUM VOLUNTEERS INC NaN \n", - "33069 WYOMING TERRITORIAL PARK HISTORIC ASSOCIATION INC NaN \n", - "33070 WYOMING TRANSPORTATION MUSEUM CORP NaN \n", - "33071 LITTLE PEOPLE LEARNING CENTER INC NaN \n", + " State Code (FIPS) Region Code (AAM) Tax Period Income \\\n", + "0 2.0 6 201312.000000 6.029120e+05 \n", + "1 2.0 6 201312.000000 1.379576e+06 \n", + "2 2.0 6 201312.000000 7.400300e+05 \n", + "3 2.0 6 201412.000000 0.000000e+00 \n", + "4 2.0 6 201312.000000 6.029120e+05 \n", + "... ... ... ... ... \n", + "33067 56.0 5 201347.458548 1.069682e+08 \n", + "33068 56.0 5 201404.000000 0.000000e+00 \n", + "33069 56.0 5 201312.000000 2.085080e+05 \n", + "33070 56.0 5 201309.000000 0.000000e+00 \n", + "33071 56.0 5 201312.000000 1.274960e+05 \n", "\n", - " Museum Type Institution Name \\\n", - "0 HISTORY MUSEUM NaN \n", - "1 ARBORETUM, BOTANICAL GARDEN, OR NATURE CENTER NaN \n", - "2 SCIENCE & TECHNOLOGY MUSEUM OR PLANETARIUM NaN \n", - "3 HISTORIC PRESERVATION NaN \n", - "4 HISTORY MUSEUM NaN \n", - "... ... ... \n", - "33067 HISTORIC PRESERVATION NaN \n", - "33068 GENERAL MUSEUM NaN \n", - "33069 HISTORIC PRESERVATION NaN \n", - "33070 HISTORY MUSEUM NaN \n", - "33071 HISTORIC PRESERVATION NaN \n", + " Revenue HISTORY MUSEUM ... MS NJ OR TX KS IN NV NY OH \\\n", + "0 5.502360e+05 1 ... 0 0 0 0 0 0 0 0 0 \n", + "1 1.323742e+06 0 ... 0 0 0 0 0 0 0 0 0 \n", + "2 7.290800e+05 0 ... 0 0 0 0 0 0 0 0 0 \n", + "3 0.000000e+00 0 ... 0 0 0 0 0 0 0 0 0 \n", + "4 5.502360e+05 1 ... 0 0 0 0 0 0 0 0 0 \n", + "... ... ... ... .. .. .. .. .. .. .. .. .. \n", + "33067 2.097605e+07 0 ... 0 0 0 0 0 0 0 0 0 \n", + "33068 0.000000e+00 0 ... 0 0 0 0 0 0 0 0 0 \n", + "33069 8.398100e+04 0 ... 0 0 0 0 0 0 0 0 0 \n", + "33070 0.000000e+00 1 ... 0 0 0 0 0 0 0 0 0 \n", + "33071 1.267620e+05 0 ... 0 0 0 0 0 0 0 0 0 \n", "\n", - " Street Address (Administrative Location) \\\n", - "0 4721 AIRCRAFT DR \n", - "1 4601 CAMPBELL AIRSTRIP RD \n", - "2 9711 KENAI SPUR HWY \n", - "3 214 BIRCH STREET \n", - "4 301 W NORTHERN LIGHTS BLVD \n", - "... ... \n", - "33067 PO BOX 73 \n", - "33068 2301 CENTRAL AVENUE \n", - "33069 1273 N 15TH ST STE 121 \n", - "33070 PO BOX 704 \n", - "33071 NATIONAL PARK SERVICE \n", + " OK \n", + "0 0 \n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "... .. \n", + "33067 0 \n", + "33068 0 \n", + "33069 0 \n", + "33070 0 \n", + "33071 0 \n", "\n", - " City (Administrative Location) State (Administrative Location) \\\n", - "0 153 0 \n", - "1 153 0 \n", - "2 3809 0 \n", - "3 3809 0 \n", - "4 153 0 \n", - "... ... ... \n", - "33067 7003 50 \n", - "33068 1323 50 \n", - "33069 4101 50 \n", - "33070 1323 50 \n", - "33071 8575 50 \n", - "\n", - " Zip Code (Administrative Location) ... Latitude Longitude \\\n", - "0 99502 ... 61.17925 -149.97254 \n", - "1 99507 ... 61.16890 -149.76708 \n", - "2 99611 ... 60.56149 -151.21598 \n", - "3 99611 ... 60.56280 -151.26597 \n", - "4 99503 ... 61.17925 -149.97254 \n", - "... ... ... ... ... \n", - "33067 82801 ... 44.82345 -106.87592 \n", - "33068 82001 ... 41.13941 -104.81813 \n", - "33069 82072 ... 41.32276 -105.57686 \n", - "33070 82003 ... 41.13010 -104.81916 \n", - "33071 82190 ... 44.91303 -110.41584 \n", - "\n", - " Locale Code (NCES) County Code (FIPS) State Code (FIPS) \\\n", - "0 1.0 20.0 2.0 \n", - "1 4.0 20.0 2.0 \n", - "2 3.0 122.0 2.0 \n", - "3 3.0 122.0 2.0 \n", - "4 1.0 20.0 2.0 \n", - "... ... ... ... \n", - "33067 4.0 33.0 56.0 \n", - "33068 1.0 21.0 56.0 \n", - "33069 3.0 1.0 56.0 \n", - "33070 1.0 21.0 56.0 \n", - "33071 4.0 29.0 56.0 \n", - "\n", - " Region Code (AAM) Employer ID Number Tax Period Income \\\n", - "0 6 920071852 201312.000000 6.029120e+05 \n", - "1 6 920115504 201312.000000 1.379576e+06 \n", - "2 6 921761906 201312.000000 7.400300e+05 \n", - "3 6 920165178 201412.000000 0.000000e+00 \n", - "4 6 920071852 201312.000000 6.029120e+05 \n", - "... ... ... ... ... \n", - "33067 5 836007540.0 201347.458548 1.069682e+08 \n", - "33068 5 237368629.0 201404.000000 0.000000e+00 \n", - "33069 5 830318392.0 201312.000000 2.085080e+05 \n", - "33070 5 830295570.0 201309.000000 0.000000e+00 \n", - "33071 5 830249072.0 201312.000000 1.274960e+05 \n", - "\n", - " Revenue \n", - "0 5.502360e+05 \n", - "1 1.323742e+06 \n", - "2 7.290800e+05 \n", - "3 0.000000e+00 \n", - "4 5.502360e+05 \n", - "... ... \n", - "33067 2.097605e+07 \n", - "33068 0.000000e+00 \n", - "33069 8.398100e+04 \n", - "33070 0.000000e+00 \n", - "33071 1.267620e+05 \n", - "\n", - "[33072 rows x 25 columns]" + "[33072 rows x 70 columns]" ] }, - "execution_count": 31, + "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Final dataset" + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": { + "id": "_l2tFo0RBlZ9" + }, + "outputs": [], + "source": [ + "# Any other preprocessing...?\n", + "\n", + "normilizingCols=[\"Income\", \"Tax Period\", \"Revenue\"]\n", + "for i in normilizingCols:\n", + " df[i] = 5*(df[i] - df[i].min())/(df[i].max() - df[i].min())" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 930 + }, + "id": "CdPfPeMg-gTG", + "outputId": "1554caf7-37c2-4135-bbdc-aeea16a7a9d2" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
LatitudeLongitudeLocale Code (NCES)County Code (FIPS)State Code (FIPS)Region Code (AAM)Tax PeriodIncomeRevenueHISTORY MUSEUM...MSNJORTXKSINNVNYOHOK
061.17925-149.972541.020.02.060.6007514.9999644.9977081...0000000000
161.16890-149.767084.020.02.060.6007514.9999174.9970470...0000000000
260.56149-151.215983.0122.02.060.6007514.9999554.9975550...0000000000
360.56280-151.265973.0122.02.060.2878605.0000004.9981790...0000000000
461.17925-149.972541.020.02.060.6007514.9999644.9977081...0000000000
..................................................................
3306744.82345-106.875924.033.056.050.4898044.9935704.9802280...0000000000
3306841.13941-104.818131.021.056.050.3128915.0000004.9981790...0000000000
3306941.32276-105.576863.01.056.050.6007514.9999874.9981080...0000000000
3307041.13010-104.819161.021.056.050.6101385.0000004.9981791...0000000000
3307144.91303-110.415844.029.056.050.6007514.9999924.9980710...0000000000
\n", + "

33072 rows × 70 columns

\n", + "
" + ], + "text/plain": [ + " Latitude Longitude Locale Code (NCES) County Code (FIPS) \\\n", + "0 61.17925 -149.97254 1.0 20.0 \n", + "1 61.16890 -149.76708 4.0 20.0 \n", + "2 60.56149 -151.21598 3.0 122.0 \n", + "3 60.56280 -151.26597 3.0 122.0 \n", + "4 61.17925 -149.97254 1.0 20.0 \n", + "... ... ... ... ... \n", + "33067 44.82345 -106.87592 4.0 33.0 \n", + "33068 41.13941 -104.81813 1.0 21.0 \n", + "33069 41.32276 -105.57686 3.0 1.0 \n", + "33070 41.13010 -104.81916 1.0 21.0 \n", + "33071 44.91303 -110.41584 4.0 29.0 \n", + "\n", + " State Code (FIPS) Region Code (AAM) Tax Period Income Revenue \\\n", + "0 2.0 6 0.600751 4.999964 4.997708 \n", + "1 2.0 6 0.600751 4.999917 4.997047 \n", + "2 2.0 6 0.600751 4.999955 4.997555 \n", + "3 2.0 6 0.287860 5.000000 4.998179 \n", + "4 2.0 6 0.600751 4.999964 4.997708 \n", + "... ... ... ... ... ... \n", + "33067 56.0 5 0.489804 4.993570 4.980228 \n", + "33068 56.0 5 0.312891 5.000000 4.998179 \n", + "33069 56.0 5 0.600751 4.999987 4.998108 \n", + "33070 56.0 5 0.610138 5.000000 4.998179 \n", + "33071 56.0 5 0.600751 4.999992 4.998071 \n", + "\n", + " HISTORY MUSEUM ... MS NJ OR TX KS IN NV NY OH OK \n", + "0 1 ... 0 0 0 0 0 0 0 0 0 0 \n", + "1 0 ... 0 0 0 0 0 0 0 0 0 0 \n", + "2 0 ... 0 0 0 0 0 0 0 0 0 0 \n", + "3 0 ... 0 0 0 0 0 0 0 0 0 0 \n", + "4 1 ... 0 0 0 0 0 0 0 0 0 0 \n", + "... ... ... .. .. .. .. .. .. .. .. .. .. \n", + "33067 0 ... 0 0 0 0 0 0 0 0 0 0 \n", + "33068 0 ... 0 0 0 0 0 0 0 0 0 0 \n", + "33069 0 ... 0 0 0 0 0 0 0 0 0 0 \n", + "33070 1 ... 0 0 0 0 0 0 0 0 0 0 \n", + "33071 0 ... 0 0 0 0 0 0 0 0 0 0 \n", + "\n", + "[33072 rows x 70 columns]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Final dataset\n", + "df" ] }, {