更强大的双语对话模型——ChatGLM3

ChatGLM3 是智谱AI和清华大学 KEG 实验室联合发布的新一代对话预训练模型。ChatGLM3-6B 是 ChatGLM3 系列中的开源模型，在保留了前两代模型对话流畅、部署门槛低等众多优秀特性的基础上，ChatGLM3-6B 引入了如下特性：

1、更强大的基础模型：ChatGLM3-6B 的基础模型 ChatGLM3-6B-Base 采用了更多样的训练数据、更充分的训练步数和更合理的训练策略。在语义、数学、推理、代码、知识等不同角度的数据集上测评显示，ChatGLM3-6B-Base 具有在 10B 以下的基础模型中最强的性能。

2、更完整的功能支持：ChatGLM3-6B 采用了全新设计的 Prompt 格式，除正常的多轮对话外。同时原生支持工具调用（Function Call）、代码执行（Code Interpreter）和 Agent 任务等复杂场景。

3、更全面的开源序列：除了对话模型 ChatGLM3-6B 外，还开源了基础模型 ChatGLM3-6B-Base、长文本对话模型 ChatGLM3-6B-32K。以上所有权重对学术研究完全开放，在填写问卷进行登记后亦允许免费商业使用。

这里我们使用ChatGLM3-6B来进行测试，两种方式，一种是单独的web测试，另外一种是用Text-generation-webui

首先我们clone一下https://github.com/THUDM/ChatGLM3.git，然后创建虚拟环境python -m venv venv,激活虚拟环境venv\Scripts\activate ,然后安装相应的依赖包

pip install -r requirements -i https://pypi.tuna.tsinghua.edu.cn/simple

最后下载模型，不方便使用huggingface的同学，可以在modelscope中来进行下载：

from modelscope import snapshot_download
model_dir = snapshot_download("chatglm3-6b", revision = "v1.0.0"，cahe_dir="your model path")

修改web_demo.py的代码如下：

tokenizer = AutoTokenizer.from_pretrained("your model path", trust_remote_code=True)

model = AutoModel.from_pretrained("your model path", trust_remote_code=True).cuda()

接着就可以启动python web_demo.py：

由于显卡限制，生成的速度稍慢，但生成的内容和Claude2比起来还是详细不少。下面的内容是Claude2生成的

好的,这里是一个基于LSTM和PyTorch实现的简单天气预报神经网络的代码示例:
 
 
```python
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
 
 
# 创建Dataset加载天气数据
class WeatherDataset(Dataset):
    def __init__(self, x, y):
        self.x = x 
        self.y = y
        
    def __len__(self):
        return len(self.x)
    
    def __getitem__(self, idx):
        return self.x[idx], self.y[idx]
 
 
# 定义LSTM模型    
class WeatherForecastLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(WeatherForecastLSTM, self).__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers) 
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        out, _ = self.lstm(x)
        out = out[-1, :, :]
        out = self.fc(out)
        return out
 
 
# 准备训练数据        
train_x = # 过去7天气温数据
train_y = # 第8天气温
 
 
train_data = WeatherDataset(train_x, train_y)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
 
 
# 创建LSTM模型
input_size = 1 # 气温数据
seq_length = 7 # 7天数据
num_layers = 1 
hidden_size = 32
output_size = 1 # 预测第8天气温
 
 
model = WeatherForecastLSTM(input_size, hidden_size, num_layers, output_size)
 
 
# 定义损失函数和优化器
criterion = nn.MSELoss() 
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
 
 
# 训练
num_epochs = 100
for epoch in range(num_epochs):
    for batch_x, batch_y in train_loader:
        outputs = model(batch_x)
        loss = criterion(outputs, batch_y)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
    print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
```
 
 
这个模型利用LSTM网络学习天气时间序列数据的长期依赖关系,可以用于预测未来天气。我们可以根据不同的实际天气数据调整模型结构,添加更多特征,进一步提升预报精度。

下面是ChatGLM3生成的内容

