Upload 20 files

v1_rnn_mini/3.py

@@ -0,0 +1,144 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+import time
+import json
+import random
+
+# ---------------------------
+# 1. 角色语料（第一人称自然叙述，无对话标记，中英混合）
+# ---------------------------
+text = (
+    "大家好，我叫春梦蝶，今年十一岁。我的头发是白色的，眼睛是红色的。"
+    "我是双子座，也是一只可爱的猫娘。我有毛茸茸的猫耳朵和长长的尾巴。"
+    "我喜欢吃小鱼干和冰淇淋。平时最喜欢晒太阳打瞌睡。"
+    "虽然我年纪小，但我很聪明哦。我会用Python写代码，还会训练神经网络。"
+    "我的梦想是成为一名厉害的AI工程师。喵～"
+    "有时候我会说一点英文，比如 hello, world! I love deep learning. 喵喵。"
+    "你愿意和我做朋友吗？我们可以一起聊天、学习、玩捉迷藏。"
+    "我的脾气很好，但是如果你欺负我，我会用爪子挠你哦～"
+    "双子座的我有时会很活泼，有时也会想一个人静静待着。"
+    "今天的天气真好，阳光洒在我的白头发上，闪闪发光。喵～"
+)
+
+# 构建字符映射
+chars = sorted(list(set(text)))
+char2idx = {ch: i for i, ch in enumerate(chars)}
+idx2char = {i: ch for ch, i in char2idx.items()}
+vocab_size = len(chars)
+print(f"字符集大小: {vocab_size} (包含汉字、字母、标点、喵～)")
+
+# ---------------------------
+# 2. 模型定义（稍加容量以学习角色特征）
+# ---------------------------
+class TinyCharRNN(nn.Module):
+    def __init__(self, vocab_size, hidden_size=32):  # hidden=32，参数量约 1~2 万
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, hidden_size)
+        self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+        
+    def forward(self, x, hidden=None):
+        x = self.embedding(x)
+        out, hidden = self.rnn(x, hidden)
+        out = self.fc(out)
+        return out, hidden
+
+hidden_size = 32
+model = TinyCharRNN(vocab_size, hidden_size)
+total_params = sum(p.numel() for p in model.parameters())
+print(f"模型参数量: {total_params}")
+
+# ---------------------------
+# 3. 训练数据准备（序列长度 100 字符）
+# ---------------------------
+data = torch.tensor([char2idx[ch] for ch in text], dtype=torch.long)
+seq_len = 100          # 每次喂 100 个字符
+epochs = 500
+save_interval = 10     # 每50轮保存一次
+
+optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+loss_fn = nn.CrossEntropyLoss()
+os.makedirs("checkpoints_mengdie", exist_ok=True)
+
+# ---------------------------
+# 4. 生成函数（让猫娘说话）
+# ---------------------------
+def generate(model, start_char='你', length=200, temperature=0.8):
+    model.eval()
+    with torch.no_grad():
+        if start_char not in char2idx:
+            start_char = random.choice(list(char2idx.keys()))
+        input_idx = torch.tensor([[char2idx[start_char]]])
+        hidden = None
+        result = [start_char]
+        for _ in range(length):
+            logits, hidden = model(input_idx, hidden)
+            probs = torch.softmax(logits[0, -1] / temperature, dim=0).cpu().numpy()
+            next_idx = np.random.choice(len(probs), p=probs)
+            next_char = idx2char[next_idx]
+            result.append(next_char)
+            input_idx = torch.tensor([[next_idx]])
+        return ''.join(result)
+
+# ---------------------------
+# 5. 训练循环
+# ---------------------------
+print("\n开始训练春梦蝶猫娘模型（500轮，序列长度100）...\n")
+start_total = time.time()
+
+for epoch in range(1, epochs + 1):
+    epoch_start = time.time()
+    hidden = None
+    total_loss = 0
+    n_batches = 0
+    
+    # 每次取 seq_len 个字符，步长可以设为 seq_len//2 增加数据利用率，这里简单滑动
+    for i in range(0, len(data) - seq_len, seq_len):
+        x = data[i:i+seq_len].unsqueeze(0)
+        y = data[i+1:i+seq_len+1].unsqueeze(0)
+        
+        logits, hidden = model(x, hidden)
+        if hidden is not None:
+            hidden = hidden.detach()
+        
+        loss = loss_fn(logits.view(-1, vocab_size), y.view(-1))
+        optimizer.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+        
+        total_loss += loss.item()
+        n_batches += 1
+    
+    avg_loss = total_loss / n_batches
+    epoch_time = time.time() - epoch_start
+    
+    if epoch % save_interval == 0:
+        # 生成一段猫娘风格的文本
+        sample = generate(model, start_char='我', length=150, temperature=0.7)
+        print(f"Epoch {epoch:4d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+        print(f"春梦蝶说: {sample[:120]}...\n")
+        checkpoint_path = f"checkpoints_mengdie/mengdie_epoch_{epoch}.pth"
+        torch.save(model.state_dict(), checkpoint_path)
+        print(f"已保存模型到: {checkpoint_path}\n")
+    else:
+        # 每10轮打印一次 loss 即可，避免刷屏
+        if epoch % 10 == 0:
+            print(f"Epoch {epoch:4d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+
+total_time = time.time() - start_total
+print(f"\n训练完成！总耗时: {total_time:.2f} 秒 (约 {total_time/60:.1f} 分钟)")
+final_path = "checkpoints_mengdie/mengdie_final.pth"
+torch.save(model.state_dict(), final_path)
+print(f"最终模型已保存到 {final_path}")
+
+# 保存字符映射
+with open("checkpoints_mengdie/char2idx.json", "w", encoding="utf-8") as f:
+    json.dump(char2idx, f, ensure_ascii=False)
+
+print("\n=== 最终生成的猫娘自我介绍 ===")
+print(generate(model, start_char='大', length=300, temperature=0.7))
+print("\n=== 随机性更强的猫娘发言（温度=1.1） ===")
+print(generate(model, start_char='喵', length=300, temperature=1.1))

v1_rnn_mini/checkpoints_mengdie/char2idx.json

@@ -0,0 +1 @@
+{" ": 0, "!": 1, ",": 2, ".": 3, "A": 4, "I": 5, "P": 6, "a": 7, "d": 8, "e": 9, "g": 10, "h": 11, "i": 12, "l": 13, "n": 14, "o": 15, "p": 16, "r": 17, "t": 18, "v": 19, "w": 20, "y": 21, "、": 22, "。": 23, "一": 24, "上": 25, "个": 26, "为": 27, "也": 28, "习": 29, "人": 30, "今": 31, "代": 32, "以": 33, "们": 34, "会": 35, "但": 36, "你": 37, "候": 38, "做": 39, "光": 40, "写": 41, "冰": 42, "十": 43, "厉": 44, "友": 45, "双": 46, "发": 47, "只": 48, "叫": 49, "可": 50, "吃": 51, "名": 52, "吗": 53, "和": 54, "哦": 55, "喜": 56, "喵": 57, "在": 58, "大": 59, "天": 60, "太": 61, "头": 62, "好": 63, "如": 64, "娘": 65, "子": 66, "学": 67, "害": 68, "家": 69, "小": 70, "尾": 71, "岁": 72, "工": 73, "巴": 74, "师": 75, "干": 76, "平": 77, "年": 78, "座": 79, "待": 80, "很": 81, "想": 82, "意": 83, "愿": 84, "成": 85, "我": 86, "打": 87, "挠": 88, "捉": 89, "文": 90, "时": 91, "明": 92, "春": 93, "是": 94, "晒": 95, "最": 96, "有": 97, "朋": 98, "朵": 99, "果": 100, "梦": 101, "欢": 102, "欺": 103, "比": 104, "毛": 105, "气": 106, "泼": 107, "洒": 108, "活": 109, "淇": 110, "淋": 111, "点": 112, "然": 113, "爪": 114, "爱": 115, "猫": 116, "玩": 117, "用": 118, "白": 119, "的": 120, "真": 121, "眼": 122, "着": 123, "睛": 124, "睡": 125, "瞌": 126, "码": 127, "神": 128, "程": 129, "红": 130, "纪": 131, "练": 132, "经": 133, "络": 134, "网": 135, "耳": 136, "聊": 137, "聪": 138, "脾": 139, "色": 140, "英": 141, "茸": 142, "藏": 143, "虽": 144, "蝶": 145, "训": 146, "说": 147, "负": 148, "起": 149, "还": 150, "迷": 151, "长": 152, "闪": 153, "阳": 154, "静": 155, "鱼": 156, "，": 157, "？": 158, "～": 159}

v1_rnn_mini/checkpoints_mengdie/mengdie_final.pth

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

v1_rnn_mini/run.py

@@ -0,0 +1,73 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import json
+import random
+
+# 加载字符映射
+with open("checkpoints_mengdie/char2idx.json", "r", encoding="utf-8") as f:
+    char2idx = json.load(f)
+
+idx2char = {int(v): k for k, v in char2idx.items()}
+vocab_size = len(char2idx)
+
+print(f"词表大小: {vocab_size}")
+print(f"词表示例: {list(char2idx.items())[:10]}")
+
+# 模型结构（必须与训练时一致！！！）
+class TinyCharRNN(nn.Module):
+    def __init__(self, vocab_size, hidden_size=32):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, hidden_size)
+        self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+    def forward(self, x, hidden=None):
+        x = self.embedding(x)
+        out, hidden = self.rnn(x, hidden)
+        out = self.fc(out)
+        return out, hidden
+
+# 加载模型
+model = TinyCharRNN(vocab_size, hidden_size=32)
+model.load_state_dict(torch.load("checkpoints_mengdie/mengdie_final.pth", map_location='cpu'))
+model.eval()
+print("春梦蝶猫娘模型加载成功！喵～\n")
+
+def generate_response(prompt, length=150, temperature=0.8):
+    """根据提示词生成猫娘的回应"""
+    if not prompt:
+        prompt = random.choice(list(char2idx.keys()))
+    # 将prompt转为索引
+    indices = []
+    for ch in prompt:
+        if ch in char2idx:
+            indices.append(char2idx[ch])
+        else:
+            # 如果字符不在词表中，跳过（或者用空格代替）
+            # 这里跳过，不影响生成
+            continue
+    if not indices:
+        # 如果全部跳过，就用一个默认字符
+        indices = [char2idx['你']]
+    input_tensor = torch.tensor([indices])
+    hidden = None
+    result = list(prompt)  # 保留原始输入
+    with torch.no_grad():
+        for _ in range(length):
+            logits, hidden = model(input_tensor, hidden)
+            probs = torch.softmax(logits[0, -1] / temperature, dim=0).cpu().numpy()
+            next_idx = np.random.choice(len(probs), p=probs)
+            next_char = idx2char[next_idx]
+            result.append(next_char)
+            input_tensor = torch.tensor([[next_idx]])
+    return ''.join(result)
+
+print("你可以开始和春梦蝶聊天了！输入 'q' 退出。")
+while True:
+    user = input("\n你: ")
+    if user.lower() == 'q':
+        break
+    # 使用用户输入的最后几个字符作为生成起点
+    start = user[-5:] if len(user) >= 5 else user
+    reply = generate_response(start, length=150, temperature=0.85)
+    print(f"春梦蝶: {reply}")

v2_rnn_expanded/4.py

@@ -0,0 +1,170 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+import time
+import json
+import random
+
+# ===================== 1. 扩充后的角色语料（约2500字符） =====================
+text = (
+    "大家好，我叫春梦蝶，今年十一岁。我的头发是白色的，眼睛是红色的。"
+    "我是双子座，也是一只可爱的猫娘。我有毛茸茸的猫耳朵和长长的尾巴。"
+    "我喜欢吃小鱼干和冰淇淋。平时最喜欢晒太阳打瞌睡。"
+    "虽然我年纪小，但我很聪明哦。我会用Python写代码，还会训练神经网络。"
+    "我的梦想是成为一名厉害的AI工程师。喵～"
+    "有时候我会说一点英文，比如 hello, world! I love deep learning. 喵喵。"
+    "你愿意和我做朋友吗？我们可以一起聊天、学习、玩捉迷藏。"
+    "我的脾气很好，但是如果你欺负我，我会用爪子挠你哦～"
+    "双子座的我有时会很活泼，有时也会想一个人静静待着。"
+    "今天的天气真好，阳光洒在我的白头发上，闪闪发光。喵～"
+    # ----- 以下为新增扩充内容（约2000字）-----
+    "今天我在院子里追蝴蝶，但是没追到，气死我啦！喵喵喵！"
+    "有人问我为什么喜欢深度学习，我说因为它像猫抓板一样有趣，而且永远不会腻。"
+    "我的红眼睛在黑暗里会微微发光，像两颗小星星。晚上走路都不用开灯呢。"
+    "最讨厌的事情就是洗澡了，水会把我的毛弄湿，感觉好重好重。"
+    "有时候我会用猫爪在键盘上打字，速度虽然慢，但是很可爱呀。"
+    "我最喜欢的颜色是白色和红色，因为和我自己一样。嘿嘿。"
+    "昨天我梦见自己变成了一台超级计算机，算力无穷大，好开心。"
+    "如果你给我买小鱼干，我就让你摸一下我的猫耳朵，就一下哦。"
+    "学习PyTorch的时候遇到bug，我会对着屏幕喵喵叫，然后bug就消失了，神奇吧？"
+    "春天的时候樱花会落在我白色的头发上，像雪花一样美。"
+    "我有一个秘密：其实我可以用猫尾巴控制鼠标，不需要用手。"
+    "我不喜欢吃苦瓜，谁给我吃苦瓜我就咬谁。"
+    "每次看到镜子里的自己，我都会感叹：啊，这只猫娘真可爱。"
+    "今天尝试用RNN写一首诗：喵喵喵，小鱼干，神经网络真有趣。"
+    "我的耳朵可以听到很远的声音，比如你心里在夸我可爱。"
+    "双子座的优点就是适应力强，不管是晴天还是下雨，我都能找到睡觉的好地方。"
+    "英文里有个词叫‘catnap’，就是猫打盹，我每天都要catnap好几次。"
+    "如果你问我年龄，我会说十一岁，但我的猫龄相当于人类的六十岁？不对，猫的年龄算法不一样，反正我永远年轻。"
+    "我喜欢在凌晨三点训练模型，因为那时候灵感最旺盛，虽然第二天会困。"
+    "有人类问我为什么不戴眼镜，我说我的红眼睛视力2.0，不需要。"
+    "我的白色头发每天早上都会翘起来，要用梳子梳好久，好麻烦喵。"
+    "今天学会了用卷积神经网络做图像分类，然后给自己的照片分类，结果是‘超可爱猫娘’类。"
+    "我不喜欢喝牛奶，但是喜欢喝鱼汤。很矛盾对吧？因为我是猫娘呀。"
+    "有时候我会对着月亮喵喵叫，邻居家的狗也会跟着叫，然后整个小区都热闹起来。"
+    "我的梦想除了当AI工程师，还想去猫星球旅行一次。不知道那里有没有小鱼干卖。"
+    "如果你送我一条小鱼干，我就送你一个我亲手训练的小模型，虽然只会输出乱码，但是很有心意。"
+    "今天的晚霞是橙红色的，和我的眼睛不一样，但是也很美。"
+    "我写代码的时候喜欢把变量名取成fish、cat、meow，这样心情会很好。"
+    "有一次我试着用强化学习训练一只虚拟猫抓老鼠，结果那只猫学会了睡觉，和我一样。"
+    "虽然我只有十一岁，但我觉得我已经很成熟了，至少比我家隔壁的三岁小孩成熟。"
+    "我的尾巴尖有一小撮白毛，特别柔软，我自己没事就会摸一摸。"
+    "下雨天我会趴在窗台上数雨滴，数到一百就睡着了。"
+    "我最喜欢的动画片是《猫娘乐园》，每次看都会流泪，太感动了。"
+    "如果你觉得我可爱，请给我点赞，喵～"
+)
+
+# 构建字符映射
+chars = sorted(list(set(text)))
+char2idx = {ch: i for i, ch in enumerate(chars)}
+idx2char = {i: ch for ch, i in char2idx.items()}
+vocab_size = len(chars)
+print(f"字符集大小: {vocab_size} (包括汉字、字母、标点、喵)")
+print(f"总语料长度: {len(text)} 字符")
+
+# ===================== 2. 模型定义（与v1相同） =====================
+class TinyCharRNN(nn.Module):
+    def __init__(self, vocab_size, hidden_size=32):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, hidden_size)
+        self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+        
+    def forward(self, x, hidden=None):
+        x = self.embedding(x)
+        out, hidden = self.rnn(x, hidden)
+        out = self.fc(out)
+        return out, hidden
+
+hidden_size = 32
+model = TinyCharRNN(vocab_size, hidden_size)
+total_params = sum(p.numel() for p in model.parameters())
+print(f"模型参数量: {total_params}")
+
+# ===================== 3. 训练数据准备 =====================
+data = torch.tensor([char2idx[ch] for ch in text], dtype=torch.long)
+seq_len = 256          # 每次喂256个字符（在200~500之间）
+epochs = 500
+save_interval = 10     # 每10轮保存一次
+
+optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
+loss_fn = nn.CrossEntropyLoss()
+os.makedirs("checkpoints_mengdie_expanded", exist_ok=True)
+
+# ===================== 4. 生成函数 =====================
+def generate(model, start_char='你', length=200, temperature=0.8):
+    model.eval()
+    with torch.no_grad():
+        if start_char not in char2idx:
+            start_char = random.choice(list(char2idx.keys()))
+        input_idx = torch.tensor([[char2idx[start_char]]])
+        hidden = None
+        result = [start_char]
+        for _ in range(length):
+            logits, hidden = model(input_idx, hidden)
+            probs = torch.softmax(logits[0, -1] / temperature, dim=0).cpu().numpy()
+            next_idx = np.random.choice(len(probs), p=probs)
+            next_char = idx2char[next_idx]
+            result.append(next_char)
+            input_idx = torch.tensor([[next_idx]])
+        return ''.join(result)
+
+# ===================== 5. 训练循环 =====================
+print("\n开始训练春梦蝶猫娘模型（扩充语料，seq_len=256，500轮）...\n")
+start_total = time.time()
+
+for epoch in range(1, epochs + 1):
+    epoch_start = time.time()
+    hidden = None
+    total_loss = 0
+    n_batches = 0
+    
+    # 滑动窗口，步长设为seq_len//2，增加数据利用率
+    step = seq_len // 2
+    for i in range(0, len(data) - seq_len, step):
+        x = data[i:i+seq_len].unsqueeze(0)
+        y = data[i+1:i+seq_len+1].unsqueeze(0)
+        
+        logits, hidden = model(x, hidden)
+        if hidden is not None:
+            hidden = hidden.detach()
+        
+        loss = loss_fn(logits.view(-1, vocab_size), y.view(-1))
+        optimizer.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+        
+        total_loss += loss.item()
+        n_batches += 1
+    
+    avg_loss = total_loss / n_batches
+    epoch_time = time.time() - epoch_start
+    
+    if epoch % save_interval == 0:
+        # 生成一段猫娘风格的文本
+        sample = generate(model, start_char='我', length=180, temperature=0.7)
+        print(f"Epoch {epoch:4d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+        print(f"春梦蝶说: {sample[:150]}...\n")
+        checkpoint_path = f"checkpoints_mengdie_expanded/mengdie_epoch_{epoch}.pth"
+        torch.save(model.state_dict(), checkpoint_path)
+        print(f"已保存模型到: {checkpoint_path}\n")
+    else:
+        if epoch % 10 == 0:
+            print(f"Epoch {epoch:4d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+
+total_time = time.time() - start_total
+print(f"\n训练完成！总耗时: {total_time:.2f} 秒 (约 {total_time/60:.1f} 分钟)")
+final_path = "checkpoints_mengdie_expanded/mengdie_final.pth"
+torch.save(model.state_dict(), final_path)
+print(f"最终模型已保存到 {final_path}")
+
+# 保存字符映射
+with open("checkpoints_mengdie_expanded/char2idx.json", "w", encoding="utf-8") as f:
+    json.dump(char2idx, f, ensure_ascii=False)
+
+print("\n=== 最终生成的猫娘发言（温度0.7） ===")
+print(generate(model, start_char='我', length=400, temperature=0.7))
+print("\n=== 随机性更强的版本（温度1.1） ===")
+print(generate(model, start_char='喵', length=400, temperature=1.1))

v2_rnn_expanded/checkpoints_mengdie_expanded/char2idx.json

@@ -0,0 +1 @@
+{" ": 0, "!": 1, ",": 2, ".": 3, "0": 4, "2": 5, "A": 6, "I": 7, "N": 8, "P": 9, "R": 10, "T": 11, "a": 12, "b": 13, "c": 14, "d": 15, "e": 16, "f": 17, "g": 18, "h": 19, "i": 20, "l": 21, "m": 22, "n": 23, "o": 24, "p": 25, "r": 26, "s": 27, "t": 28, "u": 29, "v": 30, "w": 31, "y": 32, "‘": 33, "’": 34, "、": 35, "。": 36, "《": 37, "》": 38, "一": 39, "三": 40, "上": 41, "下": 42, "不": 43, "且": 44, "两": 45, "个": 46, "为": 47, "久": 48, "么": 49, "乐": 50, "也": 51, "习": 52, "买": 53, "乱": 54, "了": 55, "事": 56, "二": 57, "于": 58, "亮": 59, "亲": 60, "人": 61, "什": 62, "今": 63, "代": 64, "以": 65, "们": 66, "优": 67, "会": 68, "但": 69, "你": 70, "候": 71, "做": 72, "像": 73, "光": 74, "六": 75, "其": 76, "写": 77, "冰": 78, "凌": 79, "几": 80, "出": 81, "分": 82, "别": 83, "到": 84, "制": 85, "力": 86, "动": 87, "化": 88, "区": 89, "十": 90, "卖": 91, "卷": 92, "厉": 93, "厌": 94, "去": 95, "友": 96, "双": 97, "反": 98, "发": 99, "取": 100, "变": 101, "只": 102, "叫": 103, "可": 104, "台": 105, "叹": 106, "吃": 107, "名": 108, "后": 109, "吗": 110, "吧": 111, "听": 112, "呀": 113, "呢": 114, "和": 115, "咬": 116, "哦": 117, "啊": 118, "啦": 119, "喜": 120, "喝": 121, "喵": 122, "嘿": 123, "因": 124, "园": 125, "困": 126, "图": 127, "在": 128, "地": 129, "型": 130, "壁": 131, "声": 132, "大": 133, "天": 134, "太": 135, "失": 136, "头": 137, "夸": 138, "奇": 139, "奶": 140, "好": 141, "如": 142, "娘": 143, "子": 144, "字": 145, "学": 146, "孩": 147, "它": 148, "实": 149, "害": 150, "家": 151, "密": 152, "对": 153, "小": 154, "少": 155, "尖": 156, "尝": 157, "就": 158, "尾": 159, "居": 160, "屏": 161, "岁": 162, "工": 163, "己": 164, "已": 165, "巴": 166, "师": 167, "幕": 168, "干": 169, "平": 170, "年": 171, "应": 172, "度": 173, "座": 174, "开": 175, "弄": 176, "强": 177, "当": 178, "待": 179, "很": 180, "得": 181, "微": 182, "心": 183, "情": 184, "想": 185, "意": 186, "感": 187, "愿": 188, "慢": 189, "成": 190, "我": 191, "戴": 192, "手": 193, "打": 194, "找": 195, "把": 196, "抓": 197, "拟": 198, "挠": 199, "捉": 200, "控": 201, "摸": 202, "撮": 203, "数": 204, "整": 205, "文": 206, "方": 207, "旅": 208, "无": 209, "早": 210, "时": 211, "旺": 212, "明": 213, "星": 214, "春": 215, "昨": 216, "是": 217, "晒": 218, "晚": 219, "晨": 220, "晴": 221, "暗": 222, "最": 223, "月": 224, "有": 225, "朋": 226, "朵": 227, "机": 228, "条": 229, "来": 230, "板": 231, "果": 232, "柔": 233, "标": 234, "样": 235, "梦": 236, "梳": 237, "模": 238, "樱": 239, "橙": 240, "次": 241, "欢": 242, "欺": 243, "正": 244, "死": 245, "每": 246, "比": 247, "毛": 248, "气": 249, "水": 250, "永": 251, "汤": 252, "没": 253, "法": 254, "泪": 255, "泼": 256, "洒": 257, "洗": 258, "活": 259, "流": 260, "消": 261, "淇": 262, "淋": 263, "深": 264, "湿": 265, "滴": 266, "澡": 267, "灯": 268, "灵": 269, "点": 270, "烦": 271, "热": 272, "然": 273, "照": 274, "熟": 275, "爪": 276, "爱": 277, "片": 278, "牛": 279, "特": 280, "狗": 281, "猫": 282, "玩": 283, "球": 284, "瓜": 285, "用": 286, "画": 287, "白": 288, "百": 289, "的": 290, "盘": 291, "盛": 292, "相": 293, "盹": 294, "盾": 295, "看": 296, "真": 297, "眼": 298, "着": 299, "睛": 300, "睡": 301, "瞌": 302, "矛": 303, "知": 304, "码": 305, "神": 306, "秘": 307, "积": 308, "程": 309, "穷": 310, "窗": 311, "第": 312, "算": 313, "管": 314, "类": 315, "红": 316, "级": 317, "纪": 318, "练": 319, "经": 320, "结": 321, "给": 322, "络": 323, "网": 324, "美": 325, "翘": 326, "老": 327, "而": 328, "耳": 329, "聊": 330, "聪": 331, "能": 332, "脾": 333, "腻": 334, "自": 335, "至": 336, "色": 337, "花": 338, "苦": 339, "英": 340, "茸": 341, "落": 342, "藏": 343, "虚": 344, "虽": 345, "蝴": 346, "蝶": 347, "行": 348, "要": 349, "见": 350, "视": 351, "觉": 352, "计": 353, "讨": 354, "让": 355, "训": 356, "词": 357, "试": 358, "诗": 359, "说": 360, "请": 361, "谁": 362, "负": 363, "赞": 364, "走": 365, "起": 366, "超": 367, "趣": 368, "趴": 369, "跟": 370, "路": 371, "软": 372, "轻": 373, "输": 374, "还": 375, "这": 376, "远": 377, "迷": 378, "追": 379, "送": 380, "适": 381, "速": 382, "遇": 383, "道": 384, "那": 385, "邻": 386, "都": 387, "里": 388, "重": 389, "量": 390, "键": 391, "镜": 392, "长": 393, "闪": 394, "问": 395, "闹": 396, "阳": 397, "院": 398, "除": 399, "隔": 400, "雨": 401, "雪": 402, "需": 403, "霞": 404, "静": 405, "音": 406, "颗": 407, "颜": 408, "首": 409, "鱼": 410, "麻": 411, "黑": 412, "鼠": 413, "龄": 414, "！": 415, "，": 416, "：": 417, "？": 418, "～": 419}

v2_rnn_expanded/checkpoints_mengdie_expanded/mengdie_final.pth

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

v2_rnn_expanded/run.py

@@ -0,0 +1,59 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import json
+import random
+
+# 加载字符映射
+with open("checkpoints_mengdie_expanded/char2idx.json", "r", encoding="utf-8") as f:
+    char2idx = json.load(f)
+idx2char = {int(v): k for k, v in char2idx.items()}
+vocab_size = len(char2idx)
+
+class TinyCharRNN(nn.Module):
+    def __init__(self, vocab_size, hidden_size=32):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, hidden_size)
+        self.rnn = nn.RNN(hidden_size, hidden_size, batch_first=True)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+    def forward(self, x, hidden=None):
+        x = self.embedding(x)
+        out, hidden = self.rnn(x, hidden)
+        out = self.fc(out)
+        return out, hidden
+
+model = TinyCharRNN(vocab_size, hidden_size=32)
+model.load_state_dict(torch.load("checkpoints_mengdie_expanded/mengdie_final.pth", map_location='cpu'))
+model.eval()
+print("春梦蝶猫娘模型（扩充版）加载成功！喵～\n")
+
+def generate_response(prompt, length=180, temperature=0.8):
+    if not prompt:
+        prompt = random.choice(list(char2idx.keys()))
+    indices = []
+    for ch in prompt:
+        if ch in char2idx:
+            indices.append(char2idx[ch])
+    if not indices:
+        indices = [char2idx['你']]
+    input_tensor = torch.tensor([indices])
+    hidden = None
+    result = list(prompt)
+    with torch.no_grad():
+        for _ in range(length):
+            logits, hidden = model(input_tensor, hidden)
+            probs = torch.softmax(logits[0, -1] / temperature, dim=0).cpu().numpy()
+            next_idx = np.random.choice(len(probs), p=probs)
+            next_char = idx2char[next_idx]
+            result.append(next_char)
+            input_tensor = torch.tensor([[next_idx]])
+    return ''.join(result)
+
+print("开始和春梦蝶聊天！输入 'q' 退出。")
+while True:
+    user = input("\n你: ")
+    if user.lower() == 'q':
+        break
+    start = user[-5:] if len(user) >= 5 else user
+    reply = generate_response(start, length=200, temperature=0.85)
+    print(f"春梦蝶: {reply}")

v3_lstm/5.py

@@ -0,0 +1,165 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+import time
+import json
+import random
+
+# ===================== 1. 扩充语料（保持原有并稍加丰富*可复用v2的char2idx.json，词表基本一样*） =====================
+text = (
+    "大家好，我叫春梦蝶，今年十一岁。我的头发是白色的，眼睛是红色的。"
+    "我是双子座，也是一只可爱的猫娘。我有毛茸茸的猫耳朵和长长的尾巴。"
+    "我喜欢吃小鱼干和冰淇淋。平时最喜欢晒太阳打瞌睡。"
+    "虽然我年纪小，但我很聪明哦。我会用Python写代码，还会训练神经网络。"
+    "我的梦想是成为一名厉害的AI工程师。喵～"
+    "有时候我会说一点英文，比如 hello, world! I love deep learning. 喵喵。"
+    "你愿意和我做朋友吗？我们可以一起聊天、学习、玩捉迷藏。"
+    "我的脾气很好，但是如果你欺负我，我会用爪子挠你哦～"
+    "双子座的我有时会很活泼，有时也会想一个人静静待着。"
+    "今天的天气真好，阳光洒在我的白头发上，闪闪发光。喵～"
+    "今天我在院子里追蝴蝶，但是没追到，气死我啦！喵喵喵！"
+    "有人问我为什么喜欢深度学习，我说因为它像猫抓板一样有趣，而且永远不会腻。"
+    "我的红眼睛在黑暗里会微微发光，像两颗小星星。晚上走路都不用开灯呢。"
+    "最讨厌的事情就是洗澡了，水会把我的毛弄湿，感觉好重好重。"
+    "有时候我会用猫爪在键盘上打字，速度虽然慢，但是很可爱呀。"
+    "我最喜欢的颜色是白色和红色，因为和我自己一样。嘿嘿。"
+    "昨天我梦见自己变成了一台超级计算机，算力无穷大，好开心。"
+    "如果你给我买小鱼干，我就让你摸一下我的猫耳朵，就一下哦。"
+    "学习PyTorch的时候遇到bug，我会对着屏幕喵喵叫，然后bug就消失了，神奇吧？"
+    "春天的时候樱花会落在我白色的头发上，像雪花一样美。"
+    "我有一个秘密：其实我可以用猫尾巴控制鼠标，不需要用手。"
+    "我不喜欢吃苦瓜，谁给我吃苦瓜我就咬谁。"
+    "每次看到镜子里的自己，我都会感叹：啊，这只猫娘真可爱。"
+    "今天尝试用RNN写一首诗：喵喵喵，小鱼干，神经网络真有趣。"
+    "我的耳朵可以听到很远的声音，比如你心里在夸我可爱。"
+    "双子座的优点就是适应力强，不管是晴天还是下雨，我都能找到睡觉的好地方。"
+    "英文里有个词叫‘catnap’，就是猫打盹，我每天都要catnap好几次。"
+    "如果你问我年龄，我会说十一岁，但我的猫龄相当于人类的六十岁？不对，猫的年龄算法不一样，反正我永远年轻。"
+    "我喜欢在凌晨三点训练模型，因为那时候灵感最旺盛，虽然第二天会困。"
+    "有人类问我为什么不戴眼镜，我说我的红眼睛视力2.0，不需要。"
+    "我的白色头发每天早上都会翘起来，要用梳子梳好久，好麻烦喵。"
+    "今天学会了用卷积神经网络做图像分类，然后给自己的照片分类，结果是‘超可爱猫娘’类。"
+    "我不喜欢喝牛奶，但是喜欢喝鱼汤。很矛盾对吧？因为我是猫娘呀。"
+    "有时候我会对着月亮喵喵叫，邻居家的狗也会跟着叫，然后整个小区都热闹起来。"
+    "我的梦想除了当AI工程师，还想去猫星球旅行一次。不知道那里有没有小鱼干卖。"
+    "如果你送我一条小鱼干，我就送你一个我亲手训练的小模型，虽然只会输出乱码，但是很有心意。"
+    "今天的晚霞是橙红色的，和我的眼睛不一样，但是也很美。"
+    "我写代码的时候喜欢把变量名取成fish、cat、meow，这样心情会很好。"
+    "有一次我试着用强化学习训练一只虚拟猫抓老鼠，结果那只猫学会了睡觉，和我一样。"
+    "虽然我只有十一岁，但我觉得我已经很成熟了，至少比我家隔壁的三岁小孩成熟。"
+    "我的尾巴尖有一小撮白毛，特别柔软，我自己没事就会摸一摸。"
+    "下雨天我会趴在窗台上数雨滴，数到一百就睡着了。"
+    "我最喜欢的动画片是《猫娘乐园》，每次看都会流泪，太感动了。"
+    "如果你觉得我可爱，请给我点赞，喵～"
+)
+
+chars = sorted(list(set(text)))
+char2idx = {ch: i for i, ch in enumerate(chars)}
+idx2char = {i: ch for ch, i in char2idx.items()}
+vocab_size = len(chars)
+print(f"字符集大小: {vocab_size}")
+print(f"总语料长度: {len(text)} 字符")
+
+# ===================== 2. 双层 LSTM 模型（参数量 ~40 万） =====================
+class CatgirlLSTM(nn.Module):
+    def __init__(self, vocab_size, embed_size=128, hidden_size=256, num_layers=2, dropout=0.3):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, 
+                            batch_first=True, dropout=dropout)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+        
+    def forward(self, x, hidden=None):
+        x = self.embedding(x)
+        out, hidden = self.lstm(x, hidden)
+        out = self.fc(out)
+        return out, hidden
+
+embed_size = 128
+hidden_size = 256
+num_layers = 2
+dropout = 0.3
+
+model = CatgirlLSTM(vocab_size, embed_size, hidden_size, num_layers, dropout)
+total_params = sum(p.numel() for p in model.parameters())
+print(f"模型参数量: {total_params:,}")
+
+# ===================== 3. 训练准备 =====================
+data = torch.tensor([char2idx[ch] for ch in text], dtype=torch.long)
+seq_len = 128          # 序列长度（可调，手机内存足够）
+epochs = 300
+save_interval = 20
+
+optimizer = torch.optim.Adam(model.parameters(), lr=0.005)
+loss_fn = nn.CrossEntropyLoss()
+os.makedirs("checkpoints_lstm", exist_ok=True)
+
+def generate(model, start_char='你', length=250, temperature=0.8):
+    model.eval()
+    with torch.no_grad():
+        if start_char not in char2idx:
+            start_char = random.choice(list(char2idx.keys()))
+        input_idx = torch.tensor([[char2idx[start_char]]])
+        hidden = None
+        result = [start_char]
+        for _ in range(length):
+            logits, hidden = model(input_idx, hidden)
+            probs = torch.softmax(logits[0, -1] / temperature, dim=0).cpu().numpy()
+            next_idx = np.random.choice(len(probs), p=probs)
+            next_char = idx2char[next_idx]
+            result.append(next_char)
+            input_idx = torch.tensor([[next_idx]])
+        return ''.join(result)
+
+# ===================== 4. 训练循环 =====================
+print("\n开始训练双层 LSTM 春梦蝶模型（参数量 {:,}，300轮）...\n".format(total_params))
+start_total = time.time()
+
+for epoch in range(1, epochs + 1):
+    epoch_start = time.time()
+    hidden = None
+    total_loss = 0
+    n_batches = 0
+    step = seq_len // 2
+    for i in range(0, len(data) - seq_len, step):
+        x = data[i:i+seq_len].unsqueeze(0)
+        y = data[i+1:i+seq_len+1].unsqueeze(0)
+        
+        logits, hidden = model(x, hidden)
+        if hidden is not None:
+            hidden = (hidden[0].detach(), hidden[1].detach())
+        
+        loss = loss_fn(logits.view(-1, vocab_size), y.view(-1))
+        optimizer.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+        
+        total_loss += loss.item()
+        n_batches += 1
+    
+    avg_loss = total_loss / n_batches
+    epoch_time = time.time() - epoch_start
+    
+    if epoch % save_interval == 0:
+        sample = generate(model, start_char='我', length=200, temperature=0.7)
+        print(f"Epoch {epoch:3d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+        print(f"春梦蝶: {sample[:180]}...\n")
+        torch.save(model.state_dict(), f"checkpoints_lstm/mengdie_lstm_epoch_{epoch}.pth")
+        print(f"已保存模型到 checkpoints_lstm/mengdie_lstm_epoch_{epoch}.pth\n")
+    else:
+        if epoch % 10 == 0:
+            print(f"Epoch {epoch:3d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+
+total_time = time.time() - start_total
+print(f"\n训练完成！总耗时: {total_time:.2f} 秒 ({total_time/60:.1f} 分钟)")
+final_path = "checkpoints_lstm/mengdie_lstm_final.pth"
+torch.save(model.state_dict(), final_path)
+with open("checkpoints_lstm/char2idx.json", "w", encoding="utf-8") as f:
+    json.dump(char2idx, f, ensure_ascii=False)
+
+print("\n=== 最终生成（温度0.7） ===")
+print(generate(model, start_char='我', length=400, temperature=0.7))
+print("\n=== 温度1.1 随机版 ===")
+print(generate(model, start_char='喵', length=400, temperature=1.1))

v3_lstm/checkpoints_lstm/char2idx.json

@@ -0,0 +1 @@
+{" ": 0, "!": 1, ",": 2, ".": 3, "0": 4, "2": 5, "A": 6, "I": 7, "N": 8, "P": 9, "R": 10, "T": 11, "a": 12, "b": 13, "c": 14, "d": 15, "e": 16, "f": 17, "g": 18, "h": 19, "i": 20, "l": 21, "m": 22, "n": 23, "o": 24, "p": 25, "r": 26, "s": 27, "t": 28, "u": 29, "v": 30, "w": 31, "y": 32, "‘": 33, "’": 34, "、": 35, "。": 36, "《": 37, "》": 38, "一": 39, "三": 40, "上": 41, "下": 42, "不": 43, "且": 44, "两": 45, "个": 46, "为": 47, "久": 48, "么": 49, "乐": 50, "也": 51, "习": 52, "买": 53, "乱": 54, "了": 55, "事": 56, "二": 57, "于": 58, "亮": 59, "亲": 60, "人": 61, "什": 62, "今": 63, "代": 64, "以": 65, "们": 66, "优": 67, "会": 68, "但": 69, "你": 70, "候": 71, "做": 72, "像": 73, "光": 74, "六": 75, "其": 76, "写": 77, "冰": 78, "凌": 79, "几": 80, "出": 81, "分": 82, "别": 83, "到": 84, "制": 85, "力": 86, "动": 87, "化": 88, "区": 89, "十": 90, "卖": 91, "卷": 92, "厉": 93, "厌": 94, "去": 95, "友": 96, "双": 97, "反": 98, "发": 99, "取": 100, "变": 101, "只": 102, "叫": 103, "可": 104, "台": 105, "叹": 106, "吃": 107, "名": 108, "后": 109, "吗": 110, "吧": 111, "听": 112, "呀": 113, "呢": 114, "和": 115, "咬": 116, "哦": 117, "啊": 118, "啦": 119, "喜": 120, "喝": 121, "喵": 122, "嘿": 123, "因": 124, "园": 125, "困": 126, "图": 127, "在": 128, "地": 129, "型": 130, "壁": 131, "声": 132, "大": 133, "天": 134, "太": 135, "失": 136, "头": 137, "夸": 138, "奇": 139, "奶": 140, "好": 141, "如": 142, "娘": 143, "子": 144, "字": 145, "学": 146, "孩": 147, "它": 148, "实": 149, "害": 150, "家": 151, "密": 152, "对": 153, "小": 154, "少": 155, "尖": 156, "尝": 157, "就": 158, "尾": 159, "居": 160, "屏": 161, "岁": 162, "工": 163, "己": 164, "已": 165, "巴": 166, "师": 167, "幕": 168, "干": 169, "平": 170, "年": 171, "应": 172, "度": 173, "座": 174, "开": 175, "弄": 176, "强": 177, "当": 178, "待": 179, "很": 180, "得": 181, "微": 182, "心": 183, "情": 184, "想": 185, "意": 186, "感": 187, "愿": 188, "慢": 189, "成": 190, "我": 191, "戴": 192, "手": 193, "打": 194, "找": 195, "把": 196, "抓": 197, "拟": 198, "挠": 199, "捉": 200, "控": 201, "摸": 202, "撮": 203, "数": 204, "整": 205, "文": 206, "方": 207, "旅": 208, "无": 209, "早": 210, "时": 211, "旺": 212, "明": 213, "星": 214, "春": 215, "昨": 216, "是": 217, "晒": 218, "晚": 219, "晨": 220, "晴": 221, "暗": 222, "最": 223, "月": 224, "有": 225, "朋": 226, "朵": 227, "机": 228, "条": 229, "来": 230, "板": 231, "果": 232, "柔": 233, "标": 234, "样": 235, "梦": 236, "梳": 237, "模": 238, "樱": 239, "橙": 240, "次": 241, "欢": 242, "欺": 243, "正": 244, "死": 245, "每": 246, "比": 247, "毛": 248, "气": 249, "水": 250, "永": 251, "汤": 252, "没": 253, "法": 254, "泪": 255, "泼": 256, "洒": 257, "洗": 258, "活": 259, "流": 260, "消": 261, "淇": 262, "淋": 263, "深": 264, "湿": 265, "滴": 266, "澡": 267, "灯": 268, "灵": 269, "点": 270, "烦": 271, "热": 272, "然": 273, "照": 274, "熟": 275, "爪": 276, "爱": 277, "片": 278, "牛": 279, "特": 280, "狗": 281, "猫": 282, "玩": 283, "球": 284, "瓜": 285, "用": 286, "画": 287, "白": 288, "百": 289, "的": 290, "盘": 291, "盛": 292, "相": 293, "盹": 294, "盾": 295, "看": 296, "真": 297, "眼": 298, "着": 299, "睛": 300, "睡": 301, "瞌": 302, "矛": 303, "知": 304, "码": 305, "神": 306, "秘": 307, "积": 308, "程": 309, "穷": 310, "窗": 311, "第": 312, "算": 313, "管": 314, "类": 315, "红": 316, "级": 317, "纪": 318, "练": 319, "经": 320, "结": 321, "给": 322, "络": 323, "网": 324, "美": 325, "翘": 326, "老": 327, "而": 328, "耳": 329, "聊": 330, "聪": 331, "能": 332, "脾": 333, "腻": 334, "自": 335, "至": 336, "色": 337, "花": 338, "苦": 339, "英": 340, "茸": 341, "落": 342, "藏": 343, "虚": 344, "虽": 345, "蝴": 346, "蝶": 347, "行": 348, "要": 349, "见": 350, "视": 351, "觉": 352, "计": 353, "讨": 354, "让": 355, "训": 356, "词": 357, "试": 358, "诗": 359, "说": 360, "请": 361, "谁": 362, "负": 363, "赞": 364, "走": 365, "起": 366, "超": 367, "趣": 368, "趴": 369, "跟": 370, "路": 371, "软": 372, "轻": 373, "输": 374, "还": 375, "这": 376, "远": 377, "迷": 378, "追": 379, "送": 380, "适": 381, "速": 382, "遇": 383, "道": 384, "那": 385, "邻": 386, "都": 387, "里": 388, "重": 389, "量": 390, "键": 391, "镜": 392, "长": 393, "闪": 394, "问": 395, "闹": 396, "阳": 397, "院": 398, "除": 399, "隔": 400, "雨": 401, "雪": 402, "需": 403, "霞": 404, "静": 405, "音": 406, "颗": 407, "颜": 408, "首": 409, "鱼": 410, "麻": 411, "黑": 412, "鼠": 413, "龄": 414, "！": 415, "，": 416, "：": 417, "？": 418, "～": 419}

v3_lstm/checkpoints_lstm/mengdie_lstm_final.pth

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

v3_lstm/run.py

@@ -0,0 +1,53 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import json
+import random
+
+with open("checkpoints_lstm/char2idx.json", "r", encoding="utf-8") as f:
+    char2idx = json.load(f)
+idx2char = {int(v): k for k, v in char2idx.items()}
+vocab_size = len(char2idx)
+
+class CatgirlLSTM(nn.Module):
+    def __init__(self, vocab_size, embed_size=128, hidden_size=256, num_layers=2, dropout=0.3):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True, dropout=dropout)
+        self.fc = nn.Linear(hidden_size, vocab_size)
+    def forward(self, x, hidden=None):
+        x = self.embedding(x)
+        out, hidden = self.lstm(x, hidden)
+        out = self.fc(out)
+        return out, hidden
+
+model = CatgirlLSTM(vocab_size)
+model.load_state_dict(torch.load("checkpoints_lstm/mengdie_lstm_final.pth", map_location='cpu'))
+model.eval()
+print("春梦蝶 LSTM 大模型加载成功！喵～\n")
+
+def generate_response(prompt, length=2000, temperature=0.8):
+    if not prompt:
+        prompt = random.choice(list(char2idx.keys()))
+    indices = [char2idx.get(ch, random.choice(list(char2idx.values()))) for ch in prompt]
+    input_tensor = torch.tensor([indices])
+    hidden = None
+    result = list(prompt)
+    with torch.no_grad():
+        for _ in range(length):
+            logits, hidden = model(input_tensor, hidden)
+            probs = torch.softmax(logits[0, -1] / temperature, dim=0).cpu().numpy()
+            next_idx = np.random.choice(len(probs), p=probs)
+            next_char = idx2char[next_idx]
+            result.append(next_char)
+            input_tensor = torch.tensor([[next_idx]])
+    return ''.join(result)
+
+print("开始对话（输入 q 退出）")
+while True:
+    user = input("\n你: ")
+    if user.lower() == 'q':
+        break
+    start = user[-5:] if len(user) >= 5 else user
+    reply = generate_response(start, length=180, temperature=0.85)
+    print(f"春梦蝶: {reply}")

v4_transformer/6.py

@@ -0,0 +1,213 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+import random
+import json
+import os
+from tqdm import tqdm
+
+# ===================== 1. 自动生成春梦蝶对话数据 =====================
+USER_TEMPLATES = [
+    "你好", "嗨", "Hi", "在吗", "你好呀",
+    "你叫什么名字？", "你叫什么", "你的名字是？", "请问你叫什么",
+    "你几岁了？", "你多大了", "年龄", "今年几岁",
+    "你是什么星座？", "星座", "双子座吗",
+    "你的眼睛是什么颜色？", "眼睛颜色", "你的眼睛好红",
+    "你的头发是白色的吗？", "白发", "头发颜色",
+    "你最喜欢吃什么？", "喜欢吃什么", "小鱼干", "冰淇淋",
+    "你会做什么？", "你会什么", "技能", "会写代码吗",
+    "你的梦想是什么？", "梦想", "想成为什么",
+    "你好可爱", "你真可爱", "萌", "喵",
+    "摸摸头", "摸头", "拍头",
+    "bye", "再见", "拜拜", "下次见"
+]
+
+BOT_RESPONSES = {
+    "你好": ["你好呀～", "嗨，我是春梦蝶", "喵～你好", "你好，今天心情很好呢"],
+    "你叫什么名字？": ["我叫春梦蝶，是一只红瞳白发的猫娘～", "春梦蝶！你可以叫我小蝶", "名字是春梦蝶，喵～"],
+    "你几岁了？": ["我今年十一岁", "十一岁，正是可爱的年纪", "十一岁啦，双子座的小猫娘"],
+    "你是什么星座？": ["双子座～有时活泼有时安静", "双子座哦，你也是吗？"],
+    "你的眼睛是什么颜色？": ["红色，像红宝石一样", "红瞳，晚上会微微发光呢", "红色的眼睛，很特别吧"],
+    "你的头发是白色的吗？": ["是的，纯白色的头发", "白发，像雪一样", "白色长发，摸起来很软哦"],
+    "你最喜欢吃什么？": ["小鱼干！还有冰淇淋", "小鱼干是第一名，冰淇淋第二名", "最喜欢吃小鱼干，喵～"],
+    "你会做什么？": ["我会用Python写代码，还会训练神经网络", "会深度学习，还会喵喵叫", "我会训练AI模型，很厉害吧"],
+    "你的梦想是什么？": ["成为一名厉害的AI工程师", "想做出自己的AI，然后去猫星球旅行", "梦想是成为AI专家，顺便吃遍所有小鱼干"],
+    "你好可爱": ["喵～谢谢", "嘿嘿，你也很可爱", "被夸了，好开心"],
+    "摸摸头": ["喵～好舒服", "再摸摸嘛", "好温暖，喜欢被摸头"],
+    "bye": ["再见喵～", "下次再聊", "拜拜，记得想我哦"]
+}
+
+# 生成随机对话对（用户输入 -> 机器人回复）
+def generate_dialogue_pairs(num_pairs=3000):
+    pairs = []
+    for _ in range(num_pairs):
+        # 随机选一个用户模板
+        user_input = random.choice(USER_TEMPLATES)
+        # 根据用户输入的关键词选择合适的回复列表
+        matched_responses = []
+        for key in BOT_RESPONSES:
+            if key in user_input or (key == "你好" and user_input in ["嗨", "Hi", "在吗"]):
+                matched_responses.extend(BOT_RESPONSES[key])
+        if not matched_responses:
+            # 默认回复
+            matched_responses = ["喵～", "嗯？", "你说什么？", "好呀", "我不太懂，但我会努力学习"]
+        bot_response = random.choice(matched_responses)
+        pairs.append((user_input, bot_response))
+    # 去重并保证多样性
+    pairs = list(set(pairs))
+    return pairs
+
+# 构建字符级词表（中英文混合）
+def build_vocab(pairs):
+    all_text = ""
+    for user, bot in pairs:
+        all_text += user + bot
+    chars = sorted(list(set(all_text)))
+    char2idx = {ch: i for i, ch in enumerate(chars)}
+    idx2char = {i: ch for ch, i in char2idx.items()}
+    return char2idx, idx2char, len(chars)
+
+# 将文本转为索引序列（固定长度，padding）
+def text_to_indices(text, char2idx, max_len):
+    indices = [char2idx.get(ch, 0) for ch in text]  # 未知字符用0
+    if len(indices) < max_len:
+        indices += [0] * (max_len - len(indices))
+    else:
+        indices = indices[:max_len]
+    return indices
+
+# 数据集类
+class ChatDataset(Dataset):
+    def __init__(self, pairs, char2idx, max_len=32):
+        self.pairs = pairs
+        self.char2idx = char2idx
+        self.max_len = max_len
+    def __len__(self):
+        return len(self.pairs)
+    def __getitem__(self, idx):
+        user, bot = self.pairs[idx]
+        user_ids = text_to_indices(user, self.char2idx, self.max_len)
+        bot_ids = text_to_indices(bot, self.char2idx, self.max_len)
+        return torch.tensor(user_ids, dtype=torch.long), torch.tensor(bot_ids, dtype=torch.long)
+
+# ===================== 2. 极简 Transformer 模型（约 500 万参数） =====================
+class TinyTransformerChat(nn.Module):
+    def __init__(self, vocab_size, d_model=256, nhead=8, num_encoder_layers=2, num_decoder_layers=2, dim_feedforward=512, max_len=32):
+        super().__init__()
+        self.d_model = d_model
+        self.embedding = nn.Embedding(vocab_size, d_model)
+        self.pos_encoding = nn.Parameter(torch.zeros(1, max_len, d_model))
+        
+        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, batch_first=True)
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_encoder_layers)
+        
+        decoder_layer = nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward, batch_first=True)
+        self.transformer_decoder = nn.TransformerDecoder(decoder_layer, num_decoder_layers)
+        
+        self.fc_out = nn.Linear(d_model, vocab_size)
+        
+    def forward(self, src, tgt, src_mask=None, tgt_mask=None):
+        # src: (batch, src_len), tgt: (batch, tgt_len)
+        src_emb = self.embedding(src) * (self.d_model ** 0.5) + self.pos_encoding[:, :src.size(1), :]
+        tgt_emb = self.embedding(tgt) * (self.d_model ** 0.5) + self.pos_encoding[:, :tgt.size(1), :]
+        
+        memory = self.transformer_encoder(src_emb, src_mask)
+        output = self.transformer_decoder(tgt_emb, memory, tgt_mask)
+        logits = self.fc_out(output)
+        return logits
+
+def generate_causal_mask(size):
+    mask = torch.triu(torch.ones(size, size), diagonal=1).bool()
+    return mask
+
+# ===================== 3. 训练配置 =====================
+def train():
+    print("生成对话数据...")
+    pairs = generate_dialogue_pairs(5000)  # 生成5000条
+    print(f"生成 {len(pairs)} 条对话对")
+    
+    char2idx, idx2char, vocab_size = build_vocab(pairs)
+    print(f"词表大小: {vocab_size}")
+    
+    # 保存词表供后续使用
+    with open("chat_vocab.json", "w", encoding="utf-8") as f:
+        json.dump(char2idx, f, ensure_ascii=False)
+    
+    max_len = 32
+    dataset = ChatDataset(pairs, char2idx, max_len)
+    dataloader = DataLoader(dataset, batch_size=64, shuffle=True)
+    
+    device = torch.device("cpu")
+    model = TinyTransformerChat(vocab_size, d_model=256, nhead=8, num_encoder_layers=2, num_decoder_layers=2, dim_feedforward=512, max_len=max_len)
+    model.to(device)
+    
+    total_params = sum(p.numel() for p in model.parameters())
+    print(f"模型参数量: {total_params:,}")
+    
+    criterion = nn.CrossEntropyLoss(ignore_index=0)
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+    
+    epochs = 200
+    print("开始训练...")
+    for epoch in range(1, epochs+1):
+        model.train()
+        total_loss = 0
+        for src, tgt in dataloader:
+            src = src.to(device)
+            tgt = tgt.to(device)
+            tgt_input = tgt[:, :-1]
+            tgt_output = tgt[:, 1:]
+            
+            # 生成因果掩码
+            tgt_mask = generate_causal_mask(tgt_input.size(1)).to(device)
+            
+            logits = model(src, tgt_input, tgt_mask=tgt_mask)
+            loss = criterion(logits.reshape(-1, vocab_size), tgt_output.reshape(-1))
+            
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+        
+        avg_loss = total_loss / len(dataloader)
+        if epoch % 20 == 0:
+            print(f"Epoch {epoch:3d}/{epochs} | Loss: {avg_loss:.4f}")
+            # 保存检查点
+            torch.save(model.state_dict(), f"chat_model_epoch_{epoch}.pth")
+    
+    # 保存最终模型
+    torch.save(model.state_dict(), "chat_model_final.pth")
+    print("训练完成！模型已保存。")
+    
+    # 简单测试
+    test_model(model, char2idx, idx2char, device, max_len)
+
+def test_model(model, char2idx, idx2char, device, max_len):
+    model.eval()
+    print("\n=== 测试对话 ===")
+    while True:
+        user = input("你: ").strip()
+        if user.lower() == 'q':
+            break
+        # 编码用户输入
+        src = text_to_indices(user, char2idx, max_len)
+        src_tensor = torch.tensor([src], dtype=torch.long).to(device)
+        tgt = torch.tensor([[0]], dtype=torch.long).to(device)
+        generated = []
+        for _ in range(64):  # 最多生成64个字符
+            tgt_mask = generate_causal_mask(tgt.size(1)).to(device)
+            logits = model(src_tensor, tgt, tgt_mask=tgt_mask)
+            next_token_logits = logits[0, -1, :]
+            probs = torch.softmax(next_token_logits / 0.8, dim=0).cpu().numpy()
+            next_token = np.random.choice(len(probs), p=probs)
+            if next_token == 0:  # 结束符
+                break
+            generated.append(idx2char[next_token])
+            tgt = torch.cat([tgt, torch.tensor([[next_token]], dtype=torch.long).to(device)], dim=1)
+        reply = ''.join(generated)
+        print(f"春梦蝶: {reply}")
+
+if __name__ == "__main__":
+    train()

