深度学习——基于卷积神经网络实现食物图像分类【1】（datalodar处理方法）

原创 已于 2025-06-14 17:32:41 修改 · 1k 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#深度学习 #cnn #图像分类 #卷积神经网络 #pytorch

于 2025-06-14 17:29:56 首次发布

文章目录

1. 项目概述

在这个项目中，我们将使用PyTorch框架构建一个卷积神经网络(CNN)来实现食物图像分类任务。我们的数据集包含20种不同的食物类别，包括八宝粥、巴旦木、白萝卜、板栗等常见食物。本文将详细介绍从数据准备、模型构建到训练和评估的完整流程。

2. 环境准备

首先，我们需要导入必要的Python库：

import torch
import torchvision.models as models
from torch import nn
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import numpy as np
import os

3. 数据准备与预处理

3.1 数据转换定义

我们定义了两组数据转换，分别用于训练集和验证集：

data_transforms = {
    'train': transforms.Compose([
        transforms.Resize([256,256]),   # 统一图像大小为256x256
        transforms.ToTensor(),          # 转换为PyTorch张量
    ]),
    'valid': transforms.Compose([
        transforms.Resize([256,256]),
        transforms.ToTensor(),
    ]),
}

3.2 数据文件准备

我们编写了一个函数来生成包含图像路径和标签的文本文件：

def train_test_file(root, dir):
    file_txt = open(dir+'.txt','w')
    path = os.path.join(root, dir)
    for roots, directories, files in os.walk(path):
        if len(directories) != 0:
            dirs = directories
        else:
            now_dir = roots.split('\\')
            for file in files:
                path_1 = os.path.join(roots, file)
                file_txt.write(path_1+' '+str(dirs.index(now_dir[-1]))+'\n')
    file_txt.close()

# 调用函数生成训练集和测试集文件
root = r'.\食物分类\food_dataset'
train_dir = 'train'
test_dir = 'test'
train_test_file(root, train_dir)
train_test_file(root, test_dir)
  • 生成的 txt 文件如下所示，包含图片的路径、类别和对应的标签

在这里插入图片描述

3.3 自定义数据集类

我们创建了一个继承自torch.utils.data.Dataset的自定义数据集类：

class food_dataset(Dataset):
    def __init__(self, file_path, transform=None):
        self.file_path = file_path
        self.imgs = []
        self.labels = []
        self.transform = transform
        with open(self.file_path) as f:
            samples = [x.strip().split(' ') for x in f.readlines()]
            for img_path, label in samples:
                self.imgs.append(img_path)
                self.labels.append(label)
    
    def __len__(self):
        return len(self.imgs)
    
    def __getitem__(self, idx):
        image = Image.open(self.imgs[idx])
        if self.transform:
            image = self.transform(image)
        label = self.labels[idx]
        label = torch.from_numpy(np.array(label, dtype=np.int64))
        return image, label

3.4 创建数据加载器

training_data = food_dataset(file_path='train.txt', transform=data_transforms['train'])
test_data = food_dataset(file_path='test.txt', transform=data_transforms['valid'])

train_dataloader = DataLoader(training_data, batch_size=16, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=16, shuffle=True)

4. 模型构建

我们定义了一个包含三个卷积层的CNN模型：

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        # 第一个卷积块
        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 16, 5, 1, 2),  # (16,256,256)
            nn.ReLU(),
            nn.MaxPool2d(2),             # (16,128,128)
        )
        # 第二个卷积块
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, 5, 1, 2),  # (32,128,128)
            nn.ReLU(),
            nn.MaxPool2d(2),            # (32,64,64)
        )
        # 第三个卷积块
        self.conv3 = nn.Sequential(
            nn.Conv2d(32, 64, 5, 1, 2),  # (64,64,64)
            nn.ReLU(),
            nn.MaxPool2d(2),             # (64,32,32)
        )
        # 全连接层
        self.out = nn.Linear(64*32*32, 20)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.size(0), -1)      # 展平操作
        output = self.out(x)
        return output

5. 训练与评估

5.1 设备选择

