Upload folder using huggingface_hub

README.md

@@ -1,46 +1,126 @@
-# LongEmotion 比赛核心文件
+# Emotion Detection Model - LongEmotion
 
-## 📁 文件结构
+情感检测模型，基于BERT的中文情感分类器
 
-### model/
-- `best_model.pt` - 训练好的BERT模型（验证准确率91.47%）
+## 📊 模型信息
 
-### test_data/
-- `test.jsonl` - 比赛测试集（136个样本）
+- **基础模型**: bert-base-chinese
+- **任务类型**: 6分类情感检测
+- **验证准确率**: 91.47%
+- **框架**: PyTorch + Transformers
 
-### scripts/
-- `run_inference_final.py` - 推理运行脚本
-- `inference_longemotion.py` - 推理核心逻辑
-- `convert_submission_format.py` - 格式转换脚本
-- `detection_model.py` - 模型定义
+## 🏷️ 情感类别
 
-### submission/
-- `submission.jsonl` - 提交文件（格式: {"id": 0, "predicted_index": 24}）
-- `Emotion_Detection_Result.jsonl` - 备份提交文件
+模型可以识别以下6种情感：
+- `sadness` (悲伤)
+- `joy` (快乐)
+- `love` (爱)
+- `anger` (愤怒)
+- `fear` (恐惧)
+- `surprise` (惊讶)
 
-### reports/
-- 项目进度报告和自查报告
+## 📁 文件说明
 
-## 🚀 使用方法
+```
+detection_hug/
+├── model.pt                      # 模型权重文件
+├── config.json                   # 模型配置
+├── tokenizer_config.json         # 分词器配置
+├── vocab.txt                     # 词表
+├── special_tokens_map.json       # 特殊符号映射
+├── detection_model.py            # 模型定义
+├── inference_example.py          # 推理示例
+└── README.md                     # 本文件
+```
+
+## 🚀 快速开始
+
+### 环境要求
 
-### 运行推理
 ```bash
-# 从Detection文件夹内运行
-cd Detection
-python scripts/run_inference_final.py
+pip install torch transformers
+```
+
+### 基本使用
+
+```python
+import torch
+from transformers import BertTokenizer
+from detection_model import EmotionDetectionModel
+
+# 1. 加载分词器
+tokenizer = BertTokenizer.from_pretrained(".")
+
+# 2. 加载模型
+model = EmotionDetectionModel(
+    model_name="bert-base-chinese",
+    num_emotions=6
+)
+checkpoint = torch.load("model.pt", map_location="cpu")
+model.load_state_dict(checkpoint)
+model.eval()
+
+# 3. 预测
+text = "我今天很开心！"
+encoding = tokenizer(text, return_tensors='pt', max_length=512, truncation=True, padding=True)
+outputs = model(**encoding)
+predicted_emotion = torch.argmax(outputs['logits'], dim=-1).item()
+
+# 情感映射
+emotions = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+print(f"预测情感: {emotions[predicted_emotion]}")
 ```
 
-### 转换格式（可选）
+### 使用推理脚本
+
 ```bash
-# 从Detection/scripts文件夹内运行
-cd Detection/scripts
-python convert_submission_format.py
+python inference_example.py
+```
+
+## 📈 模型性能
+
+- **数据集**: dair-ai/emotion (中文情感数据)
+- **验证准确率**: 91.47%
+- **平均置信度**: 89.27%
+- **最大序列长度**: 512 tokens
+
+## 🔧 技术细节
+
+### 模型架构
+
+```
+EmotionDetectionModel
+├── BERT Encoder (bert-base-chinese)
+│   └── 768-dim hidden states
+├── Dropout (p=0.1)
+├── Linear Layer (768 → 384)
+├── ReLU Activation
+├── Dropout (p=0.1)
+└── Output Layer (384 → 6)
+```
+
+### 训练参数
+
+- **优化器**: AdamW
+- **学习率**: 2e-5
+- **批次大小**: 16
+- **最大长度**: 512
+
+## 📝 引用
+
+如果您使用此模型，请注明：
+```
+LongEmotion Detection Model
+- 基于 bert-base-chinese
+- 训练于 dair-ai/emotion 数据集
 ```
 
-## 📊 模型性能
-- 验证准确率: 91.47%
-- 平均预测置信度: 89.27%
-- 推理时间: ~5-10分钟/136样本
+## 📧 联系方式
+
+如有问题，请通过项目仓库联系。
+
+---
+
+**License**: 遵循 bert-base-chinese 的许可协议
+**Created**: 2025
 
-## 📝 提交
-提交文件: `submission/submission.jsonl`

config.json

