边缘计算场景下的大模型落地：基于 Cherry Studio 的 DeepSeek-R1-0528 本地部署

前言

作为学生，我选择用 Cherry Studio 在本地调用 DeepSeek-R1-0528，完全是被它的实用性和 "性价比" 圈粉。最近在 GitHub 和 AI 社群里，大家都在热议 DeepSeek-R1-0528，尤其是它的数学解题和编程能力。像我在准备数学建模竞赛时，用它推导算法公式，居然能给出比参考答案更简洁的步骤；写 Python 爬虫作业，它甚至能直接帮我优化代码的运行效率，比我自己反复调试快多了。

但我不想把学习数据传到云端，毕竟论文思路、编程作业这些要是泄露，被判定为 "AI 代写" 就麻烦了。Cherry Studio 正好解决了这个痛点，装在我的旧笔记本电脑上都不卡，还能把 DeepSeek-R1-0528 稳稳运行起来。最方便的是，它整合了超多模型，平时写英语作文用翻译模型，期末复习用知识问答模型，切换起来超顺滑。

而且，通过本地部署，我还能把自己整理的错题集、笔记 "喂" 给模型，让它越来越懂我的学习薄弱点。现在它就像我专属的 AI 学习伙伴，既能帮我攻克难题，又不用担心隐私问题，这种安全感和高效学习体验，非常不错。

关于蓝耘api

这里我们调用使用到了蓝耘的api，有的同学就会有疑问了，蓝耘平台是啥，为什么会使用到蓝耘平台呢？我的回答是好用，非常好用。

Cherry Studio 通过集成蓝耘 API，能解锁一些本地部署难以实现的功能：

实时更新模型版本：蓝耘会第一时间同步 DeepSeek 官方的模型升级（比如后续可能推出的 R1-06XX 版本），无需我手动下载更新包，随时能用最新功能。
- 多模型融合调用 ：除了 DeepSeek-R1-0528，蓝耘 API 还支持其他大模型，如通义千问系列
  
  为助力开发者和用户使用，提供高额免费 token 资源包。如每位用户有 500 万 tokens 免费额度，像图中 DeepSeek - V3 资源包总额 5000000 token ，能在不额外付费情况下，尽情开展各类调用测试、开发应用等。

涵盖文本、图像、音视频等多模态模型。如 DeepSeek 系列文生文模型，以及图像、视频生成相关模型，像用于视频生成的 I2V - 01、T2V - 01 等，满足多样化开发需求

获取蓝耘智算平台接入api相关信息

首项我们需要先进行注册

点击链接进行注册

输入正确信息就可以进行登录操作了

注册好了之后，我们来到模型广场

挑选一款你喜欢的模型，我这里调用的就是最新的DeepSeek-R1-0528

我们先点击将模型名称进行复制

/maas/deepseek-ai/DeepSeek-R1-0528

然后去申请api

点击创建API就行了

将api复制下来，需要获取的信息我们已经都搞定了，下面就是教大家如何使用Cherry Studio进行api链接

Cherry Studio的下载

我们点击Cherry Studio 官方网站 - 全能的AI助手进行本地应用的下载

登录上应用，一开始是下面这个样子的

点击左下角的小齿轮进行设置操作，我们就进入到模型服务的界面了，然后我们就进行蓝耘平台的添加操作就行了

点击添加

填写相关的信息

然后这里我们需要填写两个信息，一个是api一个是api访问地址

我们直接将刚刚创建的api填写到第一个空里面去

api地址的话我们就直接输入https://maas-api.lanyun.net就行了

然后点击添加模型 /maas/deepseek-ai/DeepSeek-R1-0528

然后这里就可以显示的看到具体的信息了

我们可以点击检测，看看是否能够成功调用

我这里显示连接成功

我们这里也是可以将其他的模型都添加进来的

然后我们回到主页，点击上方模型，选择我们的ai

我们这里可以先试探性的询问下你是谁

这里他的反应速度真的快，生成答案加上思考时间比原版本的R1快很多了

我接着询问你帮我生成一份对抗学习的代码

Python 复制代码

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 设置随机种子保证可复现性
torch.manual_seed(42)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 数据加载与预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_set = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=128, shuffle=True)

test_set = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=256, shuffle=False)