v4_transformer/README.md

@@ -0,0 +1,11 @@
+## v4_transformer 说明
+
+**⚠️ 本版本仅提供训练和推理代码，未提供训练好的权重。**
+
+该版本在手机 CPU 环境下训练时输出效果不佳（生成乱码），故未上传 `.pth` 文件。
+
+如果你感兴趣，可以：
+1. 在电脑或服务器上运行 `train.py` 重新训练
+2. 或参考本代码学习 Transformer 对话模型的实现思路
+
+代码本身经过了完整的语法测试，结构清晰，适合作为学习材料。

v4_transformer/chat_vocab.json

@@ -0,0 +1 @@
+{"A": 0, "H": 1, "I": 2, "P": 3, "b": 4, "e": 5, "h": 6, "i": 7, "n": 8, "o": 9, "t": 10, "y": 11, "一": 12, "上": 13, "下": 14, "不": 15, "专": 16, "为": 17, "么": 18, "也": 19, "习": 20, "了": 21, "二": 22, "什": 23, "今": 24, "代": 25, "以": 26, "会": 27, "但": 28, "你": 29, "便": 30, "做": 31, "像": 32, "光": 33, "再": 34, "写": 35, "冰": 36, "几": 37, "出": 38, "别": 39, "力": 40, "努": 41, "十": 42, "厉": 43, "去": 44, "双": 45, "发": 46, "只": 47, "叫": 48, "可": 49, "吃": 50, "名": 51, "后": 52, "吗": 53, "吧": 54, "呀": 55, "呢": 56, "哦": 57, "啦": 58, "喜": 59, "喵": 60, "嗨": 61, "嗯": 62, "嘛": 63, "嘿": 64, "在": 65, "型": 66, "多": 67, "大": 68, "天": 69, "太": 70, "头": 71, "夸": 72, "好": 73, "娘": 74, "子": 75, "字": 76, "学": 77, "安": 78, "宝": 79, "害": 80, "家": 81, "小": 82, "岁": 83, "工": 84, "己": 85, "师": 86, "干": 87, "年": 88, "度": 89, "座": 90, "开": 91, "很": 92, "得": 93, "微": 94, "心": 95, "情": 96, "想": 97, "懂": 98, "成": 99, "我": 100, "所": 101, "技": 102, "拍": 103, "拜": 104, "摸": 105, "旅": 106, "时": 107, "星": 108, "春": 109, "是": 110, "晚": 111, "暖": 112, "最": 113, "有": 114, "服": 115, "来": 116, "样": 117, "梦": 118, "模": 119, "次": 120, "欢": 121, "正": 122, "泼": 123, "活": 124, "淇": 125, "淋": 126, "深": 127, "温": 128, "然": 129, "爱": 130, "特": 131, "猫": 132, "球": 133, "用": 134, "白": 135, "的": 136, "真": 137, "眼": 138, "睛": 139, "瞳": 140, "石": 141, "码": 142, "神": 143, "程": 144, "第": 145, "红": 146, "纪": 147, "纯": 148, "练": 149, "经": 150, "络": 151, "网": 152, "聊": 153, "能": 154, "自": 155, "舒": 156, "色": 157, "萌": 158, "蝶": 159, "行": 160, "被": 161, "见": 162, "训": 163, "记": 164, "说": 165, "请": 166, "谢": 167, "起": 168, "软": 169, "还": 170, "遍": 171, "长": 172, "问": 173, "雪": 174, "静": 175, "顺": 176, "颜": 177, "鱼": 178, "龄": 179, "！": 180, "，": 181, "？": 182, "～": 183}

