userAdapted_MenuRecommender.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rcdXfDkW-hEz",
        "outputId": "a319400b-7bfc-40fb-8b57-1f3cde36b94b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 530,
      "metadata": {
        "id": "feCVLT1D0xrM"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from collections import deque\n",
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "import gym\n",
        "from gym import spaces\n",
        "\n",
        "from sklearn.preprocessing import LabelEncoder"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 531,
      "metadata": {
        "id": "59QG6fPW0_Um"
      },
      "outputs": [],
      "source": [
        "class ReplayBuffer:\n",
        "    def __init__(self, capacity):\n",
        "        self.buffer = deque(maxlen=capacity)\n",
        "\n",
        "    def push(self, state, action, reward, next_state, done):\n",
        "        self.buffer.append((state, action, reward, next_state, done))\n",
        "\n",
        "    def sample(self, batch_size):\n",
        "        my_buffer = []\n",
        "        for i in range(batch_size):\n",
        "            my_buffer.append(self.buffer[-batch_size+i])\n",
        "        return my_buffer\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.buffer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 532,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RZq13-xi6mwA",
        "outputId": "bd6b4e03-af6b-4e34-8f20-985338a72395"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{0: '1명 닭꼬치',\n",
              " 1: '간장치킨',\n",
              " 2: '갈비탕',\n",
              " 3: '강된장보리밥',\n",
              " 4: '고구마치즈돈가스',\n",
              " 5: '고구마피자',\n",
              " 6: '고기',\n",
              " 7: '고등어회',\n",
              " 8: '곱창',\n",
              " 9: '국밥',\n",
              " 10: '김치볶음밥',\n",
              " 11: '김치전',\n",
              " 12: '김치찌개',\n",
              " 13: '낙곱새',\n",
              " 14: '냉면',\n",
              " 15: '냉소바',\n",
              " 16: '닭갈비',\n",
              " 17: '닭강정',\n",
              " 18: '닭꼬치',\n",
              " 19: '닭똥집튀김',\n",
              " 20: '닭발',\n",
              " 21: '닭볶음탕',\n",
              " 22: '닭우동',\n",
              " 23: '대창',\n",
              " 24: '덮밥',\n",
              " 25: '돈가스',\n",
              " 26: '돼지갈비',\n",
              " 27: '돼지고기김치찜',\n",
              " 28: '돼지국밥',\n",
              " 29: '된장찌개',\n",
              " 30: '두부김치',\n",
              " 31: '떡볶이',\n",
              " 32: '라면',\n",
              " 33: '로제떡볶이',\n",
              " 34: '로제마라샹궈',\n",
              " 35: '마라떡볶이',\n",
              " 36: '마라탕',\n",
              " 37: '마제소바',\n",
              " 38: '막국수',\n",
              " 39: '멘보샤',\n",
              " 40: '무뼈닭발',\n",
              " 41: '바게트',\n",
              " 42: '바나나 한개',\n",
              " 43: '밥버거',\n",
              " 44: '백반',\n",
              " 45: '봉구스밥버거',\n",
              " 46: '부대찌개',\n",
              " 47: '분짜',\n",
              " 48: '불고기백반',\n",
              " 49: '불고기피자',\n",
              " 50: '불닭게티',\n",
              " 51: '비빔국수',\n",
              " 52: '사케동',\n",
              " 53: '삼각김밥',\n",
              " 54: '삼겹살',\n",
              " 55: '새우초밥',\n",
              " 56: '샌드위치',\n",
              " 57: '선지해장국',\n",
              " 58: '설렁탕',\n",
              " 59: '소고기덮밥',\n",
              " 60: '소고기무국',\n",
              " 61: '소곱창',\n",
              " 62: '소바',\n",
              " 63: '솥밥',\n",
              " 64: '순대국',\n",
              " 65: '순대국밥',\n",
              " 66: '순두부찌개',\n",
              " 67: '스테이크',\n",
              " 68: '스파게티',\n",
              " 69: '쌀국수',\n",
              " 70: '씨리얼',\n",
              " 71: '야끼소바',\n",
              " 72: '양꼬치',\n",
              " 73: '양념치킨',\n",
              " 74: '양송이수프',\n",
              " 75: '연어덮밥',\n",
              " 76: '연어초밥',\n",
              " 77: '연어회',\n",
              " 78: '열무국수',\n",
              " 79: '요거트아이스크림',\n",
              " 80: '유부초밥',\n",
              " 81: '육회',\n",
              " 82: '자장면',\n",
              " 83: '전',\n",
              " 84: '제육덮밥',\n",
              " 85: '제육볶음',\n",
              " 86: '족발',\n",
              " 87: '직화고기',\n",
              " 88: '짜장면',\n",
              " 89: '짜파게티',\n",
              " 90: '쫄면',\n",
              " 91: '쭈꾸미볶음',\n",
              " 92: '청국장',\n",
              " 93: '초밥',\n",
              " 94: '추어탕',\n",
              " 95: '치즈돈까스',\n",
              " 96: '치킨',\n",
              " 97: '치킨, 고기, 막걸리, 파전, 샐러드',\n",
              " 98: '칼국수',\n",
              " 99: '콩나물국밥육개장',\n",
              " 100: '크림파스타',\n",
              " 101: '타코야끼',\n",
              " 102: '투움바파스타',\n",
              " 103: '파스타',\n",
              " 104: '파전',\n",
              " 105: '페퍼로니피자',\n",
              " 106: '포케',\n",
              " 107: '피자',\n",
              " 108: '하와이안피자',\n",
              " 109: '항정살덮밥',\n",
              " 110: '해장국',\n",
              " 111: '햄버거',\n",
              " 112: '허니콤보',\n",
              " 113: '화채',\n",
              " 114: '회',\n",
              " 115: '회덮밥'}"
            ]
          },
          "execution_count": 532,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import csv\n",
        "\n",
        "menu_dict = {}\n",
        "first = True\n",
        "with open(\"./menu.csv\", 'r') as file:\n",
        "    reader = csv.reader(file)\n",
        "    for row in reader:\n",
        "        if first:\n",
        "          first=False\n",
        "          continue\n",
        "        idx, menu = row\n",
        "        menu_dict[int(idx)] = menu\n",
        "menu_dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 534,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P_VZDVaeF3Tm",
        "outputId": "0f6bf24f-59b5-452f-f2aa-b1a951e805bb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "DQN(\n",
              "  (fc1): Linear(in_features=6, out_features=128, bias=True)\n",
              "  (relu): ReLU()\n",
              "  (fc2): Linear(in_features=128, out_features=128, bias=True)\n",
              "  (fc3): Linear(in_features=128, out_features=116, bias=True)\n",
              ")"
            ]
          },
          "execution_count": 534,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# DQN 모델 정의 (이전에 정의한 것과 동일해야 함)\n",
        "class DQN(nn.Module):\n",
        "    def __init__(self, state_dim, action_dim):\n",
        "        super(DQN, self).__init__()\n",
        "        self.fc1 = nn.Linear(state_dim, 128)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.fc2 = nn.Linear(128, 128)\n",
        "        self.fc3 = nn.Linear(128, action_dim)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.relu(self.fc1(x))\n",
        "        x = self.relu(self.fc2(x))\n",
        "        return self.fc3(x)\n",
        "\n",
        "# 에이전트 정의 (이전에 정의한 것과 동일해야 함)\n",
        "class DQNAgent:\n",
        "    def __init__(self, state_dim, action_dim, replay_buffer):\n",
        "        self.state_dim = state_dim\n",
        "        self.action_dim = action_dim\n",
        "        self.replay_buffer = replay_buffer\n",
        "        self.model = DQN(state_dim, action_dim)\n",
        "        self.optimizer = optim.Adam(self.model.parameters(), lr=0.0005)\n",
        "        self.epsilon = 0.1  # 사용자 입력에서는 낮은 탐색 확률 사용\n",
        "        self.epsilon_min = 0.01\n",
        "\n",
        "    def select_action(self, state):\n",
        "        state = torch.FloatTensor(state).unsqueeze(0)\n",
        "        with torch.no_grad():\n",
        "            q_values = self.model(state)\n",
        "        action = q_values.max(1)[1].item()\n",
        "        \n",
        "        return action, q_values\n",
        "\n",
        "    def update_model(self, batch_size):\n",
        "        if len(self.replay_buffer) < batch_size:\n",
        "            return\n",
        "        batch = self.replay_buffer.sample(batch_size)\n",
        "        states, actions, rewards, next_states, dones = zip(*batch)\n",
        "\n",
        "        states = torch.FloatTensor(states)\n",
        "        next_states = torch.FloatTensor(next_states)\n",
        "        actions = torch.LongTensor(actions)\n",
        "        rewards = torch.FloatTensor(rewards)\n",
        "        dones = torch.FloatTensor(dones)\n",
        "        \n",
        "        current_q_values = self.model(states).gather(1, actions.view(-1, 1)).squeeze(1)\n",
        "        max_next_q_values = self.model(next_states).max(1)[0]\n",
        "        expected_q_values = rewards + (1 - dones) * 0.99 * max_next_q_values\n",
        "\n",
        "        loss = nn.MSELoss()(current_q_values, expected_q_values.detach())\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        self.optimizer.step()\n",
        "\n",
        "# 모델 및 에이전트 초기화\n",
        "state_dim = 6  # 상태 차원 (예시)\n",
        "action_dim = len(menu_dict)  # 행동 차원 (예시, 메뉴 수)\n",
        "replay_buffer = ReplayBuffer(10000)\n",
        "agent = DQNAgent(state_dim, action_dim, replay_buffer)\n",
        "\n",
        "# 체크포인트에서 모델 불러오기\n",
        "checkpoint_path = './model/final_model_state_dict.pth'  # 예시 체크포인트 경로\n",
        "checkpoint = torch.load(checkpoint_path)\n",
        "agent.model.load_state_dict(checkpoint)\n",
        "agent.model.eval()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 535,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "20nab-B-F3Lx",
        "outputId": "fd4d740d-35a3-46f5-f05a-54f71412ad31"
      },
      "outputs": [],
      "source": [
        "def get_user_input():\n",
        "    feeling = float(input(\"기분을 숫자로 입력하세요 (예: 1~10, 1: 최악, 10: 최고): \"))\n",
        "    weather = float(input(\"날씨를 숫자로 입력하세요 (예: 0: 맑음, 1: 구름, 2: 흐림, 3: 비, 4: 눈): \"))\n",
        "    temp = float(input(\"체감 온도를 숫자로 입력하세요 (예: 1~10, 1: 추움, 10: 더움): \"))\n",
        "    time = float(input(\"체감 식사 시간대를 입력하세요 (0: 아침, 1: 점심, 2: 저녁, 3: 야식): \"))\n",
        "    num_people = float(input(\"인원수를 숫자로 입력하세요 (예: 1, 2, 3, 4 or 5명 이상: 5): \"))\n",
        "    gender = float(input(\"성별을 입력하세요 (0: 남성, 1: 여성): \"))\n",
        "    state = [feeling, weather, temp, time, num_people, gender]\n",
        "    return state\n",
        "\n",
        "def get_user_feedback(action):\n",
        "    recommended_menus = menu_dict[action]\n",
        "    feedback = int(input(f\"추천된 메뉴: {recommended_menus}. 만족하셨나요? (1: 예, 0: 아니오): \"))\n",
        "    return feedback"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 537,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AbcOwT7hF3JH",
        "outputId": "c1c371ce-c9d8-4f19-c237-24a0ce4328cc"
      },
      "outputs": [],
      "source": [
        "# 사용자 입력 받기\n",
        "state = get_user_input()\n",
        "\n",
        "# 모델을 통해 메뉴 추천 받기\n",
        "action, q_value = agent.select_action(state)\n",
        "\n",
        "# 사용자 피드백 받기\n",
        "reward = get_user_feedback(action)\n",
        "done = True  # 단일 스텝이므로 에피소드 종료\n",
        "\n",
        "# 리플레이 버퍼에 경험 추가\n",
        "next_state = state  # 단일 스텝이므로 상태가 변하지 않음\n",
        "agent.replay_buffer.push(state, action, reward, next_state, done)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 526,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 315
        },
        "id": "OCvnaqh5Fx_3",
        "outputId": "33b0735c-d366-4730-abd6-fa709e2f159a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "35\n",
            "tensor([[-1.8534, -1.2835, -1.6721, -2.7721, -1.7791, -1.9205, -3.2602, -1.8648,\n",
            "         -1.9829, -3.7335, -1.8329, -1.7251, -1.6378, -1.6758, -2.3379, -1.8201,\n",
            "         -2.1955, -1.5408, -1.6900, -2.0315, -3.0437, -1.6749, -1.9298, -1.9248,\n",
            "         -3.5639, -1.7553, -2.0900, -1.5469, -1.8242, -3.5551, -1.5788, -3.5775,\n",
            "         -1.1987, -2.2391, -1.5868, -0.9070, -0.9225, -3.2100, -1.7657, -2.1878,\n",
            "         -2.8535, -1.4991, -3.8671, -1.9753, -1.6077, -1.9772, -2.1619, -1.5199,\n",
            "         -2.5573, -1.8917, -1.6972, -1.5690, -1.5787, -2.0799, -2.9908, -3.1854,\n",
            "         -2.3221, -1.7814, -2.2092, -1.8530, -1.8201, -2.2212, -2.0924, -1.4364,\n",
            "         -1.9176, -1.3367, -1.9609, -2.2384, -1.7060, -1.4190, -2.1038, -1.6288,\n",
            "         -2.1032, -2.2093, -1.8031, -1.7425, -1.9774, -3.7320, -2.3913, -3.0951,\n",
            "         -2.1710, -1.3734, -1.6701, -2.0771, -1.9599, -1.8365, -2.7730, -1.5031,\n",
            "         -1.8744, -2.1101, -2.1113, -3.1574, -2.2599, -1.3822, -1.4564, -1.7674,\n",
            "         -3.0818, -1.7062, -3.7003, -1.7189, -1.3468, -1.0837, -1.5286, -3.6766,\n",
            "         -1.9033, -1.7145, -5.3017, -2.2228, -1.7919, -1.5235, -1.8766, -2.4329,\n",
            "         -1.6612, -2.6040, -3.3409, -1.9273]], grad_fn=<AddmmBackward0>) tensor([[35]])\n"
          ]
        }
      ],
      "source": [
        "# 사용자 피드백을 바탕으로 모델 업데이트   아직 구현 안됨\n",
        "batch_size = 1  # 단일 사용자 피드백이므로 배치 크기를 1로 설정\n",
        "print(action)\n",
        "agent.update_model(batch_size)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 538,
      "metadata": {
        "id": "h42oC8N3F1mZ"
      },
      "outputs": [],
      "source": [
        "torch.save(agent.model.state_dict(), './model/final_model_state_dict.pth')\n",
        "torch.save(agent.model, './model/final_model.pth')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 540,
      "metadata": {},
      "outputs": [],
      "source": [
        "def softmax(x):\n",
        "    # 입력 배열 x에 대해 softmax 연산 수행\n",
        "    exp_x = np.exp(x - np.max(x))  # 입력 배열에서 최대값을 빼준 후 softmax 계산\n",
        "    softmax_x = exp_x / np.sum(exp_x)  # softmax 계산\n",
        "    return softmax_x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 541,
      "metadata": {
        "id": "WqTbT9nzF1j3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1600x800 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.font_manager as fm\n",
        "import numpy as np\n",
        "\n",
        "# 한글 폰트 설정\n",
        "path = 'C:/Windows/Fonts/batang.ttc'  # 사용할 한글 폰트 파일 경로\n",
        "fontprop = fm.FontProperties(fname=path)\n",
        "\n",
        "# 그래프 그리기\n",
        "plt.figure(figsize=(16, 8))\n",
        "plt.bar(menu_dict.values(), softmax(q_value.numpy().flatten()))\n",
        "\n",
        "# x축 레이블 폰트 설정\n",
        "plt.xticks(rotation=90, ha='center', fontsize=10, fontproperties=fontprop)\n",
        "plt.ylabel('q_value', fontproperties=fontprop)  # y축 레이블\n",
        "plt.title('메뉴별 q_value', fontproperties=fontprop)  # 그래프 제목\n",
        "\n",
        "plt.tight_layout()  # 그래프 레이아웃 조정\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K2WnpFJ9F1NL"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.8.10"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}