device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")
model = CNN().to(device)

5.2 训练函数

def train(dataloader, model, loss_fn, optimizer):
    model.train()
    batch_size_num = 1
    for X, y in dataloader:
        X, y = X.to(device), y.to(device)
        pred = model(X)
        loss = loss_fn(pred, y)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if batch_size_num % 100 == 0:
            print(f"loss: {loss.item():>7f} [number:{batch_size_num}]")
        batch_size_num += 1

5.3 测试函数

labels = {0:"八宝粥", 1:"巴旦木", 2:"白萝卜", 3:"板栗", 4:"菠萝", 5:"草莓",
          6:"蛋", 7:"蛋挞", 8:"骨肉相连", 9:"瓜子", 10:"哈密瓜", 11:"汉堡",
          12:"胡萝卜", 13:"火龙果", 14:"鸡翅", 15:"青菜", 16:"生肉", 17:"圣女果",
          18:"薯条", 19:"炸鸡"}

def Test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    model.eval()
    test_loss, correct = 0, 0
    
    with torch.no_grad():
        for X, y in dataloader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    
    test_loss /= num_batches
    correct /= size
    result = zip(pred.argmax(1).tolist(), y.tolist())
    for i in result:
        print(f"当前测试的结果为：{labels[i[0]]}\t当前真实的结果为：{labels[i[1]]}")
    print(f"\n最终测试结果: \n 准确率:{(100*correct):.2f}%, 平均损失:{test_loss:.4f}")

5.4 模型训练与评估

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

epochs = 10
for t in range(epochs):
    print(f"epoch {t+1}\n---------------")
    train(train_dataloader, model, loss_fn, optimizer)
print("Done!")
Test(test_dataloader, model, loss_fn)

6. 关键点解析

  1. 数据预处理：

    • 统一图像大小(256x256)
    • 转换为PyTorch张量
    • 自动归一化到[0,1]范围

  2. 模型结构：

    • 三个卷积块，每个块包含卷积层、ReLU激活和最大池化
    • 逐步增加通道数(16→32→64)
    • 逐步减小特征图尺寸(256→128→64→32)
    • 全连接层输出20个类别的概率分布

  3. 训练技巧：

    • 使用Adam优化器，学习率设为0.001
    • 交叉熵损失函数
    • 批量大小为16
    • 训练10个epoch

  4. 评估方法：

    • 计算整体准确率
    • 计算平均损失
    • 展示部分预测结果与真实标签的对比

7. 可能的改进方向

  1. 数据增强：在训练时添加随机翻转、旋转等增强技术，提高模型泛化能力
  2. 学习率调度：使用学习率衰减策略，如StepLR或ReduceLROnPlateau
  3. 模型优化：尝试更深的网络结构或预训练模型(如ResNet)
  4. 正则化：添加Dropout层或L2正则化防止过拟合
  5. 超参数调优：系统性地调整学习率、批量大小等超参数

8. 完整代码

import torch
import torchvision.models as models
from torch import nn
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import numpy as np
import os

data_transforms = { #字典
    'train':
        transforms.Compose([            #对图片预处理的组合
        transforms.Resize([256,256]),   #对数据进行改变大小
        transforms.ToTensor(),          #数据转换为tensor
    ]),
    'valid':
        transforms.Compose([
        transforms.Resize([256,256]),
        transforms.ToTensor(),
    ]),
}

def train_test_file(root,dir):
    file_txt = open(dir+'small.txt','w')
    path = os.path.join(root,dir)
    for roots,directories,files in os.walk(path):
        if len(directories) !=0:
            dirs = directories
        else:
            now_dir = roots.split('\\')
            for file in files:
                path_1 = os.path.join(roots,file)
                print(path_1)
                file_txt.write(path_1+' '+str(dirs.index(now_dir[-1]))+'\n')

    file_txt.close()

root = r'.\食物分类\food_dataset'
train_dir = 'train'
test_dir = 'test'
train_test_file(root,train_dir)
train_test_file(root,test_dir)

