FFTrainingLoop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-07-06T00:30:37.096629Z",
     "start_time": "2024-07-06T00:30:36.051334Z"
    }
   },
   "source": [
    "#Importing all the different python modules needed\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from torch.utils.data import TensorDataset, DataLoader, random_split\n",
    "from ffModel import FeedForward\n",
    "from torch.optim.lr_scheduler import ExponentialLR, StepLR, MultiStepLR, ReduceLROnPlateau\n",
    "from sklearn.preprocessing import StandardScaler"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-06T00:31:05.541577Z",
     "start_time": "2024-07-06T00:31:05.481561Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#importing data into pandas data frame\n",
    "train_data = pd.read_csv('train.csv')\n",
    "test_data = pd.read_csv('test.csv')\n",
    "\n",
    "# Save the Id column from the test data for kaggle purposes.\n",
    "savedID = test_data['Id'].astype('int32')\n",
    "test_data.drop(['Id'], axis=1, inplace=True)\n",
    "\n",
    "# Separate target variable from training data\n",
    "Ytrain = train_data['SalePrice']\n",
    "Xtrain = train_data.drop(['SalePrice', 'Id'], axis=1)\n",
    "\n",
    "# Combine training and test data for consistent encoding\n",
    "combinedData = pd.concat([Xtrain, test_data], axis=0)\n",
    "\n",
    "# Handle categorical variables by applying one hot encoding\n",
    "combinedData = pd.get_dummies(combinedData)\n",
    "\n",
    "# Fill missing values with column means\n",
    "combinedData = combinedData.fillna(combinedData.mean())\n",
    "\n",
    "# Separate the combined data back into training and test sets\n",
    "Xtrain = combinedData.iloc[:len(Xtrain), :]\n",
    "Xtest = combinedData.iloc[len(Xtrain):, :]\n",
    "\n",
    "# Standardize the data using scikit-learn\n",
    "scaler = StandardScaler()\n",
    "Xtrain = scaler.fit_transform(Xtrain)\n",
    "Xtest = scaler.transform(Xtest)\n",
    "\n",
    "# Convert to torch tensors\n",
    "Xtrain = torch.tensor(Xtrain, dtype=torch.float32)\n",
    "Ytrain = torch.tensor(Ytrain.values, dtype=torch.float32).view(-1, 1)\n",
    "Xtest = torch.tensor(Xtest, dtype=torch.float32)\n",
    "\n",
    "# Create DataLoader for the test data\n",
    "testValuesFinal = DataLoader(TensorDataset(Xtest), shuffle=False)\n",
    "\n",
    "#create dataloader for training data\n",
    "trainValuesFinal = DataLoader(TensorDataset(Xtrain, Ytrain),batch_size= 28,  shuffle=True)"
   ],
   "id": "6bf0ffa3b56b1648",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-01T20:31:27.867387Z",
     "start_time": "2024-07-01T20:31:27.404688Z"
    }
   },
   "cell_type": "code",
   "source": [
    "'''\n",
    "Now its time to set up the model, optimizer, and the loss function to actually preform the training.\n",
    "For the loss equation as im doing uni-variate normal regression to determine the correct numerical value\n",
    "I will at first use default hyperparameters and assess how well the model is doing then adjust from there using optuna in separate notebook\n",
    "'''\n",
    "model = FeedForward(0.1262981918417337).to('cuda')\n",
    "model.init_weights()\n",
    "optimizer = optim.AdamW(model.parameters(), lr=7.216877087985235e-05, betas=(0.3765401693820542, 0.5171372098061646), eps=1e-9, weight_decay=1.6014659044365067e-05)\n",
    "lossf = nn.MSELoss()\n",
    "scheduler = ReduceLROnPlateau(optimizer, 'min', patience=81, factor=0.0032423913478675614)"
   ],
   "id": "369a30afb467ad28",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-01T20:31:37.950183Z",
     "start_time": "2024-07-01T20:31:27.868105Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#Now to actually train the model in 174 epochs\n",
    "#Set up average_loss variable again for scheduler\n",
    "average_loss = 0\n",
    "\n",
    "#Set model to training mode\n",
    "model.train()\n",
    "\n",
    "#Actual training loop\n",
    "for epoch in range(174):\n",
    "    for inputs, targets in trainValuesFinal:\n",
    "        inputs = inputs.to('cuda')\n",
    "        targets = targets.to('cuda')\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = lossf(outputs, targets)\n",
    "        loss.backward()\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)\n",
    "        optimizer.step()\n",
    "        average_loss += loss.item()\n",
    "    #remember to step scheduler after each epoch\n",
    "    scheduler.step(average_loss/len(trainValuesFinal))"
   ],
   "id": "e2db33157a8a132d",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-01T20:31:38.183875Z",
     "start_time": "2024-07-01T20:31:37.950648Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#now to set up the testing to submit to kaggle.\n",
    "model.eval()\n",
    "predictions = []\n",
    "with torch.no_grad():\n",
    "    for item in testValuesFinal:\n",
    "        item = item[0].to('cuda')\n",
    "        prediction = model.forward(item)\n",
    "        predictions.append(prediction.cpu().numpy())\n",
    "submission = np.concatenate(predictions).reshape(-1, 1)\n",
    "submission = pd.DataFrame(submission, columns=['SalePrice'])\n",
    "final = pd.concat([savedID, submission], axis=1)\n",
    "final.to_csv('submission.csv', index=False)"
   ],
   "id": "c7b5d1c798aa032",
   "outputs": [],
   "execution_count": 5
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}