2_Relation_Extraction-master/ex.py

#%%
import pandas as pd
import pickle
import torch

# 처음 불러온 tsv 파일을 원하는 형태의 DataFrame으로 변경 시켜줍니다.
# 변경한 DataFrame 형태는 baseline code description 이미지를 참고해주세요.
def preprocessing_dataset(dataset, label_type):
	label = []
	for i in dataset[8]:
		if i == 'blind':
			label.append(100)
		else:
			label.append(label_type[i])
	entity_1_span = []
	for s,e in zip(dataset[3].values, dataset[4].values):
		entity_1_span.append([s,e])
	entity_2_span = []
	for s,e in zip(dataset[6].values, dataset[7].values):
		entity_2_span.append([s,e])
	out_dataset = pd.DataFrame({'sentence':dataset[1],
								'entity_01':dataset[2],
								'entity_01_span': entity_1_span,
								'entity_02':dataset[5],
								'entity_02_span': entity_2_span,
								'label':label})
	return out_dataset

# tsv 파일을 불러옵니다.
def load_data(dataset_dir):
	# load label_type, classes
	with open('/opt/ml/input/data/label_type.pkl', 'rb') as f:
		label_type = pickle.load(f)
	# load dataset
	dataset = pd.read_csv(dataset_dir, delimiter='\t', header=None)
	# preprecessing dataset
	dataset = preprocessing_dataset(dataset, label_type)
	
	return dataset

# %%
from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-multilingual-cased")
# %%
# df = pd.read_csv('/opt/ml/input/data/train/train_folds.tsv', delimiter=',')
df = load_data('/opt/ml/input/data/train/train.tsv')
#%%
# tokenizer.tokenize((df.loc[1].sentence))
tokenizer.add_special_tokens({'additional_special_tokens':['[ENT1]', '[ENT2]']})
#%%
def string_replace(string, idx_s, idx_e, replace_word):
    return string[:idx_s] + replace_word + string[idx_e+1:]

# for _, row in df.iterrows():
#     e1_s, e1_e = row.entity_01_span[0], row.entity_01_span[1]
#     e2_s, e2_e = row.entity_02_span[0], row.entity_02_span[1]
#     sentence = row.sentence
#     # print(sentence)
#     # print(row.entity_01)
#     # print(row.entity_02)
#     sentence = string_replace(sentence, e1_s, e1_e, '[E1]')
#     sentence = string_replace(sentence, e2_s, e2_e, '[E2]')
    # print(sentence)
# %%
def tokenized_dataset(dataset, tokenizer):
	concat_entity = []
	for _, row in dataset.iterrows():
		e1_s, e1_e = row.entity_01_span[0], row.entity_01_span[1]
		e2_s, e2_e = row.entity_02_span[0], row.entity_02_span[1]
		sentence = row.sentence
		# print(sentence)
		# print(row.entity_01)
		# print(row.entity_02)
		sentence = string_replace(sentence, e1_s, e1_e, '[ENT1]')
		sentence = string_replace(sentence, e2_s, e2_e, '[ENT2]')
		concat_entity.append(sentence)
	tokenized_sentences = tokenizer(
			concat_entity,
			return_tensors="pt", # 2차원 배열로 나온다.
			padding=True,
			truncation=True,
			max_length=100,
			add_special_tokens=True, #문장 맨앞, 맨뒤에 [CLS] [SEP]를 넣을지 말지를 정해줌
			)
	return tokenized_sentences
# %%
tokenized_train = tokenized_dataset(df, tokenizer)
#%%
print(tokenized_train['input_ids'][0])
print(tokenizer.decode(tokenized_train['input_ids'][0]))
# %%
class RE_Dataset(torch.utils.data.Dataset):
	def __init__(self, tokenized_dataset, labels):
		self.tokenized_dataset = tokenized_dataset
		self.labels = labels

	def __getitem__(self, idx):
		item = {key: val[idx].clone().detach() for key, val in self.tokenized_dataset.items()}
		item['labels'] = torch.tensor(self.labels[idx])
		return item

	def __len__(self):
		return len(self.labels)
# %%
# RE_Dataset 을 통과하면 return dictionary에 'labels' key가 하나 더 붙는게 끝
# 추가로 index별로 나뉜다.
RE_train_dataset = RE_Dataset(tokenized_train, df['label'].values)
# %%
tokenized_sentence = RE_train_dataset[0]['input_ids']
decoded_sentence = tokenizer.decode(tokenized_sentence)
# %%
from torch.utils.data import DataLoader

train_loader = DataLoader(RE_train_dataset,
                              batch_size=2,
                              num_workers=1,
                              pin_memory=True,
                              shuffle=True)
# %%
model.resize_token_embeddings(len(tokenizer))




import argparse
from data_loader.create_folds import stratified_kfold
from pprint import pprint
from tqdm import tqdm
import random
import os

from sklearn.metrics import accuracy_score
from sklearn.model_selection import StratifiedKFold, train_test_split
import numpy as np
import torch
from torch.utils.data import DataLoader
import torch.nn as nn
from transformers import AutoTokenizer, AdamW

from model.model import MultilabeledSequenceModel
from config import YamlConfigManager
from data_loader.load_data import *
from trainer.trainer import Trainer 