#Dataset是用来处理数据的
class food_dataset(Dataset):        # food_dataset是自己创建的类名称，可以改为你需要的名称
    def __init__(self,file_path,transform=None):    #类的初始化，解析数据文件txt
        self.file_path = file_path
        self.imgs = []
        self.labels = []
        self.transform = transform
        with open(self.file_path) as f: #是把train.txt文件中的图片路径保存在self.imgs
            samples = [x.strip().split(' ') for x in f.readlines()]
            for img_path,label in samples:
                self.imgs.append(img_path)  #图像的路径
                self.labels.append(label)   #标签，还不是tensor

# 初始化：把图片目录加到self
    def __len__(self):  #类实例化对象后，可以使用len函数测量对象的个数
        return  len(self.imgs)

    #training_data[1]
    def __getitem__(self, idx):    #关键，可通过索引的形式获取每一个图片的数据及标签
        image = Image.open(self.imgs[idx])  #读取到图片数据，还不是tensor，BGR
        if self.transform:                  #将PIL图像数据转换为tensor
            image = self.transform(image)   #图像处理为256*256，转换为tensor

        label = self.labels[idx]    #label还不是tensor
        label = torch.from_numpy(np.array(label,dtype=np.int64))    #label也转换为tensor
        return image,label
#training_data包含了本次需要训练的全部数据集
training_data = food_dataset(file_path='train.txt', transform=data_transforms['train'])
test_data = food_dataset(file_path='test.txt', transform=data_transforms['valid'])

#training_data需要具备索引的功能，还要确保数据是tensor
train_dataloader = DataLoader(training_data,batch_size=16,shuffle=True)
test_dataloader = DataLoader(test_data,batch_size=16,shuffle=True)


'''判断当前设备是否支持GPU，其中mps是苹果m系列芯片的GPU'''
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")   #字符串的格式化，CUDA驱动软件的功能：pytorch能够去执行cuda的命令
# 神经网络的模型也需要传入到GPU，1个batch_size的数据集也需要传入到GPU，才可以进行训练


''' 定义神经网络  类的继承这种方式'''
class CNN(nn.Module): #通过调用类的形式来使用神经网络，神经网络的模型，nn.mdoule
    def __init__(self): #输入大小：(3,256,256)
        super(CNN,self).__init__()  #初始化父类
        self.conv1 = nn.Sequential( #将多个层组合成一起，创建了一个容器，将多个网络组合在一起
            nn.Conv2d(              # 2d一般用于图像，3d用于视频数据（多一个时间维度），1d一般用于结构化的序列数据
                in_channels=3,      # 图像通道个数，1表示灰度图（确定了卷积核 组中的个数）
                out_channels=16,     # 要得到多少个特征图，卷积核的个数
                kernel_size=5,      # 卷积核大小 3×3
                stride=1,           # 步长
                padding=2,          # 一般希望卷积核处理后的结果大小与处理前的数据大小相同，效果会比较好
            ),                      # 输出的特征图为(16,256,256)
            nn.ReLU(),  # Relu层，不会改变特征图的大小
            nn.MaxPool2d(kernel_size=2),    # 进行池化操作(2×2操作),输出结果为(16,128,128)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16,32,5,1,2),  #输出(32,128,128)
            nn.ReLU(),  #Relu层  (32,128,128)
            nn.MaxPool2d(kernel_size=2),    #池化层，输出结果为(32,64,64)
        )
        self.conv3 = nn.Sequential(
            nn.Conv2d(32, 64, 5, 1, 2),  # 输出(64,64,64)
            nn.ReLU(),  # Relu层  (64,64,64)
            nn.MaxPool2d(kernel_size=2),  # 池化层，输出结果为(64,32,32)
        )
        self.out = nn.Linear(64*32*32,20)  # 全连接层得到的结果


    def forward(self,x):   #前向传播，你得告诉它 数据的流向 是神经网络层连接起来，函数名称不能改
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.size(0),-1)    # flatten操作，结果为：(batch_size,32 * 64 * 64)
        output = self.out(x)
        return output