@@ -0,0 +1,34 @@
+{
+    "model_type": "bert-emotion-detection",
+    "base_model": "bert-base-chinese",
+    "architecture": "EmotionDetectionModel",
+    "task": "emotion-classification",
+    "num_emotions": 6,
+    "emotion_labels": {
+        "0": "sadness",
+        "1": "joy",
+        "2": "love",
+        "3": "anger",
+        "4": "fear",
+        "5": "surprise"
+    },
+    "model_params": {
+        "hidden_size": 768,
+        "dropout": 0.1,
+        "classifier_architecture": "two-layer-mlp",
+        "intermediate_size": 384
+    },
+    "training_info": {
+        "dataset": "dair-ai/emotion",
+        "max_length": 512,
+        "validation_accuracy": 0.9147,
+        "framework": "pytorch"
+    },
+    "inference": {
+        "max_length": 512,
+        "batch_size": 16,
+        "device": "cuda or cpu"
+    },
+    "version": "1.0",
+    "created_by": "LongEmotion Detection Task"
+}

detection_model.py

@@ -0,0 +1,238 @@
+"""
+情感检测模型
+Emotion Detection Task
+多标签分类任务
+"""
+import torch
+import torch.nn as nn
+from transformers import (
+    BertModel,
+    BertTokenizer,
+    AutoModel,
+    AutoTokenizer
+)
+from typing import Dict, List, Optional
+
+
+class EmotionDetectionModel(nn.Module):
+    """情感检测模型（多标签分类）"""
+    
+    def __init__(
+        self,
+        model_name: str = "bert-base-chinese",
+        num_emotions: int = 7,
+        dropout: float = 0.1
+    ):
+        """
+        初始化检测模型
+        
+        Args:
+            model_name: 预训练模型名称
+            num_emotions: 情感类别数量
+            dropout: Dropout 比率
+        """
+        super().__init__()
+        
+        self.bert = AutoModel.from_pretrained(model_name)
+        hidden_size = self.bert.config.hidden_size
+        
+        # 多标签分类头
+        self.classifier = nn.Sequential(
+            nn.Dropout(dropout),
+            nn.Linear(hidden_size, hidden_size // 2),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_size // 2, num_emotions)
+        )
+        
+        self.num_emotions = num_emotions
+    
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        labels: Optional[torch.Tensor] = None
+    ):
+        """
+        前向传播
+        
+        Args:
+            input_ids: 输入ID
+            attention_mask: 注意力掩码
+            labels: 标签（多标签，形状为 [batch_size, num_emotions]）
+            
+        Returns:
+            模型输出
+        """
+        outputs = self.bert(
+            input_ids=input_ids,
+            attention_mask=attention_mask
+        )
+        
+        # 使用 [CLS] token 的表示
+        pooled_output = outputs.last_hidden_state[:, 0, :]
+        
+        # 分类
+        logits = self.classifier(pooled_output)
+        
+        loss = None
+        if labels is not None:
+            # 使用 BCE Loss 进行多标签分类
+            loss_fct = nn.BCEWithLogitsLoss()
+            loss = loss_fct(logits, labels.float())
+        
+        return {
+            'loss': loss,
+            'logits': logits
+        }
+
+
+class EmotionDetectionModelWrapper:
+    """情感检测模型封装器"""
+    
+    def __init__(
+        self,
+        model_name: str = "bert-base-chinese",
+        num_emotions: int = 7,
+        max_length: int = 512,
+        device: str = "cuda" if torch.cuda.is_available() else "cpu",
+        threshold: float = 0.5
+    ):
+        """
+        初始化
+        
+        Args:
+            model_name: 预训练模型名称
+            num_emotions: 情感类别数量
+            max_length: 最大序列长度
+            device: 设备
+            threshold: 分类阈值
+        """
+        self.model_name = model_name
+        self.num_emotions = num_emotions
+        self.max_length = max_length
+        self.device = device
+        self.threshold = threshold
+        
+        # 加载分词器
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        
+        # 加载模型
+        self.model = EmotionDetectionModel(
+            model_name=model_name,
+            num_emotions=num_emotions
+        ).to(device)
+        
+        # 情感标签名称
+        self.emotion_names = [
+            "happiness",
+            "sadness",
+            "anger",
+            "fear",
+            "surprise",
+            "disgust",
+            "neutral"
+        ]
+    
+    def preprocess(self, texts: List[str]) -> Dict[str, torch.Tensor]:
+        """预处理文本"""
+        encoding = self.tokenizer(
+            texts,
+            padding=True,
+            truncation=True,
+            max_length=self.max_length,
+            return_tensors="pt"
+        )
+        
+        return {k: v.to(self.device) for k, v in encoding.items()}
+    
+    def predict(self, texts: List[str]) -> List[Dict[str, any]]:
+        """
+        批量预测
+        
+        Args:
+            texts: 文本列表
+            
+        Returns:
+            预测结果列表
+        """
+        self.model.eval()
+        
+        inputs = self.preprocess(texts)
+        
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            logits = outputs['logits']
+            probabilities = torch.sigmoid(logits)  # 多标签使用 sigmoid
+        
+        results = []
+        for i, probs in enumerate(probabilities):
+            # 获取超过阈值的情感
+            detected_emotions = []
+            emotion_scores = {}
+            
+            for j, prob in enumerate(probs):
+                emotion_scores[self.emotion_names[j]] = float(prob)
+                if prob >= self.threshold:
+                    detected_emotions.append({
+                        'emotion': self.emotion_names[j],
+                        'score': float(prob)
+                    })
+            
+            results.append({
+                'text': texts[i],
+                'emotions': detected_emotions,
+                'all_scores': emotion_scores
+            })
+        
+        return results
+    
+    def save(self, save_path: str):
+        """保存模型"""
+        import os
+        os.makedirs(save_path, exist_ok=True)
+        
+        # 保存模型权重
+        torch.save(self.model.state_dict(), f"{save_path}/model.pt")
+        
+        # 保存分词器
+        self.tokenizer.save_pretrained(save_path)
+        
+        # 保存配置
+        import json
+        config = {
+            'model_name': self.model_name,
+            'num_emotions': self.num_emotions,
+            'max_length': self.max_length,
+            'threshold': self.threshold
+        }
+        with open(f"{save_path}/config.json", 'w') as f:
+            json.dump(config, f, indent=2)
+        
+        print(f"检测模型已保存到 {save_path}")
+    
+    @classmethod
+    def load(cls, model_path: str, device: str = "cuda"):
+        """加载模型"""
+        import json
+        
+        # 加载配置
+        with open(f"{model_path}/config.json", 'r') as f:
+            config = json.load(f)
+        
+        instance = cls(
+            model_name=config['model_name'],
+            num_emotions=config['num_emotions'],
+            max_length=config['max_length'],
+            device=device,
+            threshold=config.get('threshold', 0.5)
+        )
+        
+        # 加载权重
+        instance.model.load_state_dict(
+            torch.load(f"{model_path}/model.pt", map_location=device)
+        )
+        
+        print(f"检测模型已从 {model_path} 加载")
+        return instance
+