import optuna
from optuna.visualization import plot_parallel_coordinate
import os
os.environ["TOKENIZERS_PARALLELISM"] = "false"
# 시드 고정
def seed_everything(seed: int = 42):
    random.seed(seed)
    np.random.seed(seed)
    os.environ["PYTHONHASHSEED"] = str(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)  # type: ignore
    torch.backends.cudnn.deterministic = True  # type: ignore
    torch.backends.cudnn.benchmark = True  # type: ignore

def hp_search(trial, cfg):
    params = {
        'lr': trial.suggest_loguniform("lr", 1e-7, 1e-4),
        'batch_size': trial.suggest_categorical("batch_size", [1, 2]),
        'dropout': trial.suggest_float("dropout", 0.5, 0.7)
    }
    all_acc= []
    for fold in range(5):
        temp_acc = train(fold, params, cfg)
        all_acc.append(temp_acc)
        trial.report(temp_acc, fold)
        if trial.should_prune():
            raise optuna.TrialPruned()

    return np.mean(all_acc)

def train(fold, params, cfg, save_model=False):
    print('\n'+ '='*30 + f' {fold} FOLD TRAINING START!! ' + '='*30+ '\n')
    
    seed_everything(cfg.values.seed)
    MODEL_NAME = cfg.values.model_name
    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)

    df = pd.read_csv('/opt/ml/input/data/train/train_folds.tsv', delimiter=',')
    train_df = df[df.kfold != fold].reset_index(drop=True)
    valid_df = df[df.kfold == fold].reset_index(drop=True)

    tokenized_train = tokenized_dataset(train_df, tokenizer)
    tokenized_val = tokenized_dataset(valid_df, tokenizer)

    RE_train_dataset = RE_Dataset(tokenized_train, train_df['label'].values)
    RE_val_dataset = RE_Dataset(tokenized_val, valid_df['label'].values)

    train_loader = DataLoader(RE_train_dataset,
                              batch_size=params['batch_size'],
                              num_workers=cfg.values.train_args.num_workers,
                              pin_memory=True,
                              shuffle=True)
    
    valid_loader = DataLoader(RE_val_dataset,
                              batch_size=cfg.values.train_args.batch_size,
                              num_workers=cfg.values.train_args.num_workers,
                              pin_memory=True,
                              shuffle=False)
    
    model = MultilabeledSequenceModel(MODEL_NAME, 42, params['dropout']).to(device)
    optimizer = AdamW(params=model.parameters(), lr=params['lr'])
    loss = nn.CrossEntropyLoss()
    model_set = {
        'model': model,
        'loss': loss,
        'optimizer': optimizer
    }
    best_acc = -np.inf
    trainer = Trainer(model_set, device, cfg)
    early_stopping = 3
    early_stopping_counter = 0
    for epoch in range(cfg.values.train_args.num_epochs):
        train_loss = trainer.train_epoch(train_loader)
        val_acc = trainer.evaluate_epoch(valid_loader)
        print(f'FOLD: {fold}, EPOCH: {epoch}, TRAIN_LOSS: {train_loss:.3f}, VAL_ACC: {val_acc:.3f}')
        if val_acc > best_acc: 
            best_acc = val_acc
            if save_model:
                torch.save(model.state_dict(), f'model_{fold}.bin')
        else:
            early_stopping_counter += 1
        
        if early_stopping_counter > early_stopping:
            break
    return best_acc

def main(cfg):
    # stratified_kfold(cfg)
    USE_KFOLD = cfg.values.val_args.use_kfold     
    if USE_KFOLD:
        objective = lambda trial: hp_search(trial, cfg)
        study = optuna.create_study(direction='maximize')
        study.optimize(objective, n_trials=20)
    
        best_trial = study.best_trial
        print(f'best acc : {best_trial.values}')
        print(f'best acc : {best_trial.params}')
        # params = {
        #     'batch_size': 1,
        #     'lr': 1.61e-06,
        #     'dropout': 0.633
        # }
        scores = 0
        for j in range(5):
            scr = train(j, best_trial.params, cfg, save_model=True)  #best_trial.params
            scores += scr

        print(scores / 5)
        df = study.trials_dataframe(attrs=("number", "value", "params", "state"))
        df.to_csv('./hpo_result.csv')
        plot_parallel_coordinate(study)
    
    else:
        # train_df = whole_df[whole_df.kfold != 0].reset_index(drop=True)
        # valid_df = whole_df[whole_df.kfold == 0].reset_index(drop=True)

        # tokenized_train = tokenized_dataset(train_df, tokenizer)
        # tokenized_val = tokenized_dataset(valid_df, tokenizer)

        # RE_train_dataset = RE_Dataset(tokenized_train, train_df['label'].values)
        # RE_val_dataset = RE_Dataset(tokenized_val, valid_df['label'].values)
        # dataset = {
        #     'train': RE_train_dataset,
        #     'valid': RE_val_dataset
        # }

        # objective = lambda trial: hp_search(trial,
        #                                     model_name=MODEL_NAME,
        #                                     dataset=dataset,
        #                                     label_nbr=42,
        #                                     metric_name='accuracy',
        #                                     device=device)
        # study = optuna.create_study(direction='maximize')
        # study.optimize(objective, timeout=1800)
        pass

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--config_file_path', type=str, default='./config.yml')
    parser.add_argument('--config', type=str, default='base')
    args = parser.parse_args()

    cfg = YamlConfigManager(args.config_file_path, args.config)
    pprint(cfg.values)
    print('\n')
    main(cfg)