CaliforniaHousing.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/aiaaee/California_Housing/blob/main/CaliforniaHousing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 113,
      "metadata": {
        "id": "D2sE0Uiiyljx"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as f\n",
        "from torch.utils.data import Dataset , DataLoader\n",
        "import torch.optim as optim\n",
        "from sklearn.datasets import fetch_california_housing\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from torchvision import transforms\n",
        "from tqdm import tqdm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 114,
      "metadata": {
        "id": "lYpZoY-q1iKe"
      },
      "outputs": [],
      "source": [
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 115,
      "metadata": {
        "id": "D2tFM3Xi--mo"
      },
      "outputs": [],
      "source": [
        "data = fetch_california_housing()\n",
        "# In dataset as_frame is false . it means that we need to create Dataset and do data and target combination\n",
        "X, y = data.data, data.target\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "# Standardize the features\n",
        "scaler = StandardScaler()\n",
        "X_train = scaler.fit_transform(X_train)\n",
        "X_test = scaler.transform(X_test)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 116,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ljmQMXKwDGZY",
        "outputId": "e8b0fa6c-4c39-4e55-c63e-c430514ce8b4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(16512, 8) (16512,)\n",
            "(4128, 8) (4128,)\n"
          ]
        }
      ],
      "source": [
        "print(X_train.shape , y_train.shape)\n",
        "print(X_test.shape , y_test.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lruTIt2bG_uv",
        "outputId": "b000d641-b8da-4015-9985-8b74ace8b9d5"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-0.326196  ,  0.34849025, -0.17491646, ...,  0.05137609,\n",
              "        -1.3728112 ,  1.27258656],\n",
              "       [-0.03584338,  1.61811813, -0.40283542, ..., -0.11736222,\n",
              "        -0.87669601,  0.70916212],\n",
              "       [ 0.14470145, -1.95271028,  0.08821601, ..., -0.03227969,\n",
              "        -0.46014647, -0.44760309],\n",
              "       ...,\n",
              "       [-0.49697313,  0.58654547, -0.60675918, ...,  0.02030568,\n",
              "        -0.75500738,  0.59946887],\n",
              "       [ 0.96545045, -1.07984112,  0.40217517, ...,  0.00707608,\n",
              "         0.90651045, -1.18553953],\n",
              "       [-0.68544764,  1.85617335, -0.85144571, ..., -0.08535429,\n",
              "         0.99543676, -1.41489815]])"
            ]
          },
          "metadata": {},
          "execution_count": 117
        }
      ],
      "source": [
        "X_train"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 118,
      "metadata": {
        "id": "XUYhnB5YDOSd"
      },
      "outputs": [],
      "source": [
        "# Create a custom PyTorch dataset\n",
        "\n",
        "toTensorTransform = transforms.Lambda(lambda x: torch.tensor(x, dtype=torch.float32))\n",
        "class CaliforniaHousingDataset(Dataset):\n",
        "    def __init__(self, features, targets, transform=None, target_transform=None):\n",
        "        self.features = features\n",
        "        self.targets = targets\n",
        "        self.transform = transform\n",
        "        self.target_transform = target_transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.features)\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        x = self.features[index]\n",
        "        y = self.targets[index]\n",
        "        if self.transform:\n",
        "            x = self.transform(x)\n",
        "        if self.target_transform:\n",
        "            y = self.target_transform(y)\n",
        "        return x, y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 119,
      "metadata": {
        "id": "1qoNQVtEDtZa"
      },
      "outputs": [],
      "source": [
        "# Create instances of the custom dataset\n",
        "train_dataset = CaliforniaHousingDataset(X_train, y_train, transform=toTensorTransform,\n",
        "                                         target_transform=transforms.Lambda(lambda x: torch.tensor(x, dtype=torch.float32).unsqueeze(0)))\n",
        "\n",
        "test_dataset = CaliforniaHousingDataset(X_test, y_test, transform=toTensorTransform,\n",
        "                                        target_transform=transforms.Lambda(lambda x: torch.tensor(x, dtype=torch.float32).unsqueeze(0)))\n",
        "\n",
        "# Create PyTorch data loaders\n",
        "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 120,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l0TliIY9Fvp9",
        "outputId": "4c3b0e9a-38a0-40dc-8090-c8ec24bcf446"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([64, 1])\n"
          ]
        }
      ],
      "source": [
        "for data, target in train_loader:\n",
        "    print(target.size())\n",
        "    break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "id": "cPZY_RX7N2Ui"
      },
      "outputs": [],
      "source": [
        "class NeuralNet(nn.Module):\n",
        "  def __init__(self , input_feature , hidden_feature , output_feature , *args , **kwargs ):\n",
        "    super().__init__(*args , **kwargs )\n",
        "    self.flatten = nn.Flatten()\n",
        "    self.fc1 = nn.Linear(input_feature , hidden_feature)\n",
        "    self.r1 = nn.ReLU()\n",
        "    self.fc2 = nn.Linear(hidden_feature , hidden_feature)\n",
        "    self.r2 = nn.ReLU()\n",
        "    self.fc3 = nn.Linear(hidden_feature , output_feature)\n",
        "    self.r3 = nn.ReLU()\n",
        "\n",
        "\n",
        "  def forward(self , x ):\n",
        "      output = self.flatten(x)\n",
        "      output = self.r1(self.fc1(x))\n",
        "      output = self.r2(self.fc2(output))\n",
        "      return self.r3(self.fc3(output))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 122,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "01bcM0TBPhrB",
        "outputId": "694d58a0-de03-42ef-bfaf-552f9d9a7197"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "NeuralNet(\n",
              "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
              "  (fc1): Linear(in_features=8, out_features=200, bias=True)\n",
              "  (r1): ReLU()\n",
              "  (fc2): Linear(in_features=200, out_features=200, bias=True)\n",
              "  (r2): ReLU()\n",
              "  (fc3): Linear(in_features=200, out_features=1, bias=True)\n",
              "  (r3): ReLU()\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ],
      "source": [
        "model = NeuralNet(8 , 200 , 1 )\n",
        "model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {
        "id": "lb-ZTKy4sB8P"
      },
      "outputs": [],
      "source": [
        "criterion = nn.MSELoss()\n",
        "optimizer = optim.Adam(model.parameters() , lr=1e-3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BMk8bYjZs5Ju",
        "outputId": "d2ed6370-1467-4b1c-b79d-25c6d7da3b7a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": []
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [10/30]: loss train: 0.302, validation: 0.306\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": []
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [20/30]: loss train: 0.270, validation: 0.282\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": []
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [30/30]: loss train: 0.253, validation: 0.288\n"
          ]
        }
      ],
      "source": [
        "train_history = []\n",
        "validation_history = []\n",
        "num_epochs = 30\n",
        "for epoch in range(num_epochs):\n",
        "\n",
        "    model.train()\n",
        "    losses = []\n",
        "\n",
        "    with tqdm(train_loader, leave=False) as bar:\n",
        "        bar.set_description(f\"[Epoch: {epoch + 1}/{num_epochs}]\")\n",
        "\n",
        "        for batch_idx, (data, target) in enumerate(bar):\n",
        "\n",
        "            data = data.to(device)\n",
        "            target = target.to(device)\n",
        "\n",
        "            output = model(data)\n",
        "\n",
        "            loss = criterion(output, target)\n",
        "\n",
        "            optimizer.zero_grad()\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "            losses.append(loss.item())\n",
        "            bar.set_postfix(avg_epoch_loss=f\"{sum(losses)/len(losses):.4f}\")\n",
        "    train_history.append(sum(losses)/len(losses))\n",
        "\n",
        "    model.eval()\n",
        "    running_testloss = 0.0\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for i, (test_data, test_label) in enumerate(test_loader):\n",
        "            test_output = model(test_data)\n",
        "            vloss = criterion(test_output, test_label)\n",
        "            running_testloss += vloss.item()\n",
        "        avg_vloss = running_testloss / (i + 1)\n",
        "        validation_history.append(avg_vloss)\n",
        "        if epoch % 10 == 9:\n",
        "            print(f'Epoch [{epoch + 1}/{num_epochs}]: loss train: {sum(losses)/len(losses):.3f}, validation: {avg_vloss:.3f}')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "fig, ax = plt.subplots(figsize=(8, 5))\n",
        "ax.plot(train_history, label=\"train_loss\")\n",
        "ax.plot(validation_history, label=\"validation_loss\")\n",
        "ax.set_title(\"train vs validation loss\")\n",
        "ax.set_ylabel('Loss')\n",
        "ax.set_xlabel('epochs')\n",
        "ax.grid()\n",
        "ax.legend(loc='upper right')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 505
        },
        "id": "NKwbLdTzvKPF",
        "outputId": "37d1aa45-e515-4252-cfca-70eb0d5e822c"
      },
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7956f9957fd0>"
            ]
          },
          "metadata": {},
          "execution_count": 112
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNKXOL1wo8nOF0hfUXlz4nz",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}