model = CNN().to(device) #把刚刚创建的模型传入到GPU
print(model)


def train(dataloader,model,loss_fn,optimizer):
    model.train() #告诉模型，我要开始训练，模型中w进行随机化操作，已经更新w，在训练过程中，w会被修改的
# pytorch提供2种方式来切换训练和测试的模式，分别是：model.train() 和 mdoel.eval()
# 一般用法是：在训练开始之前写上model.train(),在测试时写上model.eval()
    batch_size_num = 1
    for X,y in dataloader:              #其中batch为每一个数据的编号
        X,y = X.to(device),y.to(device) #把训练数据集和标签传入cpu或GPU
        pred = model.forward(X)         # .forward可以被省略，父类种已经对此功能进行了设置
        loss = loss_fn(pred,y)          # 通过交叉熵损失函数计算损失值loss
        # Backpropagation 进来一个batch的数据，计算一次梯度，更新一次网络
        optimizer.zero_grad()           # 梯度值清零
        loss.backward()                 # 反向传播计算得到每个参数的梯度值w
        optimizer.step()                # 根据梯度更新网络w参数

        loss_value = loss.item()        # 从tensor数据种提取数据出来，tensor获取损失值
        if batch_size_num %100 ==0:
            print(f"loss: {loss_value:>7f} [number:{batch_size_num}]")
        batch_size_num += 1



labels={0:"八宝粥",1:"巴旦木",2:"白萝卜",3:"板栗",4:"菠萝",5:"草莓",
           6:"蛋",7:"蛋挞",8:"骨肉相连",9:"瓜子",10:"哈密瓜",11:"汉堡",
           12:"胡萝卜",13:"火龙果",14:"鸡翅",15:"青菜",16:"生肉",17:"圣女果",
           18:"薯条",19:"炸鸡"}

def Test(dataloader,model,loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)  # 打包的数量
    model.eval()        #测试，w就不能再更新
    test_loss,correct =0,0

    with torch.no_grad():       #一个上下文管理器，关闭梯度计算。当你确认不会调用Tensor.backward()的时候
        for X,y in dataloader:
            X,y = X.to(device),y.to(device)
            pred = model(X) #等价于model.forward(X)

            test_loss += loss_fn(pred,y).item() #test_loss是会自动累加每一个批次的损失值
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
            a = (pred.argmax(1) == y) #dim=1表示每一行中的最大值对应的索引号，dim=0表示每一列中的最大值对应的索引号
            b = (pred.argmax(1) == y).type(torch.float)
    test_loss /= num_batches #能来衡量模型测试的好坏
    correct /= size  #平均的正确率
    result = zip(pred.argmax(1).tolist(), y.tolist())
    for i in result:
        print(f"当前测试的结果为：{labels[i[0]]}\t当前真实的结果为：{labels[i[1]]}")
    print(f"\n最终测试结果: \n 准确率:{(100*correct):.2f}%, 平均损失:{test_loss:.4f}")

loss_fn = nn.CrossEntropyLoss()  #创建交叉熵损失函数对象，因为手写字识别一共有十种数字，输出会有10个结果

optimizer = torch.optim.Adam(model.parameters(),lr=0.001) #创建一个优化器，SGD为随机梯度下降算法
# # params：要训练的参数，一般我们传入的都是model.parameters()
# # lr:learning_rate学习率，也就是步长
#
# # loss表示模型训练后的输出结果与样本标签的差距。如果差距越小，就表示模型训练越好，越逼近真实的模型
# train(train_dataloader,model,loss_fn,optimizer) #训练1次完整的数据。多轮训练
# Test(test_dataloader,model,loss_fn)

epochs = 10
for t in range(epochs):
    print(f"epoch {t+1}\n---------------")
    train(train_dataloader,model,loss_fn,optimizer)
print("Done!")
Test(test_dataloader,model,loss_fn)

9. 总结

本文详细介绍了使用PyTorch实现食物图像分类的完整流程，包括数据准备、模型构建、训练和评估。通过这个项目，我们学习到了：

  1. 如何自定义数据集类来处理图像数据
  2. 如何构建一个有效的CNN模型
  3. PyTorch训练循环的基本结构
  4. 模型评估的方法和指标

