diff --git a/AI/LSTM_attention_test.ipynb b/AI/LSTM_attention_test.ipynb new file mode 100644 index 0000000..47e6cd6 --- /dev/null +++ b/AI/LSTM_attention_test.ipynb @@ -0,0 +1,1681 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ix1Jbg_xWTxg", + "outputId": "2b5f0a6a-2634-47a4-e269-b72e64d74705" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "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", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import os\n", + "import json\n", + "import csv\n", + "\n", + "TL_sentence_path = '/content/drive/MyDrive/LSTM+attention/sentence_dataTL.csv'\n", + "VL_sentence_path = '/content/drive/MyDrive/LSTM+attention/sentence_dataVL.csv'\n", + "\n", + "# data파일 불러오기\n", + "TL_sentence_data = pd.read_csv(TL_sentence_path, encoding='utf-8')\n", + "VL_sentence_data = pd.read_csv(VL_sentence_path, encoding='utf-8')\n", + "\n", + "# 중복 제거, Pronuncication 열은 필요 없다고 생각\n", + "TL_sentence_data.drop('Pronunciation', axis=1, inplace=True)\n", + "TL_sentence_data = TL_sentence_data.drop_duplicates().reset_index(drop=True)\n", + "VL_sentence_data.drop('Pronunciation', axis=1, inplace=True)\n", + "VL_sentence_data = VL_sentence_data.drop_duplicates().reset_index(drop=True)" + ], + "metadata": { + "id": "xPCQBU1BWfcw" + }, + "execution_count": 40, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "TL_sentence_data[:5]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "UZGjs0aPXrCe", + "outputId": "b61a98c7-d756-401d-dec3-e4cbea4a68c4" + }, + "execution_count": 41, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " Dialect \\\n", + "0 여기는 옥수갱이 잘 된다 카던디 옥수갱이 말고는 무신 농사를 많이 짓습니껴 \n", + "1 장례 관련해서 초상집 같은 데 가가 하지 말아야 데는 기 있습니껴 \n", + "2 예전에는 집 안에서 여자들이 남자 위로 띠넘으면 안 덴다 캤습니껴 \n", + "3 음식을 많이 장만하려고 하면 일손이 모자라서 음식하기가 안 힘들었습니까 \n", + "4 이 구두 하나만 계속 신고 댕기이꺼네 인자 굽이 많이 닳아서 갈아야 되겠네 \n", + "\n", + " Standard \n", + "0 여기는 옥수수 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까 \n", + "1 장례 관련해서 초상집 같은 데 가서 하지 말아야 데는 게 있습니까 \n", + "2 예전에는 집 안에서 여자들이 남자 위로 뛰어넘으면 안 된다 했습니까 \n", + "3 음식을 많이 장만하려고 하면 일손이 모자라서 음식하기가 안 힘들었습니까 \n", + "4 이 구두 하나만 계속 신고 다니니까 이제 굽이 많이 닳아서 갈아야 되겠네 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DialectStandard
0여기는 옥수갱이 잘 된다 카던디 옥수갱이 말고는 무신 농사를 많이 짓습니껴여기는 옥수수 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까
1장례 관련해서 초상집 같은 데 가가 하지 말아야 데는 기 있습니껴장례 관련해서 초상집 같은 데 가서 하지 말아야 데는 게 있습니까
2예전에는 집 안에서 여자들이 남자 위로 띠넘으면 안 덴다 캤습니껴예전에는 집 안에서 여자들이 남자 위로 뛰어넘으면 안 된다 했습니까
3음식을 많이 장만하려고 하면 일손이 모자라서 음식하기가 안 힘들었습니까음식을 많이 장만하려고 하면 일손이 모자라서 음식하기가 안 힘들었습니까
4이 구두 하나만 계속 신고 댕기이꺼네 인자 굽이 많이 닳아서 갈아야 되겠네이 구두 하나만 계속 신고 다니니까 이제 굽이 많이 닳아서 갈아야 되겠네
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"TL_sentence_data[:5]\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"Dialect\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"\\uc7a5\\ub840 \\uad00\\ub828\\ud574\\uc11c \\ucd08\\uc0c1\\uc9d1 \\uac19\\uc740 \\ub370 \\uac00\\uac00 \\ud558\\uc9c0 \\ub9d0\\uc544\\uc57c \\ub370\\ub294 \\uae30 \\uc788\\uc2b5\\ub2c8\\uaef4\",\n \"\\uc774 \\uad6c\\ub450 \\ud558\\ub098\\ub9cc \\uacc4\\uc18d \\uc2e0\\uace0 \\ub315\\uae30\\uc774\\uaebc\\ub124 \\uc778\\uc790 \\uad7d\\uc774 \\ub9ce\\uc774 \\ub2f3\\uc544\\uc11c \\uac08\\uc544\\uc57c \\ub418\\uaca0\\ub124\",\n \"\\uc608\\uc804\\uc5d0\\ub294 \\uc9d1 \\uc548\\uc5d0\\uc11c \\uc5ec\\uc790\\ub4e4\\uc774 \\ub0a8\\uc790 \\uc704\\ub85c \\ub760\\ub118\\uc73c\\uba74 \\uc548 \\ub374\\ub2e4 \\ucea4\\uc2b5\\ub2c8\\uaef4\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Standard\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"\\uc7a5\\ub840 \\uad00\\ub828\\ud574\\uc11c \\ucd08\\uc0c1\\uc9d1 \\uac19\\uc740 \\ub370 \\uac00\\uc11c \\ud558\\uc9c0 \\ub9d0\\uc544\\uc57c \\ub370\\ub294 \\uac8c \\uc788\\uc2b5\\ub2c8\\uae4c\",\n \"\\uc774 \\uad6c\\ub450 \\ud558\\ub098\\ub9cc \\uacc4\\uc18d \\uc2e0\\uace0 \\ub2e4\\ub2c8\\ub2c8\\uae4c \\uc774\\uc81c \\uad7d\\uc774 \\ub9ce\\uc774 \\ub2f3\\uc544\\uc11c \\uac08\\uc544\\uc57c \\ub418\\uaca0\\ub124\",\n \"\\uc608\\uc804\\uc5d0\\ub294 \\uc9d1 \\uc548\\uc5d0\\uc11c \\uc5ec\\uc790\\ub4e4\\uc774 \\ub0a8\\uc790 \\uc704\\ub85c \\ub6f0\\uc5b4\\ub118\\uc73c\\uba74 \\uc548 \\ub41c\\ub2e4 \\ud588\\uc2b5\\ub2c8\\uae4c\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 41 + } + ] + }, + { + "cell_type": "code", + "source": [ + "VL_sentence_data[:5]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "a0cWFdpxDKN7", + "outputId": "d47ecea6-b4fc-4d39-fd3c-d1d7369da953" + }, + "execution_count": 42, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " Dialect \\\n", + "0 오랫동안 한 동네에서 살았던 할머니이제 도주식하면 매매 아프네요 \n", + "1 혈압약은 시간을 맞춰 챙겨 드셔야지 안 그러면 효과가 없습니다 \n", + "2 집에 돌아와 보이꺼네 문이 열려 있고 뼈다지가 열어둔 돈 전부 없어지던 어이떼 \n", + "3 아들 오늘 중요한 시험 보니까에 이 생엿 하고 사가꼬 먹고 힘내서 시험 잘 봐레이 \n", + "4 옛날부터 조상꿈이나 돼지꿈 꾸만 집에 돈 많이 들어온다고 좋아 해지로 \n", + "\n", + " Standard \n", + "0 오랫동안 한 동네에서 살았던 할머니인데 돌아가겨서 마음이 아프네요 \n", + "1 혈압약은 시간을 맞춰 챙겨 드셔야지 안 그러면 효과가 없습니다 \n", + "2 집에 돌아와 보니까 문이 열려 있고 서랍이 열어둔 돈 전부 없어지던 어이떼 \n", + "3 아들 오늘 중요한 시험 보니까 이 생 엿 하고 사서 먹고 힘내서 시험 잘 봐 \n", + "4 옛날부터 조상꿈이나 돼지꿈 꾸면 집에 돈 많이 들어온다고 좋아 했죠 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DialectStandard
0오랫동안 한 동네에서 살았던 할머니이제 도주식하면 매매 아프네요오랫동안 한 동네에서 살았던 할머니인데 돌아가겨서 마음이 아프네요
1혈압약은 시간을 맞춰 챙겨 드셔야지 안 그러면 효과가 없습니다혈압약은 시간을 맞춰 챙겨 드셔야지 안 그러면 효과가 없습니다
2집에 돌아와 보이꺼네 문이 열려 있고 뼈다지가 열어둔 돈 전부 없어지던 어이떼집에 돌아와 보니까 문이 열려 있고 서랍이 열어둔 돈 전부 없어지던 어이떼
3아들 오늘 중요한 시험 보니까에 이 생엿 하고 사가꼬 먹고 힘내서 시험 잘 봐레이아들 오늘 중요한 시험 보니까 이 생 엿 하고 사서 먹고 힘내서 시험 잘 봐
4옛날부터 조상꿈이나 돼지꿈 꾸만 집에 돈 많이 들어온다고 좋아 해지로옛날부터 조상꿈이나 돼지꿈 꾸면 집에 돈 많이 들어온다고 좋아 했죠
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"VL_sentence_data[:5]\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"Dialect\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"\\ud608\\uc555\\uc57d\\uc740 \\uc2dc\\uac04\\uc744 \\ub9de\\ucdb0 \\ucc59\\uaca8 \\ub4dc\\uc154\\uc57c\\uc9c0 \\uc548 \\uadf8\\ub7ec\\uba74 \\ud6a8\\uacfc\\uac00 \\uc5c6\\uc2b5\\ub2c8\\ub2e4\",\n \"\\uc61b\\ub0a0\\ubd80\\ud130 \\uc870\\uc0c1\\uafc8\\uc774\\ub098 \\ub3fc\\uc9c0\\uafc8 \\uafb8\\ub9cc \\uc9d1\\uc5d0 \\ub3c8 \\ub9ce\\uc774 \\ub4e4\\uc5b4\\uc628\\ub2e4\\uace0 \\uc88b\\uc544 \\ud574\\uc9c0\\ub85c\",\n \"\\uc9d1\\uc5d0 \\ub3cc\\uc544\\uc640 \\ubcf4\\uc774\\uaebc\\ub124 \\ubb38\\uc774 \\uc5f4\\ub824 \\uc788\\uace0 \\ubf08\\ub2e4\\uc9c0\\uac00 \\uc5f4\\uc5b4\\ub454 \\ub3c8 \\uc804\\ubd80 \\uc5c6\\uc5b4\\uc9c0\\ub358 \\uc5b4\\uc774\\ub5bc\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Standard\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"\\ud608\\uc555\\uc57d\\uc740 \\uc2dc\\uac04\\uc744 \\ub9de\\ucdb0 \\ucc59\\uaca8 \\ub4dc\\uc154\\uc57c\\uc9c0 \\uc548 \\uadf8\\ub7ec\\uba74 \\ud6a8\\uacfc\\uac00 \\uc5c6\\uc2b5\\ub2c8\\ub2e4\",\n \"\\uc61b\\ub0a0\\ubd80\\ud130 \\uc870\\uc0c1\\uafc8\\uc774\\ub098 \\ub3fc\\uc9c0\\uafc8 \\uafb8\\uba74 \\uc9d1\\uc5d0 \\ub3c8 \\ub9ce\\uc774 \\ub4e4\\uc5b4\\uc628\\ub2e4\\uace0 \\uc88b\\uc544 \\ud588\\uc8e0\",\n \"\\uc9d1\\uc5d0 \\ub3cc\\uc544\\uc640 \\ubcf4\\ub2c8\\uae4c \\ubb38\\uc774 \\uc5f4\\ub824 \\uc788\\uace0 \\uc11c\\ub78d\\uc774 \\uc5f4\\uc5b4\\ub454 \\ub3c8 \\uc804\\ubd80 \\uc5c6\\uc5b4\\uc9c0\\ub358 \\uc5b4\\uc774\\ub5bc\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 42 + } + ] + }, + { + "cell_type": "code", + "source": [ + "standard_sentences_TL = TL_sentence_data['Standard']\n", + "dialect_sentences_TL = TL_sentence_data['Dialect']\n", + "standard_sentences_VL = VL_sentence_data['Standard']\n", + "dialect_sentences_VL = VL_sentence_data['Dialect']" + ], + "metadata": { + "id": "jlxCy4d3WyDB" + }, + "execution_count": 43, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "standard_sentences_TL[:5]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aj-awCcGFReV", + "outputId": "4cf3e645-11c4-4450-9615-0926f2306167" + }, + "execution_count": 44, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 여기는 옥수수 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까\n", + "1 장례 관련해서 초상집 같은 데 가서 하지 말아야 데는 게 있습니까\n", + "2 예전에는 집 안에서 여자들이 남자 위로 뛰어넘으면 안 된다 했습니까\n", + "3 음식을 많이 장만하려고 하면 일손이 모자라서 음식하기가 안 힘들었습니까\n", + "4 이 구두 하나만 계속 신고 다니니까 이제 굽이 많이 닳아서 갈아야 되겠네\n", + "Name: Standard, dtype: object" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dialect_sentences_TL[:5]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ctrb-c6hFWAX", + "outputId": "6340fc72-eb4e-4ab8-9757-cabea9479748" + }, + "execution_count": 45, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 여기는 옥수갱이 잘 된다 카던디 옥수갱이 말고는 무신 농사를 많이 짓습니껴\n", + "1 장례 관련해서 초상집 같은 데 가가 하지 말아야 데는 기 있습니껴\n", + "2 예전에는 집 안에서 여자들이 남자 위로 띠넘으면 안 덴다 캤습니껴\n", + "3 음식을 많이 장만하려고 하면 일손이 모자라서 음식하기가 안 힘들었습니까\n", + "4 이 구두 하나만 계속 신고 댕기이꺼네 인자 굽이 많이 닳아서 갈아야 되겠네\n", + "Name: Dialect, dtype: object" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# 학습 데이터 중에서 겹치는 표준어 문장과 방언 문장 제거\n", + "filtered_data_TR = {\n", + " \"src\": [],\n", + " \"tar\": []\n", + "}\n", + "\n", + "for i in range(0, len(dialect_sentences_TL)):\n", + " if (standard_sentences_TL[i] != dialect_sentences_TL[i]):\n", + " filtered_data_TR[\"src\"].append(dialect_sentences_TL[i])\n", + " filtered_data_TR[\"tar\"].append(standard_sentences_TL[i])\n", + "\n", + "filtered_df_TR = pd.DataFrame(filtered_data_TR)\n", + "\n", + "print(filtered_df_TR[:10])\n", + "print(len(filtered_df_TR))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GEIz3cMTXc76", + "outputId": "094b4095-e589-401a-ea7b-1d882bdd5963" + }, + "execution_count": 46, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " src \\\n", + "0 여기는 옥수갱이 잘 된다 카던디 옥수갱이 말고는 무신 농사를 많이 짓습니껴 \n", + "1 장례 관련해서 초상집 같은 데 가가 하지 말아야 데는 기 있습니껴 \n", + "2 예전에는 집 안에서 여자들이 남자 위로 띠넘으면 안 덴다 캤습니껴 \n", + "3 이 구두 하나만 계속 신고 댕기이꺼네 인자 굽이 많이 닳아서 갈아야 되겠네 \n", + "4 콩이파리는 가시가 있어가 꺼끄럽고 뻣뻣하고 묵어 보면 맛이 없어예 \n", + "5 여기에는 옥수갱이가 잘 된다 카던디 옥수갱이 말고는 무신 농사를 마이 짓습니껴 \n", + "6 여개는 옥수갱이가 잘 된다 카던디 옥수갱이 말고는 무신 농사를 마이 짓습니껴 \n", + "7 음식 먹으만 계속 설사하고 토하고 할 때는 물 많이 잡수고 병원에 가봐야 합니데이 \n", + "8 논두렁에 전선이 늘어져 있거나 정전이 됐을 때 두꺼비 집을 무짜로 만지만 위험합니더 \n", + "9 딱꾹지를 멈치지도 않고 점들 하는디 이럴 때는 우예 해야 합니껴 \n", + "\n", + " tar \n", + "0 여기는 옥수수 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까 \n", + "1 장례 관련해서 초상집 같은 데 가서 하지 말아야 데는 게 있습니까 \n", + "2 예전에는 집 안에서 여자들이 남자 위로 뛰어넘으면 안 된다 했습니까 \n", + "3 이 구두 하나만 계속 신고 다니니까 이제 굽이 많이 닳아서 갈아야 되겠네 \n", + "4 콩잎은 가시가 있어서 껄끄럽고 뻣뻣하고 먹어 보면 맛이 없어요 \n", + "5 여기에는 옥수수가 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까 \n", + "6 여기는 옥수수가 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까 \n", + "7 음식 먹으면 계속 설사하고 토하고 할 때는 물 많이 잡수고 병원에 가봐야 합니다 \n", + "8 논두렁에 전선이 늘어져 있거나 정전이 됐을 때 두꺼비 집을 함부로 만지면 위험합니다 \n", + "9 딱꾹지를 멈추지도 않고 점들 하는데 이럴 때는 어떻게 해야 합니까 \n", + "211878\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# 검증 데이터 중에서 겹치는 표준어 문장과 방언 문장 제거\n", + "filtered_data_VL = {\n", + " \"src\": [],\n", + " \"tar\": []\n", + "}\n", + "\n", + "for i in range(0, len(dialect_sentences_VL)):\n", + " if (standard_sentences_VL[i] != dialect_sentences_VL[i]):\n", + " filtered_data_VL[\"src\"].append(dialect_sentences_VL[i])\n", + " filtered_data_VL[\"tar\"].append(standard_sentences_VL[i])\n", + "\n", + "filtered_df_VL = pd.DataFrame(filtered_data_VL)\n", + "\n", + "print(filtered_df_VL[:10])\n", + "print(len(filtered_df_VL))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kv006ObsFwYF", + "outputId": "98d2caf3-6d41-46d2-d33c-871d77841043" + }, + "execution_count": 47, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " src \\\n", + "0 오랫동안 한 동네에서 살았던 할머니이제 도주식하면 매매 아프네요 \n", + "1 집에 돌아와 보이꺼네 문이 열려 있고 뼈다지가 열어둔 돈 전부 없어지던 어이떼 \n", + "2 아들 오늘 중요한 시험 보니까에 이 생엿 하고 사가꼬 먹고 힘내서 시험 잘 봐레이 \n", + "3 옛날부터 조상꿈이나 돼지꿈 꾸만 집에 돈 많이 들어온다고 좋아 해지로 \n", + "4 게얼에 먹을 채소나 과일 같은 것은 어데 보관을 했습니꺼 \n", + "5 촌구숙이라 젊은 사람들은 함부레 없고 전부 노인들만 있으이꺼네 농사 짓기가 힘들어요 \n", + "6 촌구석이라 젊은 사람들은 한 번이 없고 전부 노인들만 있으니까네 농사 짓기가 힘들어요 \n", + "7 소도 사람맨치로 잘 먹어야 근육도 붙고 심도 생겨서 일을 잘 하지로 \n", + "8 소도 사람 맨치로 잘 먹어야 근육도 붇고 힘도 생겨서 일을 잘 하지요 \n", + "9 옷가심을 짜를 때는 미리 선을 끟어 놓아야 쪽바리 잘 자를 수 있어예 \n", + "\n", + " tar \n", + "0 오랫동안 한 동네에서 살았던 할머니인데 돌아가겨서 마음이 아프네요 \n", + "1 집에 돌아와 보니까 문이 열려 있고 서랍이 열어둔 돈 전부 없어지던 어이떼 \n", + "2 아들 오늘 중요한 시험 보니까 이 생 엿 하고 사서 먹고 힘내서 시험 잘 봐 \n", + "3 옛날부터 조상꿈이나 돼지꿈 꾸면 집에 돈 많이 들어온다고 좋아 했죠 \n", + "4 겨울에 먹을 채소나 과일 같은 것은 어디에 보관을 했습니까 \n", + "5 촌구석이라 젊은 사람들은 아예 없고 전부 노인들만 있으니까 농사 짓기가 힘들어요 \n", + "6 촌구석이라 젊은 사람들은 한 번이 없고 전부 노인들만 있으니까 농사 짓기가 힘들어요 \n", + "7 소도 사람처럼 잘 먹어야 근육도 붙고 힘도 생겨서 일을 잘 하지요 \n", + "8 소도 사람 처럼 잘 먹어야 근육도 붇고 힘도 생겨서 일을 잘 하지요 \n", + "9 옷감을 자를 때는 미리 선을 그어 놓아야 똑바로 잘 자를 수 있어요 \n", + "27509\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 문장 길이 계산\n", + "def sentenceLengths(sentences):\n", + " return [len(sentence.split(' ')) for sentence in sentences]" + ], + "metadata": { + "id": "OFCJmuqdOo6m" + }, + "execution_count": 48, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.hist(sentenceLengths(filtered_data_TR['src']), bins=10)\n", + "plt.xlabel('length of dialect')\n", + "plt.ylabel('number of dialect')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "-zqR5FSPpN3X", + "outputId": "8c626b82-8e48-4504-f14a-98261e591f3f" + }, + "execution_count": 49, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.hist(sentenceLengths(filtered_data_TR['tar']), bins=10)\n", + "plt.xlabel('length of standard')\n", + "plt.ylabel('number of standard')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "wET-0eUhp2Vv", + "outputId": "af7c7c24-db11-43ad-a5e7-2a8f2e376979" + }, + "execution_count": 50, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "def threshold_len_max(max_len, data):\n", + " data = list(data) # 제네레이터를 리스트로 변환\n", + " sentence_count = 0\n", + " for sentence in data:\n", + " if len(sentence) <= max_len:\n", + " sentence_count += 1\n", + " return sentence_count / len(data) * 100\n", + "\n", + "def threshold_len_min(min_len, data):\n", + " data = list(data) # 제네레이터를 리스트로 변환\n", + " sentence_count = 0\n", + " for sentence in data:\n", + " if len(sentence) >= min_len:\n", + " sentence_count += 1\n", + " return sentence_count / len(data) * 100" + ], + "metadata": { + "id": "SqMQxZO4p1TQ" + }, + "execution_count": 51, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "len(filtered_data_TR['src'])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cRQ_fdfSE0Rb", + "outputId": "7abe010f-44bf-4014-d36f-b9a812542219" + }, + "execution_count": 52, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "211878" + ] + }, + "metadata": {}, + "execution_count": 52 + } + ] + }, + { + "cell_type": "code", + "source": [ + "max_len = 22\n", + "dialect_max = threshold_len_max(max_len, (sentence.split(' ') for sentence in filtered_data_TR['src']))\n", + "standard_max = threshold_len_max(max_len, (sentence.split(' ') for sentence in filtered_data_TR['tar']))\n", + "\n", + "print(f\"dialect 중 {max_len} 이하인 비율은 {dialect_max}\")\n", + "print(f\"standard 중 {max_len} 이하인 비율은 {standard_max}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ali5lQXaqSf0", + "outputId": "398406ce-6798-40b8-9942-ab1546088d0f" + }, + "execution_count": 53, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "dialect 중 22 이하인 비율은 80.23060440442141\n", + "standard 중 22 이하인 비율은 80.11355591425254\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "## 문장의 길이가 긴 것이 많아 80프로 정도의 데이터만 남김\n", + "\n", + "d_filter_indices = [i for i, sentence in enumerate(sentence.split(' ') for sentence in filtered_data_TR['src']) if len(sentence) <= max_len ]\n", + "s_filter_indices = [i for i, sentence in enumerate(sentence.split(' ') for sentence in filtered_data_TR['tar']) if len(sentence) <= max_len ]" + ], + "metadata": { + "id": "iLXOEUz2u45D" + }, + "execution_count": 54, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "indices = list(set(d_filter_indices) & set(s_filter_indices))" + ], + "metadata": { + "id": "aV630gtgwMDM" + }, + "execution_count": 55, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "len(indices)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "U2I4XBAtPd_b", + "outputId": "69928af8-0155-4376-f9ad-f74c02b7bb57" + }, + "execution_count": 56, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "169723" + ] + }, + "metadata": {}, + "execution_count": 56 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import pickle\n", + "1\n", + "# pickle 파일로부터 데이터를 불러옴\n", + "with open('/content/drive/MyDrive/LSTM+attention/filtered_dialect.pkl', 'rb') as f:\n", + " filtered_dialect = pickle.load(f)\n", + "\n", + "with open('/content/drive/MyDrive/LSTM+attention/filtered_standard.pkl', 'rb') as f:\n", + " filtered_standard = pickle.load(f)\n", + "\n", + "# 불러온 데이터를 확인\n", + "print(filtered_dialect[:10])\n", + "print(filtered_standard[:10])" + ], + "metadata": { + "id": "B041nyJnISFJ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a1a6f21a-e62b-451d-ba83-7bc6131169a4" + }, + "execution_count": 57, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['여기는 옥수갱이 잘 된다 카던디 옥수갱이 말고는 무신 농사를 많이 짓습니껴', '장례 관련해서 초상집 같은 데 가가 하지 말아야 데는 기 있습니껴', '예전에는 집 안에서 여자들이 남자 위로 띠넘으면 안 덴다 캤습니껴', '이 구두 하나만 계속 신고 댕기이꺼네 인자 굽이 많이 닳아서 갈아야 되겠네', '콩이파리는 가시가 있어가 꺼끄럽고 뻣뻣하고 묵어 보면 맛이 없어예', '여기에는 옥수갱이가 잘 된다 카던디 옥수갱이 말고는 무신 농사를 마이 짓습니껴', '여개는 옥수갱이가 잘 된다 카던디 옥수갱이 말고는 무신 농사를 마이 짓습니껴', '음식 먹으만 계속 설사하고 토하고 할 때는 물 많이 잡수고 병원에 가봐야 합니데이', '논두렁에 전선이 늘어져 있거나 정전이 됐을 때 두꺼비 집을 무짜로 만지만 위험합니더', '딱꾹지를 멈치지도 않고 점들 하는디 이럴 때는 우예 해야 합니껴']\n", + "['여기는 옥수수 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까', '장례 관련해서 초상집 같은 데 가서 하지 말아야 데는 게 있습니까', '예전에는 집 안에서 여자들이 남자 위로 뛰어넘으면 안 된다 했습니까', '이 구두 하나만 계속 신고 다니니까 이제 굽이 많이 닳아서 갈아야 되겠네', '콩잎은 가시가 있어서 껄끄럽고 뻣뻣하고 먹어 보면 맛이 없어요', '여기에는 옥수수가 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까', '여기는 옥수수가 잘 된다 하던데 옥수수 말고는 무슨 농사를 많이 짓습니까', '음식 먹으면 계속 설사하고 토하고 할 때는 물 많이 잡수고 병원에 가봐야 합니다', '논두렁에 전선이 늘어져 있거나 정전이 됐을 때 두꺼비 집을 함부로 만지면 위험합니다', '딱꾹지를 멈추지도 않고 점들 하는데 이럴 때는 어떻게 해야 합니까']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(len(filtered_dialect))\n", + "print(len(filtered_standard))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_dUEMZ8HRPow", + "outputId": "5067f019-15c7-478e-97ad-074ad2d14085" + }, + "execution_count": 58, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "169723\n", + "169723\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.hist(sentenceLengths(filtered_dialect), bins=10)\n", + "plt.xlabel('length of dialect')\n", + "plt.ylabel('number of dialect')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "yf8viS-nR3bN", + "outputId": "6b532d01-82f7-49b4-9926-a530de3da23d" + }, + "execution_count": 59, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.hist(sentenceLengths(filtered_standard), bins=10)\n", + "plt.xlabel('length of standard')\n", + "plt.ylabel('number of standard')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "2g430fC7RliO", + "outputId": "c0891822-c902-49b8-aeb0-4821ad1e608b" + }, + "execution_count": 60, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "SOS_token = 0\n", + "EOS_token = 1\n", + "UNK_token = 2\n", + "PAD_token = 3\n", + "\n", + "class Lang:\n", + " def __init__(self, name):\n", + " self.name = name\n", + " self.word2index = {\"UNK\": 2}\n", + " self.word2count = {}\n", + " self.index2word = {0: \"SOS\", 1: \"EOS\", 2: \"UNK\", 3: \"PAD\"}\n", + " self.n_words = 4 # SOS, EOS, UNK, PAD\n", + "\n", + " def addSentence(self, sentence):\n", + " for word in sentence.split(\" \"):\n", + " self.addWord(word)\n", + "\n", + " def addWord(self, word):\n", + " if word not in self.word2index:\n", + " self.word2index[word] = self.n_words\n", + " self.word2count[word] = 1\n", + " self.index2word[self.n_words] = word\n", + " self.n_words += 1\n", + " else:\n", + " self.word2count[word] += 1\n", + "\n", + " def getWordIndex(self, word):\n", + " return self.word2index.get(word, self.word2index[\"UNK\"])" + ], + "metadata": { + "id": "oMl0xGNU49XX" + }, + "execution_count": 61, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Lang 객체 생성\n", + "dialect_lang = Lang(\"Dialect\")\n", + "standard_lang = Lang(\"Standard\")\n", + "\n", + "# 문장 추가\n", + "for sentence in filtered_dialect[:10]:\n", + " dialect_lang.addSentence(sentence)\n", + "for sentence in filtered_standard[:10]:\n", + " standard_lang.addSentence(sentence)\n", + "\n", + "for sentence in filtered_df_VL['src'][:10]:\n", + " dialect_lang.addSentence(sentence)\n", + "for sentence in filtered_df_VL['tar'][:10]:\n", + " standard_lang.addSentence(sentence)\n", + "\n", + "# 문장\n", + "pairs = list(zip(filtered_dialect[:10], filtered_standard[:10]))\n", + "VL_pairs = list(zip(filtered_df_VL['src'][:10], filtered_df_VL['tar'][:10]))\n", + "\n", + "# 문장을 인덱스로 변환\n", + "def indexesFromSentence(lang, sentence):\n", + " return [lang.getWordIndex(word) for word in sentence.split(' ')]\n", + "\n", + "def tensorFromSentence(lang, sentence, max_length):\n", + " indexes = indexesFromSentence(lang, sentence)\n", + " indexes.append(EOS_token)\n", + " if len(indexes) < max_length:\n", + " indexes += [PAD_token] * (max_length - len(indexes))\n", + " elif len(indexes) > max_length:\n", + " indexes = indexes[:max_length-1] + [EOS_token]\n", + " return torch.tensor(indexes, dtype=torch.long).view(-1, 1)\n", + "\n", + "def tensorsFromPair(pair):\n", + " input_tensor = tensorFromSentence(dialect_lang, pair[0], max_len)\n", + " target_tensor = tensorFromSentence(standard_lang, pair[1], max_len)\n", + " return (input_tensor, target_tensor)" + ], + "metadata": { + "id": "VBPYjCbZ8l6k" + }, + "execution_count": 62, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "max_len = 22\n", + "\n", + "# 검증 데이터를 인덱스로 변환\n", + "validation_input_tensors = [tensorFromSentence(dialect_lang, pair[0], max_len) for pair in VL_pairs]\n", + "validation_target_tensors = [tensorFromSentence(standard_lang, pair[1], max_len) for pair in VL_pairs]\n", + "\n", + "# 모델 정의\n", + "class EncoderRNN(nn.Module):\n", + " def __init__(self, input_size, hidden_size):\n", + " super(EncoderRNN, self).__init__()\n", + " self.hidden_size = hidden_size\n", + " self.embedding = nn.Embedding(input_size, hidden_size)\n", + " self.lstm = nn.LSTM(hidden_size, hidden_size)\n", + "\n", + " def forward(self, input, hidden):\n", + " embedded = self.embedding(input).view(1, 1, -1)\n", + " output, hidden = self.lstm(embedded, hidden)\n", + " return output, hidden\n", + "\n", + " def initHidden(self):\n", + " return (torch.zeros(1, 1, self.hidden_size),\n", + " torch.zeros(1, 1, self.hidden_size))\n", + "\n", + "class AttnDecoderRNN(nn.Module):\n", + " def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=max_len):\n", + " super(AttnDecoderRNN, self).__init__()\n", + " self.hidden_size = hidden_size\n", + " self.output_size = output_size\n", + " self.dropout_p = dropout_p\n", + " self.max_length = max_length\n", + "\n", + " self.embedding = nn.Embedding(self.output_size, self.hidden_size)\n", + " self.attn = nn.Linear(self.hidden_size * 2, self.max_length)\n", + " self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)\n", + " self.dropout = nn.Dropout(self.dropout_p)\n", + " self.lstm = nn.LSTM(self.hidden_size, self.hidden_size)\n", + " self.out = nn.Linear(self.hidden_size, self.output_size)\n", + "\n", + " def forward(self, input, hidden, encoder_outputs):\n", + " embedded = self.embedding(input).view(1, 1, -1)\n", + " embedded = self.dropout(embedded)\n", + "\n", + " attn_weights = nn.functional.softmax(\n", + " self.attn(torch.cat((embedded[0], hidden[0][0]), 1)), dim=1)\n", + " attn_applied = torch.bmm(attn_weights.unsqueeze(0),\n", + " encoder_outputs.unsqueeze(0))\n", + "\n", + " output = torch.cat((embedded[0], attn_applied[0]), 1)\n", + " output = self.attn_combine(output).unsqueeze(0)\n", + "\n", + " output = nn.functional.relu(output)\n", + " output, hidden = self.lstm(output, hidden)\n", + "\n", + " output = nn.functional.log_softmax(self.out(output[0]), dim=1)\n", + " return output, hidden, attn_weights\n", + "\n", + " def initHidden(self):\n", + " return (torch.zeros(1, 1, self.hidden_size),\n", + " torch.zeros(1, 1, self.hidden_size))" + ], + "metadata": { + "id": "EyqODVGn87BL" + }, + "execution_count": 63, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import random\n", + "import time\n", + "import math\n", + "\n", + "def asMinutes(s):\n", + " m = math.floor(s / 60)\n", + " s -= m * 60\n", + " return f'{m}m {s:.2f}s'\n", + "\n", + "def timeSince(since, percent):\n", + " now = time.time()\n", + " s = now - since\n", + " es = s / (percent)\n", + " rs = es - s\n", + " return f'{asMinutes(s)} (- {asMinutes(rs)})'\n", + "\n", + "# 모델 훈련 함수\n", + "def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=max_len):\n", + " encoder_hidden = encoder.initHidden()\n", + "\n", + " encoder_optimizer.zero_grad()\n", + " decoder_optimizer.zero_grad()\n", + "\n", + " input_length = input_tensor.size(0)\n", + " target_length = target_tensor.size(0)\n", + "\n", + " encoder_outputs = torch.zeros(max_length, encoder.hidden_size)\n", + "\n", + " loss = 0\n", + "\n", + " for ei in range(input_length):\n", + " encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)\n", + " encoder_outputs[ei] = encoder_output[0, 0]\n", + "\n", + " decoder_input = torch.tensor([[SOS_token]])\n", + "\n", + " decoder_hidden = encoder_hidden\n", + "\n", + " for di in range(target_length):\n", + " decoder_output, decoder_hidden, decoder_attention = decoder(\n", + " decoder_input, decoder_hidden, encoder_outputs)\n", + " topv, topi = decoder_output.topk(1)\n", + " decoder_input = topi.squeeze().detach() # 다음 입력으로 사용\n", + "\n", + " loss += criterion(decoder_output, target_tensor[di])\n", + " if decoder_input.item() == EOS_token:\n", + " break\n", + "\n", + " loss.backward()\n", + "\n", + " encoder_optimizer.step()\n", + " decoder_optimizer.step()\n", + "\n", + " return loss.item() / target_length\n", + "\n", + "def evaluate(encoder, decoder, input_tensor, target_tensor, criterion, max_length=max_len):\n", + " with torch.no_grad():\n", + " encoder_hidden = encoder.initHidden()\n", + "\n", + " input_length = input_tensor.size(0)\n", + " target_length = target_tensor.size(0)\n", + "\n", + " encoder_outputs = torch.zeros(max_length, encoder.hidden_size)\n", + "\n", + " loss = 0\n", + "\n", + " for ei in range(input_length):\n", + " encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)\n", + " encoder_outputs[ei] = encoder_output[0, 0]\n", + "\n", + " decoder_input = torch.tensor([[SOS_token]])\n", + "\n", + " decoder_hidden = encoder_hidden\n", + "\n", + " for di in range(target_length):\n", + " decoder_output, decoder_hidden, decoder_attention = decoder(\n", + " decoder_input, decoder_hidden, encoder_outputs)\n", + " topv, topi = decoder_output.topk(1)\n", + " decoder_input = topi.squeeze().detach() # 다음 입력으로 사용\n", + "\n", + " loss += criterion(decoder_output, target_tensor[di])\n", + " if decoder_input.item() == EOS_token:\n", + " break\n", + "\n", + " return loss.item() / target_length\n", + "\n", + "def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):\n", + " start = time.time()\n", + " plot_losses = []\n", + " plot_val_losses = []\n", + " print_loss_total = 0 # Reset every print_every\n", + " plot_loss_total = 0 # Reset every plot_every\n", + " val_loss_total = 0\n", + " val_loss_avg = 0\n", + "\n", + " encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)\n", + " decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)\n", + " training_pairs = [tensorsFromPair(random.choice(pairs)) for _ in range(n_iters)]\n", + " criterion = nn.NLLLoss()\n", + "\n", + " for iter in range(1, n_iters + 1):\n", + " training_pair = training_pairs[iter - 1]\n", + " input_tensor = training_pair[0]\n", + " target_tensor = training_pair[1]\n", + "\n", + " loss = train(input_tensor, target_tensor, encoder,\n", + " decoder, encoder_optimizer, decoder_optimizer, criterion)\n", + " print_loss_total += loss\n", + " plot_loss_total += loss\n", + "\n", + " # 검증 데이터에 대한 손실 계산\n", + " if iter % print_every == 0:\n", + " val_loss_total = 0\n", + " for val_input, val_target in zip(validation_input_tensors, validation_target_tensors):\n", + " val_loss = evaluate(encoder, decoder, val_input, val_target, criterion)\n", + " val_loss_total += val_loss\n", + "\n", + " val_loss_avg = val_loss_total / len(validation_input_tensors)\n", + " print_loss_avg = print_loss_total / print_every\n", + " print_loss_total = 0\n", + " print(f'{timeSince(start, iter / n_iters)} ({iter} {iter / n_iters * 100:.2f}%) '\n", + " f'Train Loss: {print_loss_avg:.4f}, Val Loss: {val_loss_avg:.4f}')\n", + "\n", + " if iter % plot_every == 0:\n", + " plot_loss_avg = plot_loss_total / plot_every\n", + " plot_val_losses.append(val_loss_avg)\n", + " plot_losses.append(plot_loss_avg)\n", + " plot_loss_total = 0\n", + "\n", + " showPlot(plot_losses, plot_val_losses)\n", + "\n", + "def showPlot(train_losses, val_losses):\n", + " plt.figure()\n", + " plt.plot(train_losses, label='Training Loss')\n", + " plt.plot(val_losses, label='Validation Loss')\n", + " plt.title('Training and Validation Loss')\n", + " plt.xlabel('Iterations')\n", + " plt.ylabel('Loss')\n", + " plt.legend()\n", + " plt.show()" + ], + "metadata": { + "id": "Uaozw3dc_vdk" + }, + "execution_count": 68, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# 모델 초기화 및 훈련\n", + "hidden_size = 256\n", + "encoder = EncoderRNN(dialect_lang.n_words, hidden_size)\n", + "decoder = AttnDecoderRNN(hidden_size, standard_lang.n_words, dropout_p=0.1)\n", + "\n", + "trainIters(encoder, decoder, 1000, print_every=100, plot_every=50) # 적은 수의 iteration으로 실행" + ], + "metadata": { + "id": "JLgmcaB5UKtN", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 656 + }, + "outputId": "c12315c4-2421-4ee8-c38e-8609fd2af79f" + }, + "execution_count": 69, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0m 12.51s (- 1m 52.60s) (100 10.00%) Train Loss: 2.6009, Val Loss: 3.2177\n", + "0m 22.69s (- 1m 30.76s) (200 20.00%) Train Loss: 1.6699, Val Loss: 4.1320\n", + "0m 33.58s (- 1m 18.36s) (300 30.00%) Train Loss: 1.5512, Val Loss: 4.4176\n", + "0m 44.24s (- 1m 6.37s) (400 40.00%) Train Loss: 1.4290, Val Loss: 4.4798\n", + "0m 55.07s (- 0m 55.07s) (500 50.00%) Train Loss: 1.3086, Val Loss: 4.1685\n", + "1m 5.12s (- 0m 43.41s) (600 60.00%) Train Loss: 1.2437, Val Loss: 5.1896\n", + "1m 15.75s (- 0m 32.47s) (700 70.00%) Train Loss: 1.1878, Val Loss: 5.2546\n", + "1m 26.22s (- 0m 21.56s) (800 80.00%) Train Loss: 1.0526, Val Loss: 4.7955\n", + "1m 36.49s (- 0m 10.72s) (900 90.00%) Train Loss: 0.6964, Val Loss: 5.1462\n", + "1m 45.93s (- 0m 0.00s) (1000 100.00%) Train Loss: 0.7646, Val Loss: 5.2876\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "def saveModel(encoder, decoder, encoder_path='encoder.pth', decoder_path='decoder.pth'): ## 모델 저장\n", + " torch.save(encoder.state_dict(), encoder_path)\n", + " torch.save(decoder.state_dict(), decoder_path)" + ], + "metadata": { + "id": "_Gjpck4MUHBm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def loadModel(encoder_path='encoder.pth', decoder_path='decoder.pth'): ## 모델 로드\n", + " encoder = EncoderRNN(dialect_lang.n_words, hidden_size)\n", + " decoder = AttnDecoderRNN(hidden_size, standard_lang.n_words, dropout_p=0.1)\n", + " encoder.load_state_dict(torch.load(encoder_path))\n", + " decoder.load_state_dict(torch.load(decoder_path))\n", + " return encoder, decoder" + ], + "metadata": { + "id": "t3WSCqgH-djn" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "encoder_path = '/content/drive/MyDrive/LSTM+attention/test_encoder.pth'\n", + "decoder_path = '/content/drive/MyDrive/LSTM+attention/test_decoder.pth'" + ], + "metadata": { + "id": "TqE3502bKBs5" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "saveModel(encoder, decoder, encoder_path, decoder_path)" + ], + "metadata": { + "id": "W6R4lLLE-gqu" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# 모델 평가 함수\n", + "def evaluateRandomly(encoder, decoder, n=10):\n", + " for i in range(n):\n", + " pair = random.choice(test_pairs)\n", + " print('Dialect:', pair[0])\n", + " print('Expected:', pair[1])\n", + " output_words = evaluate(encoder, decoder, pair[0])\n", + " output_sentence = ' '.join(output_words)\n", + " print('Predicted:', output_sentence)\n", + " print('')\n" + ], + "metadata": { + "id": "zYySN_5AUvbG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## 테스트 데이터 준비 필요\n", + "test_dialect_sentences = [\"밥 무나?\", \"와 이리 더운교?\", \"이거 맛있다카이\", \"오늘 날씨 좋네예\"]\n", + "test_standard_sentences = [\"밥 먹었니?\", \"왜 이렇게 덥지?\", \"이거 맛있다고 하네\", \"오늘 날씨 좋네\"]\n", + "\n", + "test_pairs = list(zip(test_dialect_sentences, test_standard_sentences))" + ], + "metadata": { + "id": "ch8xAa69U5DA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# 저장된 모델 불러오기\n", + "encoder, decoder = loadModel(encoder_path, decoder_path)\n", + "\n", + "hidden_size = 256\n", + "encoder = EncoderRNN(dialect_lang.n_words, hidden_size)\n", + "decoder = AttnDecoderRNN(hidden_size, standard_lang.n_words, dropout_p=0.1)\n", + "\n", + "evaluateRandomly(encoder, decoder, n=len(test_pairs))" + ], + "metadata": { + "id": "THo_PKRYM4vP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## 테스트 함수 실행\n", + "evaluateRandomly(encoder, decoder, n=len(test_pairs))" + ], + "metadata": { + "id": "JQNbhsGTVRCe" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file