noshot 4.0.0__py3-none-any.whl → 6.0.0__py3-none-any.whl

noshot/data/ML TS XAI/ML/ML Lab CIA 2 (I Found Only This Check)/weatherAUS.ipynb

@@ -1,155 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": []
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "source": [
-        "1.\tDesign a custom 4-layer feed forward neural network for the weather prediction dataset. Modify your model to include L2 regularization on all hidden layers."
-      ],
-      "metadata": {
-        "id": "41vyXTdsmm3h"
-      }
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 3,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "HOFKtDK0kHT9",
-        "outputId": "5366de78-d21f-4462-e430-327c4d38bb1e"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Epoch 1/20, Loss: 0.7105\n",
-            "Epoch 2/20, Loss: 0.7018\n",
-            "Epoch 3/20, Loss: 0.6926\n",
-            "Epoch 4/20, Loss: 0.6830\n",
-            "Epoch 5/20, Loss: 0.6730\n",
-            "Epoch 6/20, Loss: 0.6629\n",
-            "Epoch 7/20, Loss: 0.6525\n",
-            "Epoch 8/20, Loss: 0.6419\n",
-            "Epoch 9/20, Loss: 0.6308\n",
-            "Epoch 10/20, Loss: 0.6192\n",
-            "Epoch 11/20, Loss: 0.6071\n",
-            "Epoch 12/20, Loss: 0.5944\n",
-            "Epoch 13/20, Loss: 0.5811\n",
-            "Epoch 14/20, Loss: 0.5673\n",
-            "Epoch 15/20, Loss: 0.5531\n",
-            "Epoch 16/20, Loss: 0.5387\n",
-            "Epoch 17/20, Loss: 0.5241\n",
-            "Epoch 18/20, Loss: 0.5096\n",
-            "Epoch 19/20, Loss: 0.4954\n",
-            "Epoch 20/20, Loss: 0.4817\n",
-            "\n",
-            "Test Accuracy: 0.7860\n",
-            "\n",
-            "Classification Report:\n",
-            "               precision    recall  f1-score   support\n",
-            "\n",
-            "         0.0       0.78      1.00      0.88     10588\n",
-            "         1.0       1.00      0.04      0.08      3035\n",
-            "\n",
-            "    accuracy                           0.79     13623\n",
-            "   macro avg       0.89      0.52      0.48     13623\n",
-            "weighted avg       0.83      0.79      0.70     13623\n",
-            "\n"
-          ]
-        }
-      ],
-      "source": [
-        "import pandas as pd\n",
-        "import numpy as np\n",
-        "from sklearn.model_selection import train_test_split\n",
-        "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
-        "from sklearn.metrics import accuracy_score, classification_report\n",
-        "import torch\n",
-        "import torch.nn as nn\n",
-        "import torch.nn.functional as F\n",
-        "\n",
-        "df = pd.read_csv(\"weatherAUS.csv\", on_bad_lines='skip')\n",
-        "\n",
-        "df = df.dropna(subset=[\"RainTomorrow\"])\n",
-        "\n",
-        "num_cols = df.select_dtypes(include=[\"float64\", \"int64\"]).columns\n",
-        "df[num_cols] = df[num_cols].fillna(df[num_cols].median())\n",
-        "\n",
-        "cat_cols = df.select_dtypes(include=[\"object\"]).columns\n",
-        "df[cat_cols] = df[cat_cols].fillna(df[cat_cols].mode().iloc[0])\n",
-        "\n",
-        "le_dict = {}\n",
-        "for col in cat_cols:\n",
-        "    le = LabelEncoder()\n",
-        "    df[col] = le.fit_transform(df[col])\n",
-        "    le_dict[col] = le\n",
-        "\n",
-        "X = df.drop(\"RainTomorrow\", axis=1)\n",
-        "y = df[\"RainTomorrow\"]\n",
-        "\n",
-        "scaler = StandardScaler()\n",
-        "X = scaler.fit_transform(X)\n",
-        "\n",
-        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
-        "\n",
-        "X_train = torch.tensor(X_train, dtype=torch.float32)\n",
-        "y_train = torch.tensor(y_train.values, dtype=torch.float32).view(-1, 1)\n",
-        "X_test = torch.tensor(X_test, dtype=torch.float32)\n",
-        "y_test = torch.tensor(y_test.values, dtype=torch.float32).view(-1, 1)\n",
-        "\n",
-        "class WeatherPredictor(nn.Module):\n",
-        "    def __init__(self, input_size):\n",
-        "        super(WeatherPredictor, self).__init__()\n",
-        "        self.fc1 = nn.Linear(input_size, 128)\n",
-        "        self.fc2 = nn.Linear(128, 64)\n",
-        "        self.fc3 = nn.Linear(64, 32)\n",
-        "        self.fc4 = nn.Linear(32, 1)\n",
-        "\n",
-        "    def forward(self, x):\n",
-        "        x = F.relu(self.fc1(x))\n",
-        "        x = F.relu(self.fc2(x))\n",
-        "        x = F.relu(self.fc3(x))\n",
-        "        x = torch.sigmoid(self.fc4(x))\n",
-        "        return x\n",
-        "\n",
-        "model = WeatherPredictor(input_size=X_train.shape[1])\n",
-        "criterion = nn.BCELoss()\n",
-        "optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)  # L2 regularization\n",
-        "\n",
-        "epochs = 20\n",
-        "for epoch in range(epochs):\n",
-        "    model.train()\n",
-        "    optimizer.zero_grad()\n",
-        "    outputs = model(X_train)\n",
-        "    loss = criterion(outputs, y_train)\n",
-        "    loss.backward()\n",
-        "    optimizer.step()\n",
-        "    print(f\"Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}\")\n",
-        "\n",
-        "model.eval()\n",
-        "with torch.no_grad():\n",
-        "    preds = model(X_test)\n",
-        "    preds_class = (preds > 0.5).float()\n",
-        "    acc = accuracy_score(y_test, preds_class)\n",
-        "    print(f\"\\nTest Accuracy: {acc:.4f}\")\n",
-        "    print(\"\\nClassification Report:\\n\", classification_report(y_test, preds_class))"
-      ]
-    }
-  ]
-}