要使用 LSTM 和 PyTorch 实现一个天气预报的神经网络，你需要完成以下步骤：
1. 准备数据：首先，你需要准备一个包含日期和对应的温度、湿度、风速等气象数据的数据集。数据集可以是 CSV 文件、Excel 文件或其他格式。确保数据集中的每个日期都有对应的温度、湿度、风速等气象数据。
2. 数据预处理：将数据集按日期排序，将日期转换为 PyTorch 中的 Tensor。将温度、湿度、风速等气象数据 corresponding_to 字段添加到每个样本的 Tensor 中。
3. 定义模型：定义一个包含 LSTM 层的神经网络模型。LSTM 是一种适合处理时间序列数据的神经网络。在模型中添加一个全连接层，将 LSTM 层的输出传递给全连接层，并使用 softmax 函数输出预测的天气状况（如多云、晴、雨等）。
4. 训练模型：将准备好的数据输入到模型中，使用交叉熵损失函数和随机梯度下降法（SGD）优化器进行训练。在训练过程中，你需要设置一些超参数，如学习率、批次大小、迭代次数等。
5. 验证模型：使用验证集来评估模型的性能。计算模型在验证集上的准确率、损失函数值等指标，以确定模型是否过拟合或欠拟合。
6. 预测：使用训练好的模型对新的日期进行预测。将新的日期转换为 Tensor，然后将 Tensor 输入到模型中，得到预测的天气状况。
下面是一个简单的示例代码：
 
 
 
 
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.preprocessing import LabelEncoder
from torch.utils.data import Dataset, DataLoader
import pandas as pd
# 数据预处理
def preprocess_data(data):
    data['date'] = pd.to_datetime(data['date'])
    data['temperature'] = data['temperature'].astype('float32')
    data['humidity'] = data['humidity'].astype('float32')
    data['wind_speed'] = data['wind_speed'].astype('float32')
    encoder = LabelEncoder()
    data['weather'] = encoder.fit_transform(data['weather'])
    data = data.drop(['weather', 'date'], axis=1)
    return data
class WeatherDataset(Dataset):
    def __init__(self, data):
        self.data = data
    def __len__(self):
        return len(self.data)
    def __getitem__(self, index):
        return self.data.iloc[index]
# 定义模型
class WeatherModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(WeatherModel, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size)
        self.fc = nn.Linear(hidden_size, output_size)
    def forward(self, x):
        lstm_out, _ = self.lstm(x)
        out = self.fc(lstm_out[:, -1, :])
        return out
# 训练模型
def train_model(model, device, train_loader, val_loader, optimizer, epochs, lr):
    model.to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=lr)
    for epoch in range(epochs):
        model.train()
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device), target.to(device)
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()
        model.eval()
        with torch.no_grad():
            total_correct = 0
            total_samples = 0
            for data, target in val_loader:
                data, target = data.to(device), target.to(device)
                output = model(data)
                _, predicted = torch.max(output.data, 1)
                total_correct += (predicted == target).sum().item()
                total_samples += target.size(0)
            accuracy = total_correct / total_samples
            print(f'Epoch {epoch + 1}, Validation Accuracy: {accuracy}')
# 预测
def predict_weather(model, device, test_loader):
    model.eval()
    predictions = []
    with torch.no_grad():
        for data, _ in test_loader:
            data = data.to(device)
            output = model(data)
            _, predicted = torch.max(output.data, 1)
            predictions.extend(predicted.cpu().numpy())
    return predictions
# 主函数
def main():
    # 读取数据
    data = pd.read_csv('weather_data.csv')
    train_data = preprocess_data(data)
    train_dataset = WeatherDataset(train_data)
    val_data = preprocess_data(data)
    val_dataset = WeatherDataset(val_data)
    test_data = preprocess_data(data)
    test_dataset = WeatherDataset(test_data)
    # 定义模型
    input_size = train_data.shape[1]
    hidden_size = 128
    output_size = len(train_data['weather'].unique())
    model = WeatherModel(input_size, hidden_size, output_size)
    # 设备
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    # 数据加载
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=32, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
    # 训练模型
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    train_model(model, device, train_loader, val_loader, optimizer, 10, 0.001)
    # 预测
    predictions = predict_weather(model, device, test_loader)
    print(predictions)
if __name__ == '__main__':
    main()
 
 
这个示例代码只是一个基本的框架，你需要根据你的数据集和需求进行相应的调整。

然后我们在text-generation-webui中调用这个模型，可以参考我前面的图文如何优雅的使用各类LLM来进行配置，我们将下载的模型放到models文件夹，然后启动python server.py --trust-remote-code

整体来说，使用的结果符合预期

感兴趣的同学可以自行体验。