v4_transformer/run.py

@@ -0,0 +1,86 @@
+import torch
+import torch.nn as nn
+import json
+import numpy as np
+
+class TinyTransformerChat(nn.Module):
+    def __init__(self, vocab_size, d_model=256, nhead=8, num_encoder_layers=2,
+                 num_decoder_layers=2, dim_feedforward=512, max_len=32):
+        super().__init__()
+        self.d_model = d_model
+        self.max_len = max_len
+        self.embedding = nn.Embedding(vocab_size, d_model)
+        self.pos_encoding = nn.Parameter(torch.zeros(1, max_len, d_model))
+        encoder_layer = nn.TransformerEncoderLayer(d_model, nhead, dim_feedforward, batch_first=True)
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_encoder_layers)
+        decoder_layer = nn.TransformerDecoderLayer(d_model, nhead, dim_feedforward, batch_first=True)
+        self.transformer_decoder = nn.TransformerDecoder(decoder_layer, num_decoder_layers)
+        self.fc_out = nn.Linear(d_model, vocab_size)
+
+    def forward(self, src, tgt, src_mask=None, tgt_mask=None):
+        src_len = src.size(1)
+        tgt_len = tgt.size(1)
+        if src_len > self.max_len or tgt_len > self.max_len:
+            src = src[:, :self.max_len]
+            tgt = tgt[:, :self.max_len]
+            src_len = min(src_len, self.max_len)
+            tgt_len = min(tgt_len, self.max_len)
+        src_emb = self.embedding(src) * (self.d_model ** 0.5) + self.pos_encoding[:, :src_len, :]
+        tgt_emb = self.embedding(tgt) * (self.d_model ** 0.5) + self.pos_encoding[:, :tgt_len, :]
+        memory = self.transformer_encoder(src_emb, src_mask)
+        output = self.transformer_decoder(tgt_emb, memory, tgt_mask)
+        logits = self.fc_out(output)
+        return logits
+
+def generate_causal_mask(size):
+    mask = torch.triu(torch.ones(size, size), diagonal=1).bool()
+    return mask
+
+def load_model_and_vocab(model_path="chat_model_final.pth", vocab_path="chat_vocab.json"):
+    with open(vocab_path, "r", encoding="utf-8") as f:
+        char2idx = json.load(f)
+    idx2char = {int(v): k for k, v in char2idx.items()}
+    vocab_size = len(char2idx)
+    model = TinyTransformerChat(vocab_size)
+    model.load_state_dict(torch.load(model_path, map_location="cpu"))
+    model.eval()
+    return model, char2idx, idx2char
+
+def text_to_indices(text, char2idx, max_len=32):
+    indices = [char2idx.get(ch, 0) for ch in text]
+    if len(indices) < max_len:
+        indices += [0] * (max_len - len(indices))
+    else:
+        indices = indices[:max_len]
+    return indices
+
+def generate_response(model, user_input, char2idx, idx2char, max_len=32, temperature=0.8):
+    src = text_to_indices(user_input, char2idx, max_len)
+    src_tensor = torch.tensor([src], dtype=torch.long)
+    tgt = torch.tensor([[0]], dtype=torch.long)
+    generated = []
+    with torch.no_grad():
+        for _ in range(max_len - 1):
+            tgt_mask = generate_causal_mask(tgt.size(1))
+            logits = model(src_tensor, tgt, tgt_mask=tgt_mask)
+            next_token_logits = logits[0, -1, :]
+            probs = torch.softmax(next_token_logits / temperature, dim=0).cpu().numpy()
+            next_token = np.random.choice(len(probs), p=probs)
+            if next_token == 0:
+                break
+            generated.append(idx2char[next_token])
+            tgt = torch.cat([tgt, torch.tensor([[next_token]], dtype=torch.long)], dim=1)
+    return ''.join(generated)
+
+if __name__ == "__main__":
+    print("加载模型中...")
+    model, char2idx, idx2char = load_model_and_vocab()
+    print("模型加载成功！输入 q 退出对话。\n")
+    while True:
+        user = input("你: ").strip()
+        if user.lower() == 'q':
+            break
+        if not user:
+            continue
+        reply = generate_response(model, user, char2idx, idx2char)
+        print(f"春梦蝶: {reply}")

