0708

.gitignore

@@ -0,0 +1 @@
+*.ipynb

app.py

@@ -1,7 +1,90 @@
 import gradio as gr
+from models import *
+from huggingface_hub import hf_hub_download
+import os
+from config import *
+device = torch.device('cuda' if torch.cuda.is_available() else "cpu")
+
+ENTITY_REPO_ID = 'cccornflake/absa_v2_entity'
+ENTITY_FILENAME = "entity_model.pt"
+
+SENTIMENT_REPO_ID = 'cccornflake/absa_v2_sentiment'
+SENTIMENT_FILENAME = "sentiment_model.pt"
+
+print("downloading model...")
+sen_model_file = hf_hub_download(repo_id=SENTIMENT_REPO_ID, filename=SENTIMENT_FILENAME)
+entity_model_file = hf_hub_download(repo_id=ENTITY_REPO_ID, filename=ENTITY_FILENAME)
+
+base_model = cfg.base_model
+
+tokenizer = AutoTokenizer.from_pretrained(base_model)
+
+sen_model = Classifier(base_model, num_labels=2, device=device, tokenizer=tokenizer)
+sen_model.load_state_dict(torch.load(sen_model_file))
+
+entity_model = Classifier(base_model, num_labels=2, device=device, tokenizer=tokenizer)
+entity_model.load_state_dict(torch.load(entity_model_file))
+
+
+def infer(test_sentence):
+    entity_model.to(device)
+    entity_model.eval()
+    sen_model.to(device)
+    sen_model.eval()
+    
+    form = test_sentence
+    annotation = []
+    
+    if len(form) > 500:
+        return "Too long sentence!"
+    
+    
+    for pair in entity_property_pair:  
+        
+        form_ = form + "[SEP]"   
+        pair_ = entity2str[pair] + "[SEP]"
+        
+        tokenized_data = tokenizer(form_, pair_, padding='max_length', max_length=512, truncation=True)
+        
+        input_ids = torch.tensor([tokenized_data['input_ids']]).to(device)
+        attention_mask = torch.tensor([tokenized_data['attention_mask']]).to(device)
+        
+        first_sep = tokenized_data['input_ids'].index(2)
+        last_sep = tokenized_data['input_ids'][first_sep+2:].index(2) + (first_sep + 2)        
+        mask = [0] * len(tokenized_data['input_ids'])        
+        for i in range(first_sep + 2, last_sep):
+            mask[i] = 1     
+        mask = torch.tensor([mask]).to(device)
+                
+        with torch.no_grad():
+            outputs = entity_model(input_ids, attention_mask, mask)
+        ce_logits = outputs
+        ce_predictions = torch.argmax(ce_logits, dim = -1)
+
+        ce_result = tf_id_to_name[ce_predictions[0]]
+
+        if ce_result == 'True':
+            with torch.no_grad():
+                outputs = sen_model(input_ids, attention_mask, mask)
+            pc_logits = outputs
+            pc_predictions = torch.argmax(pc_logits, dim=-1)
+            pc_result = polarity_id_to_name[pc_predictions[0]]
+
+            annotation.append(f"{pair} - {pc_result}")
+            
+    result = '\n'.join(annotation)
+    return result
+
+article = "**이미지를 업로드하세요.**" \
+    
+demo = gr.Interface(fn=infer,
+             inputs=gr.Textbox(type="text", label="Input Sentence"),
+             outputs=gr.Textbox(type="text", label="Result Sentence")
+            #  examples=[image_path,]
+             )
+
+demo.launch(share=True)
+
+
 
-def greet(name):
-    return "Hello " + name + "!!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()

config.py

