Upload folder using huggingface_hub

code/inference.py

@@ -0,0 +1,191 @@
+import os
+import json
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer, AutoConfig
+
+# 모델과 토크나이저를 로드하는 함수
+def model_fn(model_dir):
+    """
+    SageMaker가 모델을 로드하기 위해 호출하는 함수
+    
+    Args:
+        model_dir (str): 모델 파일이 저장된 디렉토리 경로
+        
+    Returns:
+        dict: 모델, 토크나이저, 설정 등을 포함한 딕셔너리
+    """
+    # 환경 변수 설정 (선택 사항)
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    
+    # 설정 파일 로드
+    config_path = os.path.join(model_dir, "config.json")
+    config = AutoConfig.from_pretrained(config_path)
+    
+    print(f"Loading model from {model_dir}")
+    print(f"Device: {'cuda' if torch.cuda.is_available() else 'cpu'}")
+    
+    # 레이블 매핑 로드 (있는 경우)
+    label_map = {}
+    label_map_path = os.path.join(model_dir, "label_map.json")
+    if os.path.exists(label_map_path):
+        with open(label_map_path, 'r', encoding='utf-8') as f:
+            label_map = json.load(f)
+        print(f"Loaded label map from {label_map_path}")
+    else:
+        print("No label map found. Using numeric indices as labels.")
+    
+    # 모델 로드
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_dir, 
+        config=config,
+        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+    )
+    
+    # GPU 사용 가능한 경우 모델을 GPU로 이동
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+    model.eval()
+    
+    # 토크나이저 로드
+    tokenizer = AutoTokenizer.from_pretrained(model_dir)
+    
+    return {
+        "model": model,
+        "tokenizer": tokenizer,
+        "config": config,
+        "device": device,
+        "label_map": label_map
+    }
+
+# 입력 데이터 처리 함수
+def input_fn(request_body, request_content_type):
+    """
+    SageMaker가 요청 데이터를 처리하기 위해 호출하는 함수
+    
+    Args:
+        request_body: 요청 본문 데이터
+        request_content_type (str): 요청 콘텐츠 타입
+        
+    Returns:
+        dict: 처리된 입력 데이터
+    """
+    if request_content_type == "application/json":
+        input_data = json.loads(request_body)
+        
+        # 문자열인 경우 텍스트로 처리
+        if isinstance(input_data, str):
+            return {"text": input_data}
+        
+        return input_data
+    
+    elif request_content_type == "text/plain":
+        # 일반 텍스트 처리
+        return {"text": request_body.decode('utf-8')}
+    
+    else:
+        raise ValueError(f"지원되지 않는 콘텐츠 타입: {request_content_type}")
+
+# 예측 함수
+def predict_fn(input_data, model_dict):
+    """
+    SageMaker가 모델 예측을 수행하기 위해 호출하는 함수
+    
+    Args:
+        input_data (dict): 처리된 입력 데이터
+        model_dict (dict): model_fn에서 반환한 모델 정보
+        
+    Returns:
+        dict: 예측 결과
+    """
+    model = model_dict["model"]
+    tokenizer = model_dict["tokenizer"]
+    device = model_dict["device"]
+    label_map = model_dict["label_map"]
+    
+    # 입력 텍스트 가져오기
+    if "text" in input_data:
+        text = input_data["text"]
+    else:
+        raise ValueError("입력 데이터에 'text' 필드가 없습니다")
+    
+    # 토큰화 옵션
+    max_length = input_data.get("max_length", 512)
+    padding = input_data.get("padding", "max_length")
+    truncation = input_data.get("truncation", True)
+    
+    # 토큰화
+    inputs = tokenizer(
+        text,
+        return_tensors="pt",
+        padding=padding,
+        truncation=truncation,
+        max_length=max_length
+    )
+    
+    # 입력 텐서를 디바이스로 이동
+    inputs = {name: tensor.to(device) for name, tensor in inputs.items()}
+    
+    # 모델 추론
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probabilities = torch.softmax(logits, dim=1)
+    
+    # 이진 분류 모델인 경우 (클래스 수가 2인 경우)
+    if logits.shape[1] == 2:
+        positive_prob = probabilities[0, 1].item()
+        negative_prob = probabilities[0, 0].item()
+        prediction = 1 if positive_prob > 0.5 else 0
+        
+        result = {
+            "prediction": prediction,
+            "positive_probability": positive_prob,
+            "negative_probability": negative_prob
+        }
+        
+        # 레이블 매핑이 있는 경우 레이블 추가
+        if label_map:
+            pred_label = str(prediction)
+            if pred_label in label_map:
+                result["label"] = label_map[pred_label]
+    
+    # 다중 클래스 모델인 ���우
+    else:
+        predictions = torch.argmax(probabilities, dim=1).cpu().numpy().tolist()
+        probabilities = probabilities.cpu().numpy().tolist()[0]
+        
+        result = {
+            "prediction": predictions[0],
+            "probabilities": probabilities,
+        }
+        
+        # 레이블 매핑이 있는 경우 레이블 추가
+        if label_map:
+            pred_label = str(predictions[0])
+            if pred_label in label_map:
+                result["label"] = label_map[pred_label]
+            
+            # 모든 레이블에 대한 확률 매핑 추가
+            result["label_probabilities"] = {
+                label_map.get(str(idx), str(idx)): prob 
+                for idx, prob in enumerate(probabilities)
+            }
+    
+    return result
+
+# 출력 데이터 처리 함수
+def output_fn(prediction, response_content_type):
+    """
+    SageMaker가 예측 결과를 응답 형식으로 변환하기 위해 호출하는 함수
+    
+    Args:
+        prediction: predict_fn에서 반환한 예측 결과
+        response_content_type (str): 원하는 응답 콘텐츠 타입
+        
+    Returns:
+        str: 직렬화된 예측 결과
+    """
+    if response_content_type == "application/json":
+        return json.dumps(prediction, ensure_ascii=False)
+    else:
+        raise ValueError(f"지원되지 않는 콘텐츠 타입: {response_content_type}")

code/requirement.txt

@@ -0,0 +1,5 @@
+torch>=1.13.0
+transformers>=4.26.0
+numpy>=1.23.5
+scikit-learn>=1.0.2
+protobuf>=3.20.0,<4.0.0

config.json

@@ -0,0 +1,27 @@
+{
+  "_name_or_path": "bert-base-uncased",
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "torch_dtype": "float32",
+  "transformers_version": "4.49.0",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer_config.json

@@ -0,0 +1,56 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}