CNN+LSTM_Model_Train.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CNN+LSTM_Model_Train.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zawWBXPoi3rJ"
      },
      "source": [
        "#Why CNN + LSTM?\n",
        "\n",
        "( About RNN - https://www.youtube.com/watch?v=Y2wfIKQyd1I )\n",
        "\n",
        "( About LSTM - https://www.youtube.com/watch?v=LfnrRPFhkuY , http://colah.github.io/posts/2015-08-Understanding-LSTMs/ )\n",
        "\n",
        "There is inherent (= inbuilt) time dependence in the input data of mechanical bearing for RUL prediction. Using an LSTM network is an appopriate technique to learn patterns in a time-series data.\n",
        "\n",
        "Input data of the 6 bearing learning datasets are 1D data (1D vibration signals(both horizontal acceleration and vertical acceleration) and this 1D data contains only time domain information), directly anlyzing 1D data (time domain is complicated as we cannot get more insights about the data and we cannot extract the necessary features properly from 1D data. Hence, we converted 1D data into 2D CWT feature image data (the obtained 2D data contains both time domain and frequency domain information), with time-frequency domain information, can understand the data well and can extract important necessary features accurately from the data which helps to train the model ideally. Time-Frequency domain features clearly visualize the degradation(= damage) process of the bearings compared to time domain features.\n",
        "\n",
        "Now, our input data is a 2D CWT image and also time dependent. Therfore using CNN + LSTM, because CNN works well for image like data, CNN analyzes the image inputs perfectly whereas LSTM performs well for time-series data. (time-series data = time-series data is a set of observations(data) usually collected at discrete(= different) and equally spaced time intervals) (Here, in our collected dataset, vibration signals are collected at every 10 seconds (different time and equal time intervals). Hence our data is time-series data). And also LSTM is a good sequence model which performs sequence modeling\n",
        "\n",
        "Our collected input data is represented as 2d CWT images, but a window of pre-defined frames (say 5) is used as a sequence. First passed through a CNN architecture for encoding and then encoded feature vector sequence is passed through LSTM architecture, hence CNN+LSTM architecture\n",
        "\n",
        "(In our CNN + LSTM model, 1st we inputted 2D CWT images to the CNN for encoding (encoding is the process of converting the data from one form to another form) and CNN is capable of analyzing images properly which helps in extracting better features from the input image. After inputting 2D CWT images to the CNN Encoder, the CNN Encoder applies convolution, Batch Normalization, ReLU Activation to the inputted image and CNN Encoder converts the 2D image input data into 1D linear continuous vector by flattening, this flattened vector sequence or encoded feature vector sequence is then inputted to LSTM units or LSTM cells. LSTM units or LSTM cells analyze the inputted vector sequences at different time steps(t, t+1, t+2, t+3, t+4) and output the final time step(t+4) LSTM unit vector sequence, from which we calculate the HI(Health Indicator)\n",
        "\n",
        "(LSTM cell or LSTM unit at time step t takes hidden layers or hidden states and encoded vector sequence of CNN Encoder of t time step image as input)\n",
        "\n",
        "(LSTM cell or LSTM unit at time step t+1 takes output of LSTM cell at t time step and current encoded vector sequence(i.e. encoded vector sequence of CNN Encoder of t+1 time step image) as input)\n",
        "\n",
        "(LSTM cell or LSTM unit at time step t+2 takes output of LSTM cell at t+1 time step and current encoded vector sequence(i.e. encoded vector sequence of CNN Encoder of t+2 time step image) as input)\n",
        "\n",
        "(LSTM cell or LSTM unit at time step t+3 takes output of LSTM cell at t+2 time step and current encoded vector sequence(i.e. encoded vector sequence of CNN Encoder of t+3 time step image) as input)\n",
        "\n",
        "(LSTM cell or LSTM unit at time step t+4 takes output of LSTM cell at t+3 time step and current encoded vector sequence(i.e. encoded vector sequence of CNN Encoder of t+4 time step image) as input) )\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_4uR0GzqhF3G"
      },
      "source": [
        "#Mounting Google Drive\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OtC5tAtxgB-h",
        "outputId": "513611d9-df4d-4f32-8062-eba4231a87db"
      },
      "source": [
        "'''\n",
        "Mounting => Before your computer can use any kind of storage device (such as hard drive, Google drive), we or our operating system must make it\n",
        "accessible through the computer’s file system. This process is called mounting. we can only access files on mounted media.\n",
        "In Computers, to mount is to make a group of files in a file system structure accessible to a user or user group. In some usages, it means to make a\n",
        "device physically accessible. Mounting a file system (Google drive) attaches that Google drive to a directory (mount point) and makes it available to the\n",
        "system. In simple words, with mounting a Google drive, user and operating system can access to all the files present in the Google drive. A mounted disk \n",
        "(a mounted drive) is available to the operating system as a file system, for reading, writing, or both.\n",
        "'''\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DN-3NuEgjyim"
      },
      "source": [
        "#Importing the Required Libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TrTCNjtPi8Nj"
      },
      "source": [
        "'''\n",
        "Python library = python library is the collection of modules(= python files) and this python library is the reusable(=able to use again) chunk(= part, section\n",
        ", block) of code we want to include in our python programs or projects to make the implementation easier and faster.\n",
        "\n",
        "import = send \n",
        "\n",
        "os module in python provides functions for interacting with the operating system. os module in Python provides functions for creating and removing a \n",
        "directory(folder), fetching its contents, os module used for changing and identifying the current directory, etc. Basically os module allows source code\n",
        "to communicate (interact) with operating system.\n",
        "\n",
        "Pickle in Python is primarily used in serializing and deserializing a Python object structure. In other words, it's the process of converting a python\n",
        "object into a byte stream to store it in a file/database. Basically pickle library is used to dump (store) all the files of a directory (folder) into \n",
        "single combined file (pickle(.pkz) file) for easy fetching and fast retrieval of data. pickle.dump() is used to create a pickle file, it is used to dump\n",
        "(store) data in a pickle file. pickle.load() is used to load(= start, activate) pickle file\n",
        "\n",
        "Torch (or PyTorch) is an open-source library for machine learning and deep learning. Torch library provides a wide range of algorithms for machine learning and \n",
        "deep learning. The core package of Torch is “torch”, torch package provides a flexible (= adaptable, adjustable, alterable, changeable) N-dimensional array or \n",
        "Tensor, which supports basic routines for indexing, slicing, transposing, type-casting, resizing, sharing storage and cloning. The Tensor also supports \n",
        "mathematical operations like max, min, sum, statistical distributions like uniform, normal and multinomial, and BLAS operations like dot product, matrix-vector \n",
        "multiplication, matrix-matrix multiplication, matrix-vector product and matrix product. The torch package also simplifies object oriented programming and \n",
        "serialization by providing various convenience functions which are used throughout its packages\n",
        "\n",
        "Code for processing data samples can get messy and hard to maintain; we ideally want our dataset code to be decoupled (=separated) from our model training code \n",
        "for better readability and modularity. PyTorch provides two data primitives: torch.utils.data.DataLoader and torch.utils.data.Dataset that allow us to use \n",
        "pre-loaded datasets as well as our own data. DataLoader wraps an iterable around the Dataset to enable easy access to the samples\n",
        "(modularity = Modularity refers to the concept of making multiple modules(= parts, python files) first and then linking and combining them to form a complete \n",
        "              system. Modularity enables re-usability and will minimize duplication. Basically, modularity means dividing a large and complex problem into \n",
        "              various small and simple modules and perform required operations on each individual module and then linking & combining all modules to solve a\n",
        "              complete problem)\n",
        "\n",
        "torch.utils.data.Dataset is an abstract class representing a dataset. custom dataset (torch dataset) should inherit Dataset and apply the following methods:\n",
        "(1)__init__ , (2)__len__ , (3)__getitem__ , and (4) an optional argument transform. Dataset stores the samples and their corresponding labels\n",
        "\n",
        "torch.utils.data.DataLoader wraps an iterable around the Dataset to enable easy access to the samples\n",
        "\n",
        "numpy module allows us to work with numerical data. numpy provides an object called numpy array. numpy supports large multi-dimensional arrays & matrices. \n",
        "Basically numpy is a python library used for working with arrays. numpy used for arithmetic operations, statistical operations, bitwise operations, copying \n",
        "and viewing arrays, stacking, matrix operations, linear algebra, mathematical operations, searching, sorting, and counting.\n",
        "\n",
        "torch.nn => https://www.javatpoint.com/torch_nn-in-pytorch#:~:text=PyTorch%20provides%20the%20torch.,any%20features%20from%20these%20models.\n",
        "PyTorch provides the torch.nn package to help us in creating and training the artificial neural networks. torch.nn provide us many classes and modules to \n",
        "implement and train the neural network.\n",
        "\n",
        "torch.optim => torch.optim is a package(= collection of modules(= python files)) implementing(= applying, using, utilizing) various optimization algorithms.\n",
        "\n",
        "Matplotlib is the most popular plotting(=sketching, drawing, designing, outlining) library for Python. python library = Collection of modules \n",
        "(modules = python files). Pyplot is a Matplotlib module which provides a MATLAB-like interface. Each pyplot function makes some change to a figure. For\n",
        "example, creates a figure, creates a plotting area in a figure, plots some lines in a plotting area,  decorates the plot with labels, etc. The various plots\n",
        "we can utilize using Pyplot are Line Plot, Histogram, Scatter, 3D Plot, Image, Contour, hexagonal binnning plot and Polar. Can also import as  \n",
        "\"import matplotlib.pyplot as plt\"\n",
        "\n",
        "as keyword is used as alias (AKA, also called as)\n",
        "'''\n",
        "import os\n",
        "import pickle as pkl\n",
        "import torch\n",
        "from torch.utils.data import Dataset\n",
        "from torch.utils.data import DataLoader\n",
        "import numpy as np\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from matplotlib import pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "atOv9b_jxpt7"
      },
      "source": [
        "'''\n",
        "numpy.random.seed() function => https://www.sharpsightlabs.com/blog/numpy-random-seed/\n",
        "initialize(=activate, start) random seed to generate(=produce, create) same random(=not fixed, ela padithe ala, without certain order) values every time\n",
        "The random module is a built-in module in python to generate the pseudo random values. random module uses random generator algorithm to generate pseudo \n",
        "random values. Pseudo random values are the computer-generated random values which appear to be random, but actually deterministic(=opposite of randomness,\n",
        "fixed, pre-planned, pre-determined)\n",
        "seed() function in random module provide seeds(=inputs, random inputs) to the random generator algorithm. And this random generator algorithm generate pseudo\n",
        "random value outputs.\n",
        "here, (1234) is the random input we have given\n",
        "'''\n",
        "np.random.seed(1234) #initialize random seed to generate same random values every time"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BRRxRK84Qfib"
      },
      "source": [
        "#PHM IEEE Dataset - Sequential(sequence)\n",
        "\n",
        "Helper Function = A helper function is a function that performs part of the computation (= operation, calculation, estimation, guess) of another function. Helper functions are used to make our programs (= codes) easier to read by giving names to computations. Helper functions also let you reuse computations, just as with functions in general. A helper function is a function we write because we need that particular functionality (= purpose, operation) of a function in multiple places in a code, and because it makes the code more readable. Instead of defining a particular functionality many times, insert(=put, embed) the functionality which we required many times in a helper function, so that we can use that particular functionality as many times we required without defining again"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-CjlfNLeQQaU"
      },
      "source": [
        "'''\n",
        "#Load(= activate, start) data from pickle(.pkz) file\n",
        "\n",
        "def keyword is used to define (= create) a function or method in python\n",
        "using def keyword we defined (= created) a function load_data_from_pfile and passed an argument file_path. Argument is the value to be passed in a function. \n",
        "Here file_path is the location of all pickle files. i.e. file_path = /content/drive/MyDrive/Colab Notebooks \n",
        "\n",
        "with keyword => automatically releases memory after allocation. Whenever we open the file with open() function, it allocates some resources and memory to the \n",
        "file. And we should use close() function to release or delete that memory from the file otherwise errors will come. Sometimes we forget to close() the file and \n",
        "we couldn’t find that we didn’t closed the file, so even the whole code is correct we might get errors and we may not be able to correct it. So it’s better to \n",
        "use “with” keyword along with open() function as “with” keyword automatically releases or deletes memory after process completion\n",
        "\n",
        "The open() function opens a file in text format by default. To open a file in binary format, add 'b' to the mode parameter. Hence the \"rb\" mode opens the file \n",
        "in binary format for reading, while the \"wb\" mode opens the file in binary format for writing. (Note: there are 2 basic mode parameters (r = read mode,w = write \n",
        "mode)). Unlike text files, binary files are not human-readable\n",
        "\n",
        "as = The as keyword is used to create an alias (= aka, also known as, also called). In the code, we created an alias pfile when opening the file_path, and now \n",
        "we can refer to the file_path (or we can access the file_path) by using pfile instead of file_path.\n",
        "\n",
        "Basically The pickle(.pkz) file is created using Python pickle and the dump() method and is loaded (=started, activated) using Python pickle and the load() \n",
        "method. we imported(=send) pickle module as pkl in the code. Therefore pkl.dump() is used to create pickle(.pkz) file and pkl.load() is used to load(=start, \n",
        "activate) pickle file. Here, pfile is the pickle file. Pkl.load(pfile) loads (= starts, activates) the pfile in rb (read binary) mode. We stored the loaded \n",
        "pfile in sample_data variable.\n",
        "\n",
        "return keyword = the return keyword is used to exit (= come out from) a function and return a value. Return sample_data => returns value of sample_data and \n",
        "                 exits a function.\n",
        "\n",
        "'''\n",
        "def load_data_from_pfile(file_path):  #Helper Function\n",
        "    with open(file_path, 'rb') as pfile:\n",
        "        sample_data = pkl.load(pfile)\n",
        "    return sample_data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4EBOWqZ-najC"
      },
      "source": [
        "'''\n",
        "created pkzfiles_path variable, and assigned(= allocate, allot, set) the path where the pickle(.pkz) files were saved in the pc or in the google drive.\n",
        "\n",
        "Python lists => https://www.w3schools.com/python/python_lists.asp (lists are used to store multiple items in a single variable)\n",
        "created pfiles list and stored 6 different bearings all data pickle files (bearing1_1_all_data.pkz, bearing1_2_all_data.pkz, bearing2_1_all_data.pkz, \n",
        "bearing2_2_all_data.pkz, bearing3_1_all_data.pkz, bearing3_2_all_data.pkz)\n",
        "\n",
        "Created an empty list named DATA\n",
        "\n",
        "for pfile in pfiles: => for loop - https://www.w3schools.com/python/python_for_loops.asp (A for loop is used for iterating over a sequence (that is either a \n",
        "list, a tuple, a dictionary, a set, or a string). )\n",
        "(here, pfile is an iterator. an iterator is an object used to iterate over iterable.)\n",
        "(here, pfiles is an iterable or sequence. an iterable is an object where iterator can iterate(= repeat, loop) over)\n",
        "(pfile is an iterator used to iterate over pfiles iterable or pfiles sequence)\n",
        "\n",
        "_data = load_data_from_pfile(pfile) => load_data_from_pfile(pfile) loads the data from a pickle file(pfile) and returns the data of the loaded pickle file\n",
        "                                       (here, pfile = bearing1_1_all_data.pkz or bearing1_2_all_data.pkz or bearing2_1_all_data.pkz or bearing2_2_all_data.pkz \n",
        "                                       or bearing3_1_all_data.pkz or bearing3_2_all_data.pkz). _data contains the data of a loaded pickle file(loaded pfile)\n",
        "\n",
        "_data['y'] = _data['y'][:, np.newaxis] => _data['y'] contains the list of failure probability values or fault probability values of a pfile\n",
        "                                          np.newaxis is used to add the new axis (= new dimension). Hence, _data['y'] values are stored in new dimension \n",
        "                                          (= new axis). i.e. if the data is stored in x-axis then fault probability values will be stored in y-axis\n",
        "\n",
        "DATA.append(_data) - DATA is the empty list which we created. append() - https://www.w3schools.com/python/ref_list_append.asp  (The append() method appends\n",
        "                     (= adds) an element to the end of the list. ). _data contains the data of a pfile in pfiles. now DATA list contains the data of each pfile\n",
        "                     in pfiles because we are appending(= adding) _data of each pfile to the DATA list. therefore DATA list contains the data of every pfile \n",
        "                     in pfiles\n",
        "                                          \n",
        "'''\n",
        "pkzfiles_path = '/content/drive/MyDrive/Colab Notebooks/'\n",
        "pfiles = [pkzfiles_path+'bearing1_1_all_data.pkz', pkzfiles_path+'bearing1_2_all_data.pkz', \\\n",
        "          pkzfiles_path+'bearing2_1_all_data.pkz', pkzfiles_path+'bearing2_2_all_data.pkz', \\\n",
        "          pkzfiles_path+'bearing3_1_all_data.pkz', pkzfiles_path+'bearing3_2_all_data.pkz']\n",
        "\n",
        "# load data as global (In python, an object(variable or list or tuple or dictionary or set) declared outside of the function(or method) or in global scope\n",
        "# (= range) is known as a global object. this means that a global object can be accessed inside or outside of the function (global object can be accessed \n",
        "# anywhere) in the code ) (accessed = read, obtained, acquired, examined)\n",
        "DATA = []  #Global List \n",
        "for pfile in pfiles:\n",
        "    _data = load_data_from_pfile(pfile)\n",
        "    _data['y'] = _data['y'][:, np.newaxis]\n",
        "    DATA.append(_data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k6bb5-dfn6KL"
      },
      "source": [
        "**torch Dataset class**\n",
        "\n",
        "(Basically, here we created a class for PHM IEEE Dataset(Pronostia Bearing dataset) named PHMDataset_Sequential and this PHMDataset_Sequential class inherting(obtaining, acquiring, getting, recieving) the functionality(properties and methods) from PyTorch Dataset class(i.e. torch.utils.data.Dataset))\n",
        "\n",
        "(Converting numpy array (nd array) into tensor)\n",
        "\n",
        "https://pytorch.org/tutorials/beginner/data_loading_tutorial.html\n",
        "\n",
        "torch.utils.data is a data loading (=activation) class of Torch (or PyTorch)\n",
        "\n",
        "torch.utils.data.Dataset is an abstract class representing(= considered as) a dataset. custom dataset (= if the dataset can be modified (=changed) according to our (user’s) requirements, then dataset is considered as custom dataset, for example we are modifying torch dataset in the code, so torch dataset is the custom dataset) should inherit (= acquire, obtain, derive, get, receive) Dataset and apply (= use) the following methods:\n",
        "\n",
        "(1) `__len__` so that len(dataset) returns the size of the dataset\n",
        "\n",
        "(2) `__getitem__` to support the indexing such that dataset[i] can be used to get ith sample (data)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DpRGA9sJtMqF"
      },
      "source": [
        "'''\n",
        "Python classes and objects => https://www.w3schools.com/python/python_classes.asp\n",
        "A Class is like an object constructor, or a blueprint for creating objects. and objects of the class is used as references to access (= read, get, obtain,\n",
        "examine, acquire) the class properties (properties = variables, arrays, lists, etc.)\n",
        "\n",
        "Python Inheritance => https://www.w3schools.com/python/python_inheritance.asp\n",
        "Inheritance allows us to define a class that inherits (= acquires, obtains, gets, recieves) all the methods and properties from another class. The process of \n",
        "deriving(= obtaining, acquiring) one class(child class) from another class(parent class)\n",
        "\n",
        "Created PHMDataset_Sequential class using class keyword. we send Dataset as the parameter inside the class. To create a class that inherits the functionality \n",
        "(=methods and properties) from another class, send the parent class as a parameter when creating the child class. Here, parameter Dataset is the parent class \n",
        "and PHMDataset_Sequential is the child class. Parent class is a class from which a class inherits, parent class also called as base class or super class. \n",
        "Child class is a class which inherits from another class (parent class), child class also called as derived class or sub class. \n",
        "class PHMDatset_Sequential(Dataset) => this means PHMDataset_Sequential class inherits the functionality (= methods and properties) from Dataset class\n",
        "\n",
        "Using def keyword, we defined (= created) __init__ function. __init__ function is used to assign values to class object properties or other operations that are \n",
        "necessary to do when the object is being created. The __init__() function is called automatically every time the class is being used to create a new object. We \n",
        "added __init__() function to the child class, therefore the child class will no longer inherit the parent's __init__() function. The child's __init__() \n",
        "function overrides (= removes, ignores) the inheritance of the parent's __init__() function.\n",
        "The self parameter is a reference to the current (= present, ongoing) instance (= object) of the class, and is used to access (= read, obtain, examine, acquire) \n",
        "the properties (like variables, arrays, lists, dictionaries, tuples, strings) that belongs to the class. example: self.dataset_id = dataset_id, \n",
        "self.indices = indices, self.seq_len = seq_len (reference in python = a python program accesses (= reads, obtains, gets) data values through (= via) references. \n",
        "A reference is a name that refers to the specific (= certain, particular) location in memory of a value (object))\n",
        "\n",
        "def keyword is used to create a function. using def keyword defined (= created) __len__() function and passed self parameter as an argument. __len__() function\n",
        "returns the size of the dataset. we passed self parameter in __len__() function, hence we can access all self parameter or self object properties inside the\n",
        "__len__() function.\n",
        "return len(self.indices) => (doubt)\n",
        "\n",
        "def keyword is used to create a function. using def keyword defined (= created) __getitem__() function and passed self parameter and i as argmuments. arguments\n",
        "are the values that can be passed inside the function. arguments should be passed inside the parenthesis of function name. __getitem__() is used to support the \n",
        "indexing such that dataset[i] can be used to get ith sample (ith data). we passed self parameter in __getitem__() function, hence we can access all self \n",
        "parameter or self object properties inside the __getitem__() function. i is used to access the ith data (ith sample or ith item) in tensor\n",
        "\n",
        "sample_id = self.indices[i] => sample_id store the ith sample (ith data) indices from the dataset that needs to be included in the output sequence\n",
        "                               (indices = plural of index)\n",
        "    \n",
        "the function torch.from_numpy() => converts a numpy array into a tensor \n",
        "numpy array => https://www.javatpoint.com/numpy-array, \n",
        "tensor => https://www.javatpoint.com/pytorch-tensors#:~:text=A%20tensor%20is%20an%20n,computation%20with%20strong%20GPU%20acceleration. \n",
        "tensor = torch.from_numpy(numpy.array) => general syntax to Create a Tensor from numpy array\n",
        "created sample dictionary with x key and y key. x key contains tensor of DATA[self.dataset_id]['x'][sample_id:sample_id+self.seq_len] i.e. contains the tensor \n",
        "of every pfile image sequences of specific with seq_len. y key contains tensor of DATA[self.dataset_id]['y'][sample_id+self.seq_len-1] i.e. contains the tensor \n",
        "of failure probability values of the last frame (last time output sequence) \n",
        "return sample => __getitem__() function return the sample dictionary as an output and exits the function\n",
        "'''\n",
        "class PHMDataset_Sequential(Dataset):\n",
        "    '''\n",
        "    PHM IEEE data set where each item(data) is a sequence(sequence = sequence is an input sample(input example) consists of multiple data points. There can be \n",
        "    a variable(= changeable) number of these data points in a sequence input sample and the data points in the sequence depend on each other)\n",
        "    '''\n",
        "    def __init__(self, dataset_id=0, indices=[], seq_len=5):\n",
        "        '''\n",
        "        dataset_id = index(= position) of dataset to read from  (index = An index is a numerical representation of an item's(a data) position in a sequence)\n",
        "        indices = indices from the dataset that needs to be included in the output sequence \n",
        "        seq_len = length of the output sequence (sequence output sample) i.e., return a sequence of length `seq_len` from the dataset as `x` and fault \n",
        "        probability of the last frame (last frame means last time output sequence, since it is a time series data) as `y` \n",
        "        '''\n",
        "        self.dataset_id = dataset_id\n",
        "        self.indices = indices \n",
        "        self.seq_len = seq_len \n",
        "    \n",
        "    def __len__(self):\n",
        "        return len(self.indices)\n",
        "    \n",
        "    def __getitem__(self, i):\n",
        "        sample_id = self.indices[i] \n",
        "        sample = {'x': torch.from_numpy(DATA[self.dataset_id]['x'][sample_id:sample_id+self.seq_len]), \n",
        "                  'y': torch.from_numpy(DATA[self.dataset_id]['y'][sample_id+self.seq_len-1])}\n",
        "        return sample"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Skc02UN8cuEq"
      },
      "source": [
        "**Splitting(=dividing, separating) into train data sequences and val data sequences and printing the no. of train data sequences and printing the no. of val data sequences of all 6 bearing pickle files**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OwTfFy1Ex8fa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e6b64600-4b75-42a1-e1c5-265cd4b2e386"
      },
      "source": [
        "'''\n",
        "SEQ_LEN = 5 => SEQ_LEN - each sequence length, therefore each sequence contains 5 data points\n",
        "\n",
        "created VAL_SPLIT variable to store the percentage of data split(= divide, separate) into validation data from learning or training data.\n",
        "since we assigned, 0.1 to the VAL_SPLIT variable, we are separating 10% data from learning or training data (total training data) and made it as validation data\n",
        "\n",
        "created train_datasets empty list and val_datasets empty list\n",
        "\n",
        "for dataset_id in range(len(DATA)): => for loop - https://www.w3schools.com/python/python_for_loops.asp (A for loop is used for iterating over a sequence (that \n",
        "is either a list, a tuple, a dictionary, a set, or a string). )\n",
        "(here, dataset_id is an iterator. an iterator is an object used to iterate over an iterable. (dataset_id = index of the dataset to read from))\n",
        "(range() => https://www.w3schools.com/python/ref_func_range.asp , (The range() function returns a sequence of numbers, starting from 0 by default, and \n",
        "increments by 1 (by default), and stops before a specified number.) Syntax :: range(start, stop, step) - start : Optional(may or may not required). An integer \n",
        "number specifying at which position to start. Default is 0 , stop : Required(must be required). An integer number specifying at which position to stop \n",
        "(not included) , step : Optional(may or may not required). An integer number specifying the incrementation. Default is 1 )\n",
        "len(DATA) - DATA : DATA is a global list that contains the data of every pfile in pfiles (pfile represents pickle file). len() function is a built-in function \n",
        "            in python. we use len() to get the length of the list i.e. DATA\n",
        "\n",
        "no_of_files = DATA[dataset_id]['x'].shape[0] => DATA[dataset_id]['x'].shape[0] return the no. of sequences of length 5 for every dataset_id in 0th dimension\n",
        "                                                (x-axis)\n",
        "                                                DATA : DATA is a global list that contains the data of every pfile in pfiles (pfile represents pickle file)\n",
        "                                                dataset_id : index(= position) of dataset to read from   (here, dataset is DATA)\n",
        "                                                'x' : sequence of length SEQ_LEN i.e. 5 from DATA\n",
        "                                                shape : shape in python returns the no. of elements in each dimension. shape returns the output in tuple format.\n",
        "                                                        shape[0] => returns the no. of elements in 0th dimension. (returns the no. of elements in x-axis)\n",
        "                                                (no_of_files represent total no. of files. basically, no_of_files contains data(data files or records))\n",
        "\n",
        " no_of_seqs = no_of_files-SEQ_LEN+1 => (basically, no_of_seqs contains number of sequences)\n",
        "                                       example : if we have 5 data file or 5 records, then the no. of sequences of length 2 will be 4 (no_of_files - SEQ_LEN +1)\n",
        "                                                 i.e. 5-2+1 = 4 (if 1,2,3,4,5 are the total records or total data files, sequences of the length 2 are \n",
        "                                                 (1,2), (2,3), (3,4), (4,5) )\n",
        "(therefore, based on above example, no_of_files = 5, no_of_seqs = 4  note: the above example is just for my understanding purpose, there is no link for above\n",
        "example and below code)  \n",
        "\n",
        "no_of_val = int(VAL_SPLIT*no_of_seqs) => no_of_val represents no. of validation data sequences\n",
        "                                         int - https://www.w3schools.com/python/ref_func_int.asp  (The int() function converts the specified value into an \n",
        "                                         integer number. Syntax : int(value, base), value - A number or a string that can be converted into an integer number\n",
        "                                         base - A number representing the number format. Default value: 10 )\n",
        "                                         VAL_SPLIT variable stored the percentage of data split(= divide, separate) into validation data. since we assigned, 0.1 \n",
        "                                         to the VAL_SPLIT variable, that means separating 10% data and made it as validation data. (val_split = 0.1)\n",
        "                                         no_of_seqs - represents number of sequences\n",
        "                                         VAL_SPLIT*no_of_seqs - means separating 10% sequences from no_of_seqs and those 10% sequences are considered as \n",
        "                                         validation data sequences\n",
        "\n",
        "perm = np.random.permutation(no_of_seqs) => permutation - randomly changing the arrangement of data. (each of several possible ways in which a set of data or \n",
        "                                                          number of values can be ordered or arranged)\n",
        "                                            perm = np.random.permutation(no_of_seqs) - Created perm variable and stored the sequences by applying permutation.\n",
        "                                            (that means after every iteration a sequence with random order will be generated and stored in perm variable)\n",
        "\n",
        "val_indices = perm[0:no_of_val] => applied permutation to all the validation data sequences and stored in val_indices\n",
        "                                   (permutation - randomly changing the arrangement of data in validation data sequences. (each of several possible ways in \n",
        "                                    which a set of data or number of values can be ordered or arranged in a sequence))\n",
        "\n",
        "train_indices = perm[no_of_val:] => applied permutation to all the train data sequences and stored in train_indices\n",
        "                                   (permutation - randomly changing the arrangement of data in train data sequences. (each of several possible ways in \n",
        "                                    which a set of data or number of values can be ordered or arranged in a sequence))\n",
        "( no_of_seqs - is the sequences (learning data sequences or training data sequences)\n",
        "  train_indices - is the train data image sequences in random order (90% data sequences of learning data sequences are considered as train data sequences)\n",
        "  val_indices - is the validation data image sequences in random order (10% data sequences of learning data sequences are considered as validation data \n",
        "                sequences) )\n",
        "\n",
        "train_dataset = PHMDataset_Sequential(dataset_id=dataset_id, indices=train_indices, seq_len=SEQ_LEN) =>\n",
        "                created train_dataset variable and called PHMDataset_Sequential class and send dataset_id, indices, and seq_len as parameters inside the class \n",
        "                and assigned dataset_id, train_indices and SEQ_LEN respectively to the parameters \n",
        "                train_dataset = returns and contains the train data sequences of SEQ_LEN(with length 5) of a bearing pickle file of dataset_id \n",
        "                (dataset_id = 1 represents bearing1_1_all_data.pkz, dataset_id = 2 represents bearing1_2_all_data.pkz, dataset_id = 3 represents \n",
        "                bearing2_1_all_data.pkz, dataset_id = 4 represents bearing2_2_all_data.pkz, dataset_id = 5 represents bearing3_1_all_data.pkz, dataset_id = 6 \n",
        "                represents bearing1_2_all_data.pkz )\n",
        "\n",
        "val_dataset = PHMDataset_Sequential(dataset_id=dataset_id, indices=val_indices, seq_len=SEQ_LEN) =>\n",
        "              created val_dataset variable and called PHMDataset_Sequential class and send dataset_id, indices, and seq_len as parameters inside the class \n",
        "              and assigned dataset_id, val_indices and SEQ_LEN respectively to the parameters\n",
        "              val_dataset = returns and contains the validation data sequences of SEQ_LEN(with length 5) of a bearing pickle file of dataset_id \n",
        "              (dataset_id = 1 represents bearing1_1_all_data.pkz, dataset_id = 2 represents bearing1_2_all_data.pkz, dataset_id = 3 represents \n",
        "              bearing2_1_all_data.pkz, dataset_id = 4 represents bearing2_2_all_data.pkz, dataset_id = 5 represents bearing3_1_all_data.pkz, dataset_id = 6 \n",
        "              represents bearing1_2_all_data.pkz )\n",
        "\n",
        " print(len(train_dataset), len(val_dataset)) => printing the length of train_dataset (i.e. printing the no. of train data sequences of SEQ_LEN = 5 for each\n",
        "                                                bearing pickle file at a time) and printing the length of val_dataset (i.e. printing the no. of validation data \n",
        "                                                sequences of SEQ_LEN = 5 for each bearing pickle file at a time)\n",
        "(The len() function returns the length of an object (i.e. returns the number of items in an object.))\n",
        "\n",
        " train_datasets.append(train_dataset) => append - https://www.w3schools.com/python/ref_list_append.asp (The append() method appends(adds) an element to the end \n",
        "                                         of the list.)\n",
        "                                         train_datasets.append(train_dataset) - train_datasets is an empty list and here we are appending(= adding) \n",
        "                                         train_dataset of each pickle file. therefore train_datasets list now contains the train data sequences of all 6\n",
        "                                         bearing pickle files\n",
        " \n",
        " val_datasets.append(val_dataset) => append - https://www.w3schools.com/python/ref_list_append.asp (The append() method appends(adds) an element to the end \n",
        "                                     of the list.)\n",
        "                                     val_datasets.append(val_dataset) - val_datasets is an empty list and here we are appending(= adding) \n",
        "                                     val_dataset of each pickle file. therefore val_datasets list now contains the validation data sequences of all 6\n",
        "                                     bearing pickle files\n",
        "'''\n",
        "SEQ_LEN = 5 # sequence length\n",
        "VAL_SPLIT = 0.1\n",
        "\n",
        "train_datasets, val_datasets = [], []\n",
        "for dataset_id in range(len(DATA)):\n",
        "    no_of_files = DATA[dataset_id]['x'].shape[0]\n",
        "    no_of_seqs = no_of_files-SEQ_LEN+1\n",
        "    no_of_val = int(VAL_SPLIT*no_of_seqs)\n",
        "    perm = np.random.permutation(no_of_seqs)\n",
        "    val_indices = perm[0:no_of_val]\n",
        "    train_indices = perm[no_of_val:]\n",
        "\n",
        "    train_dataset = PHMDataset_Sequential(dataset_id=dataset_id, indices=train_indices, seq_len=SEQ_LEN) \n",
        "    val_dataset = PHMDataset_Sequential(dataset_id=dataset_id, indices=val_indices, seq_len=SEQ_LEN) \n",
        "    print(len(train_dataset), len(val_dataset)) \n",
        "\n",
        "    train_datasets.append(train_dataset) \n",
        "    val_datasets.append(val_dataset) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2520 279\n",
            "781 86\n",
            "817 90\n",
            "714 79\n",
            "460 51\n",
            "1470 163\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "29q-gxw_efTp"
      },
      "source": [
        "'''\n",
        "batch_size => refers to the no. of samples in each batch\n",
        "\n",
        "train_batch_size = 16 => batch size of train dataset sequences is 16, that means train dataset sequences divided into batches (= groups, collection) of data \n",
        "                         and each batch sequence contains 16 samples (16 number of data)\n",
        "\n",
        "val_batch_size = 16 => batch size of validation dataset sequences is 16, that means validation dataset sequences divided into batches (= groups, collection) of \n",
        "                       data and each batch sequence contains 16 samples (16 number of data)\n",
        "'''\n",
        "train_batch_size = 16\n",
        "val_batch_size = 16"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZwF0fp5HnOJM"
      },
      "source": [
        "**torch DataLoader**\n",
        "\n",
        "https://pytorch.org/tutorials/beginner/data_loading_tutorial.html\n",
        "\n",
        "Following features are essential when loading(= activating, starting) data for training the models\n",
        "\n",
        "Batching data => splitting(= dividing) the dataset into a collection(= batch) of smaller data chunks(= portions, blocks) that are send into the model one at a time. (Basically, batching data means dividing the dataset into batches of data and feed that batches as input to the model one at a time\n",
        "\n",
        "Shuffling data => rearranging data or reorganizing data. data shuffling is important because by shuffling the data, one can make sure that each data point creates a separate change on the model, without being affected(= altered, changed) by the same data points before them\n",
        "\n",
        "(optionally) load tha data in parallel using multiprocessing workers\n",
        "\n",
        "torch.utils.data.DataLoader is an iterator which provides all these features\n",
        "\n",
        "(iterator in python is an object that is used to iterate(= repeat, loop) over iterable objects like lists, tuples, dictionaries, and sets. the iterator object is initialized using the iter() method. iterator uses the next() method for iteration)\n",
        "\n",
        "(iterable is an object, which one can iterate(=repeat, loop) over. examples: lists, tuples, dictionaries, sets. iterable generates an iterator when passed(=moved) to iter() method. iterator is an object, which is used to iterate over an iterable object using next() method)\n",
        "\n",
        "(every iterator is also an iterable, but not every iterable is an iterator)\n",
        "\n",
        "Note: if for loop is used to iterate(= repeat, loop) over the data, then these features(Batching data, shuffling data) are not included which makes data loading somewhat difficult and requires more processing time"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nf0z_9lFeTit"
      },
      "source": [
        "sample dataloader(train_dataloaders) that loads batch of 16 samples(train data sequences) at a time \n",
        "\n",
        "sample dataloader(val_dataloaders) that loads batch of 16 samples(val data sequences) at a time "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1lwM5I5jju2Z"
      },
      "source": [
        "'''\n",
        "train_dataloaders = [] => train_dataloaders is an empty list\n",
        "\n",
        "for train_dataset in train_datasets: \n",
        "    train_dataloaders.append( DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True, num_workers=1) ) =>\n",
        "(train_dataset - is the train data sequences of a single bearing pickle file\n",
        "batch_size => refers to the no. of samples (no. of data sequences) in each batch\n",
        "shuffle => whether we want the data to be shuffled(= rearranged or reorganized) or not. shuffle is a boolean value, either true or false. shuffle=true \n",
        "represents data to be shuffled. shuffle=false represents data not to be shuffled\n",
        "num_workers => no. of processes needed for loading(= activating, starting) the data, here, num_workers=1, therefore 1 time processing will be carried out for\n",
        "data loading) \n",
        "(Here, we are loading(= starting, activating) the train data sequences of all 6 bearing pickle files)\n",
        "(90% of the data in each bearing pickle file is considered as train data)\n",
        "(we are loading a batch of 16 train data sequences at a time)\n",
        "(shuffle=True - Train Data sequences in batches are rearranged)\n",
        "(num_workers=1, processing will be carried out 1 time for train data sequences loading)\n",
        "\n",
        "val_dataloaders = [] => val_dataloaders is an empty list \n",
        "(val_dataset - is the validation data sequences of a single bearing pickle file\n",
        "batch_size => refers to the no. of samples (no. of data sequences) in each batch\n",
        "shuffle => whether we want the data to be shuffled(= rearranged or reorganized) or not. shuffle is a boolean value, either true or false. shuffle=true \n",
        "represents data to be shuffled. shuffle=false represents data not to be shuffled\n",
        "num_workers => no. of processes needed for loading(= activating, starting) the data, here, num_workers=1, therefore 1 time processing will be carried out for\n",
        "data loading) \n",
        "(Here, we are loading(= starting, activating) the validation data sequences of all 6 bearing pickle files)\n",
        "(10% of the data in each bearing pickle file is considered as val data)\n",
        "(we are loading a batch of 16 val data sequences at a time)\n",
        "(shuffle=True - val Data sequences in batches are rearranged)\n",
        "(num_workers=1, processing will be carried out 1 time for val data sequences loading)\n",
        "\n",
        "'''\n",
        "train_dataloaders = []\n",
        "for train_dataset in train_datasets:  \n",
        "    train_dataloaders.append( DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True, num_workers=1) ) \n",
        "\n",
        "val_dataloaders = []\n",
        "for val_dataset in val_datasets:  \n",
        "    val_dataloaders.append( DataLoader(val_dataset, batch_size=val_batch_size, shuffle=False, num_workers=1) ) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ml-9_Z2K6gb_"
      },
      "source": [
        "#Note: \n",
        "\n",
        "pytorch expects (takes) input to a CNN as shape - [NxCxHxW] as opposed to [NxHxWxC] in keras or tensorflow. We already have input image feature shapes in [CxHxW] format stored in pickle files\n",
        "\n",
        "N => batch size, C => no. of channels or no. of filters, H => height of an image in pixels, W => width of an image in pixels\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VDMyyeA5nJYP"
      },
      "source": [
        "#Model Architecture (CNN + LSTM)\n",
        "\n",
        "**CNN Model Architecture** - https://docs.google.com/presentation/d/1zBWkbJVMJlYxCUdSXEP2LSetPUmhVUfumaAzdb5Zd3I/edit?usp=sharing\n",
        "\n",
        "([CNN_Architecture](https://docs.google.com/presentation/d/1zBWkbJVMJlYxCUdSXEP2LSetPUmhVUfumaAzdb5Zd3I/edit?usp=sharing) )\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j_-VdBNqdWI3"
      },
      "source": [
        "**Convolution + Batch Normalization + ReLU Activation**\n",
        "\n",
        "References:\n",
        "\n",
        "(1) Conv2d - https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html\n",
        "\n",
        "(2) torch.nn.Sequential() - https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html\n",
        "\n",
        "(3) BatchNorm1D - https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm1d.html\n",
        "\n",
        "(4) BatchNorm2d - https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm2d.html#torch.nn.BatchNorm2d\n",
        "\n",
        "(5) ReLU - https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html#torch.nn.ReLU"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jWUpYOYjnITL"
      },
      "source": [
        "'''\n",
        "using def keyword, defined(= created) conv_bn_relu() function and passed in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1,\n",
        "bias=True, padding_mode='zeros', batch_norm=True as parameters(arguments or values) to the function. (in conv_bn_relu(), conv represents convolution, bn \n",
        "represents batch normalization, relu represents rectified linear units layer activation function)\n",
        "in_channels (int datatype only) – Number of channels or number of filters in the input image\n",
        "out_channels (int datatype only) – Number of channels or number of filters produced by the convolution.(Convolution operation is element-wise multiplication. \n",
        "Convolution operation is the element-wise multiplication of each pixel value inside the image. In CNN, the main objective of convolution operation is to extract \n",
        "necessary features from the input image)\n",
        "kernel_size (int datatype or tuple datatype) – Size of the convolving kernel (or convolving filter). (Convolving filter is the filter which we used to perform\n",
        "convolution operation on the image). for example if kernel_size=3 => means convolving filter (or filter or kernel) will be of the size 3x3\n",
        "stride (int datatype or tuple datatype, optional) – Stride of the convolution. Default: 1 (stride is the no. of pixels (pixel values) shifts (moves, movements, \n",
        "transfers, changes, alterations) over the input image matrix. (Note: shifts are done only from left to right). stride = 1 => means move the filter to 1 pixel \n",
        "at a time. (that means if the filter first starts at pixel value 1 and completes the process (matrix multiplication), second time it starts at pixel value 2.). \n",
        "stride = 2 => means move the filter to 2 pixels at a time. (that means if the filter first starts at pixel value 1 and completes the process (matrix \n",
        "multiplication), second time it starts at pixel value 3.)\n",
        "padding (int datatype or tuple datatype, optional) – Zero-padding added to all sides of the input. Default: 0. (padding means simply a process of adding \n",
        "layers of zeros to our input images. padding = 0 => means adding 0 extra rows and 0 extra columns around (= on every side, on all sides) an input image. \n",
        "padding = 1 => means adding 1 extra row and 1 extra column around (= on every side, on all sides) an input image. Advantage of padding: padding prevents the \n",
        "image from shrinking (= get smaller, reduce size), it also helps preventing dimensionality reduction.)\n",
        "dilation (int datatype or tuple datatype, optional) – Spacing (= distance, gap) between kernel (or filter) elements. Default: 1\n",
        "groups - tells us how many output channels(or filters) to be used to combine with input channels to perform convolution. (example: groups=1 means each input\n",
        "channel combines with total(all) filters to perform convolution and get output, groups=2 means input and output channels divides into 2 groups and performs \n",
        "convolution in each group)\n",
        "bias - After multiply the inputs with weights(filters), we add the bias at last. (in y = ax + b, b => bias, a => weights(filters), x => inputs). Bias is like \n",
        "the intercept (b) added in a linear equation (y = ax + b). Bias is an additional parameter in the neural network which is used to adjust the output along with \n",
        "the weighted sum of the inputs to the neuron. Thus, Bias is a constant which helps the model in a way that model can fit(= suitable, apt, appropriate, relevant) \n",
        "best for the given data. Advantage of Bias : prevents biased prediction(prediction based on favoritism, unfairness prediction, inequality prediction).\n",
        "bias (bool datatype, optional) – If True, adds a learnable (= able to be learned) bias to the output. Default: True (bias=True)\n",
        "padding_mode (string datatype, optional) – There are different padding modes in CNN such as 'zeros', 'reflect', 'replicate', 'circular'. Default padding mode: \n",
        "'zeros'\n",
        "batch_norm - batch normalization, rescaling (=resetting, adjusting) all the data (values or pixel values) of a batch (= group, collection) in a particular range \n",
        "(-1 to 1) or [-1,1]. (batch_norm=True => if batch_norm is True, batch normalization will be applied)\n",
        "\n",
        "nn.Conv2d() => Applies a 2D convolution (= 2D convolution means performing convolution operation with 2x2 filters i.e. sliding 2x2 filters over an image) over \n",
        "               an input signal. passed in_channels, out_channels, kernel_size, stride=stride, padding=padding, dilation=dialtion, groups=groups, bias=bias,\n",
        "               padding_mode=padding_mode as arguments (values or parameters) inside the nn.Conv2d() function\n",
        "\n",
        "nn.init.xavier_uniform_(conv.weight) => method used to randomly(= ela padithe ala) initialize(= activate, start, store) the weights, if we initialize like this,\n",
        "                                        the training will be better\n",
        "\n",
        "nn.ReLU() => Applies the Rectified Linear Units function element-wise, ReLU(x) = (x)+ = max(0,x). (ReLU => Rectified Linear Units layer, ReLU is an activation \n",
        "function that will output the positive values or non-negative values (> 0) as it is without change, whereas output the negative values (< 0) as zero (0). \n",
        "Advantage of ReLU: ReLU allows the models to learn faster and perform better, avoids overfitting.) (Note: Activation function: An activation function transforms \n",
        "the shape/representation of the data going into it.)\n",
        "\n",
        "if batch_norm: => represents if batch_norm is True (i.e. if batch_norm==True) (if batch_norm==True, applies batch normalization over an input image)\n",
        "return nn.Sequential(conv, nn.BatchNorm2d(out_channels), relu)\n",
        "return keyword = The return keyword is used to exit (= come out from) a function and return a value\n",
        "nn.Sequential() function => acts as a sequential(= occuring in an order, consecutive) container(= storage, holder). Modules will be added to Sequential() in the \n",
        "order and modules are passed as arguments into the Sequential() function. (Here modules are Conv2d(), BatchNorm2d() and ReLU())\n",
        "BatchNorm2d() => applies a batch normalization over a 4D input image\n",
        "\n",
        "else: => represents if batch_norm is False (i.e. if batch_norm==False or if batch_norm!=True) (if batch_norm==False, don't apply batch normalization over an \n",
        "         input image)\n",
        "'''\n",
        "def conv_bn_relu(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', batch_norm=True):\n",
        "    conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=bias, padding_mode=padding_mode)\n",
        "    nn.init.xavier_uniform_(conv.weight)\n",
        "    relu = nn.ReLU()\n",
        "    if batch_norm:\n",
        "        return nn.Sequential(\n",
        "            conv,\n",
        "            nn.BatchNorm2d(out_channels),\n",
        "            relu\n",
        "        )\n",
        "    else:\n",
        "        return nn.Sequential(\n",
        "            conv,\n",
        "            relu\n",
        "        )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tKTQ9J_6XrCr"
      },
      "source": [
        "**CNN for Encoding**\n",
        "\n",
        "Encoding - Encoding is the process of converting data from one form to another form\n",
        "\n",
        "**CNN Encoder** - https://docs.google.com/presentation/d/1G9Qov2ul2LTh5sKRSwMZXHWEr2TJtpVesLWj1Dj5NS0/edit#slide=id.p \n",
        "\n",
        "([CNN Encoder](https://docs.google.com/presentation/d/1G9Qov2ul2LTh5sKRSwMZXHWEr2TJtpVesLWj1Dj5NS0/edit#slide=id.p))\n",
        "\n",
        "CNN Encoder converts the 2D image input data into 1D linear continuous vector by flatenning. (In computer programming, a vector is an array with only one dimension) (linear means straight or looking like a line)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1jlOmDZJAKtp"
      },
      "source": [
        "References: \n",
        "\n",
        "(1) torch.nn.Module - https://pytorch.org/docs/stable/generated/torch.nn.Module.html\n",
        "\n",
        "(2) MaxPool2d - https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html#torch.nn.MaxPool2d\n",
        "\n",
        "(3) Flatten - https://pytorch.org/docs/stable/generated/torch.nn.Flatten.html#torch.nn.Flatten\n",
        "\n",
        "(4) Linear -  https://pytorch.org/docs/stable/generated/torch.nn.Linear.html#torch.nn.Linear\n",
        "\n",
        "(5) Dropout - https://pytorch.org/docs/stable/generated/torch.nn.Dropout.html\n",
        "\n",
        "(6) forward call or forward pass (forward( )) - https://deeplizard.com/learn/video/MasG7tZj-hw\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PF1wD4FYARY4"
      },
      "source": [
        "Note: pytorch expects (takes) input to a CNN as shape - [NxCxHxW] as opposed to [NxHxWxC] in keras or tensorflow. We already have input image feature shapes in [CxHxW] format stored in pickle files\n",
        "\n",
        "N => batch size, C => no. of channels or no. of filters, H => height of an image in pixels, W => width of an image in pixels"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-5q_W0cYfhty"
      },
      "source": [
        "'''\n",
        "# CNN for Encoding\n",
        "\n",
        "Python classes and objects => https://www.w3schools.com/python/python_classes.asp\n",
        "A Class is like an object constructor, or a blueprint for creating objects. and objects of the class is used as references to access (= read, get, obtain,\n",
        "examine, acquire) the class properties (properties = variables, arrays, lists, etc.)\n",
        "\n",
        "Python Inheritance => https://www.w3schools.com/python/python_inheritance.asp\n",
        "Inheritance allows us to define a class that inherits (= acquires, obtains, gets, recieves) all the methods and properties from another class.\n",
        "\n",
        "Created CNN_CWT_Encoder class using class keyword. send nn.Module class as the parameter inside the CNN_CWT_Encoder class. nn.Module is the Base class(or super \n",
        "class or parent class) for all neural network modules(= basically, a module is a python file. module is a file consisting of python code. module can define \n",
        "functions, classes and variables). nn.Module class contains all the methods and properties of neural networks. our models should also subclass this class. \n",
        "(i.e. our model should inherits (= acquires, obtains, gets, recieves) all the methods and properties from this nn.Module class.). To create a class that \n",
        "inherits the functionality (=methods and properties) from another class, send the parent class as a parameter when creating the child class. Here, nn.Module is \n",
        "the parent class and CNN_CWT_Encoder is the child class. Parent class is a class from which a class inherits. Child class is a class which inherits from another \n",
        "class (parent class), child class also called as derived class or sub class class CNN_CWT_Encoder(nn.Module) => this means CNN_CWT_Encoder class inherits the \n",
        "functionality (= methods and properties) from nn.Module class\n",
        "\n",
        "Using def keyword, we defined (= created) __init__ function. __init__ function is used to assign values to class object properties or other operations that are \n",
        "necessary to do when the object is being created. The __init__() function is called automatically every time the class is being used to create a new object. We \n",
        "added __init__() function to the child class, therefore the child class will no longer inherit the parent's __init__() function. The child's __init__() function\n",
        "overrides (= removes, ignores) the inheritance of the parent's __init__() function. The self parameter is a reference to the current (= present, ongoing) \n",
        "instance (= object) of the class, and is used to access (= read, obtain, examine, acquire) the properties (like variables, arrays, lists, dictionaries, tuples, \n",
        "strings) that belongs to the class. (reference in python = a python program accesses (= reads, obtains, gets) data values through (= via) references. A \n",
        "reference is a name that refers to the specific (= certain, particular) location in memory of a value (object))\n",
        "\n",
        "super().__init__() => this initializes (= starts, activates) the parent class (i.e. nn.Module), basically this activates the nn.Module class and uses nn.Module\n",
        "class functionality (properties and methods)\n",
        "\n",
        "conv1 is the property (property in class means variable of a class or array of a class or string of a class or list of a class or dictionary of a class or tuple \n",
        "of a class) of CNN_CWT_Encoder class and self parameter is the object of CNN_CWT_Encoder class which is used to access conv1. conv_bn_relu() function applies \n",
        "Convolution, Batch Normalization and ReLU activation function if batch_norm is True else (i.e. batch_norm is False) applies Convolution and ReLU activation \n",
        "function. conv_bn_relu() function takes in_channels, out_channels, kernel_size, stride, padding, bias, batch_norm as parameters (arguments or values) to the \n",
        "function. here, in_channels=2, out_channels=16, kernel_size=3, stride=1, padding=1, bias=True, batch_norm=True\n",
        "\n",
        "pool1 is the property of CNN_CWT_Encoder class and self parameter is the object of CNN_CWT_Encoder class which is used to access pool1. nn.MaxPool2d() Applies a \n",
        "2D max pooling over an input. (Max pooling is a pooling operation that selects the maximum element (max pixel value) from the region of feature map covered by \n",
        "the filter.) (pooling means combining pixel values as groups, since we taken 2x2 filter for max pooling, one 2x2 matrix is considered as one group). Basically \n",
        "max pool returns the maximum pixel value (maximum element) from feature maps (feature images) and outputs a pooled feature map. nn.MaxPool2d() takes kernel_size \n",
        "and stride as parameters (arguments or values) to the function. here, kernel_size=2, stride=2\n",
        "\n",
        "conv2, pool2, conv3, pool3, conv4, pool4 => approach is same as conv1 and pool1\n",
        "\n",
        "flatten is the property of CNN_CWT_Encoder class and self parameter is the object of CNN_CWT_Encoder class which is used to access flatten. nn.Flatten() \n",
        "Flattens(=reduces) a contiguous(=adjacent, side-by-side, close, next-to) range(area, space) of dimensions into a tensor \n",
        "(tensor = https://www.javatpoint.com/pytorch-tensors#:~:text=A%20tensor%20is%20an%20n,computation%20with%20strong%20GPU%20acceleration)\n",
        "(tensor = A tensor is an n-dimensional data container. For example, In PyTorch, 1d-tensor is a vector, 2d-tensor is a matrix, 3d- tensor is a cube, and \n",
        "4d-tensor is a cube vector.)\n",
        "(Basically, flatten => flattening is converting the data (image pixel values) into a 1-dimensional array for inputting it to the next layer. Flatten the output \n",
        "                       of the convolution and max pool layers to create a single long feature vector (or single linear continuous vector). And this vector is \n",
        "                       connected to the final classification model, which is called a fully-connected layer. \n",
        "                       In other words, put all the pixel data (pixel values) in one line and make connections with the final layers (fully connected layers).\n",
        "                       In the above architecture diagram, after flattening, we got a 1D single long feature vector (1D single linear continuous vector) of \n",
        "                       128x8x8 = 8192 size.\n",
        "\n",
        "fc1 is the property of CNN_CWT_Encoder class and self parameter is the object of CNN_CWT_Encoder class which is used to access fc1. (fc1 => represents fully \n",
        "connected layer 1). nn.Linear() Applies a linear transformation to the incoming(=inputting, arriving, entering, comming, approaching) data. (linear \n",
        "transformation = linear transformation (sometimes called linear map) is a mapping(= matching process where the points(or data points) of one set are matched \n",
        "against the points of another set ) between 2 vector spaces. linear transformation takes a vector as input and transforms(= change, modify, convert)). \n",
        "nn.Linear() function takes in_features and out_features as parameters. (in_features – size of each input sample, out_features – size of each output sample). \n",
        "here, in_features=8192 (i.e. size of the input (vector) is 8192), out_features=256 (i.e. size of the output(vector) is 256). Therefore after applying Linear \n",
        "function to the flatten layer output, the size of the flatten layer output is reduced from 8192 to 256. (256 is the size of fc1 layer output)\n",
        "\n",
        "fc2 is the property of CNN_CWT_Encoder class and self parameter is the object of CNN_CWT_Encoder class which is used to access fc2. (fc2 => represents fully \n",
        "connected layer 2). nn.Linear() Applies a linear transformation to the incoming data. linear transformation takes a vector as input and transforms(= change, \n",
        "modify, convert)). nn.Linear() function takes in_features and out_features as parameters. here, in_features= 256 out_features=128. Therefore after applying \n",
        "Linear function to the fc1, the size of the fc1 output is reduced from 256 to 128.(128 is the size of the fc2 output)\n",
        "\n",
        "dropout1 is the property of CNN_CWT_Encoder class and self parameter is the object of CNN_CWT_Encoder class which is used to access dropout1. (dropout1 => \n",
        "dropout for fc1). nn.Dropout() randomly zeroes some of the elements of the input tensor with probability p, during training. Each channel will become zero on \n",
        "every forward call. (forward call or forward pass = The \"forward pass\" refers to calculation process, values of the output layers from the inputs data. \n",
        "forward call or forward pass in CNN means traversing(= traveling, moving) through all neurons from first to last layer. A loss function is calculated from the \n",
        "output values.) (neurons in artificial neural networks(artificial neural networks such as CNN, fully connected neural networks or fully connected layers) = \n",
        "https://www.tutorialspoint.com/artificial_neural_network/artificial_neural_network_basic_concepts.htm , basically neurons in CNN contains the information\n",
        "about input signals.). nn.Dropout() function takes p and inplace as parameters. p represents => probability of an element(sample) to be zeroed (probability of \n",
        "an element to become zero). Default p value: 0.5. here, p=0.2\n",
        "\n",
        "'''\n",
        "class CNN_CWT_Encoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.conv1 = conv_bn_relu(2, 16, 3, stride=1, padding=1, bias=True, batch_norm=True)\n",
        "        self.pool1 = nn.MaxPool2d(2, stride=2)\n",
        "        self.conv2 = conv_bn_relu(16, 32, 3, stride=1, padding=1, bias=True, batch_norm=True)\n",
        "        self.pool2 = nn.MaxPool2d(2, stride=2)\n",
        "        self.conv3 = conv_bn_relu(32, 64, 3, stride=1, padding=1, bias=True, batch_norm=True)\n",
        "        self.pool3 = nn.MaxPool2d(2, stride=2)\n",
        "        self.conv4 = conv_bn_relu(64, 128, 3, stride=1, padding=1, bias=True, batch_norm=True)\n",
        "        self.pool4 = nn.MaxPool2d(2, stride=2)\n",
        "        self.flatten = nn.Flatten()\n",
        "        self.fc1 = nn.Linear(8192, 256)\n",
        "        self.fc2 = nn.Linear(256, 128)\n",
        "        self.dropout1 = nn.Dropout(p=0.2)\n",
        "\n",
        "    '''\n",
        "    forward() method is a method present in nn.Module class. forward() method applies forward pass or forward call or forward propagation of CNN. (forward call \n",
        "    or forward pass = The \"forward pass\" refers to calculation process, calculating the values of the output layers from the inputs data. forward call or \n",
        "    forward pass in CNN means traversing(= traveling, moving) through all neurons from first to last layer. A loss function is calculated from the output \n",
        "    values.) (neurons in artificial neural networks(artificial neural netowrks such as CNN, fully connected neural networks or fully connected layers) = \n",
        "    https://www.tutorialspoint.com/artificial_neural_network/artificial_neural_network_basic_concepts.htm , basically neurons in CNN contains the information\n",
        "    about input signals.)\n",
        "    using def keyword defined(= created) forward() method and passed self and x as the paramters inside the function. self => The self parameter is a reference \n",
        "    to the current (= present, ongoing) instance (= object) of the class, and is used to access (= read, obtain, examine, acquire) the properties (like \n",
        "    variables, arrays, lists, dictionaries, tuples, strings, etc.) that belongs to the class. (reference in python = a python program accesses (= reads, obtains, \n",
        "    gets) data values through (= via) references. A reference is a name that refers to the specific (= certain, particular) location in memory of a value \n",
        "    (object)). x => x represents tensor(input tensor). \n",
        "    forward() method accepts a tensor as input, and then, returns a tensor as output. the returned tensor will be the output of the network. The forward() \n",
        "    method is the actual network transformation. The forward method is the mapping that maps(=matches) an input tensor to a prediction output tensor. (To know \n",
        "    more about forward() method refer this link => https://deeplizard.com/learn/video/MasG7tZj-hw)\n",
        "\n",
        "    To perform the convolution operation, we pass the tensor to the forward method of the first convolutional layer, self.conv1. when we call the forward() \n",
        "    method of a nn.Module, there is a special way that we make the call. When want to call the forward() method of a nn.Module instance(object), we call the \n",
        "    actual instance instead of calling the forward() method directly i.e.\n",
        "    Instead of doing this => self.conv1.forward(tensor), we do this => self.conv1(tensor). here, x is the tensor\n",
        "    our input tensor will transform(= change) as we move through the convolution layers. The first convolution layer has a convolution operation, whose \n",
        "    output is then passed to a max pooling operation with kernel_size=2 and stride=2 (our input image 1st goes into convolution layer, in this layer convolution\n",
        "    operation will be performed on the input image)\n",
        "\n",
        "    The output tensor x of the first convolution layer is then passed to the next convolution layer after applying max pool to the output tensor x, which is \n",
        "    identical except for the fact that we call self.conv2() instead of self.conv1(). same procedure for conv3 and conv4 as well. (self.conv3(), self.conv4())\n",
        "\n",
        "    after applying convolution and max pooling to the tensor x, we flatten (= reduce, reshape) the tensor x (basically we converting n dimensional array into \n",
        "    single linear continuous vector) to feed this flattened vector into fully connected layers\n",
        "\n",
        "    fc1 => represents fully connected layer 1. here, fc1 applies linear transformation (i.e. nn.Linear()) to the tensor x. linear transformation takes a vector \n",
        "    as input and transforms(= change, modify, convert))that vector. nn.Linear() function takes in_features and out_features as parameters. (in_features – size \n",
        "    of each input sample, out_features – size of each output sample). here, in_features=8192 (i.e. size of the input (vector) is 8192), out_features=256 (i.e. \n",
        "    size of the output(vector) is 256). Therefore after applying fc1 layer to the flatten layer output, the size of the flatten layer output is reduced from \n",
        "    8192 to 256. (256 is the size of fc1 layer output)\n",
        "\n",
        "    dropout1 => dropout for fc1. nn.Dropout() randomly zeroes some of the elements of the input tensor x with probability p, during training. Each channel will \n",
        "    become zero on every forward call. nn.Dropout() function takes p and inplace as parameters. p represents => probability of an element(sample) to be zeroed \n",
        "    (probability of an element to become zero). Default p value: 0.2. here, p=0.2\n",
        "\n",
        "    nn.ReLU() => Applies the Rectified Linear Units function element-wise, ReLU(x) = (x)+ = max(0,x). (ReLU => Rectified Linear Units layer, ReLU is an \n",
        "    activation function that will output the positive values or non-negative values (> 0) as it is without change, whereas output the negative values (< 0) as \n",
        "    zero (0). Advantage of ReLU: ReLU allows the models to learn faster and perform better, avoids overfitting.). After applying dropout1 to the tensor x,\n",
        "    applies ReLU activation function (i.e. nn.ReLU()) to the tensor x )\n",
        "\n",
        "    fc2 => represents fully connected layer 2. here, fc2 applies linear transformation (i.e. nn.Linear()) to the tensor x. linear transformation takes a vector \n",
        "    as input and transforms(= change, modify, convert))that vector. nn.Linear() function takes in_features and out_features as parameters. (in_features – size \n",
        "    of each input sample, out_features – size of each output sample). here, in_features=256 (i.e. size of the input (vector) is 256), out_features=128 (i.e. \n",
        "    size of the output(vector) is 128). Therefore after applying fc2 layer to the fc1 layer output, the size of the fc1 layer output is reduced from 256 to \n",
        "    128. (128 is the size of fc2 layer output)\n",
        "\n",
        "    Then applies ReLU activation function (i.e. nn.ReLU()) to the tensor x) \n",
        "    nn.ReLU() => Applies the Rectified Linear Units function element-wise, ReLU(x) = (x)+ = max(0,x). (ReLU => Rectified Linear Units layer, ReLU is an \n",
        "    activation function that will output the positive values or non-negative values (> 0) as it is without change, whereas output the negative values (< 0) as \n",
        "    zero (0). Advantage of ReLU: ReLU allows the models to learn faster and perform better, avoids overfitting.). After applying dropout1 to the tensor x,\n",
        "    applies ReLU activation function (i.e. nn.ReLU()) to the tensor x )\n",
        "\n",
        "    return keyword => return keyword returns the output of a function and exits the function\n",
        "    return x => returns the tensor x of forward() and exits the forward() function    \n",
        "    '''\n",
        "\n",
        "    def forward(self, x):\n",
        "        # input shape = [Nx2x128x128]\n",
        "        x = self.conv1(x) # [Nx16x128x128]\n",
        "        x = self.pool1(x) # [Nx16x64x64]\n",
        "        x = self.conv2(x) # [Nx32x64x64]\n",
        "        x = self.pool2(x) # [Nx32x32x32]\n",
        "        x = self.conv3(x) # [Nx64x32x32]\n",
        "        x = self.pool3(x) # [Nx64x16x16]\n",
        "        x = self.conv4(x) # [Nx128x16x16]\n",
        "        x = self.pool4(x) # [Nx128x8x8]\n",
        "        x = self.flatten(x) # [Nx8192] {128*8*8=8192} (N => batch size, 128 => no. of channels, 8*8 => height of image*width of image)\n",
        "        x = self.fc1(x) # [Nx256] \n",
        "        # x = self.dropout1(x) # apply dropout (Dropout is much harder to implement in LSTM)\n",
        "        x = nn.ReLU()(x) # apply ReLU activation\n",
        "        x = self.fc2(x) # [Nx128]\n",
        "        x = nn.ReLU()(x) # apply ReLU activation\n",
        "        return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h5Q5zNeUNAK_"
      },
      "source": [
        "# CNN + LSTM for Fault Probability prediction\n",
        "\n",
        "References:\n",
        "\n",
        "https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f2xToulhM_eb"
      },
      "source": [
        "'''\n",
        "# CNN + LSTM for Fault Probability prediction\n",
        "\n",
        "Python classes and objects => https://www.w3schools.com/python/python_classes.asp\n",
        "A Class is like an object constructor, or a blueprint for creating objects. and objects of the class is used as references to access (= read, get, obtain,\n",
        "examine, acquire) the class properties (properties = variables, arrays, lists, etc.)\n",
        "\n",
        "Python Inheritance => https://www.w3schools.com/python/python_inheritance.asp\n",
        "Inheritance allows us to define a class that inherits (= acquires, obtains, gets, recieves) all the methods and properties from another class.\n",
        "\n",
        "Created CNN_LSTM_FP class using class keyword. send nn.Module class as the parameter inside the CNN_LSTM_FP class. nn.Module is the Base class(or super \n",
        "class or parent class) for all neural network modules(= basically, a module is a python file. module is a file consisting of python code. module can define \n",
        "functions, classes and variables). nn.Module class contains all the methods and properties of neural networks. our models should also subclass this class. \n",
        "(i.e. our model should inherits (= acquires, obtains, gets, recieves) all the methods and properties from this nn.Module class.). To create a class that \n",
        "inherits the functionality (=methods and properties) from another class, send the parent class as a parameter when creating the child class. Here, nn.Module is \n",
        "the parent class and CNN_LSTM_FP is the child class. Parent class is a class from which a class inherits. Child class is a class which inherits from another \n",
        "class (parent class), child class also called as derived class or sub class class CNN_LSTM_FP(nn.Module) => this means CNN_LSTM_FP class inherits the \n",
        "functionality (= methods and properties) from nn.Module class\n",
        "\n",
        "Using def keyword, we defined (= created) __init__ function. __init__ function is used to assign values to class object properties or other operations that are \n",
        "necessary to do when the object is being created. The __init__() function is called automatically every time the class is being used to create a new object. We \n",
        "added __init__() function to the child class, therefore the child class will no longer inherit the parent's __init__() function. The child's __init__() function\n",
        "overrides (= removes, ignores) the inheritance of the parent's __init__() function. The self parameter is a reference to the current (= present, ongoing) \n",
        "instance (= object) of the class, and is used to access (= read, obtain, examine, acquire) the properties (like variables, arrays, lists, dictionaries, tuples, \n",
        "strings) that belongs to the class. (reference in python = a python program accesses (= reads, obtains, gets) data values through (= via) references. A \n",
        "reference is a name that refers to the specific (= certain, particular) location in memory of a value (object))\n",
        "\n",
        "super().__init__() => this initializes (= starts, activates) the parent class (i.e. nn.Module), basically this activates the nn.Module class and uses nn.Module\n",
        "class functionality (properties and methods)\n",
        "\n",
        "self.encoder = CNN_CWT_Encoder() => self.encoder calls the CNN_CWT_Encoder() class and applies CNN_CWT_Encoder() class functionality(properties and \n",
        "methods) i.e. applies convolution, pooling, Max Pooling, Batch Normalization for extracting important features from 2D CWT image and finally flatenning to \n",
        "encode(= convert, flatten, reduce) the 2D CWT image into 1D linear continous vector sequence or flatenned vector sequence or encoded feature vector sequence\n",
        "\n",
        "self.lstm1 = nn.LSTM(input_size=128, hidden_size=256, num_layers=2, batch_first=True) => \n",
        "nn.LSTM() - Applies a multi-layer long short-term memory (LSTM) RNN to an input sequence.\n",
        "(LSTM contains (1) hidden state(s) or hidden layer(s), (2) cell state(s) or cell layer(s), (3) input state(s) or input layer(s), (4) input gate(s), (5) forget \n",
        "gate(s), (6) cell(s), (7) output gate(s).......https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html (Refer this link for better understanding) )\n",
        "input_size - The number of expected features in the input x (128)\n",
        "hidden_size - The number of features in the hidden state or hidden layer h (256)\n",
        "num_layers - Number of recurrent(= loop, repeat) layers. E.g., setting num_layers=2 would mean stacking(= grouping, combining) two LSTMs together to form a \n",
        "stacked LSTM, with the second LSTM taking in outputs of the first LSTM along with 2nd LSTM inputs and computing the final results, with the 3rd LSTM taking in\n",
        "outputs of the 2nd LSTM along with 3rd LSTM inputs and computing the final results. Default: 1\n",
        "batch_first = If True, then the input and output tensors are provided as (batch, seq, feature). Default: False\n",
        "\n",
        "self.fc = nn.Linear(256, 1) => \n",
        "nn.Linear() Applies a linear transformation to the incoming(=inputting, arriving, entering, comming, approaching) data. (linear transformation = linear \n",
        "transformation (sometimes called linear map) is a mapping(= matching process where the points(or data points) of one set are matched \n",
        "against the points of another set ) between 2 vector spaces. linear transformation takes a vector as input and transforms(= change, modify, convert, reduce) \n",
        "that vector). nn.Linear() function takes in_features and out_features as parameters. (in_features – size of each input sample(input vector), out_features – size \n",
        "of each output sample (output vector)). here, in_features=256 (i.e. size of the input (vector) is 256), out_features=1 (i.e. size of the output(vector) is 1)\n",
        "'''\n",
        "class CNN_LSTM_FP(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.encoder = CNN_CWT_Encoder()\n",
        "        self.lstm1 = nn.LSTM(input_size=128, hidden_size=256, num_layers=2, batch_first=True)\n",
        "        self.fc = nn.Linear(256, 1)\n",
        "\n",
        "    '''\n",
        "    forward() method is a method present in nn.Module class. forward() method applies forward pass or forward call or forward propagation of CNN. (forward call \n",
        "    or forward pass = The \"forward pass\" refers to calculation process, calculating the values of the output layers from the inputs data. forward call or \n",
        "    forward pass means traversing(= traveling, moving) through all neurons from first to last layer. A loss function is calculated from the output \n",
        "    values.) (neurons in artificial neural networks = https://www.tutorialspoint.com/artificial_neural_network/artificial_neural_network_basic_concepts.htm , \n",
        "    basically neurons in Neural Network contains the information about input signals.)\n",
        "    using def keyword defined(= created) forward() method and passed self and x as the paramters inside the function. self => The self parameter is a reference \n",
        "    to the current (= present, ongoing) instance (= object) of the class, and is used to access (= read, obtain, examine, acquire) the properties (like \n",
        "    variables, arrays, lists, dictionaries, tuples, strings, etc.) that belongs to the class. (reference in python = a python program accesses (= reads, obtains, \n",
        "    gets) data values through (= via) references. A reference is a name that refers to the specific (= certain, particular) location in memory of a value \n",
        "    (object)). x => x represents tensor(input tensor). \n",
        "    forward() method accepts a tensor as input, and then, returns a tensor as output. the returned tensor will be the output of the network. The forward() \n",
        "    method is the actual network transformation. The forward method is the mapping that maps(=matches) an input tensor to a prediction output tensor. (To know \n",
        "    more about forward() method refer this link => https://deeplizard.com/learn/video/MasG7tZj-hw)\n",
        "\n",
        "    batch_size, seq_len, C, H, W = x.size() => size() function count the number of elements in each dimension (in each axis) and return the count\n",
        "\n",
        "    shape - https://www.w3schools.com/python/numpy/numpy_array_shape.asp (The shape of an array is the number of elements in each dimension(in each axis).)\n",
        "\n",
        "    x = nn.Sigmoid()(x) => torch.nn.Sigmoid() - https://pytorch.org/docs/stable/generated/torch.nn.Sigmoid.html , Sigmoid activation function converts the \n",
        "                           input data to a particular range (0 to 1), our problem is to find probability, Since probability of anything exists only between the \n",
        "                           range of 0 and 1, sigmoid is the right choice.\n",
        "                           nn.Sigmoid()(x) - applies Sigmoid activation function to the input x\n",
        "\n",
        "    return x => returns the final output of x and exits the forward() function\n",
        "    '''    \n",
        "    def forward(self, x):\n",
        "        # input shape = [N x l x 2 x 128 x 128] Here, N - batch size, l - sequence length (i.e. SEQ_LEN = 5),  2 - no. of channels or no. of filters, \n",
        "                                                      # 128 * 128 - height of an image * width of an image\n",
        "        batch_size, seq_len, C, H, W = x.size()\n",
        "        x = x.view(batch_size*seq_len, C, H, W) # transform input of shape [N x l x 2 x 128 x 128] into input of shape [(Nxl) x 2 x 128 x 128]. basically,\n",
        "                                                # converting(= transforming) into sequences. [(Nxl) x 2 x 128 x 128] - transformed input sequence\n",
        "        x = self.encoder(x) # pass transformed input sequence through CNN Encoder, CNN Encoder converts the image input data sequence of shape \n",
        "                            # [(Nxl) x 2 x 128 x 128] into linear vector sequence by flatenning, output feature vector sequence shape = [(Nxl) x 128]\n",
        "        x = x.view(batch_size, seq_len, -1) # transform encoded feature vector sequence into time distributed(= shared, alloted, assigned) input as required by\n",
        "                                            # LSTM unit or LSTM cell\n",
        "        x, _ = self.lstm1(x) # pass transformed encoded feature vector sequence through LSTM unit or LSTM cell, _ variable contains the hidden layers or hidden\n",
        "                             # states of LSTM, we don't require those hidden layers in our implementation, therefore just stored in _ variable, and if we want\n",
        "                             # we can initialize(= activate, start) hidden states from _ variable, here hidden states are the array of zeroes\n",
        "        x = self.fc(x[:,-1,:]) # pass last vector sequence(i.e. output vector sequence of LSTM unit at last time step) through fully connected network layer\n",
        "        x = nn.Sigmoid()(x)\n",
        "        return x    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zxrvA0g2Suja"
      },
      "source": [
        "#Switching from CPU to GPU\n",
        "\n",
        "(Why switch from CPU to GPU? - training artificial neural networks or deep neural networks(like CNN, LSTM) with CPU takes more time whereas training with GPU takes very less time compared to CPU. (training time on GPU = 100 * training time on CPU). Therefore GPUs should be used for model training to reduce the training time)\n",
        "\n",
        "**(1) Declaring a variable \"device\" which will hold the device(i.e. either GPU or CPU) we are training the model on.**\n",
        "\n",
        "**Utilizing GPU for computation(= calculation, estimation) with CUDA tensor**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kJVDQZbYTNGR"
      },
      "source": [
        "References:\n",
        "\n",
        "(1) torch.cuda - https://pytorch.org/docs/stable/cuda.html\n",
        "\n",
        "(2) How to run cuda on google colab jupyter notebook - https://pytorch.org/docs/stable/cuda.html\n",
        "\n",
        "(to run cuda on google colab = go to runtime -> change runtime type -> Hardware accelerator or hardware device (GPU) -> save)\n",
        "\n",
        "(3) torch.Tensor Attributes (torch.device) - https://pytorch.org/docs/stable/tensor_attributes.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FVAQQEufR_wW",
        "outputId": "e6b6182b-277a-4717-f897-115e9c1e692b"
      },
      "source": [
        "'''\n",
        "A torch.device is an object representing the device(= tool, machine) on which a torch.Tensor is or will be allocated(=assigned, alloted). \n",
        "The torch.device contains a device type (i.e. 'cpu' or 'cuda') and optional device ordinal for the device type. If the device ordinal is not present, this \n",
        "object will always represent the current device for the device type, even after torch.cuda.set_device() is called; e.g., a torch.Tensor constructed with device \n",
        "'cuda' is equivalent to 'cuda:X' where X is the result of torch.cuda.current_device(). Basically this torch.device() tells the torch.Tensor that where\n",
        "torch.Tensor is to be allocated (i.e. either allocated on cpu or gpu(gpu means cuda)). (cpu => central processing unit, gpu => graphics processing unit)\n",
        "\n",
        "A torch.Tensor’s device can be accessed(=read, obtained, acquired, retrieved, examined) via(=through) the Tensor.device property. A torch.device can be \n",
        "constructed via a string or via a string and device ordinal. Here, we constructed(= created, built) the torch.device via a string.\n",
        "\n",
        "\"cuda:0\" => CUDA is a model created by Nvidia for parallel computing platform and application programming interface. (parallel computing = parallel computing is\n",
        "a type of computing architecture in which several processors simultaneously(at a time) execute multiple, smaller calculations broken down from an overall larger\n",
        ", complex problem). (Application Programming Interface (API) => in computing, an API is an interface(= network, link, connection, communication) that defines \n",
        "interactions(= communications) between multiple software applications. An API is a software(= software is the programs(=codes) and other operating information\n",
        "used by a computer, software => instructions that tell a computer what to do, a set of instructions that directs a computer's hardware to perform a task is \n",
        "called a software or program or software program) intermediary(= mediator) that allows 2 applications to talk to each other. In other words, an API is the \n",
        "messenger that delivers(=transports, brings) our request(= application, input, input application) to the provider that we are requesting it from and then \n",
        "delivers the response(= output, output application) back to us. (An example of API => when we use an application on our mobile phone, the application connects\n",
        "to the internet and sends data to a server(= A server is a computer that serves(= delivers, supplies, sends) information to other computers). The server than \n",
        "retrieves(=fetches, gets, obtains) that data, interprets(=understands) data, performs the necessary actions and sends it back to our mobile phone.) (internet => \n",
        "an internet is a vast network that connects computers or smart phones or smart TVs all over the world. Through the internet, people can share information \n",
        "communicate with each other from anywhere within an interner connection).)\n",
        "CUDA is the parallel computing architecture of NVIDIA which allows for dramatic increases in computing performance by harnessing(= utilizing, using) the power \n",
        "of the GPU.\n",
        "\"cuda:0\" = torch.device('cuda:0') or torch.device(\"cuda:0\") => means device(type='cuda', index=0) or device(type:\"cuda\", index=0) => device of type \"cuda\" and\n",
        "index is 0\n",
        "\n",
        "torch.cuda.is_available() => torch.cuda adds support for CUDA tensor(= A tensor is a n-dimensional container(for example, 1D tensor is a vector, 2D tensor is a \n",
        "matrix, 3D tensor is a cube, 4D tensor is a cube vector)) types, that implement the same function as CPU tensors, but they(CUDA tensors) utilize GPUs for \n",
        "computation(= calculation, estimation) \n",
        "whenever we want to implement CUDA functions, we should always import(=send) torch.cuda\n",
        "torch.cuda.is_available() => determine(=discover, find out, tell) if our system supports CUDA or not. (it tells whether CUDA is available in our system(=PC, \n",
        "laptop) or not)\n",
        "\n",
        "print(device) => this prints the device type. (i.e. if torch.cuda.is_available() is True, prints cuda:0 (that means currently our system supporting \n",
        "device(type:\"cuda\", index=0)) else (i.e. if torch.cuda.is_available() is False(not True), prints cpu (if torch.cuda.is_available() is not True, that means our \n",
        "system doesn't support cuda, in our system cuda is not available, that means our system runs on CPU and doesn't run on GPU))\n",
        "\n",
        "device => device gives the type of the device and it's index(=position)\n",
        "'''\n",
        "device=torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\") # Declaring a variable \"device\" which will hold the device(i.e. either GPU or CPU) we are \n",
        "                                                                      #training the model on\n",
        "print(device)\n",
        "device"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda:0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda', index=0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ru6vZO1-X_Ep"
      },
      "source": [
        "**(2) Connecting(=linking) our model to the device(GPU) to train the model on GPU. (Model training on GPU takes very less time compared to model training on CPU)**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dIlpVyGLYS8g"
      },
      "source": [
        "References:\n",
        "\n",
        "(1) How to train models on the GPU - https://towardsdatascience.com/pytorch-switching-to-the-gpu-a7c0b21e8a99"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q6S3N-j7W_58"
      },
      "source": [
        "'''\n",
        "connecting CNN_LSTM_FP() model (or CNN_LSTM_FP() class) to the device(here device is the GPU). (Note: model.to(device) connects the model or moves the model to \n",
        "the device(i.e. either CPU or GPU) so that we can perform our model training on the device(CPU or GPU))\n",
        "'''\n",
        "model = CNN_LSTM_FP().to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aw2uM_hAZiiO"
      },
      "source": [
        "#Training the Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ThSIts75bAjD"
      },
      "source": [
        "**(1) Loss function**\n",
        "\n",
        "References:\n",
        "\n",
        "(a) Loss function => https://medium.com/@zeeshanmulla/cost-activation-loss-function-neural-network-deep-learning-what-are-these-91167825a4de\n",
        "\n",
        "(Use of Loss function => Loss function is a method of evaluating (= calculating) “how well our algorithm(prediction model or machine learning) models(performs on) our dataset”. If our predictions are totally off(= wrong, mistaken), our loss function will output a higher number. If our predictions are pretty good, our loss function will output a lower number. Since we tune(=adjust) our algorithm to try and improve our model, our loss function will tell us whether our model is improving or not, loss function will tell us whether our model predicting correctly or not. ‘Loss’  helps us to understand how much the predicted value differ from actual value)   \n",
        "\n",
        "(b) torch.nn.MSELoss ( = MSE Loss (Mean Squared Error Loss) ) => (1) https://towardsdatascience.com/understanding-different-loss-functions-for-neural-networks-dd1ed0274718 , (2) https://deeplizard.com/learn/video/Skc8nqJirJg , (3) https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html#torch.nn.MSELoss\n",
        "\n",
        "(RUL Prediction is a Regression problem. Regression problem => Predicting a value(output) for an input based on previous(=past) data. we are predicting the RUL of Mechanical Bearing using that Bearing's previous performance data (horiz accel and vert accel). Therefore RUL Prediction is considered as a regression problem)\n",
        "\n",
        "(There are various types of Loss functions. Since RUL Prediction is a regression problem, MSE Loss(Mean Sqaured Error Loss) is used. Generally MSE Loss is used for regression tasks or regresion problems.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W1neSgCUZRse"
      },
      "source": [
        "'''\n",
        "nn.MSELoss => MSELoss, As the name suggests, this loss is calculated by taking the mean(=average) of squared differences between actual(target) values and \n",
        "              predicted values. For a single sample, with MSE, we first calculate the difference (the error) between the provided output prediction(i.e. actual \n",
        "              value or target value) and the label(i.e. predicted value(our predicted value)). We then square this error\n",
        "              ( MSE(input) = (output - label)*(output - label) or MSE = (actual value - predicted value)*(actual value - predicted value) )\n",
        "              If we passed multiple samples to the model at once (a batch of samples), then we would take the mean of the squared errors over all of these \n",
        "              samples\n",
        "\n",
        "critetion => Here, criterion is the MSEcriterion\n",
        "\n",
        "nn.MSELoss(reduction='sum') => nn.MSELoss creates a criterion(= norm, model, measure) that measures the mean squared error between each element in the input x \n",
        "                               and target y (output y). \n",
        "                               (mean squared error = mean(=average) of squared differences between actual(target) values and predicted values.\n",
        "                               ( MSELoss = [(actual output - predicted output) * (actual output - predicted output)] )\n",
        "                               reduction='sum' => reduction - Specifies(=tells, indicates) which reduction to apply(=use) to the output:\n",
        "                                                  reduction='none' => no reduction will be applied\n",
        "                                                  reduction='mean' => the output will be summed(=added) and the sum of the output will be divided by the number \n",
        "                                                  of elements in the output\n",
        "                                                  reduction='sum' => the output will be summed(=added) and the division by the number of elements in the output\n",
        "                                                  is avoided \n",
        "'''\n",
        "criterion = nn.MSELoss(reduction='sum')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oRPKg9NpfbqP"
      },
      "source": [
        "**(2) Optimizer**\n",
        "\n",
        "Optimization = maximization, enhancement, improvement, maximizing the model's performance\n",
        "\n",
        "To train a neural network model (such as CNN, LSTM), we must define a loss function in order to measure the difference between actual value and prediction value(our prediction value).  Loss function is a method of evaluating (= calculating) “how well our algorithm(prediction model or machine learning) models(performs on) our dataset”. If our predictions are totally off(= wrong, mistaken), our loss function will output a higher number. If our predictions are pretty good, our loss function will output a lower number. our loss function will tell us whether our model is improving or not, loss function will tell us whether our model predicting correctly or not. ‘Loss’ helps us to understand how much the predicted value differ from actual value\n",
        "\n",
        "we need to use this loss to train our network(model) such that it performs better. Essentially what we need to do is to take the loss and try to minimize(=reduce) it, because a lower loss means our model is going to perform better\n",
        "\n",
        "Optimizers also called as Optimization algorithms are responsible for reducing the losses and to provide the most accurate results possible. Here we are using\n",
        "Adam optimizer(Adaptive Moment Estimation optimizer)\n",
        "\n",
        "References:\n",
        "\n",
        "(a) Optimizer (= torch.optim) - https://pytorch.org/docs/stable/optim.html\n",
        "\n",
        "(b)(1) https://www.kdnuggets.com/2020/12/optimization-algorithms-neural-networks.html , (2) https://towardsdatascience.com/optimization-algorithms-in-deep-learning-191bfc2737a4 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q0zyautgeepQ"
      },
      "source": [
        "'''\n",
        "torch.optim is a package implementing various optimization algorithms. To use torch.optim you have to construct an optimizer object, that will hold the current \n",
        "state and will update the parameters based on the computed gradients. (Computed = calculated) (gradient = gradient simply measures the change in all weights \n",
        "with respect to change in error(i.e. change in loss), basically gradient tells us that if loss changes how will the weights changes in neural networks). \n",
        "(gradient = difference in loss / difference in weights)\n",
        "\n",
        "To construct an Optimizer you have to give it an iterable containing the parameters (all should be Variables) to optimize(=improve, make perfect, develop, \n",
        "advance, maximize). Then, you can specify optimizer-specific options such as the learning rate, weight decay, etc. (iterable = iterable is an object, which one \n",
        "can iterate(=repeat, loop) over. examples: lists, tuples, dictionaries, sets. iterable generates an iterator when passed(=moved) to iter() method. iterator is \n",
        "an object, which is used to iterate over an iterable object using next() method. every iterator is also an iterable, but not every iterable is an iterator)\n",
        "\n",
        "Note: If you need to move a model to GPU via .cuda(), please do so before constructing optimizers for model. Parameters of a model after .cuda() will be \n",
        "different objects with those before the call. In general, we should make sure that optimized parameters live in consistent(= unchanging) locations when \n",
        "optimizers are constructed and used.\n",
        "\n",
        "optimizer => here optimizer is the optimizer object(i.e. torch.optim class object)\n",
        "\n",
        "optim.Adam(model.parameters(), lr=0.0001, betas=(0.9, 0.999), eps=1e-08, amsgrad=False) => \n",
        "optim.Adam implements Adam algorithm. Adam algorithm is an optimization algorithm useful for reducing the losses and to provide the most accurate results \n",
        "possible based on computed gradients. Basically Adam algorithm optimize the model by reducing loss function so that the model predicted value and the actual\n",
        "value will be almost same. A lower loss means our model is going to perform better\n",
        "model.parameters() => with model.parameters(), we can loop(=repeat, iterate) over the parameters(parameters which we want to optimize) of the model and then \n",
        "                      initialize each paramter with tensor functions\n",
        "lr (float, optional) => learning rate. The learning rate is a hyperparameter(= hyperparameter is a variable which determines the network structure) that \n",
        "                        controls how much to change the model in response to the estimated error each time the model weights are updated. Choosing the learning \n",
        "                        rate is challenging as a value too small may result in a long training process that could get stuck, whereas a value too large may \n",
        "                        result an unstable(= ambiguous, uncertain) training process. Basically, learning rate is a parameter that determines how much an \n",
        "                        updating step influences(=effects, affects, impacts, controls) the current value of the weights. here, lr=0.0001\n",
        "betas (Tuple[float, float], optional) – coefficients used for computing running averages of gradient and its square (default: (0.9, 0.999))\n",
        "eps (float, optional) – term added to the denominator to improve numerical stability (default: 1e-8) (numerical stability - numerical stability refers to how a\n",
        "                        malformed(= errored, irregular, faulty) input affects the execution(= performance) of an algorithm. In numerically stable algorithm, \n",
        "                        errors in the input lessen(=reduce, minimize, decrease)) as the algorithm executes, having little effect on the final output\n",
        "amsgrad (boolean, optional) – whether to use the AMSGrad variant of Adam algorithm or not. AMSgrad is a variant(= derivative, sub-optimizer) of the optimizer \n",
        "                              Adam that uses the maximum of past squared gradients to update the parameters.  (default: False) \n",
        "'''\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.0001, betas=(0.9, 0.999), eps=1e-08, amsgrad=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l7eoptg18X57"
      },
      "source": [
        "**(3) Learning rate scheduler**\n",
        "\n",
        "Learning rate - https://www.youtube.com/watch?v=jWT-AX9677k  \n",
        "(In machine learning and statistics, the learning rate is a tuning(=adjusting) parameter in an optimization algorithm that determines the step size at each iteration while moving toward a minimum of a loss function. learning rate also called as gain)\n",
        "\n",
        "(The learning rate is a hyperparameter(= hyperparameter is a variable which determines the network structure) that controls how much to change the model in response to the estimated error each time the model weights are updated. Choosing the learning rate is challenging as a value too small may result in a long training process that could get stuck, whereas a value too large may result an unstable(= ambiguous, uncertain) training process. Basically, learning rate is a parameter that determines how much an updating step influences(=effects, affects, impacts, controls) the current value of the weights.)\n",
        "\n",
        "(we need learning rate to multiply the gradients. Basically, we multiply the gradients with learning rate. this learning rate is a small number usually ranging between 0.01 and 0.0001 but the actual value can vary, so any value we get for the gradient is going to become relatively small once we multiply with learning rate.)\n",
        "\n",
        "Learning rate scheduler - https://www.youtube.com/watch?v=81NJgoR5RfY\n",
        "\n",
        "(Learning rate scheduler improve the optimization process during the training. Learning rate scheduler adjust(= modify, regulate, alter, change) our learning rate during the training loop based on the no. of epochs. Basically, Learning Rate scheduler(or LR scheduler) adjust the learning rate for better results. Adjusting the learning rate - means most of the time we want to decrease the learning rate, not increase the learning rate, but it always depends on our specific problem. Learning rate scheduler adjust the learning rate during training by reducing the learning rate)\n",
        "\n",
        "epoch - https://towardsdatascience.com/epoch-vs-iterations-vs-batch-size-4dfb9c7ce9c9\n",
        "\n",
        "(An epoch means training the neural network with all the training data for one cycle. In an epoch, we use all of the data exactly once. A forward pass and a backward pass together are counted as one pass. An epoch is made up of one or more batches, where we use a part of the dataset to train the neural network. **\" One Epoch is when an ENTIRE dataset is passed forward and backward through the neural network only ONCE. Since one epoch is too big to feed to the computer at once we divide it in several smaller batches(= groups of data, set of data, collection of data). passing the entire dataset through a neural network is not correct as neural network doesn't understand. Therefore we need to pass the full(=entire, complete) dataset multiple times to the same neural network.(that means we divide the dataset into batches and pass each batch at a time to neural network. As the number of epochs increases, more number of times the weights are changed in the neural network and the curve goes from underfitting to optimal to overfitting curve \"**)\n",
        "\n",
        "weight(s) in neural network - (1) https://deepai.org/machine-learning-glossary-and-terms/weight-artificial-neural-network#:~:text=Weight%20is%20the%20parameter%20within,weight%2C%20and%20a%20bias%20value.&text=Often%20the%20weights%20of%20a,hidden%20layers%20of%20the%20network. , (2) https://www.youtube.com/watch?v=82_R6Sgiuo0\n",
        "\n",
        "(Weight is the parameter within a neural network that transforms(= changes) input data within the network's hidden layers. A neural network is a series of nodes, or series of neurons. Within each node there is a set of inputs, weights, and bias values. As an input enters the node, it gets multiplied by a weight value and the resulting output is either observed, or passed to the next layer in the neural network. Often the weights of a neural network are contained within the hidden layers of the network. Weight affects the amount of influence a change in the input will have upon the output. A low weight value will have no change on the input(therefore no change on the output or slight change on the output), and alternatively a larger weight value will more significantly change the output)\n",
        "\n",
        "References:\n",
        "\n",
        "(a) torch.optim.lr_scheduler - https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C5sOr573jCC7"
      },
      "source": [
        "'''\n",
        "optim.lr_scheduler.MultiStepLR(optimizer, milestones=[10,20,30], gamma=0.1, last_epoch=-1, verbose=False) => \n",
        "torch.optim.lr_scheduler provides several methods to adjust(= modify, regulate, alter, change) the learning rate based on the number of epochs. Learning rate \n",
        "scheduling should be applied after optimizer’s update\n",
        "torch.optim.lr_scheduler.MultiStepLR() => MultiStepLR() is one of the learning rate schedulers. MultiStepLR() Decays(= decreases) the learning rate of each \n",
        "                                          parameter group by gamma once the number of epoch reaches one of the milestones. Notice that such decay can happen \n",
        "                                          simultaneously with other changes to the learning rate from outside this scheduler. When last_epoch=-1, sets initial \n",
        "                                          lr as lr\n",
        "optimizer (Optimizer) – Wrapped optimizer. (Optimizer also called as Optimization algorithm reduce the losses and provide the most accurate results possible. \n",
        "                                            Here we are using Adam optimizer(Adaptive Moment Estimation optimizer))  \n",
        "milestones (list) – List of epoch indices. Must be increasing.\n",
        "gamma (float) – Multiplicative factor(= multiplier, factor that multiplies) of learning rate decay(= decrease). Default: 0.1\n",
        "last_epoch (int) – The index(= position) of last epoch. Default: -1. When last_epoch=-1, sets initial lr as lr\n",
        "verbose (bool) – verbose will show training progress for each epoch. verbose = True - means will show training progress for each epoch. verbose = Flase - means\n",
        "                 will show nothing \n",
        "'''\n",
        "multistep_lr_sch = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[10,20,30], gamma=0.1, last_epoch=-1, verbose=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dh5UUy3rFSVK"
      },
      "source": [
        "**Calculating Train Loss**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KZpPZVzYALse"
      },
      "source": [
        "'''\n",
        "using def keyword defined(=created) train_epoch() function and passed model, dataloader, criterion, optimizer as parameters inside the function\n",
        "\n",
        "model.train() => model.train() or model.train(mode=True) sets the mode to train. model.train() tells our model that we are training the model. So effectively \n",
        "                 layers like convolution, maxpool, ReLU, dropout, batchnorm etc. which behave different on the train and test procedures know what is going on \n",
        "                 and hence can behave accordingly. In case of model.train() => the model knows it has to learn the layers (Note: we think that train() function \n",
        "                 trains the model but it does not do that. train() just sets the mode and tells our model that we perform training on the model)\n",
        "\n",
        "for i, batch in enumerate(dataloader): => i, batch are the iterators and dataloader is the iterable\n",
        "(iterator in python is an object that is used to iterate(= repeat, loop) over iterable objects like lists, tuples, dictionaries, and sets. the iterator object \n",
        "is initialized using the iter() method. iterator uses the next() method for iteration\n",
        "iterable is an object, which one can iterate(=repeat, loop) over. examples: lists, tuples, dictionaries, sets. iterable generates an iterator when passed\n",
        "(=moved) to iter() method. iterator is an object, which is used to iterate over an iterable object using next() method\n",
        "every iterator is also an iterable, but not every iterable is an iterator)\n",
        "enumerate() => https://www.geeksforgeeks.org/enumerate-in-python/ , https://www.tutorialspoint.com/enumerate-in-python\n",
        "(A lot of times when dealing with iterators, we also get a need to keep a count of iterations. Python eases the programmers task by providing a built-in \n",
        "function enumerate() for this task. Enumerate() method adds a counter to an iterable and returns it in a form of enumerate object. This enumerate object can \n",
        "then be used directly in for loops or be converted into a list of tuples using list() method )\n",
        "(enumerate() syntax = > enumerate(iterable, start=0)\n",
        "                        Parameters: \n",
        "                        Iterable: any object that supports iteration\n",
        "                        Start: the index value from which the counter is to be started, by default it is 0)\n",
        "(Basically, The enumerate() function assigns an index to each item in an iterable object that can be used to reference the item later. It makes it easier to \n",
        "keep track of the content(= data, information) of an iterable object.)\n",
        "\n",
        "x = batch['x'].to(device, dtype=torch.float) => connecting batch['x'] (batch['x'] => horiz accel and vert accel feature values of train data) to the device(here \n",
        "                                                device is the GPU). A torch.dtype is an object that represents the data type of a torch.Tensor. \n",
        "                                                dtype = torch.float represents 32-bit floating point number. (that means batch['x'] connects to GPU as floating \n",
        "                                                point datatype) \n",
        "\n",
        "y = batch['y'].to(device, dtype=torch.float) => connecting batch['y'] (batch['y'] => fault probability values or failure probability values of train data) to \n",
        "                                                the device(here device is the GPU). A torch.dtype is an object that represents the data type of a torch.Tensor. \n",
        "                                                dtype = torch.float represents 32-bit floating point number. (that means batch['y'] connects to GPU as floating \n",
        "                                                point datatype)\n",
        "\n",
        "optimizer.zero_grad() => https://pytorch.org/docs/master/generated/torch.optim.Optimizer.zero_grad.html\n",
        "(optimizer.zero_grad() => Sets(= assigns, allots) the gradients of all optimized torch.Tensor to zero. In PyTorch, we need to set the gradients to zero before \n",
        "starting to do backpropragation(backward pass of inputs) because PyTorch accumulates(= adds, sums) the gradients on subsequent(= consecutive, successive, next) \n",
        "backward passes. So, the default action is to accumulate (= sum, add) the gradients on every loss.backward() call. Because of this, when we start our training \n",
        "loop, ideally we should zero out the gradients so that we do the parameter update correctly. Else the gradient would point in some other direction than the \n",
        "intended(= planned) direction towards the minimum(in case of minimization objectives) or maximum (in case of maximization objectives))\n",
        "(gradient = gradient simply measures the change in all weights with respect to change in error(i.e. change in loss), basically gradient tells us that if loss \n",
        "changes how will the weights changes in neural networks). (gradient = difference in loss / difference in weights). (the gradient is a numeric calculation \n",
        "allowing us to know how to adjust the parameters of a network in such a way that its output deviation is minimized) )\n",
        "\n",
        "y_prediction = model(x) => predicting fault probability of train data using CNN + LSTM\n",
        "\n",
        "loss = criterion(y_prediction, y) => applies MSELoss to y_prediction and y\n",
        "\n",
        "loss.backward() => applies back propagation(= back propagation is the process of updating(= changing) the weights of the neural network in order to reduce the \n",
        "                   error in prediction) (back propagation = backward pass of inputs). basically loss.backward() is used to compute(= calculate, evaluate) \n",
        "                   gradients\n",
        "\n",
        "torch.nn.utils.clip_grad_norm_(model.parameters(), 0.2) => Normalize the gradients of the model, with model.parameters can access the parameters(learnable\n",
        "parameters) of the model i.e. weights, bias\n",
        "\n",
        "optimizer.step() => https://pytorch.org/docs/stable/optim.html\n",
        "(optimizer.step() => applies Gradient Descent(= gradient reduction, gradient reduces, output deviation reduces). All optimizers or optimization algorithms \n",
        "implement a step() method, that updates(= improves) the parameters. optimizer.step() function is used to update the parameters of neural network. \n",
        "optimizer.step() function can be called once the gradients are computed(= calculated, evaluated) using loss.backward() ) \n",
        "\n",
        "total_loss += loss.cpu().item() => total_loss = total_loss + loss.cpu().item()\n",
        "(loss.cpu().item() => loss.cpu() - copying loss to the cpu memory. actually loss present in gpu memory because we are training our model in the gpu memory.\n",
        "                      calculating the loss in gpu memory is not reliable as it consumes memory of gpu which leads to cuda out of memory or gpu out of memory\n",
        "                      error. hence we are copying loss to the cpu memory and calculating loss\n",
        "                   => .item() act as a pytorch tensor so we can use it as a value )\n",
        "\n",
        "num_of_samples += x.shape[0] => num_of_samples = num_of_samples + x.shape[0]\n",
        "(x.shape[0] => x is the horiz accel and vert accel feature values(value images) of the train data\n",
        "               x.shape => returns the shape of x, x.shape[0] => returns the shape of x in 0th dimension \n",
        "               shape => ( https://www.w3schools.com/python/numpy/numpy_array_shape.asp )The shape of an array is the number of elements in each dimension. \n",
        "                        shape in python displays output in tuple format. x contains 4 dimensions that means x.shape gives no. of elements in each dimension(i.e. \n",
        "                        no. of elements in 4 dimensions). x.shape[0] gives no. of elements in 0th dimension as output (i.e. no. of horiz accel feature image \n",
        "                        values and vert accel feature image values of train data) )\n",
        "(now value of the num_of_samples variable = num_of_samples + x.shape[0]......that means num_of_samples stores the no. of horiz accel and vert accel feature \n",
        "image values of train data)\n",
        "\n",
        "return total_loss/num_of_samples => returns total_loss / num_of_samples (i.e. train loss) and exits train_epoch() function\n",
        "\n",
        "'''\n",
        "def train_epoch(model, dataloader, criterion, optimizer):\n",
        "    total_loss = 0\n",
        "    num_of_samples = 0\n",
        "    model.train()\n",
        "    for i, batch in enumerate(dataloader):\n",
        "        x = batch['x'].to(device, dtype=torch.float)\n",
        "        y = batch['y'].to(device, dtype=torch.float)\n",
        "\n",
        "        optimizer.zero_grad()\n",
        "        y_prediction = model(x)\n",
        "        loss = criterion(y_prediction, y)\n",
        "        loss.backward()\n",
        "        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.2)\n",
        "        optimizer.step()\n",
        "\n",
        "        total_loss += loss.cpu().item()\n",
        "        num_of_samples += x.shape[0]\n",
        "    return total_loss/num_of_samples"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QyA4NRAnOuI7"
      },
      "source": [
        "**Calculating Validation Loss**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mnmFb662No9P"
      },
      "source": [
        "'''\n",
        "using def keyword defined(=created) eval() function and passed model, dataloader, criterion as parameters inside the function\n",
        "\n",
        "model.eval() => model.eval() or model.train(mode=False) sets the mode to validate or test or evaluate. model.eval() tells our model that we are testing the \n",
        "                model or validating the model or evaluating the model or checking the model. So effectively layers like convolution, maxpool, ReLU, dropout, \n",
        "                batchnorm etc. which behave different on the train and test procedures know what is going on and hence can behave accordingly. model.eval() => \n",
        "                it indicates the model that nothing new is to be learnt and the model is used for validating. (Note: we think that eval() function validates or \n",
        "                evaluates the model but it does not do that. eval() just sets the mode and tells our model that we perform validation on the model)\n",
        "\n",
        "for i, batch in enumerate(dataloader): => i, batch are the iterators and dataloader is the iterable\n",
        "(iterator in python is an object that is used to iterate(= repeat, loop) over iterable objects like lists, tuples, dictionaries, and sets. the iterator object \n",
        "is initialized using the iter() method. iterator uses the next() method for iteration\n",
        "iterable is an object, which one can iterate(=repeat, loop) over. examples: lists, tuples, dictionaries, sets. iterable generates an iterator when passed\n",
        "(=moved) to iter() method. iterator is an object, which is used to iterate over an iterable object using next() method\n",
        "every iterator is also an iterable, but not every iterable is an iterator)\n",
        "enumerate() => https://www.geeksforgeeks.org/enumerate-in-python/ , https://www.tutorialspoint.com/enumerate-in-python\n",
        "(A lot of times when dealing with iterators, we also get a need to keep a count of iterations. Python eases the programmers task by providing a built-in \n",
        "function enumerate() for this task. Enumerate() method adds a counter to an iterable and returns it in a form of enumerate object. This enumerate object can \n",
        "then be used directly in for loops or be converted into a list of tuples using list() method )\n",
        "(enumerate() syntax = > enumerate(iterable, start=0)\n",
        "                        Parameters: \n",
        "                        Iterable: any object that supports iteration\n",
        "                        Start: the index value from which the counter is to be started, by default it is 0)\n",
        "(Basically, The enumerate() function assigns an index to each item in an iterable object that can be used to reference the item later. It makes it easier to \n",
        "keep track of the content(= data, information) of an iterable object.)\n",
        "\n",
        "x = batch['x'].to(device, dtype=torch.float) => connecting batch['x'] (batch['x'] => horiz accel and vert accel feature values of val data) to the device(here \n",
        "                                                device is the GPU). A torch.dtype is an object that represents the data type of a torch.Tensor. \n",
        "                                                dtype = torch.float represents 32-bit floating point number. (that means batch['x'] connects to GPU as floating \n",
        "                                                point datatype)\n",
        "\n",
        "y = batch['y'].to(device, dtype=torch.float) => connecting batch['y'] (batch['y'] => fault probability values or failure probability values of val data) to the \n",
        "                                                device(here device is the GPU). A torch.dtype is an object that represents the data type of a torch.Tensor. \n",
        "                                                dtype = torch.float represents 32-bit floating point number. (thatmeans batch['y'] connects to GPU as floating \n",
        "                                                point datatype) \n",
        "\n",
        "with torch.no_grad(): => with statement in python automatically closes the opened file(automatically releases the memory) without using close() function\n",
        "                         torch.no_grad() => (1) https://pytorch.org/docs/stable/generated/torch.no_grad.html , \n",
        "                                            (2) https://stackoverflow.com/questions/63351268/torch-no-grad-affects-on-model-accuracy\n",
        "                         (torch.no_grad() basically skips(=ignores) the gradient calculation over the weights. That means we are not changing any weight in the \n",
        "                         specified layers. torch.no_grad() just disables the tracking of any calculations required to calculate a gradient. It won't have any \n",
        "                         effect on accuracy in a pure inference mode, since gradients are not needed there. but we can't use torch.no_grad() during training \n",
        "                         time since we need the gradients to train and optimize(=improve, enhance) the model. In general if we go for inference we always want \n",
        "                         to set the network to eval mode and disable gradients. This saves run time and memory consumption and won't affect accuracy. )\n",
        "                         (inference => Inference refers to the process of using a trained machine learning model to make a prediction.)\n",
        "                         (gradient = gradient simply measures the change in all weights with respect to change in error(i.e. change in loss), basically gradient \n",
        "                         tells us that if loss changes how will the weights changes in neural networks). (gradient = difference in loss / difference in weights). \n",
        "                         (the gradient is a numeric calculation allowing us to know how to adjust the parameters of a network in such a way that its output \n",
        "                         deviation is minimized) )\n",
        "\n",
        "y_prediction = model(x) => predicting fault probability of val data using CNN + LSTM\n",
        "\n",
        "loss = criterion(y_prediction, y) => applies MSELoss to y_prediction and y\n",
        "\n",
        "total_loss += loss.cpu().item() => total_loss = total_loss + loss.cpu().item()\n",
        "(loss.cpu().item() => loss.cpu() - copying loss to the cpu memory. actually loss present in gpu memory because we are training our model in the gpu memory.\n",
        "                      calculating the loss in gpu memory is not reliable as it consumes memory of gpu which leads to cuda out of memory or gpu out of memory\n",
        "                      error. hence we are copying loss to the cpu memory and calculating loss\n",
        "                   => .item() act as a pytorch tensor so we can use it as a value )\n",
        "\n",
        "num_of_samples += x.shape[0] => num_of_samples = num_of_samples + x.shape[0]\n",
        "(x.shape[0] => x is the horiz accel and vert accel feature values(value images) of the val data\n",
        "               x.shape => returns the shape of x, x.shape[0] => returns the shape of x in 0th dimension \n",
        "               shape => ( https://www.w3schools.com/python/numpy/numpy_array_shape.asp )The shape of an array is the number of elements in each dimension. \n",
        "                        shape in python displays output in tuple format. x contains 4 dimensions that means x.shape gives no. of elements in each dimension(i.e. \n",
        "                        no. of elements in 4 dimensions). x.shape[0] gives no. of elements in 0th dimension as output (i.e. no. of horiz accel feature image \n",
        "                        values and vert accel feature image values of val data) )\n",
        "(now value of the num_of_samples variable = num_of_samples + x.shape[0]......that means num_of_samples stores the no. of horiz accel and vert accel feature \n",
        "image values of val data)\n",
        "\n",
        "return total_loss/num_of_samples => returns total_loss / num_of_samples (i.e. val loss) and exits eval() function\n",
        "'''\n",
        "def eval(model, dataloader, criterion):\n",
        "    total_loss = 0\n",
        "    num_of_samples = 0\n",
        "    model.eval()\n",
        "    for i, batch in enumerate(dataloader):\n",
        "        x = batch['x'].to(device, dtype=torch.float)\n",
        "        y = batch['y'].to(device, dtype=torch.float)\n",
        "\n",
        "        with torch.no_grad():\n",
        "            y_prediction = model(x)\n",
        "            loss = criterion(y_prediction, y)\n",
        "\n",
        "        total_loss += loss.cpu().item()\n",
        "        num_of_samples += x.shape[0]\n",
        "    return total_loss/num_of_samples"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vit0W_q7fnod"
      },
      "source": [
        "**Printing Train Loss and Val Loss**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bv5OoMf2Uqx-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "426620b0-a7cb-4d72-bead-697dcd4b41c5"
      },
      "source": [
        "'''\n",
        "max_epochs = 30 => assigned 30 to max_epochs variable. therefore train loss and val loss will be calculated and displayed for maximium 30 epochs (1 to 30)\n",
        "(An epoch means training the neural network with all the training data for one cycle. In an epoch, we use all of the data exactly once. A forward pass and a \n",
        "backward pass together are counted as one pass. An epoch is made up of one or more batches of the dataset and epoch is used to train the neural network. \n",
        "\"One Epoch is when an ENTIRE dataset is passed forward and backward through the neural network only ONCE. Since one epoch is too big to feed to the computer at \n",
        "once we divide it into several smaller batches(= groups of data, set of data, collection of data). passing the entire dataset through a neural network is not \n",
        "correct as neural network doesn't understand. Therefore we need to pass the full(=entire, complete) dataset multiple times to the same neural network.(that \n",
        "means we divide the dataset into batches and pass each batch at a time to neural network. As the number of epochs increases, more number of times the weights \n",
        "are changed in the neural network and the curve goes from underfitting to optimal(= ideal, perfect) to overfitting curve \")\n",
        "\n",
        "loss_vals = [] => is an empty list\n",
        "\n",
        "for epoch in range(max_epochs): => for - https://www.w3schools.com/python/python_for_loops.asp (A for loop is used for iterating over a sequence (that is either \n",
        "                                   a range, a list, a tuple, a dictionary, a set, or a string).)\n",
        "                                   epoch - epoch is the iterator used to iterate over the max_epochs range\n",
        "                                   range() - https://www.w3schools.com/python/ref_func_range.asp (The range() function returns a sequence(= series) of numbers, \n",
        "                                   starting from 0 by default, and increments by 1 (by default), and stops before a specified number.)\n",
        "                                   max_epochs - max_epochs is an iterable which epoch can iterate over\n",
        "train_loss = 0\n",
        "    for train_dataloader in train_dataloaders:\n",
        "        train_loss += train_epoch(model, train_dataloader, criterion, optimizer)\n",
        "    train_loss /= len(train_dataloaders) =>\n",
        "( train_epoch(model, train_dataloader, criterion, optimizer) returns the train loss, and train_loss = train_loss / len(train_dataloaders), that means train_loss\n",
        "contains the train loss of each epoch from 1 to 30 )\n",
        "\n",
        "val_loss = 0\n",
        "    for val_dataloader in val_dataloaders:\n",
        "        val_loss += eval(model, val_dataloader, criterion)\n",
        "    val_loss /= len(val_dataloaders)\n",
        "( eval(model, val_dataloader, criterion) returns the val loss, and val_loss = val_loss / len(val_dataloaders), that means val_loss contains the validation loss \n",
        "of each epoch from 1 to 30 )\n",
        "\n",
        "multistep_lr_sch.step() => means calling scheduler.step(), here scheduler(or learning rate scheduler) is multistep_lr_sch (If we don’t call scheduler.step(), \n",
        "                           the learning rate won’t be changed and stays at the initial value. Note: the scheduler will just manipulate the learning rate. It \n",
        "                           won’t update the model. Therefore you should call scheduler.step() in the epoch loop)\n",
        "\n",
        "loss_vals.append([train_loss, val_loss]) => The append() method appends(= adds) an element to the end of the list. In loss_vals.append([train_loss, val_loss]),\n",
        "                                            loss_vals is an empty list. in loss_vals list we are appending(= adding) the list of train_loss and val_loss of \n",
        "                                            every epoch from 1 to 30. therefore loss_vals contains train loss and val loss of every epoch 1 to 30\n",
        "\n",
        "print('{0}/{1}: train_loss = {2:.4f}, val_loss = {3:.4f}'.format(epoch+1, max_epochs, train_loss, val_loss) ) => printing train loss and val loss of nth epoch \n",
        "from max_epochs (here, n = 1, 2, 3,--------,30) i.e. (1/30, 2/30, 3/30, ----------, 30/30), and train loss upto 4 decimal points of each epoch, and val loss \n",
        "upto 4 decimal points of each epoch\n",
        "(format() => The format() function formats(= arranges, configures, presents) a specified value into a specified format. )\n",
        "'''\n",
        "max_epochs = 30\n",
        "\n",
        "loss_vals = [] # place holder to store history of loss values for each epoch\n",
        "for epoch in range(max_epochs):\n",
        "    train_loss = 0\n",
        "    for train_dataloader in train_dataloaders:\n",
        "        train_loss += train_epoch(model, train_dataloader, criterion, optimizer)\n",
        "    train_loss /= len(train_dataloaders)\n",
        "    \n",
        "    val_loss = 0\n",
        "    for val_dataloader in val_dataloaders:\n",
        "        val_loss += eval(model, val_dataloader, criterion)\n",
        "    val_loss /= len(val_dataloaders)\n",
        "    \n",
        "    # multistep_lr_sch.step()\n",
        "    loss_vals.append([train_loss, val_loss])\n",
        "    print('{0}/{1}: train_loss = {2:.4f}, val_loss = {3:.4f}'.format(epoch+1, max_epochs, train_loss, val_loss) )"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1/30: train_loss = 0.0364, val_loss = 0.0983\n",
            "2/30: train_loss = 0.0252, val_loss = 0.1118\n",
            "3/30: train_loss = 0.0151, val_loss = 0.1353\n",
            "4/30: train_loss = 0.0137, val_loss = 0.1241\n",
            "5/30: train_loss = 0.0120, val_loss = 0.1147\n",
            "6/30: train_loss = 0.0088, val_loss = 0.1103\n",
            "7/30: train_loss = 0.0079, val_loss = 0.0997\n",
            "8/30: train_loss = 0.0059, val_loss = 0.1200\n",
            "9/30: train_loss = 0.0043, val_loss = 0.0927\n",
            "10/30: train_loss = 0.0038, val_loss = 0.0834\n",
            "11/30: train_loss = 0.0043, val_loss = 0.0808\n",
            "12/30: train_loss = 0.0029, val_loss = 0.0701\n",
            "13/30: train_loss = 0.0022, val_loss = 0.0745\n",
            "14/30: train_loss = 0.0021, val_loss = 0.0641\n",
            "15/30: train_loss = 0.0024, val_loss = 0.0822\n",
            "16/30: train_loss = 0.0019, val_loss = 0.0706\n",
            "17/30: train_loss = 0.0013, val_loss = 0.0567\n",
            "18/30: train_loss = 0.0018, val_loss = 0.0655\n",
            "19/30: train_loss = 0.0015, val_loss = 0.0543\n",
            "20/30: train_loss = 0.0014, val_loss = 0.0706\n",
            "21/30: train_loss = 0.0013, val_loss = 0.0314\n",
            "22/30: train_loss = 0.0008, val_loss = 0.0559\n",
            "23/30: train_loss = 0.0014, val_loss = 0.0258\n",
            "24/30: train_loss = 0.0011, val_loss = 0.0233\n",
            "25/30: train_loss = 0.0007, val_loss = 0.0618\n",
            "26/30: train_loss = 0.0008, val_loss = 0.0241\n",
            "27/30: train_loss = 0.0006, val_loss = 0.0298\n",
            "28/30: train_loss = 0.0010, val_loss = 0.0235\n",
            "29/30: train_loss = 0.0007, val_loss = 0.0306\n",
            "30/30: train_loss = 0.0006, val_loss = 0.0334\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0iW3bCNhcta"
      },
      "source": [
        "**Plotting train loss and val loss**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "id": "YHlulKKCf_or",
        "outputId": "ef5c18d3-181a-4cb1-e8d7-4ad42ccbbb88"
      },
      "source": [
        "'''\n",
        "plt.plot(range(len(loss_vals)), [l[0] for l in loss_vals], 'b.-', label='train loss') => \n",
        "(The plot() function in pyplot module of matplotlib library is used to make a 2D hexagonal binning plot of points x, y. the below output is the example of 2D\n",
        "hexagonal binning plot of points x,y. The plot() function is used to draw points(markers) in a diagram. By default, the plot() function draws a line from point \n",
        "to point. The function takes parameters for specifying(= describing, drawing) points in the diagram. Parameter 1 is an array containing the points on the x-axis. \n",
        "Parameter 2 is an array containing the points on the y-axis.)\n",
        "(range() - https://www.w3schools.com/python/ref_func_range.asp (The range() function returns a sequence(= series) of numbers, starting from 0 by default, and \n",
        "increments by 1 (by default), and stops before a specified number.))\n",
        "(len(loss_vals) = 30)\n",
        "(l[0] for l in loss_vals => l[0] in loss_vals represents train_loss(i.e. x-axis), therefore l[0] for l in loss_vals means traversing(=moving) through all train \n",
        "loss from epoch 1 to epoch 30)\n",
        "('b.-' => represents blue color for points and line in a diagram or plot)\n",
        "(label='train loss' => i.e. x-axis name is train loss)\n",
        "\n",
        "plt.plot(range(max_epochs), [l[1] for l in loss_vals], 'r.-', label='val loss') =>\n",
        "(l[1] for l in loss_vals => l[1] in loss_vals represents val_loss(i.e. y-axis), therefore l[1] for l in loss_vals means traversing(=moving) through all val loss \n",
        "from epoch 1 to epoch 30)\n",
        "('r.-' => represents red color for points and line in a diagram or plot)\n",
        "(label='val loss' => i.e. y-axis name is train loss)\n",
        "\n",
        "plt.legend() => plt.legend() is used to display the tags or labels(train loss and val loss) on right top of the plot\n",
        "\n",
        "plt.show() => The show() function in pyplot module of matplotlib library is used to display the plot or diagram or figure. here, plt.show() is used to display \n",
        "              the hexagonal binning plot as shown in output\n",
        "'''\n",
        "plt.plot(range(len(loss_vals)), [l[0] for l in loss_vals], 'b.-', label='train loss')\n",
        "plt.plot(range(len(loss_vals)), [l[1] for l in loss_vals], 'r.-', label='val loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V4FLQtQUyxfe"
      },
      "source": [
        "**Saving the Model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UWhufAvnjQfi"
      },
      "source": [
        "'''\n",
        "torch.save() => saves the model (saves the tensor object) to the PC or to the Google Drive. here, model is CNN_LSTM_FP(), CNN + LSTM model for fault probability \n",
        "estimation\n",
        "\n",
        "model.state_dict() => https://pytorch.org/tutorials/recipes/recipes/saving_and_loading_models_for_inference.html , \n",
        "                      https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.html\n",
        "                      (In PyTorch, the learnable parameters (i.e. weights and biases) of a torch.nn.Module model are contained in the model’s parameters \n",
        "                      (accessed with model.parameters()). A state_dict is an essential entity(=object) if you are interested in saving or loading models from \n",
        "                      PyTorch. Because state_dict objects are Python dictionaries, they can be easily saved, updated, altered, and restored, adding a great deal \n",
        "                      of modularity to PyTorch models and optimizers. Note that only layers with learnable parameters (convolutional layers, linear layers, \n",
        "                      etc.) and registered buffers (batchnorm’s running_mean) have entries in the model’s state_dict. Saving the model’s state_dict (i.e. \n",
        "                      model.state_dict()) with the torch.save() function will give the most flexibility for restoring the model later. model.state_dict() is the \n",
        "                      recommended method for saving models, because it only saves the trained model’s learned parameters. )\n",
        "                      (torch.save(model.state_dict()) saves only the trained model parameters (parameters means inputs, weights, bias, convolution layer etc))\n",
        "                      (Note: Modularity - Modularity refers to the concept of making multiple modules first and then linking and combining them to form a \n",
        "                      complete system.  Modularity enables re-usability and will minimize duplication.)\n",
        "                      (Note: Inference - Inference refers to the process of using a trained machine learning model to make a prediction. Basically inference \n",
        "                      means validating the trained model)\n",
        "                      (Basically, model.state_dict() => save a trained model, torch.save() => save a model)\n",
        "\n",
        "torch.save(model.state_dict()) => saves only the trained model parameters\n",
        "\n",
        "'/content/drive/MyDrive/Colab Notebooks/Models/cnn_model1.pth' => '/content/drive/MyDrive/Colab Notebooks/Models/ - is the path where we want to save the model\n",
        "                                                                   'cnn_lstm_model1.pth' - is the saved model file name (.pth extension or .pth FileType - \n",
        "                                                                   The pth file type is primarily associated(= connected, linked, related) with PyTorch. pth is \n",
        "                                                                   a data file for Machine Learning model or Deep Learning model with PyTorch. ) \n",
        "'''\n",
        "torch.save(model.state_dict(), '/content/drive/MyDrive/Colab Notebooks/Models/cnn_lstm_model1.pth')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bhtTdx5V0-iR"
      },
      "source": [
        "#Evaluating or validating the Model Performance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5iuTnkTB1YZ6"
      },
      "source": [
        "**Loading the Model**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2u2eH_-dpOq8",
        "outputId": "8c186262-80a4-49a8-97a7-35d40364eb22"
      },
      "source": [
        "'''\n",
        "model.load_state_dict() => load(= start, activate) the saved trained model of model.state_dict(), torch.load() => load the saved model of torch.save()\n",
        " ((In PyTorch, the learnable parameters (i.e. weights and biases) of a torch.nn.Module model are contained in the model’s parameters (accessed with \n",
        " model.parameters()). A state_dict is an essential entity(=object) if you are interested in saving or loading models from PyTorch. Because state_dict objects \n",
        " are Python dictionaries, they can be easily saved, updated, altered, and restored, adding a great deal of modularity to PyTorch models and optimizers. Note \n",
        " that only layers with learnable parameters (convolutional layers, linear layers, etc.) and registered buffers (batchnorm’s running_mean) have entries in the \n",
        " model’s state_dict. model.load_state_dict() is the recommended method for loading models, because it loads the trained model’s learned parameters.\n",
        " \n",
        " model.load_state_dict(torch.load()) => loads(= starts, activates) only the trained model parameters\n",
        "\n",
        " '/content/drive/MyDrive/Colab Notebooks/Models/cnn_model1.pth' => '/content/drive/MyDrive/Colab Notebooks/Models/ - is the path where we want to load the model \n",
        "                                                                   from \n",
        "                                                                   'cnn_lstm_model1.pth' - is the model file name which we want to load(.pth extension or .pth \n",
        "                                                                   FileType - The pth file type is primarily associated(= connected, linked, related) with \n",
        "                                                                   PyTorch. pth is a data file for Machine Learning model or Deep Learning model with PyTorch.)\n",
        "                                                                   \n",
        " <All keys matched successfully> represents => loading is successful (that means no missing keys or unexpected keys were found which interrupts the loading of\n",
        "                                               model)\n",
        "'''\n",
        "model.load_state_dict(torch.load('/content/drive/MyDrive/Colab Notebooks/Models/cnn_lstm_model1.pth'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yPy8w1S12RCW"
      },
      "source": [
        "**Applying Inference**\n",
        "\n",
        "(Inference - Inference refers to the process of using a trained machine learning model to make a prediction. Basically inference means validating the trained model)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "atZ4zQ-TprEW"
      },
      "source": [
        "'''\n",
        "def model_inference_helper(model, dataloader): => using def keyword, defined(= created) model_inference_helper function and passed model, dataloader as \n",
        "                                                  parameters inside the function\n",
        "\n",
        "results = {'labels':[], 'predictions':[]} => created results dictionary and stored 2 empty lists with keys 'labels' and 'predictions'. So in results dictionary, \n",
        "                                             'labels' key represents an empty list and 'predictions' key also represents an empty list\n",
        "\n",
        "model.eval() => model.eval() or model.train(mode=False) sets the mode to validate or test or evaluate. model.eval() tells our model that we are testing the \n",
        "                model or validating the model or evaluating the model or checking the model. So effectively layers like convolution, maxpool, ReLU, dropout, \n",
        "                batchnorm etc. which behave different on the train and test procedures know what is going on and hence can behave accordingly. model.eval() => \n",
        "                it indicates the model that nothing new is to be learnt and the model is used for validating. (Note: we think that eval() function validates or \n",
        "                evaluates the model but it does not do that. eval() just sets the mode and tells our model that we perform validation on the model)\n",
        "\n",
        "for i, batch in enumerate(dataloader): => i, batch are the iterators and dataloader is the iterable\n",
        "(iterator in python is an object that is used to iterate(= repeat, loop) over iterable objects like lists, tuples, dictionaries, and sets. the iterator object \n",
        "is initialized using the iter() method. iterator uses the next() method for iteration\n",
        "iterable is an object, which one(=iterator) can iterate(=repeat, loop) over. examples: lists, tuples, dictionaries, sets. iterable generates an iterator when \n",
        "passed(=moved) to iter() method. iterator is an object, which is used to iterate over an iterable object using next() method\n",
        "every iterator is also an iterable, but not every iterable is an iterator)\n",
        "enumerate() => https://www.geeksforgeeks.org/enumerate-in-python/ , https://www.tutorialspoint.com/enumerate-in-python\n",
        "(A lot of times when dealing with iterators, we also get a need to keep a count of iterations. Python eases the programmers task by providing a built-in \n",
        "function enumerate() for this task. Enumerate() method adds a counter to an iterable and returns it in a form of enumerate object. This enumerate object can \n",
        "then be used directly in for loops or be converted into a list of tuples using list() method )\n",
        "(enumerate() syntax = > enumerate(iterable, start=0)\n",
        "                        Parameters: \n",
        "                        Iterable: any object that supports iteration\n",
        "                        Start: the index value from which the counter is to be started, by default it is 0)\n",
        "(Basically, The enumerate() function assigns an index to each item in an iterable object that can be used to reference the item later. It makes it easier to \n",
        "keep track of the content(= data, information) of an iterable object.)\n",
        "\n",
        "x = batch['x'].to(device, dtype=torch.float) => connecting batch['x'] (batch['x'] => horiz accel and vert accel feature values of val data) to the device(here \n",
        "                                                device is the GPU). A torch.dtype is an object that represents the data type of a torch.Tensor. \n",
        "                                                dtype = torch.float represents 32-bit floating point number. (that means batch['x'] connects to GPU as floating \n",
        "                                                point datatype)\n",
        "\n",
        "y = batch['y'] => Connecting batch['y'] (batch['y'] => fault probability values or failure probability values of val data) to the device(here device is the GPU).\n",
        "\n",
        "with torch.no_grad(): => with statement in python automatically closes the opened file(automatically releases the memory) without using close() function\n",
        "                         torch.no_grad() => (1) https://pytorch.org/docs/stable/generated/torch.no_grad.html , \n",
        "                                            (2) https://stackoverflow.com/questions/63351268/torch-no-grad-affects-on-model-accuracy\n",
        "                         (torch.no_grad() basically skips(=ignores) the gradient calculation over the weights. That means we are not changing any weight in the \n",
        "                         specified layers. torch.no_grad() just disables the tracking of any calculations required to calculate a gradient. It won't have any \n",
        "                         effect on accuracy in a pure inference mode, since gradients are not needed there. but we can't use torch.no_grad() during training \n",
        "                         time since we need the gradients to train and optimize(=imprrove, enhance) the model. In general if we go for inference we always want \n",
        "                         to set the network to eval mode and disable gradients. This saves run time and memory consumption and won't affect accuracy. )\n",
        "                         (inference => Inference refers to the process of using a trained machine learning model to make a prediction. Basically inference \n",
        "                         means validating the trained model)) \n",
        "                         (gradient = gradient simply measures the change in all weights with respect to change in error(i.e. change in loss), basically gradient \n",
        "                         tells us that if loss changes how will the weights changes in neural networks). (gradient = difference in loss / difference in weights). \n",
        "                         (the gradient is a numeric calculation allowing us to know how to adjust the parameters of a network in such a way that its output \n",
        "                         deviation is minimized) )\n",
        "\n",
        "y_prediction = model(x) => predicting fault probability of val data using CNN + LSTM\n",
        "\n",
        "results['labels'] += y.squeeze().tolist() => results['labels] = results['labels'] + y.squeeze().tolist()\n",
        "(results['labels'] => represents an empty list)\n",
        "(y.squeeze().tolist() => squeeze - https://pytorch.org/docs/master/generated/torch.squeeze.html#torch.squeeze ..... the squeeze() method returns a tensor with \n",
        "                         all the dimensions of input of size 1 removed. squeeze() function removes one-dimensional entry or 1D input from the shape of the given \n",
        "                         tensor. \n",
        "                         tolist() => tolist() returns the tensor as a list.\n",
        "                         so, y.squeeze().tolist() => returns the fault probability values of val data as a list and also removes the 1D data if any)\n",
        "\n",
        "results['predictions'] += y_prediction.cpu().squeeze().tolist() => results['predictions'] = results['predictions'] + y_prediction.cpu().squeeze().tolist()\n",
        "(results['predictions'] => represents an empty list)\n",
        "(y_prediction.cpu().squeeze().tolist() => y_prediction - means predicting fault probability of val data using CNN\n",
        "                                          cpu() or tensor.cpu() in pytorch - This is used to move the tensor to CPU memory. tensor.cpu() or cpu() moves tensor \n",
        "                                          back to memory accessible to the CPU.\n",
        "                                          squeeze - https://pytorch.org/docs/master/generated/torch.squeeze.html#torch.squeeze ..... the squeeze() method \n",
        "                                          returns a tensor with all the dimensions of input of size 1 removed. squeeze() function removes one-dimensional entry \n",
        "                                          or 1D input from the shape of the given tensor. \n",
        "                                          tolist() => tolist() returns the tensor as a list.\n",
        "                                          so, y_prediction.cpu().squeeze().tolist() - applies prediction in finding out faults using CNN + LSTM on CPU and \n",
        "                                          returns predicted values as a list and also removes the 1D data if any )\n",
        "\n",
        "return results => here, return keyword returns the results dictionary with 'labels' key and 'predictions' key(i.e. return the labels list values and predictions \n",
        "list values of results dictionary) and exits(comes out from) the model_inference_helper() function. Basically returns the actual values and predicted values\n",
        "\n",
        "(Basically, results['labels'] = contains actual fault probability values or real failure probability values\n",
        "            results['predictions'] = contains predicted fault probability values or predicted failure probability values)\n",
        "'''\n",
        "def model_inference_helper(model, dataloader):\n",
        "    results = {'labels':[], 'predictions':[]}\n",
        "    model.eval()\n",
        "    for i, batch in enumerate(dataloader):\n",
        "        x = batch['x'].to(device, dtype=torch.float)\n",
        "        y = batch['y']\n",
        "\n",
        "        with torch.no_grad():\n",
        "            y_prediction = model(x)\n",
        "\n",
        "        if y.size(0)>1:\n",
        "            results['labels'] += y.squeeze().tolist()\n",
        "            results['predictions'] += y_prediction.cpu().squeeze().tolist()\n",
        "        elif y.size(0)==1:\n",
        "            results['labels'].append(y.squeeze().tolist())\n",
        "            results['predictions'].append(y_prediction.cpu().squeeze().tolist())\n",
        "    return results"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rOqsZth67efE"
      },
      "source": [
        "**sorting(= arranging in order) the results dictionary (i.e. sorting labels (actual values) and predicted values)**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r9BRx29ZqXw_"
      },
      "source": [
        "'''\n",
        "def sort_results(results): => using def keyword defined(=created) sort_results() function and passed results as a parameter inside a function\n",
        "\n",
        "ind = [i[0] for i in sorted(enumerate(results['labels']), key=lambda x: x[1])] => Basically sorting the actual values or labels\n",
        "sorted(enumerate(results['labels']) => means here, we are sorting(=arranging in an order) labels(or actual values)\n",
        "i[0] => represents 1st element\n",
        "i[0] for i in sorted(enumerate(results['labels'])) => enumerate() gives the output as follows - (index, value), so we are inserting 1st value in this)\n",
        "lambda => A lambda function is a small anonymous(=unknown) function. A lambda function can take any number of arguments(arguments = data that are passed into a \n",
        "          function(here lambda function)), but can only have one expression.\n",
        "key=lambda x: x[1] => lambda x: x[1] takes the single argument x and returns x[1] (i.e. the item at index 1 in x ). key stored the lambda x: x[1]\n",
        "\n",
        "results['labels'] = [results['labels'][i] for i in ind] => traversing(=moving) through every actual value or label\n",
        "\n",
        "results['predictions'] = [results['predictions'][i] for i in ind] => traversing(= moving) through every predicted value\n",
        "\n",
        "return results => here, return keyword returns the sorted(= arranged in order) results dictionary with 'labels' key and 'predictions' key(i.e. return the labels \n",
        "list values which are sorted(= arranged in order) and predictions list values which are sorted(= arranged in order) of results dictionary) and exits(comes out \n",
        "from) the sort_results() function \n",
        "'''\n",
        "def sort_results(results):\n",
        "    ind = [i[0] for i in sorted(enumerate(results['labels']), key=lambda x: x[1])]\n",
        "    results['labels'] = [results['labels'][i] for i in ind]\n",
        "    results['predictions'] = [results['predictions'][i] for i in ind]\n",
        "    return results"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kCVir1dS5TaC"
      },
      "source": [
        "**Performance on bearing1_1.pkz dataset**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 334
        },
        "id": "OR8Dhdsaqxfh",
        "outputId": "4452079b-1296-49f5-91cb-5c120469856b"
      },
      "source": [
        "'''\n",
        "train_results = model_inference_helper(model, train_dataloaders[0]) =>\n",
        "model_inference_helper(model, train_dataloader[0]) - this function uses a trained machine learning model(i.e. CNN_LSTM_FP() ) to make a prediction on \n",
        "bearing1_1_train_data.pkz. here, model is CNN_LSTM_FP() and train_dataloaders[0] contains bearing1_1 train data pickle file. train_results is created to store \n",
        "this function\n",
        "\n",
        "val_results = model_inference_helper(model, val_dataloaders[0]) =>\n",
        "model_inference_helper(model, val1_dataloader[0]) - this function uses a trained machine learning model(i.e. CNN_LSTM_FP() ) to make a prediction on \n",
        "bearing1_1_val_data.pkz. here, model is CNN_LSTM_FP() and val_dataloaders[0] contains bearing1_1 validation data pickle file. val_results is created to store \n",
        "this function\n",
        "\n",
        "results = {'labels': train_results['labels']+val_results['labels'], 'predictions': train_results['predictions']+val_results['predictions']} =>\n",
        "'labels': train_results['labels']+val_results['labels'] - therefore, results['labels'] = bearing1_1_train_data.pkz actual values + bearing1_1_val_data.pkz \n",
        "          actual values\n",
        "'predictions': train_results['predictions']+val_results['predictions'] - therefore, results['predictions'] = bearing1_1_train_data.pkz predicted values and \n",
        "               bearing1_1_val_data.pkz predicted values\n",
        "therefore, results dictionary contains bearing1_1_train_data.pkz actual values + bearing1_1_val_data.pkz actual values + bearing1_1_train_data.pkz predicted \n",
        "values + bearing1_1_val_data.pkz predicted values\n",
        "\n",
        "results = sort_results(results) => sort the results dictionary (arranges the results dictionary elements in a certain order)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=[20,5]) => \n",
        "In matplotlib, A plot is a graphical technique for representing a data set, usually as a graph showing the relationship between two or more variables. Subplots \n",
        "mean groups of axes(x-axis, y-axis) that can exist in a single matplotlib figure. subplots() function in the matplotlib library, helps in creating multiple \n",
        "layouts(= diagrams, sketches) of subplots.\n",
        "plt.subplots(nrows=1, ncols=2, figsize=[20,5]) - plt.subplots() create a figure and a set of subplots. nrows - number of rows of a subplot grid. ncols - number\n",
        "                                                 of columns of a subplot grid. figsize method in matplotlib is used to set the dimensions(length and width) of\n",
        "                                                 a matplotlib figure. figsize is also used to change the dimensions(length and width) of a matplotlib figure. \n",
        "                                                 here, 20 is the width and 5 is the height\n",
        "                                                 (grid - a pattern of horizontal and vertical lines that cross each other to make a set of squares. A grid looks\n",
        "                                                 like this - https://www.mathsisfun.com/definitions/grid.html)\n",
        "\n",
        "ax[0].plot(range(len(results['labels'])), results['labels'], 'b.-', label='labels') =>\n",
        "plotting labels(actual values) of bearing1_1_train_data.pkz and bearing1_1_val_data.pkz. The labels or actual values represented with blue color('b.-') in the \n",
        "plot or graph and labeled(= named) as labels(actual values)\n",
        "(A plot is a graphical technique for representing a data set, usually as a graph showing the relationship between two or more variables. The plot() function is \n",
        "used to draw points(markers) in a diagram. By default, the plot() function draws a line from point to point. The function takes parameters for specifying points \n",
        "in the diagram. Parameter 1 is an array containing the points on the x-axis. Parameter 2 is an array containing the points on the y-axis.)\n",
        "\n",
        "ax[0].plot(range(len(results['predictions'])), results['predictions'], 'r.-', label='predicted values') =>\n",
        "plotting predicted values of bearing1_1_train_data.pkz and bearing1_1_val_data.pkz. The predicted values represented with red color('r.-') in the plot or graph \n",
        "and labeled(= named) as predicted values\n",
        "\n",
        "ax[0].legend() => ax[0].legend() is used to display the tags or labels(i.e. labels(actual values) and predicted values) on top left of the plot\n",
        "\n",
        "(ax[0] => represents 1st column)\n",
        "\n",
        "ax[1].scatter(train_results['labels'], train_results['predictions'], marker='.', c='b', label='train') =>\n",
        "scatter() => https://www.w3schools.com/python/matplotlib_scatter.asp (With Matplotlib Pyplot, we can use the scatter() function to draw a scatter plot. The \n",
        "scatter() function plots one dot(= point) for each observation(plots one dot for x-axis and y-axis combined). It needs two arrays or lists or tuples, etc. of \n",
        "the same length, one for the values of the x-axis, and one for values on the y-axis)\n",
        "train_results['labels'] => x-axis(horizontal axis), bearing1_1_train_data true labels(or bearing1_1_train_data actual values)\n",
        "(actual value - the actual value is the value that is obtained by observation or by measuring the available data(or past data or previous performance data). It \n",
        "is also called the observed value. )\n",
        "train_results['predictions'] => y-axis(vertical axis), bearing1_1_train_data predicted values\n",
        "(predicted value - The predicted value is the value that is predicted based on the regression analysis. Regression problem => Predicting a value for an input \n",
        "observation based on previous(=past) data.)\n",
        "marker => https://matplotlib.org/stable/api/markers_api.html\n",
        "c='b' => represents blue color to the label\n",
        "label='train' => means labeled(= named) as train\n",
        "since we used scatter() function for plotting, it plots the point based on both x-axis(true labels) and y-axis(predictions). Basically scatter() function plots\n",
        "one point for both x-axis and y-axis\n",
        "\n",
        "ax[1].scatter(val_results['labels'], val_results['predictions'], marker='.', c='r', label='val')\n",
        "val_results['labels'] => x-axis(horizontal axis), bearing1_1_val_data true labels(or bearing1_1_val_data actual values)\n",
        "val_results['predictions'] => y-axis(vertical axis), bearing1_1_val_data predicted values\n",
        "marker => https://matplotlib.org/stable/api/markers_api.html\n",
        "c='r' => represents red color to the label\n",
        "label='val' => means labeled(= named) as val\n",
        "\n",
        "ax[1].scatter(results['labels'], results['labels'], marker='.', c='k', label='expected') =>\n",
        "results['labels'] => x-axis(horizontal axis), bearing1_1_train_data true labels and bearing1_1_val_data true labels\n",
        "results['labels'] => y-axis(vertical axis), bearing1_1_train_data true labels and bearing1_1_val_data true labels\n",
        "marker => https://matplotlib.org/stable/api/markers_api.html\n",
        "c='k' => represents black color to the label\n",
        "label='expected' => means labeled(= named) as expected\n",
        "(expected - our ideal(= perfect) expected values. for example ideally, if the real value or actual value or true label or label is 0.1, then predicted value\n",
        "should also 0.1. basically expected label is plotted to visualize(= analyze, view, see) the results(train, val), how much closely related to the ideal \n",
        "expected values. here, expected represents a black line, if we draw plot to all the real values then we get the expected values. Ideally, the results predicted\n",
        "should lie on the black line(i.e. expected values line), then only we can say that our model is performing correctly)\n",
        "\n",
        "ax[1].set_xlabel('true labels') => labelled(= named) x-axis as true labels\n",
        "\n",
        "ax[1].set_ylabel('predictions') => labelled(= named) y-axis as predictions\n",
        "\n",
        "ax[1].legend() => ax[1].legend() is used to display the tags or labels(i.e. train, val and expected) on top left of the plot\n",
        "\n",
        "(ax[1] => represents 2nd column)\n",
        "\n",
        "plt.subplots_adjust(wspace=0.5) => plt.subplots_adjust - adjust the subplot layouts(= diagrams, sketches)\n",
        "                                   wspace - The width of the padding(= spacing) between subplots, here wspace=0.5\n",
        "\n",
        "plt.show() => The show() function in pyplot module of matplotlib library is used to display the plot or diagram or figure. here, plt.show() is used to display \n",
        "              the hexagonal binning plot as shown in output\n",
        "'''\n",
        "train_results = model_inference_helper(model, train_dataloaders[0])\n",
        "val_results = model_inference_helper(model, val_dataloaders[0])\n",
        "results = {'labels': train_results['labels']+val_results['labels'], 'predictions': train_results['predictions']+val_results['predictions']}\n",
        "results = sort_results(results)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=[20,5])\n",
        "ax[0].plot(range(len(results['labels'])), results['labels'], 'b.-', label='labels(actual values)')\n",
        "ax[0].plot(range(len(results['predictions'])), results['predictions'], 'r.-', label='predicted values')\n",
        "ax[0].legend()\n",
        "ax[1].scatter(train_results['labels'], train_results['predictions'], marker='.', c='b', label='train')\n",
        "ax[1].scatter(val_results['labels'], val_results['predictions'], marker='.', c='r', label='val')\n",
        "ax[1].scatter(results['labels'], results['labels'], marker='.', c='k', label='expected')\n",
        "ax[1].set_xlabel('true labels')\n",
        "ax[1].set_ylabel('predictions')\n",
        "ax[1].legend()\n",
        "plt.subplots_adjust(wspace=0.5)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zz4D3dP39eE4"
      },
      "source": [
        "**Performance on bearing1_2.pkz dataset**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 334
        },
        "id": "FMecWMHhsXn3",
        "outputId": "f95c18a3-312e-4849-c2b9-6e9eb90421fc"
      },
      "source": [
        "train_results = model_inference_helper(model, train_dataloaders[1])\n",
        "val_results = model_inference_helper(model, val_dataloaders[1])\n",
        "results = {'labels': train_results['labels']+val_results['labels'], 'predictions': train_results['predictions']+val_results['predictions']}\n",
        "results = sort_results(results)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=[20,5])\n",
        "ax[0].plot(range(len(results['labels'])), results['labels'], 'b.-', label='labels(actual values)')\n",
        "ax[0].plot(range(len(results['predictions'])), results['predictions'], 'r.-', label='predicted values')\n",
        "ax[0].legend()\n",
        "ax[1].scatter(train_results['labels'], train_results['predictions'], marker='.', c='b', label='train')\n",
        "ax[1].scatter(val_results['labels'], val_results['predictions'], marker='.', c='r', label='val')\n",
        "ax[1].scatter(results['labels'], results['labels'], marker='.', c='k', label='expected')\n",
        "ax[1].set_xlabel('true labels')\n",
        "ax[1].set_ylabel('predictions')\n",
        "ax[1].legend()\n",
        "plt.subplots_adjust(wspace=0.5)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zfNW3SvP9paH"
      },
      "source": [
        "**Performance on bearing2_1.pkz dataset**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 334
        },
        "id": "oHHNQDcys7Uy",
        "outputId": "504cbd8f-cfd8-4d84-f92f-3f679bac7a43"
      },
      "source": [
        "train_results = model_inference_helper(model, train_dataloaders[2])\n",
        "val_results = model_inference_helper(model, val_dataloaders[2])\n",
        "results = {'labels': train_results['labels']+val_results['labels'], 'predictions': train_results['predictions']+val_results['predictions']}\n",
        "results = sort_results(results)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=[20,5])\n",
        "ax[0].plot(range(len(results['labels'])), results['labels'], 'b.-', label='labels(actual values)')\n",
        "ax[0].plot(range(len(results['predictions'])), results['predictions'], 'r.-', label='predicted values')\n",
        "ax[0].legend()\n",
        "ax[1].scatter(train_results['labels'], train_results['predictions'], marker='.', c='b', label='train')\n",
        "ax[1].scatter(val_results['labels'], val_results['predictions'], marker='.', c='r', label='val')\n",
        "ax[1].scatter(results['labels'], results['labels'], marker='.', c='k', label='expected')\n",
        "ax[1].set_xlabel('true labels')\n",
        "ax[1].set_ylabel('predictions')\n",
        "ax[1].legend()\n",
        "plt.subplots_adjust(wspace=0.5)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Svf-F0O9wWq"
      },
      "source": [
        "**Performance on bearing2_2.pkz dataset**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 334
        },
        "id": "6PpF1XT1tnsu",
        "outputId": "b299b913-8f90-4ab3-a371-e6e12d75c561"
      },
      "source": [
        "train_results = model_inference_helper(model, train_dataloaders[3])\n",
        "val_results = model_inference_helper(model, val_dataloaders[3])\n",
        "results = {'labels': train_results['labels']+val_results['labels'], 'predictions': train_results['predictions']+val_results['predictions']}\n",
        "results = sort_results(results)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=[20,5])\n",
        "ax[0].plot(range(len(results['labels'])), results['labels'], 'b.-', label='labels(actual values)')\n",
        "ax[0].plot(range(len(results['predictions'])), results['predictions'], 'r.-', label='predicted values')\n",
        "ax[0].legend()\n",
        "ax[1].scatter(train_results['labels'], train_results['predictions'], marker='.', c='b', label='train')\n",
        "ax[1].scatter(val_results['labels'], val_results['predictions'], marker='.', c='r', label='val')\n",
        "ax[1].scatter(results['labels'], results['labels'], marker='.', c='k', label='expected')\n",
        "ax[1].set_xlabel('true labels')\n",
        "ax[1].set_ylabel('predictions')\n",
        "ax[1].legend()\n",
        "plt.subplots_adjust(wspace=0.5)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2xwRvuOe96Of"
      },
      "source": [
        "**Performance on bearing3_1.pkz dataset**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 334
        },
        "id": "mMzMo2aPuWBt",
        "outputId": "b08d5e73-024e-4ac0-ba94-b71c73de42ae"
      },
      "source": [
        "train_results = model_inference_helper(model, train_dataloaders[4])\n",
        "val_results = model_inference_helper(model, val_dataloaders[4])\n",
        "results = {'labels': train_results['labels']+val_results['labels'], 'predictions': train_results['predictions']+val_results['predictions']}\n",
        "results = sort_results(results)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=[20,5])\n",
        "ax[0].plot(range(len(results['labels'])), results['labels'], 'b.-', label='labels(actual values)')\n",
        "ax[0].plot(range(len(results['predictions'])), results['predictions'], 'r.-', label='predicted values')\n",
        "ax[0].legend()\n",
        "ax[1].scatter(train_results['labels'], train_results['predictions'], marker='.', c='b', label='train')\n",
        "ax[1].scatter(val_results['labels'], val_results['predictions'], marker='.', c='r', label='val')\n",
        "ax[1].scatter(results['labels'], results['labels'], marker='.', c='k', label='expected')\n",
        "ax[1].set_xlabel('true labels')\n",
        "ax[1].set_ylabel('predictions')\n",
        "ax[1].legend()\n",
        "plt.subplots_adjust(wspace=0.5)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_gyawgB-AmW"
      },
      "source": [
        "**Performance on bearing3_2.pkz dataset**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 334
        },
        "id": "FanPNsTNvSnt",
        "outputId": "9a1b570c-8c86-4643-c228-1c8bd8fbd700"
      },
      "source": [
        "train_results = model_inference_helper(model, train_dataloaders[5])\n",
        "val_results = model_inference_helper(model, val_dataloaders[5])\n",
        "results = {'labels': train_results['labels']+val_results['labels'], 'predictions': train_results['predictions']+val_results['predictions']}\n",
        "results = sort_results(results)\n",
        "\n",
        "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=[20,5])\n",
        "ax[0].plot(range(len(results['labels'])), results['labels'], 'b.-', label='labels(actual values)')\n",
        "ax[0].plot(range(len(results['predictions'])), results['predictions'], 'r.-', label='predicted values')\n",
        "ax[0].legend()\n",
        "ax[1].scatter(train_results['labels'], train_results['predictions'], marker='.', c='b', label='train')\n",
        "ax[1].scatter(val_results['labels'], val_results['predictions'], marker='.', c='r', label='val')\n",
        "ax[1].scatter(results['labels'], results['labels'], marker='.', c='k', label='expected')\n",
        "ax[1].set_xlabel('true labels')\n",
        "ax[1].set_ylabel('predictions')\n",
        "ax[1].legend()\n",
        "plt.subplots_adjust(wspace=0.5)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}