Appendix00_Logistic_Regression_Without_ValSplit_Final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "af1cdfb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "57c0ffe8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data loading and pre-processing\n",
    "train_X = pd.read_csv('train.csv')\n",
    "test_X = pd.read_csv('test.csv' )\n",
    "train_X.drop(train_X.columns[train_X.columns.str.contains('unnamed',case = False)],axis = 1, inplace = True)\n",
    "test_X.drop(test_X.columns[test_X.columns.str.contains('unnamed',case = False)],axis = 1, inplace = True)\n",
    "\n",
    "train_result = pd.read_csv('train_result.csv')\n",
    "train_y_class = train_result['Class']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d8cf7480",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Removing negative values from the features with zeros. \n",
    "#Later this step was not performed as there is any change in the LR training. So used the original features as such.\n",
    "#train_X = train_X.mask(train_X < 0.0, 0.0)\n",
    "#test_X = test_X.mask(train_X < 0.0, 0.0)\n",
    "#train_X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c4741fbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50000,)\n",
      "(50000, 1568)\n",
      "(10000, 1568)\n"
     ]
    }
   ],
   "source": [
    "#Converting Pandas dataframe into Numpy Array\n",
    "X_train = train_X.to_numpy() # (m, c) dimension m = examples in train dataset\n",
    "X_test = test_X.to_numpy()   # (m, c) dimension m = examples in test dataset\n",
    "train_y = train_y_class.to_numpy() #(m,)\n",
    "\n",
    "print(train_y.shape)\n",
    "print(X_train.shape)\n",
    "print(X_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "621912de",
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot(y, c):\n",
    "    '''\n",
    "    Function for one hot ecoding\n",
    "    Arguments:\n",
    "    y--> label/ground truth.\n",
    "    c--> Number of classes.\n",
    "    \n",
    "    Return:\n",
    "        one-hot encoded y values\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    # A zero matrix of size (m, c)\n",
    "    y_hot = np.zeros((len(y), c))\n",
    "    \n",
    "    # Putting 1 for column where the label is,\n",
    "    # Using multidimensional indexing.\n",
    "    y_hot[np.arange(len(y)), y] = 1\n",
    "    \n",
    "    return y_hot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b99ddc0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(z):\n",
    "    '''\n",
    "    Softmax function\n",
    "    Argument:\n",
    "         z--> linear part.\n",
    "    Return:\n",
    "        Softmax value\n",
    "    '''\n",
    " \n",
    "    \n",
    "    # subtracting the max of z for numerical stability.\n",
    "    exp = np.exp(z - np.max(z)) # (m, c ) dimension\n",
    "    \n",
    "    # Calculating softmax for all examples.\n",
    "    for i in range(len(z)):\n",
    "        exp[i] /= np.sum(exp[i])\n",
    "    \n",
    "    return exp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "08f07f98",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X, w, b):\n",
    "    '''\n",
    "    Support function for predictions\n",
    "        \n",
    "    # X --> Input.\n",
    "    # w --> weights.\n",
    "    # b --> bias\n",
    "    \n",
    "    Return:\n",
    "    class with highest probability\n",
    "    '''   \n",
    "    \n",
    "    # Predicting\n",
    "    z = X@w + b\n",
    "    y_hat = softmax(z) #(m, c) dimensions. m =  examples, X.shape[0], c =total classes\n",
    "    \n",
    "    class_with_high_prob = np.argmax(y_hat, axis=1) #(m,) m = examples,X.shape[0]\n",
    "    \n",
    "    # Returning the class with highest probability.\n",
    "    return class_with_high_prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "86497a20",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prediction_accuracy(y, y_hat):\n",
    "    return np.sum(y==y_hat)/len(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c9a488cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_predict_accuracy(X, y, w, b):\n",
    "    '''\n",
    "    Support function for predicting the model accuracy\n",
    "    \n",
    "    Arguments:\n",
    "    X --> Dataset (train, val, test)\n",
    "    y --> Target labels\n",
    "    w --> weights after training\n",
    "    b --> bias  after training\n",
    "    \n",
    "    Return:\n",
    "    model_accuracy, confusion_matrix, sum_preds, sum_correct, misclassification_error, losses\n",
    "    '''\n",
    "        \n",
    "    preds = predict(X, w, b)\n",
    "    model_accuracy = prediction_accuracy(y, preds)\n",
    "\n",
    "    n_classes = len(np.unique(y))\n",
    "    \n",
    "    confusion_matrix = np.zeros((n_classes,n_classes))\n",
    "    for (true, pred) in zip(y, preds):\n",
    "        confusion_matrix[int(true-1), int(pred-1)] += 1\n",
    "\n",
    "    #misclassification_error(confusion_matrix):\n",
    "    sum_preds = np.sum(confusion_matrix)\n",
    "    sum_correct = np.sum(np.diag(confusion_matrix))\n",
    "    misclassification_error = 1.0 - (float(sum_correct) / float(sum_preds))\n",
    "    \n",
    "    return model_accuracy, confusion_matrix, sum_preds, sum_correct, misclassification_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f3b0fff4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_reg_lamb(X, y, lr, epochs, lamb):\n",
    "    '''\n",
    "    Multiclass Logistic Regression Classifier Model\n",
    "    \n",
    "    Arguments:\n",
    "    X --> Input.\n",
    "    y --> true/target value.\n",
    "    lr --> Learning rate.\n",
    "    epochs --> Number of iterations.\n",
    "    lamb --> regularization parameter (lambda)\n",
    "    \n",
    "    Return:\n",
    "    w --> weights after training\n",
    "    b --> bias ater training\n",
    "    losses --> losses during training \n",
    "    '''\n",
    "        \n",
    "    # m-> number of training examples\n",
    "    # n-> number of features \n",
    "    m, n = X.shape\n",
    "    \n",
    "    c = len(np.unique(y)) # number of classes based on unique y values usually train_y values\n",
    "\n",
    "    \n",
    "    # Initializing weights and bias randomly.\n",
    "    np.random.seed(999)\n",
    "    w = np.random.random((n, c)) # (n,c) dimension\n",
    "    b = np.random.random(c)      # (c,) dimension\n",
    "    \n",
    "    # Empty list to store losses.\n",
    "    losses = []\n",
    "    \n",
    "    # Training loop.\n",
    "    for epoch in range(epochs):\n",
    "        \n",
    "        # Calculating hypothesis/prediction.\n",
    "        z = X@w + b # (m, c) dimension\n",
    "       \n",
    "        y_hat = softmax(z) #(m, c) dimension\n",
    "       \n",
    "        # One-hot encoding y.\n",
    "        y_hot = one_hot(y, c) #(m, c) dimension\n",
    "       \n",
    "        # Calculating the gradient of loss w.r.t w and b.\n",
    "        w_grad = (1/m)* ( np.dot(X.T, (y_hat - y_hot)) + lamb*w) #(n, c) dimension\n",
    "        b_grad = (1/m)*np.sum(y_hat - y_hot) #scalar value\n",
    "        \n",
    "        # Updating the parameters.\n",
    "        w = w - lr*w_grad #(n, c) dimension\n",
    "        b = b - lr*b_grad #(c,) dimension\n",
    "        \n",
    "        cross_entropy = - np.sum(np.log(y_hat) * (y_hot), axis=1) #(m,) dimension\n",
    "        loss = np.mean(cross_entropy)\n",
    "        \n",
    "        reg_cost = (lamb/(2*m))*np.sum(w*w)\n",
    "        total_costJ = loss + reg_cost \n",
    "        \n",
    "        losses.append(total_costJ)\n",
    "        \n",
    "        # Printing out the total cost after regularization at every 100th iteration.\n",
    "        if epoch%100==0:\n",
    "            print(f'Epoch {epoch} ==> Total CostJ = {total_costJ}')\n",
    "\n",
    "    return w, b, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "0b53e9b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy \n",
      "\n",
      "Epoch 0 ==> Total CostJ = 7.755421276792871\n",
      "\n",
      "\n",
      "Accuracy: 0.09712\n",
      "sum_preds               : 50000\n",
      "sum_correct_predictions : 4856\n",
      "sum_wrong_predictions   : 45144\n",
      "misclassification_error : 0.90288\n",
      "\n",
      "\n",
      "Test Predictions\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    lr =0.1\n",
    "    epochs = 100\n",
    "    lamb =0.001\n",
    "\n",
    "    print(\"Training Accuracy \\n\")\n",
    "    w, b, losses =  fit_reg_lamb(X_train, train_y, lr=lr, epochs=epochs, lamb=lamb)\n",
    "    train_accuracy, confusion_matrix, sum_preds, sum_correct, misclassification_error = model_predict_accuracy(X_train, train_y, w, b)\n",
    "    print('\\n')\n",
    "    print(\"Accuracy:\",train_accuracy)\n",
    "    #print('confusion_matrix:')\n",
    "    #print(confusion_matrix, '\\n')\n",
    "    print(\"sum_preds               :\", int(sum_preds)) \n",
    "    print(\"sum_correct_predictions :\", int(sum_correct)) \n",
    "    print(\"sum_wrong_predictions   :\", int(sum_preds - sum_correct))\n",
    "    print(\"misclassification_error :\", misclassification_error)\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    fig.suptitle('Training Loss', fontsize=18)\n",
    "    plt.plot(losses)\n",
    "    plt.xlabel('Epochs', fontsize=16)\n",
    "    plt.ylabel('Loss', fontsize=16)\n",
    "    plt.xticks(fontsize=14)\n",
    "    plt.yticks(fontsize=14)\n",
    "    fig.savefig('Loss_plot_Training_without_Val.jpg')\n",
    "    \n",
    "    print('\\n')\n",
    "    print(\"Test Predictions\")\n",
    "    test_predictions = predict(X_test, w, b)\n",
    "    df = pd.DataFrame(test_predictions)\n",
    "    df.index.name= 'Index'\n",
    "    file_name = f'test_predictions_lr{str(lr)}_lambda{str(lamb)}_epochs{str(epochs)}_Without_Val.csv'\n",
    "    df.to_csv(file_name, index=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ed1b02c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy \n",
      "\n",
      "Epoch 0 ==> Total CostJ = 17.574170684384733\n",
      "Epoch 100 ==> Total CostJ = 13.232918013634391\n",
      "Epoch 200 ==> Total CostJ = 12.327744043796876\n",
      "Epoch 300 ==> Total CostJ = 11.690871982680605\n",
      "Epoch 400 ==> Total CostJ = 11.168036335512467\n",
      "Epoch 500 ==> Total CostJ = 10.710864431503603\n",
      "Epoch 600 ==> Total CostJ = 10.298337416417697\n",
      "Epoch 700 ==> Total CostJ = 9.919402997408168\n",
      "Epoch 800 ==> Total CostJ = 9.567443319800034\n",
      "Epoch 900 ==> Total CostJ = 9.238112752723659\n",
      "Epoch 1000 ==> Total CostJ = 8.928356860858466\n",
      "Epoch 1100 ==> Total CostJ = 8.635913153045559\n",
      "Epoch 1200 ==> Total CostJ = 8.359033952406993\n",
      "Epoch 1300 ==> Total CostJ = 8.096322112417578\n",
      "Epoch 1400 ==> Total CostJ = 7.846628537697697\n",
      "Epoch 1500 ==> Total CostJ = 7.608985577959798\n",
      "Epoch 1600 ==> Total CostJ = 7.382562218069317\n",
      "Epoch 1700 ==> Total CostJ = 7.166633015329872\n",
      "Epoch 1800 ==> Total CostJ = 6.9605559874010705\n",
      "Epoch 1900 ==> Total CostJ = 6.763756492861901\n",
      "Epoch 2000 ==> Total CostJ = 6.575715225605492\n",
      "Epoch 2100 ==> Total CostJ = 6.395959097861841\n",
      "Epoch 2200 ==> Total CostJ = 6.224054193511497\n",
      "Epoch 2300 ==> Total CostJ = 6.059600232984556\n",
      "Epoch 2400 ==> Total CostJ = 5.902226160555327\n",
      "Epoch 2500 ==> Total CostJ = 5.75158657790502\n",
      "Epoch 2600 ==> Total CostJ = 5.607358824740672\n",
      "Epoch 2700 ==> Total CostJ = 5.4692405605501815\n",
      "Epoch 2800 ==> Total CostJ = 5.3369477391226425\n",
      "Epoch 2900 ==> Total CostJ = 5.210212894330047\n",
      "Epoch 3000 ==> Total CostJ = 5.088783675161656\n",
      "Epoch 3100 ==> Total CostJ = 4.972421582330137\n",
      "Epoch 3200 ==> Total CostJ = 4.860900869422367\n",
      "Epoch 3300 ==> Total CostJ = 4.7540075795747665\n",
      "Epoch 3400 ==> Total CostJ = 4.6515386947300446\n",
      "Epoch 3500 ==> Total CostJ = 4.55330137918682\n",
      "Epoch 3600 ==> Total CostJ = 4.459112302748878\n",
      "Epoch 3700 ==> Total CostJ = 4.368797031580044\n",
      "Epoch 3800 ==> Total CostJ = 4.282189477066659\n",
      "Epoch 3900 ==> Total CostJ = 4.199131394724377\n",
      "Epoch 4000 ==> Total CostJ = 4.119471926566145\n",
      "Epoch 4100 ==> Total CostJ = 4.04306718145307\n",
      "Epoch 4200 ==> Total CostJ = 3.9697798488401554\n",
      "Epoch 4300 ==> Total CostJ = 3.899478842050526\n",
      "Epoch 4400 ==> Total CostJ = 3.8320389678002695\n",
      "Epoch 4500 ==> Total CostJ = 3.767340619178599\n",
      "Epoch 4600 ==> Total CostJ = 3.70526948968607\n",
      "Epoch 4700 ==> Total CostJ = 3.6457163062636395\n",
      "Epoch 4800 ==> Total CostJ = 3.588576579520439\n",
      "Epoch 4900 ==> Total CostJ = 3.533750369598713\n",
      "Epoch 5000 ==> Total CostJ = 3.4811420663084873\n",
      "Epoch 5100 ==> Total CostJ = 3.4306601823288454\n",
      "Epoch 5200 ==> Total CostJ = 3.382217158412426\n",
      "Epoch 5300 ==> Total CostJ = 3.3357291796491\n",
      "Epoch 5400 ==> Total CostJ = 3.291116001947267\n",
      "Epoch 5500 ==> Total CostJ = 3.2483007879794794\n",
      "Epoch 5600 ==> Total CostJ = 3.207209951915609\n",
      "Epoch 5700 ==> Total CostJ = 3.1677730123332117\n",
      "Epoch 5800 ==> Total CostJ = 3.1299224527527776\n",
      "Epoch 5900 ==> Total CostJ = 3.093593589296423\n",
      "Epoch 6000 ==> Total CostJ = 3.0587244450132967\n",
      "Epoch 6100 ==> Total CostJ = 3.025255630454515\n",
      "Epoch 6200 ==> Total CostJ = 2.9931302301154097\n",
      "Epoch 6300 ==> Total CostJ = 2.962293694394058\n",
      "Epoch 6400 ==> Total CostJ = 2.932693736742813\n",
      "Epoch 6500 ==> Total CostJ = 2.9042802357144666\n",
      "Epoch 6600 ==> Total CostJ = 2.87700514162699\n",
      "Epoch 6700 ==> Total CostJ = 2.8508223875909406\n",
      "Epoch 6800 ==> Total CostJ = 2.8256878046618246\n",
      "Epoch 6900 ==> Total CostJ = 2.801559040896149\n",
      "Epoch 7000 ==> Total CostJ = 2.7783954841049114\n",
      "Epoch 7100 ==> Total CostJ = 2.756158188111882\n",
      "Epoch 7200 ==> Total CostJ = 2.7348098023365033\n",
      "Epoch 7300 ==> Total CostJ = 2.714314504532641\n",
      "Epoch 7400 ==> Total CostJ = 2.694637936524873\n",
      "Epoch 7500 ==> Total CostJ = 2.675747142793623\n",
      "Epoch 7600 ==> Total CostJ = 2.6576105117693354\n",
      "Epoch 7700 ==> Total CostJ = 2.6401977197040405\n",
      "Epoch 7800 ==> Total CostJ = 2.62347967699627\n",
      "Epoch 7900 ==> Total CostJ = 2.6074284768522884\n",
      "Epoch 8000 ==> Total CostJ = 2.5920173461731233\n",
      "Epoch 8100 ==> Total CostJ = 2.5772205985629504\n",
      "Epoch 8200 ==> Total CostJ = 2.563013589360035\n",
      "Epoch 8300 ==> Total CostJ = 2.549372672596713\n",
      "Epoch 8400 ==> Total CostJ = 2.5362751597997932\n",
      "Epoch 8500 ==> Total CostJ = 2.5236992805474032\n",
      "Epoch 8600 ==> Total CostJ = 2.5116241447025973\n",
      "Epoch 8700 ==> Total CostJ = 2.500029706248088\n",
      "Epoch 8800 ==> Total CostJ = 2.4888967286502957\n",
      "Epoch 8900 ==> Total CostJ = 2.478206751684439\n",
      "Epoch 9000 ==> Total CostJ = 2.4679420596557904\n",
      "Epoch 9100 ==> Total CostJ = 2.458085650955375\n",
      "Epoch 9200 ==> Total CostJ = 2.4486212088913715\n",
      "Epoch 9300 ==> Total CostJ = 2.4395330737402983\n",
      "Epoch 9400 ==> Total CostJ = 2.4308062159647337\n",
      "Epoch 9500 ==> Total CostJ = 2.4224262105468326\n",
      "Epoch 9600 ==> Total CostJ = 2.414379212389271\n",
      "Epoch 9700 ==> Total CostJ = 2.4066519327375286\n",
      "Epoch 9800 ==> Total CostJ = 2.399231616579519\n",
      "Epoch 9900 ==> Total CostJ = 2.3921060209806377\n",
      "Epoch 10000 ==> Total CostJ = 2.3852633943141806\n",
      "Epoch 10100 ==> Total CostJ = 2.3786924563489293\n",
      "Epoch 10200 ==> Total CostJ = 2.3723823791574272\n",
      "Epoch 10300 ==> Total CostJ = 2.3663227688100914\n",
      "Epoch 10400 ==> Total CostJ = 2.360503647821891\n",
      "Epoch 10500 ==> Total CostJ = 2.3549154383197926\n",
      "Epoch 10600 ==> Total CostJ = 2.3495489459005854\n",
      "Epoch 10700 ==> Total CostJ = 2.3443953441500405\n",
      "Epoch 10800 ==> Total CostJ = 2.339446159795644\n",
      "Epoch 10900 ==> Total CostJ = 2.3346932584663618\n",
      "Epoch 11000 ==> Total CostJ = 2.3301288310340227\n",
      "Epoch 11100 ==> Total CostJ = 2.3257453805120822\n",
      "Epoch 11200 ==> Total CostJ = 2.321535709488487\n",
      "Epoch 11300 ==> Total CostJ = 2.3174929080704576\n",
      "Epoch 11400 ==> Total CostJ = 2.3136103423199024\n",
      "Epoch 11500 ==> Total CostJ = 2.3098816431591067\n",
      "Epoch 11600 ==> Total CostJ = 2.3063006957272436\n",
      "Epoch 11700 ==> Total CostJ = 2.302861629169029\n",
      "Epoch 11800 ==> Total CostJ = 2.299558806837687\n",
      "Epoch 11900 ==> Total CostJ = 2.296386816895138\n",
      "\n",
      "\n",
      "Accuracy: 0.27228\n",
      "sum_preds               : 50000\n",
      "sum_correct_predictions : 13614\n",
      "sum_wrong_predictions   : 36386\n",
      "misclassification_error : 0.7277199999999999\n",
      "\n",
      "\n",
      "Validation Accuracy \n",
      "\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'X_val' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [12]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     28\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m     29\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mValidation Accuracy \u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 30\u001b[0m val_accuracy, val_confusion_matrix, val_sum_preds, val_sum_correct, val_misclassification_error \u001b[38;5;241m=\u001b[39m model_predict_accuracy(\u001b[43mX_val\u001b[49m, val_y, w, b)\n\u001b[0;32m     31\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAccuracy:\u001b[39m\u001b[38;5;124m\"\u001b[39m,val_accuracy)\n\u001b[0;32m     32\u001b[0m \u001b[38;5;66;03m#print('confusion_matrix:')\u001b[39;00m\n\u001b[0;32m     33\u001b[0m \u001b[38;5;66;03m#print(confusion_matrix, '\\n')\u001b[39;00m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'X_val' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    lr =0.1\n",
    "    epochs = 12000\n",
    "    lamb = 100.0\n",
    "\n",
    "    print(\"Training Accuracy \\n\")\n",
    "    w, b, losses =  fit_reg_lamb(X_train, train_y, lr=lr, epochs=epochs, lamb=lamb)\n",
    "    train_accuracy, confusion_matrix, sum_preds, sum_correct, misclassification_error = model_predict_accuracy(X_train, train_y, w, b)\n",
    "    print('\\n')\n",
    "    print(\"Accuracy:\",train_accuracy)\n",
    "    #print('confusion_matrix:')\n",
    "    #print(confusion_matrix, '\\n')\n",
    "    print(\"sum_preds               :\", int(sum_preds)) \n",
    "    print(\"sum_correct_predictions :\", int(sum_correct)) \n",
    "    print(\"sum_wrong_predictions   :\", int(sum_preds - sum_correct))\n",
    "    print(\"misclassification_error :\", misclassification_error)\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    fig.suptitle('Training Loss', fontsize=18)\n",
    "    plt.plot(losses)\n",
    "    plt.xlabel('Epochs', fontsize=16)\n",
    "    plt.ylabel('Loss', fontsize=16)\n",
    "    plt.xticks(fontsize=14)\n",
    "    plt.yticks(fontsize=14)\n",
    "    fig.savefig('Loss_plot_Training.jpg')\n",
    "\n",
    "    \n",
    "    print('\\n')\n",
    "    print(\"Validation Accuracy \\n\")\n",
    "    val_accuracy, val_confusion_matrix, val_sum_preds, val_sum_correct, val_misclassification_error = model_predict_accuracy(X_val, val_y, w, b)\n",
    "    print(\"Accuracy:\",val_accuracy)\n",
    "    #print('confusion_matrix:')\n",
    "    #print(confusion_matrix, '\\n')\n",
    "    print(\"sum_preds               :\", int(val_sum_preds)) \n",
    "    print(\"sum_correct_predictions :\", int(val_sum_correct)) \n",
    "    print(\"sum_wrong_predictions   :\", int(val_sum_preds - val_sum_correct))\n",
    "    print(\"misclassification_error :\", val_misclassification_error)\n",
    "    \n",
    "    \n",
    "    print('\\n')\n",
    "    print(\"Test Predictions\")\n",
    "    test_predictions = predict(X_test, w, b)\n",
    "    df = pd.DataFrame(test_predictions)\n",
    "    df.index.name= 'Index'\n",
    "    file_name = f'test_predictions_lr{str(lr)}_lambda{str(lamb)}_epochs{str(epochs)}_rerun1.csv'\n",
    "    df.to_csv(file_name, index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87922985",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    lr =0.1\n",
    "    epochs = 12000\n",
    "    lamb = 1000.0\n",
    "\n",
    "    print(\"Training Accuracy \\n\")\n",
    "    w, b, losses =  fit_reg_lamb(X_train, train_y, lr=lr, epochs=epochs, lamb=lamb)\n",
    "    train_accuracy, confusion_matrix, sum_preds, sum_correct, misclassification_error = model_predict_accuracy(X_train, train_y, w, b)\n",
    "    print('\\n')\n",
    "    print(\"Accuracy:\",train_accuracy)\n",
    "    #print('confusion_matrix:')\n",
    "    #print(confusion_matrix, '\\n')\n",
    "    print(\"sum_preds               :\", int(sum_preds)) \n",
    "    print(\"sum_correct_predictions :\", int(sum_correct)) \n",
    "    print(\"sum_wrong_predictions   :\", int(sum_preds - sum_correct))\n",
    "    print(\"misclassification_error :\", misclassification_error)\n",
    "    \n",
    "    fig = plt.figure()\n",
    "    fig.suptitle('Training Loss', fontsize=18)\n",
    "    plt.plot(losses)\n",
    "    plt.xlabel('Epochs', fontsize=16)\n",
    "    plt.ylabel('Loss', fontsize=16)\n",
    "    plt.xticks(fontsize=14)\n",
    "    plt.yticks(fontsize=14)\n",
    "    fig.savefig('Loss_plot_Training.jpg')\n",
    "\n",
    "    \n",
    "    print('\\n')\n",
    "    print(\"Validation Accuracy \\n\")\n",
    "    val_accuracy, val_confusion_matrix, val_sum_preds, val_sum_correct, val_misclassification_error = model_predict_accuracy(X_val, val_y, w, b)\n",
    "    print(\"Accuracy:\",val_accuracy)\n",
    "    #print('confusion_matrix:')\n",
    "    #print(confusion_matrix, '\\n')\n",
    "    print(\"sum_preds               :\", int(val_sum_preds)) \n",
    "    print(\"sum_correct_predictions :\", int(val_sum_correct)) \n",
    "    print(\"sum_wrong_predictions   :\", int(val_sum_preds - val_sum_correct))\n",
    "    print(\"misclassification_error :\", val_misclassification_error)\n",
    "    \n",
    "    \n",
    "    print('\\n')\n",
    "    print(\"Test Predictions\")\n",
    "    test_predictions = predict(X_test, w, b)\n",
    "    df = pd.DataFrame(test_predictions)\n",
    "    df.index.name= 'Index'\n",
    "    file_name = f'test_predictions_lr{str(lr)}_lambda{str(lamb)}_epochs{str(epochs)}_rerun1.csv'\n",
    "    df.to_csv(file_name, index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e3437b8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ef1af6e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "710956b1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60237141",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69932211",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cafc9bd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "815be8b1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11190676",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78710798",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07c842e6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82b1c168",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3abec851",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}