深度学习在哲学研究中的应用

    import torch 
    import torch.nn as nn
    from torch.utils.data import Dataset, DataLoader
    import os 
    
    python

    # 读取语料
    def read_corpus(path):
    with open(path, encoding='utf-8') as f:
        data = f.read()
    return data
    
    # 构造字符级别的数据批次      
    class CorpusDataset(Dataset):
    
    def __init__(self, data, seq_len):
        self.words = data
        self.seq_len = seq_len
        self.chars = sorted(list(set(self.words)))
        self.vocab_size = len(self.chars)
    
        # 建立字符-索引映射
        self.char2idx = {c: i for i, c in enumerate(self.chars)}
        self.idx2char = {i: c for i, c in enumerate(self.chars)}
    
    def __len__(self):
        return len(self.words) - self.seq_len
    
    def __getitem__(self, i):
        x = [self.char2idx[c] for c in self.words[i:i+self.seq_len]]
        y = [self.char2idx[c] for c in self.words[i+1:i+self.seq_len+1]]
        return torch.tensor(x), torch.tensor(y)
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-18/Cl3yejYPiE8cf90q7kBgmdNHGuMp.png)

    class LSTMModel(nn.Module):
    
    def __init__(self, vocab_size, hidden_dim):
        super().__init__()
        self.vocab_size = vocab_size
        self.hidden_dim = hidden_dim
    
        self.embed = nn.Embedding(vocab_size, hidden_dim)
        self.lstm = nn.LSTM(hidden_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, vocab_size)
    
    def forward(self, x, prev_state):
        embed = self.embed(x)
        output, state = self.lstm(embed, prev_state)
        logits = self.fc(output)
        return logits, state
    
    def init_state(self, batch_size):
        weight = next(self.parameters()).data
        return (weight.new(1, batch_size, self.hidden_dim).zero_().cuda(),
                weight.new(1, batch_size, self.hidden_dim).zero_().cuda())
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-18/2GHsD4ayv9CMuWQgAf1wVNRdF85o.png)

    # 超参数设置  
    seq_len = 100
    batch_size = 64
    vocab_size = len(corpus.chars)
    hidden_dim = 256
    n_epochs = 20
    
    # 损失函数和优化器
    criterion = nn.CrossEntropyLoss()  
    model = LSTMModel(vocab_size, hidden_dim).cuda()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    
    # 训练循环
    for epoch in range(n_epochs):
    
    # 设置初始状态
    state = model.init_state(batch_size)
    
    for x, y in data_loader:
        optimizer.zero_grad()
        x, y = x.cuda(), y.cuda()
        logits, state = model(x, state)
        loss = criterion(logits.view(-1, vocab_size), y.view(-1))
    
        loss.backward()
        optimizer.step()
    
    print(f"Epoch {epoch}, loss: {loss.item()}")
    
    # 保存模型
    model_path = "model.pth"
    torch.save(model.state_dict(), model_path)
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-18/iaVqUeLcJI0ZxHB2NmGKtTQvSn85.png)

    # 恢复模型权重  
    model.load_state_dict(torch.load(model_path))
    
    # 随机初始化输入
    idx = torch.randint(vocab_size, (1,)).cuda()
    input_seed = [corpus.idx2char[idx]]
    
    # 生成循环
    state = model.init_state(1)
    for i in range(500):
    x = torch.tensor([corpus.char2idx[c] for c in input_seed[-seq_len:]]).view(1,-1).cuda()
    logits, state = model(x, state)
    idx = torch.multinomial(logits[-1].exp(), 1)[0]  # 采样下一个字符
    char = corpus.idx2char[idx]
    input_seed.append(char)
    
    # 输出生成文本    
    print("".join(input_seed))
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-18/ipOVNM8WXhIg0GFLf93YtumB5yAe.png)