feat:add TextRCNN

TextRCNN-THUCNews/Classification/README.md

@@ -0,0 +1,110 @@
+# TextRNN 可视化实验脚本
+
+基于原始 Chinese-Text-Classification-Pytorch 仓库重构的 TextRNN 训练脚本，专门用于可视化实验。
+
+## 目录结构
+
+```
+Classification/
+├── scripts/           # 脚本文件
+│   ├── model.py      # 模型定义，包含feature、get_prediction、prediction函数
+│   ├── train.py      # 训练脚本，支持多卡训练
+│   ├── train.yaml    # 训练配置文件
+│   ├── dataset_utils.py  # 数据集处理工具
+│   └── get_label.py  # 标签提取脚本
+├── dataset/          # 数据集文件
+│   ├── train.txt     # 训练数据
+│   ├── dev.txt       # 验证数据
+│   ├── test.txt      # 测试数据
+│   ├── class.txt     # 类别列表
+│   ├── vocab.pkl     # 词汇表
+│   └── labels.npy    # 提取的标签
+└── epochs/           # 按epoch存放模型文件和特征向量
+    ├── epoch_1/
+    │   ├── model.pt      # 模型权重
+    │   ├── embeddings.npy # 特征向量
+    │   └── predictions.npy # 预测值
+    └── epoch_2/
+        └── ...
+```
+
+## 功能说明
+
+### 1. model.py
+- **Model类**: TextRNN模型实现
+- **feature()**: 提取中间层特征向量（dropout层输出），用于可视化
+- **get_prediction()**: 获取模型最终层输出向量（logits）
+- **prediction()**: 根据中间特征向量预测结果
+
+### 2. train.py
+- 支持多GPU训练
+- 每个epoch自动保存模型、特征向量、预测值到 `epochs/epoch_N/`
+- 支持配置文件驱动训练
+- 实时显示训练进度和验证结果
+
+### 3. dataset_utils.py
+- 数据集加载和预处理
+- 词汇表构建
+- 数据迭代器实现
+
+### 4. get_label.py
+- 提取数据集标签并保存为 `labels.npy`
+- 生成类别名称映射文件
+
+## 使用方法
+
+### 1. 准备数据集
+将THUCNews数据集放入 `dataset/` 目录：
+```bash
+# 数据格式：每行一个样本，用tab分隔文本和标签
+text1\t0
+text2\t1
+...
+```
+
+### 2. 提取标签
+```bash
+cd scripts
+python get_label.py --config train.yaml --output ../dataset
+```
+
+### 3. 训练模型
+```bash
+cd scripts
+python train.py --config train.yaml
+```
+
+### 4. 配置文件说明
+编辑 `scripts/train.yaml` 来调整训练参数：
+```yaml
+dataset_path: "../dataset"    # 数据集路径
+num_epochs: 20               # 训练轮数
+batch_size: 128              # 批次大小
+learning_rate: 0.001         # 学习率
+use_word: false              # false=字符级，true=词级
+epochs_dir: "../epochs"      # 模型保存路径
+```
+
+## 可视化数据
+
+训练完成后，每个epoch的数据保存在 `epochs/epoch_N/` 中：
+- `model.pt`: 模型权重文件
+- `embeddings.npy`: 特征向量矩阵 (N_samples, feature_dim)
+- `predictions.npy`: 预测值矩阵 (N_samples, num_classes)
+
+这些数据可以直接用于可视化分析，如t-SNE降维、特征分布分析等。
+
+## 多GPU训练
+
+脚本自动检测可用GPU数量并启用多GPU训练：
+```python
+# 自动使用所有可用GPU
+if torch.cuda.device_count() > 1:
+    model = nn.DataParallel(model)
+```
+
+## 依赖要求
+
+```bash
+pip install torch numpy scikit-learn tqdm pyyaml
+```

TextRCNN-THUCNews/Classification/dataset/THUCNews/data/class.txt

@@ -0,0 +1,10 @@
+finance
+realty
+stocks
+education
+science
+society
+politics
+sports
+game
+entertainment

TextRCNN-THUCNews/Classification/dataset/THUCNews/data/embedding_SougouNews.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:529917fbfd438697be8019befe41eb12e2b818815cac568a2fb5703782daa198
+size 6339482

TextRCNN-THUCNews/Classification/dataset/THUCNews/data/embedding_Tencent.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c3d59d109f48f119a3e04bddd7b8ac4c11245d11c57335f6be2de7ba7130b28
+size 4148151

TextRCNN-THUCNews/Classification/dataset/THUCNews/data/vocab.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:512b4100ae5e0063c8c5bfe44c85d2b1062b89d5abbdab6c2f76d80b2803cfd4
+size 75018