inference_example.py

@@ -0,0 +1,91 @@
+"""
+情感检测推理示例
+使用detection_hug模型进行情感分类
+"""
+import torch
+from transformers import BertTokenizer
+from detection_model import EmotionDetectionModel
+
+def load_model(model_path="model.pt", device="cpu"):
+    """加载模型"""
+    print(f"加载模型: {model_path}")
+    
+    # 加载分词器
+    tokenizer = BertTokenizer.from_pretrained(".")
+    
+    # 创建模型
+    model = EmotionDetectionModel(
+        model_name="bert-base-chinese",
+        num_emotions=6,
+        dropout=0.1
+    )
+    
+    # 加载权重
+    checkpoint = torch.load(model_path, map_location=device)
+    if isinstance(checkpoint, dict) and 'model_state_dict' in checkpoint:
+        model.load_state_dict(checkpoint['model_state_dict'])
+    else:
+        model.load_state_dict(checkpoint)
+    
+    model = model.to(device)
+    model.eval()
+    
+    print("✅ 模型加载成功")
+    return model, tokenizer
+
+def predict(text, model, tokenizer, device="cpu"):
+    """预测单个文本的情感"""
+    # 情感标签
+    EMOTIONS = ["sadness", "joy", "love", "anger", "fear", "surprise"]
+    
+    # 编码
+    encoding = tokenizer(
+        text,
+        padding='max_length',
+        truncation=True,
+        max_length=512,
+        return_tensors='pt'
+    )
+    
+    input_ids = encoding['input_ids'].to(device)
+    attention_mask = encoding['attention_mask'].to(device)
+    
+    # 推理
+    with torch.no_grad():
+        outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+        logits = outputs['logits']
+        probabilities = torch.softmax(logits, dim=-1)
+        predicted_id = torch.argmax(probabilities, dim=-1).item()
+        confidence = probabilities[0, predicted_id].item()
+    
+    return {
+        'emotion': EMOTIONS[predicted_id],
+        'confidence': confidence,
+        'all_probabilities': {
+            EMOTIONS[i]: float(probabilities[0, i])
+            for i in range(len(EMOTIONS))
+        }
+    }
+
+if __name__ == "__main__":
+    # 示例
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model, tokenizer = load_model(device=device)
+    
+    # 测试文本
+    test_texts = [
+        "我今天很开心！",
+        "这让我感到非常难过。",
+        "我爱你。"
+    ]
+    
+    print("\n" + "="*60)
+    print("情感检测结果")
+    print("="*60)
+    
+    for text in test_texts:
+        result = predict(text, model, tokenizer, device)
+        print(f"\n文本: {text}")
+        print(f"情感: {result['emotion']}")
+        print(f"置信度: {result['confidence']:.4f}")
+

model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:674ba0c78ee1e82d0e7e301184f359cc93067bc3d3c2c660589289c65f64087a
+size 1227512245

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,58 @@
+{
+  "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": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": false,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}