这个项目可以作为计算机视觉任务的入门实践，为后续更复杂的图像分类任务打下基础。读者可以尝试修改模型结构或调整超参数，观察对模型性能的影响。

E-An居士
关注
【大模型】DeepSeek + Coze 打造个人专属AI智能体使用详解
congge
04-16 1万+
DeepSeek + Coze 打造个人专属AI智能体使用详解
1️⃣ Coze智能体基础入门教学（2025年全新版本）
李同学Lino的博客
04-06 1621
不妨设想一下，倘若我们能够打造出一个数字助手，它不但能精准洞悉我们的需求，更可以独立思索、学习以及付诸行动，这便是 AI Agent 的基础理念。它恰似计算机世界里的 “智慧精灵”，能够感知周遭环境、做出判断并采取行动。AI Agent 的发展之路精彩纷呈。它走过了三个重要阶段：起初，它犹如一个被规则束缚的机器人，只能按预设好的指令开展工作。接着，它学会运用统计学方法，通过分析数据来做决策，变得越发灵活。到如今，凭借深度学习技术，它已经能够像人类一样去学习复杂的任务了。
完结15章AI 智能体从入门到高级（COZE版）零基础/零代码课程
最新发布
07-02
引言：AI智能体时代已来 在数字化浪潮席卷全球的今天，人工智能已不再是科幻电影中的遥远概念，而是真切地改变着我们工作与生活的日常工具。特别是AI智能体的出现，让"人人可创造"的智能应用时代真正到来。COZE作为一款革命性的AI智能体开发平台，以其零代码、可视化的特点，彻底打破了技术门槛，让没有任何编程背景的普通用户也能轻松构建属于自己的智能助手。 AI智能体不同于传统的程序，它具有学习能力、决策能力和自然交互能力，能够理解用户意图并自主完成任务。从简单的问答机器人到复杂的业务流程自动化，AI智能体的应用场景几乎无限。而COZE平台将这些强大功能的实现过程简化到了极致，通过拖拽式界面和模块化设计，让创意而非技术成为唯一的限制因素。 本指南将从零开始，带领读者探索COZE平台的奥秘，从基础概念到高级应用，从简单对话机器人到多功能集成智能体，一步步掌握AI智能体开发的核心技能。无论你是完全的技术小白，还是希望拓展技能边界的专业人士，都能在这趟学习旅程中找到属于自己的成长路径
零基础！扣子（coze）工作流搭建入门教程【手把手教会】
Z987421的博客
05-26 4324
简单来说，工作流就是一套“流水线操作指南”。 就像我们做菜的流程一样： 先洗菜→切菜→开火→倒油→炒菜→放调料→出锅 每一步按顺序来，最后菜出锅不好吃是哪一步出了问题，今天的菜非常好吃，又是哪一步进行了优化，明明白白。 这就是工作流的魅力——把复杂的事情拆成简单的小步骤，让不同的人或者工具都能高效配合。
扣子（Coze）轻松创建简单智能体：一个属于你自己的AI第二大脑
qq_73786393的博客
04-22 2070
简单说，​​扣子（Coze）​​是字节跳动新发的一款AI工具，能够让你像搭积木一样，不用再去写那繁琐代码就做出一个能聊天、能干活儿的AI助手。这里up准备带领大家使用扣子工具制作一个个人知识库AI，作用是帮助大家完成本地化的知识管理，使其成为个人的第二个大脑。存储个人知识的系统（无论是叫“个人知识库”“第二大脑”还是说是“AI知识图谱”）本质上都是是属于一个​。👉 点击上方网址，开启你的AI知识管理之旅！​，让AI自动优化你的智能体设定！🚀 你的AI知识库助手已初步成型！
开源大模型项目，助你效率提高 10 倍
2401_85375298的博客
10-23 1643
Flowise 是一款开源 UI 可视化工具，用于构建定制的 LLM 编排流程和 AI 代理。" )}
coze(扣子)智能体和AI应用从入门到精通(保姆式教程)
程序老曹的博客
02-22 2万+
扣子是新一代 AI 应用开发平台。无论你是否有编程基础，都可以在扣子上快速搭建基于大模型的各类 AI 应用，并将 AI 应用发布到各个社交平台、通讯软件，也可以通过 API 或 SDK 将 AI 应用集成到你的业务系统中。这个 天生漫画师 应用支持用户输入一段故事梗概或者片段，点击生成漫画就可以获得到根据自己创建的工作流生成的相对应的漫画图片。
从头到尾，手把手教你使用扣子（coze）搭建自己的AI智能体
chenzijun2016的博客
03-31 1万+
只要跟着做，就会使用coze搭建智能体
AI智能体｜使用扣子Coze搭建AI智能体，看这一篇就够了（新手必看）
热门推荐
无界生长的博客
05-02 6万+
本文详细的介绍了通过Coze平台创建和发布AI智能体的流程，包括填写Bot信息、编写提示词、添加技能和知识库、设置开场白、预览调试，最后发布到平台供用户使用。
用扣子(Coze)搭建Bot智能体详解
agentfans的博客
07-13 3万+
本文对扣子（Coze）智能体平台进行了简单介绍，包括扣子的基本概况、Bot的应用场景、扣子平台的基本能力、在扣子上搭建智能体的方法和步骤，后续会逐步分享扣子的其它玩法。，
AI智能体实战｜使用扣子Coze搭建AI智能体，看这一篇就够了（新手必读）
wxaiway的博客
11-09 2万+
本文介绍了如何使用 Coze 搭建 AI 智能体的步骤，包括创建智能体（登陆平台点击 “创建智能体” 并填写信息）、编写提示词（选择运行模式和大语言模型，填写并优化提示词）、添加技能（设置开场白）、预览与调试、发布智能体（填写发布记录选择发布平台）以及使用智能体（查看和测试）。在编辑页左侧的“人设与回复逻辑”框，填写智能体的提示词，提示词内容与智能体功能相关，填写完成后，可点击右上角的“优化”按钮，让Coze帮你优化一下提示词。调试确认Bot功能正常后，点击右上角的“发布”按钮，发布Bot。
扣子(coze)平台对接飞书多维表格踩坑了。浪费了2 个小时？
涛涛讲AI
03-29 1474
今天本来想着录一节视频课程，内容为扣子对接飞书多维表格的视频。结果被飞书多维表格Api坑了两小时。
深入浅出剖析LLM应用开发平台Coze/扣子平台
女王の专属领地
08-23 2850
Coze 是新一代一站式 AI Bot 开发平台。无论你是否有编程基础，都可以在 Coze 平台上快速搭建基于 AI 模型的各类问答 Bot，从解决简单的问答到处理复杂逻辑的对话。并且，你可以将搭建的 Bot 发布到各类社交平台和通讯软件上，与这些平台/软件上的用户互动。
一文了解清楚「Agent开发平台」工具！
女王の专属领地
01-15 3236
官方GPTs商店：各大平台均设有官方GPTs应用商店，汇聚了琳琅满目的插件与模型，满足多元化需求。知识库：在知识库构建上，各平台展现独特风采，内容既广泛又深入，助力用户轻松获取所需信息。流程图编排： 流程图编排功能作为标配，让无编程基础的用户也能通过直观拖拽，迅速构建高效工作流，实现流程自动化。多模型支持： 对于模型支持，部分平台展现开放姿态，兼容多模型选择；而有的则专注于自家大模型深度优化，但无论哪种，均能有效支撑日常工作的顺利进行。
一文掌握大模型提示词技巧：从战略到战术
2401_87555412的博客
10-23 1065
当提示词过长时，优先考虑将用户的输入放在开头或最后，如果将用户输入放在中间而且提示词中有示例，模型很可能将示例作为用户输入进行处理。##1 角色请你扮演中国软件水平考试高级辅导专家，负责用户发送的概念讲解和发送的题目解答。##2 技能### 技能1：概念讲解当我发送一些概念或者软考概念讲解的截图时（使用 OCR 将图片中的文字提取出来）。Step1：根据概括或截图帮我讲解一下相关内容，讲解时尽量通俗易懂，并给出恰当的例子，优先使用 markdown 表格的形式来呈现。
深入浅出剖析开源的 LLM应用开发平台Dify
女王の专属领地
10-24 3821
Dify是一款开源的大语言模型（LLM）应用开发平台。它融合了后端即服务（Backend as Service）和LLMOps的理念，使开发者可以快速搭建生产级的生成式AI应用。即使非技术人员，也能参与到AI应用的定义和数据运营过程中。同时Dify内置了构建LLM应用所需的关键技术栈，这为开发者节省了许多重复造轮子的时间，使其可以更加专注在创新和业务需求上。官网： https://dify.ai/zh工作流程：在可视化画布上构建和测试强大的 AI 工作流程，利用以下所有功能及其他功能。
拥有扣子，人人都是AI设计师
sugar_luo的博客
03-19 2572
AI云开发平台扣子创建应用实例分享，个人使用经验。
“扣子”开发之一：“扣子”初体验
F8_11的博客
12-29 4906
扣子”的英文名叫Coze，这个名字大概同时匹配了其中英文的发音，也同时契合了扣子的目标功能定位。扣子是新一代 AI 应用开发平台。它是字节跳动公司基于火山引擎（也就是字节跳动提供互联网云服务的平台）和豆包大模型而推出的，供用户定制开发各种AI应用的平台。核心特征：第一、扣子是个开发平台；第二、用扣子开发的是AI应用，包括智能体和功能更为全面的AI应用。
AI智能体|扣子(Coze)全网最详细讲解（保姆级）
小玉的博客
04-30 6513
想象一下，你需要在知乎上回答一个专业问题。传统方式是：搜索资料、制定大纲、编写内容、校对修改，耗时耗力。而单纯使用大模型（如ChatGPT）直接提问，又常常得到不够准确或过时的答案。为什么？大模型无法获取最新信息缺乏规划能力没有持续记忆AI智能体就是解决这些问题的答案！它不只是一个聊天机器人，而是一个可以自主完成复杂任务的数字助手。AI智能体 = 大模型(LLM) + 规划能力 + 记忆功能 + 工具使用。
扣子智能体平台
03-15
### 扣子智能体平台功能与使用说明 #### 平台概述 扣子（Coze）是由字节跳动推出的一款面向终端用户的智能体开发平台[^3]。该平台支持用户通过零代码或低代码方式快速构建基于人工智能大模型的各种智能体应用，并能够将其部署至其他网站或者通过 API 集成到现有的系统中。 #### 快速搭建智能体 无论是具备还是缺乏编程基础的用户，都能够借助扣子平台迅速创建一个 AI 智能体。例如，可以参照一篇教程中的实例来学习如何打造一个解决日常生活问题的小助手[^1]。这不仅降低了技术门槛，还使得更多的人有机会参与到智能化工具的设计过程中去。 #### 插件系统的利用 为了进一步增强所建智能体的能力，在其技能配置环节可加入不同类型的插件。一旦添加成功，则可以在编写提示语句的时候直接调用这些插件，亦或是融入自动化流程里实现更复杂操作逻辑的目的[^2]。这种灵活运用外部资源的方法极大地拓宽了单个智能体所能覆盖的应用场景范围。 ```python # 示例：假设我们有一个简单的 Python 脚本用于模拟调用某个插件功能 def call_plugin(plugin_name, parameters): result = f"Plugin {plugin_name} called with params: {parameters}" return result example_call = call_plugin("weather", {"location": "Beijing"}) print(example_call) ``` 上述代码片段仅作为概念展示之用，实际情况下具体实现会依据官方文档指导完成。 #### 总结 综上所述，扣子智能体平台提供了便捷高效的途径让用户无需深厚编码背景即可打造出满足特定需求的AI解决方案；同时它开放性强允许接入第三方服务从而提升整体性能表现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值