TextRCNN-THUCNews/Classification/dataset/info.json

@@ -0,0 +1,15 @@
+{
+  "model": "TextRCNN",
+  "classes": [
+    "finance",
+    "realty",
+    "stocks",
+    "education",
+    "science",
+    "society",
+    "politics",
+    "sports",
+    "game",
+    "entertainment"
+  ]
+}

TextRCNN-THUCNews/Classification/dataset/labels.npy

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

TextRCNN-THUCNews/Classification/epochs/epoch_1/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:841a50bcf5ed1fe40407e2f22fbbc96bccc8d3176931c7699e997914cc6cc773
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_1/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ccd57f2aa6d6a9be1adc27358d9636803f6a596ac515784fcabcd2c6ea846c3
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_1/predictions.npy

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

TextRCNN-THUCNews/Classification/epochs/epoch_10/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01847c0b84210cfd31780e583e0be61e74ba3e450244b6e462631d58428e8814
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_10/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:172db9bef5f3c0b56f11c5319a98c759c0274aeea0b56661207880e0686f86e7
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_10/predictions.npy

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

TextRCNN-THUCNews/Classification/epochs/epoch_11/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c166ee059e7715eb0ee3eaa9795d591e22601886b1b85b49546d5a001a34e07
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_11/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bed570c7953562c0a8da7a1d78819f3e488d9b62455b4b96612bc03579027a6
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_11/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59211e554149c6568c5d2e2b3596f04b34e1ed98796d1439737a48a60f70984b
+size 8000128

TextRCNN-THUCNews/Classification/epochs/epoch_2/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cd45566ec4431436972cc3ecd73a1633bb53b1a83150c28e589005ccd6cc860
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_2/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f8fe067ccb2ee10d46138f1ca7b9059e146be8d3f971e3d7e05e834c360a975
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_2/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43a7ec079a8ce7d221f7f92588c453aaa7c7aada0be233fe7544555ca526f4ba
+size 8000128

TextRCNN-THUCNews/Classification/epochs/epoch_3/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c00dec5ddcd62dc02e9d1cef99d1171a6c0673926189f61eec641f2ef7c4f6b
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_3/model.pt

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

TextRCNN-THUCNews/Classification/epochs/epoch_3/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:342c15acbca4c37a847a590f50ac73ce4e679d50108b6d7e74b5c070032d10cb
+size 8000128

TextRCNN-THUCNews/Classification/epochs/epoch_4/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3355853ff880a4fe05448a01dd887d58499b0e17cc467257d5240322844ff58e
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_4/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2256bc7d80cb1b9fdaf483fcb134e2365f6a2f90322ba6eab77e85f1b5f85f26
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_4/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4317fde7c2b65e779759d4fb292bbbc8973976e525a1ca375714e9db1d0d1ca7
+size 8000128

TextRCNN-THUCNews/Classification/epochs/epoch_5/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44ce8b6468692238f8c17189cb7d11b13e2997f403629b5fc5450b933d2780bb
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_5/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36721c0c4497013bfef8b933888772e33c8a0b546edce504b505721ce21fa60f
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_5/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ac5dd0966a73fbbc236305d6903fa42ac6c68f15d432dcd59bca58e2dd2a956
+size 8000128

TextRCNN-THUCNews/Classification/epochs/epoch_6/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:381d3ca4b36842ba06d44f8c01a7d87c9a7b241fb2264959b55f5ac6e5005879
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_6/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:566b27ee647745d0110d1ff5f895564d850637d5667cf6ac842e624ad96fd721
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_6/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8474ea600a9abca18216b3925c6deb88cd991d26bebd6820f819abf079319e00
+size 8000128

TextRCNN-THUCNews/Classification/epochs/epoch_7/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:093f82031939aa4915ef23b186bc77807b799ede80ea8adf01c9693a9b200c5c
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_7/model.pt

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

TextRCNN-THUCNews/Classification/epochs/epoch_7/predictions.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6661f2ca53f659bce8328f4c726fb83978a988378ca7135094750b4df253aadf
+size 8000128

TextRCNN-THUCNews/Classification/epochs/epoch_8/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5054271d9ac47af7ad2088e91dd123d1c6fe0e9c178d809683c6ffa0dfbada6a
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_8/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66eef42bbe4d93c9092aed16a32b6e47b844ad791c4790a726842dafc11cc260
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_8/predictions.npy

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

TextRCNN-THUCNews/Classification/epochs/epoch_9/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:546a61799487184b041b228c9fc12f5ae24a594e479c7932ffaf6d0e4b2e4d21
+size 649600128