# 定义简单CNN模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
        
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# FGSM攻击函数
def fgsm_attack(image, epsilon, data_grad):
    sign_data_grad = data_grad.sign()
    perturbed_image = image + epsilon * sign_data_grad
    perturbed_image = torch.clamp(perturbed_image, -1, 1)  # 保持像素值在[-1,1]范围内
    return perturbed_image

# 对抗训练函数
def adversarial_train(model, device, train_loader, optimizer, epoch, epsilon=0.3):
    model.train()
    total_loss = 0
    correct = 0
    
    for data, target in train_loader:
        data, target = data.to(device), target.to(device)
        data.requires_grad = True
        
        # 前向传播
        output = model(data)
        loss = criterion(output, target)
        
        # 反向传播获取梯度
        optimizer.zero_grad()
        loss.backward()
        data_grad = data.grad.data
        
        # 生成对抗样本
        perturbed_data = fgsm_attack(data, epsilon, data_grad)
        
        # 使用对抗样本重新训练
        optimizer.zero_grad()
        output_adv = model(perturbed_data)
        loss_adv = criterion(output_adv, target)
        loss_adv.backward()
        optimizer.step()
        
        total_loss += loss_adv.item()
        pred = output_adv.argmax(dim=1, keepdim=True)
        correct += pred.eq(target.view_as(pred)).sum().item()
    
    # 计算平均损失和准确率
    avg_loss = total_loss / len(train_loader.dataset)
    accuracy = 100. * correct / len(train_loader.dataset)
    print(f'Epoch: {epoch} | Train Loss: {avg_loss:.4f} | Accuracy: {accuracy:.2f}%')
    return avg_loss, accuracy

# 测试函数（包含对抗样本测试）
def test(model, device, test_loader, epsilon=0.3):
    model.eval()
    test_loss = 0
    correct = 0
    adv_correct = 0
    
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)
        
        # 正常测试
        output = model(data)
        test_loss += criterion(output, target).item()
        pred = output.argmax(dim=1, keepdim=True)
        correct += pred.eq(target.view_as(pred)).sum().item()
        
        # 生成对抗样本测试
        data.requires_grad = True
        output = model(data)
        loss = criterion(output, target)
        model.zero_grad()
        loss.backward()
        data_grad = data.grad.data
        perturbed_data = fgsm_attack(data, epsilon, data_grad)
        
        # 在对抗样本上测试
        output_adv = model(perturbed_data)
        pred_adv = output_adv.argmax(dim=1, keepdim=True)
        adv_correct += pred_adv.eq(target.view_as(pred_adv)).sum().item()
    
    # 计算指标
    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    adv_accuracy = 100. * adv_correct / len(test_loader.dataset)
    
    print(f'Test set: Average loss: {test_loss:.4f}')
    print(f'Normal Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)')
    print(f'Adversarial Accuracy: {adv_correct}/{len(test_loader.dataset)} ({adv_accuracy:.2f}%)')
    return accuracy, adv_accuracy

# 训练与测试
epochs = 10
train_losses = []
normal_accs = []
adv_accs = []

for epoch in range(1, epochs + 1):
    print(f"\n--- Epoch {epoch} ---")
    loss, acc = adversarial_train(model, device, train_loader, optimizer, epoch)
    normal_acc, adv_acc = test(model, device, test_loader)
    
    train_losses.append(loss)
    normal_accs.append(normal_acc)
    adv_accs.append(adv_acc)

# 绘制结果
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.plot(train_losses, label='Training Loss')
plt.title('Training Loss')
plt.xlabel('Epochs')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(normal_accs, label='Normal Accuracy')
plt.plot(adv_accs, label='Adversarial Accuracy')
plt.title('Test Accuracy')
plt.xlabel('Epochs')
plt.legend()
plt.tight_layout()
plt.savefig('results.png')
plt.show()

我们可以调用其他的模型让其他的模型分析下这个代码的专业性

我们这里就使用到了通义千问了

他这里也会进行思考操作

这个总结也是可以的。到这里我们的实验就结束了，你如果也想体验下deepseek的最新模型，你不妨去试试呢，确实挺不错的。

总结

在速度上，Cherry Studio 具备轻量级特性，运行流畅，搭配蓝耘 API 优化的底层架构、强劲算力及深度算法，能快速响应指令。无论是处理复杂文本生成，还是进行大规模数据推理，都能高效完成，大幅缩短等待时间。

如果你也感兴趣的话，不妨来试试呢下方链接注册就ok了

bash 复制代码

https://cloud.lanyun.net/#/registerPage?promoterCode=5663b8b127