@@ -0,0 +1,14 @@
+base_model = 'beomi/KcELECTRA-base'
+
+entity_property_pair =['주차#일반', '편의시설#마트', '편의시설#쇼핑', '학군#일반', '학군#학교 접근성', '학군#학원 접근성', 
+'학군#양육 환경', '인프라#일반', '인프라#상권', '인프라#교통', '인프라#병원', '인프라#대중교통', '환경#일반', '환경#소음', '편의시설#일반',
+'환경#공원', '환경#단지 관리', '환경#뷰', '환경#조경', '환경#관리비', '구조#집 구조', '가격#시세', '전망#일반', '학군#유치원']
+
+entity2str = dict(zip(entity_property_pair, map(lambda x: x.replace("#", ", ").replace("/", ", "), entity_property_pair)))
+
+
+tf_id_to_name = ['True', 'False']
+tf_name_to_id = {tf_id_to_name[i]: i for i in range(len(tf_id_to_name))}
+
+polarity_id_to_name = ['positive', 'negative']
+polarity_name_to_id = {polarity_id_to_name[i]: i for i in range(len(polarity_id_to_name))}

flagged/log.csv

@@ -0,0 +1,2 @@
+Input Sentence,Result Sentence,flag,username,timestamp
+hello,hello,,,2024-07-08 13:41:38.124456

models.py

@@ -0,0 +1,71 @@
+import json
+import os
+import numpy as np
+import torch
+import torch.nn as nn
+from tqdm import trange
+from transformers import ElectraModel, AutoTokenizer, AutoModel
+from transformers import AutoTokenizer, AutoConfig
+from torch.utils.data import DataLoader, TensorDataset
+from transformers import get_linear_schedule_with_warmup
+from transformers import AdamW
+from datasets import load_metric
+from sklearn.metrics import f1_score
+import pandas as pd
+import copy 
+# from utils import evaluation, evaluation_f1
+from torch.nn import functional as F
+import re
+from config import entity_property_pair
+from tqdm import tqdm
+from datasets import Dataset
+import torch.nn as nn
+from transformers import AutoModelForSequenceClassification
+from transformers import ElectraModel
+
+
+
+class Classifier(nn.Module):
+    def __init__(self, base_model, num_labels, device, tokenizer):
+        super(Classifier, self).__init__()
+        self.num_labels = num_labels
+        self.device = device
+                
+        self.electra = ElectraModel.from_pretrained('beomi/KcELECTRA-base', num_labels=2)
+        self.electra.resize_token_embeddings(len(tokenizer))    
+        
+        self.fc1 = nn.Linear(self.electra.config.hidden_size, 256)
+        self.fc2 = nn.Linear(self.electra.config.hidden_size, 512)
+        self.fc3 = nn.Linear(256+512, 2)
+        
+        self.dropout = nn.Dropout(0.1)
+        
+
+    def forward(self, input_ids, attention_mask, entity_mask):
+  
+                
+        outputs = self.electra(input_ids=input_ids, attention_mask=attention_mask, output_hidden_states=True)
+        last_hidden_state  = outputs.last_hidden_state  
+        
+        masked_last_hidden = self.entity_average(last_hidden_state, entity_mask)
+        masked_last_hidden = self.fc2(masked_last_hidden)       
+        
+        last_hidden_state = self.fc1(last_hidden_state)         
+        entity_outputs = torch.cat([last_hidden_state[:, 0, :]  , masked_last_hidden], dim=-1)        
+         
+        outputs = torch.tanh(entity_outputs)
+        outputs = self.dropout(outputs)
+        outputs = self.fc3(outputs)
+        
+
+        return outputs
+    
+    @staticmethod    
+    def entity_average(hidden_output, e_mask):        
+        e_mask_unsqueeze = e_mask.unsqueeze(1)  # [b, 1, j-i+1]
+        length_tensor = (e_mask != 0).sum(dim=1).unsqueeze(1)  # [batch_size, 1]
+
+        # [b, 1, j-i+1] * [b, j-i+1, dim] = [b, 1, dim] -> [b, dim]
+        sum_vector = torch.bmm(e_mask_unsqueeze.float(), hidden_output).squeeze(1)
+        avg_vector = sum_vector.float() / length_tensor.float()  # broadcasting
+        return avg_vector