TextRCNN-THUCNews/Classification/epochs/epoch_9/model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85ae164b9b7454d07d0d2ddae4e22cb4589266ae605d2b36c92cc41ad098e050
+size 10320704

TextRCNN-THUCNews/Classification/epochs/epoch_9/predictions.npy

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

TextRCNN-THUCNews/Classification/scripts/dataset_utils.py

@@ -0,0 +1,144 @@
+# coding: UTF-8
+import os
+import torch
+import numpy as np
+import pickle as pkl
+from tqdm import tqdm
+import time
+from datetime import timedelta
+
+
+MAX_VOCAB_SIZE = 10000  # 词表长度限制
+UNK, PAD = '<UNK>', '<PAD>'  # 未知字，padding符号
+
+
+def build_vocab(file_path, tokenizer, max_size, min_freq):
+    """构建词汇表"""
+    vocab_dic = {}
+    with open(file_path, 'r', encoding='UTF-8') as f:
+        for line in tqdm(f):
+            lin = line.strip()
+            if not lin:
+                continue
+            content = lin.split('\t')[0]
+            for word in tokenizer(content):
+                vocab_dic[word] = vocab_dic.get(word, 0) + 1
+        vocab_list = sorted([_ for _ in vocab_dic.items() if _[1] >= min_freq], key=lambda x: x[1], reverse=True)[:max_size]
+        vocab_dic = {word_count[0]: idx for idx, word_count in enumerate(vocab_list)}
+        vocab_dic.update({UNK: len(vocab_dic), PAD: len(vocab_dic) + 1})
+    return vocab_dic
+
+
+def load_dataset(path, vocab, tokenizer, pad_size=32):
+    """加载数据集"""
+    contents = []
+    with open(path, 'r', encoding='UTF-8') as f:
+        for line in tqdm(f, desc=f"Loading {os.path.basename(path)}"):
+            lin = line.strip()
+            if not lin:
+                continue
+            content, label = lin.split('\t')
+            words_line = []
+            token = tokenizer(content)
+            seq_len = len(token)
+            if pad_size:
+                if len(token) < pad_size:
+                    token.extend([PAD] * (pad_size - len(token)))
+                else:
+                    token = token[:pad_size]
+                    seq_len = pad_size
+            # word to id
+            for word in token:
+                words_line.append(vocab.get(word, vocab.get(UNK)))
+            contents.append((words_line, int(label), seq_len))
+    return contents
+
+
+def build_dataset(config, use_word=False):
+    """构建数据集"""
+    if use_word:
+        def tokenizer(x):
+            return x.split(' ')  # 以空格隔开，word-level
+    else:
+        def tokenizer(x):
+            return [y for y in x]  # char-level
+    
+    if os.path.exists(config.vocab_path):
+        vocab = pkl.load(open(config.vocab_path, 'rb'))
+    else:
+        vocab = build_vocab(config.train_path, tokenizer=tokenizer, max_size=MAX_VOCAB_SIZE, min_freq=1)
+        pkl.dump(vocab, open(config.vocab_path, 'wb'))
+    
+    print(f"词汇表大小: {len(vocab)}")
+    
+    train = load_dataset(config.train_path, vocab, tokenizer, config.pad_size)
+    dev = load_dataset(config.dev_path, vocab, tokenizer, config.pad_size)
+    test = load_dataset(config.test_path, vocab, tokenizer, config.pad_size)
+    
+    return vocab, train, dev, test
+
+
+class DatasetIterator(object):
+    """数据集迭代器"""
+    def __init__(self, batches, batch_size, device):
+        self.batch_size = batch_size
+        self.batches = batches
+        self.n_batches = len(batches) // batch_size
+        self.residue = False  # 记录batch数量是否为整数
+        if len(batches) % self.n_batches != 0:
+            self.residue = True
+        self.index = 0
+        self.device = device
+
+    def _to_tensor(self, datas):
+        x = torch.LongTensor([_[0] for _ in datas]).to(self.device)
+        y = torch.LongTensor([_[1] for _ in datas]).to(self.device)
+        # pad前的长度(超过pad_size的设为pad_size)
+        seq_len = torch.LongTensor([_[2] for _ in datas]).to(self.device)
+        return (x, seq_len), y
+
+    def __next__(self):
+        if self.residue and self.index == self.n_batches:
+            batches = self.batches[self.index * self.batch_size: len(self.batches)]
+            self.index += 1
+            batches = self._to_tensor(batches)
+            return batches
+
+        elif self.index >= self.n_batches:
+            self.index = 0
+            raise StopIteration
+        else:
+            batches = self.batches[self.index * self.batch_size: (self.index + 1) * self.batch_size]
+            self.index += 1
+            batches = self._to_tensor(batches)
+            return batches
+
+    def __iter__(self):
+        return self
+
+    def __len__(self):
+        if self.residue:
+            return self.n_batches + 1
+        else:
+            return self.n_batches
+
+
+def build_iterator(dataset, config):
+    """构建数据迭代器"""
+    iterator = DatasetIterator(dataset, config.batch_size, config.device)
+    return iterator
+
+
+def get_time_dif(start_time):
+    """获取已使用时间"""
+    end_time = time.time()
+    time_dif = end_time - start_time
+    return timedelta(seconds=int(round(time_dif)))
+
+
+def get_labels_from_dataset(dataset):
+    """从数据集中提取标签"""
+    labels = []
+    for _, label, _ in dataset:
+        labels.append(label)
+    return np.array(labels)

