[DACON] 해커톤 경진대회 회고

# csv파일 불러오기
train = pd.read_csv('./train.csv') 
test = pd.read_csv('./test.csv')    

# 분류해야 할 클래스의 데이터 분포 수 확인하기
category_counts = train['분류'].value_counts()

import random

class_counts = train['분류'].value_counts()

# 단어 순서를 랜덤하게 바꾸는 함수
def random_swap(text, n):
    words = text.split()
    new_words = words.copy()
    
    for _ in range(n):
        # 무작위로 세 개의 단어 위치를 교환
        idx1, idx2, idx3 = random.choices(range(len(new_words)), k=3)
        new_words[idx1], new_words[idx2], new_words[idx3] = new_words[idx3], new_words[idx1], new_words[idx2]
    
    return ' '.join(new_words)

# 소수 클래스에 대해 데이터 증강 적용
new_data = []
for category, count in class_counts.items():
    category_data = train[train['분류'] == category]
    
    if count < 200:
        # 데이터 증강 적용하여 텍스트 변형
        augmented_texts = []
        augmented_keywords = []
        for i in range(200 - count):  # 200개가 될 때까지 증강
            text = random.choice(category_data['제목'].tolist())          
            augmented_text = random_swap(text, 2)            
            
            keywords = random.choice(category_data['키워드'].tolist())
            augmented_keyword = random_swap(keywords, 2)
            
            augmented_texts.append(augmented_text)
            augmented_keywords.append(augmented_keyword)
        
        # 증강된 데이터를 DataFrame으로 추가
        augmented_df = pd.DataFrame({
            '제목': augmented_texts,
            '키워드': augmented_keywords,
            '분류': [category] * len(augmented_texts)
        })
        category_data_resampled = pd.concat([category_data, augmented_df])
        new_data.append(category_data_resampled)
    else:
        new_data.append(category_data)

# 데이터 결합
balanced_train = pd.concat(new_data)

# 결과 확인
balanced_train['분류'].value_counts(), len(balanced_train['분류'].unique())

# '지역' 카테고리를 제외한 나머지 데이터
other_categories = balanced_train[balanced_train['분류'] != '지역']
# '지역' 카테고리의 데이터에서 25%만 샘플링
region_category = balanced_train[balanced_train['분류'] == '지역']
region_sample = region_category.sample(frac=0.25, random_state=42)
balanced_train = pd.concat([other_categories, region_sample])
print(balanced_train['분류'].value_counts())

def preprocess_text(text):
    text = text.split(',')
    text = [re.sub(r'[^가-힣\s]', ' ', x) for x in text]
    return ' '.join(text)
    
balanced_train['processed_title'] = balanced_train['제목'].apply(preprocess_text) 
balanced_train['processed_keywords'] = balanced_train['키워드'].apply(preprocess_text)

test['제목_키워드'] = (test['제목'] + " " + test['키워드']).apply(preprocess_text)

from collections import Counter

keywords = balanced_train['processed_keywords']
keywords = keywords.tolist()
keyword_counts = Counter(keywords)

sorted_keyword_dict = sorted(keyword_dict.items(), key = lambda x:x[1])
sorted_keyword_dict_len = len(sorted_keyword_dict)

# 자주 사용되는 상위 30% 키워드만 추출하기 위한 배열
sorted_keyword = sorted_keyword_dict[int(sorted_keyword_dict_len * 0.7) :]
sorted_keyword = dict(sorted_keyword_dict).keys()

config = {
    "learning_rate": 1e-5, 
    "epoch": 50,
    "batch_size": 64,
    "weight_decay": 0.01,
    "tokenizer_max_len": 128,
}

CFG = SimpleNamespace(**config)

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
tokenizer = AutoTokenizer.from_pretrained("monologg/kobigbird-bert-base")  # BertTokenizer
model = BigBirdForSequenceClassification.from_pretrained(
    'monologg/kobigbird-bert-base', 
    num_labels=len(train['분류'].unique())
).to(device)

# 레이블 인코딩
label_encoder = {label: i for i, label in enumerate(balanced_train['분류'].unique())}
balanced_train['label'] = balanced_train['분류'].map(label_encoder)

# 데이터 분할 (train -> train + validation)
train_df, val_df = train_test_split(balanced_train, test_size=0.2, stratify=balanced_train['분류'], random_state=42)

# 데이터셋 생성
train_dataset = TextDataset(train_df.제목_키워드.tolist(), train_df.label.tolist(), tokenizer, max_len=CFG.tokenizer_max_len, preprocess_datarows=True)
val_dataset = TextDataset(val_df.제목_키워드.tolist(), val_df.label.tolist(), tokenizer,  max_len=CFG.tokenizer_max_len, preprocess_datarows=True)
test_dataset = TextDataset(test.제목_키워드.tolist(), None, tokenizer) 

# 데이터 로더 생성
train_loader = DataLoader(train_dataset, batch_size=CFG.batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=CFG.batch_size, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=CFG.batch_size, shuffle=False)