noshot/data/ML TS XAI/ML/Main/1. EDA-PCA (Balance Scale Dataset).ipynb

@@ -1,139 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1919dce4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.decomposition import PCA\n",
-    "\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "459c19c9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cols = ['class name', 'left-weight', 'left-distance', 'right-weight', 'right-distance']\n",
-    "df = pd.read_table('data/balance-scale.txt', delimiter=',', names=cols)\n",
-    "print(\"Shape:\", df.shape)\n",
-    "df.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ceb17e01",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.describe()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c3950e04",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.info()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2fd3e589-3f8f-4203-aa0b-7d3261a3c5b1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sns.countplot(df, x='class name', hue='class name')\n",
-    "plt.title(\"Count Plot ['B', 'R', 'L']\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b9d4bb7e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "features = ['left-weight', 'left-distance', 'right-weight', 'right-distance']\n",
-    "x = df.loc[:, features]\n",
-    "y = df.loc[:, 'class name']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "de2b55cc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "x = StandardScaler().fit_transform(x)\n",
-    "pca = PCA(n_components=2)\n",
-    "pct = pca.fit_transform(x)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "08a8f4c9-05d6-4422-a6f3-5c6f7605220b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "principal_df = pd.DataFrame(pct, columns=['pc1', 'pc2'])\n",
-    "principal_df['class name'] = df['class name']\n",
-    "principal_df.head()\n",
-    "\n",
-    "fig = plt.figure(figsize=(8,8))\n",
-    "ax = fig.add_subplot(1, 1, 1)\n",
-    "\n",
-    "targets = ['L','B','R']\n",
-    "colors = ['r', 'g','b']\n",
-    "for target, color in zip(targets, colors):\n",
-    "    selected = principal_df[principal_df['class name'] == target]\n",
-    "    ax.scatter(selected['pc1'], selected['pc2'], c=color, s=50)\n",
-    "\n",
-    "ax.set_xlabel('Principal Component 1')\n",
-    "ax.set_ylabel('Principal Component 2')\n",
-    "ax.set_title('2 component PCA')\n",
-    "ax.legend(targets)\n",
-    "ax.grid()"
-   ]
-  }
- ],
- "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.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

noshot/data/ML TS XAI/ML/Main/1. EDA-PCA (Rice Dataset).ipynb

@@ -1,181 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d27dd480-bff5-4179-8b5d-145b15fe2527",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import seaborn as sns\n",
-    "import scipy\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c34c5236-de26-47a7-b047-c084519f6ef7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "data, _ = scipy.io.arff.loadarff('data/rice.arff')\n",
-    "df = pd.DataFrame(data)\n",
-    "print(\"Shape:\", df.shape)\n",
-    "df.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9ef13fe2-6f7f-4e9e-97bf-f44c0b10694e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.describe()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0a51ae34-5fa4-4f78-a08c-de89bcc1f6b2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.info()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3a30c508-273f-46cd-8ecd-8361b255488b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.isnull().sum()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f0651a71-0bc1-489e-ad5f-7b080a9cb978",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sns.countplot(df, x='Class', hue='Class')\n",
-    "plt.title(\"Class Distribution\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e2d1c93f-e097-4b08-b9ff-48c7d5fd9659",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(\"Mean of Features\")\n",
-    "df.iloc[:, :-1].mean()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0977bb62-192e-43f4-8cd9-e054ea3526b9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cov = df.iloc[:, :-1].cov().round(3)\n",
-    "print(\"Covariance Matrix\")\n",
-    "cov"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e2862d9a-76b9-4367-a135-0fc36ae60478",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "eigen_vals, eigen_vecs = np.linalg.eig(cov)\n",
-    "mapping = {round(eigen_vals[i], 2): eigen_vecs[:, i].round(2) \n",
-    "           for i in range(len(eigen_vals))}\n",
-    "print(\"Eigen Value-Vector Pairs:\")\n",
-    "mapping"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "06a3c671-6cae-44c7-9960-56702042c0e5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n = 2\n",
-    "sorted_eigen_vals = sorted(mapping.keys(), reverse=True)\n",
-    "top_eigen_vals = sorted_eigen_vals[:n]\n",
-    "top_eigen_vals"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6473c348-871e-428d-a3d6-7942fc0df706",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "projection_matrix = np.array([mapping[val] for val in top_eigen_vals]).T\n",
-    "projection_matrix"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6014c705-cb9a-470f-905f-ec05eb5f89f9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "X = df.iloc[:, :-1].values\n",
-    "reduced_data = X.dot(projection_matrix)\n",
-    "reduced_df = pd.DataFrame(reduced_data, columns=[f'PC{i+1}' for i in range(n)])\n",
-    "reduced_df['Class'] = df['Class'].values\n",
-    "reduced_df.head()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f53faa36-3044-4a48-9512-f7bc947bd9ba",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sns.scatterplot(data=reduced_df, x='PC1', y='PC2', hue='Class')\n",
-    "plt.title('Principle Component Analysis')\n",
-    "plt.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.12.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}