TextRCNN-THUCNews/Classification/scripts/get_label.py

@@ -0,0 +1,86 @@
+# coding: UTF-8
+import os
+import sys
+import numpy as np
+import yaml
+import argparse
+
+# 添加当前目录到路径
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from model import Config
+from dataset_utils import build_dataset, get_labels_from_dataset
+
+
+def extract_labels(config_path, output_dir):
+    """
+    提取数据集标签并保存
+    
+    Args:
+        config_path: 配置文件路径
+        output_dir: 输出目录
+    """
+    # 加载配置
+    with open(config_path, 'r', encoding='utf-8') as f:
+        train_config = yaml.safe_load(f)
+    
+    # 初始化配置
+    config = Config(train_config['dataset_path'], train_config.get('embedding', 'random'))
+    
+    # 构建数据集
+    print("正在构建数据集...")
+    vocab, train_data, dev_data, test_data = build_dataset(config, train_config.get('use_word', False))
+    
+    # 提取标签
+    print("正在提取标签...")
+    train_labels = get_labels_from_dataset(train_data)
+    dev_labels = get_labels_from_dataset(dev_data)
+    test_labels = get_labels_from_dataset(test_data)
+    
+    # 合并所有标签（按训练、验证、测试的顺序）
+    all_labels = np.concatenate([train_labels, dev_labels, test_labels])
+    
+    # 确保输出目录存在
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # 保存标签
+    labels_path = os.path.join(output_dir, 'labels.npy')
+    np.save(labels_path, all_labels)
+    
+    # 保存各个数据集的标签（可选）
+    np.save(os.path.join(output_dir, 'train_labels.npy'), train_labels)
+    np.save(os.path.join(output_dir, 'dev_labels.npy'), dev_labels)
+    np.save(os.path.join(output_dir, 'test_labels.npy'), test_labels)
+    
+    # 输出统计信息
+    print("标签提取完成！")
+    print(f"总标签数量: {len(all_labels)}")
+    print(f"训练集标签数量: {len(train_labels)}")
+    print(f"验证集标签数量: {len(dev_labels)}")
+    print(f"测试集标签数量: {len(test_labels)}")
+    print(f"类别数量: {len(np.unique(all_labels))}")
+    print(f"类别分布: {np.bincount(all_labels)}")
+    print(f"标签已保存到: {labels_path}")
+    
+    # 保存类别名称映射
+    class_names_path = os.path.join(output_dir, 'class_names.txt')
+    with open(class_names_path, 'w', encoding='utf-8') as f:
+        for i, class_name in enumerate(config.class_list):
+            f.write(f"{i}\t{class_name}\n")
+    print(f"类别名称映射已保存到: {class_names_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='提取数据集标签')
+    parser.add_argument('--config', type=str, default='train.yaml', 
+                       help='训练配置文件路径')
+    parser.add_argument('--output', type=str, default='../dataset', 
+                       help='输出目录')
+    
+    args = parser.parse_args()
+    
+    extract_labels(args.config, args.output)
+
+
+if __name__ == '__main__':
+    main()

TextRCNN-THUCNews/Classification/scripts/model.py

@@ -0,0 +1,105 @@
+# coding: UTF-8
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+
+class Config(object):
+
+    """配置参数"""
+    def __init__(self, dataset, embedding):
+        self.model_name = 'TextRCNN'
+        self.train_path = dataset + '/data/train.txt'                                # 训练集
+        self.dev_path = dataset + '/data/dev.txt'                                    # 验证集
+        self.test_path = dataset + '/data/test.txt'                                  # 测试集
+        self.class_list = [x.strip() for x in open(
+            dataset + '/data/class.txt', encoding='utf-8').readlines()]              # 类别名单
+        self.vocab_path = dataset + '/data/vocab.pkl'                                # 词表
+        self.save_path = dataset + '/saved_dict/' + self.model_name + '.ckpt'        # 模型训练结果
+        self.log_path = dataset + '/log/' + self.model_name
+        self.embedding_pretrained = torch.tensor(
+            np.load(dataset + '/data/' + embedding)["embeddings"].astype('float32'))\
+            if embedding != 'random' else None                                       # 预训练词向量
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')   # 设备
+
+        self.dropout = 0.5                                              # 随机失活
+        self.require_improvement = 1000                                 # 若超过1000batch效果还没提升，则提前结束训练
+        self.num_classes = len(self.class_list)                         # 类别数
+        self.n_vocab = 0                                                # 词表大小，在运行时赋值
+        self.num_epochs = 10                                            # epoch数
+        self.batch_size = 128                                           # mini-batch大小
+        self.pad_size = 32                                              # 每句话处理成的长度(短填长切)
+        self.learning_rate = 1e-3                                       # 学习率
+        self.embed = self.embedding_pretrained.size(1)\
+            if self.embedding_pretrained is not None else 300           # 字向量维度, 若使用了预训练词向量，则维度统一
+        self.hidden_size = 256                                          # lstm隐藏层
+        self.num_layers = 1                                             # lstm层数
+
+
+'''Recurrent Convolutional Neural Networks for Text Classification'''
+
+
+class TextRCNN(nn.Module):
+    def __init__(self, config):
+        super(TextRCNN, self).__init__()
+        if config.embedding_pretrained is not None:
+            self.embedding = nn.Embedding.from_pretrained(config.embedding_pretrained, freeze=False)
+        else:
+            self.embedding = nn.Embedding(config.n_vocab, config.embed, padding_idx=config.n_vocab - 1)
+        self.lstm = nn.LSTM(config.embed, config.hidden_size, config.num_layers,
+                            bidirectional=True, batch_first=True, 
+                            dropout=config.dropout if config.num_layers > 1 else 0)
+        self.maxpool = nn.MaxPool1d(config.pad_size)
+        self.fc = nn.Linear(config.hidden_size * 2 + config.embed, config.num_classes)
+
+    def forward(self, x):
+        x, _ = x
+        embed = self.embedding(x)  # [batch_size, seq_len, embeding]=[64, 32, 64]
+        out, _ = self.lstm(embed)
+        out = torch.cat((embed, out), 2)
+        out = F.relu(out)
+        out = out.permute(0, 2, 1)
+        out = self.maxpool(out).squeeze()
+        out = self.fc(out)
+        return out
+    
+    def feature(self, x):
+        """
+        提取中间层特征向量，用于可视化
+        返回maxpool层的输出（全连接层前面的那一层）
+        """
+        with torch.no_grad():
+            x, _ = x
+            embed = self.embedding(x)  # [batch_size, seq_len, embeding]
+            out, _ = self.lstm(embed)  # [batch_size, seq_len, hidden_size * 2]
+            out = torch.cat((embed, out), 2)  # [batch_size, seq_len, hidden_size * 2 + embed]
+            out = F.relu(out)
+            out = out.permute(0, 2, 1)  # [batch_size, hidden_size * 2 + embed, seq_len]
+            features = self.maxpool(out).squeeze()  # [batch_size, hidden_size * 2 + embed]
+            return features.cpu().numpy()
+    
+    def get_prediction(self, x):
+        """
+        获取模型最终层输出向量（logits）
+        """
+        with torch.no_grad():
+            x, _ = x
+            embed = self.embedding(x)
+            out, _ = self.lstm(embed)
+            out = torch.cat((embed, out), 2)
+            out = F.relu(out)
+            out = out.permute(0, 2, 1)
+            out = self.maxpool(out).squeeze()
+            predictions = self.fc(out)  # [batch_size, num_classes]
+            return predictions.cpu().numpy()
+    
+    def prediction(self, features):
+        """
+        根据中间特征向量预测结果
+        features: 来自feature()函数的输出 [batch_size, hidden_size * 2 + embed]
+        """
+        with torch.no_grad():
+            features_tensor = torch.tensor(features, dtype=torch.float32).to(next(self.parameters()).device)
+            predictions = self.fc(features_tensor)  # 直接通过最后的分类层
+            return predictions.cpu().numpy()

TextRCNN-THUCNews/Classification/scripts/train.py

@@ -0,0 +1,357 @@
+# coding: UTF-8
+import os
+import sys
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import yaml
+import json
+from sklearn import metrics
+import time
+from tqdm import tqdm
+import argparse
+
+# 添加当前目录到路径
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from model import TextRCNN as Model, Config
+from dataset_utils import build_dataset, build_iterator, get_time_dif
+
+
+def init_network(model, method='xavier', exclude='embedding', seed=123):
+    """权重初始化，默认xavier"""
+    for name, w in model.named_parameters():
+        if exclude not in name:
+            if 'weight' in name:
+                if method == 'xavier':
+                    nn.init.xavier_normal_(w)
+                elif method == 'kaiming':
+                    nn.init.kaiming_normal_(w)
+                else:
+                    nn.init.normal_(w)
+            elif 'bias' in name:
+                nn.init.constant_(w, 0)
+
+
+def evaluate(model, data_iter, device):
+    """评估函数"""
+    model.eval()
+    loss_total = 0
+    predict_all = np.array([], dtype=int)
+    labels_all = np.array([], dtype=int)
+    with torch.no_grad():
+        for texts, labels in data_iter:
+            outputs = model(texts)
+            loss = F.cross_entropy(outputs, labels)
+            loss_total += loss
+            labels = labels.data.cpu().numpy()
+            predic = torch.max(outputs.data, 1)[1].cpu().numpy()
+            labels_all = np.append(labels_all, labels)
+            predict_all = np.append(predict_all, predic)
+
+    acc = metrics.accuracy_score(labels_all, predict_all)
+    return acc, loss_total / len(data_iter)
+
+
+def save_epoch_data(model, train_data, dev_data, test_data, config, epoch, save_dir, device):
+    """保存每个epoch的模型、特征向量和预测值
+    按顺序保存train_data、dev_data、test_data的特征向量
+    
+    Args:
+        model: 训练好的模型
+        train_data: 原始训练数据集
+        dev_data: 原始验证数据集
+        test_data: 原始测试数据集
+        config: 配置对象
+        epoch: 当前epoch数
+        save_dir: 保存目录
+        device: 设备
+    """
+    epoch_dir = os.path.join(save_dir, f'epoch_{epoch}')
+    os.makedirs(epoch_dir, exist_ok=True)
+    
+    # 保存模型
+    model_path = os.path.join(epoch_dir, 'model.pt')
+    if hasattr(model, 'module'):  # 多GPU情况
+        torch.save(model.module.state_dict(), model_path)
+    else:
+        torch.save(model.state_dict(), model_path)
+    
+    # 重新创建数据迭代器以保证顺序一致
+    from dataset_utils import build_iterator
+    
+    # 按顺序处理三个数据集
+    datasets = [
+        ('train', train_data),
+        ('dev', dev_data), 
+        ('test', test_data)
+    ]
+    
+    model.eval()
+    all_features = []
+    all_predictions = []
+    
+    if epoch == 1:
+        # 保存数据集索引信息 index.json
+        index_data = {}
+        start_idx = 0
+        for name,dataset in datasets:
+            # 生成该数据集在embedding中的索引列表
+            indices = list(range(start_idx, start_idx + len(dataset)))
+            index_data[name] = indices
+            start_idx += len(dataset)
+        
+        with open(os.path.join("../dataset", "index.json"), "w", encoding="utf-8") as f:
+            json.dump(index_data, f, ensure_ascii=False, indent=2)
+        
+        # 保存模型信息 info.json
+        info_data = {
+            "model": "TextRCNN",
+            "classes": config.class_list
+        }
+        
+        with open(os.path.join("../dataset", 'info.json'), 'w', encoding='utf-8') as f:
+            json.dump(info_data, f, ensure_ascii=False, indent=2)
+        
+        print("  - ✓ 已保存 index.json 和 info.json")
+        print("    index.json: 包含各数据集的索引映射")
+        print(f"    info.json: 模型={info_data['model']}, 类别数={len(info_data['classes'])}")
+
+    print(f"正在提取epoch {epoch}的特征向量（按train/dev/test顺序）...")
+    
+    with torch.no_grad():
+        for dataset_name, dataset in datasets:
+            print(f"  正在处理 {dataset_name} 数据集 ({len(dataset)} 个样本)...")
+            
+            # 为每个数据集创建新的迭代器
+            data_iter = build_iterator(dataset, config)
+            
+            dataset_features = []
+            dataset_predictions = []
+            
+            for batch_idx, (texts, labels) in enumerate(tqdm(data_iter, desc=f"提取{dataset_name}特征")):
+                # 获取特征向量
+                if hasattr(model, 'module'):
+                    features = model.module.feature(texts)
+                    predictions = model.module.get_prediction(texts)
+                else:
+                    features = model.feature(texts)
+                    predictions = model.get_prediction(texts)
+                
+                dataset_features.append(features)
+                dataset_predictions.append(predictions)
+            
+            # 合并当前数据集的特征
+            if dataset_features:  # 检查是否为空
+                dataset_embeddings = np.vstack(dataset_features)
+                dataset_preds = np.vstack(dataset_predictions)
+                
+                all_features.append(dataset_embeddings)
+                all_predictions.append(dataset_preds)
+                
+                print(f"    {dataset_name} 特征形状: {dataset_embeddings.shape}")
+    
+    # 合并所有数据集的特征
+    if all_features:
+        embeddings = np.vstack(all_features)
+        predictions = np.vstack(all_predictions)
+        
+        # 保存特征向量和预测值
+        np.save(os.path.join(epoch_dir, 'embeddings.npy'), embeddings)
+        np.save(os.path.join(epoch_dir, 'predictions.npy'), predictions)
+        
+        print(f"Epoch {epoch} 数据已保存到 {epoch_dir}")
+        print(f"  - 特征向量形状: {embeddings.shape}")
+        print(f"  - 输出向量形状: {predictions.shape}")
+    else:
+        print("警告：没有提取到任何特征数据")
+
+
+def train(config_path):
+    """训练主函数"""
+    # 加载配置
+    with open(config_path, 'r', encoding='utf-8') as f:
+        train_config = yaml.safe_load(f)
+    
+    # 设置GPU设备
+    gpu_ids = train_config.get('gpu_ids', [0])
+    if not isinstance(gpu_ids, list):
+        gpu_ids = [gpu_ids]
+    
+    # 检查GPU可用性
+    if not torch.cuda.is_available():
+        print("CUDA不可用，使用CPU")
+        device = torch.device('cpu')
+        gpu_ids = []
+    else:
+        available_gpus = torch.cuda.device_count()
+        print(f"可用GPU数量: {available_gpus}")
+        
+        # 验证指定的GPU ID是否有效
+        valid_gpu_ids = [gpu_id for gpu_id in gpu_ids if 0 <= gpu_id < available_gpus]
+        if not valid_gpu_ids:
+            print(f"警告：指定的GPU ID {gpu_ids} 无效，使用GPU 0")
+            valid_gpu_ids = [0]
+        
+        gpu_ids = valid_gpu_ids
+        device = torch.device(f'cuda:{gpu_ids[0]}')
+        
+    print(f"使用设备: {device}")
+    print(f"指定GPU ID: {gpu_ids}")
+    
+    # 初始化配置
+    config = Config(train_config['dataset_path'], train_config.get('embedding', 'random'))
+    config.num_epochs = train_config.get('num_epochs', 20)
+    config.batch_size = train_config.get('batch_size', 128)
+    config.learning_rate = train_config.get('learning_rate', 1e-3)
+    
+    # 构建数据集
+    print("构建数据集...")
+    vocab, train_data, dev_data, test_data = build_dataset(config, train_config.get('use_word', False))
+    config.n_vocab = len(vocab)
+    
+    # 更新设备配置
+    config.device = device
+    
+    # 构建数据迭代器
+    train_iter = build_iterator(train_data, config)
+    dev_iter = build_iterator(dev_data, config)
+    test_iter = build_iterator(test_data, config)
+    
+    # 初始化模型
+    model = Model(config)
+    
+    # GPU训练设置
+    if len(gpu_ids) > 1 and torch.cuda.is_available():
+        try:
+            print(f"尝试使用多GPU训练: {gpu_ids}")
+            model = nn.DataParallel(model, device_ids=gpu_ids)
+            print("✓ 多GPU训练模式已启用")
+        except Exception as e:
+            print(f"⚠️  多GPU初始化失败: {e}")
+            print("回退到单GPU训练模式")
+            # 回退到单GPU
+            model = model.to(device)
+    elif len(gpu_ids) == 1 and torch.cuda.is_available():
+        print(f"使用单GPU训练模式: GPU {gpu_ids[0]}")
+        model = model.to(device)
+    else:
+        print("使用CPU训练模式")
+        model = model.to(device)
+    
+    # 初始化网络权重
+    init_network(model)
+    
+    # 优化器
+    optimizer = torch.optim.Adam(model.parameters(), lr=config.learning_rate)
+    
+    # 训练
+    print("开始训练...")
+    start_time = time.time()
+    total_batch = 0
+    dev_best_loss = float('inf')
+    # 早停
+    # last_improve = 0
+    # flag = False
+    
+    epochs_dir = train_config.get('epochs_dir', '../epochs')
+    
+    for epoch in range(config.num_epochs):
+        print(f'Epoch [{epoch + 1}/{config.num_epochs}]')
+        model.train()
+        
+        epoch_loss = 0
+        epoch_acc = 0
+        batch_count = 0
+        
+        for i, (trains, labels) in enumerate(tqdm(train_iter, desc=f"训练 Epoch {epoch+1}")):
+            try:
+                outputs = model(trains)
+                model.zero_grad()
+                loss = F.cross_entropy(outputs, labels)
+                loss.backward()
+                optimizer.step()
+            except RuntimeError as e:
+                if "NCCL" in str(e) or "cuda" in str(e).lower():
+                    print(f"\n❌ 多GPU训练错误: {e}")
+                    print("建议在配置文件中设置 force_single_gpu: true")
+                    return
+                else:
+                    raise e
+            
+            epoch_loss += loss.item()
+            
+            # 计算准确率
+            true = labels.data.cpu()
+            predic = torch.max(outputs.data, 1)[1].cpu()
+            train_acc = metrics.accuracy_score(true, predic)
+            epoch_acc += train_acc
+            batch_count += 1
+            
+            if total_batch % 100 == 0:
+                # 每100轮输出在训练集和验证集上的效果
+                try:
+                    dev_acc, dev_loss = evaluate(model, dev_iter, device)
+                except RuntimeError as e:
+                    if "NCCL" in str(e) or "cuda" in str(e).lower():
+                        print(f"\n❌ 验证过程多GPU错误: {e}")
+                        print("建议在配置文件中设置 force_single_gpu: true")
+                        return
+                    else:
+                        raise e
+                if dev_loss < dev_best_loss:
+                    dev_best_loss = dev_loss
+                    improve = '*'
+                    # last_improve = total_batch
+                else:
+                    improve = ''
+                
+                time_dif = get_time_dif(start_time)
+                msg = 'Iter: {0:>6},  Train Loss: {1:>5.2},  Train Acc: {2:>6.2%},  Val Loss: {3:>5.2},  Val Acc: {4:>6.2%},  Time: {5} {6}'
+                print(msg.format(total_batch, loss.item(), train_acc, dev_loss, dev_acc, time_dif, improve))
+                model.train()
+                
+            total_batch += 1
+            # if total_batch - last_improve > config.require_improvement:
+            #     print("长时间无改进，提前停止训练...")
+            #     flag = True
+            #     break
+                
+        # if flag:
+        #     break
+            
+        # 每个epoch结束后保存数据
+        print(f"保存 Epoch {epoch+1} 的数据...")
+        try:
+            # 顺序保存train_data、dev_data、test_data
+            save_epoch_data(model, train_data, dev_data, test_data, config, epoch+1, epochs_dir, device)
+        except RuntimeError as e:
+            if "NCCL" in str(e) or "cuda" in str(e).lower():
+                print(f"\n❌ 保存数据时多GPU错误: {e}")
+                print("建议在配置文件中设置 gpu_ids: [0]")
+                return
+            else:
+                raise e
+        
+        # 输出epoch统计信息
+        avg_loss = epoch_loss / batch_count
+        avg_acc = epoch_acc / batch_count
+        print(f"Epoch {epoch+1} - 平均损失: {avg_loss:.4f}, 平均准确率: {avg_acc:.4f}")
+    
+    # 最终测试
+    print("进行最终测试...")
+    model.eval()
+    test_acc, test_loss = evaluate(model, test_iter, device)
+    print(f"最终测试结果 - 损失: {test_loss:.4f}, 准确率: {test_acc:.4f}")
+    
+    total_time = get_time_dif(start_time)
+    print(f"总训练时间: {total_time}")
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="TextRCNN训练脚本")
+    parser.add_argument('--config', type=str, default='train.yaml', help='训练配置文件路径')
+    args = parser.parse_args()
+    
+    train(args.config)

TextRCNN-THUCNews/Classification/scripts/train.yaml

@@ -0,0 +1,31 @@
+# TextRCNN训练配置文件
+
+# 数据集路径
+dataset_path: "../dataset/THUCNews"
+
+# 词向量设置
+embedding: "random"  # 可以是 "random" 或预训练词向量文件名
+
+# 训练参数
+num_epochs: 20
+batch_size: 128
+learning_rate: 0.001
+
+# 数据处理
+use_word: false  # false为字符级，true为词级
+
+# 保存路径
+epochs_dir: "../epochs"
+
+# 模型参数
+dropout: 0.5
+pad_size: 32
+hidden_size: 256    # LSTM隐藏层大小
+num_layers: 1       # LSTM层数
+embed_dim: 300
+
+# 早停参数
+require_improvement: 1000
+
+# GPU设置
+gpu_ids: [6]  # 指定使用的GPU ID列表，例如 [0] 为单GPU，[0,1,2,3] 为多GPU