2. pytorch_lstm_simpleSeq.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "pytorch_lstm_simpleSeq.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "HBDcgn2-oEwx"
      },
      "source": [
        "%matplotlib inline\n",
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "from torchsummary import summary\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns \n",
        "import argparse\n",
        "import time\n",
        "from copy import deepcopy # Add Deepcopy for args"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RUcAo9s2JA8s"
      },
      "source": [
        "# Generating Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aFPdECgiGdho",
        "outputId": "8b0432c1-7bdb-485c-8970-d1d0b0abcc56"
      },
      "source": [
        "# split a univariate sequence into samples\n",
        "def split_sequence(sequence, n_steps):\n",
        "\tX, y = list(), list()\n",
        "\tfor i in range(len(sequence)):\n",
        "\t\t# find the end of this pattern\n",
        "\t\tend_ix = i + n_steps\n",
        "\t\t# check if we are beyond the sequence\n",
        "\t\tif end_ix > len(sequence)-1:\n",
        "\t\t\tbreak\n",
        "\t\t# gather input and output parts of the pattern\n",
        "\t\tseq_x, seq_y = sequence[i:end_ix], sequence[end_ix]\n",
        "\t\tX.append(seq_x)\n",
        "\t\ty.append(seq_y)\n",
        "\treturn np.array(X), np.array(y)\n",
        " \n",
        "# define input sequence\n",
        "raw_seq = [10*i for i in range(1000)] #[10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
        "# choose a number of time steps\n",
        "n_steps = 3\n",
        "# split into samples\n",
        "X, y = split_sequence(raw_seq, n_steps)\n",
        "# reshape from [batch_size, seq_len] into [seq_len, batch_size, features]\n",
        "n_features = 1\n",
        "X = np.swapaxes(X,0,1)\n",
        "X = X.reshape((X.shape[0], X.shape[1], n_features))\n",
        "\n",
        "print(X[:,:10,0], \"\\n\", y[:10])\n",
        "\n",
        "print(\"X.shape = {}\".format(X.shape))\n",
        "print(\"y.shape = {}\".format(y.shape))"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[  0  10  20  30  40  50  60  70  80  90]\n",
            " [ 10  20  30  40  50  60  70  80  90 100]\n",
            " [ 20  30  40  50  60  70  80  90 100 110]] \n",
            " [ 30  40  50  60  70  80  90 100 110 120]\n",
            "X.shape = (3, 997, 1)\n",
            "y.shape = (997,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wB6nIOo6JTtC"
      },
      "source": [
        "# Model Define"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Op8pMqA-8WjG"
      },
      "source": [
        "class LSTM(nn.Module):\n",
        "    def __init__(self, input_dim, output_dim, hid_dim, batch_first = False): \n",
        "        super(LSTM, self).__init__()\n",
        "        \n",
        "        self.input_dim = input_dim\n",
        "        self.output_dim = output_dim\n",
        "        self.hid_dim = hid_dim\n",
        "\n",
        "        self.layer = nn.LSTM(input_size = self.input_dim, hidden_size = self.hid_dim, batch_first = batch_first)\n",
        "        self.FC = nn.Linear(self.hid_dim, self.output_dim)\n",
        "\n",
        "    def forward(self, x):\n",
        "        output, (h, c) = self.layer(x)\n",
        "        y = self.FC(output[-1]) # many-to-one\n",
        "        return y\n",
        "\n",
        "\n",
        "class LSTM_2FC(nn.Module):\n",
        "    def __init__(self, input_dim, output_dim, hid_dim, batch_first = False): \n",
        "        super(LSTM_2FC, self).__init__()\n",
        "        \n",
        "        self.input_dim = input_dim\n",
        "        self.output_dim = output_dim\n",
        "        self.hid_dim = hid_dim\n",
        "\n",
        "        self.layer = nn.LSTM(input_size = self.input_dim, hidden_size = self.hid_dim, batch_first = batch_first)\n",
        "        self.FC1 = nn.Linear(self.hid_dim, self.hid_dim//2)\n",
        "        self.FC2 = nn.Linear(self.hid_dim//2, self.output_dim)\n",
        "\n",
        "    def forward(self, x):\n",
        "        output, (h, c) = self.layer(x)\n",
        "        y = self.FC1(output[-1]) # many-to-one\n",
        "        y = self.FC2(y)\n",
        "        return y"
      ],
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "39l8qBuDMn-F"
      },
      "source": [
        "# Model training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UmH1pnS-xB02"
      },
      "source": [
        "def experiment(data, args):  \n",
        "    net = LSTM_2FC(args.input_dim, args.output_dim, args.hid_dim, args.batch_first)\n",
        "\n",
        "    criterion = nn.MSELoss() # regression 문제이므로\n",
        "    optimizer = optim.Adam(net.parameters(), lr = args.lr, weight_decay=args.l2 if args.l2 is not None else 0)\n",
        "    \n",
        "    train_losses = []\n",
        "        \n",
        "    for epoch in range(args.epoch):  # loop over the dataset multiple times\n",
        "        optimizer.zero_grad() \n",
        "\n",
        "        #print(epoch)\n",
        "        input_x, true_y = data\n",
        "\n",
        "        input_x = torch.Tensor(input_x).float()\n",
        "        true_y = torch.Tensor(true_y).float()\n",
        "\n",
        "        pred_y = net(input_x)\n",
        "        #print(input_x.shape, pred_y.shape, true_y.shape)\n",
        "        print(torch.squeeze(pred_y)[:5])\n",
        "        print(true_y[:5])\n",
        "\n",
        "        loss = criterion(torch.squeeze(pred_y), true_y)\n",
        "        print(f'Epoch : {epoch} - loss : {loss.item()/len(true_y)}\\n')\n",
        "        train_losses.append(loss.item()/len(true_y))\n",
        "\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "\n",
        "    # Give first starting sequence and let the model generate rest \n",
        "    test_y = np.array([10,20,30])\n",
        "    for i in range(100):\n",
        "        test_x = test_y[i : i + n_steps]\n",
        "        test_x = test_x.reshape((n_steps, 1, n_features))\n",
        "        y = net(torch.Tensor(test_x).float())\n",
        "        test_y = np.append(test_y, y.view(-1).item())\n",
        "\n",
        "    return test_y, train_losses"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0A-B_TTdn-XK"
      },
      "source": [
        "# Experiment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPHcTlXQSI9X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df81cd8c-d5c8-4054-94c8-1f907c87dc9e"
      },
      "source": [
        "# ====== Random Seed Initialization ====== #\n",
        "seed = 123\n",
        "np.random.seed(seed)\n",
        "torch.manual_seed(seed)\n",
        "\n",
        "parser = argparse.ArgumentParser()\n",
        "args = parser.parse_args(\"\")\n",
        "\n",
        "# ====== Model Capacity ====== #\n",
        "args.input_dim = 1\n",
        "args.output_dim = 1 \n",
        "args.hid_dim = 30\n",
        "args.seq_len = n_steps\n",
        "\n",
        "# ====== Regularization ======= #\n",
        "args.l2 = 0\n",
        "\n",
        "# ====== Optimizer & Training ====== #\n",
        "args.lr = 1e-3\n",
        "args.epoch = 1000\n",
        "args.batch_first = False\n",
        "\n",
        "\n",
        "# ====== Experiment Variable ====== #\n",
        "# gen_y, train_losses = experiment((X, y), deepcopy(args))\n",
        "\n",
        "mode = \"single\" # \"double\", None\n",
        "\n",
        "if mode == \"single\" :\n",
        "    name_var1 = 'hid_dim'\n",
        "    list_var1 = [20, 23, 25]\n",
        "\n",
        "    loss_df = pd.DataFrame(columns=['loss', name_var1])\n",
        "    df = pd.DataFrame(columns=['gen_y', name_var1])\n",
        "    for var1 in list_var1:\n",
        "        setattr(args, name_var1, var1)\n",
        "        print(args)\n",
        "        \n",
        "        ts = time.time()\n",
        "        gen_y, train_losses = experiment((X, y), deepcopy(args))\n",
        "        te = time.time()\n",
        "        print(f'Elapsed time : {te-ts}s\\n')\n",
        "\n",
        "        newDf = pd.DataFrame({\"gen_y\":gen_y, name_var1:[var1]*len(gen_y)})\n",
        "        df = pd.concat([df, newDf])\n",
        "        loss_df = pd.concat([loss_df, pd.DataFrame({\"loss\":train_losses, name_var1:[var1]*len(train_losses)}) ])"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[1;30;43m스트리밍 출력 내용이 길어서 마지막 5000줄이 삭제되었습니다.\u001b[0m\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 751 - loss : 29585.2517552658\n",
            "\n",
            "tensor([29.9042, 39.8461, 49.8032, 59.9042, 69.6987], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 752 - loss : 29576.290872617854\n",
            "\n",
            "tensor([30.1886, 40.2190, 50.2555, 60.4659, 70.3919], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 753 - loss : 29567.3259779338\n",
            "\n",
            "tensor([29.7871, 39.7131, 49.6327, 59.7046, 69.4650], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 754 - loss : 29558.353059177534\n",
            "\n",
            "tensor([30.2564, 40.3303, 50.3918, 60.6490, 70.6273], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 755 - loss : 29549.376128385156\n",
            "\n",
            "tensor([29.7023, 39.6258, 49.5346, 59.6053, 69.3502], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 756 - loss : 29540.387161484454\n",
            "\n",
            "tensor([30.2614, 40.3307, 50.3914, 60.6659, 70.6594], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 757 - loss : 29531.394182547643\n",
            "\n",
            "tensor([29.7809, 39.7041, 49.6295, 59.7421, 69.5315], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 758 - loss : 29522.389167502508\n",
            "\n",
            "tensor([30.1061, 40.0992, 50.1010, 60.3222, 70.2483], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 759 - loss : 29513.37813440321\n",
            "\n",
            "tensor([30.0334, 39.9937, 49.9613, 60.1485, 70.0365], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 760 - loss : 29504.36108324975\n",
            "\n",
            "tensor([29.9080, 39.8356, 49.7566, 59.8904, 69.7168], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 761 - loss : 29495.33600802407\n",
            "\n",
            "tensor([30.2266, 40.2576, 50.2572, 60.4943, 70.4533], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 762 - loss : 29486.30290872618\n",
            "\n",
            "tensor([29.7878, 39.7319, 49.6148, 59.7011, 69.4701], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 763 - loss : 29477.263791374124\n",
            "\n",
            "tensor([30.2133, 40.3104, 50.3208, 60.5681, 70.5331], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 764 - loss : 29468.218655967903\n",
            "\n",
            "tensor([29.8219, 39.8221, 49.7286, 59.8499, 69.6590], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 765 - loss : 29459.16148445336\n",
            "\n",
            "tensor([30.0034, 40.0542, 50.0150, 60.2106, 70.1071], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 766 - loss : 29450.104312938816\n",
            "\n",
            "tensor([30.0341, 40.0754, 50.0423, 60.2529, 70.1624], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 767 - loss : 29441.03109327984\n",
            "\n",
            "tensor([29.8651, 39.8211, 49.7254, 59.8686, 69.6954], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 768 - loss : 29431.957873620864\n",
            "\n",
            "tensor([30.2020, 40.2245, 50.2114, 60.4678, 70.4322], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 769 - loss : 29422.878635907724\n",
            "\n",
            "tensor([29.8476, 39.7664, 49.6550, 59.7897, 69.5961], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 770 - loss : 29413.785356068205\n",
            "\n",
            "tensor([30.2094, 40.2265, 50.2092, 60.4700, 70.4374], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 771 - loss : 29404.688064192578\n",
            "\n",
            "tensor([29.8621, 39.8093, 49.7066, 59.8581, 69.6850], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 772 - loss : 29395.58475426279\n",
            "\n",
            "tensor([30.0830, 40.1189, 50.0848, 60.3231, 70.2567], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 773 - loss : 29386.469408224675\n",
            "\n",
            "tensor([29.9471, 39.9582, 49.8842, 60.0749, 69.9531], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 774 - loss : 29377.35406218656\n",
            "\n",
            "tensor([29.9378, 39.9539, 49.8743, 60.0597, 69.9314], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 775 - loss : 29368.22266800401\n",
            "\n",
            "tensor([30.0886, 40.1415, 50.0955, 60.3269, 70.2565], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 776 - loss : 29359.091273821465\n",
            "\n",
            "tensor([29.8642, 39.8424, 49.7240, 59.8686, 69.6911], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 777 - loss : 29349.94784353059\n",
            "\n",
            "tensor([30.1973, 40.2558, 50.2240, 60.4854, 70.4548], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 778 - loss : 29340.80441323972\n",
            "\n",
            "tensor([29.7997, 39.7471, 49.6074, 59.7352, 69.5337], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 779 - loss : 29331.64493480441\n",
            "\n",
            "tensor([30.2453, 40.3140, 50.2989, 60.5911, 70.5949], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 780 - loss : 29322.485456369108\n",
            "\n",
            "tensor([29.7502, 39.6934, 49.5536, 59.6889, 69.4875], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 781 - loss : 29313.313941825476\n",
            "\n",
            "tensor([30.2168, 40.2806, 50.2634, 60.5608, 70.5675], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 782 - loss : 29304.138415245736\n",
            "\n",
            "tensor([29.8044, 39.7588, 49.6325, 59.7923, 69.6201], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 783 - loss : 29294.954864593783\n",
            "\n",
            "tensor([30.1127, 40.1456, 50.0949, 60.3533, 70.3082], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 784 - loss : 29285.76328986961\n",
            "\n",
            "tensor([29.9762, 39.9644, 49.8647, 60.0634, 69.9478], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 785 - loss : 29276.565697091275\n",
            "\n",
            "tensor([29.9641, 39.9542, 49.8451, 60.0312, 69.9016], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 786 - loss : 29267.360080240724\n",
            "\n",
            "tensor([30.1401, 40.1903, 50.1263, 60.3687, 70.3123], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 787 - loss : 29258.148445336006\n",
            "\n",
            "tensor([29.8294, 39.8130, 49.6687, 59.8069, 69.6155], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 788 - loss : 29248.93079237713\n",
            "\n",
            "tensor([30.2081, 40.3097, 50.2759, 60.5554, 70.5405], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 789 - loss : 29239.705115346038\n",
            "\n",
            "tensor([29.7419, 39.7287, 49.5838, 59.7224, 69.5170], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 790 - loss : 29230.473420260783\n",
            "\n",
            "tensor([30.2096, 40.3018, 50.2790, 60.5824, 70.5887], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 791 - loss : 29221.23370110331\n",
            "\n",
            "tensor([29.7678, 39.7242, 49.5886, 59.7531, 69.5721], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 792 - loss : 29211.983951855567\n",
            "\n",
            "tensor([30.1587, 40.1863, 50.1413, 60.4289, 70.4082], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 793 - loss : 29202.732196589768\n",
            "\n",
            "tensor([29.9331, 39.8804, 49.7654, 59.9671, 69.8359], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 794 - loss : 29193.468405215648\n",
            "\n",
            "tensor([30.0413, 40.0140, 49.9178, 60.1436, 70.0472], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 795 - loss : 29184.20260782347\n",
            "\n",
            "tensor([30.0972, 40.1006, 50.0134, 60.2481, 70.1680], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 796 - loss : 29174.928786359076\n",
            "\n",
            "tensor([29.8885, 39.8744, 49.7384, 59.9041, 69.7340], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 797 - loss : 29165.646940822466\n",
            "\n",
            "tensor([30.1728, 40.2698, 50.2173, 60.4861, 70.4498], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 798 - loss : 29156.35506519559\n",
            "\n",
            "tensor([29.7465, 39.7588, 49.6079, 59.7480, 69.5371], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 799 - loss : 29147.0591775326\n",
            "\n",
            "tensor([30.2091, 40.3392, 50.3130, 60.6178, 70.6181], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 800 - loss : 29137.757271815448\n",
            "\n",
            "tensor([29.7146, 39.6957, 49.5469, 59.7010, 69.4927], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 801 - loss : 29128.44934804413\n",
            "\n",
            "tensor([30.2178, 40.2793, 50.2457, 60.5593, 70.5607], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 802 - loss : 29119.1334002006\n",
            "\n",
            "tensor([29.8369, 39.7668, 49.6318, 59.8223, 69.6535], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 803 - loss : 29109.81143430291\n",
            "\n",
            "tensor([30.1402, 40.1198, 50.0482, 60.3257, 70.2748], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 804 - loss : 29100.479438314946\n",
            "\n",
            "tensor([30.0145, 39.9621, 49.8505, 60.0774, 69.9626], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 805 - loss : 29091.141424272817\n",
            "\n",
            "tensor([29.9763, 39.9462, 49.8272, 60.0387, 69.9046], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 806 - loss : 29081.799398194584\n",
            "\n",
            "tensor([30.1343, 40.1869, 50.1119, 60.3738, 70.3096], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 807 - loss : 29072.44332998997\n",
            "\n",
            "tensor([29.8004, 39.8138, 49.6654, 59.8269, 69.6259], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 808 - loss : 29063.087261785357\n",
            "\n",
            "tensor([30.1888, 40.3243, 50.2818, 60.5791, 70.5569], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 809 - loss : 29053.72116349047\n",
            "\n",
            "tensor([29.7064, 39.7186, 49.5617, 59.7167, 69.4948], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 810 - loss : 29044.353059177534\n",
            "\n",
            "tensor([30.2223, 40.3275, 50.2924, 60.6147, 70.6138], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 811 - loss : 29034.976930792378\n",
            "\n",
            "tensor([29.7682, 39.7207, 49.5712, 59.7573, 69.5620], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 812 - loss : 29025.59077231695\n",
            "\n",
            "tensor([30.1888, 40.1969, 50.1347, 60.4439, 70.4152], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 813 - loss : 29016.200601805416\n",
            "\n",
            "tensor([29.9375, 39.8646, 49.7339, 59.9604, 69.8168], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 814 - loss : 29006.802407221665\n",
            "\n",
            "tensor([30.0604, 40.0232, 49.9163, 60.1734, 70.0743], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 815 - loss : 28997.396188565697\n",
            "\n",
            "tensor([30.0811, 40.0780, 49.9731, 60.2292, 70.1336], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 816 - loss : 28987.98595787362\n",
            "\n",
            "tensor([29.8846, 39.8850, 49.7402, 59.9372, 69.7611], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 817 - loss : 28978.56369107322\n",
            "\n",
            "tensor([30.1589, 40.2683, 50.1967, 60.4832, 70.4308], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 818 - loss : 28969.141424272817\n",
            "\n",
            "tensor([29.7347, 39.7660, 49.5993, 59.7631, 69.5371], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 819 - loss : 28959.709127382146\n",
            "\n",
            "tensor([30.2186, 40.3615, 50.3147, 60.6378, 70.6250], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 820 - loss : 28950.270812437313\n",
            "\n",
            "tensor([29.7040, 39.6921, 49.5214, 59.6969, 69.4699], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 821 - loss : 28940.822467402206\n",
            "\n",
            "tensor([30.2396, 40.3039, 50.2488, 60.5852, 70.5765], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 822 - loss : 28931.372116349048\n",
            "\n",
            "tensor([29.8222, 39.7523, 49.5949, 59.8099, 69.6234], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 823 - loss : 28921.91374122367\n",
            "\n",
            "tensor([30.1582, 40.1409, 50.0499, 60.3558, 70.2970], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 824 - loss : 28912.447342026077\n",
            "\n",
            "tensor([29.9940, 39.9435, 49.8082, 60.0574, 69.9211], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 825 - loss : 28902.974924774324\n",
            "\n",
            "tensor([29.9893, 39.9726, 49.8378, 60.0816, 69.9394], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 826 - loss : 28893.500501504514\n",
            "\n",
            "tensor([30.1167, 40.1731, 50.0701, 60.3477, 70.2568], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 827 - loss : 28884.01404212638\n",
            "\n",
            "tensor([29.8057, 39.8368, 49.6712, 59.8625, 69.6478], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 828 - loss : 28874.52156469408\n",
            "\n",
            "tensor([30.1888, 40.3332, 50.2651, 60.5808, 70.5365], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 829 - loss : 28865.025075225676\n",
            "\n",
            "tensor([29.6968, 39.7201, 49.5413, 59.7232, 69.4811], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 830 - loss : 28855.516549648946\n",
            "\n",
            "tensor([30.2367, 40.3505, 50.2943, 60.6433, 70.6282], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 831 - loss : 28846.008024072216\n",
            "\n",
            "tensor([29.7475, 39.7043, 49.5320, 59.7472, 69.5312], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 832 - loss : 28836.489468405216\n",
            "\n",
            "tensor([30.2088, 40.2206, 50.1385, 60.4796, 70.4396], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 833 - loss : 28826.964894684053\n",
            "\n",
            "tensor([29.9144, 39.8413, 49.6864, 59.9400, 69.7716], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 834 - loss : 28817.434302908725\n",
            "\n",
            "tensor([30.0855, 40.0559, 49.9317, 60.2238, 70.1133], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 835 - loss : 28807.895687061184\n",
            "\n",
            "tensor([30.0594, 40.0557, 49.9223, 60.1977, 70.0679], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 836 - loss : 28798.35105315948\n",
            "\n",
            "tensor([29.9042, 39.9218, 49.7622, 59.9955, 69.8055], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 837 - loss : 28788.80040120361\n",
            "\n",
            "tensor([30.1427, 40.2582, 50.1594, 60.4654, 70.3795], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 838 - loss : 28779.245737211633\n",
            "\n",
            "tensor([29.7346, 39.7839, 49.6014, 59.8026, 69.5598], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 839 - loss : 28769.679037111335\n",
            "\n",
            "tensor([30.2158, 40.3655, 50.2963, 60.6482, 70.6127], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 840 - loss : 28760.108324974924\n",
            "\n",
            "tensor([29.6856, 39.6782, 49.4866, 59.6991, 69.4519], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 841 - loss : 28750.529588766298\n",
            "\n",
            "tensor([30.2659, 40.3317, 50.2581, 60.6334, 70.6132], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 842 - loss : 28740.950852557675\n",
            "\n",
            "tensor([29.7937, 39.7162, 49.5318, 59.7795, 69.5663], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 843 - loss : 28731.35807422267\n",
            "\n",
            "tensor([30.2014, 40.1855, 50.0758, 60.4230, 70.3552], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 844 - loss : 28721.765295887664\n",
            "\n",
            "tensor([29.9606, 39.9057, 49.7387, 60.0125, 69.8394], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 845 - loss : 28712.166499498497\n",
            "\n",
            "tensor([30.0238, 40.0248, 49.8730, 60.1580, 70.0045], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 846 - loss : 28702.555667001005\n",
            "\n",
            "tensor([30.0835, 40.1476, 50.0112, 60.3078, 70.1750], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 847 - loss : 28692.93480441324\n",
            "\n",
            "tensor([29.8177, 39.8776, 49.6952, 59.9280, 69.6987], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 848 - loss : 28683.31995987964\n",
            "\n",
            "tensor([30.1694, 40.3263, 50.2286, 60.5693, 70.4912], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 849 - loss : 28673.69107321966\n",
            "\n",
            "tensor([29.6895, 39.7290, 49.5287, 59.7525, 69.4931], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 850 - loss : 28664.058174523572\n",
            "\n",
            "tensor([30.2481, 40.3657, 50.2852, 60.6721, 70.6388], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 851 - loss : 28654.41925777332\n",
            "\n",
            "tensor([29.7285, 39.6801, 49.4794, 59.7352, 69.4986], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 852 - loss : 28644.7703109328\n",
            "\n",
            "tensor([30.2454, 40.2533, 50.1478, 60.5336, 70.4834], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 853 - loss : 28635.115346038114\n",
            "\n",
            "tensor([29.8874, 39.8068, 49.6188, 59.9075, 69.7112], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 854 - loss : 28625.45436308927\n",
            "\n",
            "tensor([30.1248, 40.1044, 49.9577, 60.2952, 70.1750], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 855 - loss : 28615.79338014042\n",
            "\n",
            "tensor([30.0227, 40.0244, 49.8544, 60.1558, 69.9873], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 856 - loss : 28606.118355065195\n",
            "\n",
            "tensor([29.9282, 39.9754, 49.7953, 60.0740, 69.8729], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 857 - loss : 28596.44332998997\n",
            "\n",
            "tensor([30.1065, 40.2371, 50.1015, 60.4308, 70.3041], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 858 - loss : 28586.76028084253\n",
            "\n",
            "tensor([29.7435, 39.8227, 49.6188, 59.8671, 69.6134], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 859 - loss : 28577.067201604816\n",
            "\n",
            "tensor([30.2029, 40.3608, 50.2580, 60.6420, 70.5776], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 860 - loss : 28567.370110330994\n",
            "\n",
            "tensor([29.6783, 39.6775, 49.4566, 59.7154, 69.4543], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 861 - loss : 28557.66700100301\n",
            "\n",
            "tensor([30.2968, 40.3621, 50.2611, 60.6826, 70.6520], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 862 - loss : 28547.957873620864\n",
            "\n",
            "tensor([29.7596, 39.6726, 49.4501, 59.7377, 69.5014], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 863 - loss : 28538.242728184552\n",
            "\n",
            "tensor([30.2601, 40.2498, 50.1163, 60.5169, 70.4488], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 864 - loss : 28528.519558676027\n",
            "\n",
            "tensor([29.9046, 39.8477, 49.6385, 59.9436, 69.7354], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 865 - loss : 28518.792377131394\n",
            "\n",
            "tensor([30.0740, 40.1001, 49.9268, 60.2652, 70.1112], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 866 - loss : 28509.057171514545\n",
            "\n",
            "tensor([30.0292, 40.1036, 49.9240, 60.2453, 70.0696], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 867 - loss : 28499.317953861584\n",
            "\n",
            "tensor([29.8453, 39.9393, 49.7346, 60.0186, 69.7846], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 868 - loss : 28489.568706118356\n",
            "\n",
            "tensor([30.1391, 40.3073, 50.1694, 60.5380, 70.4233], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 869 - loss : 28479.81745235707\n",
            "\n",
            "tensor([29.6966, 39.7570, 49.5294, 59.8037, 69.5376], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 870 - loss : 28470.060180541626\n",
            "\n",
            "tensor([30.2529, 40.3746, 50.2605, 60.6890, 70.6382], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 871 - loss : 28460.296890672016\n",
            "\n",
            "tensor([29.7102, 39.6618, 49.4255, 59.7295, 69.4832], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 872 - loss : 28450.523570712136\n",
            "\n",
            "tensor([30.2815, 40.2912, 50.1568, 60.5958, 70.5442], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 873 - loss : 28440.746238716147\n",
            "\n",
            "tensor([29.8504, 39.7655, 49.5368, 59.8683, 69.6550], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 874 - loss : 28430.964894684053\n",
            "\n",
            "tensor([30.1705, 40.1607, 49.9856, 60.3776, 70.2589], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 875 - loss : 28421.173520561686\n",
            "\n",
            "tensor([29.9780, 39.9846, 49.7706, 60.1064, 69.9094], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 876 - loss : 28411.376128385156\n",
            "\n",
            "tensor([29.9666, 40.0413, 49.8344, 60.1668, 69.9676], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 877 - loss : 28401.578736208627\n",
            "\n",
            "tensor([30.0619, 40.2042, 50.0225, 60.3808, 70.2202], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 878 - loss : 28391.769307923772\n",
            "\n",
            "tensor([29.7666, 39.8782, 49.6470, 59.9505, 69.7017], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 879 - loss : 28381.957873620864\n",
            "\n",
            "tensor([30.1750, 40.3419, 50.1952, 60.6134, 70.5246], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 880 - loss : 28372.13640922768\n",
            "\n",
            "tensor([29.6810, 39.6972, 49.4414, 59.7533, 69.4969], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 881 - loss : 28362.31293881645\n",
            "\n",
            "tensor([30.3131, 40.3837, 50.2446, 60.7128, 70.6779], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 882 - loss : 28352.47743229689\n",
            "\n",
            "tensor([29.7270, 39.6396, 49.3702, 59.7016, 69.4595], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 883 - loss : 28342.64192577733\n",
            "\n",
            "tensor([30.3253, 40.3269, 50.1618, 60.6197, 70.5648], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 884 - loss : 28332.80040120361\n",
            "\n",
            "tensor([29.8342, 39.7769, 49.5144, 59.8535, 69.6251], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 885 - loss : 28322.948846539617\n",
            "\n",
            "tensor([30.1464, 40.1994, 49.9989, 60.3987, 70.2648], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 886 - loss : 28313.097291875627\n",
            "\n",
            "tensor([29.9541, 40.0357, 49.8025, 60.1526, 69.9484], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 887 - loss : 28303.23370110331\n",
            "\n",
            "tensor([29.8924, 40.0197, 49.7871, 60.1297, 69.9132], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 888 - loss : 28293.366098294886\n",
            "\n",
            "tensor([30.0940, 40.2706, 50.0818, 60.4792, 70.3387], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 889 - loss : 28283.492477432297\n",
            "\n",
            "tensor([29.7191, 39.8065, 49.5459, 59.8739, 69.6219], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 890 - loss : 28273.61885656971\n",
            "\n",
            "tensor([30.2459, 40.3759, 50.2172, 60.6833, 70.6232], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 891 - loss : 28263.73119358074\n",
            "\n",
            "tensor([29.6972, 39.6611, 49.3822, 59.7335, 69.4969], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 892 - loss : 28253.84152457372\n",
            "\n",
            "tensor([30.3098, 40.3317, 50.1606, 60.6502, 70.6106], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 893 - loss : 28243.943831494482\n",
            "\n",
            "tensor([29.8102, 39.7298, 49.4530, 59.8273, 69.6188], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 894 - loss : 28234.042126379136\n",
            "\n",
            "tensor([30.2138, 40.2168, 50.0062, 60.4525, 70.3533], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 895 - loss : 28224.13039117352\n",
            "\n",
            "tensor([29.9340, 39.9449, 49.6815, 60.0556, 69.8558], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 896 - loss : 28214.218655967903\n",
            "\n",
            "tensor([30.0128, 40.1068, 49.8659, 60.2529, 70.0760], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 897 - loss : 28204.30290872618\n",
            "\n",
            "tensor([30.0175, 40.1650, 49.9309, 60.3204, 70.1482], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 898 - loss : 28194.37512537613\n",
            "\n",
            "tensor([29.8009, 39.9419, 49.6775, 60.0351, 69.8128], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 899 - loss : 28184.44332998997\n",
            "\n",
            "tensor([30.1376, 40.3159, 50.1175, 60.5655, 70.4684], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 900 - loss : 28174.50551654965\n",
            "\n",
            "tensor([29.6922, 39.7380, 49.4436, 59.8046, 69.5760], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 901 - loss : 28164.559679037113\n",
            "\n",
            "tensor([30.3065, 40.3925, 50.2061, 60.7101, 70.6814], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 902 - loss : 28154.61183550652\n",
            "\n",
            "tensor([29.7054, 39.6345, 49.3151, 59.6854, 69.4636], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 903 - loss : 28144.661985957875\n",
            "\n",
            "tensor([30.3762, 40.3956, 50.1911, 60.6961, 70.6675], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 904 - loss : 28134.696088264795\n",
            "\n",
            "tensor([29.7682, 39.7147, 49.3940, 59.7629, 69.5421], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 905 - loss : 28124.734202607822\n",
            "\n",
            "tensor([30.2315, 40.3062, 50.0743, 60.5313, 70.4396], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 906 - loss : 28114.76028084253\n",
            "\n",
            "tensor([29.8681, 39.9497, 49.6578, 60.0337, 69.8284], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 907 - loss : 28104.782347041124\n",
            "\n",
            "tensor([29.9606, 40.1141, 49.8526, 60.2522, 70.0806], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 908 - loss : 28094.80040120361\n",
            "\n",
            "tensor([30.0331, 40.2129, 49.9685, 60.3882, 70.2429], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 909 - loss : 28084.81043129388\n",
            "\n",
            "tensor([29.7560, 39.8738, 49.5803, 59.9550, 69.7412], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 910 - loss : 28074.816449348044\n",
            "\n",
            "tensor([30.2247, 40.3687, 50.1611, 60.6512, 70.5952], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 911 - loss : 28064.812437311935\n",
            "\n",
            "tensor([29.6900, 39.6810, 49.3600, 59.7463, 69.5412], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 912 - loss : 28054.812437311935\n",
            "\n",
            "tensor([30.3270, 40.3721, 50.1625, 60.6883, 70.6761], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 913 - loss : 28044.798395185557\n",
            "\n",
            "tensor([29.7675, 39.7001, 49.3747, 59.7795, 69.6004], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 914 - loss : 28034.78034102307\n",
            "\n",
            "tensor([30.2535, 40.2695, 50.0231, 60.5131, 70.4556], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 915 - loss : 28024.76028084253\n",
            "\n",
            "tensor([29.8960, 39.9059, 49.5943, 59.9991, 69.8274], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 916 - loss : 28014.730190571714\n",
            "\n",
            "tensor([30.0635, 40.1614, 49.8850, 60.3157, 70.1835], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 917 - loss : 28004.696088264795\n",
            "\n",
            "tensor([29.9841, 40.1261, 49.8418, 60.2551, 70.1014], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 918 - loss : 27994.651955867605\n",
            "\n",
            "tensor([29.8415, 40.0024, 49.7055, 60.1031, 69.9284], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 919 - loss : 27984.61183550652\n",
            "\n",
            "tensor([30.0983, 40.2902, 50.0426, 60.5071, 70.4243], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 920 - loss : 27974.561685055167\n",
            "\n",
            "tensor([29.7015, 39.7881, 49.4591, 59.8519, 69.6719], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 921 - loss : 27964.507522567703\n",
            "\n",
            "tensor([30.2790, 40.3939, 50.1616, 60.6813, 70.6745], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 922 - loss : 27954.43931795386\n",
            "\n",
            "tensor([29.6916, 39.6543, 49.2914, 59.6832, 69.5071], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 923 - loss : 27944.373119358075\n",
            "\n",
            "tensor([30.3999, 40.4406, 50.1952, 60.7232, 70.7326], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 924 - loss : 27934.30290872618\n",
            "\n",
            "tensor([29.7292, 39.6828, 49.3103, 59.6940, 69.5131], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 925 - loss : 27924.22266800401\n",
            "\n",
            "tensor([30.3086, 40.3913, 50.1271, 60.6190, 70.5847], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 926 - loss : 27914.14042126379\n",
            "\n",
            "tensor([29.7970, 39.8690, 49.5242, 59.9116, 69.7385], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 927 - loss : 27904.050150451356\n",
            "\n",
            "tensor([30.0415, 40.2084, 49.9235, 60.3631, 70.2599], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 928 - loss : 27893.951855566702\n",
            "\n",
            "tensor([29.9590, 40.1372, 49.8436, 60.2684, 70.1454], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 929 - loss : 27883.855566700102\n",
            "\n",
            "tensor([29.8032, 39.9531, 49.6371, 60.0403, 69.8888], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 930 - loss : 27873.747241725174\n",
            "\n",
            "tensor([30.1808, 40.3436, 50.0931, 60.5830, 70.5471], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 931 - loss : 27863.63891675025\n",
            "\n",
            "tensor([29.6932, 39.7236, 49.3725, 59.7704, 69.6178], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 932 - loss : 27853.520561685054\n",
            "\n",
            "tensor([30.3322, 40.4065, 50.1646, 60.6988, 70.7270], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 933 - loss : 27843.400200601805\n",
            "\n",
            "tensor([29.7225, 39.6730, 49.3066, 59.7138, 69.5835], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 934 - loss : 27833.273821464394\n",
            "\n",
            "tensor([30.3056, 40.3357, 50.0647, 60.5763, 70.5835], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 935 - loss : 27823.141424272817\n",
            "\n",
            "tensor([29.8441, 39.8441, 49.4901, 59.8983, 69.7765], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 936 - loss : 27813.001003009027\n",
            "\n",
            "tensor([30.1353, 40.2263, 49.9265, 60.3803, 70.3195], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 937 - loss : 27802.85255767302\n",
            "\n",
            "tensor([29.9421, 40.0649, 49.7397, 60.1516, 70.0397], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 938 - loss : 27792.706118355065\n",
            "\n",
            "tensor([29.9047, 40.0738, 49.7586, 60.1726, 70.0671], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 939 - loss : 27782.55366098295\n",
            "\n",
            "tensor([30.0479, 40.2464, 49.9619, 60.4145, 70.3630], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 940 - loss : 27772.389167502508\n",
            "\n",
            "tensor([29.7235, 39.8539, 49.5093, 59.9071, 69.7937], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 941 - loss : 27762.228686058173\n",
            "\n",
            "tensor([30.2273, 40.3773, 50.1133, 60.6173, 70.6448], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 942 - loss : 27752.054162487464\n",
            "\n",
            "tensor([29.6825, 39.6917, 49.3055, 59.6905, 69.5795], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 943 - loss : 27741.877632898697\n",
            "\n",
            "tensor([30.3979, 40.4646, 50.1916, 60.7105, 70.7706], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 944 - loss : 27731.699097291876\n",
            "\n",
            "tensor([29.7024, 39.6651, 49.2579, 59.6266, 69.5084], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 945 - loss : 27721.514543630892\n",
            "\n",
            "tensor([30.3849, 40.4651, 50.1809, 60.6766, 70.7151], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 946 - loss : 27711.321965897692\n",
            "\n",
            "tensor([29.7311, 39.7797, 49.3951, 59.7615, 69.6433], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 947 - loss : 27701.125376128384\n",
            "\n",
            "tensor([30.1532, 40.3175, 50.0267, 60.4788, 70.4643], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 948 - loss : 27690.924774322968\n",
            "\n",
            "tensor([29.8651, 40.0275, 49.6984, 60.0949, 70.0128], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 949 - loss : 27680.716148445335\n",
            "\n",
            "tensor([29.8768, 40.0535, 49.7381, 60.1431, 70.0738], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 950 - loss : 27670.503510531595\n",
            "\n",
            "tensor([30.1053, 40.2855, 50.0090, 60.4628, 70.4577], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 951 - loss : 27660.286860581746\n",
            "\n",
            "tensor([29.7145, 39.7942, 49.4397, 59.8194, 69.7349], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 952 - loss : 27650.060180541626\n",
            "\n",
            "tensor([30.3065, 40.4142, 50.1569, 60.6601, 70.7328], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 953 - loss : 27639.833500501503\n",
            "\n",
            "tensor([29.6866, 39.6650, 49.2813, 59.6563, 69.5893], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 954 - loss : 27629.598796389168\n",
            "\n",
            "tensor([30.3516, 40.3977, 50.1216, 60.6197, 70.7033], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 955 - loss : 27619.360080240724\n",
            "\n",
            "tensor([29.7852, 39.7702, 49.3907, 59.7645, 69.7088], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 956 - loss : 27609.115346038114\n",
            "\n",
            "tensor([30.2233, 40.2963, 49.9930, 60.4387, 70.4674], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 957 - loss : 27598.870611835508\n",
            "\n",
            "tensor([29.8956, 39.9824, 49.6337, 60.0086, 69.9566], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 958 - loss : 27588.615847542627\n",
            "\n",
            "tensor([29.9949, 40.1522, 49.8401, 60.2392, 70.2182], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 959 - loss : 27578.357071213642\n",
            "\n",
            "tensor([29.9909, 40.1784, 49.8774, 60.2826, 70.2750], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 960 - loss : 27568.090270812438\n",
            "\n",
            "tensor([29.7668, 39.9321, 49.6000, 59.9711, 69.9353], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 961 - loss : 27557.823470411233\n",
            "\n",
            "tensor([30.1532, 40.3352, 50.0641, 60.5152, 70.5836], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 962 - loss : 27547.544633901703\n",
            "\n",
            "tensor([29.6799, 39.7448, 49.3674, 59.7125, 69.6759], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 963 - loss : 27537.265797392178\n",
            "\n",
            "tensor([30.3608, 40.4612, 50.1844, 60.6545, 70.7692], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 964 - loss : 27526.984954864594\n",
            "\n",
            "tensor([29.6876, 39.6708, 49.2574, 59.5756, 69.5316], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 965 - loss : 27516.692076228686\n",
            "\n",
            "tensor([30.4354, 40.5121, 50.2263, 60.6844, 70.7991], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 966 - loss : 27506.397191574724\n",
            "\n",
            "tensor([29.6828, 39.7051, 49.3027, 59.6096, 69.5599], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 967 - loss : 27496.098294884654\n",
            "\n",
            "tensor([30.2819, 40.4283, 50.1509, 60.5795, 70.6618], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 968 - loss : 27485.79338014042\n",
            "\n",
            "tensor([29.7603, 39.8895, 49.5435, 59.8717, 69.8424], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 969 - loss : 27475.482447342027\n",
            "\n",
            "tensor([29.9907, 40.1782, 49.8916, 60.2706, 70.2976], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 970 - loss : 27465.16549648947\n",
            "\n",
            "tensor([29.9967, 40.1781, 49.8964, 60.2756, 70.3072], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 971 - loss : 27454.8445336008\n",
            "\n",
            "tensor([29.7676, 39.8923, 49.5684, 59.9022, 69.8953], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 972 - loss : 27444.52156469408\n",
            "\n",
            "tensor([30.2441, 40.3810, 50.1315, 60.5630, 70.6762], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 973 - loss : 27434.18856569709\n",
            "\n",
            "tensor([29.6732, 39.6903, 49.3247, 59.6353, 69.6361], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 974 - loss : 27423.855566700102\n",
            "\n",
            "tensor([30.3678, 40.4349, 50.1785, 60.6233, 70.7793], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 975 - loss : 27413.52256770311\n",
            "\n",
            "tensor([29.7226, 39.7005, 49.3225, 59.6240, 69.6383], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 976 - loss : 27403.171514543632\n",
            "\n",
            "tensor([30.3117, 40.3681, 50.0869, 60.4913, 70.6157], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 977 - loss : 27392.828485456368\n",
            "\n",
            "tensor([29.8384, 39.8812, 49.5295, 59.8296, 69.8449], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 978 - loss : 27382.469408224675\n",
            "\n",
            "tensor([30.1109, 40.2370, 49.9503, 60.3043, 70.3758], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 979 - loss : 27372.108324974924\n",
            "\n",
            "tensor([29.9320, 40.0832, 49.7856, 60.1085, 70.1510], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 980 - loss : 27361.743229689066\n",
            "\n",
            "tensor([29.8486, 40.0227, 49.7307, 60.0482, 70.0944], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 981 - loss : 27351.374122367102\n",
            "\n",
            "tensor([30.0674, 40.2595, 50.0060, 60.3707, 70.4795], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 982 - loss : 27340.998996990973\n",
            "\n",
            "tensor([29.6975, 39.8114, 49.4791, 59.7591, 69.7974], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 983 - loss : 27330.62186559679\n",
            "\n",
            "tensor([30.2881, 40.4221, 50.1709, 60.5585, 70.7231], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 984 - loss : 27320.23671013039\n",
            "\n",
            "tensor([29.6817, 39.6985, 49.3158, 59.5565, 69.5862], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 985 - loss : 27309.849548645936\n",
            "\n",
            "tensor([30.4381, 40.5191, 50.2553, 60.6385, 70.8211], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 986 - loss : 27299.45436308927\n",
            "\n",
            "tensor([29.6595, 39.6664, 49.2754, 59.4925, 69.5131], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 987 - loss : 27289.057171514545\n",
            "\n",
            "tensor([30.3935, 40.5153, 50.2673, 60.6364, 70.8087], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 988 - loss : 27278.65396188566\n",
            "\n",
            "tensor([29.6636, 39.7511, 49.4070, 59.6329, 69.6591], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 989 - loss : 27268.242728184552\n",
            "\n",
            "tensor([30.1454, 40.3252, 50.0890, 60.4200, 70.5490], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 990 - loss : 27257.83149448345\n",
            "\n",
            "tensor([29.8554, 40.0149, 49.7425, 60.0130, 70.0816], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 991 - loss : 27247.41223671013\n",
            "\n",
            "tensor([29.8687, 40.0214, 49.7572, 60.0298, 70.1073], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 992 - loss : 27236.988966900703\n",
            "\n",
            "tensor([30.1443, 40.2944, 50.0713, 60.3980, 70.5425], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 993 - loss : 27226.56369107322\n",
            "\n",
            "tensor([29.7021, 39.7592, 49.4473, 59.6762, 69.7424], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 994 - loss : 27216.13039117352\n",
            "\n",
            "tensor([30.3374, 40.4241, 50.2080, 60.5650, 70.7755], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 995 - loss : 27205.69709127382\n",
            "\n",
            "tensor([29.6752, 39.6603, 49.3168, 59.5223, 69.5997], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 996 - loss : 27195.25777331996\n",
            "\n",
            "tensor([30.3756, 40.4255, 50.1914, 60.5283, 70.7400], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 997 - loss : 27184.80441323972\n",
            "\n",
            "tensor([29.7677, 39.7725, 49.4399, 59.6376, 69.7160], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 998 - loss : 27174.35506519559\n",
            "\n",
            "tensor([30.2340, 40.3218, 50.0795, 60.3678, 70.5318], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 999 - loss : 27163.9037111334\n",
            "\n",
            "Elapsed time : 9.69416856765747s\n",
            "\n",
            "Namespace(batch_first=False, epoch=1000, hid_dim=25, input_dim=1, l2=0, lr=0.001, output_dim=1, seq_len=3)\n",
            "tensor([-0.1890, -0.2349, -0.2492, -0.2518, -0.2516], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 0 - loss : 33486.59378134403\n",
            "\n",
            "tensor([-0.1709, -0.2156, -0.2310, -0.2342, -0.2342], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 1 - loss : 33486.43530591775\n",
            "\n",
            "tensor([-0.1531, -0.1967, -0.2133, -0.2171, -0.2173], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 2 - loss : 33486.292878635904\n",
            "\n",
            "tensor([-0.1357, -0.1782, -0.1959, -0.2003, -0.2008], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 3 - loss : 33486.16850551655\n",
            "\n",
            "tensor([-0.1187, -0.1600, -0.1788, -0.1839, -0.1846], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 4 - loss : 33486.03811434303\n",
            "\n",
            "tensor([-0.1020, -0.1421, -0.1620, -0.1677, -0.1688], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 5 - loss : 33485.90772316951\n",
            "\n",
            "tensor([-0.0856, -0.1245, -0.1454, -0.1519, -0.1533], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 6 - loss : 33485.76930792377\n",
            "\n",
            "tensor([-0.0697, -0.1072, -0.1292, -0.1364, -0.1381], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 7 - loss : 33485.458375125374\n",
            "\n",
            "tensor([-0.0540, -0.0902, -0.1131, -0.1211, -0.1232], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 8 - loss : 33484.930792377134\n",
            "\n",
            "tensor([-0.0385, -0.0734, -0.0972, -0.1059, -0.1084], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 9 - loss : 33484.76429287864\n",
            "\n",
            "tensor([-0.0232, -0.0567, -0.0813, -0.0908, -0.0937], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 10 - loss : 33484.63189568706\n",
            "\n",
            "tensor([-0.0081, -0.0402, -0.0655, -0.0758, -0.0791], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 11 - loss : 33484.49949849548\n",
            "\n",
            "tensor([ 0.0068, -0.0239, -0.0498, -0.0609, -0.0646], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 12 - loss : 33484.36509528586\n",
            "\n",
            "tensor([ 0.0216, -0.0078, -0.0341, -0.0460, -0.0502], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 13 - loss : 33484.234704112336\n",
            "\n",
            "tensor([ 0.0362,  0.0082, -0.0186, -0.0311, -0.0359], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 14 - loss : 33484.10030090271\n",
            "\n",
            "tensor([ 0.0506,  0.0239, -0.0031, -0.0163, -0.0216], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 15 - loss : 33483.9739217653\n",
            "\n",
            "tensor([ 0.0649,  0.0395,  0.0123, -0.0015, -0.0073], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 16 - loss : 33483.84152457372\n",
            "\n",
            "tensor([0.0792, 0.0548, 0.0276, 0.0133, 0.0070], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 17 - loss : 33483.707121364096\n",
            "\n",
            "tensor([0.0933, 0.0700, 0.0428, 0.0282, 0.0213], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 18 - loss : 33483.58074222668\n",
            "\n",
            "tensor([0.1073, 0.0849, 0.0579, 0.0430, 0.0357], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 19 - loss : 33483.45035105316\n",
            "\n",
            "tensor([0.1213, 0.0997, 0.0727, 0.0577, 0.0501], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 20 - loss : 33483.321965897696\n",
            "\n",
            "tensor([0.1352, 0.1143, 0.0874, 0.0724, 0.0646], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 21 - loss : 33483.19358074223\n",
            "\n",
            "tensor([0.1491, 0.1287, 0.1018, 0.0870, 0.0790], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 22 - loss : 33483.063189568704\n",
            "\n",
            "tensor([0.1630, 0.1430, 0.1159, 0.1013, 0.0935], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 23 - loss : 33482.930792377134\n",
            "\n",
            "tensor([0.1769, 0.1571, 0.1297, 0.1153, 0.1077], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 24 - loss : 33482.802407221665\n",
            "\n",
            "tensor([0.1908, 0.1711, 0.1433, 0.1290, 0.1216], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 25 - loss : 33482.67602808425\n",
            "\n",
            "tensor([0.2048, 0.1851, 0.1565, 0.1422, 0.1351], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 26 - loss : 33482.545636910734\n",
            "\n",
            "tensor([0.2189, 0.1989, 0.1694, 0.1549, 0.1481], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 27 - loss : 33482.41524573721\n",
            "\n",
            "tensor([0.2330, 0.2128, 0.1821, 0.1672, 0.1604], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 28 - loss : 33482.28686058174\n",
            "\n",
            "tensor([0.2473, 0.2267, 0.1946, 0.1791, 0.1721], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 29 - loss : 33482.15446339017\n",
            "\n",
            "tensor([0.2617, 0.2406, 0.2070, 0.1906, 0.1833], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 30 - loss : 33482.02808425276\n",
            "\n",
            "tensor([0.2764, 0.2547, 0.2195, 0.2022, 0.1945], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 31 - loss : 33481.89568706118\n",
            "\n",
            "tensor([0.2914, 0.2692, 0.2323, 0.2141, 0.2060], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 32 - loss : 33481.765295887664\n",
            "\n",
            "tensor([0.3067, 0.2840, 0.2454, 0.2263, 0.2179], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 33 - loss : 33481.636910732195\n",
            "\n",
            "tensor([0.3224, 0.2992, 0.2589, 0.2390, 0.2305], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 34 - loss : 33481.50250752257\n",
            "\n",
            "tensor([0.3386, 0.3150, 0.2729, 0.2522, 0.2436], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 35 - loss : 33481.370110330994\n",
            "\n",
            "tensor([0.3553, 0.3313, 0.2874, 0.2660, 0.2573], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 36 - loss : 33481.23771313942\n",
            "\n",
            "tensor([0.3724, 0.3481, 0.3024, 0.2803, 0.2717], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 37 - loss : 33481.10531594785\n",
            "\n",
            "tensor([0.3902, 0.3657, 0.3181, 0.2952, 0.2865], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 38 - loss : 33480.96690070211\n",
            "\n",
            "tensor([0.4086, 0.3839, 0.3343, 0.3106, 0.3018], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 39 - loss : 33480.82046138415\n",
            "\n",
            "tensor([0.4276, 0.4029, 0.3511, 0.3264, 0.3174], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 40 - loss : 33480.471414242726\n",
            "\n",
            "tensor([0.4474, 0.4227, 0.3687, 0.3429, 0.3335], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 41 - loss : 33480.31293881645\n",
            "\n",
            "tensor([0.4679, 0.4433, 0.3869, 0.3599, 0.3499], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 42 - loss : 33480.17652958877\n",
            "\n",
            "tensor([0.4893, 0.4649, 0.4058, 0.3774, 0.3666], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 43 - loss : 33480.042126379136\n",
            "\n",
            "tensor([0.5115, 0.4874, 0.4255, 0.3953, 0.3836], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 44 - loss : 33479.90772316951\n",
            "\n",
            "tensor([0.5346, 0.5109, 0.4459, 0.4139, 0.4010], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 45 - loss : 33479.77131394183\n",
            "\n",
            "tensor([0.5587, 0.5355, 0.4672, 0.4330, 0.4187], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 46 - loss : 33479.63289869609\n",
            "\n",
            "tensor([0.5838, 0.5613, 0.4895, 0.4528, 0.4369], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 47 - loss : 33479.49448345035\n",
            "\n",
            "tensor([0.6099, 0.5883, 0.5127, 0.4733, 0.4556], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 48 - loss : 33479.356068204615\n",
            "\n",
            "tensor([0.6373, 0.6166, 0.5370, 0.4946, 0.4748], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 49 - loss : 33479.21364092277\n",
            "\n",
            "tensor([0.6658, 0.6463, 0.5624, 0.5167, 0.4946], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 50 - loss : 33479.069207622866\n",
            "\n",
            "tensor([0.6956, 0.6775, 0.5890, 0.5397, 0.5152], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 51 - loss : 33478.92477432297\n",
            "\n",
            "tensor([0.7267, 0.7103, 0.6170, 0.5637, 0.5365], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 52 - loss : 33478.782347041124\n",
            "\n",
            "tensor([0.7593, 0.7447, 0.6463, 0.5888, 0.5586], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 53 - loss : 33478.633901705114\n",
            "\n",
            "tensor([0.7933, 0.7809, 0.6772, 0.6150, 0.5817], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 54 - loss : 33478.485456369104\n",
            "\n",
            "tensor([0.8288, 0.8189, 0.7097, 0.6424, 0.6058], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 55 - loss : 33478.33500501505\n",
            "\n",
            "tensor([0.8659, 0.8588, 0.7438, 0.6712, 0.6309], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 56 - loss : 33478.18455366098\n",
            "\n",
            "tensor([0.9047, 0.9008, 0.7798, 0.7015, 0.6572], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 57 - loss : 33478.032096288865\n",
            "\n",
            "tensor([0.9452, 0.9450, 0.8177, 0.7333, 0.6848], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 58 - loss : 33477.87562688064\n",
            "\n",
            "tensor([0.9875, 0.9913, 0.8577, 0.7668, 0.7137], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 59 - loss : 33477.721163490474\n",
            "\n",
            "tensor([1.0317, 1.0400, 0.8998, 0.8020, 0.7440], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 60 - loss : 33477.55466399198\n",
            "\n",
            "tensor([1.0778, 1.0911, 0.9441, 0.8392, 0.7759], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 61 - loss : 33477.39418254764\n",
            "\n",
            "tensor([1.1259, 1.1446, 0.9908, 0.8784, 0.8095], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 62 - loss : 33477.22567703109\n",
            "\n",
            "tensor([1.1760, 1.2007, 1.0400, 0.9198, 0.8448], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 63 - loss : 33477.06118355065\n",
            "\n",
            "tensor([1.2282, 1.2595, 1.0918, 0.9635, 0.8821], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 64 - loss : 33476.89468405215\n",
            "\n",
            "tensor([1.2826, 1.3209, 1.1462, 1.0096, 0.9214], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 65 - loss : 33476.7221664995\n",
            "\n",
            "tensor([1.3390, 1.3850, 1.2035, 1.0584, 0.9629], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 66 - loss : 33476.54363089268\n",
            "\n",
            "tensor([1.3976, 1.4517, 1.2635, 1.1098, 1.0067], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 67 - loss : 33476.34102306921\n",
            "\n",
            "tensor([1.4584, 1.5211, 1.3263, 1.1641, 1.0530], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 68 - loss : 33475.626880641925\n",
            "\n",
            "tensor([1.5215, 1.5935, 1.3924, 1.2216, 1.1023], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 69 - loss : 33474.906720160485\n",
            "\n",
            "tensor([1.5876, 1.6694, 1.4624, 1.2832, 1.1556], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 70 - loss : 33474.678034102304\n",
            "\n",
            "tensor([1.6566, 1.7487, 1.5362, 1.3488, 1.2126], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 71 - loss : 33474.47943831494\n",
            "\n",
            "tensor([1.7284, 1.8313, 1.6137, 1.4185, 1.2738], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 72 - loss : 33474.27683049147\n",
            "\n",
            "tensor([1.8030, 1.9173, 1.6951, 1.4925, 1.3394], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 73 - loss : 33474.07221664995\n",
            "\n",
            "tensor([1.8805, 2.0064, 1.7802, 1.5707, 1.4095], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 74 - loss : 33473.85757271815\n",
            "\n",
            "tensor([1.9607, 2.0987, 1.8691, 1.6533, 1.4844], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 75 - loss : 33473.63490471414\n",
            "\n",
            "tensor([2.0438, 2.1939, 1.9616, 1.7402, 1.5642], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 76 - loss : 33473.34403209629\n",
            "\n",
            "tensor([2.1294, 2.2921, 2.0575, 1.8314, 1.6489], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 77 - loss : 33471.47241725175\n",
            "\n",
            "tensor([2.2185, 2.3939, 2.1576, 1.9276, 1.7397], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 78 - loss : 33470.89869608826\n",
            "\n",
            "tensor([2.3114, 2.4999, 2.2624, 2.0292, 1.8369], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 79 - loss : 33470.61785356068\n",
            "\n",
            "tensor([2.4081, 2.6099, 2.3716, 2.1360, 1.9402], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 80 - loss : 33470.3370110331\n",
            "\n",
            "tensor([2.5085, 2.7238, 2.4851, 2.2476, 2.0496], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 81 - loss : 33470.0481444333\n",
            "\n",
            "tensor([2.6126, 2.8415, 2.6028, 2.3640, 2.1647], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 82 - loss : 33469.75325977934\n",
            "\n",
            "tensor([2.7202, 2.9630, 2.7246, 2.4848, 2.2851], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 83 - loss : 33469.4483450351\n",
            "\n",
            "tensor([2.8313, 3.0881, 2.8504, 2.6100, 2.4104], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 84 - loss : 33469.14142427282\n",
            "\n",
            "tensor([2.9459, 3.2168, 2.9802, 2.7393, 2.5402], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 85 - loss : 33468.82848545637\n",
            "\n",
            "tensor([3.0639, 3.3489, 3.1139, 2.8726, 2.6740], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 86 - loss : 33468.5035105316\n",
            "\n",
            "tensor([3.1852, 3.4844, 3.2514, 3.0100, 2.8116], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 87 - loss : 33468.17652958877\n",
            "\n",
            "tensor([3.3096, 3.6230, 3.3925, 3.1513, 2.9528], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 88 - loss : 33467.84152457372\n",
            "\n",
            "tensor([3.4369, 3.7645, 3.5370, 3.2964, 3.0976], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 89 - loss : 33467.4704112337\n",
            "\n",
            "tensor([3.5669, 3.9087, 3.6845, 3.4450, 3.2458], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 90 - loss : 33466.67001003009\n",
            "\n",
            "tensor([3.6995, 4.0553, 3.8350, 3.5969, 3.3977], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 91 - loss : 33464.09829488465\n",
            "\n",
            "tensor([3.8356, 4.2054, 3.9893, 3.7532, 3.5543], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 92 - loss : 33463.65897693079\n",
            "\n",
            "tensor([3.9752, 4.3589, 4.1477, 3.9138, 3.7157], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 93 - loss : 33463.23771313942\n",
            "\n",
            "tensor([4.1182, 4.5155, 4.3097, 4.0782, 3.8812], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 94 - loss : 33462.81043129388\n",
            "\n",
            "tensor([4.2640, 4.6746, 4.4749, 4.2460, 4.0504], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 95 - loss : 33462.36108324975\n",
            "\n",
            "tensor([4.4125, 4.8360, 4.6429, 4.4167, 4.2225], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 96 - loss : 33461.87562688064\n",
            "\n",
            "tensor([4.5630, 4.9989, 4.8132, 4.5899, 4.3970], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 97 - loss : 33461.18956870612\n",
            "\n",
            "tensor([4.7151, 5.1627, 4.9851, 4.7651, 4.5731], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 98 - loss : 33456.59378134403\n",
            "\n",
            "tensor([4.8696, 5.3281, 5.1595, 4.9432, 4.7520], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 99 - loss : 33454.85857572718\n",
            "\n",
            "tensor([5.0278, 5.4968, 5.3379, 5.1262, 4.9355], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 100 - loss : 33453.59679037111\n",
            "\n",
            "tensor([5.1893, 5.6682, 5.5197, 5.3136, 5.1233], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 101 - loss : 33452.88866599799\n",
            "\n",
            "tensor([5.3534, 5.8415, 5.7038, 5.5046, 5.3151], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 102 - loss : 33451.86760280842\n",
            "\n",
            "tensor([5.5195, 6.0162, 5.8893, 5.6985, 5.5103], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 103 - loss : 33447.488465396185\n",
            "\n",
            "tensor([5.6876, 6.1922, 6.0761, 5.8951, 5.7094], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 104 - loss : 33443.47442326981\n",
            "\n",
            "tensor([5.8585, 6.3704, 6.2646, 6.0948, 5.9131], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 105 - loss : 33438.96489468405\n",
            "\n",
            "tensor([6.0341, 6.5529, 6.4570, 6.2994, 6.1238], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 106 - loss : 33437.947843530594\n",
            "\n",
            "tensor([6.2141, 6.7397, 6.6527, 6.5080, 6.3407], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 107 - loss : 33436.91273821465\n",
            "\n",
            "tensor([6.3980, 6.9301, 6.8511, 6.7193, 6.5624], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 108 - loss : 33435.356068204615\n",
            "\n",
            "tensor([6.5850, 7.1236, 7.0515, 6.9323, 6.7875], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 109 - loss : 33430.758274824475\n",
            "\n",
            "tensor([6.7763, 7.3214, 7.2551, 7.1477, 7.0163], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 110 - loss : 33429.52256770311\n",
            "\n",
            "tensor([6.9723, 7.5241, 7.4626, 7.3658, 7.2483], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 111 - loss : 33427.59478435306\n",
            "\n",
            "tensor([7.1736, 7.7327, 7.6749, 7.5871, 7.4833], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 112 - loss : 33425.711133400204\n",
            "\n",
            "tensor([7.3793, 7.9460, 7.8911, 7.8105, 7.7192], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 113 - loss : 33424.35105315948\n",
            "\n",
            "tensor([7.5887, 8.1635, 8.1108, 8.0357, 7.9553], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 114 - loss : 33422.28485456369\n",
            "\n",
            "tensor([7.8013, 8.3848, 8.3338, 8.2624, 8.1909], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 115 - loss : 33417.488465396185\n",
            "\n",
            "tensor([8.0180, 8.6105, 8.5609, 8.4918, 8.4273], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 116 - loss : 33416.06018054162\n",
            "\n",
            "tensor([8.2389, 8.8412, 8.7930, 8.7249, 8.6652], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 117 - loss : 33414.609829488465\n",
            "\n",
            "tensor([8.4638, 9.0763, 9.0297, 8.9615, 8.9047], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 118 - loss : 33413.119358074226\n",
            "\n",
            "tensor([8.6922, 9.3154, 9.2708, 9.2019, 9.1460], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 119 - loss : 33411.606820461384\n",
            "\n",
            "tensor([8.9237, 9.5578, 9.5159, 9.4461, 9.3894], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 120 - loss : 33410.02006018054\n",
            "\n",
            "tensor([9.1576, 9.8027, 9.7642, 9.6936, 9.6348], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 121 - loss : 33408.2186559679\n",
            "\n",
            "tensor([ 9.3924, 10.0484, 10.0139,  9.9429,  9.8812], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 122 - loss : 33402.714142427285\n",
            "\n",
            "tensor([ 9.6273, 10.2938, 10.2642, 10.1935, 10.1283], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 123 - loss : 33399.00902708124\n",
            "\n",
            "tensor([ 9.8645, 10.5415, 10.5173, 10.4481, 10.3796], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 124 - loss : 33394.13039117352\n",
            "\n",
            "tensor([10.1046, 10.7915, 10.7736, 10.7071, 10.6360], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 125 - loss : 33387.57873620863\n",
            "\n",
            "tensor([10.3484, 11.0449, 11.0337, 10.9711, 10.8988], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 126 - loss : 33384.68605817452\n",
            "\n",
            "tensor([10.5965, 11.3023, 11.2980, 11.2408, 11.1688], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 127 - loss : 33382.66198595787\n",
            "\n",
            "tensor([10.8482, 11.5627, 11.5654, 11.5146, 11.4448], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 128 - loss : 33380.50551654965\n",
            "\n",
            "tensor([11.1024, 11.8251, 11.8348, 11.7912, 11.7255], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 129 - loss : 33377.28385155466\n",
            "\n",
            "tensor([11.3587, 12.0890, 12.1054, 12.0696, 12.0096], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 130 - loss : 33371.30591775326\n",
            "\n",
            "tensor([11.6176, 12.3548, 12.3775, 12.3498, 12.2972], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 131 - loss : 33368.67201604814\n",
            "\n",
            "tensor([11.8796, 12.6234, 12.6520, 12.6322, 12.5879], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 132 - loss : 33366.373119358075\n",
            "\n",
            "tensor([12.1442, 12.8941, 12.9281, 12.9159, 12.8804], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 133 - loss : 33363.98996990973\n",
            "\n",
            "tensor([12.4109, 13.1665, 13.2052, 13.2001, 13.1733], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 134 - loss : 33361.265797392174\n",
            "\n",
            "tensor([12.6791, 13.4401, 13.4831, 13.4843, 13.4658], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 135 - loss : 33353.96389167503\n",
            "\n",
            "tensor([12.9489, 13.7149, 13.7616, 13.7683, 13.7573], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 136 - loss : 33350.69007021063\n",
            "\n",
            "tensor([13.2218, 13.9927, 14.0426, 14.0540, 14.0497], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 137 - loss : 33348.18455366098\n",
            "\n",
            "tensor([13.4974, 14.2730, 14.3257, 14.3411, 14.3423], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 138 - loss : 33345.650952858574\n",
            "\n",
            "tensor([13.7753, 14.5556, 14.6106, 14.6294, 14.6352], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 139 - loss : 33343.09127382146\n",
            "\n",
            "tensor([14.0553, 14.8401, 14.8972, 14.9188, 14.9284], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 140 - loss : 33340.5035105316\n",
            "\n",
            "tensor([14.3373, 15.1264, 15.1853, 15.2092, 15.2218], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 141 - loss : 33337.89568706118\n",
            "\n",
            "tensor([14.6209, 15.4144, 15.4749, 15.5007, 15.5156], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 142 - loss : 33335.27181544634\n",
            "\n",
            "tensor([14.9062, 15.7040, 15.7658, 15.7931, 15.8100], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 143 - loss : 33332.6258776329\n",
            "\n",
            "tensor([15.1930, 15.9950, 16.0579, 16.0866, 16.1050], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 144 - loss : 33329.95586760281\n",
            "\n",
            "tensor([15.4811, 16.2874, 16.3513, 16.3811, 16.4007], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 145 - loss : 33327.27382146439\n",
            "\n",
            "tensor([15.7703, 16.5808, 16.6457, 16.6764, 16.6969], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 146 - loss : 33324.56770310933\n",
            "\n",
            "tensor([16.0604, 16.8753, 16.9410, 16.9724, 16.9937], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 147 - loss : 33321.83751253761\n",
            "\n",
            "tensor([16.3512, 17.1706, 17.2369, 17.2690, 17.2909], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 148 - loss : 33319.059177532596\n",
            "\n",
            "tensor([16.6423, 17.4663, 17.5333, 17.5660, 17.5883], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 149 - loss : 33316.146439317956\n",
            "\n",
            "tensor([16.9334, 17.7621, 17.8298, 17.8629, 17.8857], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 150 - loss : 33312.09227683049\n",
            "\n",
            "tensor([17.2239, 18.0575, 18.1258, 18.1593, 18.1824], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 151 - loss : 33304.96690070211\n",
            "\n",
            "tensor([17.5150, 18.3537, 18.4225, 18.4563, 18.4798], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 152 - loss : 33298.32096288867\n",
            "\n",
            "tensor([17.8074, 18.6514, 18.7207, 18.7550, 18.7787], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 153 - loss : 33294.08024072216\n",
            "\n",
            "tensor([18.1032, 18.9528, 19.0227, 19.0573, 19.0813], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 154 - loss : 33291.05115346038\n",
            "\n",
            "tensor([18.4019, 19.2574, 19.3279, 19.3628, 19.3870], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 155 - loss : 33287.987963891675\n",
            "\n",
            "tensor([18.7032, 19.5648, 19.6358, 19.6711, 19.6955], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 156 - loss : 33284.89669007021\n",
            "\n",
            "tensor([19.0068, 19.8746, 19.9462, 19.9818, 20.0065], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 157 - loss : 33281.77933801404\n",
            "\n",
            "tensor([19.3124, 20.1867, 20.2588, 20.2947, 20.3197], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 158 - loss : 33278.63791374122\n",
            "\n",
            "tensor([19.6200, 20.5008, 20.5735, 20.6097, 20.6349], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 159 - loss : 33275.478435305915\n",
            "\n",
            "tensor([19.9294, 20.8168, 20.8901, 20.9267, 20.9521], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 160 - loss : 33272.29488465396\n",
            "\n",
            "tensor([20.2405, 21.1347, 21.2085, 21.2454, 21.2711], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 161 - loss : 33269.09729187562\n",
            "\n",
            "tensor([20.5532, 21.4542, 21.5287, 21.5659, 21.5918], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 162 - loss : 33265.87763289869\n",
            "\n",
            "tensor([20.8675, 21.7754, 21.8504, 21.8880, 21.9141], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 163 - loss : 33262.64593781344\n",
            "\n",
            "tensor([21.1832, 22.0982, 22.1738, 22.2116, 22.2380], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 164 - loss : 33259.39418254764\n",
            "\n",
            "tensor([21.5004, 22.4224, 22.4987, 22.5368, 22.5634], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 165 - loss : 33256.12838515547\n",
            "\n",
            "tensor([21.8190, 22.7482, 22.8250, 22.8635, 22.8903], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 166 - loss : 33252.85255767302\n",
            "\n",
            "tensor([22.1390, 23.0754, 23.1528, 23.1916, 23.2187], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 167 - loss : 33249.55667001003\n",
            "\n",
            "tensor([22.4603, 23.4040, 23.4820, 23.5211, 23.5484], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 168 - loss : 33246.24674022066\n",
            "\n",
            "tensor([22.7830, 23.7339, 23.8126, 23.8521, 23.8796], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 169 - loss : 33242.92076228686\n",
            "\n",
            "tensor([23.1069, 24.0652, 24.1445, 24.1843, 24.2121], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 170 - loss : 33239.58676028084\n",
            "\n",
            "tensor([23.4321, 24.3979, 24.4778, 24.5179, 24.5459], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 171 - loss : 33236.23269809428\n",
            "\n",
            "tensor([23.7586, 24.7319, 24.8124, 24.8529, 24.8811], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 172 - loss : 33232.86860581745\n",
            "\n",
            "tensor([24.0863, 25.0672, 25.1484, 25.1892, 25.2176], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 173 - loss : 33229.49448345035\n",
            "\n",
            "tensor([24.4153, 25.4039, 25.4856, 25.5268, 25.5554], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 174 - loss : 33226.10030090271\n",
            "\n",
            "tensor([24.7455, 25.7418, 25.8242, 25.8657, 25.8946], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 175 - loss : 33222.70210631896\n",
            "\n",
            "tensor([25.0769, 26.0810, 26.1641, 26.2059, 26.2350], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 176 - loss : 33219.28385155466\n",
            "\n",
            "tensor([25.4095, 26.4216, 26.5052, 26.5474, 26.5767], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 177 - loss : 33215.85757271815\n",
            "\n",
            "tensor([25.7434, 26.7634, 26.8477, 26.8902, 26.9198], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 178 - loss : 33212.41524573721\n",
            "\n",
            "tensor([26.0784, 27.1065, 27.1915, 27.2342, 27.2641], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 179 - loss : 33208.95887662989\n",
            "\n",
            "tensor([26.4147, 27.4509, 27.5365, 27.5796, 27.6097], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 180 - loss : 33205.49448345035\n",
            "\n",
            "tensor([26.7521, 27.7965, 27.8828, 27.9263, 27.9566], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 181 - loss : 33202.01805416249\n",
            "\n",
            "tensor([27.0908, 28.1435, 28.2305, 28.2743, 28.3048], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 182 - loss : 33198.52357071214\n",
            "\n",
            "tensor([27.4306, 28.4918, 28.5794, 28.6235, 28.6543], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 183 - loss : 33195.015045135406\n",
            "\n",
            "tensor([27.7716, 28.8413, 28.9296, 28.9741, 29.0051], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 184 - loss : 33191.498495486456\n",
            "\n",
            "tensor([28.1138, 29.1922, 29.2811, 29.3260, 29.3572], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 185 - loss : 33187.967903711135\n",
            "\n",
            "tensor([28.4571, 29.5443, 29.6340, 29.6791, 29.7106], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 186 - loss : 33184.42326980943\n",
            "\n",
            "tensor([28.8016, 29.8977, 29.9881, 30.0336, 30.0653], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 187 - loss : 33180.86459378134\n",
            "\n",
            "tensor([29.1473, 30.2524, 30.3435, 30.3893, 30.4213], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 188 - loss : 33177.299899699094\n",
            "\n",
            "tensor([29.4941, 30.6085, 30.7002, 30.7464, 30.7786], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 189 - loss : 33173.717151454366\n",
            "\n",
            "tensor([29.8420, 30.9658, 31.0583, 31.1048, 31.1372], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 190 - loss : 33170.126379137415\n",
            "\n",
            "tensor([30.1912, 31.3244, 31.4176, 31.4645, 31.4971], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 191 - loss : 33166.51554663992\n",
            "\n",
            "tensor([30.5414, 31.6844, 31.7783, 31.8255, 31.8584], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 192 - loss : 33162.8926780341\n",
            "\n",
            "tensor([30.8928, 32.0457, 32.1403, 32.1879, 32.2210], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 193 - loss : 33159.25977933801\n",
            "\n",
            "tensor([31.2453, 32.4082, 32.5036, 32.5515, 32.5849], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 194 - loss : 33155.6148445336\n",
            "\n",
            "tensor([31.5989, 32.7721, 32.8682, 32.9165, 32.9501], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 195 - loss : 33151.953861584756\n",
            "\n",
            "tensor([31.9536, 33.1373, 33.2342, 33.2828, 33.3166], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 196 - loss : 33148.28084252758\n",
            "\n",
            "tensor([32.3094, 33.5038, 33.6015, 33.6504, 33.6845], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 197 - loss : 33144.59378134403\n",
            "\n",
            "tensor([32.6662, 33.8717, 33.9701, 34.0194, 34.0537], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 198 - loss : 33140.89468405215\n",
            "\n",
            "tensor([33.0242, 34.2409, 34.3400, 34.3897, 34.4243], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 199 - loss : 33137.1815446339\n",
            "\n",
            "tensor([33.3832, 34.6114, 34.7113, 34.7614, 34.7962], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 200 - loss : 33133.458375125374\n",
            "\n",
            "tensor([33.7433, 34.9832, 35.0839, 35.1344, 35.1694], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 201 - loss : 33129.721163490474\n",
            "\n",
            "tensor([34.1044, 35.3563, 35.4579, 35.5087, 35.5440], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 202 - loss : 33125.967903711135\n",
            "\n",
            "tensor([34.4665, 35.7308, 35.8332, 35.8844, 35.9199], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 203 - loss : 33122.204613841524\n",
            "\n",
            "tensor([34.8297, 36.1067, 36.2099, 36.2614, 36.2972], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 204 - loss : 33118.42928786359\n",
            "\n",
            "tensor([35.1938, 36.4838, 36.5879, 36.6398, 36.6758], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 205 - loss : 33114.633901705114\n",
            "\n",
            "tensor([35.5590, 36.8623, 36.9672, 37.0195, 37.0558], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 206 - loss : 33110.82848545637\n",
            "\n",
            "tensor([35.9251, 37.2422, 37.3479, 37.4006, 37.4371], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 207 - loss : 33107.01303911735\n",
            "\n",
            "tensor([36.2921, 37.6233, 37.7300, 37.7830, 37.8198], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 208 - loss : 33103.18555667001\n",
            "\n",
            "tensor([36.6601, 38.0059, 38.1134, 38.1668, 38.2039], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 209 - loss : 33099.336008024075\n",
            "\n",
            "tensor([37.0290, 38.3897, 38.4982, 38.5520, 38.5893], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 210 - loss : 33095.478435305915\n",
            "\n",
            "tensor([37.3988, 38.7749, 38.8843, 38.9385, 38.9761], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 211 - loss : 33091.61083249749\n",
            "\n",
            "tensor([37.7694, 39.1615, 39.2718, 39.3264, 39.3642], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 212 - loss : 33087.72517552658\n",
            "\n",
            "tensor([38.1409, 39.5494, 39.6607, 39.7157, 39.7537], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 213 - loss : 33083.82748244734\n",
            "\n",
            "tensor([38.5133, 39.9386, 40.0509, 40.1063, 40.1446], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 214 - loss : 33079.91574724173\n",
            "\n",
            "tensor([38.8865, 40.3292, 40.4425, 40.4983, 40.5369], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 215 - loss : 33075.991975927784\n",
            "\n",
            "tensor([39.2604, 40.7211, 40.8354, 40.8917, 40.9305], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 216 - loss : 33072.056168505515\n",
            "\n",
            "tensor([39.6351, 41.1144, 41.2298, 41.2864, 41.3255], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 217 - loss : 33068.102306920766\n",
            "\n",
            "tensor([40.0106, 41.5090, 41.6254, 41.6825, 41.7219], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 218 - loss : 33064.13841524574\n",
            "\n",
            "tensor([40.3868, 41.9050, 42.0225, 42.0800, 42.1196], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 219 - loss : 33060.15847542628\n",
            "\n",
            "tensor([40.7637, 42.3023, 42.4209, 42.4789, 42.5188], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 220 - loss : 33056.170511534605\n",
            "\n",
            "tensor([41.1412, 42.7009, 42.8207, 42.8792, 42.9193], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 221 - loss : 33052.1664994985\n",
            "\n",
            "tensor([41.5194, 43.1009, 43.2219, 43.2808, 43.3212], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 222 - loss : 33048.1444332999\n",
            "\n",
            "tensor([41.8981, 43.5023, 43.6245, 43.6838, 43.7245], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 223 - loss : 33044.116349047144\n",
            "\n",
            "tensor([42.2775, 43.9049, 44.0284, 44.0882, 44.1292], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 224 - loss : 33040.06820461384\n",
            "\n",
            "tensor([42.6573, 44.3090, 44.4337, 44.4939, 44.5352], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 225 - loss : 33036.01003009027\n",
            "\n",
            "tensor([43.0377, 44.7143, 44.8403, 44.9011, 44.9426], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 226 - loss : 33031.93580742227\n",
            "\n",
            "tensor([43.4185, 45.1210, 45.2484, 45.3096, 45.3515], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 227 - loss : 33027.8555667001\n",
            "\n",
            "tensor([43.7998, 45.5290, 45.6578, 45.7195, 45.7617], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 228 - loss : 33023.75325977934\n",
            "\n",
            "tensor([44.1815, 45.9384, 46.0686, 46.1309, 46.1733], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 229 - loss : 33019.6409227683\n",
            "\n",
            "tensor([44.5635, 46.3491, 46.4807, 46.5435, 46.5863], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 230 - loss : 33015.51253761284\n",
            "\n",
            "tensor([44.9458, 46.7611, 46.8943, 46.9576, 47.0007], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 231 - loss : 33011.370110330994\n",
            "\n",
            "tensor([45.3283, 47.1744, 47.3092, 47.3731, 47.4164], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 232 - loss : 33007.217652958876\n",
            "\n",
            "tensor([45.7111, 47.5890, 47.7255, 47.7899, 47.8336], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 233 - loss : 33003.05115346038\n",
            "\n",
            "tensor([46.0940, 48.0050, 48.1431, 48.2082, 48.2521], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 234 - loss : 32998.870611835504\n",
            "\n",
            "tensor([46.4769, 48.4222, 48.5622, 48.6278, 48.6721], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 235 - loss : 32994.678034102304\n",
            "\n",
            "tensor([46.8599, 48.8407, 48.9826, 49.0488, 49.0934], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 236 - loss : 32990.46940822467\n",
            "\n",
            "tensor([47.2429, 49.2606, 49.4043, 49.4712, 49.5162], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 237 - loss : 32986.244734202606\n",
            "\n",
            "tensor([47.6258, 49.6817, 49.8274, 49.8950, 49.9403], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 238 - loss : 32982.01003009027\n",
            "\n",
            "tensor([48.0084, 50.1041, 50.2520, 50.3201, 50.3658], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 239 - loss : 32977.76328986961\n",
            "\n",
            "tensor([48.3908, 50.5277, 50.6778, 50.7467, 50.7927], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 240 - loss : 32973.50250752257\n",
            "\n",
            "tensor([48.7727, 50.9526, 51.1050, 51.1746, 51.2210], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 241 - loss : 32969.22367101304\n",
            "\n",
            "tensor([49.1542, 51.3787, 51.5336, 51.6040, 51.6507], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 242 - loss : 32964.930792377134\n",
            "\n",
            "tensor([49.5351, 51.8061, 51.9635, 52.0347, 52.0818], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 243 - loss : 32960.63189568706\n",
            "\n",
            "tensor([49.9153, 52.2346, 52.3948, 52.4668, 52.5143], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 244 - loss : 32956.31494483451\n",
            "\n",
            "tensor([50.2946, 52.6644, 52.8274, 52.9002, 52.9482], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 245 - loss : 32951.98395185557\n",
            "\n",
            "tensor([50.6729, 53.0952, 53.2614, 53.3351, 53.3835], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 246 - loss : 32947.6409227683\n",
            "\n",
            "tensor([51.0500, 53.5273, 53.6967, 53.7713, 53.8202], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 247 - loss : 32943.28385155466\n",
            "\n",
            "tensor([51.4257, 53.9604, 54.1333, 54.2089, 54.2582], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 248 - loss : 32938.91273821465\n",
            "\n",
            "tensor([51.7998, 54.3945, 54.5713, 54.6479, 54.6977], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 249 - loss : 32934.52758274825\n",
            "\n",
            "tensor([52.1721, 54.8297, 55.0105, 55.0883, 55.1385], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 250 - loss : 32930.13039117352\n",
            "\n",
            "tensor([52.5423, 55.2659, 55.4510, 55.5300, 55.5807], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 251 - loss : 32925.717151454366\n",
            "\n",
            "tensor([52.9101, 55.7030, 55.8928, 55.9731, 56.0244], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 252 - loss : 32921.28986960882\n",
            "\n",
            "tensor([53.2751, 56.1409, 56.3359, 56.4175, 56.4694], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 253 - loss : 32916.85456369107\n",
            "\n",
            "tensor([53.6370, 56.5796, 56.7802, 56.8633, 56.9158], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 254 - loss : 32912.40120361083\n",
            "\n",
            "tensor([53.9954, 57.0189, 57.2257, 57.3104, 57.3635], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 255 - loss : 32907.92978936811\n",
            "\n",
            "tensor([54.3497, 57.4588, 57.6724, 57.7589, 57.8127], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 256 - loss : 32903.45035105316\n",
            "\n",
            "tensor([54.6994, 57.8991, 58.1203, 58.2087, 58.2632], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 257 - loss : 32898.95887662989\n",
            "\n",
            "tensor([55.0438, 58.3397, 58.5692, 58.6598, 58.7151], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 258 - loss : 32894.451354062185\n",
            "\n",
            "tensor([55.3822, 58.7804, 59.0192, 59.1122, 59.1684], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 259 - loss : 32889.93179538616\n",
            "\n",
            "tensor([55.7139, 59.2209, 59.4701, 59.5658, 59.6230], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 260 - loss : 32885.39819458375\n",
            "\n",
            "tensor([56.0379, 59.6610, 59.9219, 60.0207, 60.0789], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 261 - loss : 32880.84854563691\n",
            "\n",
            "tensor([56.3531, 60.1003, 60.3745, 60.4768, 60.5362], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 262 - loss : 32876.28485456369\n",
            "\n",
            "tensor([56.6583, 60.5384, 60.8278, 60.9340, 60.9948], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 263 - loss : 32871.70912738215\n",
            "\n",
            "tensor([56.9523, 60.9748, 61.2815, 61.3923, 61.4547], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 264 - loss : 32867.12136409228\n",
            "\n",
            "tensor([57.2334, 61.4089, 61.7355, 61.8516, 61.9158], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 265 - loss : 32862.51554663992\n",
            "\n",
            "tensor([57.5001, 61.8400, 62.1896, 62.3119, 62.3782], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 266 - loss : 32857.90571715146\n",
            "\n",
            "tensor([57.7502, 62.2671, 62.6433, 62.7730, 62.8417], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 267 - loss : 32853.27382146439\n",
            "\n",
            "tensor([57.9817, 62.6892, 63.0962, 63.2346, 63.3064], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 268 - loss : 32848.62788365095\n",
            "\n",
            "tensor([58.1922, 63.1047, 63.5479, 63.6968, 63.7721], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 269 - loss : 32843.97191574724\n",
            "\n",
            "tensor([58.3790, 63.5120, 63.9977, 64.1590, 64.2386], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 270 - loss : 32839.29789368104\n",
            "\n",
            "tensor([58.5390, 63.9087, 64.4445, 64.6210, 64.7059], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 271 - loss : 32834.619859578735\n",
            "\n",
            "tensor([58.6691, 64.2920, 64.8873, 65.0823, 65.1738], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 272 - loss : 32829.92176529589\n",
            "\n",
            "tensor([58.7656, 64.6582, 65.3244, 65.5422, 65.6419], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 273 - loss : 32825.20962888666\n",
            "\n",
            "tensor([58.8250, 65.0027, 65.7537, 65.9998, 66.1098], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 274 - loss : 32820.485456369104\n",
            "\n",
            "tensor([58.8430, 65.3195, 66.1721, 66.4538, 66.5769], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 275 - loss : 32815.74322968907\n",
            "\n",
            "tensor([58.8156, 65.6005, 66.5756, 66.9022, 67.0423], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 276 - loss : 32810.99297893681\n",
            "\n",
            "tensor([58.7384, 65.8359, 66.9581, 67.3425, 67.5049], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 277 - loss : 32806.22868605817\n",
            "\n",
            "tensor([58.6070, 66.0130, 67.3107, 67.7705, 67.9627], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 278 - loss : 32801.45235707121\n",
            "\n",
            "tensor([58.4169, 66.1167, 67.6201, 68.1794, 68.4125], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 279 - loss : 32796.65596790371\n",
            "\n",
            "tensor([58.1636, 66.1300, 67.8666, 68.5582, 68.8493], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 280 - loss : 32791.84754262788\n",
            "\n",
            "tensor([57.8429, 66.0367, 68.0214, 68.8877, 69.2634], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 281 - loss : 32787.029087261784\n",
            "\n",
            "tensor([57.4509, 65.8252, 68.0467, 69.1341, 69.6361], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 282 - loss : 32782.19859578736\n",
            "\n",
            "tensor([56.9840, 65.4931, 67.9045, 69.2416, 69.9293], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 283 - loss : 32777.35205616851\n",
            "\n",
            "tensor([56.4390, 65.0487, 67.5786, 69.1382, 70.0692], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 284 - loss : 32772.48746238716\n",
            "\n",
            "tensor([55.8131, 64.5097, 67.0989, 68.7919, 69.9553], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 285 - loss : 32767.616850551654\n",
            "\n",
            "tensor([55.1109, 63.9106, 66.5449, 68.3305, 69.6273], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 286 - loss : 32762.72818455366\n",
            "\n",
            "tensor([54.3606, 63.3297, 66.0438, 68.0523, 69.5235], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 287 - loss : 32757.82748244734\n",
            "\n",
            "tensor([53.5595, 62.7697, 65.5600, 67.8765, 69.6963], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 288 - loss : 32752.914744232698\n",
            "\n",
            "tensor([52.6902, 62.2004, 65.0665, 67.5975, 69.8193], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 289 - loss : 32747.983951855567\n",
            "\n",
            "tensor([51.7651, 61.6084, 64.6153, 67.2265, 69.6481], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 290 - loss : 32743.04112337011\n",
            "\n",
            "tensor([50.9935, 61.1530, 64.3950, 67.0860, 69.5212], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 291 - loss : 32738.08625877633\n",
            "\n",
            "tensor([50.3138, 60.7676, 64.3908, 67.3416, 69.9196], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 292 - loss : 32733.119358074222\n",
            "\n",
            "tensor([49.6657, 60.3300, 64.3747, 67.6424, 70.4428], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 293 - loss : 32728.134403209628\n",
            "\n",
            "tensor([49.1242, 60.0300, 64.6214, 68.2641, 71.2874], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 294 - loss : 32723.139418254763\n",
            "\n",
            "tensor([48.5297, 59.6264, 64.8355, 68.8991, 72.1300], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 295 - loss : 32718.132397191574\n",
            "\n",
            "tensor([47.8285, 59.0283, 64.8520, 69.3714, 72.8062], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 296 - loss : 32713.10932798395\n",
            "\n",
            "tensor([46.9944, 58.1894, 64.5252, 69.5596, 73.2455], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 297 - loss : 32708.070210631897\n",
            "\n",
            "tensor([46.0273, 57.1191, 63.7492, 69.3764, 73.4166], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 298 - loss : 32703.025075225676\n",
            "\n",
            "tensor([44.9564, 55.8812, 62.5143, 68.7301, 73.2793], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 299 - loss : 32697.961885656972\n",
            "\n",
            "tensor([43.8544, 54.6348, 61.0647, 67.6162, 72.8236], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 300 - loss : 32692.884653961886\n",
            "\n",
            "tensor([42.7585, 53.4761, 59.7226, 66.1701, 72.0380], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 301 - loss : 32687.79338014042\n",
            "\n",
            "tensor([41.6621, 52.3789, 58.6274, 64.6976, 70.8724], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 302 - loss : 32682.69408224674\n",
            "\n",
            "tensor([40.5761, 51.3331, 57.8417, 63.6852, 69.6659], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 303 - loss : 32677.576730190573\n",
            "\n",
            "tensor([39.5213, 50.3281, 57.3360, 63.3637, 69.1448], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 304 - loss : 32672.44332998997\n",
            "\n",
            "tensor([38.5009, 49.3154, 56.9624, 63.5610, 69.4884], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 305 - loss : 32667.303911735205\n",
            "\n",
            "tensor([37.4740, 48.2169, 56.5204, 63.9563, 70.3039], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 306 - loss : 32662.146439317952\n",
            "\n",
            "tensor([36.4063, 46.9802, 55.8398, 64.2754, 71.2823], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 307 - loss : 32656.976930792378\n",
            "\n",
            "tensor([35.3499, 45.6999, 54.9038, 64.3270, 72.2193], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 308 - loss : 32651.79338014042\n",
            "\n",
            "tensor([34.3115, 44.4536, 53.7982, 63.9402, 72.8393], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 309 - loss : 32646.59177532598\n",
            "\n",
            "tensor([33.2781, 43.2648, 52.6685, 63.0649, 72.7417], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 310 - loss : 32641.384152457373\n",
            "\n",
            "tensor([32.2864, 42.1979, 51.7439, 62.0648, 71.8018], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 311 - loss : 32636.15847542628\n",
            "\n",
            "tensor([31.5442, 41.4932, 51.4049, 61.8808, 71.3994], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 312 - loss : 32630.92076228686\n",
            "\n",
            "tensor([31.1153, 41.1275, 51.4751, 62.4765, 72.2346], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 313 - loss : 32625.67101303912\n",
            "\n",
            "tensor([30.8569, 40.8945, 51.5915, 63.2235, 73.5066], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 314 - loss : 32620.413239719157\n",
            "\n",
            "tensor([30.6323, 40.6107, 51.5144, 63.6812, 74.5944], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 315 - loss : 32615.1334002006\n",
            "\n",
            "tensor([30.3651, 40.1712, 51.1227, 63.6076, 75.0162], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 316 - loss : 32609.84152457372\n",
            "\n",
            "tensor([30.0362, 39.5573, 50.3908, 63.0277, 74.6367], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 317 - loss : 32604.53961885657\n",
            "\n",
            "tensor([29.7142, 38.8980, 49.4690, 62.1522, 73.9517], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 318 - loss : 32599.221664994984\n",
            "\n",
            "tensor([29.5615, 38.4380, 48.6537, 61.1601, 73.4391], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 319 - loss : 32593.887662988967\n",
            "\n",
            "tensor([29.6484, 38.3677, 48.3590, 60.6781, 73.1871], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 320 - loss : 32588.54563691073\n",
            "\n",
            "tensor([30.0300, 38.7603, 48.6196, 60.9768, 73.9527], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 321 - loss : 32583.18956870612\n",
            "\n",
            "tensor([30.4538, 39.1817, 48.8747, 61.2251, 74.6193], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 322 - loss : 32577.819458375125\n",
            "\n",
            "tensor([30.7839, 39.4249, 48.8743, 61.0368, 74.6323], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 323 - loss : 32572.437311935806\n",
            "\n",
            "tensor([30.9995, 39.4898, 48.6479, 60.4609, 74.0142], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 324 - loss : 32567.039117352055\n",
            "\n",
            "tensor([31.1577, 39.4984, 48.3726, 59.7827, 73.1589], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 325 - loss : 32561.626880641925\n",
            "\n",
            "tensor([31.3535, 39.6003, 48.2153, 59.2601, 72.5670], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 326 - loss : 32556.20260782347\n",
            "\n",
            "tensor([31.5790, 39.7951, 48.2011, 58.9453, 72.2862], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 327 - loss : 32550.768304914745\n",
            "\n",
            "tensor([31.7789, 40.0191, 48.2878, 58.7910, 72.1654], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 328 - loss : 32545.317953861584\n",
            "\n",
            "tensor([31.8988, 40.1992, 48.4024, 58.6894, 72.0001], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 329 - loss : 32539.855566700102\n",
            "\n",
            "tensor([31.9114, 40.2940, 48.4963, 58.5665, 71.6777], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 330 - loss : 32534.377131394183\n",
            "\n",
            "tensor([31.8183, 40.3031, 48.5714, 58.4344, 71.2282], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 331 - loss : 32528.89067201605\n",
            "\n",
            "tensor([31.6418, 40.2529, 48.6626, 58.3624, 70.7781], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 332 - loss : 32523.386158475427\n",
            "\n",
            "tensor([31.4162, 40.1808, 48.8079, 58.4217, 70.4752], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 333 - loss : 32517.867602808426\n",
            "\n",
            "tensor([31.1792, 40.1202, 49.0254, 58.6392, 70.4039], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 334 - loss : 32512.34302908726\n",
            "\n",
            "tensor([30.9540, 40.0830, 49.3016, 58.9819, 70.5359], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 335 - loss : 32506.802407221665\n",
            "\n",
            "tensor([30.7384, 40.0501, 49.5955, 59.3753, 70.7563], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 336 - loss : 32501.24373119358\n",
            "\n",
            "tensor([30.5168, 39.9875, 49.8567, 59.7362, 70.9308], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 337 - loss : 32495.675025075227\n",
            "\n",
            "tensor([30.2860, 39.8793, 50.0550, 60.0120, 70.9788], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 338 - loss : 32490.090270812438\n",
            "\n",
            "tensor([30.0724, 39.7523, 50.2015, 60.2052, 70.9188], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 339 - loss : 32484.499498495486\n",
            "\n",
            "tensor([29.9239, 39.6668, 50.3378, 60.3585, 70.8404], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 340 - loss : 32478.888665997994\n",
            "\n",
            "tensor([29.8728, 39.6622, 50.4887, 60.5071, 70.8227], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 341 - loss : 32473.265797392178\n",
            "\n",
            "tensor([29.9003, 39.7024, 50.6183, 60.6390, 70.8659], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 342 - loss : 32467.632898696087\n",
            "\n",
            "tensor([29.9477, 39.6936, 50.6387, 60.6961, 70.8925], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 343 - loss : 32461.98595787362\n",
            "\n",
            "tensor([29.9724, 39.5726, 50.4724, 60.6114, 70.8121], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 344 - loss : 32456.324974924773\n",
            "\n",
            "tensor([29.9951, 39.3907, 50.1327, 60.3596, 70.5971], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 345 - loss : 32450.65396188566\n",
            "\n",
            "tensor([30.1120, 39.3554, 49.8440, 60.0613, 70.3287], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 346 - loss : 32444.964894684053\n",
            "\n",
            "tensor([30.3938, 39.6331, 49.9127, 59.9978, 70.1814], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 347 - loss : 32439.26178535607\n",
            "\n",
            "tensor([30.7242, 40.0131, 50.1436, 60.0886, 70.1562], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 348 - loss : 32433.54864593781\n",
            "\n",
            "tensor([30.9331, 40.1896, 50.1641, 60.0496, 70.1141], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 349 - loss : 32427.823470411233\n",
            "\n",
            "tensor([30.9810, 40.1171, 49.9150, 59.7962, 69.9787], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 350 - loss : 32422.08224674022\n",
            "\n",
            "tensor([30.9612, 40.0031, 49.7002, 59.5724, 69.8422], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 351 - loss : 32416.335005015044\n",
            "\n",
            "tensor([30.9733, 40.0537, 49.8534, 59.7407, 69.9096], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 352 - loss : 32410.569709127383\n",
            "\n",
            "tensor([30.9392, 40.0962, 50.0967, 60.0267, 70.0316], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 353 - loss : 32404.792377131394\n",
            "\n",
            "tensor([30.7786, 39.9333, 50.1080, 60.1270, 70.0618], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 354 - loss : 32398.994984954865\n",
            "\n",
            "tensor([30.5367, 39.6136, 49.9189, 60.0789, 70.0433], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 355 - loss : 32393.193580742227\n",
            "\n",
            "tensor([30.3549, 39.4055, 49.8488, 60.1410, 70.1100], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 356 - loss : 32387.376128385156\n",
            "\n",
            "tensor([30.2976, 39.4443, 50.0414, 60.3856, 70.2694], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 357 - loss : 32381.544633901703\n",
            "\n",
            "tensor([30.2577, 39.5046, 50.1845, 60.5291, 70.3505], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 358 - loss : 32375.70110330993\n",
            "\n",
            "tensor([30.1751, 39.4530, 50.0945, 60.4144, 70.2710], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 359 - loss : 32369.845536609828\n",
            "\n",
            "tensor([30.1251, 39.4286, 49.9512, 60.1812, 70.1105], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 360 - loss : 32363.97993981946\n",
            "\n",
            "tensor([30.1951, 39.5960, 50.0063, 60.0992, 70.0440], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 361 - loss : 32358.0962888666\n",
            "\n",
            "tensor([30.3298, 39.8593, 50.1774, 60.1440, 70.0743], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 362 - loss : 32352.198595787362\n",
            "\n",
            "tensor([30.3962, 40.0006, 50.2026, 60.0481, 70.0092], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 363 - loss : 32346.290872617854\n",
            "\n",
            "tensor([30.3729, 40.0148, 50.1131, 59.8419, 69.8438], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 364 - loss : 32340.369107321967\n",
            "\n",
            "tensor([30.3427, 40.0620, 50.1702, 59.8665, 69.8604], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 365 - loss : 32334.435305917752\n",
            "\n",
            "tensor([30.2938, 40.1054, 50.3064, 60.0480, 70.0265], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 366 - loss : 32328.489468405216\n",
            "\n",
            "tensor([30.1533, 39.9949, 50.2627, 60.0346, 70.0379], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 367 - loss : 32322.529588766298\n",
            "\n",
            "tensor([29.9751, 39.8105, 50.1276, 59.9201, 69.9576], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 368 - loss : 32316.55366098295\n",
            "\n",
            "tensor([29.8909, 39.7598, 50.1627, 60.0223, 70.0773], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 369 - loss : 32310.57372116349\n",
            "\n",
            "tensor([29.8822, 39.7966, 50.2578, 60.1559, 70.2167], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 370 - loss : 32304.57372116349\n",
            "\n",
            "tensor([29.8781, 39.7966, 50.2277, 60.0629, 70.1127], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 371 - loss : 32298.561685055167\n",
            "\n",
            "tensor([29.9290, 39.8468, 50.2197, 59.9588, 69.9738], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 372 - loss : 32292.53961885657\n",
            "\n",
            "tensor([30.0496, 39.9881, 50.3360, 60.0293, 70.0255], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 373 - loss : 32286.499498495486\n",
            "\n",
            "tensor([30.1086, 40.0382, 50.3604, 59.9999, 69.9556], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 374 - loss : 32280.453360080242\n",
            "\n",
            "tensor([30.0944, 39.9925, 50.3122, 59.9188, 69.8145], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 375 - loss : 32274.387161484454\n",
            "\n",
            "tensor([30.0893, 39.9655, 50.3476, 60.0288, 69.9377], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 376 - loss : 32268.310932798395\n",
            "\n",
            "tensor([30.0378, 39.8593, 50.2982, 60.0640, 69.9777], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 377 - loss : 32262.218655967903\n",
            "\n",
            "tensor([29.9657, 39.7101, 50.1777, 60.0074, 69.8933], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 378 - loss : 32256.12036108325\n",
            "\n",
            "tensor([30.0018, 39.7176, 50.2245, 60.1360, 70.0376], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 379 - loss : 32250.004012036108\n",
            "\n",
            "tensor([30.0538, 39.7476, 50.2633, 60.2122, 70.0901], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 380 - loss : 32243.881644934805\n",
            "\n",
            "tensor([30.0807, 39.7294, 50.2188, 60.1878, 70.0282], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 381 - loss : 32237.743229689066\n",
            "\n",
            "tensor([30.1408, 39.7409, 50.1980, 60.2387, 70.1437], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 382 - loss : 32231.588766298897\n",
            "\n",
            "tensor([30.1427, 39.6615, 50.0276, 60.1090, 70.0875], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 383 - loss : 32225.424272818454\n",
            "\n",
            "tensor([30.2075, 39.7058, 49.9911, 60.0702, 70.1001], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 384 - loss : 32219.245737211633\n",
            "\n",
            "tensor([30.3196, 39.8552, 50.0900, 60.1420, 70.1710], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 385 - loss : 32213.0591775326\n",
            "\n",
            "tensor([30.3202, 39.8352, 49.9554, 59.9480, 70.0023], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 386 - loss : 32206.85255767302\n",
            "\n",
            "tensor([30.4267, 40.0193, 50.1604, 60.1793, 70.2699], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 387 - loss : 32200.63590772317\n",
            "\n",
            "tensor([30.2775, 39.8417, 49.8963, 59.8426, 69.9466], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 388 - loss : 32194.40922768305\n",
            "\n",
            "tensor([30.3349, 40.0131, 50.1805, 60.2266, 70.4034], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 389 - loss : 32188.16850551655\n",
            "\n",
            "tensor([30.1543, 39.8324, 49.9890, 60.0014, 70.1946], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 390 - loss : 32181.91374122367\n",
            "\n",
            "tensor([30.0399, 39.7388, 49.9036, 59.8971, 70.1300], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 391 - loss : 32175.646940822466\n",
            "\n",
            "tensor([30.0841, 39.8908, 50.1322, 60.1759, 70.4537], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 392 - loss : 32169.36810431294\n",
            "\n",
            "tensor([29.9636, 39.8067, 50.0108, 59.9436, 70.1357], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 393 - loss : 32163.07923771314\n",
            "\n",
            "tensor([30.0277, 39.9438, 50.1556, 60.0705, 70.2882], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 394 - loss : 32156.7703109328\n",
            "\n",
            "tensor([30.0308, 39.9802, 50.1605, 59.9966, 70.1800], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 395 - loss : 32150.453360080242\n",
            "\n",
            "tensor([29.9796, 39.9574, 50.1146, 59.8555, 69.9264], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 396 - loss : 32144.124373119357\n",
            "\n",
            "tensor([30.0950, 40.1638, 50.4059, 60.2413, 70.4006], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 397 - loss : 32137.78335005015\n",
            "\n",
            "tensor([29.9478, 40.0022, 50.2598, 60.0324, 70.0452], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 398 - loss : 32131.424272818454\n",
            "\n",
            "tensor([29.9003, 39.9423, 50.2654, 60.0833, 70.0922], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 399 - loss : 32125.0591775326\n",
            "\n",
            "tensor([29.8754, 39.9133, 50.3162, 60.2119, 70.2512], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 400 - loss : 32118.678034102308\n",
            "\n",
            "tensor([29.7828, 39.7864, 50.2260, 60.1245, 70.0607], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 401 - loss : 32112.28485456369\n",
            "\n",
            "tensor([29.9014, 39.8748, 50.3376, 60.3118, 70.3261], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 402 - loss : 32105.87963891675\n",
            "\n",
            "tensor([29.8927, 39.8000, 50.2404, 60.1914, 70.0853], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 403 - loss : 32099.466399197594\n",
            "\n",
            "tensor([29.9946, 39.8512, 50.2818, 60.2904, 70.2298], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 404 - loss : 32093.033099297892\n",
            "\n",
            "tensor([30.0873, 39.8606, 50.2718, 60.3652, 70.3906], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 405 - loss : 32086.59177532598\n",
            "\n",
            "tensor([30.0427, 39.6777, 50.0310, 60.1616, 70.1452], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 406 - loss : 32080.138415245736\n",
            "\n",
            "tensor([30.1649, 39.6886, 49.9729, 60.2007, 70.3392], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 407 - loss : 32073.67101303912\n",
            "\n",
            "tensor([30.2006, 39.6536, 49.8561, 60.1008, 70.2500], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 408 - loss : 32067.18555667001\n",
            "\n",
            "tensor([30.3517, 39.7890, 49.9306, 60.1866, 70.3952], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 409 - loss : 32060.69408224674\n",
            "\n",
            "tensor([30.4041, 39.8195, 49.8966, 60.1347, 70.3236], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 410 - loss : 32054.194583751254\n",
            "\n",
            "tensor([30.3915, 39.8059, 49.8365, 60.0636, 70.2368], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 411 - loss : 32047.675025075227\n",
            "\n",
            "tensor([30.4317, 39.8902, 49.9122, 60.1649, 70.4195], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 412 - loss : 32041.14343029087\n",
            "\n",
            "tensor([30.2857, 39.7642, 49.7499, 59.9857, 70.2125], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 413 - loss : 32034.605817452357\n",
            "\n",
            "tensor([30.3254, 39.9023, 49.9206, 60.1785, 70.4786], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 414 - loss : 32028.046138415244\n",
            "\n",
            "tensor([30.1300, 39.7765, 49.7877, 60.0136, 70.2587], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 415 - loss : 32021.480441323973\n",
            "\n",
            "tensor([30.1675, 39.9111, 49.9504, 60.2023, 70.5545], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 416 - loss : 32014.902708124373\n",
            "\n",
            "tensor([29.9628, 39.7355, 49.7149, 59.9064, 70.2214], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 417 - loss : 32008.310932798395\n",
            "\n",
            "tensor([30.0243, 39.9140, 49.9212, 60.0959, 70.4119], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 418 - loss : 32001.705115346038\n",
            "\n",
            "tensor([29.9966, 39.9583, 49.9359, 60.0571, 70.3429], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 419 - loss : 31995.08324974925\n",
            "\n",
            "tensor([29.9761, 39.9555, 49.8499, 59.9077, 70.2203], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 420 - loss : 31988.45737211635\n",
            "\n",
            "tensor([30.0541, 40.0769, 49.9240, 59.9447, 70.3105], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 421 - loss : 31981.815446339016\n",
            "\n",
            "tensor([29.9803, 40.0170, 49.7707, 59.6914, 70.0101], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 422 - loss : 31975.163490471416\n",
            "\n",
            "tensor([30.1687, 40.3555, 50.2016, 60.1592, 70.4968], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 423 - loss : 31968.49548645938\n",
            "\n",
            "tensor([29.9534, 40.1410, 49.8919, 59.7230, 69.9432], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 424 - loss : 31961.819458375125\n",
            "\n",
            "tensor([30.0354, 40.2743, 50.0441, 59.8919, 70.1944], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 425 - loss : 31955.129388164492\n",
            "\n",
            "tensor([29.8743, 40.1688, 49.9327, 59.7249, 69.9626], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 426 - loss : 31948.423269809427\n",
            "\n",
            "tensor([29.8724, 40.2546, 50.0832, 59.8990, 70.1414], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 427 - loss : 31941.707121364092\n",
            "\n",
            "tensor([29.8453, 40.2541, 50.0892, 59.8935, 70.1335], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 428 - loss : 31934.980942828486\n",
            "\n",
            "tensor([29.7084, 40.1246, 49.9308, 59.6751, 69.8471], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 429 - loss : 31928.244734202606\n",
            "\n",
            "tensor([29.8672, 40.3731, 50.2951, 60.1390, 70.4073], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 430 - loss : 31921.48846539619\n",
            "\n",
            "tensor([29.6991, 40.1490, 49.9769, 59.7065, 69.8465], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 431 - loss : 31914.722166499498\n",
            "\n",
            "tensor([29.8002, 40.2364, 50.0673, 59.8118, 69.9827], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 432 - loss : 31907.94784353059\n",
            "\n",
            "tensor([29.8435, 40.3074, 50.1780, 59.9496, 70.1278], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 433 - loss : 31901.16148445336\n",
            "\n",
            "tensor([29.8260, 40.2506, 50.0920, 59.8371, 69.9916], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 434 - loss : 31894.36108324975\n",
            "\n",
            "tensor([29.8972, 40.2524, 50.0652, 59.8109, 69.9983], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 435 - loss : 31887.54262788365\n",
            "\n",
            "tensor([29.7969, 40.1250, 49.9230, 59.6350, 69.7440], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 436 - loss : 31880.722166499498\n",
            "\n",
            "tensor([29.9814, 40.3705, 50.3110, 60.1726, 70.4189], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 437 - loss : 31873.885656970913\n",
            "\n",
            "tensor([29.8132, 40.1231, 50.0111, 59.8092, 69.9411], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 438 - loss : 31867.033099297892\n",
            "\n",
            "tensor([29.8324, 40.0649, 49.9487, 59.7697, 69.9243], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 439 - loss : 31860.17251755266\n",
            "\n",
            "tensor([29.8761, 40.1150, 50.0570, 59.9410, 70.1372], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 440 - loss : 31853.299899699097\n",
            "\n",
            "tensor([29.8833, 40.0767, 50.0042, 59.8850, 70.0508], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 441 - loss : 31846.413239719157\n",
            "\n",
            "tensor([29.9851, 40.0972, 49.9900, 59.8707, 70.0382], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 442 - loss : 31839.514543630892\n",
            "\n",
            "tensor([29.9391, 40.0359, 49.9243, 59.7889, 69.8862], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 443 - loss : 31832.605817452357\n",
            "\n",
            "tensor([30.1592, 40.2588, 50.2264, 60.1991, 70.4289], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 444 - loss : 31825.68104312939\n",
            "\n",
            "tensor([29.9188, 39.9161, 49.8156, 59.7183, 69.7737], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 445 - loss : 31818.7482447342\n",
            "\n",
            "tensor([30.0880, 40.0683, 50.0279, 60.0227, 70.1850], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 446 - loss : 31811.805416248746\n",
            "\n",
            "tensor([30.0284, 40.0180, 50.0243, 60.0560, 70.1985], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 447 - loss : 31804.842527582747\n",
            "\n",
            "tensor([30.0043, 39.9372, 49.9427, 59.9961, 70.1259], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 448 - loss : 31797.871614844535\n",
            "\n",
            "tensor([30.0745, 39.9471, 49.9407, 60.0085, 70.1491], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 449 - loss : 31790.89067201605\n",
            "\n",
            "tensor([29.9993, 39.8791, 49.8659, 59.8911, 69.9264], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 450 - loss : 31783.897693079238\n",
            "\n",
            "tensor([30.2265, 40.1626, 50.2155, 60.2908, 70.4167], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 451 - loss : 31776.892678034103\n",
            "\n",
            "tensor([30.0726, 39.9523, 49.9692, 60.0088, 70.0241], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 452 - loss : 31769.871614844535\n",
            "\n",
            "tensor([30.0495, 39.8957, 49.9306, 60.0153, 70.0567], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 453 - loss : 31762.840521564693\n",
            "\n",
            "tensor([30.0848, 39.9498, 50.0384, 60.1870, 70.2934], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 454 - loss : 31755.799398194584\n",
            "\n",
            "tensor([29.9614, 39.8055, 49.8756, 60.0058, 70.0340], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 455 - loss : 31748.744232698093\n",
            "\n",
            "tensor([30.1051, 39.9645, 50.0461, 60.1873, 70.2506], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 456 - loss : 31741.68104312939\n",
            "\n",
            "tensor([30.0212, 39.9099, 49.9893, 60.1014, 70.0842], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 457 - loss : 31734.59779338014\n",
            "\n",
            "tensor([30.1132, 40.0195, 50.1245, 60.2808, 70.3318], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 458 - loss : 31727.512537612838\n",
            "\n",
            "tensor([30.0074, 39.8565, 49.9200, 60.0839, 70.1098], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 459 - loss : 31720.40922768305\n",
            "\n",
            "tensor([29.9865, 39.8326, 49.8883, 60.0735, 70.1135], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 460 - loss : 31713.29588766299\n",
            "\n",
            "tensor([30.1001, 39.9931, 50.0742, 60.2915, 70.3924], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 461 - loss : 31706.17251755266\n",
            "\n",
            "tensor([29.9911, 39.8584, 49.8856, 60.0794, 70.1224], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 462 - loss : 31699.035105315947\n",
            "\n",
            "tensor([30.1104, 39.9728, 49.9839, 60.2060, 70.3229], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 463 - loss : 31691.881644934805\n",
            "\n",
            "tensor([29.9923, 39.8644, 49.8425, 60.0512, 70.1286], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 464 - loss : 31684.722166499498\n",
            "\n",
            "tensor([30.1505, 40.0429, 50.0196, 60.2615, 70.4290], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 465 - loss : 31677.55065195587\n",
            "\n",
            "tensor([29.9996, 39.8687, 49.7793, 59.9979, 70.1254], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 466 - loss : 31670.36509528586\n",
            "\n",
            "tensor([30.1187, 40.0239, 49.9407, 60.1878, 70.3952], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 467 - loss : 31663.167502507524\n",
            "\n",
            "tensor([30.0452, 39.9574, 49.8364, 60.0730, 70.2828], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 468 - loss : 31655.95987963892\n",
            "\n",
            "tensor([30.0442, 39.9567, 49.7940, 60.0162, 70.2420], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 469 - loss : 31648.73821464393\n",
            "\n",
            "tensor([30.0878, 40.0528, 49.8901, 60.0999, 70.3327], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 470 - loss : 31641.50451354062\n",
            "\n",
            "tensor([30.0416, 40.0425, 49.8645, 60.0595, 70.2932], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 471 - loss : 31634.260782347043\n",
            "\n",
            "tensor([30.0710, 40.0654, 49.8543, 60.0543, 70.3536], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 472 - loss : 31627.009027081243\n",
            "\n",
            "tensor([29.9235, 39.9354, 49.6841, 59.8442, 70.1118], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 473 - loss : 31619.737211634903\n",
            "\n",
            "tensor([30.1423, 40.2420, 50.0460, 60.2192, 70.5300], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 474 - loss : 31612.46138415246\n",
            "\n",
            "tensor([29.8896, 39.9997, 49.7494, 59.8485, 70.0638], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 475 - loss : 31605.171514543632\n",
            "\n",
            "tensor([30.0915, 40.2184, 49.9843, 60.1190, 70.4479], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 476 - loss : 31597.865596790372\n",
            "\n",
            "tensor([29.8552, 40.0019, 49.7364, 59.8163, 70.0852], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 477 - loss : 31590.55366098295\n",
            "\n",
            "tensor([29.9650, 40.1553, 49.9143, 59.9973, 70.2919], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 478 - loss : 31583.227683049146\n",
            "\n",
            "tensor([29.9907, 40.1999, 49.9554, 60.0189, 70.3104], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 479 - loss : 31575.88966900702\n",
            "\n",
            "tensor([29.8378, 40.0573, 49.7900, 59.8077, 70.0537], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 480 - loss : 31568.541624874622\n",
            "\n",
            "tensor([30.0291, 40.2717, 50.0395, 60.0934, 70.4229], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 481 - loss : 31561.177532597794\n",
            "\n",
            "tensor([29.8413, 40.0590, 49.7769, 59.7676, 70.0414], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 482 - loss : 31553.809428284854\n",
            "\n",
            "tensor([29.9229, 40.1622, 49.9016, 59.8904, 70.1668], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 483 - loss : 31546.423269809427\n",
            "\n",
            "tensor([30.0132, 40.2797, 50.0550, 60.0555, 70.3496], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 484 - loss : 31539.02708124373\n",
            "\n",
            "tensor([29.8401, 40.0747, 49.8149, 59.7664, 70.0234], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 485 - loss : 31531.61885656971\n",
            "\n",
            "tensor([29.9794, 40.1986, 49.9574, 59.9326, 70.2476], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 486 - loss : 31524.20661985958\n",
            "\n",
            "tensor([29.8833, 40.1098, 49.8792, 59.8242, 70.0895], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 487 - loss : 31516.7703109328\n",
            "\n",
            "tensor([29.9454, 40.1854, 49.9936, 59.9499, 70.2202], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 488 - loss : 31509.327983951855\n",
            "\n",
            "tensor([29.9690, 40.1718, 49.9786, 59.9345, 70.2328], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 489 - loss : 31501.87362086259\n",
            "\n",
            "tensor([29.8321, 39.9976, 49.7854, 59.7017, 69.9698], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 490 - loss : 31494.411233701103\n",
            "\n",
            "tensor([30.0334, 40.2274, 50.0867, 60.0480, 70.3492], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 491 - loss : 31486.93480441324\n",
            "\n",
            "tensor([29.9024, 40.0620, 49.9040, 59.8160, 70.0610], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 492 - loss : 31479.444332998995\n",
            "\n",
            "tensor([29.9732, 40.1048, 49.9620, 59.8820, 70.1548], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 493 - loss : 31471.94784353059\n",
            "\n",
            "tensor([29.9717, 40.0909, 49.9697, 59.8861, 70.1584], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 494 - loss : 31464.435305917752\n",
            "\n",
            "tensor([29.9322, 40.0294, 49.9138, 59.8073, 70.0554], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 495 - loss : 31456.914744232698\n",
            "\n",
            "tensor([30.0460, 40.1356, 50.0527, 59.9611, 70.2256], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 496 - loss : 31449.380140421265\n",
            "\n",
            "tensor([29.9151, 39.9811, 49.8953, 59.7617, 69.9811], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 497 - loss : 31441.835506519557\n",
            "\n",
            "tensor([30.0771, 40.1431, 50.1045, 60.0055, 70.2689], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 498 - loss : 31434.280842527583\n",
            "\n",
            "tensor([29.8966, 39.9162, 49.8487, 59.6823, 69.8816], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 499 - loss : 31426.70812437312\n",
            "\n",
            "tensor([30.0856, 40.1419, 50.1473, 60.0250, 70.2498], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 500 - loss : 31419.131394182547\n",
            "\n",
            "tensor([29.9578, 39.9875, 49.9894, 59.8222, 69.9994], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 501 - loss : 31411.544633901703\n",
            "\n",
            "tensor([29.9973, 40.0016, 50.0155, 59.8445, 70.0336], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 502 - loss : 31403.939819458374\n",
            "\n",
            "tensor([29.9907, 40.0053, 50.0501, 59.8694, 70.0321], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 503 - loss : 31396.326980942828\n",
            "\n",
            "tensor([29.9966, 40.0186, 50.0912, 59.9033, 70.0475], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 504 - loss : 31388.700100300903\n",
            "\n",
            "tensor([30.0143, 40.0080, 50.0825, 59.8831, 70.0348], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 505 - loss : 31381.061183550653\n",
            "\n",
            "tensor([29.9282, 39.9077, 49.9822, 59.7458, 69.8574], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 506 - loss : 31373.41223671013\n",
            "\n",
            "tensor([30.1098, 40.1309, 50.2672, 60.0720, 70.2079], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 507 - loss : 31365.755265797394\n",
            "\n",
            "tensor([29.8715, 39.8339, 49.9266, 59.6443, 69.6936], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 508 - loss : 31358.08625877633\n",
            "\n",
            "tensor([30.1751, 40.1830, 50.3569, 60.1622, 70.3039], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 509 - loss : 31350.40521564694\n",
            "\n",
            "tensor([29.8053, 39.7513, 49.8824, 59.5709, 69.5656], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 510 - loss : 31342.712136409227\n",
            "\n",
            "tensor([30.1545, 40.1533, 50.3620, 60.1454, 70.2374], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 511 - loss : 31335.009027081243\n",
            "\n",
            "tensor([29.9464, 39.9109, 50.1143, 59.8357, 69.8333], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 512 - loss : 31327.289869608827\n",
            "\n",
            "tensor([29.9081, 39.8640, 50.0917, 59.8091, 69.7862], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 513 - loss : 31319.566700100302\n",
            "\n",
            "tensor([30.1278, 40.1022, 50.3782, 60.1610, 70.2135], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 514 - loss : 31311.829488465395\n",
            "\n",
            "tensor([29.8270, 39.7276, 49.9617, 59.6489, 69.5757], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 515 - loss : 31304.078234704113\n",
            "\n",
            "tensor([30.0714, 40.0335, 50.3327, 60.0954, 70.0989], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 516 - loss : 31296.31895687061\n",
            "\n",
            "tensor([30.0535, 39.9716, 50.2508, 59.9902, 69.9749], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 517 - loss : 31288.54964894684\n",
            "\n",
            "tensor([29.8668, 39.7162, 49.9493, 59.6124, 69.5036], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 518 - loss : 31280.76629889669\n",
            "\n",
            "tensor([30.1988, 40.1470, 50.4677, 60.2381, 70.2359], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 519 - loss : 31272.96890672016\n",
            "\n",
            "tensor([29.9973, 39.8796, 50.1720, 59.8826, 69.7939], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 520 - loss : 31265.16549648947\n",
            "\n",
            "tensor([29.9458, 39.7740, 50.0565, 59.7579, 69.6567], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 521 - loss : 31257.352056168507\n",
            "\n",
            "tensor([30.1328, 40.0187, 50.3648, 60.1416, 70.1123], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 522 - loss : 31249.52256770311\n",
            "\n",
            "tensor([29.9307, 39.7721, 50.0929, 59.8086, 69.6805], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 523 - loss : 31241.685055165497\n",
            "\n",
            "tensor([30.0819, 39.9313, 50.2646, 60.0159, 69.9348], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 524 - loss : 31233.835506519557\n",
            "\n",
            "tensor([30.0425, 39.8826, 50.2117, 59.9492, 69.8406], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 525 - loss : 31225.97592778335\n",
            "\n",
            "tensor([29.9842, 39.8196, 50.1459, 59.8671, 69.7227], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 526 - loss : 31218.102306920762\n",
            "\n",
            "tensor([30.1457, 40.0042, 50.3525, 60.1213, 70.0357], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 527 - loss : 31210.218655967903\n",
            "\n",
            "tensor([29.9376, 39.7351, 50.0421, 59.7489, 69.5722], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 528 - loss : 31202.324974924773\n",
            "\n",
            "tensor([30.1079, 39.9771, 50.3411, 60.1156, 70.0036], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 529 - loss : 31194.423269809427\n",
            "\n",
            "tensor([30.0310, 39.8566, 50.1908, 59.9368, 69.7812], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 530 - loss : 31186.507522567703\n",
            "\n",
            "tensor([29.9706, 39.7859, 50.1132, 59.8465, 69.6545], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 531 - loss : 31178.581745235708\n",
            "\n",
            "tensor([30.1482, 40.0395, 50.4282, 60.2367, 70.1169], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 532 - loss : 31170.64192577733\n",
            "\n",
            "tensor([29.9059, 39.6946, 50.0131, 59.7475, 69.5218], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 533 - loss : 31162.69408224674\n",
            "\n",
            "tensor([30.1083, 39.9681, 50.3395, 60.1484, 70.0013], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 534 - loss : 31154.734202607822\n",
            "\n",
            "tensor([29.9853, 39.8230, 50.1754, 59.9555, 69.7448], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 535 - loss : 31146.762286860583\n",
            "\n",
            "tensor([30.0428, 39.8728, 50.2210, 60.0230, 69.8332], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 536 - loss : 31138.78034102307\n",
            "\n",
            "tensor([30.0273, 39.8523, 50.1959, 60.0054, 69.8065], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 537 - loss : 31130.79037111334\n",
            "\n",
            "tensor([30.0181, 39.8467, 50.1897, 60.0097, 69.8045], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 538 - loss : 31122.784353059178\n",
            "\n",
            "tensor([30.0824, 39.9022, 50.2346, 60.0765, 69.8957], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 539 - loss : 31114.7703109328\n",
            "\n",
            "tensor([29.9601, 39.7414, 50.0332, 59.8414, 69.5981], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 540 - loss : 31106.746238716147\n",
            "\n",
            "tensor([30.2050, 40.0840, 50.4393, 60.3325, 70.1842], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 541 - loss : 31098.712136409227\n",
            "\n",
            "tensor([29.8790, 39.6148, 49.8563, 59.6537, 69.3617], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 542 - loss : 31090.66399197593\n",
            "\n",
            "tensor([30.2690, 40.1692, 50.5347, 60.4811, 70.3686], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 543 - loss : 31082.60782347041\n",
            "\n",
            "tensor([29.8460, 39.6043, 49.8541, 59.6826, 69.3751], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 544 - loss : 31074.537612838514\n",
            "\n",
            "tensor([30.1927, 40.0603, 50.3927, 60.3457, 70.2025], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 545 - loss : 31066.45737211635\n",
            "\n",
            "tensor([29.9434, 39.7571, 50.0379, 59.9349, 69.6787], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 546 - loss : 31058.369107321967\n",
            "\n",
            "tensor([30.0128, 39.8553, 50.1487, 60.0821, 69.8606], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 547 - loss : 31050.26479438315\n",
            "\n",
            "tensor([30.1155, 39.9754, 50.2728, 60.2482, 70.0805], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 548 - loss : 31042.154463390172\n",
            "\n",
            "tensor([29.8662, 39.6460, 49.8614, 59.7700, 69.4919], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 549 - loss : 31034.03410230692\n",
            "\n",
            "tensor([30.2205, 40.1345, 50.4360, 60.4534, 70.3299], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 550 - loss : 31025.901705115346\n",
            "\n",
            "tensor([29.9234, 39.7003, 49.8625, 59.7663, 69.4820], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 551 - loss : 31017.75325977934\n",
            "\n",
            "tensor([30.1075, 39.9938, 50.2264, 60.2037, 70.0056], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 552 - loss : 31009.60080240722\n",
            "\n",
            "tensor([30.1243, 40.0078, 50.2307, 60.2328, 70.0603], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 553 - loss : 31001.434302908725\n",
            "\n",
            "tensor([29.8771, 39.6475, 49.7657, 59.7050, 69.4339], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 554 - loss : 30993.25777331996\n",
            "\n",
            "tensor([30.2145, 40.1685, 50.4261, 60.5001, 70.3956], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 555 - loss : 30985.071213640924\n",
            "\n",
            "tensor([29.9156, 39.7525, 49.8913, 59.8720, 69.6276], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 556 - loss : 30976.87261785356\n",
            "\n",
            "tensor([30.0510, 39.9237, 50.0788, 60.1078, 69.9346], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 557 - loss : 30968.65997993982\n",
            "\n",
            "tensor([30.0464, 39.9617, 50.1292, 60.1667, 69.9889], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 558 - loss : 30960.445336008022\n",
            "\n",
            "tensor([29.9741, 39.8584, 49.9767, 59.9888, 69.7733], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 559 - loss : 30952.214643931795\n",
            "\n",
            "tensor([30.1154, 40.0455, 50.1911, 60.2590, 70.1227], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 560 - loss : 30943.97592778335\n",
            "\n",
            "tensor([29.9001, 39.7648, 49.8331, 59.8430, 69.6177], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 561 - loss : 30935.723169508525\n",
            "\n",
            "tensor([30.1630, 40.1333, 50.2770, 60.3732, 70.2649], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 562 - loss : 30927.462387161486\n",
            "\n",
            "tensor([29.9095, 39.7792, 49.8111, 59.8228, 69.5975], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 563 - loss : 30919.191574724173\n",
            "\n",
            "tensor([30.1270, 40.1128, 50.2362, 60.3387, 70.2263], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 564 - loss : 30910.90672016048\n",
            "\n",
            "tensor([29.9542, 39.8463, 49.8685, 59.9105, 69.7229], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 565 - loss : 30902.615847542627\n",
            "\n",
            "tensor([30.0319, 39.9909, 50.0570, 60.1390, 69.9900], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 566 - loss : 30894.310932798395\n",
            "\n",
            "tensor([30.0630, 40.0444, 50.1203, 60.2286, 70.1098], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 567 - loss : 30885.995987963892\n",
            "\n",
            "tensor([29.9007, 39.7883, 49.7647, 59.8205, 69.6439], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 568 - loss : 30877.67101303912\n",
            "\n",
            "tensor([30.1465, 40.1831, 50.2814, 60.4348, 70.3677], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 569 - loss : 30869.34002006018\n",
            "\n",
            "tensor([29.8654, 39.7673, 49.7205, 59.7697, 69.5787], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 570 - loss : 30860.990972918757\n",
            "\n",
            "tensor([30.1827, 40.2139, 50.2791, 60.4419, 70.4000], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 571 - loss : 30852.637913741222\n",
            "\n",
            "tensor([29.8117, 39.7182, 49.6395, 59.6705, 69.4537], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 572 - loss : 30844.26880641926\n",
            "\n",
            "tensor([30.2591, 40.3508, 50.4422, 60.6383, 70.6312], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 573 - loss : 30835.891675025076\n",
            "\n",
            "tensor([29.8079, 39.7181, 49.6187, 59.6571, 69.4542], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 574 - loss : 30827.50451354062\n",
            "\n",
            "tensor([30.0835, 40.1358, 50.1690, 60.3298, 70.2724], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 575 - loss : 30819.107321965897\n",
            "\n",
            "tensor([30.0088, 40.0157, 49.9933, 60.1212, 70.0285], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 576 - loss : 30810.696088264795\n",
            "\n",
            "tensor([29.8575, 39.8167, 49.7332, 59.8065, 69.6422], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 577 - loss : 30802.27883650953\n",
            "\n",
            "tensor([30.2014, 40.3126, 50.3748, 60.5830, 70.5805], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 578 - loss : 30793.849548645936\n",
            "\n",
            "tensor([29.8096, 39.7346, 49.5995, 59.6482, 69.4602], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 579 - loss : 30785.410230692076\n",
            "\n",
            "tensor([30.1157, 40.1876, 50.1970, 60.3776, 70.3404], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 580 - loss : 30776.95887662989\n",
            "\n",
            "tensor([30.0009, 40.0246, 49.9821, 60.1281, 70.0503], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 581 - loss : 30768.497492477432\n",
            "\n",
            "tensor([29.8785, 39.8242, 49.6992, 59.7945, 69.6680], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 582 - loss : 30760.026078234703\n",
            "\n",
            "tensor([30.1670, 40.2600, 50.2808, 60.5023, 70.5128], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 583 - loss : 30751.54864593781\n",
            "\n",
            "tensor([29.8640, 39.8267, 49.7066, 59.8115, 69.6897], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 584 - loss : 30743.057171514545\n",
            "\n",
            "tensor([30.0861, 40.1027, 50.0386, 60.2206, 70.2061], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 585 - loss : 30734.55767301906\n",
            "\n",
            "tensor([29.9675, 39.9734, 49.8841, 60.0260, 69.9502], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 586 - loss : 30726.042126379136\n",
            "\n",
            "tensor([30.0166, 40.0388, 49.9577, 60.1117, 70.0506], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 587 - loss : 30717.520561685054\n",
            "\n",
            "tensor([30.0694, 40.1005, 50.0267, 60.2061, 70.1854], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 588 - loss : 30708.98696088265\n",
            "\n",
            "tensor([29.8935, 39.8742, 49.7416, 59.8724, 69.7993], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 589 - loss : 30700.447342026077\n",
            "\n",
            "tensor([30.1292, 40.1988, 50.1564, 60.3836, 70.4267], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 590 - loss : 30691.895687061184\n",
            "\n",
            "tensor([29.8489, 39.8044, 49.6284, 59.7405, 69.6657], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 591 - loss : 30683.327983951855\n",
            "\n",
            "tensor([30.1407, 40.2475, 50.2223, 60.4603, 70.5159], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 592 - loss : 30674.752256770313\n",
            "\n",
            "tensor([29.8914, 39.8626, 49.6810, 59.7953, 69.7392], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 593 - loss : 30666.16850551655\n",
            "\n",
            "tensor([30.0541, 40.1285, 50.0453, 60.2360, 70.2542], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 594 - loss : 30657.58074222668\n",
            "\n",
            "tensor([30.0115, 40.0678, 49.9569, 60.1308, 70.1446], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 595 - loss : 30648.970912738216\n",
            "\n",
            "tensor([29.9112, 39.9028, 49.7135, 59.8337, 69.8144], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 596 - loss : 30640.36108324975\n",
            "\n",
            "tensor([30.1115, 40.2350, 50.1750, 60.3921, 70.4600], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 597 - loss : 30631.737211634903\n",
            "\n",
            "tensor([29.8681, 39.8675, 49.6625, 59.7611, 69.7294], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 598 - loss : 30623.101303911735\n",
            "\n",
            "tensor([30.1320, 40.2457, 50.1596, 60.3696, 70.4605], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 599 - loss : 30614.459378134405\n",
            "\n",
            "tensor([29.8193, 39.8336, 49.6228, 59.7027, 69.6585], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 600 - loss : 30605.803410230692\n",
            "\n",
            "tensor([30.2095, 40.3682, 50.3133, 60.5505, 70.6805], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 601 - loss : 30597.139418254763\n",
            "\n",
            "tensor([29.7494, 39.7429, 49.4958, 59.5459, 69.4939], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 602 - loss : 30588.465396188567\n",
            "\n",
            "tensor([30.1764, 40.3583, 50.3180, 60.5617, 70.7078], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 603 - loss : 30579.781344032097\n",
            "\n",
            "tensor([29.8466, 39.8719, 49.6531, 59.7389, 69.7460], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 604 - loss : 30571.085255767302\n",
            "\n",
            "tensor([29.9602, 40.0620, 49.9225, 60.0655, 70.1213], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 605 - loss : 30562.373119358075\n",
            "\n",
            "tensor([30.0997, 40.2407, 50.1440, 60.3320, 70.4433], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 606 - loss : 30553.66700100301\n",
            "\n",
            "tensor([29.7912, 39.7919, 49.5344, 59.5711, 69.5467], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 607 - loss : 30544.938816449347\n",
            "\n",
            "tensor([30.2160, 40.4158, 50.3829, 60.6243, 70.7962], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 608 - loss : 30536.204613841524\n",
            "\n",
            "tensor([29.8366, 39.8606, 49.6349, 59.7049, 69.7347], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 609 - loss : 30527.462387161486\n",
            "\n",
            "tensor([29.9787, 40.0387, 49.8583, 59.9820, 70.0800], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 610 - loss : 30518.706118355065\n",
            "\n",
            "tensor([30.0679, 40.2087, 50.1132, 60.2891, 70.4181], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 611 - loss : 30509.941825476428\n",
            "\n",
            "tensor([29.8735, 39.9091, 49.6951, 59.7631, 69.8066], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 612 - loss : 30501.167502507524\n",
            "\n",
            "tensor([30.1181, 40.2352, 50.1200, 60.2932, 70.4557], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 613 - loss : 30492.383149448346\n",
            "\n",
            "tensor([29.8574, 39.8996, 49.6947, 59.7593, 69.8166], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 614 - loss : 30483.588766298897\n",
            "\n",
            "tensor([30.0886, 40.1920, 50.0582, 60.2026, 70.3495], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 615 - loss : 30474.782347041124\n",
            "\n",
            "tensor([29.9475, 40.0277, 49.8638, 59.9570, 70.0520], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 616 - loss : 30465.96990972919\n",
            "\n",
            "tensor([29.9824, 40.0729, 49.9244, 60.0361, 70.1673], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 617 - loss : 30457.14343029087\n",
            "\n",
            "tensor([29.9987, 40.0655, 49.8921, 59.9926, 70.1405], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 618 - loss : 30448.30892678034\n",
            "\n",
            "tensor([29.9139, 39.9906, 49.8204, 59.8942, 70.0082], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 619 - loss : 30439.466399197594\n",
            "\n",
            "tensor([30.1088, 40.2357, 50.1249, 60.2652, 70.4616], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 620 - loss : 30430.615847542627\n",
            "\n",
            "tensor([29.8099, 39.8051, 49.5341, 59.5069, 69.5659], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 621 - loss : 30421.751253761286\n",
            "\n",
            "tensor([30.2300, 40.4600, 50.4521, 60.6516, 70.8935], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 622 - loss : 30412.87662988967\n",
            "\n",
            "tensor([29.7990, 39.8107, 49.5561, 59.5262, 69.6037], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 623 - loss : 30403.991975927784\n",
            "\n",
            "tensor([30.0320, 40.1417, 50.0026, 60.0831, 70.2693], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 624 - loss : 30395.101303911735\n",
            "\n",
            "tensor([29.9484, 40.0851, 49.9645, 60.0156, 70.1444], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 625 - loss : 30386.200601805416\n",
            "\n",
            "tensor([29.9783, 40.0816, 49.9261, 59.9509, 70.0772], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 626 - loss : 30377.283851554665\n",
            "\n",
            "tensor([29.9819, 40.1132, 49.9945, 60.0350, 70.1754], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 627 - loss : 30368.363089267805\n",
            "\n",
            "tensor([29.9247, 40.0239, 49.8746, 59.8783, 69.9971], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 628 - loss : 30359.434302908725\n",
            "\n",
            "tensor([30.0258, 40.1497, 50.0384, 60.0796, 70.2421], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 629 - loss : 30350.493480441324\n",
            "\n",
            "tensor([29.8921, 39.9905, 49.8575, 59.8509, 69.9679], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 630 - loss : 30341.54262788365\n",
            "\n",
            "tensor([30.0789, 40.1959, 50.1022, 60.1577, 70.3623], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 631 - loss : 30332.581745235708\n",
            "\n",
            "tensor([29.7889, 39.8138, 49.6144, 59.5312, 69.6074], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 632 - loss : 30323.610832497492\n",
            "\n",
            "tensor([30.2937, 40.5169, 50.5630, 60.7322, 71.0400], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 633 - loss : 30314.629889669006\n",
            "\n",
            "tensor([29.6236, 39.5391, 49.2361, 59.0396, 69.0521], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 634 - loss : 30305.642928786358\n",
            "\n",
            "tensor([30.2746, 40.4744, 50.5058, 60.6407, 70.9294], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 635 - loss : 30296.64192577733\n",
            "\n",
            "tensor([29.9052, 40.0040, 49.9208, 59.8918, 70.0113], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 636 - loss : 30287.632898696087\n",
            "\n",
            "tensor([29.8309, 39.8215, 49.6310, 59.5113, 69.5818], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 637 - loss : 30278.615847542627\n",
            "\n",
            "tensor([30.1788, 40.3630, 50.4008, 60.4809, 70.7007], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 638 - loss : 30269.588766298897\n",
            "\n",
            "tensor([29.8264, 39.9027, 49.8238, 59.7434, 69.7979], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 639 - loss : 30260.547642928785\n",
            "\n",
            "tensor([30.0341, 40.0838, 50.0039, 59.9669, 70.1054], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 640 - loss : 30251.500501504514\n",
            "\n",
            "tensor([29.9439, 40.0403, 50.0262, 60.0000, 70.1091], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 641 - loss : 30242.445336008022\n",
            "\n",
            "tensor([29.9476, 40.0366, 50.0335, 60.0112, 70.1249], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 642 - loss : 30233.37813440321\n",
            "\n",
            "tensor([30.0601, 40.0993, 50.0712, 60.0648, 70.2419], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 643 - loss : 30224.304914744233\n",
            "\n",
            "tensor([29.8263, 39.8128, 49.7411, 59.6528, 69.7492], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 644 - loss : 30215.217652958876\n",
            "\n",
            "tensor([30.1300, 40.1974, 50.2374, 60.2779, 70.5060], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 645 - loss : 30206.124373119357\n",
            "\n",
            "tensor([29.9402, 39.8603, 49.7370, 59.6141, 69.7181], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 646 - loss : 30197.019057171514\n",
            "\n",
            "tensor([30.0549, 40.0791, 50.0747, 60.0362, 70.1893], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 647 - loss : 30187.901705115346\n",
            "\n",
            "tensor([30.1799, 40.2237, 50.2552, 60.2656, 70.4944], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 648 - loss : 30178.78034102307\n",
            "\n",
            "tensor([29.7821, 39.6268, 49.4279, 59.1909, 69.2287], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 649 - loss : 30169.64894684052\n",
            "\n",
            "tensor([30.2224, 40.3414, 50.4464, 60.4878, 70.7328], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 650 - loss : 30160.509528585757\n",
            "\n",
            "tensor([29.9779, 40.0145, 50.0226, 59.9350, 70.0641], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 651 - loss : 30151.356068204615\n",
            "\n",
            "tensor([29.8262, 39.7541, 49.6401, 59.4262, 69.4662], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 652 - loss : 30142.194583751254\n",
            "\n",
            "tensor([30.1261, 40.2733, 50.3964, 60.3815, 70.5532], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 653 - loss : 30133.023069207622\n",
            "\n",
            "tensor([29.9248, 40.0082, 50.0570, 59.9341, 69.9965], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 654 - loss : 30123.849548645936\n",
            "\n",
            "tensor([29.9484, 39.9630, 49.9548, 59.7968, 69.8675], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 655 - loss : 30114.655967903713\n",
            "\n",
            "tensor([29.8868, 39.9643, 50.0308, 59.8941, 69.9423], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 656 - loss : 30105.458375125378\n",
            "\n",
            "tensor([30.0960, 40.2229, 50.3608, 60.3125, 70.4539], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 657 - loss : 30096.252758274826\n",
            "\n",
            "tensor([29.8409, 39.8219, 49.8190, 59.6204, 69.6508], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 658 - loss : 30087.035105315947\n",
            "\n",
            "tensor([30.0010, 40.0465, 50.1406, 60.0399, 70.1670], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 659 - loss : 30077.809428284854\n",
            "\n",
            "tensor([29.9836, 39.9717, 50.0099, 59.8521, 69.9356], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 660 - loss : 30068.575727181546\n",
            "\n",
            "tensor([30.0166, 40.0024, 50.0480, 59.8867, 69.9656], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 661 - loss : 30059.327983951855\n",
            "\n",
            "tensor([30.1068, 40.1174, 50.2082, 60.0898, 70.2179], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 662 - loss : 30050.078234704113\n",
            "\n",
            "tensor([29.9064, 39.8054, 49.7750, 59.5182, 69.5310], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 663 - loss : 30040.816449348044\n",
            "\n",
            "tensor([30.1898, 40.2386, 50.3872, 60.3096, 70.4760], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 664 - loss : 30031.544633901703\n",
            "\n",
            "tensor([29.8463, 39.7832, 49.8088, 59.5577, 69.5525], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 665 - loss : 30022.262788365097\n",
            "\n",
            "tensor([30.1401, 40.1486, 50.2664, 60.1362, 70.2580], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 666 - loss : 30012.970912738216\n",
            "\n",
            "tensor([29.7762, 39.7622, 49.8418, 59.5806, 69.5163], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 667 - loss : 30003.669007021064\n",
            "\n",
            "tensor([30.3297, 40.4646, 50.7348, 60.7288, 70.9371], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 668 - loss : 29994.363089267805\n",
            "\n",
            "tensor([29.5661, 39.4356, 49.4168, 59.0324, 68.8660], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 669 - loss : 29985.045135406217\n",
            "\n",
            "tensor([30.1383, 40.2551, 50.5210, 60.4488, 70.5546], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 670 - loss : 29975.71514543631\n",
            "\n",
            "tensor([30.0835, 40.1698, 50.4200, 60.3182, 70.3864], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 671 - loss : 29966.383149448346\n",
            "\n",
            "tensor([29.6538, 39.5440, 49.6061, 59.2788, 69.1377], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 672 - loss : 29957.037111334\n",
            "\n",
            "tensor([30.2270, 40.2798, 50.5513, 60.4950, 70.6325], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 673 - loss : 29947.683049147443\n",
            "\n",
            "tensor([29.8965, 39.8523, 50.0296, 59.8242, 69.7898], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 674 - loss : 29938.316950852557\n",
            "\n",
            "tensor([29.9341, 39.8158, 49.9367, 59.6927, 69.6368], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 675 - loss : 29928.94483450351\n",
            "\n",
            "tensor([30.2279, 40.2133, 50.4745, 60.3897, 70.4818], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 676 - loss : 29919.562688064194\n",
            "\n",
            "tensor([29.8995, 39.7976, 49.9828, 59.7770, 69.7387], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 677 - loss : 29910.170511534605\n",
            "\n",
            "tensor([30.0813, 39.9414, 50.1171, 59.9599, 70.0218], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 678 - loss : 29900.772316950854\n",
            "\n",
            "tensor([29.9792, 39.8269, 50.0024, 59.8167, 69.8441], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 679 - loss : 29891.362086258778\n",
            "\n",
            "tensor([29.9601, 39.8004, 49.9582, 59.7318, 69.7031], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 680 - loss : 29881.943831494482\n",
            "\n",
            "tensor([30.2635, 40.1647, 50.3780, 60.2381, 70.2998], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 681 - loss : 29872.51554663992\n",
            "\n",
            "tensor([30.0129, 39.8963, 50.0823, 59.8592, 69.8179], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 682 - loss : 29863.08324974925\n",
            "\n",
            "tensor([30.0710, 39.9600, 50.1635, 59.9754, 69.9970], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 683 - loss : 29853.636910732195\n",
            "\n",
            "tensor([29.9451, 39.7810, 49.9161, 59.6465, 69.5941], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 684 - loss : 29844.184553660984\n",
            "\n",
            "tensor([29.9689, 39.9215, 50.1600, 59.9499, 69.9073], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 685 - loss : 29834.72417251755\n",
            "\n",
            "tensor([30.1925, 40.2212, 50.5390, 60.4269, 70.4879], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 686 - loss : 29825.24974924774\n",
            "\n",
            "tensor([29.7616, 39.6131, 49.7289, 59.3689, 69.1927], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 687 - loss : 29815.769307923772\n",
            "\n",
            "tensor([30.0700, 40.0881, 50.3801, 60.2089, 70.2067], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 688 - loss : 29806.280842527583\n",
            "\n",
            "tensor([30.0366, 40.0415, 50.3160, 60.1140, 70.0768], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 689 - loss : 29796.786359077232\n",
            "\n",
            "tensor([29.8087, 39.6968, 49.8441, 59.4875, 69.2954], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 690 - loss : 29787.273821464394\n",
            "\n",
            "tensor([30.1715, 40.2255, 50.5603, 60.4138, 70.4169], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 691 - loss : 29777.757271815448\n",
            "\n",
            "tensor([29.9116, 39.8822, 50.1360, 59.8724, 69.7449], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 692 - loss : 29768.238716148444\n",
            "\n",
            "tensor([29.9628, 39.8810, 50.1065, 59.8416, 69.7365], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 693 - loss : 29758.702106318957\n",
            "\n",
            "tensor([29.9392, 39.8965, 50.1795, 59.9449, 69.8402], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 694 - loss : 29749.159478435307\n",
            "\n",
            "tensor([30.0429, 40.0064, 50.3086, 60.1070, 70.0332], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 695 - loss : 29739.608826479438\n",
            "\n",
            "tensor([30.0019, 39.9150, 50.1863, 59.9552, 69.8605], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 696 - loss : 29730.046138415244\n",
            "\n",
            "tensor([29.9418, 39.8208, 50.0771, 59.8212, 69.7033], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 697 - loss : 29720.479438314946\n",
            "\n",
            "tensor([30.0694, 39.9376, 50.1895, 59.9510, 69.8594], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 698 - loss : 29710.902708124373\n",
            "\n",
            "tensor([30.0079, 39.8870, 50.1505, 59.8919, 69.7514], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 699 - loss : 29701.31594784353\n",
            "\n",
            "tensor([30.2026, 40.1150, 50.4332, 60.2603, 70.2196], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 700 - loss : 29691.72116349047\n",
            "\n",
            "tensor([29.8028, 39.5823, 49.7584, 59.3885, 69.1273], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 701 - loss : 29682.118355065195\n",
            "\n",
            "tensor([30.3040, 40.2922, 50.7085, 60.6351, 70.6747], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 702 - loss : 29672.50551654965\n",
            "\n",
            "tensor([29.7356, 39.5544, 49.7915, 59.4569, 69.1932], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 703 - loss : 29662.884653961886\n",
            "\n",
            "tensor([30.1473, 40.0452, 50.3779, 60.2055, 70.1275], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 704 - loss : 29653.255767301907\n",
            "\n",
            "tensor([29.8804, 39.7941, 50.1333, 59.8894, 69.6748], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 705 - loss : 29643.620862587763\n",
            "\n",
            "tensor([30.1556, 40.0942, 50.4726, 60.3230, 70.2263], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 706 - loss : 29633.96990972919\n",
            "\n",
            "tensor([29.8789, 39.7211, 50.0134, 59.7458, 69.5143], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 707 - loss : 29624.314944834503\n",
            "\n",
            "tensor([29.9804, 39.8890, 50.2682, 60.0916, 69.9404], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 708 - loss : 29614.65396188566\n",
            "\n",
            "tensor([30.1067, 39.9904, 50.3563, 60.2036, 70.0961], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 709 - loss : 29604.980942828486\n",
            "\n",
            "tensor([29.8186, 39.6110, 49.8862, 59.5994, 69.3358], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 710 - loss : 29595.299899699097\n",
            "\n",
            "tensor([30.2810, 40.1877, 50.5987, 60.5161, 70.4920], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 711 - loss : 29585.612838515546\n",
            "\n",
            "tensor([29.8194, 39.5364, 49.7345, 59.3816, 69.0584], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 712 - loss : 29575.909729187562\n",
            "\n",
            "tensor([30.2563, 40.1386, 50.5119, 60.3820, 70.2927], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 713 - loss : 29566.198595787362\n",
            "\n",
            "tensor([30.0732, 39.9173, 50.2521, 60.0570, 69.8801], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 714 - loss : 29556.489468405216\n",
            "\n",
            "tensor([29.8889, 39.6452, 49.8888, 59.5960, 69.3131], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 715 - loss : 29546.764292878637\n",
            "\n",
            "tensor([30.1807, 40.0962, 50.5071, 60.4064, 70.3119], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 716 - loss : 29537.033099297892\n",
            "\n",
            "tensor([29.8700, 39.7048, 50.0230, 59.7842, 69.5132], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 717 - loss : 29527.29187562688\n",
            "\n",
            "tensor([30.0810, 39.9343, 50.2714, 60.0956, 69.9030], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 718 - loss : 29517.54262788365\n",
            "\n",
            "tensor([29.9386, 39.8445, 50.2296, 60.0527, 69.8124], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 719 - loss : 29507.785356068205\n",
            "\n",
            "tensor([30.1346, 40.0412, 50.4367, 60.3263, 70.1834], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 720 - loss : 29498.016048144433\n",
            "\n",
            "tensor([29.7915, 39.5810, 49.8601, 59.5971, 69.2774], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 721 - loss : 29488.242728184552\n",
            "\n",
            "tensor([30.1230, 40.0293, 50.4335, 60.3340, 70.1943], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 722 - loss : 29478.459378134405\n",
            "\n",
            "tensor([29.9844, 39.7946, 50.0863, 59.8647, 69.5902], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 723 - loss : 29468.665997993983\n",
            "\n",
            "tensor([30.0668, 39.9094, 50.2335, 60.0506, 69.8115], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 724 - loss : 29458.87261785356\n",
            "\n",
            "tensor([30.1457, 40.0081, 50.3582, 60.2199, 70.0298], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 725 - loss : 29449.063189568707\n",
            "\n",
            "tensor([29.8758, 39.6383, 49.8800, 59.6105, 69.2626], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 726 - loss : 29439.245737211633\n",
            "\n",
            "tensor([30.2275, 40.1479, 50.5588, 60.5016, 70.3789], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 727 - loss : 29429.424272818454\n",
            "\n",
            "tensor([29.8166, 39.6203, 49.9055, 59.6720, 69.3236], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 728 - loss : 29419.586760280843\n",
            "\n",
            "tensor([30.1614, 40.0321, 50.3875, 60.2899, 70.1079], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 729 - loss : 29409.749247743228\n",
            "\n",
            "tensor([29.8278, 39.6867, 50.0185, 59.8240, 69.4788], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 730 - loss : 29399.897693079238\n",
            "\n",
            "tensor([30.2718, 40.1849, 50.5788, 60.5396, 70.3989], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 731 - loss : 29390.038114343028\n",
            "\n",
            "tensor([29.7045, 39.4863, 49.7445, 59.4893, 69.0583], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 732 - loss : 29380.170511534605\n",
            "\n",
            "tensor([30.2676, 40.2432, 50.7139, 60.7497, 70.6516], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 733 - loss : 29370.296890672016\n",
            "\n",
            "tensor([29.8754, 39.6724, 49.9710, 59.8178, 69.4991], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 734 - loss : 29360.41524573721\n",
            "\n",
            "tensor([29.8449, 39.6280, 49.9181, 59.7554, 69.4122], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 735 - loss : 29350.527582748244\n",
            "\n",
            "tensor([30.3431, 40.2711, 50.7100, 60.7585, 70.6612], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 736 - loss : 29340.62186559679\n",
            "\n",
            "tensor([29.8200, 39.5604, 49.8073, 59.6148, 69.2217], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 737 - loss : 29330.716148445335\n",
            "\n",
            "tensor([30.2033, 40.0175, 50.3527, 60.3263, 70.1464], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 738 - loss : 29320.802407221665\n",
            "\n",
            "tensor([29.9834, 39.7689, 50.0747, 59.9885, 69.7132], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 739 - loss : 29310.87662988967\n",
            "\n",
            "tensor([29.9890, 39.7353, 49.9861, 59.8644, 69.5511], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 740 - loss : 29300.94483450351\n",
            "\n",
            "tensor([30.2460, 40.1028, 50.4558, 60.4643, 70.2941], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 741 - loss : 29291.00300902708\n",
            "\n",
            "tensor([29.9193, 39.7028, 49.9747, 59.8671, 69.5398], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 742 - loss : 29281.05516549649\n",
            "\n",
            "tensor([30.1012, 39.8822, 50.1396, 60.0759, 69.8206], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 743 - loss : 29271.10330992979\n",
            "\n",
            "tensor([29.9723, 39.8219, 50.1293, 60.0722, 69.7820], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 744 - loss : 29261.135406218655\n",
            "\n",
            "tensor([30.1403, 40.0293, 50.3656, 60.3770, 70.1754], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 745 - loss : 29251.16549648947\n",
            "\n",
            "tensor([29.8845, 39.6672, 49.8809, 59.7630, 69.4100], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 746 - loss : 29241.181544633902\n",
            "\n",
            "tensor([30.0235, 39.9137, 50.2174, 60.1901, 69.9280], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 747 - loss : 29231.193580742227\n",
            "\n",
            "tensor([30.1363, 40.0225, 50.3017, 60.2792, 70.0349], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 748 - loss : 29221.19558676028\n",
            "\n",
            "tensor([29.8374, 39.6372, 49.8078, 59.6406, 69.2056], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 749 - loss : 29211.19558676028\n",
            "\n",
            "tensor([30.3048, 40.2962, 50.6526, 60.7252, 70.5684], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 750 - loss : 29201.181544633902\n",
            "\n",
            "tensor([29.8132, 39.6596, 49.8674, 59.7547, 69.3504], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 751 - loss : 29191.159478435307\n",
            "\n",
            "tensor([30.0257, 39.9231, 50.1886, 60.1861, 69.9134], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 752 - loss : 29181.129388164492\n",
            "\n",
            "tensor([29.9372, 39.8726, 50.1753, 60.1865, 69.8909], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 753 - loss : 29171.095285857573\n",
            "\n",
            "tensor([30.0142, 39.9142, 50.1810, 60.1965, 69.9120], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 754 - loss : 29161.051153460383\n",
            "\n",
            "tensor([29.9804, 39.8734, 50.1467, 60.1757, 69.8936], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 755 - loss : 29150.994984954865\n",
            "\n",
            "tensor([29.9914, 39.8471, 50.0954, 60.1247, 69.8454], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 756 - loss : 29140.932798395184\n",
            "\n",
            "tensor([30.0116, 39.8116, 50.0022, 59.9993, 69.6893], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 757 - loss : 29130.8665997994\n",
            "\n",
            "tensor([30.1090, 39.9655, 50.2116, 60.2658, 70.0083], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 758 - loss : 29120.792377131394\n",
            "\n",
            "tensor([30.1443, 39.9477, 50.1417, 60.1827, 69.9220], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 759 - loss : 29110.706118355065\n",
            "\n",
            "tensor([29.9096, 39.6644, 49.8028, 59.7687, 69.3952], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 760 - loss : 29100.615847542627\n",
            "\n",
            "tensor([30.3389, 40.2549, 50.5475, 60.7275, 70.6155], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 761 - loss : 29090.51554663992\n",
            "\n",
            "tensor([29.6851, 39.4149, 49.5075, 59.4285, 68.9689], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 762 - loss : 29080.40521564694\n",
            "\n",
            "tensor([30.3870, 40.3252, 50.6073, 60.8131, 70.7229], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 763 - loss : 29070.292878635908\n",
            "\n",
            "tensor([29.6953, 39.5308, 49.6916, 59.6752, 69.2505], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 764 - loss : 29060.16850551655\n",
            "\n",
            "tensor([30.2539, 40.1674, 50.3857, 60.5369, 70.3578], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 765 - loss : 29050.036108324974\n",
            "\n",
            "tensor([29.8864, 39.7848, 49.9853, 60.0638, 69.7449], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 766 - loss : 29039.895687061184\n",
            "\n",
            "tensor([29.9377, 39.8801, 50.1255, 60.2690, 70.0172], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 767 - loss : 29029.749247743228\n",
            "\n",
            "tensor([30.1596, 40.0636, 50.2749, 60.4748, 70.3310], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 768 - loss : 29019.592778335005\n",
            "\n",
            "tensor([29.6405, 39.4109, 49.4947, 59.5142, 69.1198], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 769 - loss : 29009.43229689067\n",
            "\n",
            "tensor([30.3283, 40.2797, 50.5287, 60.7835, 70.7074], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 770 - loss : 28999.26178535607\n",
            "\n",
            "tensor([30.0561, 39.8232, 49.8732, 59.9393, 69.6516], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 771 - loss : 28989.08324974925\n",
            "\n",
            "tensor([29.9216, 39.6869, 49.7182, 59.7432, 69.3889], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 772 - loss : 28978.89669007021\n",
            "\n",
            "tensor([30.5280, 40.5155, 50.7536, 61.0580, 71.0630], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 773 - loss : 28968.706118355065\n",
            "\n",
            "tensor([29.7533, 39.4882, 49.4706, 59.4953, 69.1437], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 774 - loss : 28958.50551654965\n",
            "\n",
            "tensor([29.8500, 39.6460, 49.6537, 59.7133, 69.4034], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 775 - loss : 28948.29889669007\n",
            "\n",
            "tensor([30.4147, 40.4769, 50.6998, 60.9853, 70.9449], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 776 - loss : 28938.078234704113\n",
            "\n",
            "tensor([29.8719, 39.7966, 49.8616, 59.9509, 69.6481], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 777 - loss : 28927.855566700102\n",
            "\n",
            "tensor([29.9314, 39.8349, 49.8666, 59.9801, 69.7310], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 778 - loss : 28917.622868605817\n",
            "\n",
            "tensor([30.0150, 40.0304, 50.1614, 60.3653, 70.2093], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 779 - loss : 28907.38214643932\n",
            "\n",
            "tensor([29.8587, 39.8155, 49.8689, 59.9882, 69.7260], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 780 - loss : 28897.13741223671\n",
            "\n",
            "tensor([30.0965, 40.0580, 50.0979, 60.2502, 70.0573], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 781 - loss : 28886.880641925778\n",
            "\n",
            "tensor([30.0005, 39.9888, 50.0537, 60.2020, 69.9829], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 782 - loss : 28876.623871614844\n",
            "\n",
            "tensor([30.0421, 39.9813, 49.9929, 60.1288, 69.9162], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 783 - loss : 28866.353059177534\n",
            "\n",
            "tensor([29.9942, 39.8986, 49.8677, 59.9747, 69.7305], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 784 - loss : 28856.07221664995\n",
            "\n",
            "tensor([30.0217, 40.0038, 50.0427, 60.1997, 69.9946], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 785 - loss : 28845.789368104313\n",
            "\n",
            "tensor([30.1308, 40.1034, 50.1219, 60.2973, 70.1311], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 786 - loss : 28835.49849548646\n",
            "\n",
            "tensor([29.8418, 39.7526, 49.6994, 59.7781, 69.4721], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 787 - loss : 28825.19959879639\n",
            "\n",
            "tensor([30.1530, 40.2072, 50.2849, 60.5153, 70.3930], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 788 - loss : 28814.894684052157\n",
            "\n",
            "tensor([29.9294, 39.8941, 49.8768, 60.0120, 69.7661], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 789 - loss : 28804.579739217654\n",
            "\n",
            "tensor([29.8728, 39.8355, 49.8087, 59.9283, 69.6487], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 790 - loss : 28794.256770310934\n",
            "\n",
            "tensor([30.2078, 40.3126, 50.4232, 60.7022, 70.6130], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 791 - loss : 28783.92778335005\n",
            "\n",
            "tensor([29.8130, 39.7728, 49.7542, 59.9001, 69.6329], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 792 - loss : 28773.59077231695\n",
            "\n",
            "tensor([29.9827, 39.9474, 49.9476, 60.1603, 69.9891], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 793 - loss : 28763.241725175525\n",
            "\n",
            "tensor([29.9592, 39.9455, 49.9756, 60.1984, 70.0172], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 794 - loss : 28752.892678034103\n",
            "\n",
            "tensor([30.0987, 40.0517, 50.0512, 60.2846, 70.1351], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 795 - loss : 28742.533600802406\n",
            "\n",
            "tensor([30.0063, 39.9291, 49.9155, 60.1379, 69.9670], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 796 - loss : 28732.16850551655\n",
            "\n",
            "tensor([30.0589, 39.9616, 49.9378, 60.1827, 70.0528], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 797 - loss : 28721.79338014042\n",
            "\n",
            "tensor([29.9704, 39.8166, 49.7276, 59.9132, 69.7144], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 798 - loss : 28711.41223671013\n",
            "\n",
            "tensor([30.1640, 40.1111, 50.1049, 60.3700, 70.2641], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 799 - loss : 28701.023069207622\n",
            "\n",
            "tensor([30.0801, 39.9954, 49.9407, 60.1643, 70.0121], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 800 - loss : 28690.627883650952\n",
            "\n",
            "tensor([29.9587, 39.8674, 49.7864, 59.9823, 69.7927], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 801 - loss : 28680.22266800401\n",
            "\n",
            "tensor([30.1066, 40.1177, 50.1137, 60.3950, 70.3109], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 802 - loss : 28669.815446339016\n",
            "\n",
            "tensor([29.8375, 39.7788, 49.6795, 59.8471, 69.6151], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 803 - loss : 28659.39819458375\n",
            "\n",
            "tensor([30.1481, 40.2136, 50.2102, 60.4942, 70.4155], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 804 - loss : 28648.96890672016\n",
            "\n",
            "tensor([29.8200, 39.8401, 49.7770, 59.9605, 69.7320], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 805 - loss : 28638.53961885657\n",
            "\n",
            "tensor([30.2296, 40.3009, 50.2793, 60.5924, 70.5713], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 806 - loss : 28628.100300902708\n",
            "\n",
            "tensor([29.5015, 39.4536, 49.3233, 59.4341, 69.1012], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 807 - loss : 28617.65295887663\n",
            "\n",
            "tensor([30.6063, 40.7775, 50.8510, 61.3162, 71.5013], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 808 - loss : 28607.201604814443\n",
            "\n",
            "tensor([29.4921, 39.3750, 49.1999, 59.3385, 69.0657], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 809 - loss : 28596.73821464393\n",
            "\n",
            "tensor([29.9405, 39.9200, 49.8389, 60.1121, 70.0276], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 810 - loss : 28586.26880641926\n",
            "\n",
            "tensor([30.5041, 40.5681, 50.5630, 60.9769, 71.1053], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 811 - loss : 28575.795386158476\n",
            "\n",
            "tensor([29.6742, 39.5293, 49.3507, 59.5428, 69.3665], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 812 - loss : 28565.311935807422\n",
            "\n",
            "tensor([30.1695, 40.1187, 50.0345, 60.4073, 70.5078], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 813 - loss : 28554.82447342026\n",
            "\n",
            "tensor([30.1420, 40.0216, 49.8651, 60.2038, 70.3022], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 814 - loss : 28544.326980942828\n",
            "\n",
            "tensor([29.6667, 39.4188, 49.1102, 59.2365, 69.0650], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 815 - loss : 28533.823470411233\n",
            "\n",
            "tensor([30.5260, 40.5289, 50.3879, 60.7034, 70.8050], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 816 - loss : 28523.311935807422\n",
            "\n",
            "tensor([30.3334, 40.3460, 50.1637, 60.4067, 70.4214], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 817 - loss : 28512.79438314945\n",
            "\n",
            "tensor([29.6751, 39.5887, 49.2750, 59.3466, 69.1393], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 818 - loss : 28502.26880641926\n",
            "\n",
            "tensor([30.1662, 40.3041, 50.1459, 60.4032, 70.4493], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 819 - loss : 28491.739217652957\n",
            "\n",
            "tensor([29.9111, 40.1234, 49.9909, 60.2062, 70.1665], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 820 - loss : 28481.197592778335\n",
            "\n",
            "tensor([29.6276, 39.8130, 49.6212, 59.7343, 69.5527], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 821 - loss : 28470.649949849547\n",
            "\n",
            "tensor([30.1409, 40.4450, 50.3432, 60.5852, 70.5939], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 822 - loss : 28460.102306920762\n",
            "\n",
            "tensor([29.8230, 40.0695, 49.9267, 60.0867, 69.9718], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 823 - loss : 28449.536609829487\n",
            "\n",
            "tensor([29.7050, 39.8587, 49.6473, 59.7454, 69.5585], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 824 - loss : 28438.970912738216\n",
            "\n",
            "tensor([30.2033, 40.4219, 50.2958, 60.5296, 70.5345], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 825 - loss : 28428.397191574724\n",
            "\n",
            "tensor([29.9079, 40.0521, 49.9077, 60.0943, 70.0119], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 826 - loss : 28417.81745235707\n",
            "\n",
            "tensor([29.8507, 39.8882, 49.6890, 59.8583, 69.7679], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 827 - loss : 28407.225677031092\n",
            "\n",
            "tensor([30.1448, 40.1913, 50.0363, 60.2932, 70.3276], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 828 - loss : 28396.63189568706\n",
            "\n",
            "tensor([29.9270, 39.9282, 49.7700, 59.9873, 69.9422], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 829 - loss : 28386.03009027081\n",
            "\n",
            "tensor([30.0630, 40.0275, 49.8563, 60.0901, 70.0805], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 830 - loss : 28375.424272818454\n",
            "\n",
            "tensor([30.1397, 40.0986, 49.9360, 60.1879, 70.2038], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 831 - loss : 28364.806419257773\n",
            "\n",
            "tensor([29.9591, 39.9239, 49.7806, 60.0157, 69.9854], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 832 - loss : 28354.184553660984\n",
            "\n",
            "tensor([30.1227, 40.1010, 49.9690, 60.2471, 70.2921], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 833 - loss : 28343.552657973923\n",
            "\n",
            "tensor([29.9221, 39.8495, 49.6620, 59.8650, 69.8120], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 834 - loss : 28332.91675025075\n",
            "\n",
            "tensor([29.9861, 39.9964, 49.8677, 60.0882, 70.0344], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 835 - loss : 28322.272818455367\n",
            "\n",
            "tensor([30.2380, 40.3270, 50.2507, 60.5344, 70.5687], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 836 - loss : 28311.620862587763\n",
            "\n",
            "tensor([29.8244, 39.8293, 49.6731, 59.8535, 69.7488], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 837 - loss : 28300.964894684053\n",
            "\n",
            "tensor([29.9422, 40.0170, 49.9252, 60.1774, 70.1636], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 838 - loss : 28290.304914744233\n",
            "\n",
            "tensor([30.0093, 40.1025, 50.0253, 60.3003, 70.3207], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 839 - loss : 28279.632898696087\n",
            "\n",
            "tensor([29.8171, 39.8473, 49.7174, 59.9272, 69.8649], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 840 - loss : 28268.954864593783\n",
            "\n",
            "tensor([30.1367, 40.2205, 50.1491, 60.4535, 70.5338], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 841 - loss : 28258.272818455367\n",
            "\n",
            "tensor([29.9157, 39.8911, 49.7335, 59.9602, 69.9620], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 842 - loss : 28247.578736208627\n",
            "\n",
            "tensor([29.9788, 39.9186, 49.7313, 59.9507, 69.9693], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 843 - loss : 28236.884653961886\n",
            "\n",
            "tensor([30.1971, 40.1882, 50.0432, 60.3137, 70.4095], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 844 - loss : 28226.180541624875\n",
            "\n",
            "tensor([29.9912, 39.9212, 49.7104, 59.9041, 69.9137], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 845 - loss : 28215.472417251756\n",
            "\n",
            "tensor([30.1413, 40.1151, 49.9261, 60.1634, 70.2503], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 846 - loss : 28204.752256770313\n",
            "\n",
            "tensor([29.9661, 39.9633, 49.7759, 59.9838, 70.0256], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 847 - loss : 28194.03009027081\n",
            "\n",
            "tensor([30.0269, 40.0679, 49.8910, 60.1124, 70.1834], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 848 - loss : 28183.29588766299\n",
            "\n",
            "tensor([29.9630, 40.0404, 49.8706, 60.0778, 70.1293], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 849 - loss : 28172.56369107322\n",
            "\n",
            "tensor([29.9577, 40.0735, 49.9178, 60.1275, 70.1868], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 850 - loss : 28161.819458375125\n",
            "\n",
            "tensor([29.9616, 40.0684, 49.8861, 60.0781, 70.1359], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 851 - loss : 28151.067201604816\n",
            "\n",
            "tensor([29.8852, 39.9942, 49.8046, 59.9692, 69.9926], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 852 - loss : 28140.306920762287\n",
            "\n",
            "tensor([30.1035, 40.2576, 50.1034, 60.3228, 70.4333], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 853 - loss : 28129.54262788365\n",
            "\n",
            "tensor([29.8273, 39.8980, 49.6715, 59.8047, 69.8153], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 854 - loss : 28118.77632898696\n",
            "\n",
            "tensor([30.1380, 40.2743, 50.1151, 60.3507, 70.5125], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 855 - loss : 28108.0\n",
            "\n",
            "tensor([29.7727, 39.8012, 49.5512, 59.6702, 69.6884], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 856 - loss : 28097.213640922768\n",
            "\n",
            "tensor([30.2354, 40.3567, 50.1935, 60.4403, 70.6418], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 857 - loss : 28086.42527582748\n",
            "\n",
            "tensor([29.7716, 39.7933, 49.5490, 59.6669, 69.6963], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 858 - loss : 28075.626880641925\n",
            "\n",
            "tensor([30.2929, 40.3962, 50.2255, 60.4833, 70.7299], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 859 - loss : 28064.826479438314\n",
            "\n",
            "tensor([29.6458, 39.6207, 49.3405, 59.4213, 69.4297], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 860 - loss : 28054.016048144433\n",
            "\n",
            "tensor([30.3787, 40.5246, 50.3890, 60.6684, 70.9511], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 861 - loss : 28043.197592778335\n",
            "\n",
            "tensor([29.7202, 39.7150, 49.4449, 59.5343, 69.5751], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 862 - loss : 28032.38114343029\n",
            "\n",
            "tensor([30.1259, 40.2355, 50.0624, 60.2688, 70.4688], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 863 - loss : 28021.54864593781\n",
            "\n",
            "tensor([30.0197, 40.1057, 49.9079, 60.0782, 70.2442], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 864 - loss : 28010.712136409227\n",
            "\n",
            "tensor([29.7965, 39.8298, 49.5815, 59.6785, 69.7617], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 865 - loss : 27999.87362086259\n",
            "\n",
            "tensor([30.2807, 40.4343, 50.2845, 60.5059, 70.7633], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 866 - loss : 27989.023069207622\n",
            "\n",
            "tensor([29.6955, 39.7091, 49.4330, 59.4758, 69.5116], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 867 - loss : 27978.166499498497\n",
            "\n",
            "tensor([30.2354, 40.3699, 50.1864, 60.3526, 70.5606], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 868 - loss : 27967.311935807422\n",
            "\n",
            "tensor([29.8808, 39.9848, 49.7750, 59.8546, 69.9324], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 869 - loss : 27956.441323971914\n",
            "\n",
            "tensor([30.0113, 40.1522, 49.9744, 60.0953, 70.2346], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 870 - loss : 27945.57071213641\n",
            "\n",
            "tensor([29.9761, 40.1272, 49.9699, 60.1057, 70.2678], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 871 - loss : 27934.690070210632\n",
            "\n",
            "tensor([29.7640, 39.8721, 49.6940, 59.7856, 69.8920], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 872 - loss : 27923.803410230692\n",
            "\n",
            "tensor([30.1340, 40.2776, 50.1375, 60.2998, 70.5183], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 873 - loss : 27912.912738214643\n",
            "\n",
            "tensor([29.7757, 39.8188, 49.6079, 59.6548, 69.7235], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 874 - loss : 27902.01003009027\n",
            "\n",
            "tensor([30.2862, 40.4093, 50.2788, 60.4457, 70.6859], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 875 - loss : 27891.107321965897\n",
            "\n",
            "tensor([29.7971, 39.7792, 49.5435, 59.5743, 69.6528], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 876 - loss : 27880.194583751254\n",
            "\n",
            "tensor([30.1533, 40.2402, 50.1075, 60.2531, 70.4736], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 877 - loss : 27869.277833500502\n",
            "\n",
            "tensor([29.9658, 40.0149, 49.8624, 59.9715, 70.1495], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 878 - loss : 27858.35506519559\n",
            "\n",
            "tensor([29.8946, 39.9203, 49.7575, 59.8533, 70.0276], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 879 - loss : 27847.42627883651\n",
            "\n",
            "tensor([30.1073, 40.1842, 50.0702, 60.2205, 70.4729], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 880 - loss : 27836.489468405216\n",
            "\n",
            "tensor([29.8188, 39.7999, 49.6020, 59.6427, 69.7737], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 881 - loss : 27825.544633901703\n",
            "\n",
            "tensor([30.2590, 40.3309, 50.2021, 60.3312, 70.5867], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 882 - loss : 27814.599799398195\n",
            "\n",
            "tensor([29.8269, 39.8216, 49.6250, 59.6344, 69.7378], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 883 - loss : 27803.64493480441\n",
            "\n",
            "tensor([30.2715, 40.3693, 50.2520, 60.3772, 70.6469], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 884 - loss : 27792.68405215647\n",
            "\n",
            "tensor([29.6769, 39.6921, 49.5093, 59.5054, 69.6045], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 885 - loss : 27781.717151454362\n",
            "\n",
            "tensor([30.2520, 40.4180, 50.3580, 60.5116, 70.8177], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 886 - loss : 27770.740220661984\n",
            "\n",
            "tensor([29.6587, 39.6879, 49.5179, 59.5162, 69.6404], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 887 - loss : 27759.76328986961\n",
            "\n",
            "tensor([30.1603, 40.2995, 50.2241, 60.3441, 70.6358], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 888 - loss : 27748.778335005016\n",
            "\n",
            "tensor([29.8767, 39.9026, 49.7357, 59.7516, 69.9465], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 889 - loss : 27737.78736208626\n",
            "\n",
            "tensor([30.0085, 40.0316, 49.8610, 59.8785, 70.1001], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 890 - loss : 27726.79037111334\n",
            "\n",
            "tensor([30.1882, 40.2477, 50.1048, 60.1494, 70.4194], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 891 - loss : 27715.785356068205\n",
            "\n",
            "tensor([29.8597, 39.8293, 49.6052, 59.5438, 69.7058], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 892 - loss : 27704.77632898696\n",
            "\n",
            "tensor([30.2509, 40.3487, 50.2205, 60.2597, 70.5440], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 893 - loss : 27693.761283851556\n",
            "\n",
            "tensor([29.7531, 39.8001, 49.6244, 59.5477, 69.6717], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 894 - loss : 27682.73821464393\n",
            "\n",
            "tensor([30.2428, 40.4355, 50.3726, 60.4307, 70.7210], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 895 - loss : 27671.713139418254\n",
            "\n",
            "tensor([29.5854, 39.6865, 49.5634, 59.4915, 69.6095], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 896 - loss : 27660.68004012036\n",
            "\n",
            "tensor([30.1909, 40.4118, 50.3945, 60.4739, 70.7971], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 897 - loss : 27649.636910732195\n",
            "\n",
            "tensor([29.6071, 39.6524, 49.5103, 59.4242, 69.5646], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 898 - loss : 27638.593781344032\n",
            "\n",
            "tensor([30.2054, 40.3441, 50.2904, 60.3211, 70.6159], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 899 - loss : 27627.540621865595\n",
            "\n",
            "tensor([29.9673, 39.9730, 49.8265, 59.7577, 69.9654], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 900 - loss : 27616.483450351054\n",
            "\n",
            "tensor([30.0036, 39.9863, 49.8370, 59.7650, 69.9871], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 901 - loss : 27605.420260782346\n",
            "\n",
            "tensor([30.2350, 40.2739, 50.1814, 60.1701, 70.4723], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 902 - loss : 27594.353059177534\n",
            "\n",
            "tensor([29.7730, 39.7103, 49.5418, 59.4133, 69.5819], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 903 - loss : 27583.277833500502\n",
            "\n",
            "tensor([30.3075, 40.4151, 50.3819, 60.3948, 70.7187], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 904 - loss : 27572.1925777332\n",
            "\n",
            "tensor([29.6890, 39.7006, 49.5961, 59.4685, 69.6116], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 905 - loss : 27561.107321965897\n",
            "\n",
            "tensor([30.2101, 40.3480, 50.3407, 60.3356, 70.6311], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 906 - loss : 27550.02006018054\n",
            "\n",
            "tensor([29.6987, 39.7597, 49.7069, 59.5935, 69.7482], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 907 - loss : 27538.918756268806\n",
            "\n",
            "tensor([30.1270, 40.2580, 50.2666, 60.2424, 70.5223], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 908 - loss : 27527.815446339016\n",
            "\n",
            "tensor([29.8213, 39.8447, 49.7829, 59.6668, 69.8587], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 909 - loss : 27516.702106318957\n",
            "\n",
            "tensor([30.0505, 40.1006, 50.0722, 59.9931, 70.2412], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 910 - loss : 27505.588766298897\n",
            "\n",
            "tensor([30.0806, 40.0806, 50.0178, 59.9102, 70.1508], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 911 - loss : 27494.463390170513\n",
            "\n",
            "tensor([29.9239, 39.8875, 49.8063, 59.6533, 69.8434], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 912 - loss : 27483.338014042125\n",
            "\n",
            "tensor([30.2772, 40.3363, 50.3369, 60.2773, 70.5810], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 913 - loss : 27472.20260782347\n",
            "\n",
            "tensor([29.6839, 39.6164, 49.5265, 59.3296, 69.4791], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 914 - loss : 27461.06519558676\n",
            "\n",
            "tensor([30.3273, 40.4546, 50.5203, 60.4960, 70.8359], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 915 - loss : 27449.919759277833\n",
            "\n",
            "tensor([29.6031, 39.5777, 49.5347, 59.3389, 69.4797], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 916 - loss : 27438.772316950854\n",
            "\n",
            "tensor([30.2825, 40.3944, 50.4559, 60.4056, 70.7316], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 917 - loss : 27427.6148445336\n",
            "\n",
            "tensor([29.6909, 39.6799, 49.6621, 59.4715, 69.6358], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 918 - loss : 27416.455366098297\n",
            "\n",
            "tensor([30.2138, 40.2723, 50.3069, 60.2088, 70.5109], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 919 - loss : 27405.28184553661\n",
            "\n",
            "tensor([29.8660, 39.8231, 49.7883, 59.5886, 69.7911], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 920 - loss : 27394.11033099298\n",
            "\n",
            "tensor([30.0904, 40.0955, 50.0997, 59.9362, 70.1884], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 921 - loss : 27382.93079237713\n",
            "\n",
            "tensor([30.1019, 40.0869, 50.0712, 59.8828, 70.1228], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 922 - loss : 27371.74523570712\n",
            "\n",
            "tensor([29.8727, 39.8501, 49.8342, 59.5995, 69.7741], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 923 - loss : 27360.55767301906\n",
            "\n",
            "tensor([30.2715, 40.3738, 50.4551, 60.3284, 70.6261], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 924 - loss : 27349.36409227683\n",
            "\n",
            "tensor([29.5806, 39.5422, 49.5261, 59.2434, 69.3634], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 925 - loss : 27338.16248746239\n",
            "\n",
            "tensor([30.3221, 40.4949, 50.6443, 60.5486, 70.8688], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 926 - loss : 27326.954864593783\n",
            "\n",
            "tensor([29.6050, 39.5994, 49.6301, 59.3583, 69.4823], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 927 - loss : 27315.743229689066\n",
            "\n",
            "tensor([30.1863, 40.2743, 50.3826, 60.2273, 70.5023], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 928 - loss : 27304.52557673019\n",
            "\n",
            "tensor([29.8543, 39.8594, 49.9302, 59.6976, 69.8870], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 929 - loss : 27293.297893681043\n",
            "\n",
            "tensor([30.0525, 40.0271, 50.0845, 59.8675, 70.1127], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 930 - loss : 27282.07221664995\n",
            "\n",
            "tensor([30.0354, 39.9750, 50.0180, 59.7760, 70.0071], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 931 - loss : 27270.83851554664\n",
            "\n",
            "tensor([30.0187, 39.9478, 49.9878, 59.7208, 69.9233], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 932 - loss : 27259.592778335005\n",
            "\n",
            "tensor([30.2108, 40.1749, 50.2382, 59.9981, 70.2371], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 933 - loss : 27248.35506519559\n",
            "\n",
            "tensor([29.8364, 39.7828, 49.8471, 59.5489, 69.6996], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 934 - loss : 27237.10330992979\n",
            "\n",
            "tensor([30.2397, 40.3101, 50.4716, 60.2922, 70.5806], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 935 - loss : 27225.843530591774\n",
            "\n",
            "tensor([29.5385, 39.4780, 49.5548, 59.2211, 69.3237], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 936 - loss : 27214.583751253762\n",
            "\n",
            "tensor([30.3805, 40.5347, 50.7715, 60.6361, 70.9587], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 937 - loss : 27203.31594784353\n",
            "\n",
            "tensor([29.5487, 39.4748, 49.5584, 59.2084, 69.3011], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 938 - loss : 27192.042126379136\n",
            "\n",
            "tensor([30.2849, 40.3318, 50.5058, 60.3013, 70.5834], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 939 - loss : 27180.764292878637\n",
            "\n",
            "tensor([29.8445, 39.7830, 49.8980, 59.5863, 69.7507], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 940 - loss : 27169.482447342027\n",
            "\n",
            "tensor([30.0974, 40.0216, 50.1263, 59.8386, 70.0700], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 941 - loss : 27158.190571715146\n",
            "\n",
            "tensor([30.0678, 39.9801, 50.0824, 59.7740, 69.9911], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 942 - loss : 27146.898696088265\n",
            "\n",
            "tensor([29.9850, 39.8826, 49.9707, 59.6206, 69.7917], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 943 - loss : 27135.598796389168\n",
            "\n",
            "tensor([30.2326, 40.1945, 50.3167, 60.0039, 70.2189], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 944 - loss : 27124.290872617854\n",
            "\n",
            "tensor([29.8082, 39.7662, 49.8962, 59.5167, 69.6221], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 945 - loss : 27112.98294884654\n",
            "\n",
            "tensor([30.2438, 40.3354, 50.5633, 60.3109, 70.5658], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 946 - loss : 27101.664994984956\n",
            "\n",
            "tensor([29.4941, 39.4523, 49.6011, 59.1938, 69.2579], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 947 - loss : 27090.34704112337\n",
            "\n",
            "tensor([30.3113, 40.4688, 50.7625, 60.5431, 70.8189], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 948 - loss : 27079.021063189568\n",
            "\n",
            "tensor([29.6267, 39.5710, 49.7256, 59.3164, 69.3893], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 949 - loss : 27067.69107321966\n",
            "\n",
            "tensor([30.1764, 40.1889, 50.3983, 60.0872, 70.2937], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 950 - loss : 27056.353059177534\n",
            "\n",
            "tensor([30.0018, 39.9466, 50.1280, 59.7675, 69.9258], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 951 - loss : 27045.011033099297\n",
            "\n",
            "tensor([29.9787, 39.8476, 49.9824, 59.5878, 69.7388], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 952 - loss : 27033.664994984956\n",
            "\n",
            "tensor([30.1779, 40.0947, 50.2719, 59.9190, 70.1182], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 953 - loss : 27022.30892678034\n",
            "\n",
            "tensor([29.9205, 39.7923, 49.9403, 59.5168, 69.6254], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 954 - loss : 27010.95285857573\n",
            "\n",
            "tensor([30.2497, 40.2120, 50.4180, 60.0666, 70.2562], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 955 - loss : 26999.588766298897\n",
            "\n",
            "tensor([29.7537, 39.6912, 49.8982, 59.4727, 69.5428], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 956 - loss : 26988.224674022065\n",
            "\n",
            "tensor([30.2386, 40.2920, 50.5789, 60.2748, 70.4965], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 957 - loss : 26976.850551654967\n",
            "\n",
            "tensor([29.5116, 39.4313, 49.6416, 59.1818, 69.2058], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 958 - loss : 26965.472417251756\n",
            "\n",
            "tensor([30.4119, 40.5224, 50.8618, 60.5921, 70.8480], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 959 - loss : 26954.090270812438\n",
            "\n",
            "tensor([29.5629, 39.4211, 49.5966, 59.1001, 69.1070], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 960 - loss : 26942.702106318957\n",
            "\n",
            "tensor([30.3097, 40.3092, 50.5821, 60.2331, 70.4227], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 961 - loss : 26931.307923771314\n",
            "\n",
            "tensor([29.9566, 39.8681, 50.0975, 59.6675, 69.7619], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 962 - loss : 26919.90772316951\n",
            "\n",
            "tensor([29.9627, 39.8306, 50.0354, 59.5923, 69.6946], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 963 - loss : 26908.507522567703\n",
            "\n",
            "tensor([30.1632, 40.0957, 50.3515, 59.9568, 70.1139], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 964 - loss : 26897.095285857573\n",
            "\n",
            "tensor([29.8394, 39.6978, 49.8996, 59.4075, 69.4469], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 965 - loss : 26885.683049147443\n",
            "\n",
            "tensor([30.3025, 40.2714, 50.5346, 60.1259, 70.2638], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 966 - loss : 26874.266800401205\n",
            "\n",
            "tensor([29.7621, 39.6923, 49.9471, 59.4505, 69.4482], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 967 - loss : 26862.83851554664\n",
            "\n",
            "tensor([30.2482, 40.2941, 50.6286, 60.2561, 70.4092], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 968 - loss : 26851.41223671013\n",
            "\n",
            "tensor([29.5292, 39.4566, 49.7378, 59.2361, 69.2108], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 969 - loss : 26839.97592778335\n",
            "\n",
            "tensor([30.2799, 40.3665, 50.7568, 60.4134, 70.5819], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 970 - loss : 26828.537612838514\n",
            "\n",
            "tensor([29.6879, 39.5699, 49.8318, 59.3175, 69.2946], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 971 - loss : 26817.09327983952\n",
            "\n",
            "tensor([30.1786, 40.1365, 50.4555, 60.0277, 70.1174], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 972 - loss : 26805.64493480441\n",
            "\n",
            "tensor([30.0736, 39.9672, 50.2554, 59.7874, 69.8378], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 973 - loss : 26794.190571715146\n",
            "\n",
            "tensor([29.9074, 39.7295, 49.9801, 59.4646, 69.4656], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 974 - loss : 26782.730190571714\n",
            "\n",
            "tensor([30.2672, 40.2011, 50.5365, 60.1165, 70.2220], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 975 - loss : 26771.267803410232\n",
            "\n",
            "tensor([29.7651, 39.5940, 49.8676, 59.3350, 69.2921], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 976 - loss : 26759.801404212638\n",
            "\n",
            "tensor([30.2881, 40.2533, 50.6133, 60.1976, 70.2930], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 977 - loss : 26748.324974924773\n",
            "\n",
            "tensor([29.6928, 39.5860, 49.9186, 59.3994, 69.3355], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 978 - loss : 26736.84854563691\n",
            "\n",
            "tensor([30.2972, 40.2974, 50.6930, 60.2949, 70.3974], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 979 - loss : 26725.366098294886\n",
            "\n",
            "tensor([29.5488, 39.4089, 49.7364, 59.1906, 69.0890], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 980 - loss : 26713.877632898697\n",
            "\n",
            "tensor([30.4126, 40.4346, 50.8600, 60.4785, 70.5983], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 981 - loss : 26702.3851554664\n",
            "\n",
            "tensor([29.6285, 39.4274, 49.7168, 59.1378, 69.0152], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 982 - loss : 26690.88665997994\n",
            "\n",
            "tensor([30.2980, 40.2521, 50.6436, 60.2027, 70.2511], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 983 - loss : 26679.38214643932\n",
            "\n",
            "tensor([29.9899, 39.8599, 50.2077, 59.6978, 69.6576], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 984 - loss : 26667.875626880643\n",
            "\n",
            "tensor([29.8735, 39.7119, 50.0493, 59.5189, 69.4514], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 985 - loss : 26656.36108324975\n",
            "\n",
            "tensor([30.2503, 40.1993, 50.6126, 60.1713, 70.2094], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 986 - loss : 26644.84854563691\n",
            "\n",
            "tensor([29.6937, 39.5028, 49.8276, 59.2463, 69.1019], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 987 - loss : 26633.3259779338\n",
            "\n",
            "tensor([30.3691, 40.3364, 50.7514, 60.2997, 70.3201], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 988 - loss : 26621.79739217653\n",
            "\n",
            "tensor([29.7173, 39.5956, 49.9773, 59.4165, 69.2616], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 989 - loss : 26610.26479438315\n",
            "\n",
            "tensor([30.2506, 40.2273, 50.6719, 60.2298, 70.2353], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 990 - loss : 26598.734202607822\n",
            "\n",
            "tensor([29.6151, 39.4913, 49.9065, 59.3689, 69.2188], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 991 - loss : 26587.191574724173\n",
            "\n",
            "tensor([30.2216, 40.1935, 50.6667, 60.2354, 70.2359], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 992 - loss : 26575.64894684052\n",
            "\n",
            "tensor([29.8007, 39.6124, 49.9876, 59.4278, 69.2710], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 993 - loss : 26564.098294884654\n",
            "\n",
            "tensor([30.1805, 40.0626, 50.4852, 59.9873, 69.9121], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 994 - loss : 26552.541624874622\n",
            "\n",
            "tensor([30.1188, 39.9494, 50.3420, 59.8139, 69.7045], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 995 - loss : 26540.98294884654\n",
            "\n",
            "tensor([29.8695, 39.6654, 50.0510, 59.4889, 69.3161], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 996 - loss : 26529.418254764292\n",
            "\n",
            "tensor([30.2999, 40.2407, 50.7266, 60.2852, 70.2521], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 997 - loss : 26517.851554663994\n",
            "\n",
            "tensor([29.6052, 39.3971, 49.8026, 59.2263, 68.9953], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 998 - loss : 26506.280842527583\n",
            "\n",
            "tensor([30.3546, 40.3322, 50.8483, 60.4289, 70.4020], grad_fn=<SliceBackward>)\n",
            "tensor([30., 40., 50., 60., 70.])\n",
            "Epoch : 999 - loss : 26494.69809428285\n",
            "\n",
            "Elapsed time : 10.65470838546753s\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 433
        },
        "id": "WhYYlwUdIfGB",
        "outputId": "1ec97d63-3844-4dea-e8a6-bc4055a654f4"
      },
      "source": [
        "if mode == \"single\":\n",
        "    # plot prediction\n",
        "    g = sns.FacetGrid(df, col=name_var1)\n",
        "    def dual_plot(gen_y, **kwargs):\n",
        "        plt.plot(gen_y, label = \"generated\")\n",
        "        plt.plot([10*i for i in range(1, len(gen_y)+1)], label = \"y=x\")\n",
        "        plt.legend(loc='upper left')\n",
        "    g.map(dual_plot, 'gen_y')\n",
        "\n",
        "    # plot loss\n",
        "    loss_g = sns.FacetGrid(loss_df, col=name_var1)\n",
        "    loss_g.map(plt.plot, 'loss')"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 648x216 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 648x216 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}