diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2aa2c14 --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +checkpoint/* +!checkpoint/.gitkeep +data/* +!data/.gitkeep +experiments/* +!experiments/.gitkeep +output/* +!output/.gitkeep +tb_logs/* +!tb_logs/.gitkeep +lightning_logs/* +!lightning_logs/.gitkeep +# 모든 __pycache__ 폴더 무시 +**/__pycache__/ +.idea/* +.DS_Store diff --git a/README.md b/README.md new file mode 100644 index 0000000..d4f5bb5 --- /dev/null +++ b/README.md @@ -0,0 +1,122 @@ +![alt text](banner.png) + +# Lv.1 NLP 기초 프로젝트 : 문장 간 유사도 측정(STS) + + + +## **프로젝트 개요** +> 진행 기간: 24년 9월 10일 ~ 24년 9월 26일 + +> 데이터셋: +> - 학습 데이터셋 9,324개 +> - 검증 데이터셋 550개 +> - 평가 데이터는 1,100개 +> +> 평가 데이터의 50%는 Public 점수 계산에 활용되어 실시간 리더보드에 표기가 되고, 남은 50%는 Private 결과 계산에 활용되었습니다. + +부스트캠프AI Tech 7기의 Level1 과정으로 NLP 기초 대회입니다. 주제는 ‘문장 간 유사도 측정’으로, 두 문장이 얼마나 유사한지를 수치화하는 자연어처리 N21 태스크인 의미 유사도 판별(Semantic Text Similarity, 이하 STS)을 진행했습니다. 학습 데이터에 주어진 문장 두 개와 유사도 점수를 기반으로 평가 데이터의 두 문장 간의 유사도를 0과 5 사이의 값으로 예측하는 모델을 구축하였습니다. + + +## **프로젝트 구조** +``` +📦project1 + ┣ 📂config + ┃ ┗ 📜config.yaml + ┣ 📂data + ┣ 📂model + ┃ ┗ 📜model.py + ┣ 📂output + ┣ 📂tb_logs + ┣ 📂utils + ┃ ┣ 📂ensemble + ┃ ┣ 📂preprocess + ┣ 📜README.md + ┣ 📜inference.py + ┣ 📜requirements.txt + ┗ 📜train.py +``` + +## **Contributors** + + + + + + + + + + +
+ 이예서
+ + badge 이예서 + + 		+ 김수진
+ + badge 김수진 + + 		+ 김민서
+ + badge 김민서 + + 		+ 홍성재
+ + badge 홍성재 + + 		+ 양가연
+ + badge 양가연 + + 		+ 홍성민
+ + badge 홍성민 + +
+ +## 역할분담 + +| 이름 | 역할 | +| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 김민서 | 베이스라인 코드 구현, 텐서보드 기능 구현, 허깅페이스 내 모델 Search, 모델링 및 튜닝(`klue/roberta-large`, `klue/roberta-base`, `team-lucid/deberta-v3-base-korean`, `deliciouscat/kf-deberta-base-cross-sts`, `upskyy/kf-deberta-multitask`, `kakaobank/kf-deberta-base`, `klue/bert-base`), 앙상블(`soft voting`, `weighted voting`) | +| 김수진 | Task에 적합한 모델 Search, 데이터 증강(`swap`), 데이터 분할, 모델링 및 튜닝(`snunlp/KR-ELECTRA-discriminator`), 앙상블(`weighted voting`) | +| 양가연 | 데이터 전처리(`hanspell`, `soynlp`), 데이터 증강(`copied_sentence`, `swap`, `synonym replacement`, `undersampling`, `masking`), 모델링 및 튜닝(`kykim/electra-kor-base`, `snunlp/KR-ELECTRA-discriminator`, `klue/roberta-large`, `WandB`), 앙상블(`weighted voting`) | +| 이예서 | EDA(`Label 분포`, `Source 분포`, `Sentence length 분석`), 데이터 전처리(`특수문자 제거`, `초성 대체`, `띄어쓰기/맞춤법 교정`), 데이터 증강(`sentence swap`, `sentence copy`, `korEDA(SR, RI, RS)`, `K-TACC(BERT_RMR, ADVERB)`), 앙상블(`weighted voting`) | +| 홍성민 | 모델링 및 튜닝(`kykim/KR-ELECTRA-Base`), 앙상블(`weighted voting`), 베이스라인 코드 수정과 기능 추가 | +| 홍성재 | 하이퍼 파라미터 튜닝(`BS`, `Epoch`, `LR`), 모델 최적화 및 앙상블(`Koelectra-base-v3-discriminator`, `roberta-small`, `bert-base-multilingual-cased` / `Soft voting`) | + +## Dependencies +* torch==2.1.0 +* transformers==4.35.2 +* pytorch-lightning==2.1.2 + +## Usage +1. Setting +``` +$ pip install -r requirements.txt +``` +2. Training +```angular2html +$ python3 train.py +``` +3. Inference +```angular2html +$ python3 inference.py +``` + +## 프로젝트 타임라인 + +Gantt chart template (Community) (3) + +## 프로젝트 수행결과 + +Gantt chart template (Community) (4) + +## 리더보드 결과 +![image](https://github.com/user-attachments/assets/e666e639-3bfe-4bed-95b1-4fd3a93ed745) + diff --git a/banner.png b/banner.png new file mode 100644 index 0000000..6114a04 Binary files /dev/null and b/banner.png differ diff --git a/checkpoint/.gitkeep b/checkpoint/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/config/config.yaml b/config/config.yaml new file mode 100644 index 0000000..feee5e7 --- /dev/null +++ b/config/config.yaml @@ -0,0 +1,27 @@ +user_name: seongmin # 실험자 이름 +model: + model_name: klue/roberta-small +early_stopping: + min_delta: 0.0 + mode: max + monitor: val_pearson + patience: 5 + verbose: False +train: + batch_size: 8 + learning_rate: 1e-5 + max_epoch: 10 + LossF: torch.nn.MSELoss + optim: torch.optim.AdamW + ## LossF와 optim은 torch.nn과 torch.optim을 꼭 적어야 합니다 + shuffle: True +data: + train_path: ./data/raw/train_01.csv + dev_path: ./data/raw/dev.csv + test_path: ./data/raw/dev.csv + predict_path: ./data/raw/test.csv + checkpoint_path: ./checkpoint/ + output_path: ./output/ + submission_path: ./data/sample_submission.csv + val_path: ./data/dev.csv +seed: 42 diff --git a/data/.gitkeep b/data/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/inference.py b/inference.py new file mode 100644 index 0000000..b131507 --- /dev/null +++ b/inference.py @@ -0,0 +1,68 @@ +import argparse +import yaml +import pandas as pd +import os +from tqdm.auto import tqdm + +import torch + +# import transformers +# import pandas as pd + +import pytorch_lightning as pl + +# import wandb +############################## +from utils import data_pipeline + + +def get_latest_experiment_folder(base_path="./experiments"): + # base_path 내의 폴더 리스트 가져오기 + experiment_folders = [ + f for f in os.listdir(base_path) if os.path.isdir(os.path.join(base_path, f)) + ] + + # 폴더가 없을 경우 None 반환 + if not experiment_folders: + return None + + # 폴더 생성 시간 기준으로 정렬 (가장 최근 폴더가 마지막에 위치) + experiment_folders.sort( + key=lambda x: os.path.getmtime(os.path.join(base_path, x)), reverse=True + ) + + # 가장 최근에 생성된 폴더 반환 + return experiment_folders[0] + + +if __name__ == "__main__": + + # baseline_config 설정 불러오기 + with open("./config/config.yaml", encoding="utf-8") as f: + CFG = yaml.load(f, Loader=yaml.FullLoader) + + # 저장된 폴더 이름 가장 최근걸로 불러오기 + exp_name = get_latest_experiment_folder() + + # dataloader / model 설정 + dataloader = data_pipeline.Dataloader(CFG) + model = torch.load(f"./experiments/{exp_name}/model.pt") + # trainer 인스턴스 생성 + trainer = pl.Trainer( + accelerator="gpu", + devices=1, + max_epochs=CFG["train"]["max_epoch"], + log_every_n_steps=1, + ) + + # Inference part + predictions = trainer.predict(model=model, datamodule=dataloader) + ## datamodule에서 predict_dataloader 호출 + + # 예측된 결과를 형식에 맞게 반올림하여 준비합니다. + predictions = list(round(float(i), 1) for i in torch.cat(predictions)) + + # output 형식을 불러와서 예측된 결과로 바꿔주고, output.csv로 출력합니다. + output = pd.read_csv("./data/raw/sample_submission.csv") + output["target"] = predictions + output.to_csv(f"./output/output_({exp_name}).csv", index=False) diff --git a/model/model.py b/model/model.py new file mode 100644 index 0000000..e476e33 --- /dev/null +++ b/model/model.py @@ -0,0 +1,108 @@ +import torch +import transformers +import torchmetrics +import pytorch_lightning as pl + + +class Model(pl.LightningModule): + def __init__(self, CFG): + super().__init__() + self.save_hyperparameters() + + # 문자열로 표현된 loss와 optimizer를 함수로 변환 + self.model_name = CFG["model"]["model_name"] + self.lr = float(CFG["train"]["learning_rate"]) + self.loss_func = eval(CFG["train"]["LossF"])() + # self.optim은 configure_optimizers에서 사용 + self.optim = eval(CFG["train"]["optim"]) + + ## CFG의 model_name으로 설정된 모델 불러오기 + self.plm = transformers.AutoModelForSequenceClassification.from_pretrained( + pretrained_model_name_or_path=self.model_name, num_labels=1 + ) + + def forward(self, x): + x = self.plm(x)["logits"] + + return x + + def training_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + loss = self.loss_func(logits, y.float()) + + # 피어슨 계수 계산 + pearson = torchmetrics.functional.pearson_corrcoef( + logits.squeeze(), y.squeeze() + ) + + # 기존코드 + # self.log("train_loss", loss) + + # 에포크 단위로 로그 기록 + self.log("loss/train", loss, on_step=True, on_epoch=True) + self.log("pearson/train", pearson, on_step=True, on_epoch=True) + + # 가로축을 에포크 기반으로 설정 + self.logger.experiment.add_scalar("loss/train_epoch", loss, self.current_epoch) + self.logger.experiment.add_scalar( + "pearson/train_epoch", pearson, self.current_epoch + ) + + return loss + + def validation_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + loss = self.loss_func(logits, y.float()) + + # 피어슨 계수 계산 + pearson = torchmetrics.functional.pearson_corrcoef( + logits.squeeze(), y.squeeze() + ) + + # 기존코드 + # self.log("val_loss", loss) + # self.log("val_pearson", torchmetrics.functional.pearson_corrcoef(logits.squeeze(), y.squeeze())) + + # 에포크 단위로 로그 기록 + self.log("loss/val", loss, on_step=False, on_epoch=True) + self.log("pearson/val", pearson, on_step=True, on_epoch=True) + + # 가로축을 에포크 기반으로 설정 + self.logger.experiment.add_scalar("loss/val_epoch", loss, self.current_epoch) + self.logger.experiment.add_scalar( + "pearson/val_epoch", pearson, self.current_epoch + ) + + return loss + + def test_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + + # 피어슨 계수 계산 + pearson = torchmetrics.functional.pearson_corrcoef( + logits.squeeze(), y.squeeze() + ) + + # 기존코드 + # self.log("test_pearson", torchmetrics.functional.pearson_corrcoef(logits.squeeze(), y.squeeze())) + + # 에포크 단위로 로그 기록 + self.log("pearson/test", pearson, on_step=True, on_epoch=True) + + # 가로축을 에포크 기반으로 설정 + self.logger.experiment.add_scalar( + "pearson/test_epoch", pearson, self.current_epoch + ) + + def predict_step(self, batch, batch_idx): + x = batch + logits = self(x) + + return logits.squeeze() + + def configure_optimizers(self): + optimizer = self.optim(self.parameters(), lr=self.lr) + return optimizer diff --git a/output/.gitkeep b/output/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..8f634bb --- /dev/null +++ b/requirements.txt @@ -0,0 +1,16 @@ +transformers==4.35.2 +wandb==0.18.0 +torchmetrics==1.2.0 +torch==2.1.0 +tokenizers==0.15.0 +seaborn==0.13.2 +pytorch-lightning==2.1.2 +pandas==2.1.3 +matplotlib==3.9.2 +hydra-core==1.3.2 +huggingface-hub==0.19.4 +scikit-learn==1.2.2 +scipy==1.10.1 +numpy==1.24.3 +joblib==1.2.0 +tqdm \ No newline at end of file diff --git a/tb_logs/.gitkeep b/tb_logs/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/train.py b/train.py new file mode 100644 index 0000000..dc62143 --- /dev/null +++ b/train.py @@ -0,0 +1,73 @@ +import argparse +import yaml +import os + +import torch + +# import transformers +# import pandas as pd + +import pytorch_lightning as pl +from pytorch_lightning.callbacks.early_stopping import EarlyStopping +from pytorch_lightning.loggers import TensorBoardLogger + +# import wandb +############################## +from utils import data_pipeline, utils +from model.model import Model + +############################## + + +if __name__ == "__main__": + + # baseline_config 설정 불러오기 + with open("./config/config.yaml", encoding="utf-8") as f: + CFG = yaml.load(f, Loader=yaml.FullLoader) + + # experiments 폴더 내부에 실험 폴더 생성 + # 폴더 이름 : 실험 날짜 - 실험 시간 - user + experiment_path = utils.create_experiment_folder(CFG) + + # dataloader / model 설정 + dataloader = data_pipeline.Dataloader(CFG) + model = Model(CFG) + + # 텐서보드 테스트 + logger = TensorBoardLogger( + "tb_logs", name=f"{utils.get_experiment_folder_name(CFG)}" + ) + + # early_stopping 설정 + early_stop = CFG['early_stopping'] + early_stop_callback = EarlyStopping( + monitor=early_stop['monitor'], + min_delta=early_stop['min_delta'], + patience=early_stop['patience'], + verbose=early_stop['verbose'], + mode=early_stop['mode'] + ) + + # trainer 인스턴스 생성 + trainer = pl.Trainer( + accelerator="gpu", + devices=1, + max_epochs=CFG["train"]["max_epoch"], + log_every_n_steps=1, + logger=logger, + ) + + # Train part + trainer.fit(model=model, datamodule=dataloader) + ## datamodule에서 train_dataloader와 val_dataloader를 호출 + + ## Dataloader 내부에 val_dataloader 부분을 수정해서 + ## valid set을 바꿀 수 있음 + + trainer.test(model=model, datamodule=dataloader) + ## datamodule에서 test_dataloader 호출 + ## predict_path로 설정된 test.csv가 사용된다 + + # 학습된 모델 저장 (experiment_folder 안에 model.pt로 저장) + torch.save(model, os.path.join(experiment_path, "model.pt")) + print(f"모델이 저장되었습니다: {experiment_path}") diff --git a/utils/.gitkeep b/utils/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/utils/data_pipeline.py b/utils/data_pipeline.py new file mode 100644 index 0000000..7208ac8 --- /dev/null +++ b/utils/data_pipeline.py @@ -0,0 +1,139 @@ +from tqdm import tqdm + +import torch +import transformers +import pandas as pd +import pytorch_lightning as pl +from torch.utils.data import Dataset, DataLoader + + +class Dataset(torch.utils.data.Dataset): + def __init__(self, inputs, targets=[]): + self.inputs = inputs + self.targets = targets + + # 학습 및 추론 과정에서 데이터를 1개씩 꺼내오는 곳 + def __getitem__(self, idx): + # 정답이 있다면 else문을, 없다면 if문을 수행합니다 + if len(self.targets) == 0: + return torch.tensor(self.inputs[idx]) + else: + return torch.tensor(self.inputs[idx]), torch.tensor(self.targets[idx]) + + # 입력하는 개수만큼 데이터를 사용합니다 + def __len__(self): + return len(self.inputs) + + +# 나중에 Custom 가능 +class Dataloader(pl.LightningDataModule): + ## instance 생성할 때 CFG(baseline_config 세팅) 입력 + def __init__(self, CFG): + super().__init__() + ## config + self.user_name = CFG['user_name'] + self.seed = CFG['seed'] + + self.model_name = CFG['model']['model_name'] + self.batch_size = CFG['train']['batch_size'] + self.shuffle = CFG['train']['shuffle'] + + self.sampler = None + + self.train_path = CFG['data']['train_path'] + self.dev_path = CFG['data']['dev_path'] + self.test_path = CFG['data']['test_path'] + self.predict_path = CFG['data']['predict_path'] + + self.train_dataset = None + self.val_dataset = None + self.test_dataset = None + self.predict_dataset = None + + self.tokenizer = transformers.AutoTokenizer.from_pretrained(self.model_name, max_length=160) + self.target_columns = ['label'] + self.delete_columns = ['id'] + self.text_columns = ['sentence_1', 'sentence_2'] + + ## tokenizing과 preprocessing은 나중에 Custom 가능 + + ### 기존 코드 + ''' + def tokenizing(self, dataframe): + data = [] + for idx, item in tqdm(dataframe.iterrows(), desc='tokenizing', total=len(dataframe)): + # 두 입력 문장을 [SEP] 토큰으로 이어붙여서 전처리합니다. + text = '[SEP]'.join([item[text_column] for text_column in self.text_columns]) + outputs = self.tokenizer(text, add_special_tokens=True, padding='max_length', truncation=True) + data.append(outputs['input_ids']) + return data + ''' + + ### truncate & padding 추가 + def tokenizing(self, dataframe): + data = [] + for idx, item in tqdm(dataframe.iterrows(), desc='tokenizing', total=len(dataframe)): + # 두 입력 문장을 [SEP] 토큰으로 이어붙여서 전처리합니다. + text = '[SEP]'.join([item[text_column] for text_column in self.text_columns]) + # padding=True와 truncation=True 옵션 추가 + outputs = self.tokenizer( + text, + add_special_tokens=True, + padding='max_length', # max_length로 패딩을 고정 + truncation=True, # 텍스트를 최대 길이로 자름 + max_length=160 # max_length 설정 + ) + data.append(outputs['input_ids']) + return data + + def preprocessing(self, data): + # 안쓰는 컬럼을 삭제합니다. + data = data.drop(columns=self.delete_columns) + + # 타겟 데이터가 없으면 빈 배열을 리턴합니다. + try: + targets = data[self.target_columns].values.tolist() + except: + targets = [] + # 텍스트 데이터를 전처리합니다. + inputs = self.tokenizing(data) + + return inputs, targets + + def setup(self, stage='fit'): + if stage == 'fit': + # 학습 데이터와 검증 데이터셋을 호출합니다 + train_data = pd.read_csv(self.train_path) + val_data = pd.read_csv(self.dev_path) + + # 학습데이터 준비 + train_inputs, train_targets = self.preprocessing(train_data) + + # 검증데이터 준비 + val_inputs, val_targets = self.preprocessing(val_data) + + # train 데이터만 shuffle을 적용해줍니다, 필요하다면 val, test 데이터에도 shuffle을 적용할 수 있습니다 + self.train_dataset = Dataset(train_inputs, train_targets) + self.val_dataset = Dataset(val_inputs, val_targets) + else: + # 평가데이터 준비 + test_data = pd.read_csv(self.test_path) + test_inputs, test_targets = self.preprocessing(test_data) + self.test_dataset = Dataset(test_inputs, test_targets) + + predict_data = pd.read_csv(self.predict_path) + predict_inputs, predict_targets = self.preprocessing(predict_data) + self.predict_dataset = Dataset(predict_inputs, []) + + def train_dataloader(self): + return torch.utils.data.DataLoader(self.train_dataset, batch_size=self.batch_size, + shuffle=False) # self.shuffle) + + def val_dataloader(self): + return torch.utils.data.DataLoader(self.val_dataset, batch_size=self.batch_size) + + def test_dataloader(self): + return torch.utils.data.DataLoader(self.test_dataset, batch_size=self.batch_size) + + def predict_dataloader(self): + return torch.utils.data.DataLoader(self.predict_dataset, batch_size=self.batch_size) \ No newline at end of file diff --git a/utils/ensemble/distribution.ipynb b/utils/ensemble/distribution.ipynb new file mode 100644 index 0000000..9a1666b --- /dev/null +++ b/utils/ensemble/distribution.ipynb @@ -0,0 +1,278 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import warnings\n", + "\n", + "# 모든 경고 메시지 무시\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_label_count(exp_path):\n", + " df = pd.read_csv(f\"{exp_path}\", encoding=\"UTF-8\")\n", + "\n", + " # target 값을 반올림하여 새로운 컬럼 생성\n", + " df[\"rounded_target\"] = df[\"target\"].round(1)\n", + "\n", + " plt.figure(figsize=(12, 6))\n", + " # 반올림된 target 값을 기준으로 카운트\n", + " grouped_data = df.groupby(\"rounded_target\")[\"id\"].count()\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\")\n", + " plt.title(\"Label Count\")\n", + " plt.xlabel(\"Label\")\n", + " plt.ylabel(\"Count\")\n", + " plt.xticks(rotation=0) # x축 라벨 회전 없애기\n", + " plt.show()\n", + "\n", + "\n", + "def plot_label_count_df(df):\n", + " plt.figure(figsize=(12, 6))\n", + " grouped_data = df.groupby(\"target\")[\"id\"].count()\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\")\n", + " plt.title(\"label Count\")\n", + " plt.xlabel(\"label\")\n", + " plt.ylabel(\"Count\")\n", + " plt.show()\n", + "\n", + "\n", + "def plot_multiple_label_counts(exp_path):\n", + " num_experiments = len(exp_path)\n", + " num_cols = 2 # 한 줄에 두 개씩 배치\n", + " num_rows = (num_experiments + 1) // num_cols # 행의 수 계산\n", + "\n", + " # 전체 subplot 크기 설정\n", + " fig, axes = plt.subplots(num_rows, num_cols, figsize=(12, 6 * num_rows)) # subplot의 크기 설정\n", + "\n", + " for idx, exp_path in enumerate(exp_path):\n", + " row = idx // num_cols\n", + " col = idx % num_cols\n", + "\n", + " # DataFrame 불러오기\n", + " df = pd.read_csv(f\"{exp_path}\", encoding=\"UTF-8\")\n", + "\n", + " # 데이터를 그룹화하여 target 별 count 계산\n", + " grouped_data = df.groupby(\"target\")[\"id\"].count()\n", + "\n", + " # subplot에 각각의 그래프 그리기\n", + " if num_rows > 1:\n", + " ax = axes[row, col] # 2차원 배열에서 해당 위치의 subplot 지정\n", + " else:\n", + " ax = axes[col] # 1차원 배열일 경우\n", + "\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\", ax=ax)\n", + "\n", + " # subplot의 제목 및 축 설정\n", + " ax.set_title(f\"Label Count ({idx})\")\n", + " ax.set_xlabel(\"label\")\n", + " ax.set_ylabel(\"Count\")\n", + "\n", + " # 여백 자동 조정\n", + " plt.tight_layout()\n", + " # 그래프 출력\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result_path_list = [\n", + " \"./results/9017_kakaobank_kf-deberta-base_lr1e-5_batch16_train_augmentV3(minseo)_0.91849.csv\",\n", + " \"./results/9103_lucid-9103-09-15-10-56.csv\",\n", + " \"./results/9112_0921_0302_yeseo_mod.csv\",\n", + " \"./results/9125_klue-roberta-large.csv\",\n", + " \"./results/9128_team-lucid_deberta-v3-base-korean_lr1e-5_batch16_train_v3_01(minseo)_ 0.93010586.csv\",\n", + " \"./results/9150_team-lucid_deberta-v3-base-korean_lr1e-5_batch16_train_01(minseo)_0.93004.csv\",\n", + " \"./results/9166_klue-roberta-large-nnp.csv\",\n", + " \"./results/9179_snunlp-KR-ELECTRA-discriminator-V1.csv\",\n", + " \"./results/9191_snunlp:KR-ELECTRA-discriminator ep9.csv\",\n", + " \"./results/9207_0925_0640_yeseo.csv\",\n", + " \"./results/9215_kykim-electra-kor-base.csv\",\n", + " \"./results/9217_snunlp-KR-ELECTRA-discriminator-V2.csv\",\n", + " \"./results/9236_0924_1313_yeseo.csv\",\n", + " \"./results/9271_0923_0544_yeseo_nom.csv\",\n", + " \"./results/9312_0920_1904_yeseo_mod.csv\",\n", + " \"./results/9316_0922_0611_yeseo_nom.csv\",\n", + " \"./results/9469_KR-SBERT_split_v1.csv\",\n", + " \"./results/9556_KR-SBERT_split_v2.csv\",\n", + "]\n", + "score_list = [\n", + " 9017,\n", + " 9103,\n", + " 9112,\n", + " 9125,\n", + " 9128,\n", + " 9150,\n", + " 9166,\n", + " 9179,\n", + " 9191,\n", + " 9207,\n", + " 9215,\n", + " 9217,\n", + " 9236,\n", + " 9271,\n", + " 9312,\n", + " 9316,\n", + " 9469,\n", + " 9556,\n", + "]\n", + "\n", + "postprocessing_list = [True] * len(result_path_list)\n", + "\n", + "plot_multiple_label_counts(result_path_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from ensemble import ensemble_with_combinations, ensemble_with_metrics, ensemble\n", + "\n", + "# ensemble_with_combinations(result_path_list, score_list, postprocessing_list,5)\n", + "ensemble(result_path_list, score_list, postprocessing_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " DataFrame Entropy Gini Coefficient\n", + "0 0 9.800139 0.307980\n", + "1 1 10.103286 0.297423\n", + "2 2 10.103286 0.297130\n", + "3 3 9.816092 0.311022\n" + ] + } + ], + "source": [ + "# 엔트로피는 값이 높을수록 데이터가 고르게 분포되어 있음을 나타내고, 지니 계수는 값이 낮을수록 고른 분포를 의미\n", + "\n", + "def calculate_entropy(data):\n", + " value_counts = data.value_counts(normalize=True)\n", + " entropy = -np.sum(\n", + " value_counts * np.log2(value_counts + 1e-9)\n", + " ) # 작은 값 추가로 로그 계산시 0 방지\n", + " return entropy\n", + "\n", + "\n", + "def calculate_gini(data):\n", + " sorted_data = np.sort(data) # 데이터를 정렬\n", + " n = len(data)\n", + "\n", + " # 지니 계수 계산\n", + " cumulative_values = np.cumsum(sorted_data) # 누적 합계\n", + " gini = (2 * np.sum(cumulative_values) / cumulative_values[-1] - (n + 1)) / n\n", + "\n", + " # 지니 계수는 양수여야 하므로 절대값을 취해 0에서 1 사이로 맞춤\n", + " return np.abs(gini)\n", + "\n", + "\n", + "def compare_datasets(dataframes):\n", + " results = []\n", + "\n", + " for idx, df in enumerate(dataframes):\n", + " if \"target\" not in df.columns:\n", + " print(f\"DataFrame {idx} does not contain 'target' column.\")\n", + " continue\n", + "\n", + " entropy = calculate_entropy(df[\"target\"])\n", + " gini = calculate_gini(df[\"target\"])\n", + " results.append({\"DataFrame\": idx, \"Entropy\": entropy, \"Gini Coefficient\": gini})\n", + "\n", + " results_df = pd.DataFrame(results)\n", + " return results_df\n", + "\n", + "df0 = pd.read_csv(\"./ensemble_results/3peo_v4 + yeseo(7 model).csv\", encoding=\"UTF-8\")\n", + "df1 = pd.read_csv(\"./ensemble_results/ensemble_01.csv\", encoding=\"UTF-8\")\n", + "df2 = pd.read_csv(\"./ensemble_results/ensemble_y8_g5_m3_s2.csv\", encoding=\"UTF-8\")\n", + "df3 = pd.read_csv(\"./ensemble_results/all_ensemble.csv\", encoding=\"UTF-8\")\n", + "\n", + "dataframes = [df0, df1, df2,df3]\n", + "comparison_results = compare_datasets(dataframes)\n", + "print(comparison_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_label_count(\"./ensemble_results/ensemble_01.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/utils/ensemble/ensemble.py b/utils/ensemble/ensemble.py new file mode 100644 index 0000000..4a01406 --- /dev/null +++ b/utils/ensemble/ensemble.py @@ -0,0 +1,164 @@ +import random +import numpy as np +import pandas as pd +import torch +from typing import List +from itertools import combinations + + +## +def seed_everything(SEED=42): + """ + 시드 고정 + """ + deterministic = True + random.seed(SEED) + np.random.seed(SEED) + torch.manual_seed(SEED) + torch.cuda.manual_seed(SEED) + torch.cuda.manual_seed_all(SEED) + if deterministic: + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + + +def postprocessing(df: pd.DataFrame) -> pd.DataFrame: + """ + 후처리 함수 : 정규화 + """ + # target 컬럼의 최소값과 최대값 + min_val = df["target"].min() + max_val = df["target"].max() + + # 정규화: 0.0~1.0 범위로 변환 + df["target"] = (df["target"] - min_val) / (max_val - min_val) + # 다시 0.0~5.0 범위로 변환 + df["target"] = df["target"] * 5.0 + return df + + # 예측값에 단순 -0.1 뺄셈 + # df["target"] = df["target"].apply(lambda x: max(0, x - 0.1)) + # return df + + +def ensemble( + result_path_list: List[pd.DataFrame], + score_list: List[float], + postprocessing_list: List[bool], + save_path="./ensemble_results/ensemble.csv", +) -> pd.DataFrame: + """ + 점수 가중 평균 Ensemble + """ + df_submission, weight_sum = None, 0 + for i, (path, weight, pp) in enumerate( + zip(result_path_list, score_list, postprocessing_list) + ): + df_now = pd.read_csv(path) + # 후처리를 진행 + if pp: + df_now = postprocessing(df_now) + + # i == 0에서 제출 파일 생성 / 점수 가중 합 + if i == 0: + df_submission = pd.read_csv(path) + df_submission["target"] = weight * df_now["target"] + else: + df_submission["target"] += weight * df_now["target"] + + weight_sum += weight + + # 점수 가중 평균 + df_submission["target"] /= weight_sum + df_submission["target"] = df_submission["target"] + df_submission.to_csv(save_path, index=False) + + +def calculate_entropy(data): + value_counts = data.value_counts(normalize=True) + entropy = -np.sum( + value_counts * np.log2(value_counts + 1e-9) + ) # 작은 값 추가로 로그 계산시 0 방지 + return entropy + + +def calculate_gini(data): + sorted_data = np.sort(data) # 데이터를 정렬 + n = len(data) + + # 지니 계수 계산 + cumulative_values = np.cumsum(sorted_data) # 누적 합계 + gini = (2 * np.sum(cumulative_values) / cumulative_values[-1] - (n + 1)) / n + + # 지니 계수는 양수여야 하므로 절대값을 취해 0에서 1 사이로 맞춤 + return np.abs(gini) + + +def ensemble_with_metrics( + result_path_list: List[str], + score_lists: List[List[float]], + postprocessing_list: List[bool], +): + """ + 주어진 여러 점수 조합에 대해 앙상블을 수행하고, 그 결과의 지니계수와 엔트로피를 계산합니다. + """ + for score_list in score_lists: + save_path = f"./ensemble_results/ensemble_{'_'.join(map(str, score_list))}.csv" + print(f"\n=== 앙상블 결과 (score_list: {score_list}) ===") + + # 앙상블 진행 + df_submission = ensemble( + result_path_list, score_list, postprocessing_list, save_path=save_path + ) + + # 지니 계수 및 엔트로피 계산 + entropy = calculate_entropy(df_submission["target"]) + gini = calculate_gini(df_submission["target"]) + + # 결과 출력 + print(f"Entropy: {entropy:.4f}") + print(f"Gini Coefficient: {gini:.4f}") + + +def ensemble_with_combinations( + result_path_list: List[str], + score_lists: List[List[float]], + postprocessing_list: List[bool], + n: int, +): + """ + 주어진 경로 목록에서 n개 조합을 생성하여 앙상블을 진행한 후, 엔트로피 및 지니계수를 출력합니다. + """ + if len(result_path_list) < n: + print("Error: 경로 목록의 개수가 n보다 적습니다.") + return + + # n개의 조합을 생성 + path_combinations = list(combinations(result_path_list, n)) + score_combinations = list(combinations(score_lists, n)) + + for idx, (path_combination, score_combination) in enumerate( + zip(path_combinations, score_combinations) + ): + print(f"\n=== 조합 {idx + 1}: 선택된 파일들 ===") + for path in path_combination: + print(f"- {path}") + + save_path = f"./ensemble_results/ensemble_combination_{idx + 1}.csv" + + # 선택된 파일 경로와 점수 조합으로 앙상블 수행 + df_submission = ensemble( + path_combination, score_combination, postprocessing_list, save_path + ) + + # 지니 계수 및 엔트로피 계산 + entropy = calculate_entropy(df_submission["target"]) + gini = calculate_gini(df_submission["target"]) + + # 평균 점수 계산 + avg_score = np.mean([np.mean(scores) for scores in score_combination]) + + # 결과 출력 + print(f"Average Score: {avg_score:.4f}") + print(f"Entropy: {entropy:.4f}") + print(f"Gini Coefficient: {gini:.4f}") diff --git a/utils/preprocess/K-TACC/BERT_augmentation.py b/utils/preprocess/K-TACC/BERT_augmentation.py new file mode 100644 index 0000000..cd56f0f --- /dev/null +++ b/utils/preprocess/K-TACC/BERT_augmentation.py @@ -0,0 +1,71 @@ +import transformers +import re +import random +import numpy as np + + +class BERT_Augmentation(): + def __init__(self): + self.model_name = 'monologg/koelectra-base-v3-generator' + self.model = transformers.AutoModelForMaskedLM.from_pretrained(self.model_name) + self.tokenizer = transformers.AutoTokenizer.from_pretrained(self.model_name) + self.unmasker = transformers.pipeline("fill-mask", model=self.model, tokenizer=self.tokenizer) + random.seed(42) + def random_masking_replacement(self, sentence, ratio=0.15): + """Masking random eojeol of the sentence, and recover them using PLM. + + Args: + sentence (str): Source sentence + ratio (int): Ratio of masking + + Returns: + str: Recovered sentence + """ + + span = int(round(len(sentence.split()) * ratio)) + + # 품질 유지를 위해, 문장의 어절 수가 4 이하라면 원문장을 그대로 리턴합니다. + if len(sentence.split()) <= 4: + return sentence + + mask = self.tokenizer.mask_token + unmasker = self.unmasker + + unmask_sentence = sentence + # 처음과 끝 부분을 [MASK]로 치환 후 추론할 때의 품질이 좋지 않음. + random_idx = random.randint(1, len(unmask_sentence.split()) - span) + + unmask_sentence = unmask_sentence.split() + # del unmask_sentence[random_idx:random_idx+span] + cache = [] + for _ in range(span): + # 처음과 끝 부분을 [MASK]로 치환 후 추론할 때의 품질이 좋지 않음. + while cache and random_idx in cache: + random_idx = random.randint(1, len(unmask_sentence) - 2) + cache.append(random_idx) + unmask_sentence[random_idx] = mask + unmask_sentence = unmasker(" ".join(unmask_sentence))[0]['sequence'] + unmask_sentence = unmask_sentence.split() + unmask_sentence = " ".join(unmask_sentence) + unmask_sentence = unmask_sentence.replace(" ", " ") + + return unmask_sentence.strip() + + def random_masking_insertion(self, sentence, ratio=0.15): + + span = int(round(len(sentence.split()) * ratio)) + mask = self.tokenizer.mask_token + unmasker = self.unmasker + + # Recover + unmask_sentence = sentence + + for _ in range(span): + unmask_sentence = unmask_sentence.split() + random_idx = random.randint(0, len(unmask_sentence)-1) + unmask_sentence.insert(random_idx, mask) + unmask_sentence = unmasker(" ".join(unmask_sentence))[0]['sequence'] + + unmask_sentence = unmask_sentence.replace(" ", " ") + + return unmask_sentence.strip() \ No newline at end of file diff --git a/utils/preprocess/K-TACC/adverb_augmentation.py b/utils/preprocess/K-TACC/adverb_augmentation.py new file mode 100644 index 0000000..fa25e62 --- /dev/null +++ b/utils/preprocess/K-TACC/adverb_augmentation.py @@ -0,0 +1,56 @@ +import re +from bs4 import BeautifulSoup +from selenium import webdriver +import random +import requests +from kiwipiepy import Kiwi +import time +from quickspacer import Spacer +class AdverbAugmentation(): + def __init__(self): + self.kiwi = Kiwi() + self.spacing = Spacer().space + def _adverb_detector(self, sentence): + + # POS info + pos_list = [(x[0], x[1]) for x in self.kiwi.tokenize(sentence)] # (token, pos) + + adverb_list = [] + for pos in pos_list: + if pos[1] == "MAG" and len(pos[0]) > 1: # 1음절 부사는 제외함. + adverb_list.append(pos[0]) + return adverb_list + + def _get_gloss(self, word): + res = requests.get("https://dic.daum.net/search.do?q=" + word, timeout=5) + time.sleep(random.uniform(0.5,2.5)) + soup = BeautifulSoup(res.content, "html.parser") + try: + # 첫 번째 뜻풀이. + meaning = soup.find('span', class_='txt_search') + except AttributeError: + return word + if not meaning: + return word + + # parsing 결과에서 한글만 추출 + meaning = re.findall('[가-힣]+', str(meaning)) + meaning = ' '.join(meaning) + + # 띄어쓰기 오류 교정 (위 에 -> 위에) + # meaning = spell_checker.check(meaning).as_dict()['checked'].strip() + meaning = self.spacing([meaning.replace(" ", "")]) + return meaning[0].strip() + + def adverb_gloss_replacement(self, sentence): + adverb_list = self._adverb_detector(sentence) + if adverb_list: + # 부사들 중에서 1개만 랜덤으로 선택합니다. + adverb = random.choice(adverb_list) + try: + gloss = self._get_gloss(adverb) + sentence = sentence.replace(adverb, gloss) + except: + print('except: ', sentence) + pass + return sentence \ No newline at end of file diff --git a/utils/preprocess/K-TACC/aeda.py b/utils/preprocess/K-TACC/aeda.py new file mode 100644 index 0000000..38cc5e1 --- /dev/null +++ b/utils/preprocess/K-TACC/aeda.py @@ -0,0 +1,15 @@ +import random + +def aeda(sentence): + punc_list = list(".,;:?!") + + sentence = sentence.split() + random_ratio = random.uniform(0.1, 0.3) # 범위는 ADEA 논문을 따름. + n_ri = max(1, int(len(sentence) * random_ratio)) + + for _ in range(n_ri): + random_punc = random.choice(punc_list) + random_idx = random.randint(0, len(sentence)-1) + sentence.insert(random_idx, random_punc) + + return ' '.join(sentence).strip() diff --git a/utils/preprocess/K-TACC/augmentation.ipynb b/utils/preprocess/K-TACC/augmentation.ipynb new file mode 100644 index 0000000..18a6165 --- /dev/null +++ b/utils/preprocess/K-TACC/augmentation.ipynb @@ -0,0 +1,421 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "3f6d8273-0de9-48e7-ab4f-c2e5638bb669", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from BERT_augmentation import BERT_Augmentation\n", + "from adverb_augmentation import AdverbAugmentation\n", + "import transformers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "98f6be27-3445-4bdd-ba5a-e29f06498477", + "metadata": {}, + "outputs": [], + "source": [ + "BERT_aug = BERT_Augmentation()\n", + "random_masking_replacement = BERT_aug.random_masking_replacement\n", + "random_masking_insertion = BERT_aug.random_masking_insertion" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "59d6ed1d-4141-4fc3-82f1-3a57cb2bb5e8", + "metadata": {}, + "outputs": [], + "source": [ + "adverb_aug = AdverbAugmentation()\n", + "adverb_gloss_replacement = adverb_aug.adverb_gloss_replacement" + ] + }, + { + "cell_type": "markdown", + "id": "7237afb4-e905-42ab-9e35-4e99242b4ba8", + "metadata": {}, + "source": [ + "## BERT augmentation" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8c81422c-9f0c-4965-ad4c-571af4304fbd", + "metadata": {}, + "outputs": [], + "source": [ + "sentence = \"아버지가 오늘 아침에 부엌에 있었다가 갑자기 일어나시더니 슬그머니 안방으로 들어가셨다.\"\n", + "ratio = 0.15" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "960cc219-aa14-44f9-a1fb-494c3c3617d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "random_masking_replacement: 아버지가 오늘은 부엌에 있었다가 갑자기 일어나 슬그머니 안방으로 들어가셨다.\n", + "random_insertion_replacement: 그런데 아버지가 오늘 아침에 부엌에 있었다가 갑자기 벌떡 일어나시더니 슬그머니 안방으로 들어가셨다.\n" + ] + } + ], + "source": [ + "print('random_masking_replacement:', random_masking_replacement(sentence, ratio))\n", + "print('random_insertion_replacement:', random_masking_insertion(sentence, ratio))" + ] + }, + { + "cell_type": "markdown", + "id": "c079b51c-400b-4773-a84b-cfc1219146a9", + "metadata": {}, + "source": [ + "## Adverb augmentation" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "802c3abd-ed68-4a3d-a1c9-a4401da7fbb5", + "metadata": {}, + "outputs": [], + "source": [ + "sentence = \"아버지가 부엌에 있었다가 갑자기 일어나시더니 슬그머니 안방으로 들어가셨다.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "bd28e530-228c-4598-b2aa-23d6dc74beb3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'아버지가 부엌에 있었다가 생각할 겨를도 없이 빨리 일어나시더니 슬그머니 안방으로 들어가셨다.'" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adverb_gloss_replacement(sentence)" + ] + }, + { + "cell_type": "markdown", + "id": "04527424-83ab-453c-816d-81b015ae3f94", + "metadata": {}, + "source": [ + "## 기존 EDA 방법 (KorEDA)\n", + "- random_delete\n", + "- random_swap\n", + "- synonym_replacement\n", + "- random_insert" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "id": "dbfa8c99-c85f-44b2-8433-e0b0a88a4f30", + "metadata": {}, + "outputs": [], + "source": [ + "from koreda import synonym_replacement, random_deletion, random_swap, random_insertion" + ] + }, + { + "cell_type": "code", + "execution_count": 864, + "id": "d12240c6-73e9-4f98-89f3-e30224468d7c", + "metadata": {}, + "outputs": [], + "source": [ + "sentence = \"이순신은 조선 중기의 매우 뛰어난 전략가이자 용맹한 무신이다.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 865, + "id": "793ff40c-cb1f-45a4-8bac-caaaa49cf77f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "synonym_replacement: 이순신은 조선 중기의 매우 뛰어난 전략가이자 용맹한 무신이다.\n", + "random_deletion: 이순신은 조선 중기의 매우 전략가이자 용맹한 무신이다.\n", + "random_swap: 이순신은 조선 무신이다. 매우 뛰어난 전략가이자 용맹한 중기의\n", + "random_insertion: 이순신은 조선 중기의 매우 뛰어난 전략가이자 용맹한 무신이다.\n" + ] + } + ], + "source": [ + "print('synonym_replacement: ', \" \".join(synonym_replacement(sentence.split(), 1)))\n", + "print('random_deletion: ', \" \".join(random_deletion(sentence.split(), 0.15)))\n", + "print('random_swap: ', \" \".join(random_swap(sentence.split(), 1)))\n", + "print('random_insertion: ', \" \".join(random_insertion(sentence.split(), 1)))" + ] + }, + { + "cell_type": "markdown", + "id": "1a6c97ad-d568-43e6-a092-869b7b00dc79", + "metadata": {}, + "source": [ + "## AEDA" + ] + }, + { + "cell_type": "code", + "execution_count": 867, + "id": "aabe5ef2-4e37-481b-ab85-3a3856d638b3", + "metadata": {}, + "outputs": [], + "source": [ + "from aeda import aeda" + ] + }, + { + "cell_type": "code", + "execution_count": 868, + "id": "e0a80bbf-6105-4b0a-bc5d-ec903e33bc1d", + "metadata": {}, + "outputs": [], + "source": [ + "sentence = \"이순신은 조선 중기의 매우 뛰어난 전략가이자 용맹한 무신이다.\"" + ] + }, + { + "cell_type": "code", + "execution_count": 877, + "id": "83a05672-0e90-4de2-8f51-dbf4ed17c8be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aeda: ! 이순신은 . 조선 중기의 매우 뛰어난 전략가이자 용맹한 무신이다.\n" + ] + } + ], + "source": [ + "print('aeda: ', aeda(sentence))" + ] + }, + { + "cell_type": "markdown", + "id": "2251fec3-5f03-4fa9-b2b9-c6c22e2c94f1", + "metadata": {}, + "source": [ + "## dataset의 크기" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "86df2c23-88cf-4fd5-a26f-83b7541124cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "11668\n" + ] + } + ], + "source": [ + "# dataset\n", + "orig_train = pd.read_json('sts/datasets/klue-sts-v1.1_train.json')\n", + "print(len(orig_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "a4cad170-2918-46d7-af3c-82c19a093fe6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22945\n" + ] + } + ], + "source": [ + "random_masking_replacement_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_random_masking_replacement_augset_span_0.15.json')\n", + "print(len(random_masking_replacement_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "d07977a9-e48d-46ba-9009-bf9f67af5f6d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23116\n" + ] + } + ], + "source": [ + "random_masking_insertion_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_random_masking_insertion_augset_span_0.15.json')\n", + "print(len(random_masking_insertion_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "513e42a0-7457-4617-be76-0fd10cf1148e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20459\n" + ] + } + ], + "source": [ + "adverb_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_adverb_augset.json')\n", + "print(len(adverb_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "2306e333-7fd0-4e59-a218-c1b75a650d13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "18115\n" + ] + } + ], + "source": [ + "sr_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_sr_augset.json')\n", + "print(len(sr_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "1401c028-96d1-434f-ad79-f9f1e74a1947", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23327\n" + ] + } + ], + "source": [ + "rs_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_rs_augset.json')\n", + "print(len(rs_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "c6e481fb-80ba-424c-b4fa-d3f944e495ab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22122\n" + ] + } + ], + "source": [ + "rd_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_rd_augset.json')\n", + "print(len(rd_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "6fca6408-8e87-422e-8235-d5c964d71edc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "18464\n" + ] + } + ], + "source": [ + "ri_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_ri_augset.json')\n", + "print(len(ri_train))" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "89260947-7350-46b9-96fa-e55e160efedb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23329\n" + ] + } + ], + "source": [ + "aeda_train = pd.read_json('sts/datasets/klue-sts-v1.1_train_aeda_augset.json')\n", + "print(len(aeda_train))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ame", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/utils/preprocess/K-TACC/augmentation.py b/utils/preprocess/K-TACC/augmentation.py new file mode 100644 index 0000000..718a51e --- /dev/null +++ b/utils/preprocess/K-TACC/augmentation.py @@ -0,0 +1,173 @@ +# Making Augset +import pandas as pd +from BERT_augmentation import BERT_Augmentation +from adverb_augmentation import AdverbAugmentation +from aeda import aeda +from tqdm import tqdm +from multiprocessing import Pool +import joblib +from functools import partial +import numpy as np + +tqdm.pandas() + +BERT_aug = BERT_Augmentation() +random_masking_replacement = BERT_aug.random_masking_replacement +random_masking_insertion = BERT_aug.random_masking_insertion +adverb_aug = AdverbAugmentation() +adverb_gloss_replacement = adverb_aug.adverb_gloss_replacement + +orig_train = pd.read_json("sts/datasets/klue-sts-v1.1_train.json") + + +def apply_random_masking_replacement(x, ratio=0.15): + return random_masking_replacement(x, ratio=ratio) + + +# dataset + +random_masking_replacement_train = orig_train.copy() +pool = joblib.Parallel(n_jobs=8, prefer="threads") +mapper = joblib.delayed(apply_random_masking_replacement) +tasks = [ + mapper(row) for i, row in random_masking_replacement_train["sentence_1"].items() +] +random_masking_replacement_train["sentence_1"] = pool(tqdm(tasks)) + +tasks = [ + mapper(row) for i, row in random_masking_replacement_train["sentence_2"].items() +] +random_masking_replacement_train["sentence_2"] = pool(tqdm(tasks)) + +random_masking_replacement_augset = pd.concat( + [orig_train, random_masking_replacement_train] +) +random_masking_replacement_augset.drop_duplicates( + ["sentence_1", "sentence_2"], inplace=True +) +print(len(random_masking_replacement_augset)) + +random_masking_replacement_augset.reset_index().to_json( + "sts/datasets/klue-sts-v1.1_train_random_masking_replacement_augset_span_0.15_nospan.json" +) + + +# random insertion +def apply_random_masking_insertion(x, ratio=0.15): + return random_masking_insertion(x, ratio=ratio) + + +ratio = 0.15 +random_masking_insertion_train = orig_train.copy() +pool = joblib.Parallel(n_jobs=8, prefer="threads") +mapper = joblib.delayed(apply_random_masking_insertion) +tasks = [mapper(row) for i, row in random_masking_insertion_train["sentence_1"].items()] +random_masking_insertion_train["sentence_1"] = pool(tqdm(tasks)) + +tasks = [mapper(row) for i, row in random_masking_insertion_train["sentence_2"].items()] +random_masking_insertion_train["sentence_2"] = pool(tqdm(tasks)) + +random_masking_insertion_augset = pd.concat( + [orig_train, random_masking_insertion_train] +) +random_masking_insertion_augset.drop_duplicates( + ["sentence_1", "sentence_2"], inplace=True +) +print(len(random_masking_insertion_augset)) +random_masking_insertion_augset.reset_index().to_json( + "sts/datasets/klue-sts-v1.1_train_random_masking_insertion_augset_span_0.15_nospan.json" +) + + +# # adverb +adverb_train = orig_train.copy() + + +def apply_adverb_gloss_replacement(df, ratio): + df["sentence_1"] = df["sentence_1"].progress_apply( + lambda x: adverb_gloss_replacement(x) + ) + df["sentence_2"] = df["sentence_2"].progress_apply( + lambda x: adverb_gloss_replacement(x) + ) + return df + + +adverb_train["sentence_1"] = adverb_train["sentence_1"].progress_apply( + lambda x: adverb_gloss_replacement(x) +) +adverb_train["sentence_2"] = adverb_train["sentence_2"].progress_apply( + lambda x: adverb_gloss_replacement(x) +) +adverb_augset = pd.concat([orig_train, adverb_train]) +adverb_augset.drop_duplicates(["sentence_1", "sentence_2"], inplace=True) +print(len(adverb_augset)) +adverb_augset.reset_index().to_json( + "sts/datasets/klue-sts-v1.1_train_adverb_augset.json" +) + + +# # koreda +from koreda import synonym_replacement, random_deletion, random_swap, random_insertion +from aeda import aeda + +# synonym_replacement +sr_train = orig_train.copy() +sr_train["sentence_1"] = sr_train["sentence_1"].apply( + lambda x: " ".join(synonym_replacement(x.split(), 1)) +) +sr_train["sentence_2"] = sr_train["sentence_2"].apply( + lambda x: " ".join(synonym_replacement(x.split(), 1)) +) +sr_augset = pd.concat([orig_train, sr_train]) +sr_augset.drop_duplicates(["sentence_1", "sentence_2"], inplace=True) +print(len(sr_augset)) +sr_augset.reset_index().to_json("sts/datasets/klue-sts-v1.1_train_sr_augset.json") + +# random_deletion +rd_train = orig_train.copy() +rd_train["sentence_1"] = rd_train["sentence_1"].apply( + lambda x: " ".join(random_deletion(x.split(), 0.15)) +) +rd_train["sentence_2"] = rd_train["sentence_2"].apply( + lambda x: " ".join(random_deletion(x.split(), 0.15)) +) +rd_augset = pd.concat([orig_train, rd_train]) +rd_augset.drop_duplicates(["sentence_1", "sentence_2"], inplace=True) +print(len(rd_augset)) +rd_augset.reset_index().to_json("sts/datasets/klue-sts-v1.1_train_rd_augset.json") + +# random_swap +rs_train = orig_train.copy() +rs_train["sentence_1"] = rs_train["sentence_1"].apply( + lambda x: " ".join(random_swap(x.split(), 1)) +) +rs_train["sentence_2"] = rs_train["sentence_2"].apply( + lambda x: " ".join(random_swap(x.split(), 1)) +) +rs_augset = pd.concat([orig_train, rs_train]) +rs_augset.drop_duplicates(["sentence_1", "sentence_2"], inplace=True) +print(len(rs_augset)) +rs_augset.reset_index().to_json("sts/datasets/klue-sts-v1.1_train_rs_augset.json") + +# random_insertion +ri_train = orig_train.copy() +ri_train["sentence_1"] = ri_train["sentence_1"].apply( + lambda x: " ".join(random_insertion(x.split(), 1)) +) +ri_train["sentence_2"] = ri_train["sentence_2"].apply( + lambda x: " ".join(random_insertion(x.split(), 1)) +) +ri_augset = pd.concat([orig_train, ri_train]) +ri_augset.drop_duplicates(["sentence_1", "sentence_2"], inplace=True) +print(len(ri_augset)) +ri_augset.reset_index().to_json("sts/datasets/klue-sts-v1.1_train_ri_augset.json") + +# aeda +aeda_train = orig_train.copy() +aeda_train["sentence_1"] = aeda_train["sentence_1"].apply(lambda x: aeda(x)) +aeda_train["sentence_2"] = aeda_train["sentence_2"].apply(lambda x: aeda(x)) +aeda_augset = pd.concat([orig_train, aeda_train]) +aeda_augset.drop_duplicates(["sentence_1", "sentence_2"], inplace=True) +print(len(aeda_augset)) +aeda_augset.reset_index().to_json("sts/datasets/klue-sts-v1.1_train_aeda_augset.json") diff --git a/utils/preprocess/K-TACC/install.sh b/utils/preprocess/K-TACC/install.sh new file mode 100644 index 0000000..545178f --- /dev/null +++ b/utils/preprocess/K-TACC/install.sh @@ -0,0 +1,7 @@ +# py-hanspell +git clone https://github.com/ssut/py-hanspell.git +cd py-hanspell +python setup.py install +cd .. + +pip install -r requirements.txt \ No newline at end of file diff --git a/utils/preprocess/K-TACC/koreda.py b/utils/preprocess/K-TACC/koreda.py new file mode 100644 index 0000000..51123b9 --- /dev/null +++ b/utils/preprocess/K-TACC/koreda.py @@ -0,0 +1,183 @@ +''' +This code was forked from +https://github.com/catSirup/KorEDA/blob/master/eda.py +''' + + +import random +import pickle +import re + +wordnet = {} +with open("wordnet.pickle", "rb") as f: + wordnet = pickle.load(f) + + +# 한글만 남기고 나머지는 삭제 +def get_only_hangul(line): + parseText= re.compile('/ ^[ㄱ-ㅎㅏ-ㅣ가-힣]*$/').sub('',line) + + return parseText + +######################################################################## +# Synonym replacement +# Replace n words in the sentence with synonyms from wordnet +######################################################################## +def synonym_replacement(words, n): + new_words = words.copy() + random_word_list = list(set([word for word in words])) + random.shuffle(random_word_list) + num_replaced = 0 + for random_word in random_word_list: + synonyms = get_synonyms(random_word) + if len(synonyms) >= 1: + synonym = random.choice(list(synonyms)) + new_words = [synonym if word == random_word else word for word in new_words] + num_replaced += 1 + if num_replaced >= n: + break + + if len(new_words) != 0: + sentence = ' '.join(new_words) + new_words = sentence.split(" ") + + else: + new_words = "" + + return new_words + + +def get_synonyms(word): + synomyms = [] + + try: + for syn in wordnet[word]: + for s in syn: + synomyms.append(s) + except: + pass + + return synomyms + +######################################################################## +# Random deletion +# Randomly delete words from the sentence with probability p +######################################################################## +def random_deletion(words, p): + if len(words) == 1: + return words + + new_words = [] + for word in words: + r = random.uniform(0, 1) + if r > p: + new_words.append(word) + + if len(new_words) == 0: + rand_int = random.randint(0, len(words)-1) + return [words[rand_int]] + + return new_words + +######################################################################## +# Random swap +# Randomly swap two words in the sentence n times +######################################################################## +def random_swap(words, n): + new_words = words.copy() + for _ in range(n): + new_words = swap_word(new_words) + + return new_words + +def swap_word(new_words): + random_idx_1 = random.randint(0, len(new_words)-1) + random_idx_2 = random_idx_1 + counter = 0 + + while random_idx_2 == random_idx_1: + random_idx_2 = random.randint(0, len(new_words)-1) + counter += 1 + if counter > 3: + return new_words + + new_words[random_idx_1], new_words[random_idx_2] = new_words[random_idx_2], new_words[random_idx_1] + return new_words + +######################################################################## +# Random insertion +# Randomly insert n words into the sentence +######################################################################## +def random_insertion(words, n): + new_words = words.copy() + for _ in range(n): + add_word(new_words) + + return new_words + + +def add_word(new_words): + synonyms = [] + counter = 0 + while len(synonyms) < 1: + if len(new_words) >= 1: + random_word = new_words[random.randint(0, len(new_words)-1)] + synonyms = get_synonyms(random_word) + counter += 1 + else: + random_word = "" + + if counter >= 10: + return + + random_synonym = synonyms[0] + random_idx = random.randint(0, len(new_words)-1) + new_words.insert(random_idx, random_synonym) + + + +def EDA(sentence, alpha_sr=0.1, alpha_ri=0.1, alpha_rs=0.1, p_rd=0.1, num_aug=9): + # sentence = get_only_hangul(sentence) + words = sentence.split(' ') + words = [word for word in words if word is not ""] + num_words = len(words) + + augmented_sentences = [] + num_new_per_technique = int(num_aug/4) + 1 + + n_sr = max(1, int(alpha_sr*num_words)) + n_ri = max(1, int(alpha_ri*num_words)) + n_rs = max(1, int(alpha_rs*num_words)) + + # sr + for _ in range(num_new_per_technique): + a_words = synonym_replacement(words, n_sr) + augmented_sentences.append(' '.join(a_words)) + + # ri + for _ in range(num_new_per_technique): + a_words = random_insertion(words, n_ri) + augmented_sentences.append(' '.join(a_words)) + + # rs + for _ in range(num_new_per_technique): + a_words = random_swap(words, n_rs) + augmented_sentences.append(" ".join(a_words)) + + # rd + for _ in range(num_new_per_technique): + a_words = random_deletion(words, p_rd) + augmented_sentences.append(" ".join(a_words)) + + augmented_sentences = [get_only_hangul(sentence) for sentence in augmented_sentences] + random.shuffle(augmented_sentences) + + if num_aug >= 1: + augmented_sentences = augmented_sentences[:num_aug] + else: + keep_prob = num_aug / len(augmented_sentences) + augmented_sentences = [s for s in augmented_sentences if random.uniform(0, 1) < keep_prob] + + augmented_sentences.append(sentence) + + return augmented_sentences \ No newline at end of file diff --git a/utils/preprocess/K-TACC/requirements.txt b/utils/preprocess/K-TACC/requirements.txt new file mode 100644 index 0000000..312bb7c --- /dev/null +++ b/utils/preprocess/K-TACC/requirements.txt @@ -0,0 +1,20 @@ +# for augmentation +torch +transformers +kiwipiepy +requests +selenium +bs4 +joblib + +# for fine-tuning +pyYAML +pytorch-lightning==1.9.1 +tqdm +torchmetrics +pandas +omegaconf +quickspacer + +# dev +wandb \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/adverb_config.yaml b/utils/preprocess/K-TACC/sts/adverb_config.yaml new file mode 100644 index 0000000..400eb89 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/adverb_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_adverb_augset.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'adverb_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/aeda_config.yaml b/utils/preprocess/K-TACC/sts/aeda_config.yaml new file mode 100644 index 0000000..6b20175 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/aeda_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_aeda_augset.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'aeda_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/base_config.yaml b/utils/preprocess/K-TACC/sts/base_config.yaml new file mode 100644 index 0000000..0412474 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/base_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: False + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'base_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/dataloader.py b/utils/preprocess/K-TACC/sts/dataloader.py new file mode 100644 index 0000000..a892b07 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/dataloader.py @@ -0,0 +1,94 @@ +import re +import pandas as pd +from tqdm.auto import tqdm +import transformers +import torch +import pytorch_lightning as pl +from ast import literal_eval + +class Dataset(torch.utils.data.Dataset): + def __init__(self, inputs, targets=[]): + self.inputs = inputs + self.targets = targets + + def __getitem__(self, idx): + if len(self.targets) == 0: + return torch.tensor(self.inputs[idx]) + else: + return torch.tensor(self.inputs[idx]), torch.tensor(self.targets[idx]).unsqueeze(0) + + def __len__(self): + return len(self.inputs) + +class Dataloader(pl.LightningDataModule): + def __init__(self, cfg, idx=None): + super().__init__() + self.model_name = cfg.model.model_name + self.batch_size = cfg.train.batch_size + self.shuffle = cfg.data.shuffle + self.max_length = cfg.data.max_length + + self.train_path = cfg.path.train_path + self.dev_path = cfg.path.dev_path + self.test_path = cfg.path.test_path + + self.train_dataset = None + self.dev_dataset = None + self.test_dataset = None + + self.tokenizer = transformers.AutoTokenizer.from_pretrained(self.model_name, max_length=self.max_length) + self.target_columns = ['labels'] + self.delete_columns = ['guid'] + self.text_columns = ['sentence1', 'sentence2'] + + def tokenizing(self, dataframe): + data = [] + for idx, item in tqdm(dataframe.iterrows(), desc='tokenizing', total=len(dataframe)): + text = self.tokenizer.sep_token.join([item[text_column] for text_column in self.text_columns]) + outputs = self.tokenizer(text, + add_special_tokens=True, + max_length=self.max_length, + padding='max_length', truncation=True) + data.append(outputs['input_ids']) + return data + + def preprocessing(self, data): + data = data.drop(columns=self.delete_columns) + + targets = [x[0]['label'] for x in data[self.target_columns].values.tolist()] + inputs = self.tokenizing(data) + return inputs, targets + + def setup(self, stage='fit'): + if stage == 'fit': + train_data = pd.read_json(self.train_path) + dev_data = pd.read_json(self.dev_path) + + train_inputs, train_targets = self.preprocessing(train_data) + dev_inputs, dev_targets = self.preprocessing(dev_data) + + self.train_dataset = Dataset(train_inputs, train_targets) + self.dev_dataset = Dataset(dev_inputs, dev_targets) + + else: + test_data = pd.read_json(self.test_path) + test_inputs, test_targets = self.preprocessing(test_data) + self.test_dataset = Dataset(test_inputs, test_targets) + + def train_dataloader(self): + return torch.utils.data.DataLoader(self.train_dataset, + batch_size=self.batch_size, + shuffle=self.shuffle) + + def val_dataloader(self): + return torch.utils.data.DataLoader(self.dev_dataset, + batch_size=self.batch_size, + shuffle=False) + + def test_dataloader(self): + return torch.utils.data.DataLoader(self.test_dataset, + batch_size=self.batch_size, + shuffle=False) + + + \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/model.py b/utils/preprocess/K-TACC/sts/model.py new file mode 100644 index 0000000..a345a6c --- /dev/null +++ b/utils/preprocess/K-TACC/sts/model.py @@ -0,0 +1,72 @@ +import os +import sys + +import transformers +from transformers import get_cosine_schedule_with_warmup +import torch +import torchmetrics +import pytorch_lightning as pl +from torch.optim.lr_scheduler import CosineAnnealingLR, ExponentialLR, OneCycleLR +import numpy as np +import wandb +from pytorch_lightning.loggers import WandbLogger + +class Model(pl.LightningModule): + def __init__(self, cfg): + super().__init__() + self.save_hyperparameters() + self.model_name = cfg.model.model_name + self.lr = cfg.train.learning_rate + self.drop_out = cfg.train.drop_out + self.warmup_ratio = cfg.train.warmup_ratio + self.weight_decay = cfg.train.weight_decay + self.plm = transformers.AutoModelForSequenceClassification.from_pretrained( + pretrained_model_name_or_path=self.model_name, + num_labels=1, + hidden_dropout_prob=self.drop_out, + attention_probs_dropout_prob=self.drop_out + ) + self.epoch = cfg.train.max_epoch + self.batch_size = cfg.train.batch_size + + self.loss_func = torch.nn.L1Loss() + self.optimizer = torch.optim.AdamW(params=self.parameters(), lr=self.lr) + + def forward(self, x): + x = self.plm(x)['logits'] + + return x + + def training_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + loss = self.loss_func(logits, y.float()) + self.log("train_loss", loss, on_step=True, on_epoch=True, prog_bar=True, logger=True) + return loss + + def validation_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + loss = self.loss_func(logits, y.float()) + self.log("val_loss", loss, prog_bar=True, logger=True) + pearson_corr = torchmetrics.functional.pearson_corrcoef(logits.squeeze(), y.squeeze()) + self.log("val_pearson", pearson_corr, prog_bar=True, logger=True) + + return {'val_loss':loss, 'val_pearson_corr':pearson_corr} + + def test_step(self, batch, batch_idx): + x, y = batch + logits = self(x) + test_pearson_corr = torchmetrics.functional.pearson_corrcoef(logits.squeeze(), y.squeeze()) + self.log("test_pearson", test_pearson_corr) + return test_pearson_corr + + def configure_optimizers(self): + optimizer = torch.optim.AdamW(params=self.parameters(), lr=self.lr, weight_decay=self.weight_decay) + # scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2, eta_min=self.lr*0.01, last_epoch=-1) + scheduler = get_cosine_schedule_with_warmup(optimizer, num_warmup_steps=self.warmup_ratio*self.trainer.estimated_stepping_batches, + num_training_steps=self.trainer.estimated_stepping_batches) + # scheduler = ExponentialLR(optimizer, gamma=0.5) + scheduler = {'scheduler':scheduler, 'interval':'step', 'frequency':1} + + return [optimizer], [scheduler] \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/random_deletion_config.yaml b/utils/preprocess/K-TACC/sts/random_deletion_config.yaml new file mode 100644 index 0000000..75cfe1e --- /dev/null +++ b/utils/preprocess/K-TACC/sts/random_deletion_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_rd_augset.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'eda_random_deletion_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/random_insertion_config.yaml b/utils/preprocess/K-TACC/sts/random_insertion_config.yaml new file mode 100644 index 0000000..d070398 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/random_insertion_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_ri_augset.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'eda_random_insertion_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/random_masking_insertion1_config.yaml b/utils/preprocess/K-TACC/sts/random_masking_insertion1_config.yaml new file mode 100644 index 0000000..166b2d8 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/random_masking_insertion1_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_random_masking_insertion_augset_0.15.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'random_masking_insertion_1_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/random_masking_replacement1_config.yaml b/utils/preprocess/K-TACC/sts/random_masking_replacement1_config.yaml new file mode 100644 index 0000000..769a660 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/random_masking_replacement1_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_random_masking_replacement_augset_0.15.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'random_masking_replacement_1_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/random_swap_config.yaml b/utils/preprocess/K-TACC/sts/random_swap_config.yaml new file mode 100644 index 0000000..82a530a --- /dev/null +++ b/utils/preprocess/K-TACC/sts/random_swap_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_rs_augset.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'eda_random_swap_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/random_synonym_replacement_config.yaml b/utils/preprocess/K-TACC/sts/random_synonym_replacement_config.yaml new file mode 100644 index 0000000..f68e262 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/random_synonym_replacement_config.yaml @@ -0,0 +1,27 @@ +path: + train_path: datasets/klue-sts-v1.1_train_sr_augset.json + dev_path: datasets/klue-sts-v1.1_dev.json + test_path: datasets/klue-sts-v1.1_dev.json + +data: + shuffle: True + augmentation: True + max_length : 128 + +model: + model_name: 'monologg/koelectra-base-v3-discriminator' + saved_name: 'eda_random_synonym_replacement_model' + +train: + seed: 42 + batch_size: 32 + max_epoch: 4 + learning_rate: 5e-5 + logging_step: 100 + drop_out: 0.1 + warmup_ratio: 0.1 + weight_decay: 0.01 + +runner: + options: + num_workers: 8 \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/train.py b/utils/preprocess/K-TACC/sts/train.py new file mode 100644 index 0000000..9a6fcd7 --- /dev/null +++ b/utils/preprocess/K-TACC/sts/train.py @@ -0,0 +1,54 @@ +import argparse +from tqdm.auto import tqdm +from omegaconf import OmegaConf + +# pl modules +import pytorch_lightning as pl +from pytorch_lightning.callbacks import ModelCheckpoint, LearningRateMonitor +from pytorch_lightning.utilities.seed import seed_everything + +# Dataloader & Model +from dataloader import Dataloader +from model import Model +import wandb +from pytorch_lightning.loggers import WandbLogger + +def main(cfg): + # Load dataloader & model + dataloader = Dataloader(cfg) + model = Model(cfg) + lr_monitor = LearningRateMonitor(logging_interval='step') + + wandb_logger = WandbLogger(project='korean_linguistic_augmentation', + name=f'{cfg.model.saved_name}_{cfg.train.learning_rate}', + log_model="all") + # checkpoint config + checkpoint_callback = ModelCheckpoint(dirpath='saved/', + monitor='val_pearson', + mode='max', + filename=f'{cfg.model.saved_name}', + save_top_k=0) + + # Train & Test + trainer = pl.Trainer(accelerator="gpu", max_epochs=cfg.train.max_epoch, + log_every_n_steps=cfg.train.logging_step, + val_check_interval=1.0, + callbacks=[checkpoint_callback, lr_monitor], + logger=wandb_logger) + + trainer.fit(model=model, datamodule=dataloader) + trainer.test(model=model, datamodule=dataloader) + wandb.finish() + +if __name__ == '__main__': + # receive arguments + parser = argparse.ArgumentParser() + parser.add_argument('--config', type=str, default='') + args, _ = parser.parse_known_args() + cfg = OmegaConf.load(f'./{args.config}.yaml') + + # seed + seed_everything(cfg.train.seed) + + # main + main(cfg) \ No newline at end of file diff --git a/utils/preprocess/K-TACC/sts/train.sh b/utils/preprocess/K-TACC/sts/train.sh new file mode 100644 index 0000000..c24257a --- /dev/null +++ b/utils/preprocess/K-TACC/sts/train.sh @@ -0,0 +1,20 @@ +# base +python train.py --config base_config + +# Random Masking Replacement +python train.py --config random_masking_replacement1_config + +# Random Masking Insertion +python train.py --config random_masking_insertion1_config + +# Adverb Augmentation +python train.py --config adverb_config + +# AEDA +python train.py --config aeda_config + +# EDA +python train.py --config random_deletion_config +python train.py --config random_insertion_config +python train.py --config random_swap_config +python train.py --config random_synonym_replacement_config \ No newline at end of file diff --git a/utils/preprocess/K-TACC/wordnet.pickle b/utils/preprocess/K-TACC/wordnet.pickle new file mode 100644 index 0000000..5275511 Binary files /dev/null and b/utils/preprocess/K-TACC/wordnet.pickle differ diff --git a/utils/preprocess/augmentation.py b/utils/preprocess/augmentation.py new file mode 100644 index 0000000..fe15956 --- /dev/null +++ b/utils/preprocess/augmentation.py @@ -0,0 +1,507 @@ +""" +Main Reference : https://github.com/boostcampaitech5/level1_semantictextsimilarity-nlp-11/blob/main/augmentation.py +""" + +import os +import re +import pickle +import random +import numpy as np +import pandas as pd +from tqdm.auto import tqdm +from enum import Enum +from typing import Union + +from soynlp.normalizer import emoticon_normalize, repeat_normalize +from hanspell import passportKey, spell_checker +from konlpy.tag import Okt, Kkma + +import warnings + +warnings.filterwarnings("ignore") + +# passportKey 설정 +passportKey.init() + + +class Augmentaion: + def __init__(self, data_path, save_path, wordnet_path): + + self.data_path = data_path + self.save_path = save_path + self.wordnet_path = wordnet_path + self.df = pd.read_csv(data_path) + self.kkma = Kkma() + + # 폴더 경로 생성 + self.create_folder(self.save_path) + + # 폴더 경로 생성 메서드 + def create_folder(self, save_path: str) -> None: + """지정된 경로에 폴더를 생성하는 메서드 + + Args: + save_path (str): 주어진 경로에 directory가 없을 경우 생성. + """ + if not os.path.exists(save_path): + os.makedirs(save_path) + + def save_data(self, df: pd.DataFrame, save_path: str, file_name: str) -> None: + """데이터 저장 메서드 + + Args: + df (pd.DataFrame): 저장할 데이터 + save_path (str): 저장할 경로 + file_name (str): 저장할 파일 명 + """ + df.to_csv(os.path.join(save_path, file_name), index=False) + + def concat(self, df_list: list[pd.DataFrame]) -> pd.DataFrame: + """주어진 DataFrame을 결합하고 중복 처리, 인덱스 재정렬을 수행하는 메서드 + + Args: + df_list (list[pd.DataFrame]): DataFrame으로 이루어진 List + + Returns: + pd.DataFrame: 결합된 DataFrame + """ + df_concat = pd.concat(df_list) + df_concat.drop_duplicates(subset=["sentence_1", "sentence_2"], inplace=True) + df_concat.reset_index(drop=True, inplace=True) + return df_concat + + def train_augmentationV1( + self, file_name="train_augmentV1.csv", save=True + ) -> Union[pd.DataFrame, None]: + """AugmentationV1 버전 데이터 생성 + - 라벨 4이상 데이터 단순 증강. + + Args: + file_name (str, optional): 저장할 파일 이름. Defaults to 'train_augmentV1.csv'. + save (bool, optional): 반환 or 저장 여부 선택. . Defaults to True. + + Returns: + Union[pd.DataFrame, None]: save=False일 경우 증강 데이터 반환 + """ + df_original = self.df.copy() + df_augment = self.simple_augmentation(df=df_original, label=4) + + if save: + self.save_data(df_augment, self.save_path, file_name) + else: + return df_augment + + # train 데이터 전처리 및 증강 메서드 + def train_augmentationV2( + self, file_name="train_augmentV2.csv", save=True + ) -> Union[pd.DataFrame, None]: + """AugementV2 버전 데이터 생성 + - 원본 데이터 + 맞춤법 검사 데이터 + 동의어 교체 데이터 + - Swap sentence, Copied Sentence + - 각 과정마다 데이터 불균형을 해소하기 위해 비율을 다르게 하여 증강 + + Args: + file_name (str, optional): 저장할 파일 이름. Defaults to 'train_augmentV2.csv'. + save (bool, optional): 반환 or 저장 여부 선택. Defaults to True. + + Returns: + Union[pd.DataFrame, None]: save=False일 경우 증강 데이터 반환 + """ + df_original = self.df.copy() + df_spellcheck = self.train_preprocessing(save=False) + df_sr = self.synonym_replacement( + df=df_spellcheck, + wordnet_path=self.wordnet_path, + symmin=3.0, + symmax=4.5, + rng=0.5, + ratio=2, + ) + df_concat = self.concat([df_original, df_spellcheck, df_sr]) + df_swap = self.swap_sentence(df_concat) + df_concat_swap = self.concat([df_concat, df_swap]) + df_augment = self.copied_sentenceV2(df_concat_swap) + + if save: + self.save_data(df_augment, self.save_path, file_name) + else: + return df_augment + + def train_augmentationV3( + self, file_name="train_augmentV3.csv", save=True + ) -> Union[pd.DataFrame, None]: + """AugmentationV3 버전 데이터 생성 + - AugmentationV2 데이터 + nnp masking 데이터 + + Args: + file_name (str, optional): 저장할 파일 이름. Defaults to 'train_augmentV3.csv'. + save (bool, optional): 반환 or 저장 여부 선택. Defaults to True. + + Returns: + Union[pd.DataFrame, None]: save=False일 경우 증강 데이터 반환 + """ + df_orignal = self.df.copy() + if "train_augmentV2.csv" in os.listdir("../data"): + print("train_augmentV2.csv is already exist!! load....") + df_augmentV2 = pd.read_csv("../data/train_augmentV2.csv") + else: + df_augmentV2 = self.train_augmentationV2(save=False) + df_nnp_masking = self.nnp_masking(df_orignal) + df_augment = self.concat([df_augmentV2, df_nnp_masking]) + + if save: + self.save_data(df_augment, self.save_path, file_name) + else: + return df_augment + + def train_preprocessing(self, file_name="train.csv", save=True): + """TRAIN 데이터 전처리 + + Args: + file_name (str, optional): 저장할 파일 이름. Defaults to 'train.csv'. + save (bool, optional): 반환 or 저장 여부 선택. Defaults to True. + + Returns: + _type_: save=False일 경우 증강 데이터 반환 + """ + df_spellcheck = self.spelling_check(self.df) + if save: + self.save_data(df_spellcheck, self.save_path, file_name) + else: + return df_spellcheck + + def val_preprocessing(self, file_name="dev.csv"): + """DEV 데이터 전처리 + + Args: + file_name (str, optional): 저장할 파일 이름. Defaults to 'dev.csv'. + """ + df_spellcheck = self.spelling_check(self.df) + self.save_data(df_spellcheck, self.save_path, file_name) + + def test_preprocessing(self, file_name="test.csv"): + """TEST 데이터 전처리 + + Args: + file_name (str, optional): 저장할 파일 이름. Defaults to 'test.csv'. + """ + df_spellcheck = self.spelling_check(self.df) + self.save_data(df_spellcheck, self.save_path, file_name) + + def spelling_check(self, df: pd.DataFrame) -> pd.DataFrame: + """ + 데이터에 apply_hanspell 함수를 적용 + Args: + df (pd.DataFrame): 맞춤법을 교정할 데이터 + + Returns: + data (pd.DataFrame): 맞춤법을 교정한 데이터 + """ + df_change = df.copy() + tqdm.pandas() + df_change["sentence_1"] = df_change["sentence_1"].progress_map( + self.apply_hanspell + ) + df_change["sentence_2"] = df_change["sentence_2"].progress_map( + self.apply_hanspell + ) + return df_change + + def apply_hanspell(self, text: str) -> str: + """ + 중복 감정 표현 및 표현 제거, 특수 문자 제거 후 hanspell 맞춤법 검사 적용 + Args: + text (str): 교정할 문장 + + Returns: + spell_check_text (str): 교정한 문장 + """ + text = emoticon_normalize(text, num_repeats=2) + text = repeat_normalize(text, num_repeats=2) + text = text.lower() + text = re.sub("[^a-zr-ㅎ가-힣0-9 ]", "", text) + text = text.strip() + spell_check_text = spell_checker.check(text).checked + return spell_check_text + + def synonym_replacement( + self, + df: pd.DataFrame, + wordnet_path: str, + rng: float = 0.5, + symmin: float = 3.0, + symmax: float = 4.5, + ratio: int = 2, + ) -> pd.DataFrame: + """동의어 대체 및 조사 대체를 수행하는 메서드 + + Args: + df (pd.DataFrame): 데이터 증강을 진행할 DataFrame + wordnet_path (str): 동의어 사전 경로(wordnet은 KAIST에서 만든 Korean WordNet(KWN) 을 사용함.) + rng (float, optional): 데이터를 증강할 label 범위 (rng 이상). Defaults to 0.5. + symmin (float, optional): 동의어 대체 비율을 조절하는 라벨의 범위의 최소값. Defaults to 3.0. + symmax (float, optional): 동의어 대체 비율을 조절하는 라벨의 범위의 최대값. Defaults to 4.5. + ratio (int, optional): 동의어에 대해서 대체할 비율. Defaults to 2. + + Returns: + pd.DataFrame: 동의어가 대체된 DataFrame + """ + df_change = df[df["label"] >= rng].reset_index(drop=True).copy() + okt = Okt() + with open(wordnet_path, "rb") as f: + wordnet = pickle.load(f) + + n1, n2 = df_change["sentence_1"], df_change["sentence_2"] + sr_sentence = [] + + for i in tqdm(range(len(n1)), desc="Synonym Replacement"): + now_sent1 = n1[i] + now_sent2 = n2[i] + noun1 = okt.nouns(now_sent1) + noun2 = okt.nouns(now_sent2) + + # 공통된 명사를 추출. + same_nouns_set = set(noun1) & set(noun2) + for same_noun in same_nouns_set: + # 길이가 2 이상이고, wordnet에 있는지 확인. + if ( + len(same_nouns_set) > 1 + and same_noun in wordnet + and len(wordnet[same_noun]) >= 2 + ): + sym_list = wordnet[same_noun][1:] + # label 별 비율을 맞춰주기 위해 3.0 <= label < 4.5 인 데이터 절반만 변환 + if symmin <= df_change["label"][i] < symmax: + sym_list = sym_list[: len(sym_list) // ratio + 1] + + for sym in sym_list: + s1 = okt.pos(now_sent1) + s2 = okt.pos(now_sent2) + sr_sentence.append( + [ + df_change["id"][i], + df_change["source"][i], + self.make_sentence(s1, same_noun, sym), + self.make_sentence(s2, same_noun, sym), + df_change["label"][i], + df_change["binary-label"][i], + ] + ) + sr_sentence = pd.DataFrame( + sr_sentence, + columns=[ + "id", + "source", + "sentence_1", + "sentence_2", + "label", + "binary-label", + ], + ) + + return sr_sentence + + def make_sentence(self, sentence: list, compare: str, sym: str) -> str: + """ + sentence_1, sentence_2에 모두 등장하는 명사를 교체하고 조사를 교정 + Args : + sentence (list): 형태소 분석한 문장 + compare (str): 문장에서 바꿀 명사 + sym (str): 문장 삽입되는 동의어 + Returns : + replace_sentence (str): 동의어로 교체한 문장 + """ + replace_sentence = [] + check = set(["이", "가", "을", "를", "과", "와"]) + for j in range(len(sentence)): + # 문장에서 동의어를 추가한다. + if sentence[j][0] == compare: + replace_sentence.append(sym) + # 뒷말이 조사면 조사를 확인하고 바꾼다. + if ( + j + 1 < len(sentence) + and sentence[j + 1][1] == "Josa" + and sentence[j + 1][0] in check + ): + # 바뀐 명사 마지막 받침 확인 후 조사 변경 + sentence[j + 1] = ( + self.change_josa(replace_sentence[-1][0], sentence[j + 1][0]), + "Josa", + ) + else: + replace_sentence.append(sentence[j][0]) + + # hanspell로 띄어쓰기 교정. + replace_sentence = "".join(replace_sentence) + replace_sentence = spell_checker.check(replace_sentence).checked + return replace_sentence + + def check_end(self, noun: str) -> bool: + """ + 한글의 유니코드가 28로 나누어 떨어지면 받침이 없음을 판단 + Args : + noun (str): 받침 유무를 판단할 명사 + Returns : + False (bool) : 받침이 없음 + True (bool) : 받침이 있음 + """ + if (ord(noun[-1]) - ord("가")) % 28 == 0: + return False + else: + return True + + def change_josa(self, noun: str, josa: str) -> str: + """ + 명사의 끝음절 받침 여부에 따라서 조사 교체 + Args : + none (str): 끝음절의 받침 확인할 명사 + josa (str): 교정할 조사 + Returns : + josa (str): 교정한 조사 + """ + if josa == "이" or josa == "가": + return "이" if self.check_end(noun) else "가" + elif josa == "은" or josa == "는": + return "은" if self.check_end(noun) else "는" + elif josa == "을" or josa == "를": + return "을" if self.check_end(noun) else "를" + elif josa == "과" or josa == "와": + return "과" if self.check_end(noun) else "와" + else: + return josa + + def swap_sentence(self, df: pd.DataFrame) -> pd.DataFrame: + """Sentence1과 Sentence2를 Swap(0.5 <= label <3.5, 4.5<= label < 5 인 라벨에 대해서만 sentence swap) + + Args: + df (pd.DataFrame): 데이터를 증강할 DataFrame + + Returns: + pd.DataFrame: Sentence1과 Sentence2가 Swap된 DataFrame + """ + df_swapped = df.copy() + df_swapped["sentence_1"] = df["sentence_2"] + df_swapped["sentence_2"] = df["sentence_1"] + df_swapped = df_swapped[ + ((df_swapped["label"] >= 0.5) & (df_swapped["label"] < 3.5)) + | ((df_swapped["label"] >= 4.5) & (df_swapped["label"] < 5)) + ] + return df_swapped + + def copied_sentenceV2(self, df: pd.DataFrame) -> pd.DataFrame: + """(Setence1, Sentence2, label) --> (Sentence1 , Sentence2, 4.9)로 대체. + 많이 분포하는 라벨을 줄이고 적게 분포하는 라벨을 증강하기 위한 시도. + Args: + df (pd.DataFrame): 증강할 DataFrame + + Returns: + pd.DataFrame: 증강된 DataFrame + """ + df_change = df.reset_index(drop=True).copy() + sample_0005 = df_change[ + (df_change["label"] >= 0.0) & (df_change["label"] < 0.5) + ][-1779:] + sample_3035 = df_change[ + (df_change["label"] >= 3.0) & (df_change["label"] < 3.5) + ][-508:] + sample_0445 = df_change[ + (df_change["label"] >= 1.0) & (df_change["label"] < 1.5) + ][-414:] + + for index in [sample_3035.index, sample_0005.index, sample_0445.index]: + df_change.iloc[index, 3] = df_change.iloc[index, 2] + df_change.iloc[index, 4] = 4.9 + df_change.iloc[index, 5] = 1 + + df_change.drop_duplicates(subset=["sentence_1", "sentence_2"], inplace=True) + df_change.reset_index(drop=True, inplace=True) + return df_change + + def simple_augmentation(self, df: pd.DataFrame, label: float) -> pd.DataFrame: + """라벨 >= label인 데이터 단순 증강. AugmentationV1에서 사용됨. + + Args: + df (pd.DataFrame): 데이터를 증강할 DataFrame + label (float): 증강할 라벨의 범위(label 이상) + + Returns: + pd.DataFrame: 증강된 DataFrame + """ + df_change = df.copy() + df_top = df_change[df_change["label"] >= label] + df_augment = pd.concat([df_change, df_top]) + return df_augment + + def mask_nnp(self, sentence: str) -> str: + """고유명사, 외래어 masking + + Args: + sentence (str): masking될 문장 + + Returns: + str: masking된 문장 + """ + try: + words = self.kkma.pos(sentence) + for word, tag in words: + # 태그 'NNG': '일반 명사', 'NNP': '고유 명사','SL' : '외래어' + if tag in ["NNP", "SL"]: + sentence = sentence.replace(word, "") + except: + return sentence + return sentence + + def nnp_masking(self, df: pd.DataFrame) -> pd.DataFrame: + """고유명사, 외래어를 마스킹하여 증강하는 메서드 + + Args: + df (pd.DataFrame): masking할 DataFrame + + Returns: + pd.DataFrame: masking된 DataFrame + """ + df_change = df.copy() + df_change["sentence_1"] = df_change["sentence_1"].apply(self.mask_nnp) + df_change["sentence_2"] = df_change["sentence_2"].apply(self.mask_nnp) + return df_change + + +class Path(Enum): + TRAIN = "../data/raw/train.csv" + DEV = "../data/raw/dev.csv" + TEST = "../data/raw/test.csv" + WORDNET = "./wordnet.pickle" + SAVE = "../data/" + + +if __name__ == "__main__": + """ + Train 데이터 증강 : AugmentationV1, AugmentationV2, AugmentationV3 + Dev, Test 데이터 전처리 : 특수문자 처리, 중복 표현 제거, hanspell(맞춤법 검사) + """ + train_augment = Augmentaion( + data_path=Path.TRAIN.value, + save_path=Path.SAVE.value, + wordnet_path=Path.WORDNET.value, + ) + + dev_augment = Augmentaion( + data_path=Path.DEV.value, + save_path=Path.SAVE.value, + wordnet_path=Path.WORDNET.value, + ) + + test_augment = Augmentaion( + data_path=Path.TEST.value, + save_path=Path.SAVE.value, + wordnet_path=Path.WORDNET.value, + ) + + # TRAIN 데이터 증강(V1, V2, V3) + train_augment.train_augmentationV1(file_name="train_augmentV1.csv", save=True) + train_augment.train_augmentationV2(file_name="train_augmentV2.csv", save=True) + train_augment.train_augmentationV3(file_name="train_augmentV3.csv", save=True) + + # DEV, TEST 전처리(맞춤법 검사, 특수문자 처리) + dev_augment.val_preprocessing(file_name="dev_spellcheck.csv") + test_augment.val_preprocessing(file_name="test_spellcheck.csv") diff --git a/utils/preprocess/data_balancing.ipynb b/utils/preprocess/data_balancing.ipynb new file mode 100644 index 0000000..8058de0 --- /dev/null +++ b/utils/preprocess/data_balancing.ipynb @@ -0,0 +1,350 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import warnings\n", + "\n", + "# 모든 경고 메시지 무시\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "ys_bert_rmr_basic = pd.read_csv(\"../data/processed/ys_bert_rmr_basic.csv\", encoding=\"UTF-8\")\n", + "ys_adverb_basic = pd.read_csv(\"../data/processed/ys_adverb_basic.csv\", encoding=\"UTF-8\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_label_count(df,df_name):\n", + " grouped_data = df.groupby(\"label\")[\"id\"].count()\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\")\n", + " plt.title(f\"{df_name} label Count\")\n", + " plt.xlabel(\"label\")\n", + " plt.ylabel(\"Count\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_multiple_label_counts(dfs,dfnames):\n", + " num_experiments = len(dfs)\n", + " num_cols = 2 # 한 줄에 두 개씩 배치\n", + " num_rows = (num_experiments + 1) // num_cols # 행의 수 계산\n", + "\n", + " # 전체 subplot 크기 설정\n", + " fig, axes = plt.subplots(\n", + " num_rows, num_cols, figsize=(12, 6 * num_rows)\n", + " ) # subplot의 크기 설정\n", + "\n", + " for idx, df in enumerate(dfs):\n", + " row = idx // num_cols\n", + " col = idx % num_cols\n", + "\n", + " # 데이터를 그룹화하여 label 별 count 계산\n", + " grouped_data = df.groupby(\"label\")[\"id\"].count()\n", + "\n", + " # subplot에 각각의 그래프 그리기\n", + " if num_rows > 1:\n", + " ax = axes[row, col] # 2차원 배열에서 해당 위치의 subplot 지정\n", + " else:\n", + " ax = axes[col] # 1차원 배열일 경우\n", + "\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\", ax=ax)\n", + "\n", + " # subplot의 제목 및 축 설정\n", + " ax.set_title(f\"Label Count ({dfnames[idx]})\")\n", + " ax.set_xlabel(\"label\")\n", + " ax.set_ylabel(\"Count\")\n", + "\n", + " # 여백 자동 조정\n", + " plt.tight_layout()\n", + " # 그래프 출력\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_label_count(ys_bert_rmr_basic, \"ys_bert_rmr_basic\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_label_count(ys_adverb_basic, \"ys_adverb_basic\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_multiple_label_counts([ys_bert_rmr_basic, ys_adverb_basic],[\"bert_rmr_basic\",\"adverb_basic\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def special_value_interpolation(df):\n", + " # 0.5, 1.5, 2.5, 3.5, 4.5에 해당하는 값을 필터링\n", + " target_values = [0.5, 1.5, 2.5, 3.5, 4.5]\n", + " filtered_df = df[df[\"label\"].isin(target_values)]\n", + "\n", + "\n", + " # 각 값에 대해 절반은 +0.1, 절반은 -0.1\n", + " def adjust_labels(group):\n", + " n = len(group)\n", + " # 절반으로 나눔\n", + " half_n = n // 2\n", + " # 첫 절반은 -0.1, 나머지는 +0.1\n", + " group.iloc[:half_n] -= 0.1\n", + " group.iloc[half_n:] += 0.1\n", + " return group\n", + "\n", + "\n", + " # 필터링된 값들에 대한 보정\n", + " df.loc[df[\"label\"].isin(target_values), \"label\"] = filtered_df.groupby(\"label\")[\n", + " \"label\"\n", + " ].transform(adjust_labels)\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "def zero_five_balancing(df):\n", + " # 0.0 분리\n", + " zero_label_df = df[df[\"label\"] == 0.0]\n", + " non_zero_label_df = df[df[\"label\"] != 0.0]\n", + "\n", + " # 0.0 라벨 데이터를 n개와 나머지로 분리\n", + " fixed_zero_label_df = zero_label_df.iloc[:2000] # 0.0 데이터 개수\n", + " remaining_zero_label_df = zero_label_df.iloc[2000:2500] # 5.0 데이터 개수\n", + "\n", + " # 5.0 라벨 증강\n", + " remaining_zero_label_df[\"label\"] = 5.0\n", + "\n", + " # 5.0 라벨인 데이터에 sentence_2에 sentence_1 복사\n", + " remaining_zero_label_df[\"sentence_2\"] = remaining_zero_label_df[\"sentence_1\"]\n", + "\n", + " # 3000개 0.0 라벨 데이터 + 증강된 5.0 라벨 데이터 + 나머지 데이터 합침\n", + " reduced_df = pd.concat(\n", + " [fixed_zero_label_df, remaining_zero_label_df, non_zero_label_df]\n", + " )\n", + "\n", + " return reduced_df.reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "from eda import eda\n", + "\n", + "\n", + "def swap_or_eda(df, alpha_sr=0.1, alpha_ri=0.1, alpha_rs=0.1, num_aug=1):\n", + " \"\"\"\n", + " EDA 적용 함수 \\n\n", + " 주의: 한글 제외한 나머지 문자 제거됨 \\n\n", + " alpha_sr: 특정 단어를 유의어로 교체할 확률 \\n\n", + " alpha_ri: 임의의 단어를 삽입할 확률 \\n\n", + " alpha_rs: 문장 내 임의의 두 단어의 위치를 바꿀 확률 \\n\n", + " num_aug: 데이터 증강하는 개수 \\n\n", + " \"\"\"\n", + "\n", + " def _conditional_eda(row, column_name):\n", + " if row[\"label\"] in [4.6, 4.8]:\n", + " return eda.EDA(row[column_name], alpha_sr, alpha_ri, alpha_rs, num_aug+1)\n", + " if row[\"label\"] in [1.6, 2.2, 2.4, 4.4]:\n", + " return eda.EDA(row[column_name], alpha_sr, alpha_ri, alpha_rs, num_aug)\n", + " else:\n", + " return [row[column_name]]\n", + "\n", + " def _conditional_swap(df):\n", + " \"\"\"sentence_1과 sentence_2를 교환한 데이터 추가\"\"\"\n", + " df_swaped = df.rename(\n", + " columns={\"sentence_1\": \"sentence_2\", \"sentence_2\": \"sentence_1\"}\n", + " )\n", + " df_filtered = df_swaped[\n", + " ~df_swaped[\"label\"].isin([0.0, 1.6, 2.2, 2.4, 4.4, 4.6, 4.8])\n", + " ]\n", + "\n", + " return pd.concat([df, df_filtered])\n", + "\n", + " # sentence_1에 EDA 적용\n", + " df[\"sentence_1\"] = df.apply(lambda row: _conditional_eda(row, \"sentence_1\"), axis=1)\n", + " df = df.explode(\"sentence_1\").reset_index(drop=True)\n", + "\n", + " # sentence_2에 EDA 적용\n", + " df[\"sentence_2\"] = df.apply(lambda row: _conditional_eda(row, \"sentence_2\"), axis=1)\n", + " df = df.explode(\"sentence_2\").reset_index(drop=True)\n", + "\n", + " # sentence_1과 sentence_2를 교환\n", + " df = _conditional_swap(df)\n", + "\n", + " return df.reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ys_adverb_balanced = special_value_interpolation(ys_adverb_basic)\n", + "ys_adverb_balanced = zero_five_balancing(ys_adverb_balanced)\n", + "ys_adverb_balanced = swap_or_eda(ys_adverb_balanced)\n", + "plot_label_count(ys_adverb_balanced, \"ys_adverb_balanced\")\n", + "\n", + "ys_bert_rmr_balanced = special_value_interpolation(ys_bert_rmr_basic)\n", + "ys_bert_rmr_balanced = zero_five_balancing(ys_bert_rmr_balanced)\n", + "ys_bert_rmr_balanced = swap_or_eda(ys_bert_rmr_balanced)\n", + "plot_label_count(ys_bert_rmr_balanced, \"ys_bert_rmr_balanced\")" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_multiple_label_counts(\n", + " [ys_bert_rmr_balanced, ys_adverb_balanced],\n", + " [\"ys_bert_rmr_balanced\", \"ys_adverb_balanced\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "ys_adverb_balanced.to_csv(\"../data/ys_adverb_balanced.csv\")\n", + "ys_bert_rmr_balanced.to_csv(\"../data/ys_bert_rmr_balanced.csv\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ame", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/utils/preprocess/data_preprocess.ipynb b/utils/preprocess/data_preprocess.ipynb new file mode 100644 index 0000000..91bec0b --- /dev/null +++ b/utils/preprocess/data_preprocess.ipynb @@ -0,0 +1,354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 전처리/증강 데이터셋 버전 \n", + "#### 형식\n", + "- v{대분류}_{인덱스}\n", + "#### 대분류\n", + "- v1: 전처리만 적용\n", + "- v2: v1 + swap만 적용 \n", + "- v3: v2 + 데이터 증강 기법 적용\n", + "- v4: v3 + 매우 실험적인 전처리/증강 기법 적용\n", + "#### 인덱스\n", + "- 01부터 99까지 차례로 순서를 매김\n", + "#### 예시\n", + "- 맞춤법 교정 데이터셋 -> v1_01\n", + "- 특수문자 제거 데이터셋 -> v1_02\n", + "- 특수문자 제거, 띄어쓰기 교정, swap 데이터셋 -> v2_01\n", + "- 맞춤법 교정, swap, RS, SR -> v3_01\n", + "- ChatGPT api 증강 데이터셋 -> v4_01" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import warnings\n", + "\n", + "# 모든 경고 메시지 무시\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def print_label_count(df):\n", + " \"\"\"라벨 분포 확인용\"\"\"\n", + " print(len(df))\n", + " df[\"label_int\"] = pd.cut(\n", + " df[\"label\"],\n", + " bins=[x for x in range(6)],\n", + " labels=[x for x in range(5)],\n", + " right=False,\n", + " )\n", + " print(df.groupby(\"label_int\")[\"id\"].count())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def replace_special_letters(df):\n", + " \"\"\"특수문자 제거 \\n \n", + " 초성(ㄱ-ㅎ), 중성(ㅏ-ㅣ), 완성된 한글(가-힣), 알파벳(A-Za-z), 숫자(0-9), 그리고 공백(\\s)만 허용\"\"\"\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].str.replace(\n", + " r\"[^A-Za-z0-9가-힣ㄱ-ㅎㅏ-ㅣ\\s]\", \"\", regex=True\n", + " )\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(\n", + " r\"[^A-Za-z0-9가-힣ㄱ-ㅎㅏ-ㅣ\\s]\", \"\", regex=True\n", + " )\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from hanspell import passportKey, spell_checker\n", + "\n", + "# passportKey 설정\n", + "passportKey.init()\n", + "\n", + "\n", + "def spell_check(df):\n", + " \"\"\"맞춤법(오탈자, 띄어쓰기 등 전부) 교정\"\"\"\n", + " df[\"sentence_1\"] = df.apply(lambda row: spell_checker.check(row[\"sentence_1\"]).checked, axis=1)\n", + " df[\"sentence_2\"] = df.apply(lambda row: spell_checker.check(row[\"sentence_2\"]).checked, axis=1)\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import pykospacing\n", + "\n", + "\n", + "def spacing_text(df):\n", + " \"\"\"띄어쓰기만 교정\"\"\"\n", + " spacing = pykospacing.Spacing()\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].map(spacing)\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].map(spacing)\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def swap(df):\n", + " \"\"\"sentence 1과 2를 교환한 데이터 추가\"\"\"\n", + " df_swaped = df.rename(\n", + " columns={\"sentence_1\": \"sentence_2\", \"sentence_2\": \"sentence_1\"}\n", + " )\n", + " return pd.concat([df, df_swaped])\n", + "\n", + "\n", + "def swap_over_one_label(df):\n", + " \"\"\"sentence 1과 2를 교환한 데이터 추가\"\"\"\n", + " df_swaped = df.rename(\n", + " columns={\"sentence_1\": \"sentence_2\", \"sentence_2\": \"sentence_1\"}\n", + " )\n", + " df_filtered = df_swaped[df_swaped[\"label\"] >= 1]\n", + "\n", + " return pd.concat([df, df_filtered])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from eda import eda\n", + "\n", + "# 커스텀된 EDA 함수 말고 원본 패키지 사용하고 싶다면 https://github.com/toriving/KoEDA\n", + "def apply_eda(df, alpha_sr=0.1, alpha_ri=0.1, alpha_rs=0.1, num_aug=2):\n", + " \"\"\"\n", + " EDA 적용 함수 \\n \n", + " 주의: 한글 제외한 나머지 문자 제거됨 \\n\n", + " alpha_sr: 특정 단어를 유의어로 교체할 확률 \\n\n", + " alpha_ri: 임의의 단어를 삽입할 확률 \\n\n", + " alpha_rs: 문장 내 임의의 두 단어의 위치를 바꿀 확률 \\n\n", + " num_aug: 데이터 증강하는 개수 \\n\n", + " \"\"\"\n", + " def _conditional_eda(row, column_name):\n", + " if row[\"label\"] >= 0: \n", + " return eda.EDA(\n", + " row[column_name], alpha_sr, alpha_ri, alpha_rs, num_aug)\n", + " else:\n", + " return [row[column_name]]\n", + "\n", + " def _replace_person_token(df):\n", + " \"\"\"Speicial 토큰 처리: -> 궯궯궯\"\"\"\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].str.replace(\"\", \"궯궯궯\")\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(\"\", \"궯궯궯\")\n", + " return df\n", + "\n", + " def _recover_person_token(df):\n", + " \"\"\"Speicial 토큰 처리: 궯궯궯 -> \"\"\"\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].str.replace(\"궯궯궯\", \"\")\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(\"궯궯궯\", \"\")\n", + " return df\n", + "\n", + " df = _replace_person_token(df)\n", + " df[\"sentence_1\"] = df.apply(lambda row: _conditional_eda(row, \"sentence_1\"), axis=1)\n", + " df = df.explode(\"sentence_1\").reset_index(drop=True)\n", + " df[\"sentence_2\"] = df.apply(lambda row: _conditional_eda(row, \"sentence_2\"), axis=1)\n", + " df = df.explode(\"sentence_2\").reset_index(drop=True)\n", + " df = _recover_person_token(df)\n", + " \n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from eda import eda\n", + "\n", + "\n", + "# 커스텀된 EDA 함수 말고 원본 패키지 사용하고 싶다면 https://github.com/toriving/KoEDA\n", + "def apply_eda(df, alpha_sr=0.1, alpha_ri=0.1, alpha_rs=0.1, num_aug=2):\n", + " \"\"\"\n", + " EDA 적용 함수 \\n\n", + " 주의: 한글 제외한 나머지 문자 제거됨 \\n\n", + " alpha_sr: 특정 단어를 유의어로 교체할 확률 \\n\n", + " alpha_ri: 임의의 단어를 삽입할 확률 \\n\n", + " alpha_rs: 문장 내 임의의 두 단어의 위치를 바꿀 확률 \\n\n", + " num_aug: 데이터 증강하는 개수 \\n\n", + " \"\"\"\n", + "\n", + " def _conditional_eda(row, column_name):\n", + " if row[\"label\"] >= 0:\n", + " return eda.EDA(row[column_name], alpha_sr, alpha_ri, alpha_rs, num_aug)\n", + " else:\n", + " return [row[column_name]]\n", + "\n", + " df[\"sentence_1\"] = df.apply(lambda row: _conditional_eda(row, \"sentence_1\"), axis=1)\n", + " df = df.explode(\"sentence_1\").reset_index(drop=True)\n", + " df[\"sentence_2\"] = df.apply(lambda row: _conditional_eda(row, \"sentence_2\"), axis=1)\n", + " df = df.explode(\"sentence_2\").reset_index(drop=True)\n", + "\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# 전처리 및 증강 적용한 csv 파일 생성 (원하는 함수를 선택하여 사용)\n", + "def make(df, df_name):\n", + " df = replace_special_letters(df)\n", + " df = spell_check(df)\n", + " df = spacing_text(df)\n", + " df = swap(df)\n", + " df = apply_eda(df)\n", + " df = df.drop_duplicates()\n", + " df.to_csv(f\"./{df_name}.csv\")\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def make_v1(df, df_name):\n", + " df = replace_special_letters(df)\n", + " df = spell_check(df)\n", + " df = df.drop_duplicates()\n", + " df.to_csv(f\"../data/{df_name}.csv\")\n", + " return df\n", + "\n", + "\n", + "def make_v1_02(df, df_name):\n", + " df = spell_check(df)\n", + " df = df.drop_duplicates()\n", + " df.to_csv(f\"../data/{df_name}.csv\")\n", + " return df\n", + "\n", + "\n", + "def make_v2(df, df_name):\n", + " df = replace_special_letters(df)\n", + " df = spell_check(df)\n", + " df = swap(df)\n", + " df = df.drop_duplicates()\n", + " df.to_csv(f\"../data/{df_name}.csv\")\n", + " return df\n", + "\n", + "\n", + "def make_v2_02(df, df_name):\n", + " df = replace_special_letters(df)\n", + " df = spell_check(df)\n", + " df = swap_over_one_label(df)\n", + " df = df.drop_duplicates()\n", + " df.to_csv(f\"../data/{df_name}.csv\")\n", + " return df\n", + "\n", + "\n", + "def make_v2_03(df, df_name):\n", + " df = spell_check(df)\n", + " df = swap_over_one_label(df)\n", + " df = df.drop_duplicates()\n", + " df.to_csv(f\"../data/{df_name}.csv\")\n", + " return df\n", + "\n", + "\n", + "def make_v3(df, df_name):\n", + " df = replace_special_letters(df)\n", + " df = spell_check(df)\n", + " df = swap_over_one_label(df)\n", + " df = apply_eda(df, alpha_sr=0.3, alpha_ri=0.3, alpha_rs=0.3)\n", + " df = df.drop_duplicates()\n", + " df.to_csv(f\"../data/{df_name}.csv\")\n", + " return df\n", + "\n", + "def make_swap(df,df_name):\n", + " df = swap(df)\n", + " df.to_csv(f\"./{df_name}.csv\")\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "train = pd.read_csv(\"../data/raw/train.csv\", encoding=\"UTF-8\")\n", + "dev = pd.read_csv(\"../data/raw/dev.csv\", encoding=\"UTF-8\")\n", + "\n", + "train_v1 = make_v1_02(train, \"train_v1_02\")\n", + "dev_v1 = make_v1_02(dev, \"dev_v1_02\")\n", + "\n", + "print_label_count(train_v1)\n", + "print_label_count(dev_v1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "train = pd.read_csv(\"../data/raw/train.csv\", encoding=\"UTF-8\")\n", + "train_swap = make_swap(train,\"ys_raw_swap\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "ys_adverb_basic = pd.read_csv(\"../data/processed/ys_adverb_basic.csv\", encoding=\"UTF-8\")\n", + "ys_adverb_swap = swap_over_one_label(ys_adverb_basic)\n", + "ys_adverb_swap.to_csv(\"../data/ys_adverb_swap.csv\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ame", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/utils/preprocess/eda.ipynb b/utils/preprocess/eda.ipynb new file mode 100644 index 0000000..f303bd9 --- /dev/null +++ b/utils/preprocess/eda.ipynb @@ -0,0 +1,1619 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 목적\n", + "- 해당 노트북의 목적은 EDA(Exploratory Data Analysis)를 통한 실험 아이디어 도출에 있습니다. \n", + "- 여러 데이터 전처리 방법과 아이디어를 소개하고, 이를 시각화를 통해 보여줍니다. \n", + "- 빈약한 부분이나 오류가 있을 수 있습니다. 관련하여 댓글로 알려주시거나 질문해주시면 감사하겠습니다. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import warnings\n", + "\n", + "# 모든 경고 메시지 무시\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 데이터 불러오기" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train dataset count: 9324\n", + "dev dataset count: 550\n", + "test dataset count: 1100\n" + ] + } + ], + "source": [ + "train = pd.read_csv(\"../data/raw/train.csv\", encoding=\"UTF-8\")\n", + "dev = pd.read_csv(\"../data/raw/dev.csv\", encoding=\"UTF-8\")\n", + "test = pd.read_csv(\"../data/raw/test.csv\", encoding=\"UTF-8\")\n", + "print(\"train dataset count:\", len(train))\n", + "print(\"dev dataset count:\", len(dev))\n", + "print(\"test dataset count:\", len(test))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idsourcesentence_1sentence_2labelbinary-label
0boostcamp-sts-v1-train-000nsmc-sampled스릴도있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요~반전도 있고,사랑도 있고재미도있네요.2.20.0
1boostcamp-sts-v1-train-001slack-rtt앗 제가 접근권한이 없다고 뜹니다;;오, 액세스 권한이 없다고 합니다.4.21.0
2boostcamp-sts-v1-train-002petition-sampled주택청약조건 변경해주세요.주택청약 무주택기준 변경해주세요.2.40.0
3boostcamp-sts-v1-train-003slack-sampled입사후 처음 대면으로 만나 반가웠습니다.화상으로만 보다가 리얼로 만나니 정말 반가웠습니다.3.01.0
4boostcamp-sts-v1-train-004slack-sampled뿌듯뿌듯 하네요!!꼬옥 실제로 한번 뵈어요 뿌뿌뿌~!~!0.00.0
\n", + "
" + ], + "text/plain": [ + " id source \\\n", + "0 boostcamp-sts-v1-train-000 nsmc-sampled \n", + "1 boostcamp-sts-v1-train-001 slack-rtt \n", + "2 boostcamp-sts-v1-train-002 petition-sampled \n", + "3 boostcamp-sts-v1-train-003 slack-sampled \n", + "4 boostcamp-sts-v1-train-004 slack-sampled \n", + "\n", + " sentence_1 sentence_2 \\\n", + "0 스릴도있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요~ 반전도 있고,사랑도 있고재미도있네요. \n", + "1 앗 제가 접근권한이 없다고 뜹니다;; 오, 액세스 권한이 없다고 합니다. \n", + "2 주택청약조건 변경해주세요. 주택청약 무주택기준 변경해주세요. \n", + "3 입사후 처음 대면으로 만나 반가웠습니다. 화상으로만 보다가 리얼로 만나니 정말 반가웠습니다. \n", + "4 뿌듯뿌듯 하네요!! 꼬옥 실제로 한번 뵈어요 뿌뿌뿌~!~! \n", + "\n", + " label binary-label \n", + "0 2.2 0.0 \n", + "1 4.2 1.0 \n", + "2 2.4 0.0 \n", + "3 3.0 1.0 \n", + "4 0.0 0.0 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Label 분포\n", + "- Label 값의 분포를 통해 데이터가 불균형한지, 숨겨진 특징은 없는지 확인할 수 있습니다. \n", + "- 다양한 데이터 증강 기법이나 샘플링 기법 등을 적용할 아이디어를 얻을 수 있습니다. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Label 별 데이터셋 특징\n", + "아래 표는 작년 AI Tech 6기 4조에서 분석했던 내용을 가져왔습니다.\n", + "\n", + "
\n", + "\n", + "| Label 구간 | sentence_1 | sentence_2 | 특징 |\n", + "|:---:|:---|:---|:---|\n", + "| 5.0 | 검정고시가 페지되어야 한다고 봅니다 | 검정고시 페지해야 한다고 봅니다 | 문장부호의 개수 및 띄어쓰기, 조사가 생략되거나 하는 다소의 차이가 존재하나, 문장이 거의 일치합니다. |\n", + "| 4.0 ~ 4.9 | 나는 이걸 왜 보았을까?? | 이거 내가 왜 봤지? | 문장의 의미가 거의 일치하나, 단어의 어순이 다르거나 일부 단어가 유의어로 교체되었습니다. |\n", + "| 3.0 ~ 3.9 | 히딩크감독을 다시 대한민국 축구 감독으로 | 히딩크감독님을 모셔와야합니다 | 문장의 맥락이 거의 일치하나, 주요한 보어 혹은 목적어가 누락되거나 유의어 대체 등에서 뚜렷한 차이를 보입니다. |\n", + "| 2.0 ~ 2.9 | 대회 때문에 정신 없어서 오늘 올립니다. | 오늘은 대회로 바쁘지 않아서 올립니다. | 문장에서 다루는 주제와 상황은 유사하지만, 읽는 사람에 따라 다르게 해석될 여지가 있습니다. |\n", + "| 1.0 ~ 1.9 | 다크나이트와 함께 최고의 히어로물 | 히트했던 드라마인 각시탈 또한 제대로된 히어로물입니다; | 일부 단어가 일치하거나 주제는 유사하지만, 서로 다른 의미를 가지는 문장입니다. |\n", + "| 0.1 ~ 0.9 | 공짜로 주어지는 것은 아무 것도 없다. | 아무 것도 남는게 없다.. | 일부 단어는 일치하나, 맥락과 의미가 전혀 다릅니다. |\n", + "| 0.0 | 부모님 댁으로 받았는데 너무 맛있다고 하셔요!! ㅎㅎㅎ | 타고 싶은데 넘 비싸요 ㅎㅎ | 공통점이 없는 전혀 다른 문장입니다. |\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_label_count(df, df_name):\n", + " grouped_data = df.groupby(\"label\")[\"id\"].count()\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\")\n", + " plt.title(f\"{df_name} label Count\")\n", + " plt.xlabel(\"label\")\n", + " plt.ylabel(\"Count\")\n", + " plt.show()\n", + "\n", + "\n", + "def plot_multiple_label_counts(dfs, df_names):\n", + " num_experiments = len(df_names)\n", + " num_cols = 2 # 한 줄에 두 개씩 배치\n", + " num_rows = (num_experiments + 1) // num_cols # 행의 수 계산\n", + "\n", + " # 전체 subplot 크기 설정\n", + " fig, axes = plt.subplots(\n", + " num_rows, num_cols, figsize=(18, 6 * num_rows)\n", + " ) # subplot의 크기 설정\n", + "\n", + " for idx, df in enumerate(dfs):\n", + " row = idx // num_cols\n", + " col = idx % num_cols\n", + "\n", + " grouped_data = df.groupby(\"label\")[\"id\"].count()\n", + " # subplot에 각각의 그래프 그리기\n", + " if num_rows > 1:\n", + " ax = axes[row, col] # 2차원 배열에서 해당 위치의 subplot 지정\n", + " else:\n", + " ax = axes[col] # 1차원 배열일 경우\n", + "\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\", ax=ax)\n", + "\n", + " # subplot의 제목 및 축 설정\n", + " ax.set_title(f\"Label Count ({df_names[idx]})\")\n", + " ax.set_xlabel(\"label\")\n", + " ax.set_ylabel(\"Count\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(train[\"label\"], kde=True, bins=20)\n", + "plt.title(\"train label Distribution\")\n", + "plt.xlabel(\"label\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(dev[\"label\"], kde=True, bins=20)\n", + "plt.title(\"dev label Distribution\")\n", + "plt.xlabel(\"label\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_multiple_label_counts([train,dev],[\"train\",\"dev\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# 정수 구간에 따라 분류\n", + "# df[\"label\"].map(int) 사용 시 5점이 따로 분류된다.\n", + "train[\"label_int\"] = pd.cut(\n", + " train[\"label\"],\n", + " bins=[x for x in range(6)],\n", + " labels=[x for x in range(5)],\n", + " right=False,\n", + ")\n", + "\n", + "dev[\"label_int\"] = pd.cut(\n", + " dev[\"label\"],\n", + " bins=[x for x in range(6)],\n", + " labels=[x for x in range(5)],\n", + " right=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "label_int\n", + "0 3711\n", + "1 1368\n", + "2 1137\n", + "3 1715\n", + "4 1302\n", + "Name: id, dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 0점대(0~0.99)가 나머지 점수대에 비해 3배 가까이 많다.\n", + "train.groupby(\"label_int\")[\"id\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "label_int\n", + "0 88\n", + "1 110\n", + "2 110\n", + "3 110\n", + "4 110\n", + "Name: id, dtype: int64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 0점대(0~0.99)가 다소 적으나 나머지는 동일한 갯수로 고루 분포하는 것을 알 수 있다.\n", + "dev.groupby(\"label_int\")[\"id\"].count()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 데이터 source\n", + "### source\n", + "데이터셋의 출처는 총 3가지 source로 구성되어 있습니다. \n", + "- petition 데이터셋은 국민청원 게시판 제목 데이터로, 대체로 오탈자가 적은 격식체의 문장들로 구성되어 있습니다. \n", + "- NSMC(Naver Sentiment Movie Corpus) 데이터셋은 네이버 영화 감성 분석 코퍼스로, 문어체와 구어체가 섞여 있었고, 일부 문장에서 특수문자가 발견되었습니다. \n", + "- Slack 데이터셋은 Upstage에서 제공한 slack 데이터셋으로, 전반적으로 구어체의 문장으로 구성되어 있었으며, 오탈자와 함께 문장 부호, 특수문자(이모티콘, 이모지 등)가 발견되었습니다. \n", + "### RTT\n", + "- RTT(round-trip translation)란 한국어 문장을 영어로 번역했다가 다시 한국어로 번역하여 유사한 문장 쌍을 생성하는 기법입니다. \n", + "- 동일한 source에서 가져온 데이터셋에서도 RTT로 생성한 데이터와 아닌 데이터의 분포에는 차이를 보입니다. \n", + "- RTT로 생성한 데이터셋은 비교적 높은 유사도가 큰 비중을 차지하는 모습을 보입니다. 이는 RRT 기법을 생각해볼 때 어쩌면 자연스러운 결과입니다. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Source 별 데이터셋 특징\n", + "아래 표는 작년 AI Tech 6기 4조에서 분석했던 내용을 가져왔습니다. \n", + "
\n", + "\n", + "| channel | sentence_1 | sentence_2 |\n", + "|:---:|:---|:---|\n", + "| **nsmc** | 혹평하신분들은 로맨틱코메디를 얼마나 심오하게 보시는분들인지는 모르겠지만 개인적으로는 가볍게 기분좋게 보기 좋은 영화라고 생각합니다.. | 로맨틱코미디를 비판하는 사람들이 얼마나 심한지는 모르겠지만 개인적으로는 가볍게 보기 좋은 영화라고 생각한다. |\n", + "| | 울면서 본 영화다. | 울컥 하면서 보는 드라마입니다. |\n", + "| | 킹콩이면 도대체 콩진호가 얼마나 큰 건가요? | . 콩진호가 나가신다! |\n", + "| **petition** | 심평원, 한전 회식카드지출비 해외출장비 지원자금 조사의뢰 건 | 공동주택 일자리안정자금에 대한 문제점(미화원, 경비원 2019년 임금 동결건) |\n", + "| | 고등학생도 휴업 해주세요. | 근로자의 휴식권을 찾아주세요.. |\n", + "| | 청소년법 폐지 간곡히 요청합니다 | 청소년보호법 폐지 간곡히 부탁드립니다. |\n", + "| **slack** | 제가 모르는 종목도 많이 알고 계셨습니다. | 제가 있던 테이블에서도 너무나 가슴 뛰는 아이디어도 많이 나누었습니다. |\n", + "| | 두 분 어디 도장깨기 하러 가시는가요… ㅋㅋㅋ | 둘이 봉인을 어디서 뜯으려나... 하하하 |\n", + "| | 너무 감사드립니다 ㅠㅠ | 너무 부럽습니다 ㅠㅠ |\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "source\n", + "nsmc-rtt 788\n", + "nsmc-sampled 2296\n", + "petition-rtt 817\n", + "petition-sampled 2352\n", + "slack-rtt 1047\n", + "slack-sampled 2024\n", + "Name: id, dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train.groupby(\"source\")[\"id\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "source\n", + "nsmc-rtt 48\n", + "nsmc-sampled 127\n", + "petition-rtt 65\n", + "petition-sampled 127\n", + "slack-rtt 84\n", + "slack-sampled 99\n", + "Name: id, dtype: int64" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dev.groupby(\"source\")[\"id\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "source\n", + "nsmc-rtt 107\n", + "nsmc-sampled 261\n", + "petition-rtt 137\n", + "petition-sampled 256\n", + "slack-rtt 158\n", + "slack-sampled 181\n", + "Name: id, dtype: int64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test.groupby(\"source\")[\"id\"].count()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# train\n", + "sources = sorted(train[\"source\"].unique())\n", + "\n", + "# 서브플롯 생성\n", + "fig, axes = plt.subplots(1, len(sources), figsize=(15, 5))\n", + "\n", + "# 각 source별로 히스토그램 그리기\n", + "for ax, source in zip(axes, sources):\n", + " # 히스토그램 데이터\n", + " hist_data = train[train[\"source\"] == source]\n", + " hist = sns.histplot(hist_data, x=\"label\", bins=5, kde=True, ax=ax)\n", + "\n", + " # 막대 위에 숫자 추가\n", + " for p in hist.patches:\n", + " ax.annotate(\n", + " f\"{int(p.get_height())}\",\n", + " (p.get_x() + p.get_width() / 2.0, p.get_height()),\n", + " ha=\"center\",\n", + " va=\"bottom\",\n", + " )\n", + "\n", + " ax.set_title(f\"{source}\")\n", + " ax.set_xlabel(\"Label\")\n", + " ax.set_ylabel(\"Count\")\n", + "\n", + "# 레이아웃 조정\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# dev\n", + "sources = sorted(dev[\"source\"].unique())\n", + "\n", + "# 서브플롯 생성\n", + "fig, axes = plt.subplots(1, len(sources), figsize=(15, 5))\n", + "\n", + "# 각 source별로 히스토그램 그리기\n", + "for ax, source in zip(axes, sources):\n", + " # 히스토그램 데이터\n", + " hist_data = dev[dev[\"source\"] == source]\n", + " hist = sns.histplot(hist_data, x=\"label\", bins=5, kde=True, ax=ax)\n", + "\n", + " # 막대 위에 숫자 추가\n", + " for p in hist.patches:\n", + " ax.annotate(\n", + " f\"{int(p.get_height())}\",\n", + " (p.get_x() + p.get_width() / 2.0, p.get_height()),\n", + " ha=\"center\",\n", + " va=\"bottom\",\n", + " )\n", + "\n", + " ax.set_title(f\"{source}\")\n", + " ax.set_xlabel(\"Label\")\n", + " ax.set_ylabel(\"Count\")\n", + "\n", + "# 레이아웃 조정\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 텍스트" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 텍스트 길이" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "train[\"s1_len\"] = train[\"sentence_1\"].str.len() # 문장1 길이\n", + "train[\"s2_len\"] = train[\"sentence_2\"].str.len() # 문장2 길이\n", + "train[\"len_diff\"] = (train[\"s1_len\"] - train[\"s2_len\"]).map(abs) # 문장 1,2 길이 차이\n", + "\n", + "dev[\"s1_len\"] = dev[\"sentence_1\"].str.len() # 문장1 길이\n", + "dev[\"s2_len\"] = dev[\"sentence_2\"].str.len() # 문장2 길이\n", + "dev[\"len_diff\"] = (dev[\"s1_len\"] - dev[\"s2_len\"]).map(abs) # 문장 1,2 길이 차이\n", + "\n", + "test[\"s1_len\"] = test[\"sentence_1\"].str.len() # 문장1 길이\n", + "test[\"s2_len\"] = test[\"sentence_2\"].str.len() # 문장2 길이\n", + "test[\"len_diff\"] = (test[\"s1_len\"] - test[\"s2_len\"]).map(abs) # 문장 1,2 길이 차이" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 서브플롯 생성\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# 첫 번째 서브플롯: s1_len\n", + "sns.histplot(test[\"s1_len\"], kde=True, bins=50, color=\"blue\", ax=axes[0])\n", + "axes[0].set_title(\"test s1 len Distribution\")\n", + "axes[0].set_xlabel(\"Sentence Length\")\n", + "axes[0].set_ylabel(\"Count\")\n", + "\n", + "# 두 번째 서브플롯: s2_len\n", + "sns.histplot(test[\"s2_len\"], kde=True, bins=50, color=\"orange\", ax=axes[1])\n", + "axes[1].set_title(\"test s2 len Distribution\")\n", + "axes[1].set_xlabel(\"Sentence Length\")\n", + "axes[1].set_ylabel(\"Count\")\n", + "\n", + "# 레이아웃 조정\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXZklEQVR4nO3dd3wUZf4H8M9sT9tNIw1ICD2hGwQiFgSkiCiCgh71VFAuIIhyyu8UEBWQO5HTQxBF8Dw5FRULRw9FpQkBpIXQCSWVkN3U3WT3+f2R7MKSBJKQZJLdz/v1GpOdeXbmO5M1+fDMMzOSEEKAiIiIyEUp5C6AiIiIqDYx7BAREZFLY9ghIiIil8awQ0RERC6NYYeIiIhcGsMOERERuTSGHSIiInJpDDtERETk0hh2iIiIyKUx7BBRrerVqxd69eoldxm3NXv2bEiShMzMzBpd7837f/78eUiShJUrVzq127BhAzp37gydTgdJkpCdnQ0A+OKLL9C2bVuo1Wr4+vrWaG3jxo1Ds2bNanSdFWnWrBnGjRvneL1y5UpIkoT9+/fXyfYbyueQagfDDtULu3btwuzZsx2/4GvL3Llz8cMPP9TqNu7UqlWrsGjRIrnLcFn18TNw9epVDB8+HB4eHli8eDG++OILeHl54cSJExg3bhxatGiBTz75BMuWLatwHfawZp88PT0RHh6OwYMHY8WKFTCbzTVS6/HjxzF79mycP3++RtZXk+pzbSQvldwFEAElYefNN9/EuHHjavxfrzeaO3cunnjiCQwZMqTWtnGnVq1ahaNHj2Lq1Klyl+KS5P4MREREoKCgAGq12jFv3759yMnJwVtvvYW+ffs65m/fvh02mw3//Oc/0bJly0qtf8mSJfD29obZbMbly5exceNGPPPMM1i0aBHWrl2Lpk2bOtp+8sknsNlsVar/+PHjePPNN9GrV68q9QolJSVBoajdf1/fqrZNmzbV6rapfmPYISKqQ5IkQafTOc1LT08HgDJBv6L5t/LEE08gMDDQ8XrmzJn48ssvMWbMGDz55JPYs2ePY9mNgas2CCFQWFgIDw8PaLXaWt3W7Wg0Glm3TzITRDKbNWuWAFBmOnfunKPNF198Ie666y6h0+mEn5+fGDFihEhOTnZaz8mTJ8XQoUNFcHCw0Gq1onHjxmLEiBEiOztbCCHK3cbYsWNvWdsHH3wgoqOjhYeHh/D19RUxMTHiyy+/dGpz6dIl8ec//1kEBQUJjUYjoqOjxfLly53abNu2TQAQX3/9tXj77bdF48aNhVarFb179xanTp1ytHvggQfK1BgREeFYXlhYKGbOnClatGghNBqNaNKkiZg+fbooLCx02h4AERcXJ9asWSPatWvnqGv9+vVl9vHSpUvimWeeEaGhoUKj0YhmzZqJF154QZjNZkeba9euiSlTpogmTZoIjUYjWrRoIebPny+sVustj599nx544AGnebWxH9u2bRMxMTFCq9WK5s2bi6VLlzo+Wzeur6LPgL3tqVOnxNixY4XBYBB6vV6MGzdO5OXl3XY/hRDi448/Fs2bNxc6nU7cfffd4pdffimz/+fOnRMAxIoVKxzHp7yaIiIiysyfNWtWhdu215+RkVHu8gkTJggAYtOmTY559u3c6L///a+46667hLe3t/Dx8RHt27cXixYtEkIIsWLFinKP4bZt24QQQkRERIhBgwaJDRs2OH4W77//vmPZjf+/2de1Y8cOMWHCBOHv7y98fHzE6NGjRVZWllNNFe37jeu8XW3lfQ7T0tLEM888I4KCgoRWqxUdO3YUK1eudGpj/3n9/e9/d/x8NRqN6Nq1q/j999/LPdZU/7Bnh2Q3dOhQnDx5Ev/973/x/vvvO/5V2qhRIwDAO++8gzfeeAPDhw/Hc889h4yMDHz44Ye4//77cfDgQfj6+sJisaB///4wm82YPHkyQkJCcPnyZaxduxbZ2dkwGAz44osv8Nxzz6Fbt26YMGECAKBFixYV1vXJJ5/gxRdfxBNPPIEpU6agsLAQhw8fxt69e/GnP/0JAJCWloYePXpAkiRMmjQJjRo1wvr16/Hss8/CZDKVORU1f/58KBQKvPLKKzAajViwYAFGjhyJvXv3AgD+9re/wWg04tKlS3j//fcBAN7e3gAAm82GRx99FL/99hsmTJiAqKgoHDlyBO+//z5OnjxZZhzKb7/9hu+//x5/+ctf4OPjgw8++ADDhg1DcnIyAgICAABXrlxBt27dkJ2djQkTJqBt27a4fPkyvv32W+Tn50Oj0SA/Px8PPPAALl++jOeffx7h4eHYtWsXZsyYgZSUlCqPL6qN/Th48CAGDBiA0NBQvPnmm7BarZgzZ47jM2RXmc/A8OHDERkZiXnz5uHAgQP49NNPERQUhHffffeW+7V8+XI8//zzuOeeezB16lScPXsWjz76KPz9/Z1OHd3sb3/7G9q0aYNly5Zhzpw5iIyMRIsWLTBkyBD8+9//xpo1axynpjp27FjZw1zG6NGjsWzZMmzatAkPPfRQuW02b96Mp59+Gn369HHsb2JiInbu3IkpU6bg/vvvx4svvogPPvgA//d//4eoqCgAcHwFSk5XPf3003j++ecxfvx4tGnT5pZ1TZo0Cb6+vpg9ezaSkpKwZMkSXLhwAdu3b4ckSZXev8rUdqOCggL06tULp0+fxqRJkxAZGYnVq1dj3LhxyM7OxpQpU5zar1q1Cjk5OXj++echSRIWLFiAoUOH4uzZs7XeQ0Y1QO60RSSEEH//+9/L9OYIIcT58+eFUqkU77zzjtP8I0eOCJVK5Zh/8OBBAUCsXr36ltvx8vK6bW+O3WOPPSbatWt3yzbPPvusCA0NFZmZmU7zn3rqKWEwGER+fr4Q4nrPTlRUlFOPyT//+U8BQBw5csQxb9CgQWX+tS1ESe+WQqEQv/76q9P8pUuXCgBi586djnkAhEajEadPn3bM++OPPwQA8eGHHzrmjRkzRigUCrFv374y27PZbEIIId566y3h5eUlTp486bT8tddeE0qlskwP281u/hd1bezH4MGDhaenp7h8+bJj3qlTp4RKpRI3/5qr6DNg7xl55plnnOY//vjjIiAg4Jb7aLFYRFBQkOjcubPTz3fZsmUCwC17doS43itx88/hdr01VWl77do1AUA8/vjjjnk39+xMmTJF6PV6UVxcXOF2Vq9e7dRjciN7b9SGDRvKXVZez05MTIywWCyO+QsWLBAAxI8//uiYh0r07Nyutps/h4sWLRIAxH/+8x/HPIvFImJjY4W3t7cwmUxCiOs/r4CAAKcepx9//FEAED///HOZbVH9w6uxqF77/vvvYbPZMHz4cGRmZjqmkJAQtGrVCtu2bQMAGAwGAMDGjRuRn59fI9v29fXFpUuXsG/fvnKXCyHw3XffYfDgwRBCONXXv39/GI1GHDhwwOk9f/7zn53GDtx3330AgLNnz962ntWrVyMqKgpt27Z12lbv3r0BwHEs7Pr27evUa9GxY0fo9XrHtmw2G3744QcMHjwYXbt2LbM9+7+qV69ejfvuuw9+fn5O2+3bty+sVit++eWX29Zem/thtVqxZcsWDBkyBGFhYY52LVu2xMCBA6tUGwC88MILTq/vu+8+XL16FSaTqcL37N+/H+np6XjhhRecfr7jxo1zfDblZu8hzMnJqbCNr68v8vLysHnz5mpvJzIyEv379690+wkTJjj1jEycOBEqlQrr1q2rdg2VsW7dOoSEhODpp592zFOr1XjxxReRm5uLHTt2OLUfMWIE/Pz8HK+r8v8uyY+nsaheO3XqFIQQaNWqVbnL7b8kIyMjMW3aNCxcuBBffvkl7rvvPjz66KMYNWpUtf/YvPrqq9iyZQu6deuGli1bol+/fvjTn/6Enj17AgAyMjKQnZ2NZcuWVXhJsH2AqV14eLjTa/svz2vXrt22nlOnTiExMbHMqZnKbsu+Pfu2MjIyYDKZ0L59+9tu9/Dhw5Xe7u3U9H6kp6ejoKCg3KuVKnsF0622d+PPSK/Xl/ueCxcuAECZz6larUbz5s2rXENtyM3NBQD4+PhU2OYvf/kLvvnmGwwcOBCNGzdGv379MHz4cAwYMKDS24mMjKxSXTcfM29vb4SGhtb65eMXLlxAq1atylwhZj/tZf+Z2t3J/7skP4YdqtdsNhskScL69euhVCrLLLf/axUA3nvvPYwbNw4//vgjNm3ahBdffBHz5s3Dnj170KRJkypvOyoqCklJSVi7di02bNiA7777Dh999BFmzpyJN99803HJ7qhRozB27Nhy13HzGIvy9gEo6SW6HZvNhg4dOmDhwoXlLr95XMidbOvm7T700EP461//Wu7y1q1bV3l9cuxHZdX19urK0aNHAdw6AAYFBeHQoUPYuHEj1q9fj/Xr12PFihUYM2YMPv/880ptx8PDo0bqrQyr1Vpn23LVz4W7YNiheqGigYgtWrSAEAKRkZGV+qPaoUMHdOjQAa+//jp27dqFnj17YunSpXj77bdvuZ2KeHl5YcSIERgxYgQsFguGDh2Kd955BzNmzECjRo3g4+MDq9XqdG+UO3WrY/HHH3+gT58+Vd6P8jRq1Ah6vd7xR7AiLVq0QG5ubo3tY03vR1BQEHQ6HU6fPl1mWXnzamKbN4uIiABQ0mtlPx0HAEVFRTh37hw6depU49usqi+++AIAbnuKSaPRYPDgwRg8eDBsNhv+8pe/4OOPP8Ybb7yBli1b1vjxO3XqFB588EHH69zcXKSkpODhhx92zPPz8ytzw1GLxYKUlBSneVWpLSIiAocPH4bNZnPq3Tlx4oRjObkOjtmhesHLywsAyvxCGzp0KJRKJd58880y/4ISQuDq1asAAJPJhOLiYqflHTp0gEKhcLpzrJeXV6Xv0mxft51Go0F0dDSEECgqKoJSqcSwYcPw3XfflRsYMjIyKrWdm3l5ecFoNJaZP3z4cFy+fBmffPJJmWUFBQXIy8ur0nYUCgWGDBmCn3/+udxb9tuP9/Dhw7F7925s3LixTJvs7Owyx/12ano/lEol+vbtix9++AFXrlxxzD99+jTWr19fpn1VPgOV1bVrVzRq1AhLly6FxWJxzF+5cmWt3xW8MlatWoVPP/0UsbGx6NOnT4Xtbv7MKxQKR++k/f+jiv5fra5ly5ahqKjI8XrJkiUoLi52Gm/VokWLMmPDli1bVqZnpyq1Pfzww0hNTcXXX3/tmFdcXIwPP/wQ3t7eeOCBB6qzO1RPsWeH6oWYmBgAJZfhPvXUU1Cr1Rg8eDBatGiBt99+GzNmzMD58+cxZMgQ+Pj44Ny5c1izZg0mTJiAV155BVu3bsWkSZPw5JNPonXr1iguLsYXX3zhCCQ3bmfLli1YuHAhwsLCEBkZie7du5dbU79+/RASEoKePXsiODgYiYmJ+Ne//oVBgwY5xj3Mnz8f27ZtQ/fu3TF+/HhER0cjKysLBw4cwJYtW5CVlVWtY/H1119j2rRpuPvuu+Ht7Y3Bgwdj9OjR+Oabb/DCCy9g27Zt6NmzJ6xWK06cOIFvvvkGGzduLHeg8a3MnTsXmzZtwgMPPOC4DDwlJQWrV6/Gb7/9Bl9fX0yfPh0//fQTHnnkEYwbNw4xMTHIy8vDkSNH8O233+L8+fNON7G7ndrYj9mzZ2PTpk3o2bMnJk6cCKvVin/9619o3749Dh065NS2Kp+BylKr1Xj77bfx/PPPo3fv3hgxYgTOnTuHFStW1PmYnW+//Rbe3t6wWCyOOyjv3LkTnTp1wurVq2/53ueeew5ZWVno3bs3mjRpggsXLuDDDz9E586dHWNZOnfuDKVSiXfffRdGoxFarRa9e/dGUFBQteq1WCzo06cPhg8fjqSkJHz00Ue499578eijjzrV9cILL2DYsGF46KGH8Mcff2Djxo1lPndVqW3ChAn4+OOPMW7cOCQkJKBZs2b49ttvsXPnTixatOiWY5uoAZLlGjCicrz11luicePGQqFQlLkM/bvvvhP33nuv8PLyEl5eXqJt27YiLi5OJCUlCSGEOHv2rHjmmWdEixYthE6nE/7+/uLBBx8UW7ZscdrGiRMnxP333y88PDxue1PBjz/+WNx///0iICBAaLVa0aJFCzF9+nRhNBqd2qWlpYm4uDjRtGlToVarRUhIiOjTp49YtmyZo4390vObL40v7zLk3Nxc8ac//Un4+vqWuamgxWIR7777rmjXrp3QarXCz89PxMTEiDfffNOpLpTejO9mN1+qK4QQFy5cEGPGjBGNGjVy3JAvLi7O6RLqnJwcMWPGDNGyZUuh0WhEYGCguOeee8Q//vEPp8uGy1PezdxqYz/i4+NFly5dHDc9/PTTT8XLL78sdDqdU7uKPgMVXbptv0T65tsilOejjz4SkZGRQqvViq5du1bqpoI3bqMmLj23TzqdTjRp0kQ88sgj4rPPPitzw0Yhyl56/u2334p+/fo5bpAZHh4unn/+eZGSkuL0vk8++UQ0b95cKJXKcm8qWJ7b3VTQz89PeHt7i5EjR4qrV686vddqtYpXX31VBAYGCk9PT9G/f39x+vTpcj8HFdVW0U0F//znP4vAwECh0WhEhw4dnH4uQjjfVPBmuM2NHqn+kITg6Coick1DhgzBsWPHcOrUKblLISIZccwOEbmEgoICp9enTp3CunXr0KtXL3kKIqJ6gz07ROQSQkNDMW7cODRv3hwXLlzAkiVLYDabcfDgwQrv00RE7oEDlInIJQwYMAD//e9/kZqaCq1Wi9jYWMydO5dBh4jYs0NERESuTfYxO5cvX8aoUaMQEBAADw8PdOjQwemeH0IIzJw5E6GhofDw8EDfvn3LDDbMysrCyJEjodfr4evri2effdZxa3QiIiJyb7KGnWvXrqFnz55Qq9VYv349jh8/jvfee8/pYWsLFizABx98gKVLl2Lv3r3w8vJC//79UVhY6GgzcuRIHDt2DJs3b8batWvxyy+/YMKECXLsEhEREdUzsp7Geu2117Bz5078+uuv5S4XQiAsLAwvv/wyXnnlFQCA0WhEcHAwVq5ciaeeegqJiYmIjo7Gvn37HDci27BhAx5++GFcunTJ6SnIFbHZbLhy5Qp8fHxq5VbyREREVPOEEMjJyUFYWFiZh7re3FA2UVFRYurUqeKJJ54QjRo1Ep07d3a6EduZM2cEAHHw4EGn991///3ixRdfFEIIsXz5cuHr6+u0vKioSCiVSvH999+Xu93CwkJhNBod0/Hjx51uxsWJEydOnDhxajjTxYsXb5k3ZL0a6+zZs1iyZAmmTZuG//u//8O+ffvw4osvQqPRYOzYsUhNTQUABAcHO70vODjYsSw1NbXMrcBVKhX8/f0dbW42b948vPnmm2XmX7x4EXq9viZ2jYiIiGqZyWRC06ZNb/t4D1nDjs1mQ9euXTF37lwAQJcuXXD06FEsXboUY8eOrbXtzpgxA9OmTXO8th8svV7PsENERNTA3G4IiqwDlENDQxEdHe00LyoqCsnJyQCAkJAQAEBaWppTm7S0NMeykJAQpKenOy0vLi5GVlaWo83NtFqtI9gw4BAREbk2WcNOz549kZSU5DTv5MmTiIiIAABERkYiJCQE8fHxjuUmkwl79+5FbGwsACA2NhbZ2dlISEhwtNm6dStsNtsdP8mYiIiIGj5ZT2O99NJLuOeeezB37lwMHz4cv//+O5YtW4Zly5YBKOmWmjp1Kt5++220atUKkZGReOONNxAWFoYhQ4YAKOkJGjBgAMaPH4+lS5eiqKgIkyZNwlNPPVWpK7GIiIjItcl+B+W1a9dixowZOHXqFCIjIzFt2jSMHz/esVwIgVmzZmHZsmXIzs7Gvffei48++gitW7d2tMnKysKkSZPw888/Q6FQYNiwYfjggw/g7e1dqRpMJhMMBgOMRiNPaRERETUQlf37LXvYqQ8YdoiIiBqeyv79lv1xEURERES1iWGHiIiIXBrDDhEREbk0hh0iIiJyaQw7RERE5NIYdoiIiMilMewQERGRS2PYISIiIpfGsENEREQuTdZnY7mD5ORkZGZm1sq6AwMDER4eXivrJiIichUMO7UoOTkZbaOiUJCfXyvr9/D0xInERAYeIiKiW2DYqUWZmZkoyM/HyFf/juDwFjW67rTkM/jy3enIzMxk2CEiIroFhp06EBzeAk1atZO7DCIiIrfEAcpERETk0hh2iIiIyKUx7BAREZFLY9ghIiIil8awQ0RERC6NYYeIiIhcGsMOERERuTSGHSIiInJpDDtERETk0hh2iIiIyKUx7BAREZFLY9ghIiIil8awQ0RERC6NYYeIiIhcGsMOERERuTSGHSIiInJpDDtERETk0hh2iIiIyKUx7BAREZFLY9ghIiIil8awQ0RERC6NYYeIiIhcGsMOERERuTSGHSIiInJpDDtERETk0hh2iIiIyKUx7BAREZFLY9ghIiIil8awQ0RERC6NYYeIiIhcGsMOERERuTSGHSIiInJpDDtERETk0hh2iIiIyKUx7BAREZFLY9ghIiIil8awQ0RERC5N1rAze/ZsSJLkNLVt29axvLCwEHFxcQgICIC3tzeGDRuGtLQ0p3UkJydj0KBB8PT0RFBQEKZPn47i4uK63hUiIiKqp1RyF9CuXTts2bLF8Vqlul7SSy+9hP/9739YvXo1DAYDJk2ahKFDh2Lnzp0AAKvVikGDBiEkJAS7du1CSkoKxowZA7Vajblz59b5vhAREVH9I3vYUalUCAkJKTPfaDRi+fLlWLVqFXr37g0AWLFiBaKiorBnzx706NEDmzZtwvHjx7FlyxYEBwejc+fOeOutt/Dqq69i9uzZ0Gg0db07REREVM/IPmbn1KlTCAsLQ/PmzTFy5EgkJycDABISElBUVIS+ffs62rZt2xbh4eHYvXs3AGD37t3o0KEDgoODHW369+8Pk8mEY8eOVbhNs9kMk8nkNBEREZFrkjXsdO/eHStXrsSGDRuwZMkSnDt3Dvfddx9ycnKQmpoKjUYDX19fp/cEBwcjNTUVAJCamuoUdOzL7csqMm/ePBgMBsfUtGnTmt0xIiIiqjdkPY01cOBAx/cdO3ZE9+7dERERgW+++QYeHh61tt0ZM2Zg2rRpjtcmk4mBh4iIyEXJfhrrRr6+vmjdujVOnz6NkJAQWCwWZGdnO7VJS0tzjPEJCQkpc3WW/XV544DstFot9Hq900RERESuqV6FndzcXJw5cwahoaGIiYmBWq1GfHy8Y3lSUhKSk5MRGxsLAIiNjcWRI0eQnp7uaLN582bo9XpER0fXef1ERERU/8h6GuuVV17B4MGDERERgStXrmDWrFlQKpV4+umnYTAY8Oyzz2LatGnw9/eHXq/H5MmTERsbix49egAA+vXrh+joaIwePRoLFixAamoqXn/9dcTFxUGr1cq5a0RERFRPyBp2Ll26hKeffhpXr15Fo0aNcO+992LPnj1o1KgRAOD999+HQqHAsGHDYDab0b9/f3z00UeO9yuVSqxduxYTJ05EbGwsvLy8MHbsWMyZM0euXSIiIqJ6Rtaw89VXX91yuU6nw+LFi7F48eIK20RERGDdunU1XRoRERG5iHo1ZoeIiIiopjHsEBERkUtj2CEiIiKXxrBDRERELo1hh4iIiFwaww4RERG5NIYdIiIicmkMO0REROTSGHaIiIjIpTHsEBERkUtj2CEiIiKXxrBDRERELo1hh4iIiFwaww4RERG5NIYdIiIicmkMO0REROTSGHaIiIjIpTHsEBERkUtj2CEiIiKXxrBDRERELo1hh4iIiFwaww4RERG5NIYdIiIicmkMO0REROTSGHaIiIjIpTHsEBERkUtj2CEiIiKXxrBDRERELo1hh4iIiFwaww4RERG5NIYdIiIicmkMO0REROTSGHaIiIjIpTHsEBERkUtj2CEiIiKXxrBDRERELo1hh4iIiFwaww4RERG5NIadeqiwyAqbEHKXQURE5BJUchdAzs5m5GLd0VT4eqjxWOcw+OjUcpdERETUoLFnpx65kl2AdUdTYbUJXM2zYHXCJVzLs8hdFhERUYPGsFNPXMu34Kc/rsBqEwj394Svpxo5hcX49sAlWIptcpdHRETUYDHs1BMHLlyDudiGEL0Oj3QMxZMxTaDXqZBvseJUeo7c5RERETVYDDv1gBAC5zLzAAA9mvtDrVTAU6NC+8YGAMDxKyY5yyMiImrQGHbqgfQcM/IsVqiVEhr7eTjmR4XqIQG4YizEtXyO3SEiIqoOhp164Gxpr064vydUius/Em+tCuEBngDYu0NERFRdDDv1gP0UVvNA7zLL2oXqAQCJqSbee4eIiKgaGHZkllNYhIwcMwCgWaBnmeWRjbygUymQZ7biYlZ+XZdHRETU4DHsyMzeqxNq0MFTU/YejyqFAi2CSnp8khl2iIiIqoxhR2bnr5YEmMhArwrbNCkdtHzpWkGd1ERERORKGHZklmYqBAA09St7CsuuiW/JsowcM8xF1jqpi4iIyFXUm7Azf/58SJKEqVOnOuYVFhYiLi4OAQEB8Pb2xrBhw5CWlub0vuTkZAwaNAienp4ICgrC9OnTUVxcXMfVV0++pRj5lpLwEuCtqbCdt04FXw81BIDL2ezdISIiqop6EXb27duHjz/+GB07dnSa/9JLL+Hnn3/G6tWrsWPHDly5cgVDhw51LLdarRg0aBAsFgt27dqFzz//HCtXrsTMmTPreheqJTO35N45Bg811Mpb/ygcp7IYdoiIiKpE9rCTm5uLkSNH4pNPPoGfn59jvtFoxPLly7Fw4UL07t0bMTExWLFiBXbt2oU9e/YAADZt2oTjx4/jP//5Dzp37oyBAwfirbfewuLFi2Gx1P+b8GXmllyFFXiLXh27JqWnuS5z3A4REVGVyB524uLiMGjQIPTt29dpfkJCAoqKipzmt23bFuHh4di9ezcAYPfu3ejQoQOCg4Mdbfr37w+TyYRjx45VuE2z2QyTyeQ0yeF62NHetq29Zyc9x4xCjtshIiKqtLLXOtehr776CgcOHMC+ffvKLEtNTYVGo4Gvr6/T/ODgYKSmpjra3Bh07Mvtyyoyb948vPnmm3dY/Z27WnoaqzJhx0urgp+nGtfyi3AluwC37wsiIiIiQMaenYsXL2LKlCn48ssvodPp6nTbM2bMgNFodEwXL16s0+0DgM0mcDXPHnYqF10a8xJ0IiKiKpMt7CQkJCA9PR133XUXVCoVVCoVduzYgQ8++AAqlQrBwcGwWCzIzs52el9aWhpCQkIAACEhIWWuzrK/trcpj1arhV6vd5rqWnZBEaw2AbVSgsFDXan3NDaUhJ3U0svViYiI6PZkCzt9+vTBkSNHcOjQIcfUtWtXjBw50vG9Wq1GfHy84z1JSUlITk5GbGwsACA2NhZHjhxBenq6o83mzZuh1+sRHR1d5/tUFfbxOgFeWkiSVKn3BOlLesAycsyw8TFZRERElSLbmB0fHx+0b9/eaZ6XlxcCAgIc85999llMmzYN/v7+0Ov1mDx5MmJjY9GjRw8AQL9+/RAdHY3Ro0djwYIFSE1Nxeuvv464uDhotbcfByOnqlyJZefnqYZaKaHIKpBTVLmARERE5O5kHaB8O++//z4UCgWGDRsGs9mM/v3746OPPnIsVyqVWLt2LSZOnIjY2Fh4eXlh7NixmDNnjoxVV05mFQYn20mShCAfHS5nF+CahWGHiIioMupV2Nm+fbvTa51Oh8WLF2Px4sUVviciIgLr1q2r5cpqXlUuO79RsF7LsENERFQFst9nxx1Zim3IKSx5pMWtHhNRniCfknE72Qw7RERElcKwIwNjQREAQKdWQKdWVum9wfqSnqBsiwQoqvZeIiIid8SwIwNTYUnY0esqd8n5jQweamhUCtggQR0YXtOlERERuRyGHRnYe3Yqe3+dG0mShGCfkt4dbUirGq2LiIjIFTHsyMBUGnb01Qg7wPX77WgYdoiIiG6LYUcGjp6dapzGAuDo2dGEtKyxmoiIiFwVw44MTAUlV2LpPap35X8je9hp1AxW3kqZiIjolhh26pgQwjFAuTpjduzvU0kCkkqNyznFNVkeERGRy2HYqWP5FiuKS3tjfKp5GkuSJBjUJeu4YGTYISIiuhWGnTpmH6/jo1NBqaj+jQH1mtKwk11UI3URERG5KoadOnYn99i5kb1n53w2e3aIiIhuhWGnjt3p4GQ739KenfNG9uwQERHdCsNOHbuTGwreSF/as5NVYMO1PMsd10VEROSqGHbqmOkO77Fjp1YARddSAACJqaY7rouIiMhVMezUMWPhnd09+UZFGecBACdScu54XURERK6KYacOWW0CuYUlY3bu9DQWAFgyzgEAElPYs0NERFQRhp06lFNYBAFAqZDgqVHe8fos6SVh50Qqe3aIiIgqwrBTh0z2Xh2dGpJU/Xvs2BWlnwcAnEzLQbHVdsfrIyIickUMO3Uop/D6DQVrQnF2KnQqCeZiG85fzauRdRIREbkahp06lGsu6dnx0tZM2AEEmupL1pWUmltD6yQiInItDDt1yB52vGuoZwcAwg2lYSeN43aIiIjKw7BTh/LMVgCAd4317ADhhpKruk5ykDIREVG5GHbqkKNnp0bDTsm6TrJnh4iIqFwMO3XIfo+dGg07pWN2zl/NQ2GRtcbWS0RE5CoYdupIsc2GgtIw4qW983vs2PnqFPD30sAmgNPpHKRMRER0M4adOpJfOl5HKUnwUNdc2JEkCa2DvQEASRy3Q0REVAbDTh25ftm5skZuKHijNsE+AHhFFhERUXkYdupIbQxOtmsdUhp22LNDRERUBsNOHanNsNO2NOzwiiwiIqKyGHbqiOM0Vg3eUNCuVelprBRjIYwFRTW+fiIiooaMYaeO5NXCZed2ep0aYQYdAPbuEBER3Yxhp47U5mksAGjDcTtERETlYtipI7Uddlpz3A4REVG5GHbqgBBAnqXmn4t1I/vl5yfYs0NEROSEYacOWGyA1SYAAF611bMTfL1nRwhRK9sgIiJqiBh26kCBteQmgh5qJZSKmr2hoF3LIG8oJCA7vwgZOeZa2QYREVFDVK2w07x5c1y9erXM/OzsbDRv3vyOi3I1BaXP56ytU1gAoFMr0SzQCwDvpExERHSjaoWd8+fPw2ot+4Rts9mMy5cv33FRrsbes1OTDwAtj+OxERy3Q0RE5FClroaffvrJ8f3GjRthMBgcr61WK+Lj49GsWbMaK85VFBaXhB3vWrih4I1aB/tg/dFUhh0iIqIbVOmv75AhQwCUPGl77NixTsvUajWaNWuG9957r8aKcxWO01ia2g07fGwEERFRWVX662uz2QAAkZGR2LdvHwIDA2ulKFdT6DiNVcs9O46wkwubTUBRS4OhiYiIGpJqjdk5d+4cg04VmEsyIjw1tTtmJ8LfExqVAgVFVly8ll+r2yIiImooqt3VEB8fj/j4eKSnpzt6fOw+++yzOy7Mldh7djxruWdHpVSgVZA3jl0xISk1BxEBXrW6PSIiooagWj07b775Jvr164f4+HhkZmbi2rVrThPdSEJh6Zgdr1ru2QGuX5HFcTtEREQlqtXVsHTpUqxcuRKjR4+u6XpcjkLnDYHSmwrWQdixj9vhYyOIiIhKVKtnx2Kx4J577qnpWlyS0tsPAKBTKaBS1P4Nq9mzQ0RE5Kxaf32fe+45rFq1qqZrcUlKr5KwU9vjdezalPbsnM3Ig6XYdpvWRERErq9af4ELCwuxbNkybNmyBR07doRarXZavnDhwhopzhU4wk4dnMICgFCDDj5aFXLMxTiXmecIP0RERO6qWmHn8OHD6Ny5MwDg6NGjTsskifd2uZGiNOx41fINBe0kSULrEB8kXLiGE6kmhh0iInJ71foLvG3btpquw2UpvXwBAJ61/FysG7UOLgk7HLdDRERUzTE7NWXJkiXo2LEj9Ho99Ho9YmNjsX79esfywsJCxMXFISAgAN7e3hg2bBjS0tKc1pGcnIxBgwbB09MTQUFBmD59OoqLi+t6VyqkrOOeHeD6YyOSUnPrbJtERET1VbX+Aj/44IO3PF21devWSq2nSZMmmD9/Plq1agUhBD7//HM89thjOHjwINq1a4eXXnoJ//vf/7B69WoYDAZMmjQJQ4cOxc6dOwGUPHx00KBBCAkJwa5du5CSkoIxY8ZArVZj7ty51dm1Gme/GquuxuwAJT07AK/IIiIiAqoZduzjdeyKiopw6NAhHD16tMwDQm9l8ODBTq/feecdLFmyBHv27EGTJk2wfPlyrFq1Cr179wYArFixAlFRUdizZw969OiBTZs24fjx49iyZQuCg4PRuXNnvPXWW3j11Vcxe/ZsaDSa6uxejVJ6+gKo67DjDQBIzspHnrm41p/JRUREVJ9V66/g+++/X+782bNnIze3eqdOrFYrVq9ejby8PMTGxiIhIQFFRUXo27evo03btm0RHh6O3bt3o0ePHti9ezc6dOiA4OBgR5v+/ftj4sSJOHbsGLp06VLutsxmM8xms+O1yWSqVs2V4TiNVYeBI8Bbi0BvLTJzzTiVnovOTX3rbNtERET1TY2O2Rk1alSVn4t15MgReHt7Q6vV4oUXXsCaNWsQHR2N1NRUaDQa+Pr6OrUPDg5GamoqACA1NdUp6NiX25dVZN68eTAYDI6padOmVaq5soptAgpPPYC67dkBro/bOck7KRMRkZur0bCze/du6HS6Kr2nTZs2OHToEPbu3YuJEydi7NixOH78eE2WVcaMGTNgNBod08WLF2tlOyazDZKkgAQBD3Xdhh37uB0+NoKIiNxdtc6tDB061Om1EAIpKSnYv38/3njjjSqtS6PRoGXLlgCAmJgY7Nu3D//85z8xYsQIWCwWZGdnO/XupKWlISQkBAAQEhKC33//3Wl99qu17G3Ko9VqodVqq1RndVwrLLmDsVZZ9/cfahNSMm6Hg5SJiMjdVatn58ZTQAaDAf7+/ujVqxfWrVuHWbNm3VFBNpsNZrMZMTExUKvViI+PdyxLSkpCcnIyYmNjAQCxsbE4cuQI0tPTHW02b94MvV6P6OjoO6qjJmSXPu5cpxB1vu02ISWnz9izQ0RE7q5aPTsrVqyokY3PmDEDAwcORHh4OHJycrBq1Sps374dGzduhMFgwLPPPotp06bB398fer0ekydPRmxsLHr06AEA6NevH6KjozF69GgsWLAAqampeP311xEXF1cnPTe3k11Q0rOjq9szWABKrsiSJCAz14zMXDMCveU/HkRERHK4o0uEEhISkJiYCABo165dhVc/VSQ9PR1jxoxBSkoKDAYDOnbsiI0bN+Khhx4CUHLVl0KhwLBhw2A2m9G/f3989NFHjvcrlUqsXbsWEydORGxsLLy8vDB27FjMmTPnTnarxthPY+mUdd+z46lRoVmAF85l5iExxYT7WjWq8xqIiIjqg2qFnfT0dDz11FPYvn27YzxNdnY2HnzwQXz11Vdo1Khyf1iXL19+y+U6nQ6LFy/G4sWLK2wTERGBdevWVbr2umQ/jVWHT4pwEhXqw7BDRERur1pjdiZPnoycnBwcO3YMWVlZyMrKwtGjR2EymfDiiy/WdI0NVraMPTsAEFU6bicxheN2iIjIfVWrZ2fDhg3YsmULoqKiHPOio6OxePFi9OvXr8aKa+gcYUemJ5BFh5WEneNXau+miURERPVdtf4M22w2qNXqMvPVajVsNtsdF+UqrjlOY8nUsxNaEnbOZOTCXGyVpQYiIiK5VSvs9O7dG1OmTMGVK1cc8y5fvoyXXnoJffr0qbHiGroBLTxh2v8TvFXyhJ1Qgw4GDzWKbQKn0vgEdCIick/VCjv/+te/YDKZ0KxZM7Ro0QItWrRAZGQkTCYTPvzww5quscEa3MYb1+KXwUOm53BKkoSo0JI7KSem8FQWERG5p2r9GW7atCkOHDiALVu24MSJEwCAqKgop4d2Uv0QFarHnrNZOM6wQ0REbqpKPTtbt25FdHQ0TCYTJEnCQw89hMmTJ2Py5Mm4++670a5dO/z666+1VStVQ3So/Yoshh0iInJPVQo7ixYtwvjx46HX68ssMxgMeP7557Fw4cIaK47uXFTo9cvPhZBn7BAREZGcqhR2/vjjDwwYMKDC5f369UNCQsIdF0U1p1WwN1QKCcaCIqQYC+Uuh4iIqM5VKeykpaWVe8m5nUqlQkZGxh0XRTVHq1KiZVDJE9CP8X47RETkhqoUdho3boyjR49WuPzw4cMIDQ2946KoZrULMwAAjl42ylwJERFR3atS2Hn44YfxxhtvoLCw7OmQgoICzJo1C4888kiNFUc1o33jknE7x64w7BARkfup0qXnr7/+Or7//nu0bt0akyZNQps2bQAAJ06cwOLFi2G1WvG3v/2tVgql6mvf2N6zw9NYRETkfqoUdoKDg7Fr1y5MnDgRM2bMcFzdI0kS+vfvj8WLFyM4OLhWCqXqiw7VQ5KAVFMhMnLMaOSjlbskIiKiOlPlmwpGRERg3bp1uHbtGk6fPg0hBFq1agU/P7/aqI9qgJdWheaBXjiTkYejV4x4sE2Q3CURERHVmWo/yMDPzw933313TdZCtah9YwPOZOTh2GWGHSIici/VejYWNTztwzhuh4iI3BPDjpuwD1I+wsvPiYjIzTDsuInosJLLzy9nF+BankXmaoiIiOoOw46bMHioERHgCYB3UiYiIvfCsONG7ON2eCqLiIjcCcOOG+nYpCTsHL6ULW8hREREdYhhx410auoLADh0MVvWOoiIiOoSw44b6dDYAIUEpBgLkWYq+3wzIiIiV8Sw40a8tCq0DvYBAPzB3h0iInITDDtuplMTXwDAHxy3Q0REboJhx81w3A4REbkbhh0306lp6RVZF42w2YTM1RAREdU+hh030ybYBzq1AjnmYpzNzJO7HCIiolrHsONmVEoFOpQ+J4uDlImIyB0w7LghDlImIiJ3wrDjhuyDlA8kX5O3ECIiojrAsOOGYiL8AACJKTnIMxfLXA0REVHtYthxQ2G+Hggz6GC1CY7bISIil6eSuwC6M4mJidV6X6QeuGIEftp9DDqTj9OywMBAhIeH10R5REREsmPYaaBMWRkAgFGjRlXr/T53PQL/h17Aip+3490xs52WeXh64kRiIgMPERG5BIadBqog1wQAGPT839CmY0yV33/NImFrKqBvEYOR//oeklQyPy35DL58dzoyMzMZdoiIyCUw7DRwAWERaNKqXZXfF2YT+DXjDIqsgEdYSwR6a2uhOiIiIvlxgLKbUigkhOh1AIAr2QUyV0NERFR7GHbcWKivBwAgxVgocyVERES1h2HHjYUZSnp2GHaIiMiVMey4sRCDDhIAY0ERcgt5c0EiInJNDDtuTKtSopFPycDkS9n5MldDRERUOxh23FwTv5JxO5evcZAyERG5JoYdN9e4NOxc4hVZRETkohh23FxjgwckANn5RcjlQ0GJiMgFMey4Oa36+rgdnsoiIiJXxLBD109lXeMgZSIicj0MO4Qmvhy3Q0RErothh9C4NOxk5xehwCpzMURERDWMYYegVSsRVDpuJ6OQHwkiInItsv5lmzdvHu6++274+PggKCgIQ4YMQVJSklObwsJCxMXFISAgAN7e3hg2bBjS0tKc2iQnJ2PQoEHw9PREUFAQpk+fjuJiXllUFU39PQEA6YWSzJUQERHVLFnDzo4dOxAXF4c9e/Zg8+bNKCoqQr9+/ZCXl+do89JLL+Hnn3/G6tWrsWPHDly5cgVDhw51LLdarRg0aBAsFgt27dqFzz//HCtXrsTMmTPl2KUGK7w07KSxZ4eIiFyMSs6Nb9iwwen1ypUrERQUhISEBNx///0wGo1Yvnw5Vq1ahd69ewMAVqxYgaioKOzZswc9evTApk2bcPz4cWzZsgXBwcHo3Lkz3nrrLbz66quYPXs2NBqNHLvW4IQZdFAqJBRaAXVAU7nLISIiqjH16p/xRqMRAODv7w8ASEhIQFFREfr27eto07ZtW4SHh2P37t0AgN27d6NDhw4IDg52tOnfvz9MJhOOHTtW7nbMZjNMJpPT5O5USoVjoLIusovM1RAREdWcehN2bDYbpk6dip49e6J9+/YAgNTUVGg0Gvj6+jq1DQ4ORmpqqqPNjUHHvty+rDzz5s2DwWBwTE2bsicDuH4qS9eMYYeIiFxHvQk7cXFxOHr0KL766qta39aMGTNgNBod08WLF2t9mw2BI+w07YAiq5C5GiIioppRL8LOpEmTsHbtWmzbtg1NmjRxzA8JCYHFYkF2drZT+7S0NISEhDja3Hx1lv21vc3NtFot9Hq900RAoLcGWoWAQqND0lWL3OUQERHVCFnDjhACkyZNwpo1a7B161ZERkY6LY+JiYFarUZ8fLxjXlJSEpKTkxEbGwsAiI2NxZEjR5Cenu5os3nzZuj1ekRHR9fNjrgISZIQpLMBAA6lmmWuhoiIqGbIejVWXFwcVq1ahR9//BE+Pj6OMTYGgwEeHh4wGAx49tlnMW3aNPj7+0Ov12Py5MmIjY1Fjx49AAD9+vVDdHQ0Ro8ejQULFiA1NRWvv/464uLioNVq5dy9BinYQ+BiPnCAYYeIiFyErGFnyZIlAIBevXo5zV+xYgXGjRsHAHj//fehUCgwbNgwmM1m9O/fHx999JGjrVKpxNq1azFx4kTExsbCy8sLY8eOxZw5c+pqN1xKiM4GIWw4n12MFGMBQg0ecpdERER0R2QNO0LcfhCsTqfD4sWLsXjx4grbREREYN26dTVZmtvSKgFLyklow9pie1IGnu4WLndJREREd6ReDFCm+qXgzH4AwNYT6bdpSUREVP8x7FAZBWf2AQB2ns6EuZiPQSciooaNYYfKsKSdgZ9OgXyLFXvPZsldDhER0R1h2KFy3RVaciUbT2UREVFDx7BD5eoapgMAxJ9Iq9RAciIiovqKYYfK1SlYA61KgYtZBTiRmiN3OURERNXGsEPl0qkUuK9VIwDAxmPlP1CViIioIWDYoQr1b1fy9PiNx9Ju05KIiKj+YtihCvWNCoZSISExxYSLWflyl0NERFQtDDtUIT8vDbo18wfAU1lERNRwMezQLfVznMpi2CEiooaJYYduqV+7EADA/gvXkJ5TKHM1REREVcewQ7fU2NcDnZr6Qghgw1H27hARUcPDsEO3NbhjKABg7R8pMldCRERUdQw7dFsPdygJO/suZCHVyFNZRETUsDDs0G2F+XogJsIPQgDrjrB3h4iIGhaGHaqUR+ynsg5fkbkSIiKiqmHYoUp5uEMoJAk4kJyNy9kFcpdDRERUaQw7VCnBep3jBoM/HWLvDhERNRwMO1Rpj3dpDABYc/AShBAyV0NERFQ5DDtUaQM7hEKjUuBkWi6OXTHJXQ4REVGlMOxQpRk81HgoquTxEWsOXpa5GiIiosph2KEqsZ/K+vHQFRRbbTJXQ0REdHsMO1QlD7RpBH8vDTJzzfj1dKbc5RAREd0Www5ViVqpwKOdwgAA3yVckrkaIiKi22PYoSp7IqYJAGDTsTRcy7PIXA0REdGtMexQlbVvbED7xnpYrDYOVCYionqPYYeqZcTd4QCAr/dd5D13iIioXmPYoWp5tFMYdGoFktJycOhittzlEBERVYhhh6rF4KHGwx1KHg769b6LMldDRERUMYYdqranSk9l/XjoCowFRTJXQ0REVD6GHaq2u5v5oXWwNwqKrLwMnYiI6i2GHao2SZIwJrYZAOA/ey7AZuNAZSIiqn8YduiOPN6lMXy0KpzNzMNvvKMyERHVQww7dEe8tCoMK73J4L93n5e3GCIionIw7NAdGx0bAQCIP5GO5Kv5MldDRETkTCV3AVQ/JSYmVql95xAtDqWaMX/NXjx3l6HCdoGBgQgPD7/T8oiIiCqNYYecmLIyAACjRo2q0vt0EZ0Q/NQ7WHs8Cx9PfhS2wtxy23l4euJEYiIDDxER1RmGHXJSkGsCAAx6/m9o0zGm0u8TAohPtcEIHQbM/A/aGmxl2qQln8GX705HZmYmww4REdUZhh0qV0BYBJq0alel93T3MWHT8TScK9Ci113NoFJwSBgREcmPf42oxrQO9oG3VoV8ixUnUnPkLoeIiAgAww7VIKVCQpemvgCA/eev8SaDRERULzDsUI3q0MQAD7USxoIinExj7w4REcmPYYdqlFqpQJdwXwDA7+ezIAR7d4iISF4MO1TjOjYxQKtS4Fp+EU6nl38JOhERUV1h2KEap1Up0bl07M6ec1mwsXeHiIhkxLBDtaJLU19oVQpk5VmQxCuziIhIRgw7VCu0aiW6RvgBAPacvQorr8wiIiKZMOxQrenU1BeeGiVMhcU4etkodzlEROSmGHao1qiVCnSL9AdQcmVWUdknSBAREdU6WcPOL7/8gsGDByMsLAySJOGHH35wWi6EwMyZMxEaGgoPDw/07dsXp06dcmqTlZWFkSNHQq/Xw9fXF88++yxyc3kFUH3RPswAg4ca+RYrkkxKucshIiI3JGvYycvLQ6dOnbB48eJyly9YsAAffPABli5dir1798LLywv9+/dHYWGho83IkSNx7NgxbN68GWvXrsUvv/yCCRMm1NUu0G0oFRLuaxUIADhlUkCpbyRzRURE5G5kfRDowIEDMXDgwHKXCSGwaNEivP7663jssccAAP/+978RHByMH374AU899RQSExOxYcMG7Nu3D127dgUAfPjhh3j44Yfxj3/8A2FhYXW2L1Sx5oFeaOLrgUvZBfB7YJzc5RARkZupt2N2zp07h9TUVPTt29cxz2AwoHv37ti9ezcAYPfu3fD19XUEHQDo27cvFAoF9u7dW+G6zWYzTCaT00S1R5Ik3N+6EQABr+gHkJhhkbskIiJyI/U27KSmpgIAgoODneYHBwc7lqWmpiIoKMhpuUqlgr+/v6NNeebNmweDweCYmjZtWsPV080a+WjRzKtkhPLHB4wosnK0MhER1Y16G3Zq04wZM2A0Gh3TxYsX5S7JLbT3tcKab0SysRif7zovdzlEROQm6m3YCQkJAQCkpaU5zU9LS3MsCwkJQXp6utPy4uJiZGVlOdqUR6vVQq/XO01U+7RKIHvHSgDA+5tPIsVYIG9BRETkFupt2ImMjERISAji4+Md80wmE/bu3YvY2FgAQGxsLLKzs5GQkOBos3XrVthsNnTv3r3Oa6bbyz28BW0C1MizWPH6mqN8KjoREdU6WcNObm4uDh06hEOHDgEoGZR86NAhJCcnQ5IkTJ06FW+//TZ++uknHDlyBGPGjEFYWBiGDBkCAIiKisKAAQMwfvx4/P7779i5cycmTZqEp556ildi1VsCL3Q1QKNUIP5EOr4/cFnugoiIyMXJGnb279+PLl26oEuXLgCAadOmoUuXLpg5cyYA4K9//SsmT56MCRMm4O6770Zubi42bNgAnU7nWMeXX36Jtm3bok+fPnj44Ydx7733YtmyZbLsD1VOhEGNKX1bAQBm/3wMqcbC27yDiIio+mS9z06vXr1ueRpDkiTMmTMHc+bMqbCNv78/Vq1aVRvlUS16/v7m2HQsFX9cMmLG94fx2bi7IUmS3GUREZELqrdjdsi1qZQK/OPJTtAoFdiWlIHVCZfkLomIiFwUww7JplWwD156qDUA4K2fj/PqLCIiqhUMOySr8fdFonNTX+SYi/Hqd0d4dRYREdU4hh2Slf10llalwC8nM7D8t3Nyl0RERC6GYYdk1zLIG288Eg0AmL/+BA4mX5O5IiIiciUMO1QvjOwejkEdQlFsE5i06iCM+UVyl0RERC6CYYfqBUmSMG9YB4T7e+JydgFe/e4wx+8QEVGNYNihekOvU+Nff+oCtVLChmOp+GLPBblLIiIiF8CwQ/VKxya+mDEwCgDw9tpEHL1slLkiIiJq6Bh2qN75c89meCg6GBarDc9/kYCsPIvcJRERUQMm6+MiyD0lJibets3o1sCRZCUuZxdg3Mc78Mb9/lAqKn6cRGBgIMLDw2uyTCIichEMO1RnTFkZAIBRo0ZVqr06MAIho/+Bw+lAv79+hOxtn1XY1sPTEycSExl4iIioDIYdqjMFuSYAwKDn/4Y2HWMq9Z5L+RL2ZgKGbkPx0MBH0dTLVqZNWvIZfPnudGRmZjLsEBFRGQw7VOcCwiLQpFW7SrVtAsB6OhP7L1zDgWtqtGzRFI18tLVbIBERuRQOUKZ6L7ZFACL8PVFsE1h7+AryLcVyl0RERA0Iww7VewpJwoD2ITB4qGEqLMbawykotpY9nUVERFQehh1qEHRqJR7tFAaNSoEUYyHiT6TzDstERFQpDDvUYPh7aTCoQygkCTiRmoPfz2fJXRIRETUADDvUoIT7e+LBNkEAgD1ns3AyLUfmioiIqL5j2KEGp0NjA7o09QUAbDqehqvmim82SERExLBDDdK9rQIRGegFq01gV4YKKv/GcpdERET1FMMONUgKScKAdiEI1mthsUkIHv4WruZb5S6LiIjqIYYdarA0KgUe7RQGb5WAyhCEt37NgrGgSO6yiIionmHYoQbNU6PCvUFFKM65imRjMZ77fB8Ki9jDQ0RE1zHsUIPnpQLSV8+Cp1rCvvPXMGnVQRTxpoNERFSKYYdcQlHGecy41w8alQJbEtPw4n8ZeIiIqATDDrmMdo20+HhUDDRKBdYfTcWkVQdgKWbgISJydww75FIebBuEj8fEQKNSYOOxNAYeIiJi2CHX82CbICwbXRJ4Nh1PQxwDDxGRW2PYIZfUq00QPhnTFRqVApuPp2H8v/cjz1wsd1lERCQDhh1yWQ+0boTlY7vCQ63EjpMZePqTPcjMNctdFhER1TGGHXJp97VqhFXju8PPU43Dl4x4/KOdfHgoEZGbYdghl9cl3A/fTbwH4f6euJhVgMcX78SW42lyl0VERHVEJXcBRDUlMTHxlsvn3OeDf+wqxtEMC8b/ez+GRXljRDtvKBW3fmp6YGAgwsPDa7JUIiKqQww71OCZsjIAAKNGjbp9Y4US/n3Gw+euR/BtYi7+s3E3Mtf+A9acqxW+xcPTEycSExl4iIgaKIYdavAKck0AgEHP/w1tOsZU6j0X84pxIEsJXXgHNItbiY5+VjTzskG6qZMnLfkMvnx3OjIzMxl2iIgaKIYdchkBYRFo0qpdpdo2AdA234JNx9KQairEgSwVMuGJPm2DoPdQ126hRERUpzhAmdyWn6cGT3ZtgvtaBkKpkJCclY//7L2APy5mw2YTcpdHREQ1hD075NYUkoS7IvwQ2cgLW46n4YqxENtPZuCPS9m4t1Ug1Mw8REQNHnt2iFDSy/NETBP0atMIOrUC1/KL8PMfKfg1XQVNcAu5yyMiojvAsENUSpIkdGrii3H3NENMhB+UCgkZZgVCx/0TC3Zew+FL2XKXSERE1cCwQ3QTrUqJe1sGYkyPCDT1tAIA9lwuxKP/2olRn+7FrjOZEILnt4iIGgqGHaIK6D3U6BZoxZXlf8EDER5QKiT8djoTf/pkLx5bvBNf/Z7Mh4sSETUAHKBMdBtFmcnop0/B0wNb4YcTeYg/l4/Dl4w4fOkIZv90FPeF69C3uSda+qkh3XyjnlvgnZmJiOoGww7RLZR3d2aFpwHe7fvAu1N/wL8xNp8twOazBSi6egn5STuRf+Z3WFJOAcJ2y3XzzsxERHWDYYfoFm51d2YhgExzEc7lKnA5XwF1QBMY7hkBwz0joJYEAnUCfhob/DQC3moBTyVgfwyX/c7Mv/76K6KiogAAVptAfpFAjsUGY6ENRrMNRrMVJnPJ61yLDcUCsNkAmxCwCkCpALzUCniqJXiqFfBSS/DRKtC0kR+iIpvA31uDAC8NdGplnR43IqL6hGGHqBIqujtzUwBdAFiKbTiXmYfTGbm4mJUPc7ENKQUSUgquD4uTJECnUkKnVqBY0QIhYxdhevw1KH77AwqdFxRarxqs2AjgvOOVl0ZZGny0CPDSwN9LgwBvLfQeKnhrVfDSqOClLf1eq4SPruS1V+my2z0slYioPmPYIaoBGpUCbUJ80CbEBzYhkG4y44qxAGmmQmTmWGAsLILVJlBQZEVBkRWABtqQluWuSyUJaJWAVuH8VaMQUEiAhJLgJAGwCaDYBhQJCUU2oMgG5OQXID0tDQGNI1FgU6DYBuRZrMjLKsDFrIJq7Z9WKcFDLcFDJcFbp4afjye8tSoE+WgRavBAmK8OjX09EOrrgVCDjj1JRFSvMOwQ1TCFJCHEoEOIQeeYJ4RAnrkk6BQWWZF0cDe2rl6OvqNeRHTHztCqFNCqFNCoFFAp7uwiyeN7t+PTd6cgpfS1pPGE0ssXSk89FB4GKL18ofDQQ+lpgELnBUnjCYXGA5LGA4rSqeR7T0jKkl8RZquA2SqQDQC5ViCz8JY1GLQKBHkpEeKtRLCXCsHe17/391BAUc5Abg7YJqLawrBDVAckSYK3TgVvXcn/cunIQ+HZBPgrzQjR627z7qqpzlPgyyOEDTZYSnuOgGKbhOQzJ/Dbum9LQ5EnlN7+UOobQVU6KX0aQaHRlY43suFUVlHZ9RZbUGxMQ1F2KoqzU1GcnYLi7FQoC41I2L4BrVs0q3bNRETlcZmws3jxYvz9739HamoqOnXqhA8//BDdunWTuywi2VTlKfCVZU49jcKzCRUGKSGAIpsF+VYJecVAbrGEvBum/GIAKg3UAU2hDmha5v39PjmGRj6nEe7viQh/TzT19yz5PsATob4eCPTWQKviKTIiqhqXCDtff/01pk2bhqVLl6J79+5YtGgR+vfvj6SkJAQFBcldHpHLqW6QstkEcszFMBYUwVRQhOzSrxnZJlw15UOp80ZGjhkZOWYkXLhW7jp8dCo08tEi0FuLRt5aBHproPdQw1OjgrdWCU9NySBr+1etSgnNDacJNUoFtGolNEoF1EqpSvdGIqKGySXCzsKFCzF+/Hj8+c9/BgAsXboU//vf//DZZ5/htddek7k6IrJTKCQYPNQweKid5l86lYWFbz2FTz7/EoawFkjNK0ZarhVpecVIzbUiNdeKa4VWFNuAnMJi5BQW42xG3h3XIwFQKwGVQoJaIUGtlKBWoPSrBLUSzvMd35cs8/PxQnCAH3RqJXQaJTzUpZNGUXLl3Q3zdPavmpLAdbuQlZycjMzMTAAlY76KbYCldOyUuVg4xlFZSl/bl1mKr8+3iZLbHSgkCQoJUEqAj483AgP8S0OfAlqV0hEE7d/fOF9byXFkAtcfoXLz01RufrjKjY9bKe/BK0pJgkIhQamQoFJIUEgl3yskMJxStTT4sGOxWJCQkIAZM2Y45ikUCvTt2xe7d++WsTIiqiz7zRvHjx15y3YKrRcUXn5QevmVDLr28oXS0xeS1hMKja5ksLVaB0mjKxlgrdZBUqkhKTWQlKrS768HLQHAYi0JEeX/2b2dfAAZVX6XQgI0Sql0uj7fngGsVhuuXs0EJCUktbZkUtTU6bscwDF8veEpCW8lAVWlKPmqvPl16VeVVDJPqbj+Va0oCVP21z5eHvD3NUCtlKBSKKBUSLg5TpWXryobusp9b5ktlBAQZYOiuD5PADd8L0qX3/DJLV14u3ZOy25YNwAYjSbkFxTAVhqwi20CVhtgFQJFtpL7gVlL5xeLkteOdqJ0vs0+//o8qwC2vtwLEQE1eYuNymvwYSczMxNWqxXBwcFO84ODg3HixIly32M2m2E2mx2vjUYjAMBkMtVobbm5uQCAS6eOwVyQX6PrTks+AwBIPX8SZ7w86/16a3PdrLnhr/v88YMAgLsHjkCTyFZ3uLai0ikHAJB88ggStvzoWHdJrJFggwI2SI7vhSSVvlaUzitdJpXMu7GtDRJyTNlIuXAGkkoLKNWQ1Foo1BpIKi0kpRaSWlMyT6WFpNI4BRYbgGKURKWKSJrrx1cUmZ3+oClggxK2kmqEDYrSCh2TsO+FKP0vAEgwmwuQdvEcYrreDQ8vbxTZBIqsKP1a0htUXHoLA/u84lvfCLzO2cux1OhaL9bo2qh8iSeS4Neh/FtuVJf97/ZtH84sGrjLly8LAGLXrl1O86dPny66detW7ntmzZpl/2ccJ06cOHHixKmBTxcvXrxlVmjwPTuBgYFQKpVIS0tzmp+WloaQkJBy3zNjxgxMmzbN8dpmsyErKwsBAQE1ej7YZDKhadOmuHjxIvR6fY2t1xXw2JSPx6ViPDbl43EpH49LxVzp2AghkJOTg7CwsFu2a/BhR6PRICYmBvHx8RgyZAiAkvASHx+PSZMmlfserVYLrVbrNM/X17fWatTr9Q3+A1VbeGzKx+NSMR6b8vG4lI/HpWKucmwMBsNt2zT4sAMA06ZNw9ixY9G1a1d069YNixYtQl5enuPqLCIiInJfLhF2RowYgYyMDMycOROpqano3LkzNmzYUGbQMhEREbkflwg7ADBp0qQKT1vJRavVYtasWWVOmRGPTUV4XCrGY1M+Hpfy8bhUzB2PjSTE7a7XIiIiImq47uzxykRERET1HMMOERERuTSGHSIiInJpDDtERETk0hh2atHixYvRrFkz6HQ6dO/eHb///rvcJdWpX375BYMHD0ZYWBgkScIPP/zgtFwIgZkzZyI0NBQeHh7o27cvTp06JU+xdWjevHm4++674ePjg6CgIAwZMgRJSUlObQoLCxEXF4eAgAB4e3tj2LBhZe4S7oqWLFmCjh07Om52Fhsbi/Xr1zuWu+txudn8+fMhSRKmTp3qmOeux2b27NmQJMlpatu2rWO5ux4XALh8+TJGjRqFgIAAeHh4oEOHDti/f79juTv9DmbYqSVff/01pk2bhlmzZuHAgQPo1KkT+vfvj/T0dLlLqzN5eXno1KkTFi9eXO7yBQsW4IMPPsDSpUuxd+9eeHl5oX///igsLKzjSuvWjh07EBcXhz179mDz5s0oKipCv379kJeX52jz0ksv4eeff8bq1auxY8cOXLlyBUOHDpWx6rrRpEkTzJ8/HwkJCdi/fz969+6Nxx57DMeOHQPgvsflRvv27cPHH3+Mjh07Os1352PTrl07pKSkOKbffvvNscxdj8u1a9fQs2dPqNVqrF+/HsePH8d7770HPz8/Rxu3+h1cEw/jpLK6desm4uLiHK+tVqsICwsT8+bNk7Eq+QAQa9ascby22WwiJCRE/P3vf3fMy87OFlqtVvz3v/+VoUL5pKenCwBix44dQoiS46BWq8Xq1asdbRITEwUAsXv3brnKlI2fn5/49NNPeVyEEDk5OaJVq1Zi8+bN4oEHHhBTpkwRQrj3Z2bWrFmiU6dO5S5z5+Py6quvinvvvbfC5e72O5g9O7XAYrEgISEBffv2dcxTKBTo27cvdu/eLWNl9ce5c+eQmprqdIwMBgO6d+/udsfIaDQCAPz9/QEACQkJKCoqcjo2bdu2RXh4uFsdG6vViq+++gp5eXmIjY3lcQEQFxeHQYMGOR0DgJ+ZU6dOISwsDM2bN8fIkSORnJwMwL2Py08//YSuXbviySefRFBQELp06YJPPvnEsdzdfgcz7NSCzMxMWK3WMo+rCA4ORmpqqkxV1S/24+Dux8hms2Hq1Kno2bMn2rdvD6Dk2Gg0mjIPp3WXY3PkyBF4e3tDq9XihRdewJo1axAdHe32x+Wrr77CgQMHMG/evDLL3PnYdO/eHStXrsSGDRuwZMkSnDt3Dvfddx9ycnLc+ricPXsWS5YsQatWrbBx40ZMnDgRL774Ij7//HMA7vc72GUeF0HUEMXFxeHo0aNOYwzcXZs2bXDo0CEYjUZ8++23GDt2LHbs2CF3WbK6ePEipkyZgs2bN0On08ldTr0ycOBAx/cdO3ZE9+7dERERgW+++QYeHh4yViYvm82Grl27Yu7cuQCALl264OjRo1i6dCnGjh0rc3V1jz07tSAwMBBKpbLMiP+0tDSEhITIVFX9Yj8O7nyMJk2ahLVr12Lbtm1o0qSJY35ISAgsFguys7Od2rvLsdFoNGjZsiViYmIwb948dOrUCf/85z/d+rgkJCQgPT0dd911F1QqFVQqFXbs2IEPPvgAKpUKwcHBbntsbubr64vWrVvj9OnTbv2ZCQ0NRXR0tNO8qKgoxyk+d/sdzLBTCzQaDWJiYhAfH++YZ7PZEB8fj9jYWBkrqz8iIyMREhLidIxMJhP27t3r8sdICIFJkyZhzZo12Lp1KyIjI52Wx8TEQK1WOx2bpKQkJCcnu/yxKY/NZoPZbHbr49KnTx8cOXIEhw4dckxdu3bFyJEjHd+767G5WW5uLs6cOYPQ0FC3/sz07NmzzC0tTp48iYiICABu+DtY7hHSruqrr74SWq1WrFy5Uhw/flxMmDBB+Pr6itTUVLlLqzM5OTni4MGD4uDBgwKAWLhwoTh48KC4cOGCEEKI+fPnC19fX/Hjjz+Kw4cPi8cee0xERkaKgoICmSuvXRMnThQGg0Fs375dpKSkOKb8/HxHmxdeeEGEh4eLrVu3iv3794vY2FgRGxsrY9V147XXXhM7duwQ586dE4cPHxavvfaakCRJbNq0SQjhvselPDdejSWE+x6bl19+WWzfvl2cO3dO7Ny5U/Tt21cEBgaK9PR0IYT7Hpfff/9dqFQq8c4774hTp06JL7/8Unh6eor//Oc/jjbu9DuYYacWffjhhyI8PFxoNBrRrVs3sWfPHrlLqlPbtm0TAMpMY8eOFUKUXPr4xhtviODgYKHVakWfPn1EUlKSvEXXgfKOCQCxYsUKR5uCggLxl7/8Rfj5+QlPT0/x+OOPi5SUFPmKriPPPPOMiIiIEBqNRjRq1Ej06dPHEXSEcN/jUp6bw467HpsRI0aI0NBQodFoROPGjcWIESPE6dOnHcvd9bgIIcTPP/8s2rdvL7RarWjbtq1YtmyZ03J3+h0sCSGEPH1KRERERLWPY3aIiIjIpTHsEBERkUtj2CEiIiKXxrBDRERELo1hh4iIiFwaww4RERG5NIYdIiIicmkMO0Qkq169emHq1KmybX/cuHEYMmRIhfXk5+dj2LBh0Ov1kCQJ2dnZ5c4jovqLTz0nIrrB999/D7Va7Xj9+eef49dff8WuXbsQGBgIg8GApUuXlplHRPUXww4R0Q38/f2dXp85cwZRUVFo3779LecRUf3F01hEVG+YzWa88soraNy4Mby8vNC9e3ds377dsXzlypXw9fXFxo0bERUVBW9vbwwYMAApKSmVWr/VasW0adPg6+uLgIAA/PWvf8XNT8y58TRWr1698N577+GXX36BJEno1atXufOIqH5j2CGiemPSpEnYvXs3vvrqKxw+fBhPPvkkBgwYgFOnTjna5Ofn4x//+Ae++OIL/PLLL0hOTsYrr7xSqfW/9957WLlyJT777DP89ttvyMrKwpo1ayps//3332P8+PGIjY1FSkoKvv/++3LnEVH9xtNYRFQvJCcnY8WKFUhOTkZYWBgA4JVXXsGGDRuwYsUKzJ07FwBQVFSEpUuXokWLFgBKAtKcOXMqtY1FixZhxowZGDp0KABg6dKl2LhxY4Xt/f394enpCY1Gg5CQEMf88uYRUf3FsENE9cKRI0dgtVrRunVrp/lmsxkBAQGO156eno6gAwChoaFIT0+/7fqNRiNSUlLQvXt3xzyVSoWuXbuWOZVFRK6FYYeI6oXc3FwolUokJCRAqVQ6LfP29nZ8f+OVUgAgSRLDChHdEsfsEFG90KVLF1itVqSnp6Nly5ZOU02cLjIYDAgNDcXevXsd84qLi5GQkHDH6yai+o09O0RUL7Ru3RojR47EmDFj8N5776FLly7IyMhAfHw8OnbsiEGDBt3xNqZMmYL58+ejVatWaNu2LRYuXMgbAhK5AYYdIqo3VqxYgbfffhsvv/wyLl++jMDAQPTo0QOPPPJIjaz/5ZdfRkpKCsaOHQuFQoFnnnkGjz/+OIxGY42sn4jqJ0nwZDcRERG5MI7ZISIiIpfGsENELsPb27vC6ddff5W7PCKSCU9jEZHLOH36dIXLGjduDA8PjzqshojqC4YdIiIicmk8jUVEREQujWGHiIiIXBrDDhEREbk0hh0iIiJyaQw7RERE5NIYdoiIiMilMewQERGRS2PYISIiIpf2/0qdeFWjn9sJAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(test[\"len_diff\"], kde=True, bins=20)\n", + "plt.title(\"test sentence length diff Distribution\")\n", + "plt.xlabel(\"len_diff\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 서브플롯 생성\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# 첫 번째 서브플롯: s1_len\n", + "sns.histplot(dev[\"s1_len\"], kde=True, bins=50, color=\"blue\", ax=axes[0])\n", + "axes[0].set_title(\"dev s1 len Distribution\")\n", + "axes[0].set_xlabel(\"Sentence Length\")\n", + "axes[0].set_ylabel(\"Count\")\n", + "\n", + "# 두 번째 서브플롯: s2_len\n", + "sns.histplot(dev[\"s2_len\"], kde=True, bins=50, color=\"orange\", ax=axes[1])\n", + "axes[1].set_title(\"dev s2 len Distribution\")\n", + "axes[1].set_xlabel(\"Sentence Length\")\n", + "axes[1].set_ylabel(\"Count\")\n", + "\n", + "# 레이아웃 조정\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(dev[\"len_diff\"], kde=True, bins=20)\n", + "plt.title(\"dev sentence length diff Distribution\")\n", + "plt.xlabel(\"len_diff\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 서브플롯 생성\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# 첫 번째 서브플롯: s1_len\n", + "sns.histplot(train[\"s1_len\"], kde=True, bins=50, color=\"blue\", ax=axes[0])\n", + "axes[0].set_title(\"train s1 len Distribution\")\n", + "axes[0].set_xlabel(\"Sentence Length\")\n", + "axes[0].set_ylabel(\"Count\")\n", + "\n", + "# 두 번째 서브플롯: s2_len\n", + "sns.histplot(train[\"s2_len\"], kde=True, bins=50, color=\"orange\", ax=axes[1])\n", + "axes[1].set_title(\"train s2 len Distribution\")\n", + "axes[1].set_xlabel(\"Sentence Length\")\n", + "axes[1].set_ylabel(\"Count\")\n", + "\n", + "# 레이아웃 조정\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(train[\"len_diff\"], kde=True, bins=20)\n", + "plt.title(\"train sentence length diff Distribution\")\n", + "plt.xlabel(\"len_diff\")\n", + "plt.ylabel(\"Count\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_col1_col2_scatter(df, col1, col2, title=\"\"):\n", + " # Scatter plot 그리기\n", + " plt.figure(figsize=(6, 6))\n", + " plt.scatter(df[col1], df[col2], color=\"blue\")\n", + "\n", + " # 그래프에 제목과 축 레이블 추가\n", + " plt.title(f\"{title} {col1} vs {col2}\", fontsize=16)\n", + " plt.xlabel(f\"{col1}\", fontsize=12)\n", + " plt.ylabel(f\"{col2}\", fontsize=12)\n", + "\n", + " # 그래프 출력\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_col1_col2_scatter(dev,\"len_diff\", \"label\",\"dev\")\n", + "plot_col1_col2_scatter(train, \"len_diff\", \"label\",\"train\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 텍스트 BLEU Score\n", + "BLEU Score에 대한 개념과 구현은 다음 링크를 참고하세요. \n", + "- 개념: https://supkoon.tistory.com/18 \n", + "- 개념 및 구현: https://wikidocs.net/31695 " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from nltk.translate import bleu_score as bleu\n", + "chencherry = bleu.SmoothingFunction()\n", + "\n", + "# train 데이터에 대한 BLEU 점수 계산\n", + "train[\"bleu\"] = train.apply(\n", + " lambda row: max(bleu.sentence_bleu(\n", + " [row[\"sentence_1\"].split()],\n", + " row[\"sentence_2\"].split(),\n", + " weights=(0.25, 0.25, 0.25, 0.25),\n", + " smoothing_function=chencherry.method0,\n", + " ), bleu.sentence_bleu(\n", + " [row[\"sentence_2\"].split()],\n", + " row[\"sentence_1\"].split(),\n", + " weights=(0.25, 0.25, 0.25, 0.25),\n", + " smoothing_function=chencherry.method0,\n", + " )),\n", + " axis=1,\n", + ")\n", + "\n", + "# dev 데이터에 대한 BLEU 점수 계산\n", + "dev[\"bleu\"] = dev.apply(\n", + " lambda row: max(bleu.sentence_bleu(\n", + " [row[\"sentence_1\"].split()],\n", + " row[\"sentence_2\"].split(),\n", + " weights=(0.25, 0.25, 0.25, 0.25),\n", + " smoothing_function=chencherry.method0,\n", + " ), bleu.sentence_bleu(\n", + " [row[\"sentence_2\"].split()],\n", + " row[\"sentence_1\"].split(),\n", + " weights=(0.25, 0.25, 0.25, 0.25),\n", + " smoothing_function=chencherry.method0,\n", + " )),\n", + " axis=1,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5065 368\n" + ] + } + ], + "source": [ + "print(len(train[train[\"bleu\"]!=0]), len(dev[dev[\"bleu\"]!=0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_col1_col2_scatter(dev, \"bleu\", \"label\", \"dev\")\n", + "plot_col1_col2_scatter(train, \"bleu\", \"label\",\"train\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TF-IDF & Cosine Similarity" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.feature_extraction.text import TfidfVectorizer\n", + "from sklearn.metrics.pairwise import cosine_similarity\n", + "\n", + "def get_cos_sim(df):\n", + " # TF-IDF 벡터화\n", + " tfidf_vectorizer = TfidfVectorizer()\n", + "\n", + " # 문장 두 개를 결합하여 처리\n", + " combined_sentences = df[\"sentence_1\"].tolist() + df[\"sentence_2\"].tolist()\n", + "\n", + " # TF-IDF 매트릭스 생성\n", + " tfidf_matrix = tfidf_vectorizer.fit_transform(combined_sentences)\n", + "\n", + " # 문장1과 문장2의 코사인 유사도 계산\n", + " # 첫 n개의 벡터는 sentence1, n부터는 sentence2에 해당\n", + " cos_similarities = []\n", + " n = len(df)\n", + " for i in range(n):\n", + " cos_sim = cosine_similarity(tfidf_matrix[i], tfidf_matrix[i + n])[0][0]\n", + " cos_similarities.append(cos_sim)\n", + "\n", + " # 코사인 유사도 컬럼 추가\n", + " df[\"cosine_similarity\"] = cos_similarities\n", + "\n", + " return tfidf_matrix\n", + "\n", + "tfidf_matrix_train = get_cos_sim(train)\n", + "tfidf_matrix_dev = get_cos_sim(dev)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_col1_col2_scatter(dev, \"cosine_similarity\", \"label\",\"dev\")\n", + "plot_col1_col2_scatter(train, \"cosine_similarity\", \"label\", \"train\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 텍스트 내용 분석" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "스릴도있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요~ / 반전도 있고,사랑도 있고재미도있네요.\n", + "앗 제가 접근권한이 없다고 뜹니다;; / 오, 액세스 권한이 없다고 합니다.\n", + "주택청약조건 변경해주세요. / 주택청약 무주택기준 변경해주세요.\n", + "입사후 처음 대면으로 만나 반가웠습니다. / 화상으로만 보다가 리얼로 만나니 정말 반가웠습니다.\n", + "뿌듯뿌듯 하네요!! / 꼬옥 실제로 한번 뵈어요 뿌뿌뿌~!~!\n", + "오마이가뜨지져스크롸이스트휏 / 오 마이 갓 지저스 스크론 이스트 팬\n", + "전 암만 찍어도 까만 하늘.. ㅠㅠ / 암만 찍어도 하늘은 까맣다.. ㅠㅠ\n", + "이렇게 귀여운 쥐들은 처음이네요.ㅎㅎㅎ / 이렇게 지겨운 공포영화는 처음..\n", + "미세먼지 해결이 가장 시급한 문제입니다! / 가장 시급한 것이 신생아실 관리입니다!!!\n", + "크림하우스 환불조치해주세요. / 크림하우스 환불조치할 수 있도록해주세여\n", + "\n", + "액션은개뿔 총몇번쏘고 끝입니다 / 액션은 흉내만 내고 그마저도 후반부에는 슬로우모션 처리\n", + "감격스러워 입막으심? / 너무 감동해서 입 다물어?\n", + "이번 년도에 본 영화 중 가장 최악의 영화...... / 올해 본 영화 중 최악...\n", + "특히 평소 뮤직채널에 많은 영감을 불어넣어주시는! / 특히, 당신은 항상 많은 음악 채널에 영감을 줍니다!\n", + "다음 밥스테이지가 기대됩니다~ ㅎ / 다음 후기도 기대됩니다~~\n", + "사진 간지.. ㅋㅋ 축하드립니다 / 사진이 나왔어요..ㅋㅋㅋ 축하드립니다.\n", + "영화보면서 기분전환이 되었어요 / 영화 보는 내내 뭔가 모를 편안함을 느꼈어요\n", + "건강하게 자라기를!! / 얼른 건강 회복하기를요!!!\n", + "고수님들의 많은 가르침 부탁드립니다 / 고수님들의 많은 지도 부탁드립니다 \n", + "러닝화 신었더니 뒤꿈치가 푹신해서 자꾸 앞으로 힘이 쏠리고 뒤꿈치 들리네요 / 런닝화를 신고 발 뒤꿈치가 부드러워서 계속 힘을 빼고 발뒤꿈치를 들어 올렸다.\n", + "\n" + ] + } + ], + "source": [ + "def print_text(df,n):\n", + " for i in range(n):\n", + " print(df[\"sentence_1\"][i], \"/\", df[\"sentence_2\"][i])\n", + " print()\n", + "\n", + "print_text(train, 10)\n", + "print_text(dev, 10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 텍스트 전처리\n", + "- 텍스트 전처리에는 다음과 같은 방법들을 적용할 수 있습니다. \n", + "- 특수 문자 제거 \n", + "- 초성 대체 혹은 제거 \n", + "- 띄어쓰기 교정 \n", + "- 맞춤법 교정 \n", + "- `` 토큰 대체 혹은 special token으로 사용 " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# 초성(ㄱ-ㅎ), 중성(ㅏ-ㅣ), 완성된 한글(가-힣), 알파벳(A-Za-z), 숫자(0-9), 그리고 공백(\\s)만 허용\n", + "def replace_special_letters(df):\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].str.replace(\n", + " r\"[^A-Za-z0-9가-힣ㄱ-ㅎㅏ-ㅣ\\s]\", \"\", regex=True\n", + " )\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(\n", + " r\"[^A-Za-z0-9가-힣ㄱ-ㅎㅏ-ㅣ\\s]\", \"\", regex=True\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: './data/raw/train.csv'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[27], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m train_v2 \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m./data/raw/train.csv\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mUTF-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m dev_v2 \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mread_csv(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./data/raw/dev.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m, encoding\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUTF-8\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 4\u001b[0m replace_special_letters(train_v2)\n", + "File \u001b[0;32m~/miniconda/envs/ame/lib/python3.11/site-packages/pandas/io/parsers/readers.py:1026\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 1013\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 1014\u001b[0m dialect,\n\u001b[1;32m 1015\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1022\u001b[0m dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[1;32m 1023\u001b[0m )\n\u001b[1;32m 1024\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda/envs/ame/lib/python3.11/site-packages/pandas/io/parsers/readers.py:620\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 617\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m 619\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 620\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n", + "File \u001b[0;32m~/miniconda/envs/ame/lib/python3.11/site-packages/pandas/io/parsers/readers.py:1620\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1617\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1619\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1620\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniconda/envs/ame/lib/python3.11/site-packages/pandas/io/parsers/readers.py:1880\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1878\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[1;32m 1879\u001b[0m mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1880\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1881\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1882\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1883\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1884\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1885\u001b[0m \u001b[43m \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1886\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1887\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1888\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1889\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1890\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1891\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n", + "File \u001b[0;32m~/miniconda/envs/ame/lib/python3.11/site-packages/pandas/io/common.py:873\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 868\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 869\u001b[0m \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 870\u001b[0m \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 871\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m 872\u001b[0m \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 873\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 874\u001b[0m \u001b[43m \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 875\u001b[0m \u001b[43m \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 876\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 877\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 878\u001b[0m \u001b[43m \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 881\u001b[0m \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m 882\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: './data/raw/train.csv'" + ] + } + ], + "source": [ + "train_v2 = pd.read_csv(\"./data/raw/train.csv\", encoding=\"UTF-8\")\n", + "dev_v2 = pd.read_csv(\"./data/raw/dev.csv\", encoding=\"UTF-8\")\n", + "\n", + "replace_special_letters(train_v2)\n", + "replace_special_letters(dev_v2)\n", + "\n", + "print_text(train_v2, 5)\n", + "print_text(dev_v2, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "# 초성 대체\n", + "def replace_consonant(df):\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].str.replace(r\"[ㅋ]+\", \"웃음\", regex=True)\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(r\"[ㅋ]+\", \"웃음\", regex=True)\n", + " df[\"sentence_1\"] = df[\"sentence_2\"].str.replace(r\"[ㅎ]+\", \"웃음\", regex=True)\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(r\"[ㅎ]+\", \"웃음\", regex=True)\n", + "\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].str.replace(r\"[ㅜ]+\", \"슬픔\", regex=True)\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(r\"[ㅜ]+\", \"슬픔\", regex=True)\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].str.replace(r\"[ㅠ]+\", \"슬픔\", regex=True)\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].str.replace(r\"[ㅠ]+\", \"슬픔\", regex=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "반전도 있고사랑도 있고재미도있네요 / 반전도 있고사랑도 있고재미도있네요\n", + "오 액세스 권한이 없다고 합니다 / 오 액세스 권한이 없다고 합니다\n", + "주택청약 무주택기준 변경해주세요 / 주택청약 무주택기준 변경해주세요\n", + "화상으로만 보다가 리얼로 만나니 정말 반가웠습니다 / 화상으로만 보다가 리얼로 만나니 정말 반가웠습니다\n", + "꼬옥 실제로 한번 뵈어요 뿌뿌뿌 / 꼬옥 실제로 한번 뵈어요 뿌뿌뿌\n", + "오 마이 갓 지저스 스크론 이스트 팬 / 오 마이 갓 지저스 스크론 이스트 팬\n", + "암만 찍어도 하늘은 까맣다 슬픔 / 암만 찍어도 하늘은 까맣다 슬픔\n", + "이렇게 지겨운 공포영화는 처음 / 이렇게 지겨운 공포영화는 처음\n", + "가장 시급한 것이 신생아실 관리입니다 / 가장 시급한 것이 신생아실 관리입니다\n", + "크림하우스 환불조치할 수 있도록해주세여 / 크림하우스 환불조치할 수 있도록해주세여\n", + "\n", + "액션은 흉내만 내고 그마저도 후반부에는 슬로우모션 처리 / 액션은 흉내만 내고 그마저도 후반부에는 슬로우모션 처리\n", + "너무 감동해서 입 다물어 / 너무 감동해서 입 다물어\n", + "올해 본 영화 중 최악 / 올해 본 영화 중 최악\n", + "특히 당신은 항상 많은 음악 채널에 영감을 줍니다 / 특히 당신은 항상 많은 음악 채널에 영감을 줍니다\n", + "다음 후기도 기대됩니다 / 다음 후기도 기대됩니다\n", + "사진이 나왔어요웃음 축하드립니다 / 사진이 나왔어요웃음 축하드립니다\n", + "영화 보는 내내 뭔가 모를 편안함을 느꼈어요 / 영화 보는 내내 뭔가 모를 편안함을 느꼈어요\n", + "얼른 건강 회복하기를요 / 얼른 건강 회복하기를요\n", + "고수님들의 많은 지도 부탁드립니다 PERSON / 고수님들의 많은 지도 부탁드립니다 PERSON\n", + "런닝화를 신고 발 뒤꿈치가 부드러워서 계속 힘을 빼고 발뒤꿈치를 들어 올렸다 / 런닝화를 신고 발 뒤꿈치가 부드러워서 계속 힘을 빼고 발뒤꿈치를 들어 올렸다\n", + "\n" + ] + } + ], + "source": [ + "replace_consonant(train_v2)\n", + "replace_consonant(dev_v2)\n", + "\n", + "print_text(train_v2, 5)\n", + "print_text(dev_v2, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "# 띄어쓰기 교정\n", + "# !pip install git+https://github.com/haven-jeon/PyKoSpacing.git\n", + "import pykospacing\n", + "spacing = pykospacing.Spacing() \n", + "\n", + "def spacing_text(df):\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].map(spacing)\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].map(spacing)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "앗 제가 접근 권한이 없다고 뜹니다 / 오 액 세스 권한이 없다고 합니다\n", + "주택청약 조건 변경해주세요 / 주택청약 무주택기준 변경해주세요\n", + "입사 후 처음 대면으로 만나 반가웠습니다 / 화상으로만 보다 가 리얼로 만나니 정말 반가웠습니다\n", + "뿌듯 뿌듯 하네요 / 꼬옥 실제로 한 번 뵈어요 뿌뿌뿌\n", + "\n", + "액션은 개뿔 총 몇 번 쏘고 끝입니다 / 액션은 흉내만 내 고 그마저도 후반부에는 슬로우 모션 처리\n", + "감격스러워 입막으심 / 너무 감동해서 입 다 물어\n", + "이번 년도에 본 영화 중 가장 최악의 영화 / 올해 본 영화 중 최악\n", + "특히 평소 뮤직 채널에 많은 영감을 불어 넣어주시는 / 특히 당신은 항상 많은 음악 채널에 영감을 줍니다\n", + "다음 밥 스테이지가 기대됩니다 ㅎ / 다음 후기도 기대됩니다\n", + "\n" + ] + } + ], + "source": [ + "spacing_text(train_v2)\n", + "spacing_text(dev_v2)\n", + "\n", + "print_text(train_v2, 5)\n", + "print_text(dev_v2, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# 불용어 제거\n", + "from nltk.tokenize import word_tokenize \n", + "\n", + "def remove_stop_word(df):\n", + " def _do(target):\n", + " stop_words = \"아 휴 아이구 아이쿠 아이고 어\"\n", + " stop_words = stop_words.split(\" \")\n", + " word_tokens = word_tokenize(target)\n", + " result = [word for word in word_tokens if not word in stop_words]\n", + " return \" \".join(result)\n", + " df[\"sentence_1\"] = df[\"sentence_1\"].apply(_do)\n", + " df[\"sentence_2\"] = df[\"sentence_2\"].apply(_do)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "스릴도있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요~ / 반전도 있고 , 사랑도 있고재미도있네요 .\n", + "앗 제가 접근권한이 없다고 뜹니다 ; ; / 오 , 액세스 권한이 없다고 합니다 .\n", + "주택청약조건 변경해주세요 . / 주택청약 무주택기준 변경해주세요 .\n", + "입사후 처음 대면으로 만나 반가웠습니다 . / 화상으로만 보다가 리얼로 만나니 정말 반가웠습니다 .\n", + "뿌듯뿌듯 하네요 ! ! / 꼬옥 실제로 한번 뵈어요 뿌뿌뿌~ ! ~ !\n", + "\n", + "액션은개뿔 총몇번쏘고 끝입니다 / 액션은 흉내만 내고 그마저도 후반부에는 슬로우모션 처리\n", + "감격스러워 입막으심 ? / 너무 감동해서 입 다물어 ?\n", + "이번 년도에 본 영화 중 가장 최악의 영화 ...... / 올해 본 영화 중 최악 ...\n", + "특히 평소 뮤직채널에 많은 영감을 불어넣어주시는 ! / 특히 , 당신은 항상 많은 음악 채널에 영감을 줍니다 !\n", + "다음 밥스테이지가 기대됩니다~ ㅎ / 다음 후기도 기대됩니다~~\n", + "\n" + ] + } + ], + "source": [ + "remove_stop_word(train_v2)\n", + "remove_stop_word(dev_v2)\n", + "\n", + "print_text(train_v2, 5)\n", + "print_text(dev_v2, 5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 데이터 증강 (EDA, Easy Data Augmentation)\n", + "- 개념 내용은 https://stages.ai/en/competitions/327/board/community/post/2783 참고하세요. \n", + "- 코드는 https://github.com/catSirup/KorEDA 에서 가져왔습니다. " + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "import pickle\n", + "import re\n", + "\n", + "wordnet = {}\n", + "with open(\"./data/wordnet.pickle\", \"rb\") as f:\n", + " wordnet = pickle.load(f)\n", + "\n", + "\n", + "# 한글만 남기고 나머지는 삭제\n", + "def get_only_hangul(line):\n", + " parseText = re.compile(\"/ ^[ㄱ-ㅎㅏ-ㅣ가-힣]*$/\").sub(\"\", line)\n", + "\n", + " return parseText\n", + "\n", + "\n", + "########################################################################\n", + "# Synonym replacement\n", + "# Replace n words in the sentence with synonyms from wordnet\n", + "########################################################################\n", + "def synonym_replacement(words, n):\n", + " new_words = words.copy()\n", + " random_word_list = list(set([word for word in words]))\n", + " random.shuffle(random_word_list)\n", + " num_replaced = 0\n", + " for random_word in random_word_list:\n", + " synonyms = get_synonyms(random_word)\n", + " if len(synonyms) >= 1:\n", + " synonym = random.choice(list(synonyms))\n", + " new_words = [synonym if word == random_word else word for word in new_words]\n", + " num_replaced += 1\n", + " if num_replaced >= n:\n", + " break\n", + "\n", + " if len(new_words) != 0:\n", + " sentence = \" \".join(new_words)\n", + " new_words = sentence.split(\" \")\n", + "\n", + " else:\n", + " new_words = \"\"\n", + "\n", + " return new_words\n", + "\n", + "\n", + "def get_synonyms(word):\n", + " synomyms = []\n", + "\n", + " try:\n", + " for syn in wordnet[word]:\n", + " for s in syn:\n", + " synomyms.append(s)\n", + " except:\n", + " pass\n", + "\n", + " return synomyms\n", + "\n", + "\n", + "########################################################################\n", + "# Random deletion\n", + "# Randomly delete words from the sentence with probability p\n", + "########################################################################\n", + "def random_deletion(words, p):\n", + " if len(words) == 1:\n", + " return words\n", + "\n", + " new_words = []\n", + " for word in words:\n", + " r = random.uniform(0, 1)\n", + " if r > p:\n", + " new_words.append(word)\n", + "\n", + " if len(new_words) == 0:\n", + " rand_int = random.randint(0, len(words) - 1)\n", + " return [words[rand_int]]\n", + "\n", + " return new_words\n", + "\n", + "\n", + "########################################################################\n", + "# Random swap\n", + "# Randomly swap two words in the sentence n times\n", + "########################################################################\n", + "def random_swap(words, n):\n", + " new_words = words.copy()\n", + " for _ in range(n):\n", + " new_words = swap_word(new_words)\n", + "\n", + " return new_words\n", + "\n", + "\n", + "def swap_word(new_words):\n", + " random_idx_1 = random.randint(0, len(new_words) - 1)\n", + " random_idx_2 = random_idx_1\n", + " counter = 0\n", + "\n", + " while random_idx_2 == random_idx_1:\n", + " random_idx_2 = random.randint(0, len(new_words) - 1)\n", + " counter += 1\n", + " if counter > 3:\n", + " return new_words\n", + "\n", + " new_words[random_idx_1], new_words[random_idx_2] = (\n", + " new_words[random_idx_2],\n", + " new_words[random_idx_1],\n", + " )\n", + " return new_words\n", + "\n", + "\n", + "########################################################################\n", + "# Random insertion\n", + "# Randomly insert n words into the sentence\n", + "########################################################################\n", + "def random_insertion(words, n):\n", + " new_words = words.copy()\n", + " for _ in range(n):\n", + " add_word(new_words)\n", + "\n", + " return new_words\n", + "\n", + "\n", + "def add_word(new_words):\n", + " synonyms = []\n", + " counter = 0\n", + " while len(synonyms) < 1:\n", + " if len(new_words) >= 1:\n", + " random_word = new_words[random.randint(0, len(new_words) - 1)]\n", + " synonyms = get_synonyms(random_word)\n", + " counter += 1\n", + " else:\n", + " random_word = \"\"\n", + "\n", + " if counter >= 10:\n", + " return\n", + "\n", + " random_synonym = synonyms[0]\n", + " random_idx = random.randint(0, len(new_words) - 1)\n", + " new_words.insert(random_idx, random_synonym)\n", + "\n", + "\n", + "def EDA(sentence, alpha_sr=0.1, alpha_ri=0.1, alpha_rs=0.1, num_aug=9):\n", + " sentence = get_only_hangul(sentence)\n", + " words = sentence.split(\" \")\n", + " words = [word for word in words if word != \"\"]\n", + " num_words = len(words)\n", + "\n", + " augmented_sentences = []\n", + " num_new_per_technique = int(num_aug / 3) + 1 # 3가지 증강 기법에 맞춰서 수정\n", + "\n", + " n_sr = max(1, int(alpha_sr * num_words))\n", + " n_ri = max(1, int(alpha_ri * num_words))\n", + " n_rs = max(1, int(alpha_rs * num_words))\n", + "\n", + " # sr: Synonym replacement\n", + " for _ in range(num_new_per_technique):\n", + " a_words = synonym_replacement(words, n_sr)\n", + " augmented_sentences.append(\" \".join(a_words))\n", + "\n", + " # ri: Random insertion\n", + " for _ in range(num_new_per_technique):\n", + " a_words = random_insertion(words, n_ri)\n", + " augmented_sentences.append(\" \".join(a_words))\n", + "\n", + " # rs: Random swap\n", + " for _ in range(num_new_per_technique):\n", + " a_words = random_swap(words, n_rs)\n", + " augmented_sentences.append(\" \".join(a_words))\n", + "\n", + " # Hangul cleanup and shuffle\n", + " augmented_sentences = [\n", + " get_only_hangul(sentence) for sentence in augmented_sentences\n", + " ]\n", + " random.shuffle(augmented_sentences)\n", + "\n", + " # Limit the number of augmentations to num_aug\n", + " if num_aug >= 1:\n", + " augmented_sentences = augmented_sentences[:num_aug]\n", + " else:\n", + " keep_prob = num_aug / len(augmented_sentences)\n", + " augmented_sentences = [\n", + " s for s in augmented_sentences if random.uniform(0, 1) < keep_prob\n", + " ]\n", + "\n", + " # Original sentence 포함\n", + " augmented_sentences.append(sentence)\n", + "\n", + " return augmented_sentences" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "# EDA 적용 함수\n", + "def apply_eda(df, num_aug=2):\n", + " def conditional_EDA(row, column_name):\n", + " if row[\"label\"] >= 1: \n", + " return EDA(row[column_name], num_aug=num_aug)\n", + " else:\n", + " return [row[column_name]]\n", + "\n", + " df[\"sentence_1\"] = df.apply(lambda row: conditional_EDA(row, \"sentence_1\"), axis=1)\n", + " df = df.explode(\"sentence_1\").reset_index(drop=True)\n", + " \n", + " df[\"sentence_2\"] = df.apply(lambda row: conditional_EDA(row, \"sentence_2\"), axis=1)\n", + " df = df.explode(\"sentence_2\").reset_index(drop=True)\n", + "\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "train_v3 = pd.read_csv(\"./data/raw/train.csv\", encoding=\"UTF-8\")\n", + "train_v3 = apply_eda(train_v3)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 사랑도 있고 반전도 있고 재미도 있네요\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있네요 사랑도 있고 재미도 있고\n", + "스릴도 있고 반전도 있고 여느 한국영화 쓰레기들하고는 차원이 다르네요 / 반전도 있고 사랑도 있고 재미도 있네요\n", + "앗 접 제가 접근 권한이 없다고 뜹니다 / 오 액 세스 권한이 없다고 합니다\n", + "\n", + "54228\n" + ] + } + ], + "source": [ + "print_text(train_v3, 10)\n", + "print(len(train_v3))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ame", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/utils/preprocess/eda/eda.py b/utils/preprocess/eda/eda.py new file mode 100644 index 0000000..6701a02 --- /dev/null +++ b/utils/preprocess/eda/eda.py @@ -0,0 +1,188 @@ +# 데이터 증강 +import random +import pickle +import re + +wordnet = {} +with open("./wordnet.pickle", "rb") as f: + wordnet = pickle.load(f) + + +# 한글만 남기고 나머지는 삭제 +def get_only_hangul(line): + parseText = re.compile("/ ^[ㄱ-ㅎㅏ-ㅣ가-힣]*$/").sub("", line) + + return parseText + + +######################################################################## +# Synonym replacement +# Replace n words in the sentence with synonyms from wordnet +######################################################################## +def synonym_replacement(words, n): + new_words = words.copy() + random_word_list = list(set([word for word in words])) + random.shuffle(random_word_list) + num_replaced = 0 + for random_word in random_word_list: + synonyms = get_synonyms(random_word) + if len(synonyms) >= 1: + synonym = random.choice(list(synonyms)) + new_words = [synonym if word == random_word else word for word in new_words] + num_replaced += 1 + if num_replaced >= n: + break + + if len(new_words) != 0: + sentence = " ".join(new_words) + new_words = sentence.split(" ") + + else: + new_words = "" + + return new_words + + +def get_synonyms(word): + synomyms = [] + + try: + for syn in wordnet[word]: + for s in syn: + synomyms.append(s) + except: + pass + + return synomyms + + +######################################################################## +# Random deletion +# Randomly delete words from the sentence with probability p +######################################################################## +def random_deletion(words, p): + if len(words) == 1: + return words + + new_words = [] + for word in words: + r = random.uniform(0, 1) + if r > p: + new_words.append(word) + + if len(new_words) == 0: + rand_int = random.randint(0, len(words) - 1) + return [words[rand_int]] + + return new_words + + +######################################################################## +# Random swap +# Randomly swap two words in the sentence n times +######################################################################## +def random_swap(words, n): + new_words = words.copy() + for _ in range(n): + new_words = swap_word(new_words) + + return new_words + + +def swap_word(new_words): + random_idx_1 = random.randint(0, len(new_words) - 1) + random_idx_2 = random_idx_1 + counter = 0 + + while random_idx_2 == random_idx_1: + random_idx_2 = random.randint(0, len(new_words) - 1) + counter += 1 + if counter > 3: + return new_words + + new_words[random_idx_1], new_words[random_idx_2] = ( + new_words[random_idx_2], + new_words[random_idx_1], + ) + return new_words + + +######################################################################## +# Random insertion +# Randomly insert n words into the sentence +######################################################################## +def random_insertion(words, n): + new_words = words.copy() + for _ in range(n): + add_word(new_words) + + return new_words + + +def add_word(new_words): + synonyms = [] + counter = 0 + while len(synonyms) < 1: + if len(new_words) >= 1: + random_word = new_words[random.randint(0, len(new_words) - 1)] + synonyms = get_synonyms(random_word) + counter += 1 + else: + random_word = "" + + if counter >= 10: + return + + random_synonym = synonyms[0] + random_idx = random.randint(0, len(new_words) - 1) + new_words.insert(random_idx, random_synonym) + + +# RD 제거 버전 +def EDA(sentence, alpha_sr=0.1, alpha_ri=0.1, alpha_rs=0.1, num_aug=9): + sentence = get_only_hangul(sentence) + words = sentence.split(" ") + words = [word for word in words if word != ""] + num_words = len(words) + + augmented_sentences = [] + num_new_per_technique = int(num_aug / 3) + 1 # 3가지 증강 기법에 맞춰서 수정 + + n_sr = max(1, int(alpha_sr * num_words)) + n_ri = max(1, int(alpha_ri * num_words)) + n_rs = max(1, int(alpha_rs * num_words)) + + # sr: Synonym replacement + for _ in range(num_new_per_technique): + a_words = synonym_replacement(words, n_sr) + augmented_sentences.append(" ".join(a_words)) + + # ri: Random insertion + for _ in range(num_new_per_technique): + a_words = random_insertion(words, n_ri) + augmented_sentences.append(" ".join(a_words)) + + # rs: Random swap + for _ in range(num_new_per_technique): + a_words = random_swap(words, n_rs) + augmented_sentences.append(" ".join(a_words)) + + # Hangul cleanup and shuffle + augmented_sentences = [ + get_only_hangul(sentence) for sentence in augmented_sentences + ] + random.shuffle(augmented_sentences) + + # Limit the number of augmentations to num_aug + if num_aug >= 1: + augmented_sentences = augmented_sentences[:num_aug] + else: + keep_prob = num_aug / len(augmented_sentences) + augmented_sentences = [ + s for s in augmented_sentences if random.uniform(0, 1) < keep_prob + ] + + # Original sentence 포함 + augmented_sentences.append(sentence) + + return augmented_sentences diff --git a/utils/preprocess/hanspell/__init__.py b/utils/preprocess/hanspell/__init__.py new file mode 100644 index 0000000..f901408 --- /dev/null +++ b/utils/preprocess/hanspell/__init__.py @@ -0,0 +1 @@ +__version__ = "1.1" diff --git a/utils/preprocess/hanspell/constants.py b/utils/preprocess/hanspell/constants.py new file mode 100644 index 0000000..7d0505c --- /dev/null +++ b/utils/preprocess/hanspell/constants.py @@ -0,0 +1,10 @@ +base_url = 'https://m.search.naver.com/p/csearch/ocontent/util/SpellerProxy' + + +class CheckResult: + PASSED = 0 + WRONG_SPELLING = 1 + WRONG_SPACING = 2 + AMBIGUOUS = 3 + STATISTICAL_CORRECTION = 4 + diff --git a/utils/preprocess/hanspell/passportKey.py b/utils/preprocess/hanspell/passportKey.py new file mode 100644 index 0000000..1faf010 --- /dev/null +++ b/utils/preprocess/hanspell/passportKey.py @@ -0,0 +1,50 @@ +import re +import requests + + +def get_passport_key(): + """네이버에서 '네이버 맞춤법 검사기' 페이지에서 passportKey를 획득 + + - 네이버에서 '네이버 맞춤법 검사기'를 띄운 후 + html에서 passportKey를 검색하면 값을 찾을 수 있다. + + - 찾은 값을 spell_checker.py 48 line에 적용한다. + """ + + url = "https://search.naver.com/search.naver?where=nexearch&sm=top_hty&fbm=0&ie=utf8&query=네이버+맞춤법+검사기" + res = requests.get(url) + + html_text = res.text + + match = re.search(r'passportKey=([^&"}]+)', html_text) + if match: + passport_key = match.group(1) + return passport_key + else: + return False + + +def fix_spell_checker_py_code(file_path, passportKey): + """획득한 passportkey를 spell_checker.py파일에 적용""" + + pattern = r'"passportKey": ".*"' + + with open(file_path, "r", encoding="utf-8") as input_file: + content = input_file.read() + modified_content = re.sub(pattern, f'"passportKey": "{passportKey}"', content) + + with open(file_path, "w", encoding="utf-8") as output_file: + output_file.write(modified_content) + + return + + +# before run +def init(): + spell_checker_file_path = "./hanspell/spell_checker.py" + + passport_key = get_passport_key() + if passport_key: + fix_spell_checker_py_code(spell_checker_file_path, passport_key) + else: + print("passportKey를 찾을 수 없습니다.") diff --git a/utils/preprocess/hanspell/response.py b/utils/preprocess/hanspell/response.py new file mode 100644 index 0000000..3c1f910 --- /dev/null +++ b/utils/preprocess/hanspell/response.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +from collections import namedtuple + +# 조사와 어미도 단어로 처리함. 마땅한 영단어가 생각이 안 나서.. +_checked = namedtuple('Checked', + ['result', 'original', 'checked', 'errors', 'words', 'time']) + + +class Checked(_checked): + def __new__(cls, result=False, original='', checked='', errors=0, words=[], time=0.0): + return super(Checked, cls).__new__( + cls, result, original, checked, errors, words, time) + + def as_dict(self): + d = { + 'result': self.result, + 'original': self.original, + 'checked': self.checked, + 'errors': self.errors, + 'words': self.words, + 'time': self.time, + } + return d + + def only_checked(self): + return self.checked diff --git a/utils/preprocess/hanspell/spell_checker.py b/utils/preprocess/hanspell/spell_checker.py new file mode 100644 index 0000000..18b53c2 --- /dev/null +++ b/utils/preprocess/hanspell/spell_checker.py @@ -0,0 +1,117 @@ +# -*- coding: utf-8 -*- +""" +Python용 한글 맞춤법 검사 모듈 +""" + +import requests +import json +import time +import sys +from collections import OrderedDict +import xml.etree.ElementTree as ET + +from . import __version__ +from .response import Checked +from .constants import base_url +from .constants import CheckResult + +_agent = requests.Session() +PY3 = sys.version_info[0] == 3 + + +def _remove_tags(text): + text = "{}".format(text).replace("
", "") + if not PY3: + text = text.encode("utf-8") + + result = "".join(ET.fromstring(text).itertext()) + + return result + + +def check(text): + """ + 매개변수로 입력받은 한글 문장의 맞춤법을 체크합니다. + """ + if isinstance(text, list): + result = [] + for item in text: + checked = check(item) + result.append(checked) + return result + + # 최대 500자까지 가능. + if len(text) > 500: + return Checked(result=False) + + payload = { + "passportKey": "b7584e2dbf34edd27f75b6430787c04eb65feb52", + "color_blindness": "0", + "q": text, + } + + headers = { + "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36", + "referer": "https://search.naver.com/", + } + + start_time = time.time() + r = _agent.get(base_url, params=payload, headers=headers) + passed_time = time.time() - start_time + + data = json.loads(r.text) + html = data["message"]["result"]["html"] + result = { + "result": True, + "original": text, + "checked": _remove_tags(html), + "errors": data["message"]["result"]["errata_count"], + "time": passed_time, + "words": OrderedDict(), + } + + # 띄어쓰기로 구분하기 위해 태그는 일단 보기 쉽게 바꿔둠. + # ElementTree의 iter()를 써서 더 좋게 할 수 있는 방법이 있지만 + # 이 짧은 코드에 굳이 그렇게 할 필요성이 없으므로 일단 문자열을 치환하는 방법으로 작성. + html = ( + html.replace("", "") + .replace("", "") + .replace("", "") + .replace("", "") + .replace("", "") + ) + items = html.split(" ") + words = [] + tmp = "" + for word in items: + if tmp == "" and word[:1] == "<": + pos = word.find(">") + 1 + tmp = word[:pos] + elif tmp != "": + word = "{}{}".format(tmp, word) + + if word[-5:] == "": + word = word.replace("", "") + tmp = "" + + words.append(word) + + for word in words: + check_result = CheckResult.PASSED + if word[:5] == "": + check_result = CheckResult.WRONG_SPELLING + word = word.replace("", "") + elif word[:7] == "": + check_result = CheckResult.WRONG_SPACING + word = word.replace("", "") + elif word[:8] == "": + check_result = CheckResult.AMBIGUOUS + word = word.replace("", "") + elif word[:6] == "": + check_result = CheckResult.STATISTICAL_CORRECTION + word = word.replace("", "") + result["words"][word] = check_result + + result = Checked(**result) + + return result diff --git a/utils/preprocess/test.py b/utils/preprocess/test.py new file mode 100644 index 0000000..640c5b1 --- /dev/null +++ b/utils/preprocess/test.py @@ -0,0 +1,36 @@ +import yaml +import torch +import os + +import pytorch_lightning as pl +from utils import data_pipeline, utils +from model.model import Model + +if __name__ == "__main__": + + # baseline_config 설정 불러오기 + with open("./config/config.yaml", encoding="utf-8") as f: + CFG = yaml.load(f, Loader=yaml.FullLoader) + + # dataloader 설정 (test data만 사용) + dataloader = data_pipeline.Dataloader(CFG) + + # experiments 폴더 내부 실험 폴더 + exp_name = CFG["inference"]["exp_name"] + + # 저장된 모델 불러오기 + model_path = f"./experiments/{exp_name}/model.pt" + + if os.path.exists(model_path): + model = torch.load(model_path) + print(f"모델이 불러와졌습니다: {model_path}") + else: + raise FileNotFoundError(f"{model_path} 파일을 찾을 수 없습니다.") + + # trainer 인스턴스 생성 + trainer = pl.Trainer(accelerator="gpu", devices=1) + + # Test part (metrics) + trainer.test(model=model, datamodule=dataloader) + ## datamodule에서 test_dataloader 호출 + ## predict_path로 설정된 test.csv가 사용된다 diff --git a/utils/preprocess/validation_tuning.ipynb b/utils/preprocess/validation_tuning.ipynb new file mode 100644 index 0000000..47c9e76 --- /dev/null +++ b/utils/preprocess/validation_tuning.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import warnings\n", + "\n", + "# 모든 경고 메시지 무시\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "train = pd.read_csv(\"../data/raw/train.csv\", encoding=\"UTF-8\")\n", + "dev = pd.read_csv(\"../data/raw/dev.csv\", encoding=\"UTF-8\")\n", + "test = pd.read_csv(\"../data/raw/test.csv\", encoding=\"UTF-8\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_label_count(df, df_name):\n", + " grouped_data = df.groupby(\"label\")[\"id\"].count()\n", + " grouped_data.plot(kind=\"bar\", color=\"skyblue\")\n", + " plt.title(f\"{df_name} label Count\")\n", + " plt.xlabel(\"label\")\n", + " plt.ylabel(\"Count\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def special_value_interpolation(df):\n", + " # 0.5, 1.5, 2.5, 3.5, 4.5에 해당하는 값을 필터링\n", + " target_values = [0.5, 1.5, 2.5, 3.5, 4.5]\n", + " filtered_df = df[df[\"label\"].isin(target_values)]\n", + "\n", + " # 각 값에 대해 절반은 +0.1, 절반은 -0.1\n", + " def adjust_labels(group):\n", + " n = len(group)\n", + " # 절반으로 나눔\n", + " half_n = n // 2\n", + " # 첫 절반은 -0.1, 나머지는 +0.1\n", + " group.iloc[:half_n] -= 0.1\n", + " group.iloc[half_n:] += 0.1\n", + " return group\n", + "\n", + " # 필터링된 값들에 대한 보정\n", + " df.loc[df[\"label\"].isin(target_values), \"label\"] = filtered_df.groupby(\"label\")[\n", + " \"label\"\n", + " ].transform(adjust_labels)\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAHPCAYAAACyf8XcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDXklEQVR4nO3de1xVVf7/8ffhcg7ewCu3QiTNuyiZYzTjrVA0s2lyprxrOWkJ9k0bM7oo6hSmZVo59m1+qTVpWjNmZWreUkqxzCK8Z6aDpWCmcMQSBNbvjx7ubyewDgQC7tfz8diPB3uvdT57bdyc83bvdc5xGGOMAAAAbMynqgcAAABQ1QhEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEAADA9ghEACpcs2bNNGrUqAqrl5ycLIfDUe6x3HzzzRU2FklyOBxKTk6u0JoAqhaBCLChbdu2KTk5WTk5OVU9lMue2+3WtGnT1LFjR9WtW1e1atVS+/btNXnyZB07dqyqhydJWr16NQEPtudX1QMAcOlt27ZN06ZN06hRo1S/fv0Kr3/gwAH5+PD/ra+++kpxcXHKzMzUX/7yF40ZM0ZOp1MZGRl66aWX9Oabb+qLL76o6mFq9erVmj9/PqEItkYgAvCLiouLVVBQoICAAK8f43K5KnFENUNhYaFuu+02ZWdna/PmzfrDH/7g0f7444/rySefrKLRAfg5/gsH2ExycrImTZokSYqKipLD4ZDD4dCRI0ck/Tg/JjExUUuWLFG7du3kcrm0du1aSdJTTz2l66+/Xo0aNVKtWrXUuXNn/fvf/y6xj5/PIVq8eLEcDoe2bt2qiRMnqkmTJqpTp47+9Kc/6dtvvy3XcSxatEg33HCDgoOD5XK51LZtWy1YsOCi/detW6dOnTopICBAbdu21YoVK0r0ycnJ0f3336+IiAi5XC61aNFCTz75pIqLi8s8vv/85z/6/PPP9cgjj5QIQ5IUGBioxx9/3GPbG2+8oc6dO6tWrVpq3Lixhg0bpm+++cajT8+ePdWzZ88S9UaNGqVmzZpZ60eOHJHD4dBTTz2lF198Uc2bN5fL5VKXLl20Y8cOj8fNnz9fkqxzobzztYCajCtEgM3cdttt+uKLL/Taa6/pmWeeUePGjSVJTZo0sfps2rRJr7/+uhITE9W4cWPrhXbevHm65ZZbNHToUBUUFGjZsmX6y1/+olWrVql///6/uu/x48erQYMGmjp1qo4cOaK5c+cqMTFRy5cvL/NxLFiwQO3atdMtt9wiPz8/vfPOOxo3bpyKi4uVkJDg0ffgwYO64447dM8992jkyJFatGiR/vKXv2jt2rXq3bu3JOn7779Xjx499M0332js2LFq2rSptm3bpqSkJB0/flxz584t0/jefvttSdLw4cO96r948WLdeeed6tKli1JSUpSdna158+Zp69at+uyzz8p9a3Pp0qU6c+aMxo4dK4fDoVmzZum2227TV199JX9/f40dO1bHjh3T+vXr9a9//atc+wAuCwaA7cyePdtIMocPHy7RJsn4+PiYPXv2lGj7/vvvPdYLCgpM+/btzQ033OCxPTIy0owcOdJaX7RokZFk4uLiTHFxsbV9woQJxtfX1+Tk5PzieKdOnWp+/nT187EYY0x8fLy56qqrSoxFkvnPf/5jbcvNzTVhYWEmJibG2jZjxgxTp04d88UXX3g8/qGHHjK+vr4mMzPT2ibJTJ069RfHHBMTY4KCgn6xzwUFBQUmODjYtG/f3vzwww/W9lWrVhlJZsqUKda2Hj16mB49epSoMXLkSBMZGWmtHz582EgyjRo1MqdOnbK2v/XWW0aSeeedd6xtCQkJJX6/gN1wywxACT169FDbtm1LbK9Vq5b18+nTp5Wbm6tu3brp008/9arumDFjPG7HdOvWTUVFRfrvf/9b5jH+dCy5ubk6efKkevTooa+++kq5ubkefcPDw/WnP/3JWg8MDNSIESP02WefKSsrS9KPt6u6deumBg0a6OTJk9YSFxenoqIipaamlml8brdb9erV86rvJ598ohMnTmjcuHEec7X69++v1q1b69133y3Tvn/qjjvuUIMGDaz1bt26SfpxwjeA/8MtMwAlREVFlbp91apV+vvf/6709HTl5+db272dc9K0aVOP9Qsv1KdPny7zGLdu3aqpU6cqLS1N33//vUdbbm6ugoKCrPUWLVqUGGPLli0l/TjXJjQ0VAcPHlRGRobHrcOfOnHiRJnGFxgY6HXouBAIW7VqVaKtdevW+vDDD8u075+qyN85cDkjEAEo4adXXy744IMPdMstt6h79+76xz/+obCwMPn7+2vRokVaunSpV3V9fX1L3W6MKdP4Dh06pBtvvFGtW7fWnDlzFBERIafTqdWrV+uZZ54p1yTo4uJi9e7dWw8++GCp7RcClLdat26tzz77TEePHlVERESZx3MxDoej1N9XUVFRqf0r6ncOXO4IRIANleddRP/5z38UEBCg9957z+Nt9YsWLarIoXnlnXfeUX5+vt5++22PKyDvv/9+qf2//PJLGWM8jvvC5/9cmDDevHlz5eXlKS4urkLGOGDAAL322mt69dVXlZSU9It9IyMjJf34+U033HCDR9uBAwesdunHKzylXXkqz23HC3hXGcDb7gFbqlOnjiSV6ZOqfX195XA4PK5EHDlyRCtXrqzg0Xk3FsnzKkdubu5Fw9mxY8f05ptvWutut1uvvPKKOnXqpNDQUEnS7bffrrS0NL333nslHp+Tk6PCwsIyjfHPf/6zOnTooMcff1xpaWkl2s+cOaNHHnlEknTttdcqODhYL7zwgsetyDVr1mjfvn0e7+Br3ry59u/f7/FxBZ9//rm2bt1apvH9VHnOB+BywxUiwIY6d+4sSXrkkUc0aNAg+fv7a8CAAdYLY2n69++vOXPmqG/fvhoyZIhOnDih+fPnq0WLFsrIyLhUQ5ck9enTR06nUwMGDNDYsWOVl5enf/7znwoODtbx48dL9G/ZsqVGjx6tHTt2KCQkRAsXLlR2drZHgJo0aZLefvtt3XzzzRo1apQ6d+6ss2fPateuXfr3v/+tI0eOWB9R4A1/f3+tWLFCcXFx6t69u26//Xb9/ve/l7+/v/bs2aOlS5eqQYMGevzxx+Xv768nn3xSd955p3r06KHBgwdbb7tv1qyZJkyYYNW96667NGfOHMXHx2v06NE6ceKEXnjhBbVr105ut7tcv88L58N9992n+Ph4+fr6atCgQeWqBdRYVfoeNwBVZsaMGeaKK64wPj4+Hm/Bl2QSEhJKfcxLL71krr76auNyuUzr1q3NokWLSn1L/MXedr9jxw6Pfu+//76RZN5///1fHGtp+3j77bdNdHS0CQgIMM2aNTNPPvmkWbhwYYmPE4iMjDT9+/c37733nomOjrbG/sYbb5TYz5kzZ0xSUpJp0aKFcTqdpnHjxub66683Tz31lCkoKLD6yYu33V9w+vRpM2XKFNOhQwdTu3ZtExAQYNq3b2+SkpLM8ePHPfouX77cxMTEGJfLZRo2bGiGDh1qvv766xI1X331VXPVVVcZp9NpOnXqZN57772Lvu1+9uzZJR7/8/EXFhaa8ePHmyZNmhiHw8Fb8GFLDmOYWQcAAOyNOUQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2+GBGLxQXF+vYsWOqV68eH3EPAEANYYzRmTNnFB4eLh+fX74GRCDywrFjxyr0yxkBAMClc/ToUV155ZW/2IdA5IV69epJ+vEXGhgYWMWjAQAA3nC73YqIiLBex38JgcgLF26TBQYGEogAAKhhvJnuwqRqAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABgewQiAABge35VPYCabOZnJ73q91BM40oeCQAA+C24QgQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyvSgNRSkqKunTponr16ik4OFi33nqrDhw44NHn3LlzSkhIUKNGjVS3bl0NHDhQ2dnZHn0yMzPVv39/1a5dW8HBwZo0aZIKCws9+mzevFnXXHONXC6XWrRoocWLF1f24QEAgBqiSgPRli1blJCQoO3bt2v9+vU6f/68+vTpo7Nnz1p9JkyYoHfeeUdvvPGGtmzZomPHjum2226z2ouKitS/f38VFBRo27Ztevnll7V48WJNmTLF6nP48GH1799fvXr1Unp6uu6//3799a9/1XvvvXdJjxcAAFRPDmOMqepBXPDtt98qODhYW7ZsUffu3ZWbm6smTZpo6dKl+vOf/yxJ2r9/v9q0aaO0tDRdd911WrNmjW6++WYdO3ZMISEhkqQXXnhBkydP1rfffiun06nJkyfr3Xff1e7du619DRo0SDk5OVq7du2vjsvtdisoKEi5ubkKDAy0ts/87KRXx/VQTOOy/BoAAEAFuNjrd2mq1Ryi3NxcSVLDhg0lSTt37tT58+cVFxdn9WndurWaNm2qtLQ0SVJaWpo6dOhghSFJio+Pl9vt1p49e6w+P61xoc+FGj+Xn58vt9vtsQAAgMtXtQlExcXFuv/++/X73/9e7du3lyRlZWXJ6XSqfv36Hn1DQkKUlZVl9flpGLrQfqHtl/q43W798MMPJcaSkpKioKAga4mIiKiQYwQAANVTtQlECQkJ2r17t5YtW1bVQ1FSUpJyc3Ot5ejRo1U9JAAAUIn8qnoAkpSYmKhVq1YpNTVVV155pbU9NDRUBQUFysnJ8bhKlJ2drdDQUKvPxx9/7FHvwrvQftrn5+9My87OVmBgoGrVqlViPC6XSy6Xq0KODQAAVH9VeoXIGKPExES9+eab2rRpk6KiojzaO3fuLH9/f23cuNHaduDAAWVmZio2NlaSFBsbq127dunEiRNWn/Xr1yswMFBt27a1+vy0xoU+F2oAAAB7q9IrRAkJCVq6dKneeust1atXz5rzExQUpFq1aikoKEijR4/WxIkT1bBhQwUGBmr8+PGKjY3VddddJ0nq06eP2rZtq+HDh2vWrFnKysrSo48+qoSEBOsqzz333KPnn39eDz74oO666y5t2rRJr7/+ut59990qO3YAAFB9VOkVogULFig3N1c9e/ZUWFiYtSxfvtzq88wzz+jmm2/WwIED1b17d4WGhmrFihVWu6+vr1atWiVfX1/FxsZq2LBhGjFihKZPn271iYqK0rvvvqv169erY8eOevrpp/X//t//U3x8/CU9XgAAUD1Vq88hqq74HCIAAGqeGvs5RAAAAFWBQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyvSgNRamqqBgwYoPDwcDkcDq1cudKj3eFwlLrMnj3b6tOsWbMS7TNnzvSok5GRoW7duikgIEARERGaNWvWpTg8AABQQ1RpIDp79qw6duyo+fPnl9p+/Phxj2XhwoVyOBwaOHCgR7/p06d79Bs/frzV5na71adPH0VGRmrnzp2aPXu2kpOT9eKLL1bqsQEAgJrDryp33q9fP/Xr1++i7aGhoR7rb731lnr16qWrrrrKY3u9evVK9L1gyZIlKigo0MKFC+V0OtWuXTulp6drzpw5GjNmzG8/CAAAUOPVmDlE2dnZevfddzV69OgSbTNnzlSjRo0UExOj2bNnq7Cw0GpLS0tT9+7d5XQ6rW3x8fE6cOCATp8+Xeq+8vPz5Xa7PRYAAHD5qtIrRGXx8ssvq169errttts8tt9333265ppr1LBhQ23btk1JSUk6fvy45syZI0nKyspSVFSUx2NCQkKstgYNGpTYV0pKiqZNm1ZJRwIAAKqbGhOIFi5cqKFDhyogIMBj+8SJE62fo6Oj5XQ6NXbsWKWkpMjlcpVrX0lJSR513W63IiIiyjdwAABQ7dWIQPTBBx/owIEDWr58+a/27dq1qwoLC3XkyBG1atVKoaGhys7O9uhzYf1i845cLle5wxQAAKh5asQcopdeekmdO3dWx44df7Vvenq6fHx8FBwcLEmKjY1Vamqqzp8/b/VZv369WrVqVertMgAAYD9VGojy8vKUnp6u9PR0SdLhw4eVnp6uzMxMq4/b7dYbb7yhv/71ryUen5aWprlz5+rzzz/XV199pSVLlmjChAkaNmyYFXaGDBkip9Op0aNHa8+ePVq+fLnmzZvncUsMAADYW5XeMvvkk0/Uq1cva/1CSBk5cqQWL14sSVq2bJmMMRo8eHCJx7tcLi1btkzJycnKz89XVFSUJkyY4BF2goKCtG7dOiUkJKhz585q3LixpkyZwlvuAQCAxWGMMVU9iOrO7XYrKChIubm5CgwMtLbP/OykV49/KKZxZQ0NAABcxMVev0tTI+YQAQAAVCYCEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsD0CEQAAsL0qDUSpqakaMGCAwsPD5XA4tHLlSo/2UaNGyeFweCx9+/b16HPq1CkNHTpUgYGBql+/vkaPHq28vDyPPhkZGerWrZsCAgIUERGhWbNmVfahAQCAGqRKA9HZs2fVsWNHzZ8//6J9+vbtq+PHj1vLa6+95tE+dOhQ7dmzR+vXr9eqVauUmpqqMWPGWO1ut1t9+vRRZGSkdu7cqdmzZys5OVkvvvhipR0XAACoWfyqcuf9+vVTv379frGPy+VSaGhoqW379u3T2rVrtWPHDl177bWSpOeee0433XSTnnrqKYWHh2vJkiUqKCjQwoUL5XQ61a5dO6Wnp2vOnDkewQkAANhXtZ9DtHnzZgUHB6tVq1a699579d1331ltaWlpql+/vhWGJCkuLk4+Pj766KOPrD7du3eX0+m0+sTHx+vAgQM6ffp0qfvMz8+X2+32WAAAwOWrWgeivn376pVXXtHGjRv15JNPasuWLerXr5+KiookSVlZWQoODvZ4jJ+fnxo2bKisrCyrT0hIiEefC+sX+vxcSkqKgoKCrCUiIqKiDw0AAFQjVXrL7NcMGjTI+rlDhw6Kjo5W8+bNtXnzZt14442Vtt+kpCRNnDjRWne73YQiAAAuY9X6CtHPXXXVVWrcuLG+/PJLSVJoaKhOnDjh0aewsFCnTp2y5h2FhoYqOzvbo8+F9YvNTXK5XAoMDPRYAADA5atGBaKvv/5a3333ncLCwiRJsbGxysnJ0c6dO60+mzZtUnFxsbp27Wr1SU1N1fnz560+69evV6tWrdSgQYNLewAAAKBaqtJAlJeXp/T0dKWnp0uSDh8+rPT0dGVmZiovL0+TJk3S9u3bdeTIEW3cuFF//OMf1aJFC8XHx0uS2rRpo759++ruu+/Wxx9/rK1btyoxMVGDBg1SeHi4JGnIkCFyOp0aPXq09uzZo+XLl2vevHket8QAAIC9VWkg+uSTTxQTE6OYmBhJ0sSJExUTE6MpU6bI19dXGRkZuuWWW9SyZUuNHj1anTt31gcffCCXy2XVWLJkiVq3bq0bb7xRN910k/7whz94fMZQUFCQ1q1bp8OHD6tz58564IEHNGXKFN5yDwAALA5jjKnqQVR3brdbQUFBys3N9ZhPNPOzk149/qGYxpU1NAAAcBEXe/0uTY2aQwQAAFAZCEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2CEQAAMD2qjQQpaamasCAAQoPD5fD4dDKlSuttvPnz2vy5Mnq0KGD6tSpo/DwcI0YMULHjh3zqNGsWTM5HA6PZebMmR59MjIy1K1bNwUEBCgiIkKzZs26FIcHAABqiCoNRGfPnlXHjh01f/78Em3ff/+9Pv30Uz322GP69NNPtWLFCh04cEC33HJLib7Tp0/X8ePHrWX8+PFWm9vtVp8+fRQZGamdO3dq9uzZSk5O1osvvlipxwYAAGoOv6rceb9+/dSvX79S24KCgrR+/XqPbc8//7x+97vfKTMzU02bNrW216tXT6GhoaXWWbJkiQoKCrRw4UI5nU61a9dO6enpmjNnjsaMGVNxBwMAAGqsGjWHKDc3Vw6HQ/Xr1/fYPnPmTDVq1EgxMTGaPXu2CgsLrba0tDR1795dTqfT2hYfH68DBw7o9OnTpe4nPz9fbrfbYwEAAJevKr1CVBbnzp3T5MmTNXjwYAUGBlrb77vvPl1zzTVq2LChtm3bpqSkJB0/flxz5syRJGVlZSkqKsqjVkhIiNXWoEGDEvtKSUnRtGnTKvFoAABAdVIjAtH58+d1++23yxijBQsWeLRNnDjR+jk6OlpOp1Njx45VSkqKXC5XufaXlJTkUdftdisiIqJ8gwcAANVetQ9EF8LQf//7X23atMnj6lBpunbtqsLCQh05ckStWrVSaGiosrOzPfpcWL/YvCOXy1XuMAUAAGqeaj2H6EIYOnjwoDZs2KBGjRr96mPS09Pl4+Oj4OBgSVJsbKxSU1N1/vx5q8/69evVqlWrUm+XAQAA+6nSK0R5eXn68ssvrfXDhw8rPT1dDRs2VFhYmP785z/r008/1apVq1RUVKSsrCxJUsOGDeV0OpWWlqaPPvpIvXr1Ur169ZSWlqYJEyZo2LBhVtgZMmSIpk2bptGjR2vy5MnavXu35s2bp2eeeaZKjhkAAFQ/DmOMKeuDrrrqKu3YsaPEFZucnBxdc801+uqrr7yqs3nzZvXq1avE9pEjRyo5ObnEZOgL3n//ffXs2VOffvqpxo0bp/379ys/P19RUVEaPny4Jk6c6HHLKyMjQwkJCdqxY4caN26s8ePHa/LkyV4fr9vtVlBQkHJzcz1u2c387KRXj38oprHX+wIAABXjYq/fpSnXFaIjR46oqKioxPb8/Hx98803Xtfp2bOnfimP/VpWu+aaa7R9+/Zf3U90dLQ++OADr8cFAADspUyB6O2337Z+fu+99xQUFGStFxUVaePGjWrWrFmFDQ4AAOBSKFMguvXWWyVJDodDI0eO9Gjz9/dXs2bN9PTTT1fY4AAAAC6FMgWi4uJiSVJUVJQ1HwcAAKCmK9ccosOHD1f0OAAAAKpMud92v3HjRm3cuFEnTpywrhxdsHDhwt88MAAAgEulXIFo2rRpmj59uq699lqFhYXJ4XBU9LgAAAAumXIFohdeeEGLFy/W8OHDK3o8AAAAl1y5vrqjoKBA119/fUWPBQAAoEqUKxD99a9/1dKlSyt6LAAAAFWiXLfMzp07pxdffFEbNmxQdHS0/P39PdrnzJlTIYMDAAC4FMoViDIyMtSpUydJ0u7duz3amGANAABqmnIFovfff7+ixwEAAFBlyjWHCAAA4HJSritEvXr1+sVbY5s2bSr3gAAAAC61cgWiC/OHLjh//rzS09O1e/fuEl/6CgAAUN2VKxA988wzpW5PTk5WXl7ebxoQAADApVahc4iGDRvG95gBAIAap0IDUVpamgICAiqyJAAAQKUr1y2z2267zWPdGKPjx4/rk08+0WOPPVYhAwMAALhUyhWIgoKCPNZ9fHzUqlUrTZ8+XX369KmQgQEAAFwq5QpEixYtquhxAAAAVJlyBaILdu7cqX379kmS2rVrp5iYmAoZFAAAwKVUrkB04sQJDRo0SJs3b1b9+vUlSTk5OerVq5eWLVumJk2aVOQYAQAAKlW53mU2fvx4nTlzRnv27NGpU6d06tQp7d69W263W/fdd19FjxEAAKBSlesK0dq1a7Vhwwa1adPG2ta2bVvNnz+fSdUAAKDGKdcVouLiYvn7+5fY7u/vr+Li4t88KAAAgEupXIHohhtu0P/8z//o2LFj1rZvvvlGEyZM0I033lhhgwMAALgUyhWInn/+ebndbjVr1kzNmzdX8+bNFRUVJbfbreeee66ixwgAAFCpyjWHKCIiQp9++qk2bNig/fv3S5LatGmjuLi4Ch0cAADApVCmK0SbNm1S27Zt5Xa75XA41Lt3b40fP17jx49Xly5d1K5dO33wwQeVNVYAAIBKUaZANHfuXN19990KDAws0RYUFKSxY8dqzpw5XtdLTU3VgAEDFB4eLofDoZUrV3q0G2M0ZcoUhYWFqVatWoqLi9PBgwc9+pw6dUpDhw5VYGCg6tevr9GjRysvL8+jT0ZGhrp166aAgABFRERo1qxZ3h80AAC47JUpEH3++efq27fvRdv79OmjnTt3el3v7Nmz6tixo+bPn19q+6xZs/Tss8/qhRde0EcffaQ6deooPj5e586ds/oMHTpUe/bs0fr167Vq1SqlpqZqzJgxVrvb7VafPn0UGRmpnTt3avbs2UpOTtaLL77o9TgBAMDlrUxziLKzs0t9u71VzM9P3377rdf1+vXrp379+pXaZozR3Llz9eijj+qPf/yjJOmVV15RSEiIVq5cqUGDBmnfvn1au3atduzYoWuvvVaS9Nxzz+mmm27SU089pfDwcC1ZskQFBQVauHChnE6n2rVrp/T0dM2ZM8cjOAEAAPsq0xWiK664Qrt3775oe0ZGhsLCwn7zoCTp8OHDysrK8pioHRQUpK5duyotLU2SlJaWpvr161thSJLi4uLk4+Ojjz76yOrTvXt3OZ1Oq098fLwOHDig06dPl7rv/Px8ud1ujwUAAFy+yhSIbrrpJj322GMet6wu+OGHHzR16lTdfPPNFTKwrKwsSVJISIjH9pCQEKstKytLwcHBHu1+fn5q2LChR5/Savx0Hz+XkpKioKAga4mIiPjtBwQAAKqtMt0ye/TRR7VixQq1bNlSiYmJatWqlSRp//79mj9/voqKivTII49UykAvpaSkJE2cONFad7vdhCIAAC5jZQpEISEh2rZtm+69914lJSXJGCNJcjgcio+P1/z580tcjSmv0NBQST/OW/rpbbjs7Gx16tTJ6nPixAmPxxUWFurUqVPW40NDQ5Wdne3R58L6hT4/53K55HK5KuQ4AABA9VfmT6qOjIzU6tWrdfLkSX300Ufavn27Tp48qdWrVysqKqrCBhYVFaXQ0FBt3LjR2uZ2u/XRRx8pNjZWkhQbG6ucnByPd7Zt2rRJxcXF6tq1q9UnNTVV58+ft/qsX79erVq1UoMGDSpsvAAAoOYq11d3SFKDBg3UpUsX/e53vyt3sMjLy1N6errS09Ml/TiROj09XZmZmXI4HLr//vv197//XW+//bZ27dqlESNGKDw8XLfeequkHz8du2/fvrr77rv18ccfa+vWrUpMTNSgQYMUHh4uSRoyZIicTqdGjx6tPXv2aPny5Zo3b57HLTEAAGBv5frqjoryySefqFevXtb6hZAycuRILV68WA8++KDOnj2rMWPGKCcnR3/4wx+0du1aBQQEWI9ZsmSJEhMTdeONN8rHx0cDBw7Us88+a7UHBQVp3bp1SkhIUOfOndW4cWNNmTKFt9wDAACLw1yYCISLcrvdCgoKUm5ursendM/87KRXj38opnFlDQ0AAFzExV6/S1PuW2YAAACXCwIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwPQIRAACwvWofiJo1ayaHw1FiSUhIkCT17NmzRNs999zjUSMzM1P9+/dX7dq1FRwcrEmTJqmwsLAqDgcAAFRDflU9gF+zY8cOFRUVWeu7d+9W79699Ze//MXadvfdd2v69OnWeu3ata2fi4qK1L9/f4WGhmrbtm06fvy4RowYIX9/fz3xxBOX5iAAAEC1Vu0DUZMmTTzWZ86cqebNm6tHjx7Wttq1ays0NLTUx69bt0579+7Vhg0bFBISok6dOmnGjBmaPHmykpOT5XQ6K3X8AACg+qv2t8x+qqCgQK+++qruuusuORwOa/uSJUvUuHFjtW/fXklJSfr++++ttrS0NHXo0EEhISHWtvj4eLndbu3Zs6fU/eTn58vtdnssAADg8lXtrxD91MqVK5WTk6NRo0ZZ24YMGaLIyEiFh4crIyNDkydP1oEDB7RixQpJUlZWlkcYkmStZ2VllbqflJQUTZs2rXIOAgAAVDs1KhC99NJL6tevn8LDw61tY8aMsX7u0KGDwsLCdOONN+rQoUNq3rx5ufaTlJSkiRMnWutut1sRERHlHzgAAKjWakwg+u9//6sNGzZYV34upmvXrpKkL7/8Us2bN1doaKg+/vhjjz7Z2dmSdNF5Ry6XSy6XqwJGDQAAaoIaM4do0aJFCg4OVv/+/X+xX3p6uiQpLCxMkhQbG6tdu3bpxIkTVp/169crMDBQbdu2rbTxAgCAmqNGXCEqLi7WokWLNHLkSPn5/d+QDx06pKVLl+qmm25So0aNlJGRoQkTJqh79+6Kjo6WJPXp00dt27bV8OHDNWvWLGVlZenRRx9VQkICV4EAAICkGhKINmzYoMzMTN11110e251OpzZs2KC5c+fq7NmzioiI0MCBA/Xoo49afXx9fbVq1Srde++9io2NVZ06dTRy5EiPzy0CAAD25jDGmKoeRHXndrsVFBSk3NxcBQYGWttnfnbSq8c/FNO4soYGAAAu4mKv36WpMXOIAAAAKguBCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6BCAAA2F61DkTJyclyOBweS+vWra32c+fOKSEhQY0aNVLdunU1cOBAZWdne9TIzMxU//79Vbt2bQUHB2vSpEkqLCy81IcCAACqMb+qHsCvadeunTZs2GCt+/n935AnTJigd999V2+88YaCgoKUmJio2267TVu3bpUkFRUVqX///goNDdW2bdt0/PhxjRgxQv7+/nriiScu+bEAAIDqqdoHIj8/P4WGhpbYnpubq5deeklLly7VDTfcIElatGiR2rRpo+3bt+u6667TunXrtHfvXm3YsEEhISHq1KmTZsyYocmTJys5OVlOp/NSHw4AoAab+dnJX+3zUEzjSzASVLRqfctMkg4ePKjw8HBdddVVGjp0qDIzMyVJO3fu1Pnz5xUXF2f1bd26tZo2baq0tDRJUlpamjp06KCQkBCrT3x8vNxut/bs2XNpDwQAAFRb1foKUdeuXbV48WK1atVKx48f17Rp09StWzft3r1bWVlZcjqdql+/vsdjQkJClJWVJUnKysryCEMX2i+0XUx+fr7y8/OtdbfbXUFHBAAAqqNqHYj69etn/RwdHa2uXbsqMjJSr7/+umrVqlVp+01JSdG0adMqrX5l8+aSrsRlXQAALqj2t8x+qn79+mrZsqW+/PJLhYaGqqCgQDk5OR59srOzrTlHoaGhJd51dmG9tHlJFyQlJSk3N9dajh49WrEHAgAAqpUaFYjy8vJ06NAhhYWFqXPnzvL399fGjRut9gMHDigzM1OxsbGSpNjYWO3atUsnTpyw+qxfv16BgYFq27btRffjcrkUGBjosQAAgMtXtb5l9re//U0DBgxQZGSkjh07pqlTp8rX11eDBw9WUFCQRo8erYkTJ6phw4YKDAzU+PHjFRsbq+uuu06S1KdPH7Vt21bDhw/XrFmzlJWVpUcffVQJCQlyuVxVfHQAAKC6qNaB6Ouvv9bgwYP13XffqUmTJvrDH/6g7du3q0mTJpKkZ555Rj4+Pho4cKDy8/MVHx+vf/zjH9bjfX19tWrVKt17772KjY1VnTp1NHLkSE2fPr2qDgkAAFRD1ToQLVu27BfbAwICNH/+fM2fP/+ifSIjI7V69eqKHhoAALiM1Kg5RAAAAJWBQAQAAGyvWt8yAwDgt+LrNuANrhABAADbIxABAADbIxABAADbYw4RAABVgLlN1QuBCABQ7RAWcKlxywwAANgegQgAANgegQgAANgegQgAANgek6rxi7yZ2CgxuREAULNxhQgAANgegQgAANgegQgAANgegQgAANgek6pxyTBBGwBQXXGFCAAA2B5XiKoJrp4AAFB1CESosfjyRwBARSEQASJcAYDdMYcIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHm+7BwD8Zny4LGo6rhABAADb4woRANQgXIkBKke1vkKUkpKiLl26qF69egoODtatt96qAwcOePTp2bOnHA6Hx3LPPfd49MnMzFT//v1Vu3ZtBQcHa9KkSSosLLyUhwIAAKqxan2FaMuWLUpISFCXLl1UWFiohx9+WH369NHevXtVp04dq9/dd9+t6dOnW+u1a9e2fi4qKlL//v0VGhqqbdu26fjx4xoxYoT8/f31xBNPXNLjAWBP1fWqTnUdF1AVqnUgWrt2rcf64sWLFRwcrJ07d6p79+7W9tq1ays0NLTUGuvWrdPevXu1YcMGhYSEqFOnTpoxY4YmT56s5ORkOZ3OSj0G2A/fiwYANU+1vmX2c7m5uZKkhg0bemxfsmSJGjdurPbt2yspKUnff/+91ZaWlqYOHTooJCTE2hYfHy+32609e/aUup/8/Hy53W6PBQAAXL6q9RWinyouLtb999+v3//+92rfvr21fciQIYqMjFR4eLgyMjI0efJkHThwQCtWrJAkZWVleYQhSdZ6VlZWqftKSUnRtGnTKulIAABAdVNjAlFCQoJ2796tDz/80GP7mDFjrJ87dOigsLAw3XjjjTp06JCaN29ern0lJSVp4sSJ1rrb7VZERET5Bg5UE9zKKxvm1wD2UiMCUWJiolatWqXU1FRdeeWVv9i3a9eukqQvv/xSzZs3V2hoqD7++GOPPtnZ2ZJ00XlHLpdLLperAkYOXJ4IVwAuN9V6DpExRomJiXrzzTe1adMmRUVF/epj0tPTJUlhYWGSpNjYWO3atUsnTpyw+qxfv16BgYFq27ZtpYwbAADULNX6ClFCQoKWLl2qt956S/Xq1bPm/AQFBalWrVo6dOiQli5dqptuukmNGjVSRkaGJkyYoO7duys6OlqS1KdPH7Vt21bDhw/XrFmzlJWVpUcffVQJCQlcBQIAAJKq+RWiBQsWKDc3Vz179lRYWJi1LF++XJLkdDq1YcMG9enTR61bt9YDDzyggQMH6p133rFq+Pr6atWqVfL19VVsbKyGDRumESNGeHxuEQAAsLdqfYXIGPOL7REREdqyZcuv1omMjNTq1asralgAAFQrzOv77ar1FSIAAIBLgUAEAABsr1rfMgOAsuCzgwCUF4EIQJUixACoDghEQDXGREkAuDSYQwQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGyPQAQAAGzPr6oHAAAA8GtmfnbSq34PxTQuV30CEQAAsHgTPMobOqozbpkBAADbIxABAADbIxABAADbIxABAADbY1I1AACoFJX9zrCKxBUiAABgewQiAABgewQiAABgewQiAABge7YKRPPnz1ezZs0UEBCgrl276uOPP67qIQEAgGrANoFo+fLlmjhxoqZOnapPP/1UHTt2VHx8vE6cOFHVQwMAAFXMNoFozpw5uvvuu3XnnXeqbdu2euGFF1S7dm0tXLiwqocGAACqmC0CUUFBgXbu3Km4uDhrm4+Pj+Li4pSWllaFIwMAANWBLT6Y8eTJkyoqKlJISIjH9pCQEO3fv79E//z8fOXn51vrubm5kiS32+3R71zeGa/273Y7f7UPtcpWy9t61Lo8anlbj1qXRy1v61Hr8qjlbb3y1Lrwum2M+fUHGhv45ptvjCSzbds2j+2TJk0yv/vd70r0nzp1qpHEwsLCwsLCchksR48e/dWsYIsrRI0bN5avr6+ys7M9tmdnZys0NLRE/6SkJE2cONFaLy4u1qlTp9SoUSM5HI6L7sftdisiIkJHjx5VYGDgbxoztahVk8ZGLWpRi7/v6ljLGKMzZ84oPDz8V+vZIhA5nU517txZGzdu1K233irpx5CzceNGJSYmlujvcrnkcrk8ttWvX9/r/QUGBlbIHwe1qHUp6lGLWtSqPrUquh61pKCgIK/q2CIQSdLEiRM1cuRIXXvttfrd736nuXPn6uzZs7rzzjuremgAAKCK2SYQ3XHHHfr22281ZcoUZWVlqVOnTlq7dm2JidYAAMB+bBOIJCkxMbHUW2QVxeVyaerUqSVut1GLWhVRq6LrUYta1Ko+tSq6HrXKzmGMN+9FAwAAuHzZ4oMZAQAAfgmBCAAA2B6BCAAA2B6BCAAA2B6BCAAA2B6ByCYOHz6swsLCCqlVUXUu4I2OqEyc+7AjzvuyIxD9Bnv37tW4ceMUExOjsLAwhYWFKSYmRuPGjdPevXvLVOv48eN69dVXtXr1ahUUFHi0nT17VtOnT/9NY23VqpUOHjxYpsesXbtWu3btkvTjV53MmDFDV1xxhVwul6688krNnDnT6xM7Pz9ff/vb39S9e3c9+eSTkqS///3vqlu3rurVq6chQ4ZY30pcHvn5+crPzy/34yvb5s2b9cMPP/zmOvn5+Tp06FCFHWt2draysrLK/DjO/epz7ldnl9uLMuf9ZX7e/8Yvkret1atXG6fTaa677jozdepU849//MP84x//MFOnTjXXX3+9cblcZu3atV7V+vjjj039+vVNYGCgqVWrlmnRooXZvXu31Z6VlWV8fHy8qvWnP/2p1MXHx8fExcVZ695o1aqVSU1NNcYY88QTT5hGjRqZOXPmmDVr1pi5c+eakJAQM3PmTK9qTZgwwYSHh5sHHnjAtGnTxowbN840bdrUvPrqq2bp0qWmRYsWZvz48V7VumDdunWmX79+pn79+sbHx8f4+PiY+vXrm379+pn169eXqVZ6erqZMWOGmT9/vvn222892nJzc82dd95Zpno/5+/vb/bu3VumxyxatMhs27bNGGPMDz/8YO666y7j6+trfHx8jJ+fnxk7dqw5d+6cV7W+++47M3DgQBMREWHuueceU1hYaEaPHm0cDofx8fExsbGx5tixY17V4tyv2nN/z5495t577zWdOnUyoaGhJjQ01HTq1Mnce++9Zs+ePV7XMcaYY8eOmX/961/m3XffNfn5+R5teXl5Ztq0aWWq93PlOe/XrFljMjIyjDHGFBUVmenTp5vw8HDj4+NjrrjiCpOSkmKKi4u9qnXu3DnzwAMPmG7duln/XjNmzDB16tQxderUMYMHDza5uble1eK8r/rn/Io890tDICqn6Oho89hjj120ferUqaZDhw5e1YqLizN33nmnKSoqMm6329x7772mUaNG5tNPPzXGlO2Pw+FwmB49ephRo0Z5LD4+PubWW2+11r3hcrnMf//7X2OMMe3btzevv/66R/uqVatMixYtvKoVERFhhZRDhw4ZHx8fs3LlSqt93bp1JjIy0qtaxhizePFi4+fnZwYNGmQWLVpkVq9ebVavXm0WLVpkBg8ebPz9/c0rr7ziVa333nvPOJ1O065dO9O0aVPTqFEjs2nTJqu9LL//mJiYUheHw2HatGljrXsjKirKbN++3RhjzN/+9jfTrFkzs2LFCrNv3z6zcuVK07JlSzNp0iSvat11112mffv25rnnnjM9evQwf/zjH010dLT58MMPzbZt20yXLl3MiBEjvKrFuV915z4vylX3osx5X7XP+RV57l8MgaicAgICzP79+y/avn//fhMQEOBVrQYNGpgDBw54bEtJSTENGjQwH3/8cZn+OF577TVz5ZVXmoULF3ps9/PzK3OCDgsLM2lpacYYY0JCQqw/1gu++OILU6tWLa9q1apVy/pDM+bH/zn+9Mn38OHDpnbt2l6P7eqrrzbPP//8Rdvnz5/v9R9ubGysefjhh40xxhQXF5snn3zS1K1b16xZs8YYU7YnJz8/P9O3b1+TnJxsLVOnTjU+Pj5m3Lhx1jZv/PTJqWXLltZ4LtiyZYtp2rSpV7XCwsLM1q1breNxOBxm3bp1VvuHH35orrjiCq9qce5X3bnPi3LVvShz3lftc35FnvsXQyAqp9atW5unn376ou1PP/20adWqlVe1GjRoYD7//PMS22fPnm3q169vVqxY4fUfhzE/nmi///3vzW233WZOnTpljCnfH8e4cePMzTffbAoLC82YMWPMX//6V49L1ePHjzexsbFe1WrVqpVZtmyZMebH/5k6nU6PP+Bly5aZq6++2uuxuVyuCntyCgwMNF9++aXHtiVLlpg6deqYd955p0xPTh9++KFp3ry5mTJliikqKrK2l+f3HxkZaV2puuKKK8yOHTs82vfu3Wvq1KnjVa3atWubI0eOWOv+/v5m165d1vpXX33ldS3O/ao793lRrroXZc77qn3Or8hz/2IIROX0+uuvGz8/PzNgwAAzb948s2zZMrNs2TIzb948c8sttxin02n+/e9/e1WrW7duZsGCBaW2Pfnkk8blcpXpj8OYH++9T5kyxURERJi1a9caf3//Mv9x5OTkmGuvvda0aNHCDB8+3AQEBJjIyEjTu3dvExUVZYKCgqxbOr/mmWeeMQEBASYuLs40aNDAPPvssyY0NNQ8+OCD5qGHHjJBQUFm+vTpXo/tmmuu+cXbRQ8++KC55pprvKrVpEkT88knn5TY/tprr5natWubBQsWlOn3n5OTYwYNGmS6du1qBa3yPDk9/PDDJjY21pw+fdo89NBDZsCAAebMmTPGGGPOnj1rbr/9dtOnTx+vanXs2NG6orZ69WpTr149jyf3BQsWmPbt23tVi3O/6s59XpSr7kWZ875qn/Mr8ty/GALRb7B161Zzxx13mKZNmxqn02mcTqdp2rSpueOOO6zJsN745z//aYYNG3bR9pkzZ5pmzZqVa4wffPCBiYqKMj4+PuWadFZQUGAWLFhgbrrpJtO6dWvTsmVL06NHD/Pwww+bo0ePlqnWkiVLTGJiolm6dKkxxpj333/fdOvWzXTu3NkkJyd7XFH5Ne+//76pU6eO6dChg5kwYYKZOXOmmTlzppkwYYKJjo42devWNVu2bPGqVu/evc3s2bNLbVu6dKnx9/cv85OTMcYsXLjQhIaGmv/93/8t15NTfn6+ueWWW0yDBg1M7969TUBAgKldu7a5+uqrTZ06dUzTpk1L/A//Yl599VXj6+trWrRoYVwul3njjTdMeHi4uf32282gQYOM0+n8xVuQP8e5XzXnPi/KVfuizHlfdc/5FXnuXwyByAbOnDlj0tPTS7yLpKY7fPiwefDBB0337t1Ny5YtTcuWLU337t3N5MmTzeHDh72us2LFCnP//fdftH3JkiWmZ8+e5RrjF198Ybp06WIcDke53wWxZs0aM27cONO3b1/Tp08fM3LkSPPiiy+avLy8MtX58MMPzVNPPWXNJdqzZ48ZPny4GThwoFm8eHG5xlbdXY7nPi/KVfeiXFNcjue9MRV37l+Mw5hq+glJwGWiuLhYZ86cUWBgoBwOR1UPB7gk8vLydOjQIbVp00ZOp7OqhwP8Kj6YsZI8/PDDuuuuu6hVBbWqGx8fHwUFBdkmDFXX88IOtaqTunXrqmPHjrYJQ9X1nLBDrYpCIKokX3/9tY4cOUKtKqglSSNHjtQNN9xArSqo9c0331TYvyW1yqa6vmDZoVZ1PSfsUEuqmH9LvwoaC37mlVdeoVYV1ZKk8PBw+fhUTN6nVtm8/PLLFVKHWmX39ddf6+uvv6bWJaxljJHD4aiQf0dqlV9F/Fsyh+g3OHnypBYuXKi0tDTr+6BCQ0N1/fXXa9SoUWrSpAm1KqkWAFQHTqdTn3/+udq0aUOtS1yrohGIymnHjh2Kj49X7dq1FRcXp5CQEEk/flnmxo0b9f333+u9997TtddeS60KruWNo0ePaurUqVq4cCG1KqHWDz/8oJ07d6phw4Zq27atR9u5c+f0+uuva8SIEdSqhFr79u3T9u3bFRsbq9atW2v//v2aN2+e8vPzNWzYsDLd+qSW97UmTpxY6vZ58+Zp2LBhatSokSRpzpw51KrgWqU5e/asXn/9dX355ZcKCwvT4MGDrZrl9pvfp2ZTXbt2NWPGjCn1SwaLi4vNmDFjzHXXXUetSqjljfT09HJ9dhC1ft2BAwdMZGSk9cWw3bt39/hi2LJ8wjG1ylZrzZo1xul0moYNG5qAgACzZs0a06RJExMXF2duuOEG4+vrazZu3EitSqjlcDhMp06dTM+ePT0Wh8NhunTpYnr27Gl69epFrUqoZYwxbdq0Md99950xxpjMzEzTrFkzExQUZLp06WIaNmxogoODzVdffeV1vdIQiMopICDA7Nu376Lt+/bt8/pjxKlVtlrGGPPWW2/94vLMM894/SJDrbLVuvXWW03//v3Nt99+aw4ePGj69+9voqKirK9IKMsLPLXKVis2NtY88sgjxpgfP0m9QYMG1vfwGWPMQw89ZHr37k2tSqiVkpJioqKiSgSo8nwaN7XK/tlUDofDZGdnG2OMGTp0qLn++utNTk6OMebHz12Ki4szgwcPLnPdnyIQlVOzZs3Myy+/fNH2l19+2esvDaRW2WoZY6z/bTscjosuZfliSmp5Xys4ONhkZGRY68XFxeaee+4xTZs2NYcOHSrTCzy1ylYrMDDQHDx40Bjz46dC+/n5eXzX165du0xISAi1KqGWMT9+/UfLli3NAw88YAoKCowx5X+Bp1bZ/DQQXXXVVR5fTm3Mjx/aGBERUea6P0UgKqfnn3/euFwuc99995m33nrLbN++3Wzfvt289dZb5r777jO1atUy8+fPp1Yl1DLGmPDwcI9vrf65zz77zOsXGWqVrVa9evXM3r17S2xPSEgwV155pUlNTaVWJdX6+RcR161b1xw6dMhaP3LkSLm/1Jha3jlz5owZMWKEiY6ONrt27SrX15NQq3yB6MSJE8aYH5/Pfvrl1MaU79/y5whEv8GyZctM165djZ+fn/W/bD8/P9O1a1ezfPlyalVirQEDBpjHHnvsou3p6enG4XBQqxJqdenSxbzyyiultiUkJJj69et7/QJPrbLVio6ONmvWrLHWd+3aZc6fP2+tp6ammqioKGpVQq2fe+2110xISEi5v56EWmXjcDhMhw4dTExMjKlbt26J7y3bsmWLueKKK37TGAlEFaCgoMAcO3bMHDt2zLosSK3KrZWamurxRPdzeXl5ZvPmzdSqhFpPPPGE6dev30Xb7733Xq/DFbXKVmvBggVm1apVF21PSkoyo0ePplYl1CrN0aNHzcqVK8v8vYLUKnut5ORkj2Xt2rUe7X/729/MoEGDftP4eNs9AACwPb66AwAA2B6BCAAA2B6BCAAA2B6BCMBloWfPnrr//vu96rt582Y5HA7l5OT8pn02a9ZMc+fO/U01AFQPBCIAAGB7BCIAAGB7BCIAl51//etfuvbaa1WvXj2FhoZqyJAhOnHiRIl+W7duVXR0tAICAnTddddp9+7dHu0ffvihunXrplq1aikiIkL33Xefzp49e6kOA8AlRCACcNk5f/68ZsyYoc8//1wrV67UkSNHNGrUqBL9Jk2apKefflo7duxQkyZNNGDAAJ0/f16SdOjQIfXt21cDBw5URkaGli9frg8//FCJiYmX+GgAXAp+VT0AAKhod911l/XzVVddpWeffVZdunRRXl6e6tata7VNnTpVvXv3liS9/PLLuvLKK/Xmm2/q9ttvV0pKioYOHWpN1L766qv17LPPqkePHlqwYIECAgIu6TEBqFxcIQJw2dm5c6cGDBigpk2bql69eurRo4ckKTMz06NfbGys9XPDhg3VqlUr7du3T5L0+eefa/Hixapbt661xMfHq7i4WIcPH750BwPgkuAKEYDLytmzZxUfH6/4+HgtWbJETZo0UWZmpuLj41VQUOB1nby8PI0dO1b33XdfibamTZtW5JABVAMEIgCXlf379+u7777TzJkzFRERIUn65JNPSu27fft2K9ycPn1aX3zxhdq0aSNJuuaaa7R37161aNHi0gwcQJXilhmAy0rTpk3ldDr13HPP6auvvtLbb7+tGTNmlNp3+vTp2rhxo3bv3q1Ro0apcePGuvXWWyVJkydP1rZt25SYmKj09HQdPHhQb731FpOqgcsUgQjAZaVJkyZavHix3njjDbVt21YzZ87UU089VWrfmTNn6n/+53/UuXNnZWVl6Z133pHT6ZQkRUdHa8uWLfriiy/UrVs3xcTEaMqUKQoPD7+UhwPgEnEYY0xVDwIAAKAqcYUIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADYHoEIAADY3v8HF33sAmx43HYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train = special_value_interpolation(train)\n", + "dev = special_value_interpolation(dev)\n", + "plot_label_count(train, \"train\")\n", + "plot_label_count(dev, \"dev\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "\n", + "def random_sampling(df,SEED):\n", + " # 0.0에서 5.0까지 0.2 간격으로 라벨을 설정\n", + " labels = [round(x * 0.2, 1) for x in range(0, 26)] # 0.0 ~ 5.0 까지\n", + "\n", + " sample_size_per_label = 20 # 각 라벨에서 추출할 개수\n", + " sampled_df_list = []\n", + "\n", + " for label in labels:\n", + " # 각 라벨에 해당하는 데이터 추출\n", + " label_df = df[df[\"label\"] == label]\n", + "\n", + " # 해당 라벨에서 샘플링할 수 있는 데이터가 충분하지 않으면 오류 방지\n", + " if len(label_df) < sample_size_per_label:\n", + " print(f\"라벨 {label}에서 샘플링할 데이터가 부족합니다.\")\n", + " continue\n", + "\n", + " # 각 라벨에서 지정된 개수만큼 무작위로 샘플링 (random_state=42로 고정)\n", + " sampled_label_df = label_df.sample(\n", + " n=sample_size_per_label, random_state=SEED, replace=False\n", + " )\n", + " sampled_df_list.append(sampled_label_df)\n", + "\n", + " # 샘플링된 데이터를 하나의 DataFrame으로 합침\n", + " final_sampled_df = pd.concat(sampled_df_list).reset_index(drop=True)\n", + "\n", + " # 남은 데이터를 하나의 DataFrame으로 합침 (추출되지 않은 데이터들)\n", + " final_remaining_df = df.drop(final_sampled_df.index).reset_index(drop=True)\n", + "\n", + " # 추출한 510개의 데이터와 남은 데이터를 반환\n", + " return final_sampled_df, final_remaining_df" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "new_dev, new_train = random_sampling(train,0)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "new_train = pd.concat([new_train,dev])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def swap_over_zero_label(df):\n", + " \"\"\"sentence 1과 2를 교환한 데이터 추가\"\"\"\n", + " df_swaped = df.rename(\n", + " columns={\"sentence_1\": \"sentence_2\", \"sentence_2\": \"sentence_1\"}\n", + " )\n", + " df_filtered = df_swaped[df_swaped[\"label\"] != 0.0]\n", + "\n", + " return pd.concat([df, df_filtered])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "new_train = swap_over_zero_label(new_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "new_train = new_train.sample(frac=1, random_state=0).reset_index(drop=True)\n", + "new_dev = new_dev.sample(frac=1, random_state=0).reset_index(drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "new_train.to_csv(\"./split_v2_train.csv\")\n", + "new_dev.to_csv(\"./split_v2_dev.csv\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ame", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/utils/preprocess/wordnet.pickle b/utils/preprocess/wordnet.pickle new file mode 100644 index 0000000..5275511 Binary files /dev/null and b/utils/preprocess/wordnet.pickle differ diff --git a/utils/utils.py b/utils/utils.py new file mode 100644 index 0000000..7056ae6 --- /dev/null +++ b/utils/utils.py @@ -0,0 +1,33 @@ +import os +from datetime import datetime + + +def get_experiment_folder_name(CFG): + # 현재 시간 기록 + current_time = datetime.now().strftime("%m%d_%H%M") + + # CFG 값을 가져와서 폴더 이름에 추가 + user_name = CFG["user_name"] + # /로 인한 내부 다른 폴더 생성문제 해결 + model_name = CFG["model"]["model_name"].replace("/", "_") + lr = CFG["train"]["learning_rate"] + batch_size = CFG["train"]["batch_size"] + + # 폴더 이름 생성 + experiment_folder_name = ( + f"{current_time}_{model_name}_lr{lr}_batch{batch_size}({user_name})" + ) + + return experiment_folder_name + + +def create_experiment_folder(CFG, base_path="./experiments"): + + # 월일_시간분_user_name 형식으로 폴더 이름 생성 + experiment_folder_name = get_experiment_folder_name(CFG) + + # experiments 경로에 해당 폴더 생성 + experiment_path = os.path.join(base_path, experiment_folder_name) + os.makedirs(experiment_path, exist_ok=True) + + return experiment_path