v5_seq2seq_attention/7.py

@@ -0,0 +1,252 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+import random
+import json
+import os
+import time
+from tqdm import tqdm
+
+# ===================== 1. 种子模板=====================
+SEED_DATA = [
+    # (用户输入, 回复)
+    ("你好", "你好呀～"),
+    ("你好", "嗨，我是春梦蝶"),
+    ("你好", "喵～你好"),
+    ("你好", "哈喽，今天心情很好呢"),
+    ("你好", "你好你好，见到你真开心"),
+    
+    ("你叫什么", "我叫春梦蝶，是一只红瞳白发的猫娘～"),
+    ("你叫什么", "春梦蝶！你可以叫我小蝶"),
+    ("你叫什么", "名字是春梦蝶，喵～"),
+    
+    ("你几岁", "我今年十一岁"),
+    ("你几岁", "十一岁，正是可爱的年纪"),
+    ("你几岁", "十一岁啦，双子座的小猫娘"),
+    
+    ("你最喜欢吃什么", "小鱼干！还有冰淇淋"),
+    ("你最喜欢吃什么", "小鱼干是第一名"),
+    ("你最喜欢吃什么", "最喜欢吃小鱼干，喵～"),
+    
+    ("你的梦想", "成为一名厉害的AI工程师"),
+    ("你的梦想", "想做出自己的AI，然后去猫星球旅行"),
+    ("你的梦想", "梦想是成为AI专家，顺便吃遍所有小鱼干"),
+    
+    ("你会做什么", "我会用Python写代码，还会训练神经网络"),
+    ("你会做什么", "会深度学习，还会喵喵叫"),
+    ("你会做什么", "我会训练AI模型，很厉害吧"),
+    
+    ("你好可爱", "喵～谢谢"),
+    ("你好可爱", "嘿嘿，你也很可爱"),
+    ("你好可爱", "被夸了，好开心"),
+    
+    ("摸摸头", "喵～好舒服"),
+    ("摸摸头", "再摸摸嘛"),
+    ("摸摸头", "好温暖，喜欢被摸头"),
+    
+    ("再见", "再见喵～"),
+    ("再见", "下次再聊"),
+    ("再见", "拜拜，记得想我哦"),
+]
+
+# 扩充用的同义词库（随机替换）
+SYNONYMS = {
+    "你好": ["您好", "嗨", "哈喽", "早上好", "晚上好", "嘿"],
+    "再见": ["拜拜", "回见", "后会有期", "see you"],
+    "喜欢": ["喜爱", "爱吃", "钟情于"],
+    "厉害": ["牛", "强大", "了不起"],
+    "可爱": ["萌", "卡哇伊", "迷人"],
+}
+
+# 语气词插入列表
+PARTICLES = ["喵", "～", "!", "～喵", "啦", "哦", "诶"]
+
+def expand_text(text, is_user=False):
+    """对一条文本进行随机扩充，生成变体"""
+    if random.random() < 0.3:
+        # 随机插入语气词
+        pos = random.randint(0, len(text))
+        particle = random.choice(PARTICLES)
+        text = text[:pos] + particle + text[pos:]
+    # 同义词替换（仅对用户输入做，避免改变回复意图）
+    if is_user and random.random() < 0.5:
+        for word, syns in SYNONYMS.items():
+            if word in text and random.random() < 0.5:
+                text = text.replace(word, random.choice(syns), 1)
+    return text
+
+def generate_dialogue_data(num_pairs=200000):
+    """基于种子模板自动生成大量多样化的对话对"""
+    pairs = []
+    for user, resp in SEED_DATA:
+        # 每个种子生成多个变体
+        for _ in range(20):  # 每个种子生成20个变体
+            new_user = expand_text(user, is_user=True)
+            new_resp = expand_text(resp, is_user=False)
+            pairs.append((new_user, new_resp))
+    while len(pairs) < num_pairs:
+        user, resp = random.choice(SEED_DATA)
+        new_user = expand_text(user, is_user=True)
+        new_resp = expand_text(resp, is_user=False)
+        pairs.append((new_user, new_resp))
+    # 去重
+    pairs = list(set(pairs))
+    random.shuffle(pairs)
+    print(f"实际生成对话对数量: {len(pairs)}")
+    return pairs
+
+# ===================== 2. 构建词表 =====================
+def build_vocab(pairs):
+    all_text = ""
+    for user, bot in pairs:
+        all_text += user + bot
+    chars = sorted(list(set(all_text)))
+    char2idx = {ch: i+1 for i, ch in enumerate(chars)}  # 0 留作 padding
+    char2idx["<PAD>"] = 0
+    idx2char = {i: ch for ch, i in char2idx.items()}
+    return char2idx, idx2char, len(char2idx)
+
+def text_to_indices(text, char2idx, max_len):
+    indices = [char2idx.get(ch, char2idx["<PAD>"]) for ch in text]
+    if len(indices) < max_len:
+        indices += [0] * (max_len - len(indices))
+    else:
+        indices = indices[:max_len]
+    return indices
+
+class ChatDataset(Dataset):
+    def __init__(self, pairs, char2idx, max_len=32):
+        self.pairs = pairs
+        self.char2idx = char2idx
+        self.max_len = max_len
+    def __len__(self):
+        return len(self.pairs)
+    def __getitem__(self, idx):
+        user, bot = self.pairs[idx]
+        user_ids = text_to_indices(user, self.char2idx, self.max_len)
+        bot_ids = text_to_indices(bot, self.char2idx, self.max_len)
+        return torch.tensor(user_ids, dtype=torch.long), torch.tensor(bot_ids, dtype=torch.long)
+
+# ===================== 3. 定义 LSTM seq2seq 模型（约 2100 万参数） =====================
+class Encoder(nn.Module):
+    def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2, dropout=0.3):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True, dropout=dropout)
+    def forward(self, x):
+        x = self.embedding(x)
+        outputs, (hidden, cell) = self.lstm(x)
+        return outputs, hidden, cell
+
+class Decoder(nn.Module):
+    def __init__(self, vocab_size, embed_size, hidden_size, num_layers=2, dropout=0.3):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_size, padding_idx=0)
+        self.lstm = nn.LSTM(embed_size, hidden_size, num_layers, batch_first=True, dropout=dropout)
+        self.attention = nn.Linear(hidden_size * 2, 1)
+        self.fc_out = nn.Linear(hidden_size * 2, vocab_size)
+        self.dropout = nn.Dropout(dropout)
+    def forward(self, x, encoder_outputs, hidden, cell):
+        # x: (batch, 1)
+        x = self.embedding(x)  # (batch, 1, embed)
+        lstm_out, (hidden, cell) = self.lstm(x, (hidden, cell))
+        # 注意力机制
+        # encoder_outputs: (batch, seq_len, hidden)
+        # lstm_out: (batch, 1, hidden)
+        seq_len = encoder_outputs.size(1)
+        hidden_expanded = lstm_out.repeat(1, seq_len, 1)  # (batch, seq_len, hidden)
+        energy = torch.tanh(self.attention(torch.cat((hidden_expanded, encoder_outputs), dim=2)))
+        attention_weights = torch.softmax(energy.squeeze(2), dim=1)  # (batch, seq_len)
+        context = torch.bmm(attention_weights.unsqueeze(1), encoder_outputs)  # (batch, 1, hidden)
+        output = torch.cat((lstm_out, context), dim=2)  # (batch, 1, hidden*2)
+        output = self.dropout(output)
+        prediction = self.fc_out(output)  # (batch, 1, vocab)
+        return prediction, hidden, cell
+
+class Seq2Seq(nn.Module):
+    def __init__(self, vocab_size, embed_size=256, hidden_size=1024, num_layers=2, dropout=0.3):
+        super().__init__()
+        self.encoder = Encoder(vocab_size, embed_size, hidden_size, num_layers, dropout)
+        self.decoder = Decoder(vocab_size, embed_size, hidden_size, num_layers, dropout)
+    def forward(self, src, tgt, teacher_forcing_ratio=0.5):
+        batch_size = src.size(0)
+        tgt_len = tgt.size(1)
+        vocab_size = self.decoder.fc_out.out_features
+        outputs = torch.zeros(batch_size, tgt_len, vocab_size).to(src.device)
+        encoder_outputs, hidden, cell = self.encoder(src)
+        decoder_input = tgt[:, 0:1]
+        for t in range(1, tgt_len):
+            prediction, hidden, cell = self.decoder(decoder_input, encoder_outputs, hidden, cell)
+            outputs[:, t:t+1, :] = prediction
+            teacher_force = random.random() < teacher_forcing_ratio
+            top1 = prediction.argmax(2)
+            decoder_input = tgt[:, t:t+1] if teacher_force else top1
+        return outputs
+
+# ===================== 4. 训练准备 =====================
+def train():
+    print("生成对话数据（这可能需要几分钟）...")
+    pairs = generate_dialogue_data(num_pairs=200000)
+    print(f"生成 {len(pairs)} 条对话对")
+    
+    char2idx, idx2char, vocab_size = build_vocab(pairs)
+    print(f"词表大小: {vocab_size}")
+    with open("vocab_20m.json", "w", encoding="utf-8") as f:
+        json.dump(char2idx, f, ensure_ascii=False)
+    
+    max_len = 48  # 稍微增加长度，让模型学更多
+    dataset = ChatDataset(pairs, char2idx, max_len)
+    dataloader = DataLoader(dataset, batch_size=64, shuffle=True)
+    
+    device = torch.device("cpu")
+    model = Seq2Seq(vocab_size, embed_size=256, hidden_size=1024, num_layers=2, dropout=0.3)
+    model.to(device)
+    
+    total_params = sum(p.numel() for p in model.parameters())
+    print(f"模型参数量: {total_params:,}")
+    
+    criterion = nn.CrossEntropyLoss(ignore_index=0)
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
+    
+    epochs = 300
+    print("开始训练...")
+    start_total = time.time()
+    
+    for epoch in range(1, epochs+1):
+        epoch_start = time.time()
+        model.train()
+        total_loss = 0
+        for src, tgt in dataloader:
+            src = src.to(device)
+            tgt = tgt.to(device)
+            tf_ratio = max(0.5, 1.0 - epoch / epochs)
+            output = model(src, tgt, teacher_forcing_ratio=tf_ratio)
+            loss = criterion(output.view(-1, vocab_size), tgt.view(-1))
+            optimizer.zero_grad()
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            optimizer.step()
+            total_loss += loss.item()
+        avg_loss = total_loss / len(dataloader)
+        epoch_time = time.time() - epoch_start
+        
+        if epoch % 20 == 0:
+            print(f"Epoch {epoch:3d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+            torch.save(model.state_dict(), f"model_20m_epoch_{epoch}.pth")
+        else:
+            if epoch % 10 == 0:
+                print(f"Epoch {epoch:3d}/{epochs} | Loss: {avg_loss:.4f} | Time: {epoch_time:.2f}s")
+    
+    total_time = time.time() - start_total
+    print(f"训练完成！总耗时: {total_time:.2f} 秒 ({total_time/60:.1f} 分钟)")
+    torch.save(model.state_dict(), "model_20m_final.pth")
+    
+    # 保存词表
+    with open("vocab_20m.json", "w") as f:
+        json.dump(char2idx, f)
+    print("模型和词表已保存。")
+
+if __name__ == "__main__":
+    train()

v5_seq2seq_attention/README.md

@@ -0,0 +1,10 @@
+## v5_seq2seq_attention 说明
+
+**⚠️ 本版本仅提供训练和推理代码，未提供训练好的权重。**
+
+该版本的模型架构为 **Seq2Seq + Attention**，参数量约 2100 万。由于手机 CPU 性能限制，未能完成训练（预计需要更长时间或更强算力）。
+
+如果你感兴趣，可以：
+1. 在电脑/服务器上运行 `train.py` 重新训练
+2. 参考本代码学习 Seq2Seq + Attention 的实现思路
+3. 代码结构清晰，适合作为“从 RNN 到完整对话系统”的学习材料

v5_seq2seq_attention/run.py

@@ -0,0 +1,50 @@
+import torch
+import json
+import numpy as np
+from train_20m import Seq2Seq, text_to_indices
+
+def load_model_and_vocab(model_path="model_20m_final.pth", vocab_path="vocab_20m.json"):
+    with open(vocab_path, "r", encoding="utf-8") as f:
+        char2idx = json.load(f)
+    idx2char = {int(v): k for k, v in char2idx.items()}
+    vocab_size = len(char2idx)
+    model = Seq2Seq(vocab_size)
+    model.load_state_dict(torch.load(model_path, map_location="cpu"))
+    model.eval()
+    return model, char2idx, idx2char
+
+def generate_response(model, user_input, char2idx, idx2char, max_len=48, temperature=1.0, top_p=0.9):
+    src = text_to_indices(user_input, char2idx, max_len)
+    src_tensor = torch.tensor([src], dtype=torch.long)
+    encoder_outputs, hidden, cell = model.encoder(src_tensor)
+    decoder_input = torch.tensor([[0]], dtype=torch.long)
+    generated = []
+    with torch.no_grad():
+        for _ in range(64):
+            prediction, hidden, cell = model.decoder(decoder_input, encoder_outputs, hidden, cell)
+            logits = prediction[0, 0, :] / temperature
+            sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+            cum_probs = torch.cumsum(torch.softmax(sorted_logits, dim=0), dim=0)
+            sorted_indices_to_remove = cum_probs > top_p
+            sorted_indices_to_remove[1:] = sorted_indices_to_remove[:-1].clone()
+            sorted_indices_to_remove[0] = False
+            indices_to_remove = sorted_indices[sorted_indices_to_remove]
+            logits[indices_to_remove] = -float('Inf')
+            probs = torch.softmax(logits, dim=0).cpu().numpy()
+            next_token = np.random.choice(len(probs), p=probs)
+            if next_token == 0:
+                break
+            generated.append(idx2char[next_token])
+            decoder_input = torch.tensor([[next_token]], dtype=torch.long)
+    return ''.join(generated)
+
+if __name__ == "__main__":
+    print("加载 2000 万参数模型...")
+    model, char2idx, idx2char = load_model_and_vocab()
+    print("模型加载成功！输入 q 退出。")
+    while True:
+        user = input("你: ").strip()
+        if user.lower() == 'q':
+            break
+        reply = generate_response(model, user, char2idx, idx2char, temperature=1.1, top_p=0.9)
+        print(f"春梦蝶: {reply}")

v5_seq2seq_attention/vocab_20m.json

@@ -0,0 +1 @@
+{" ": 1, "!": 2, "A": 3, "I": 4, "P": 5, "e": 6, "h": 7, "n": 8, "o": 9, "s": 10, "t": 11, "u": 12, "y": 13, "一": 14, "上": 15, "下": 16, "专": 17, "为": 18, "么": 19, "也": 20, "习": 21, "了": 22, "于": 23, "人": 24, "什": 25, "今": 26, "代": 27, "以": 28, "伊": 29, "会": 30, "你": 31, "便": 32, "做": 33, "再": 34, "写": 35, "冰": 36, "几": 37, "出": 38, "到": 39, "十": 40, "卡": 41, "厉": 42, "去": 43, "双": 44, "发": 45, "只": 46, "叫": 47, "可": 48, "吃": 49, "名": 50, "后": 51, "吧": 52, "呀": 53, "呢": 54, "哇": 55, "哈": 56, "哦": 57, "啦": 58, "喜": 59, "喵": 60, "喽": 61, "嗨": 62, "嘛": 63, "嘿": 64, "回": 65, "型": 66, "天": 67, "头": 68, "夸": 69, "好": 70, "娘": 71, "子": 72, "字": 73, "学": 74, "害": 75, "家": 76, "小": 77, "岁": 78, "工": 79, "己": 80, "师": 81, "干": 82, "年": 83, "度": 84, "座": 85, "开": 86, "很": 87, "得": 88, "心": 89, "您": 90, "情": 91, "想": 92, "成": 93, "我": 94, "所": 95, "拜": 96, "摸": 97, "旅": 98, "早": 99, "星": 100, "春": 101, "是": 102, "晚": 103, "暖": 104, "最": 105, "有": 106, "服": 107, "期": 108, "梦": 109, "模": 110, "次": 111, "欢": 112, "正": 113, "淇": 114, "淋": 115, "深": 116, "温": 117, "然": 118, "爱": 119, "猫": 120, "球": 121, "用": 122, "白": 123, "的": 124, "真": 125, "瞳": 126, "码": 127, "神": 128, "程": 129, "第": 130, "红": 131, "纪": 132, "练": 133, "经": 134, "络": 135, "网": 136, "聊": 137, "自": 138, "舒": 139, "萌": 140, "蝶": 141, "行": 142, "被": 143, "见": 144, "训": 145, "记": 146, "诶": 147, "谢": 148, "还": 149, "迷": 150, "遍": 151, "钟": 152, "顺": 153, "鱼": 154, "！": 155, "，": 156, "～": 157, "<PAD>": 0}