Delete Bass (1).ipynb

Bass (1).ipynb

@@ -1,459 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "UK8TSMbvp3zZ"
-      },
-      "outputs": [],
-      "source": [
-        "path = r'D:\\Github\\階層化多変量BASSモデル\\bog_cats_data_all.xlsx'"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "l678Xe5Np3zb",
-        "outputId": "4663089e-c45e-45b0-df44-72d22dedcc35"
-      },
-      "outputs": [
-        {
-          "data": {
-            "text/plain": [
-              "tensor([[0., 1., 0., 0., 0.],\n",
-              "        [0., 1., 0., 0., 0.],\n",
-              "        [0., 1., 0., 0., 0.],\n",
-              "        [0., 1., 0., 0., 0.],\n",
-              "        [0., 1., 0., 0., 0.],\n",
-              "        [0., 1., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [1., 0., 0., 0., 0.],\n",
-              "        [1., 0., 0., 0., 0.],\n",
-              "        [1., 0., 0., 0., 0.],\n",
-              "        [1., 0., 0., 0., 0.],\n",
-              "        [1., 0., 0., 0., 0.],\n",
-              "        [1., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 0., 0.],\n",
-              "        [0., 0., 0., 1., 0.],\n",
-              "        [0., 0., 0., 1., 0.],\n",
-              "        [0., 0., 0., 1., 0.],\n",
-              "        [0., 0., 0., 1., 0.],\n",
-              "        [0., 0., 0., 1., 0.],\n",
-              "        [0., 0., 0., 1., 0.]])"
-            ]
-          },
-          "execution_count": 684,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "import pandas as pd\n",
-        "df = pd.read_excel(path, sheet_name='std')\n",
-        "\n",
-        "detect_columns = ['Ninchi', 'Kyoumi','TVshow', 'Gekijoyokoku']\n",
-        "cols = []\n",
-        "\n",
-        "for col in df.columns:\n",
-        "    for detect_col in detect_columns:\n",
-        "        if detect_col in col:\n",
-        "            cols.append(col)\n",
-        "\n",
-        "col_d = torch.zeros(len(cols), 5)\n",
-        "\n",
-        "# dummies\n",
-        "for i, col in enumerate(cols):\n",
-        "    if 'IyokuOverNinchi'in col:\n",
-        "        col_d[i, 0] = 1\n",
-        "    elif 'Ninchi' in col:\n",
-        "        col_d[i, 1] = 1\n",
-        "    elif 'Kyomi' in col:\n",
-        "        col_d[i, 2] = 1\n",
-        "    elif 'TVshow' in col:\n",
-        "        col_d[i, 3] = 1\n",
-        "col_d\n",
-        ""
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "nu9l0fPtp3zb"
-      },
-      "outputs": [],
-      "source": [
-        "import torch"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "mNNXxXN1p3zb",
-        "outputId": "56bf5a96-16f8-4184-ea8c-7dedb21bbe69"
-      },
-      "outputs": [
-        {
-          "data": {
-            "text/plain": [
-              "torch.Size([268, 6, 7])"
-            ]
-          },
-          "execution_count": 685,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "import torch\n",
-        "time_lag = 6\n",
-        "\n",
-        "# create a time-lagged dataset (batch, time_lag, features)\n",
-        "def create_time_lagged_data(x, time_lag, val=2, col_d=None):\n",
-        "    # fill nan with 0 for start part\n",
-        "    x = pd.Series(x).fillna(0).values\n",
-        "    start = 0\n",
-        "    for start in range(len(x)):\n",
-        "        if x[start] != 0:\n",
-        "            break\n",
-        "    for stops in range(len(x), 0, -1):\n",
-        "        if x[stops-1] != 0:\n",
-        "            break\n",
-        "    x = x[start:stops]\n",
-        "\n",
-        "    data = torch.zeros(len(x)-time_lag, time_lag, 2+len(col_d))\n",
-        "    # [0, 0, 1]をデータ毎にrepeat\n",
-        "    col_d = torch.cat([col_d.repeat(i+1, 1) for i in range(len(x))])\n",
-        "    for i in range(len(x)-time_lag):\n",
-        "        data[i,:,0] = torch.tensor(x[i:i+time_lag]) * 10\n",
-        "        # 公開時期\n",
-        "        data[i,:,1] = torch.tensor(range(i, i+time_lag))\n",
-        "        data[i,:,2:] = col_d[i:i+time_lag]\n",
-        "    train_d = data[:-val]\n",
-        "    val_d = data[-val:]\n",
-        "    return train_d, val_d\n",
-        "\n",
-        "dfs = []\n",
-        "val_dfs = []\n",
-        "for col,col_type in zip(cols,col_d):\n",
-        "    d = create_time_lagged_data(df[col].values, time_lag, col_d=col_type)\n",
-        "    dfs.append(d[0])\n",
-        "    val_dfs.append(d[1])\n",
-        "\n",
-        "dfs_t = torch.cat(dfs, dim=0)\n",
-        "val_dfs_t = torch.cat(val_dfs, dim=0)\n",
-        "dfs_t.shape"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "2eJUTqJWp3zc"
-      },
-      "outputs": [],
-      "source": [
-        "# LSTM\n",
-        "import torch.nn as nn\n",
-        "from torch.functional import F\n",
-        "# relu\n",
-        "\n",
-        "\n",
-        "class LSTM(nn.Module):\n",
-        "    def __init__(self, input_size, hidden_size, num_layers, output_size):\n",
-        "        super(LSTM, self).__init__()\n",
-        "        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)\n",
-        "        self.fc = nn.Linear(hidden_size, hidden_size)\n",
-        "        self.output = nn.Linear(hidden_size, output_size)\n",
-        "        #self.norm = nn.BatchNorm1d(hidden_size)\n",
-        "        self.layer_norm = nn.LayerNorm(hidden_size)\n",
-        "\n",
-        "\n",
-        "    def forward(self, x):\n",
-        "        out, _ = self.lstm(x, None)\n",
-        "        out = self.layer_norm(F.relu(self.fc(out[:, -1, :])))\n",
-        "        out = self.output(out)\n",
-        "        return out"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "oItavj7kp3zc"
-      },
-      "outputs": [],
-      "source": [
-        "# dataloader\n",
-        "from torch.utils.data import DataLoader, TensorDataset\n",
-        "\n",
-        "train_loader = DataLoader(TensorDataset(dfs_t), batch_size=8, shuffle=True)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "McVizErzp3zc",
-        "outputId": "50cf1b19-ccdf-4459-cb20-ca77f36f3d74"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "epoch 0, loss 11.606//test loss 6.443\n",
-            "epoch 5, loss 2.083//test loss 1.252\n",
-            "epoch 10, loss 1.142//test loss 0.802\n",
-            "epoch 15, loss 0.985//test loss 0.738\n",
-            "epoch 20, loss 0.891//test loss 0.706\n",
-            "epoch 25, loss 0.857//test loss 0.627\n",
-            "epoch 30, loss 0.875//test loss 0.813\n",
-            "epoch 35, loss 0.758//test loss 0.595\n",
-            "epoch 40, loss 0.729//test loss 0.686\n",
-            "epoch 45, loss 0.705//test loss 0.618\n",
-            "epoch 50, loss 0.835//test loss 0.595\n",
-            "epoch 55, loss 0.524//test loss 0.600\n",
-            "epoch 60, loss 0.494//test loss 0.848\n",
-            "epoch 65, loss 0.665//test loss 0.630\n",
-            "epoch 70, loss 0.532//test loss 0.801\n",
-            "epoch 75, loss 0.421//test loss 0.697\n",
-            "epoch 80, loss 0.433//test loss 0.747\n",
-            "epoch 85, loss 0.401//test loss 0.723\n",
-            "epoch 90, loss 0.437//test loss 0.902\n",
-            "epoch 95, loss 0.433//test loss 0.869\n",
-            "epoch 100, loss 0.324//test loss 0.799\n",
-            "epoch 105, loss 0.326//test loss 0.624\n",
-            "epoch 110, loss 0.343//test loss 0.735\n",
-            "epoch 115, loss 0.499//test loss 0.845\n",
-            "epoch 120, loss 0.317//test loss 0.823\n",
-            "epoch 125, loss 0.591//test loss 0.787\n",
-            "epoch 130, loss 0.281//test loss 0.693\n",
-            "epoch 135, loss 0.395//test loss 0.824\n",
-            "epoch 140, loss 0.289//test loss 0.809\n",
-            "epoch 145, loss 0.250//test loss 0.653\n",
-            "epoch 150, loss 0.261//test loss 0.863\n",
-            "epoch 155, loss 0.265//test loss 0.782\n",
-            "epoch 160, loss 0.253//test loss 0.799\n",
-            "epoch 165, loss 0.251//test loss 0.564\n",
-            "epoch 170, loss 0.248//test loss 0.793\n",
-            "epoch 175, loss 0.519//test loss 0.867\n",
-            "epoch 180, loss 0.242//test loss 0.719\n",
-            "epoch 185, loss 0.248//test loss 0.789\n",
-            "epoch 190, loss 0.229//test loss 0.773\n",
-            "epoch 195, loss 0.245//test loss 0.688\n",
-            "epoch 200, loss 0.257//test loss 0.709\n",
-            "epoch 205, loss 0.384//test loss 0.828\n",
-            "epoch 210, loss 0.212//test loss 0.593\n",
-            "epoch 215, loss 0.223//test loss 0.660\n",
-            "epoch 220, loss 0.194//test loss 0.558\n",
-            "epoch 225, loss 0.200//test loss 0.860\n",
-            "epoch 230, loss 0.180//test loss 0.837\n",
-            "epoch 235, loss 0.220//test loss 0.599\n",
-            "epoch 240, loss 0.219//test loss 0.977\n",
-            "epoch 245, loss 0.174//test loss 0.603\n",
-            "epoch 250, loss 0.154//test loss 0.729\n",
-            "epoch 255, loss 0.162//test loss 0.642\n",
-            "epoch 260, loss 0.167//test loss 0.569\n",
-            "epoch 265, loss 0.162//test loss 0.569\n",
-            "epoch 270, loss 0.130//test loss 0.674\n",
-            "epoch 275, loss 0.150//test loss 0.581\n",
-            "epoch 280, loss 0.352//test loss 0.722\n",
-            "epoch 285, loss 0.224//test loss 0.801\n",
-            "epoch 290, loss 0.211//test loss 0.707\n",
-            "epoch 295, loss 0.150//test loss 0.692\n",
-            "epoch 300, loss 0.125//test loss 0.603\n",
-            "epoch 305, loss 0.121//test loss 0.614\n",
-            "epoch 310, loss 0.117//test loss 0.594\n",
-            "epoch 315, loss 0.116//test loss 0.680\n",
-            "epoch 320, loss 0.121//test loss 0.643\n",
-            "epoch 325, loss 0.134//test loss 0.644\n",
-            "epoch 330, loss 0.183//test loss 0.763\n",
-            "Best Epoch: 44\n"
-          ]
-        },
-        {
-          "data": {
-            "text/plain": [
-              "<All keys matched successfully>"
-            ]
-          },
-          "execution_count": 688,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "# Training\n",
-        "import torch.optim as optim\n",
-        "\n",
-        "input_size = dfs_t.shape[2]\n",
-        "hidden_size = 64\n",
-        "num_layers = 1\n",
-        "output_size = 1\n",
-        "num_epochs = 331\n",
-        "learning_rate = 5e-4\n",
-        "\n",
-        "# seed\n",
-        "torch.manual_seed(0)\n",
-        "torch.cuda.manual_seed(0)\n",
-        "\n",
-        "model = LSTM(input_size, hidden_size, num_layers, output_size)\n",
-        "criterion = nn.MSELoss()\n",
-        "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n",
-        "\n",
-        "rmses = []\n",
-        "for epoch in range(num_epochs):\n",
-        "    total_loss = 0\n",
-        "    model.train()\n",
-        "    for t in train_loader:\n",
-        "        x = t[0][:,:-1,:]\n",
-        "        y = t[0][:,-1,:1]\n",
-        "        #print(f'x: {x}, y: {y}')\n",
-        "        outputs = model(x)\n",
-        "        optimizer.zero_grad()\n",
-        "        loss = criterion(outputs, y)\n",
-        "        loss.backward()\n",
-        "        optimizer.step()\n",
-        "        total_loss += loss.item()\n",
-        "\n",
-        "    if epoch % 5 == 0:\n",
-        "        print('epoch {}, loss {:.3f}'.format(epoch, total_loss / len(train_loader)), end='//')\n",
-        "\n",
-        "        # test\n",
-        "        model.eval()\n",
-        "        x = val_dfs_t[:, :-1, :]\n",
-        "        y = val_dfs_t[:, -1, :1]\n",
-        "        outputs = model(x)\n",
-        "        loss = criterion(outputs, y)\n",
-        "        rmses.append(loss.item())\n",
-        "        if loss.item() == min(rmses):\n",
-        "            torch.save(model.state_dict(), 'best.pth')\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "        print('test loss {:.3f}'.format(loss.item()))\n",
-        "\n",
-        "\n",
-        "# load best\n",
-        "print(f'Best Epoch: {rmses.index(min(rmses))}')\n",
-        "model.load_state_dict(torch.load('best.pth'))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "ccbxnVyQp3zc"
-      },
-      "outputs": [],
-      "source": [
-        "# 予測\n",
-        "# one-step forecast\n",
-        "\n",
-        "\n",
-        "\n",
-        "\n",
-        "pred_length = 10\n",
-        "\n",
-        "def one_step_predict(model, x, pred_length, col_d=None):\n",
-        "    preds = []\n",
-        "    model.eval()\n",
-        "    for i in range(pred_length):\n",
-        "        pred = model(x)\n",
-        "        preds.append(pred)\n",
-        "        new_line = torch.tensor([pred[0, 0], x[0, -1, 1]+1, *col_d])\n",
-        "\n",
-        "        x = torch.cat([x[:, 1:, :], new_line.unsqueeze(0).unsqueeze(0)], dim=1)\n",
-        "\n",
-        "    preds = torch.cat(preds, dim=1)\n",
-        "    preds = preds.detach().numpy()\n",
-        "    preds = preds.reshape(-1)\n",
-        "    return preds\n",
-        "\n",
-        "import numpy as np\n",
-        "import japanize_matplotlib\n",
-        "def plot_one_step_predict(model, x, pred_length, show=True, title='', val=None, col_d=None):\n",
-        "    preds = one_step_predict(model, x[-1,1:].unsqueeze(0), pred_length, col_d)\n",
-        "    plt.plot(np.arange(len(x)), x[:, -1, 0].numpy())\n",
-        "    # preds = last value of x + preds\n",
-        "    # plt scatter for validation datasets (3 dates after the last date)\n",
-        "    if val is not None:\n",
-        "        plt.scatter(np.arange(len(x), len(x)+val.shape[0]), val[:, -1, 0].numpy().reshape(-1), color='red')\n",
-        "\n",
-        "    preds = np.concatenate([x[-1, -1, 0].numpy().reshape(-1), preds])\n",
-        "    plt.plot(np.arange(len(x)-1, len(x)+pred_length), preds)\n",
-        "    plt.xticks(np.arange(len(x)+pred_length), np.arange(len(x)+pred_length))\n",
-        "    plt.title(title)\n",
-        "    plt.ylabel('Value')\n",
-        "    plt.xlabel('Release time')\n",
-        "    if show:\n",
-        "        plt.tight_layout()\n",
-        "        plt.show()\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "d1KwJXXxp3zd"
-      },
-      "outputs": [],
-      "source": [
-        "plt.figure(figsize=(8, 8))\n",
-        "\n",
-        "counter = 0\n",
-        "for i0, col in enumerate(cols):\n",
-        "    if i0 == 18:\n",
-        "        plt.tight_layout()\n",
-        "        plt.show()\n",
-        "        counter = 0\n",
-        "        plt.figure(figsize=(8, 8))\n",
-        "    plt.subplot(6, 3, counter+1)\n",
-        "    plot_one_step_predict(model, dfs[i0], 10, show=False, title=col, val=val_dfs[i0], col_d=col_d[i0])\n",
-        "    counter += 1\n",
-        "plt.tight_layout()\n",
-        "plt.show()"
-      ]
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "base",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.11.4"
-    },
-    "colab": {
-      "provenance": []
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}