【腾讯云 HAI域探秘】——自行搭建Stable Diffusion模型服务用于生成AI图片 | 自行搭建ChatGL M26BAI模型服务用于AI对话

利用HAI的ChatGLM2 6B做一个即时对话小游戏

ChatGLM2-6B 是开源中英双语对话模型 ChatGLM-6B 的第二代版本，在保留了初代模型对话流畅、部署门槛较低等众多优秀特性的基础之上，ChatGLM2-6B 引入了更强大的性能、更长的上下文、更高效的推理，所以用来做个小游戏非常的合适了。

我基本没有做什么语句优化，直接给了，并且能看到回复的情况，相当可以的呢。接下来我们使用ChatGLM2 6B返回的结果来做个适合大学生们学习的职场即时对话类游戏。 

游戏框架概述

在大学中，我们能学到有限的知识，但是我们要步入社会，想要在短时间内能站稳跟脚绝对是一件很难的事情，那么，我们就可以通过我们这款小游戏来历练我们的对话能力。

游戏接口的用语，可以自己尝试，挺好的。

目标：生成领导与员工的对话语句，来考验员工的职场适应能力。
1、信息1领导提问员工一个问题；
2、信息2是普通员工的回答方式；
3、信息3是优秀员工的回答方式；
4、信息4是领导对信息2普通员工的回复并告知回错误，给予一定的错误惩罚；
5、信息5是领导对信息3优秀员工的回复并告知回正确，给予一定的奖励话语。
6、仅生成以上5条信息，每条信息长度不超过50个字。
7、对话中不能有不文明用语。

这里用到了Stable Diffusion来创建AI图片使游戏变得更加有意思。

例如，下图就是游戏页面，老板生成的时候我写的：

翻译完成后到【Stable Diffusion】里面生成就行，注意反向用语我写的：【(semi-realistic, cgi, 3d, render, sketch, cartoon, drawing, anime:1.1)close up】，反向用词很多我再下面的SD中有说明。

开启ChatGLM2 6B的服务，下面有对应操作。这里建议选用高性能的服务。不然可能起不来。

成功示例： 

有了这个就代表我们有接口了。

先返回到腾讯云，搜索一下Cloud Studio创建一个空项目

创建空项目

编码：

编码完成后就能运行了哦，网页单独的使用【python -m http.server】来启动，不启动无法访问的哦。

自带的内置浏览器访问不效果不如单独打开的，我们可以进行测试以下。

目录

利用HAI的ChatGLM2 6B做一个即时对话小游戏

游戏框架概述

自行搭建Stable Diffusion模型服务用于生成AI图片

一、服务创建

1、服务地址：

2、等待审核(大概24小时)

二、创建服务

1、新建服务

2、选择AI模型：Stable Diffusion

3、等待创建(5~8分钟）

三、操作面板介绍

1、webui操作

2、jupyter_lab操作

四、webui操作步骤

1、中文插件安装

2、配置中文插件操作步骤

3、Reload UI后效果

五、stable Diffusion——AI绘图技巧(特色功能)

六、jupyter_lab操作步骤

 1、进入jupyter_lab操作页面

2、面板功能介绍

3、启动服务

4、添加7862端口规则

3、访问swagger接口

七、python接口解析生成AI图片

1、打开python开发工具

2、创建py文件并输入以下代码

 3、运行效果

Stable Diffusion模型总结

自行搭建ChatGL M26BAI模型服务用于AI对话

一、服务创建

新建服务

服务选择：(这里可以下拉选择大一些的硬盘)

二、操作面板介绍

1、chatglm_gradio:

2、jupyter_lab:

三、基础服务示例(jupyter_lab操作)

1、进入并启动服务

2、启动后开启访问端口(8000)

3、Python接口访问效果

四、正式服务代码

1、修改【openai-api.py】文件

 2、运行【openai-api.py】文件，服务端开启服务

五、可视化页面搭建

1、在创建cloud Studio的时候选择【应用推荐】

2、Fork项目

3、修改【.env.template】文件

4、修改【.env.template】为【.env】文件

六、运行可视化操作页面

1、新建终端

​编辑

2、运行服务

3、选择打开方式

ChatGL M26BAI模型总结、

Pytorch2.0 AI框架视频处理

一、框架选择

二、使用 JupyterLab 体验完整的机器学习工作流程

1、Terminal操作

2、打开root/dataset-fashion-mnist/data/fashion文件夹

3、创建【Notebook】

4、运行方法

5、修改pip环境配置

6、创建Terminal持续运行以下代码 

7、保存模型

8、加载模型并预测

9、预测模型

三、使用 JupyterLab 体验使用字符级循环神经网络(RNN) 生成姓名

1、数据准备

2、新建一个 Notebook 页面，选择 Python 3

3、第八步骤的代码

4、绘制损失

5、网络采样

四、使用 JupyterLab 体验视频抠像神器RobustVideoMatting

1、依赖安装

2、下载实验资源

 3、运行

4、抠图效果

5、换背景效果

Pytorch2.0总结

自行搭建Stable Diffusion模型服务用于生成AI图片

一、服务创建

1、服务地址：

高性能应用服务HAI 新品内测

2、等待审核(大概24小时)

二、创建服务

1、新建服务

2、选择AI模型：Stable Diffusion

高性能，效率更快。

3、等待创建(5~8分钟）

这里可以看到温馨提示，创建中不计费的。

创建完成效果：

三、操作面板介绍

1、webui操作

都是鼠标点击操作，方便。

2、jupyter_lab操作

命令行操作，有一定难度，但是按照步骤可以一步步搞定哦。自己配置接口，多舒服。

四、webui操作步骤

1、中文插件安装

步骤1、选择Extensions、

步骤2、选择Available、

步骤3、按照图示选择

步骤4、搜索zh_CH

步骤5、点击【Load from】进行搜索

搜索效果

搜索【zh_CN】找到后，点击【install】进行安装。

安装完毕效果

2、配置中文插件操作步骤

按照下图操作，其中步骤3是在没有看到zh_CN的情况下刷新一下。

3、Reload UI后效果

刷新后能看到中文的显示状态。刚才我们在扩展中安装了中文的插件，在设置中配置了中文插件。

页面说明，这个图给的描述很详细。

数据示例：

随机种子也可以自己添加，下面的实验我用-1和 

实验效果：

 随机种子实验效果

五、stable Diffusion——AI绘图技巧(特色功能)

在stable Diffusion中会有正向提示词&反向提示词，这个是很独特的一个功能，这里深入的测试一下。

提示词（prompt）由多个词缀构成，分为正向提示词（positive prompt）和反向提示词（negative prompt），用来告诉AI哪些需要，哪些不需要。

注：词缀的权重默认值都是1，从左到右依次减弱，权重会影响画面生成结果。 比如景色Tag在前，人物就会小，相反的人物会变大或半身。 选择正确的顺序、语法来使用提示词，将更好、更快、更有效率地展现所想所愿的画面。

逗号(,)：分割词缀，有一定权重排序功能，逗号前权重高，逗号后权重低，因而建议排序：
综述（图像质量+画风+镜头效果+光照效果+主题+构图）
主体（人物&对象+姿势+服装+道具）
细节（场景+环境+饰品+特征）

权重示例：

冒号(:)：自定义权重数值 格式：左圆括号 + 词缀 + 冒号 + 数字 + 右圆括号
单人女孩词缀，权重为0.75 (1girl:0.75)

()仅圆括号：增加权重0.1 大部分情况用圆括号即可。
权重乘以1.1 (1girl)

{}花括号：增加权重0.05
权重乘以1.05 {1girl}

[] 方括号：减少权重0.1，也有说是减弱0.05的 方括号中无法自定义权重数值，自定义权重只能使用(x:0.5)形式。
权重除以1.1 [1girl]

(())、{{}}、[[]]复用括号：叠加权重
权重乘以1.1*1.1，即权重为1.21 ((1girl))

提示词：

hanfu,tang style outfits,pink upper shan, blue chest po skirt, purple with white waistband, light green pibo, 1girl, blue eyes, gray hair, dusk, over  the  sea, HDR,UHD,8K, best quality, masterpiece, Highly detailed, Studio lighting, ultra-fine painting, sharp focus, physically-based rendering, extreme detail description, Professional, Vivid Colors, close-up view

反向(负面)提示词：

nsfw,logo,text,badhandv4,EasyNegative,ng_deepnegative_v1_75t,rev2-badprompt,verybadimagenegative_v1.3,negative_hand-neg,mutated hands and fingers,poorly drawn face,extra limb,missing limb,disconnected limbs,malformed hands,ugly 

可以直接生成，效果还是不错的，就是时间较长，这里建议使用高一些配置的服务，能快一些。

提示词我们还可以加以修饰一下效果会更好。

1girl, aqua  eyes, lipstick, brown hair, asymmetrical bangs, light smile, in  summer, bamboo  forest, flower  sea, HDR,UHD,8K, best quality, masterpiece, Highly detailed, ultra-fine painting, sharp focus, physically-based rendering, extreme detail description, Professional, Vivid Colors, close-up view, looking at viewer, hanfu, tang style outfits,<lora:hanfuTang_v32:0.5>, red upper shan, blue chest po skirt, orange waistband, light green pibo

我生成了几张图片，这是使用的词语

a young female holding a sign that says “I Love CSDN”, highlights in hair, sitting outside restaurant, brown eyes, wearing a dress, side light,[the: (painting cartoon:1.9): 0.3]

反向词语

painting, cartoon

我生成了6张，可以看看。

六、jupyter_lab操作步骤

 1、进入jupyter_lab操作页面

操作页面效果

2、面板功能介绍

3、启动服务

命令如下，直接复制并【ctrl+v】即可

cd /root/stable-diffusion-webui
python launch.py --nowebui --xformers --opt-split-attention  --listen --port 7862

命令参数描述：

本地启动效果(不支持公网访问，可以看到是127.0.0.1:7862)

启动效果(支持公网访问，可以看到是0.0.0.0:7862)

4、添加7862端口规则

操作1、进入模型操作面板

添加7862端口号码

添加端口操作

3、访问swagger接口

访问地址：ip:7862端口

七、python接口解析生成AI图片

1、打开python开发工具

我们使用的是【PyCharm Community Edition 2023.1.4】版本。

2、创建py文件并输入以下代码

注：这里一定要修改服务的IP，也就是公网的那个IP

import json
import base64
import requests

your_ip = '0.0.0.0' # HAI服务器IP地址
your_port = 7862  # SD api 监听的端口

def submit_post(url: str,data: dict):
  """
  Submit a POST request to the given URL with the given data.
  """
  return requests.post(url,data=json.dumps(data))

def save_encoded_image(b64_image: str,output_path: str):
  """
  Save the given image to the given output path.
  """
  with open(output_path,"wb") as image_file:
      image_file.write(base64.b64decode(b64_image))

if __name__ == '__main__':
  # /sdapi/v1/txt2img
  txt2img_url = f'http://{your_ip}:{your_port}/sdapi/v1/txt2img'
  data = {
     'prompt': 'a pretty cat,cyberpunk art,kerem beyit,very cute robot zen,Playful,Independent,beeple |',
     'negative_prompt':'(deformed,distorted,disfigured:1.0),poorly drawn,bad anatomy,wrong anatomy,extra limb,missing limb,floating limbs,(mutated hands and fingers:1.5),disconnected limbs,mutation,mutated,ugly,disgusting,blurry,amputation,flowers,human,man,woman',
     'Steps':50,
     'Seed':127361827368
  }
  response = submit_post(txt2img_url,data)
  save_encoded_image(response.json()['images'][0],'cat.png')

参数说明

 3、运行效果

可以看到生成的图片就在对应的文件夹内，我们还可以改很多参数。

Stable Diffusion模型总结

图片生成，还是用处非常多的，而且价格也比较划算，使用和配置都很方便，效率也好高，可以自己搭建尝试一下，很棒的。

自行搭建ChatGL M26BAI模型服务用于AI对话

单独访问效果： 

vscode内运行效果：

我们使用腾讯云来创建，有完整的操作流程，很方便我们搭建使用。

一、服务创建

创建效果：

新建服务

服务选择：(这里可以下拉选择大一些的硬盘)

剩余的时间需要等待。

创建完毕效果：

二、操作面板介绍

1、chatglm_gradio:

我们可以直接通过这个网址进行对话操作。

2、jupyter_lab:

创建控制台窗口，可以在这里进行具体的代码编辑与运行。

三、基础服务示例(jupyter_lab操作)

1、进入并启动服务

cd /root/ChatGLM2-6B/
python api.py

运行起来能看到有信息提示。 

2、启动后开启访问端口(8000)

进入到服务详情。

添加防火墙可通过的端口号。 

添加效果：

3、Python接口访问效果

添加后即可访问：http://你的公网IP:8000/ 的这个接口，具体服务参数如下列代码：

import requests

# 定义测试数据，以及FastAPI服务器的地址和端口
server_url = "http://0.0.0.0:8000"  # 请确保将地址和端口更改为您的API服务器的实际地址和端口
test_data = {
    "prompt": "'电影雨人讲的是什么？'",
    "history": [],
    "max_length": 50,
    "top_p": 0.7,
    "temperature": 0.95
}

# 发送HTTP POST请求
response = requests.post(server_url, json=test_data)

# 处理响应
if response.status_code == 200:
    result = response.json()
    print("Response:", result["response"])
    print("History:", result["history"])
    print("Status:", result["status"])
    print("Time:", result["time"])
else:
    print("Failed to get a valid response. Status code:", response.status_code)

访问效果：

四、正式服务代码

1、修改【openai-api.py】文件

使用以下代码覆盖原有的代码：

# coding=utf-8
# Implements API for ChatGLM2-6B in OpenAI's format. (https://platform.openai.com/docs/api-reference/chat)
# Usage: python openai_api.py
# Visit http://localhost:8000/docs for documents.

import time
import torch
import uvicorn
from pydantic import BaseModel, Field
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from contextlib import asynccontextmanager
from typing import Any, Dict, List, Literal, Optional, Union
from transformers import AutoTokenizer, AutoModel
from sse_starlette.sse import ServerSentEvent, EventSourceResponse


@asynccontextmanager
async def lifespan(app: FastAPI): # collects GPU memory
    yield
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
        torch.cuda.ipc_collect()


app = FastAPI(lifespan=lifespan)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

class ModelCard(BaseModel):
    id: str
    object: str = "model"
    created: int = Field(default_factory=lambda: int(time.time()))
    owned_by: str = "owner"
    root: Optional[str] = None
    parent: Optional[str] = None
    permission: Optional[list] = None


class ModelList(BaseModel):
    object: str = "list"
    data: List[ModelCard] = []


class ChatMessage(BaseModel):
    role: Literal["user", "assistant", "system"]
    content: str


class DeltaMessage(BaseModel):
    role: Optional[Literal["user", "assistant", "system"]] = None
    content: Optional[str] = None


class ChatCompletionRequest(BaseModel):
    model: str
    messages: List[ChatMessage]
    temperature: Optional[float] = None
    top_p: Optional[float] = None
    max_length: Optional[int] = None
    stream: Optional[bool] = False


class ChatCompletionResponseChoice(BaseModel):
    index: int
    message: ChatMessage
    finish_reason: Literal["stop", "length"]


class ChatCompletionResponseStreamChoice(BaseModel):
    index: int
    delta: DeltaMessage
    finish_reason: Optional[Literal["stop", "length"]]


class ChatCompletionResponse(BaseModel):
    model: str
    object: Literal["chat.completion", "chat.completion.chunk"]
    choices: List[Union[ChatCompletionResponseChoice, ChatCompletionResponseStreamChoice]]
    created: Optional[int] = Field(default_factory=lambda: int(time.time()))


@app.get("/v1/models", response_model=ModelList)
async def list_models():
    global model_args
    model_card = ModelCard(id="gpt-3.5-turbo")
    return ModelList(data=[model_card])


@app.post("/v1/chat/completions", response_model=ChatCompletionResponse)
async def create_chat_completion(request: ChatCompletionRequest):
    global model, tokenizer

    if request.messages[-1].role != "user":
        raise HTTPException(status_code=400, detail="Invalid request")
    query = request.messages[-1].content

    prev_messages = request.messages[:-1]
    if len(prev_messages) > 0 and prev_messages[0].role == "system":
        query = prev_messages.pop(0).content + query

    history = []
    if len(prev_messages) % 2 == 0:
        for i in range(0, len(prev_messages), 2):
            if prev_messages[i].role == "user" and prev_messages[i+1].role == "assistant":
                history.append([prev_messages[i].content, prev_messages[i+1].content])

    if request.stream:
        generate = predict(query, history, request.model)
        return EventSourceResponse(generate, media_type="text/event-stream")

    response, _ = model.chat(tokenizer, query, history=history)
    choice_data = ChatCompletionResponseChoice(
        index=0,
        message=ChatMessage(role="assistant", content=response),
        finish_reason="stop"
    )

    return ChatCompletionResponse(model=request.model, choices=[choice_data], object="chat.completion")


async def predict(query: str, history: List[List[str]], model_id: str):
    global model, tokenizer

    choice_data = ChatCompletionResponseStreamChoice(
        index=0,
        delta=DeltaMessage(role="assistant"),
        finish_reason=None
    )
    chunk = ChatCompletionResponse(model=model_id, choices=[choice_data], object="chat.completion.chunk")
    #yield "{}".format(chunk.json(exclude_unset=True, ensure_ascii=False))
    yield "{}".format(chunk.model_dump_json(exclude_unset=True))

    current_length = 0

    for new_response, _ in model.stream_chat(tokenizer, query, history):
        if len(new_response) == current_length:
            continue

        new_text = new_response[current_length:]
        current_length = len(new_response)

        choice_data = ChatCompletionResponseStreamChoice(
            index=0,
            delta=DeltaMessage(content=new_text),
            finish_reason=None
        )
        chunk = ChatCompletionResponse(model=model_id, choices=[choice_data], object="chat.completion.chunk")
        #yield "{}".format(chunk.json(exclude_unset=True, ensure_ascii=False))
        yield "{}".format(chunk.model_dump_json(exclude_unset=True))

    choice_data = ChatCompletionResponseStreamChoice(
        index=0,
        delta=DeltaMessage(),
        finish_reason="stop"
    )
    chunk = ChatCompletionResponse(model=model_id, choices=[choice_data], object="chat.completion.chunk")
    #yield "{}".format(chunk.json(exclude_unset=True, ensure_ascii=False))
    yield "{}".format(chunk.model_dump_json(exclude_unset=True))
    yield '[DONE]'



if __name__ == "__main__":
    tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm2-6b", revision="v1.0", trust_remote_code=True)
    model = AutoModel.from_pretrained("THUDM/chatglm2-6b", revision="v1.0", trust_remote_code=True).cuda()
    # 多显卡支持，使用下面两行代替上面一行，将num_gpus改为你实际的显卡数量
    # from utils import load_model_on_gpus
    # model = load_model_on_gpus("THUDM/chatglm2-6b", num_gpus=2)
    model.eval()

    uvicorn.run(app, host='0.0.0.0', port=8000, workers=1)

 2、运行【openai-api.py】文件，服务端开启服务

在控制台直接输入python openai-api.py即可运行

五、可视化页面搭建

1、在创建cloud Studio的时候选择【应用推荐】

选择【ChatGPT Next Web】

2、Fork项目

3、修改【.env.template】文件

直接替换我下面的就行，但是需要替换一下你服务的IP。

# Your openai api key. (required)
OPENAI_API_KEY="hongMuXiangXun"

# Access passsword, separated by comma. (optional)
CODE=

# You can start service behind a proxy
PROXY_URL=http://你的IP:8000

# Override openai api request base url. (optional)
# Default: https://api.openai.com
# Examples: http://your-openai-proxy.com
BASE_URL=http://你的IP:8000

# Specify OpenAI organization ID.(optional)
# Default: Empty
OPENAI_ORG_ID=

# (optional)
# Default: Empty
# If you do not want users to input their own API key, set this value to 1.
HIDE_USER_API_KEY=

# (optional)
# Default: Empty
# If you do not want users to use GPT-4, set this value to 1.
DISABLE_GPT4=

# (optional)
# Default: Empty
# If you do not want users to query balance, set this value to 1.
HIDE_BALANCE_QUERY=

4、修改【.env.template】为【.env】文件

鼠标右键，重命名即可。

六、运行可视化操作页面

1、新建终端

2、运行服务

 先运行npm的安装，在通过【yarn dev】启动。

npm install

yarn dev

安装时间较长，别急，等一会。

运行yarn dev效果：

3、选择打开方式

这里需要选择到端口处进行具体的选择，选择方式如下图。

我觉得这个页面设计的还是不错的。

内部访问效果也OK：

到此，恭喜你，创建完毕了。

ChatGL M26BAI模型总结、

整体上六个大步骤，没有消耗多长时间，我是搞了一遍之后开始写的这篇文章，故而看着时间长一些，其实熟练操作也就分分钟的事情，应该是适合绝大多数的程序员来操作的。

操作不复杂，基本都有提示，希望对大家都能有所帮助，下面我单独问了一个问题，就是我们程序员未来发展之路，未遂没有一个具体解答，但是还是很中肯的，那就是学无止境。

Pytorch2.0 AI框架视频处理

一、框架选择

1、这里选择【Pytorch2.0】框架办版本。

创建完就是等待的时间，这个还是比较快的，我们主要使用【jupyter_lab】。

二、使用 JupyterLab 体验完整的机器学习工作流程

这里主要使用的是 FashionMNIST 数据集。

1、Terminal操作

使用的是清华大学的镜像加载本地数据集

mkdir dataset-fashion-mnist #创建文件夹 dataset-fashion-mnist
cd dataset-fashion-mnist
wget https://mirror.tuna.tsinghua.edu.cn/raspberry-pi-os/raspbian/pool/main/d/dataset-fashion-mnist/dataset-fashion-mnist_0.0~git20200523.55506a9.orig.tar.xz #下载数据集
tar -xf dataset-fashion-mnist_0.0~git20200523.55506a9.orig.tar.xz --strip-components=1
cd data && mkdir FashionMNIST && mkdir FashionMNIST/raw 

2、打开root/dataset-fashion-mnist/data/fashion文件夹

复制文件至【root/dataset-fashion-mnist/data/FashionMNIST/raw/】文件夹

3、创建【Notebook】

运行以下代码：

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

# 加载本地训练数据
training_data = datasets.FashionMNIST(
    root="/root/dataset-fashion-mnist/data",
    train=True,
    download=True,
    transform=ToTensor(),
)
# 加载本地测试数据
test_data = datasets.FashionMNIST(
    root="/root/dataset-fashion-mnist/data",
    train=False,
    download=True,
    transform=ToTensor(),
)

4、运行方法

注意看下图：

运行效果： 

5、修改pip环境配置

pip config set global.index-url http://mirrors.cloud.tencent.com/pypi/simple
pip config set global.trusted-host mirrors.cloud.tencent.com

6、创建Terminal持续运行以下代码 

import matplotlib.pyplot as plt

labels_map = {
    0: "T-Shirt",
    1: "Trouser",
    2: "Pullover",
    3: "Dress",
    4: "Coat",
    5: "Sandal",
    6: "Shirt",
    7: "Sneaker",
    8: "Bag",
    9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
    sample_idx = torch.randint(len(training_data), size=(1,)).item()
    img, label = training_data[sample_idx]
    figure.add_subplot(rows, cols, i)
    plt.title(labels_map[label])
    plt.axis("off")
    plt.imshow(img.squeeze(), cmap="gray")
plt.show()

 运行效果：

batch_size = 64

# 创建 dataloader
train_dataloader = DataLoader(training_data, batch_size=batch_size)
test_dataloader = DataLoader(test_data, batch_size=batch_size)

for X, y in test_dataloader:
    print(f"Shape of X [N, C, H, W]: {X.shape}")
    print(f"Shape of y: {y.shape} {y.dtype}")
    break

# 获取用于训练的 cpu 或 gpu 设备
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")

# 定义模型
class NeuralNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10)
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork().to(device)
print(model)

loss_fn = nn.CrossEntropyLoss() 
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)

def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    model.train()
    for batch, (X, y) in enumerate(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 % 100 == 0:
            loss, current = loss.item(), (batch + 1) * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")

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
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

这里是第7步，这里需要等一会，一直等到出现【Done!】才结束。这里等一会。 

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

7、保存模型

torch.save(model.state_dict(), "/root/model.pth")
print("Saved PyTorch Model State to model.pth")

8、加载模型并预测

model = NeuralNetwork()
model.load_state_dict(torch.load("/root/model.pth"))

9、预测模型

classes = [
    "包",
    "上衣",
    "套头衫",
    "连衣裙",
    "外套",
    "凉鞋",
    "衬衫",
    "运动鞋",
    "包",
    "短靴",
] #定义了一个包含类别标签的 classes 列表

model.eval() #将 PyTorch 模型设置为评估模式
x, y = test_data[1][0], test_data[1][1]#测试数据 test_data 中获取样本 分别为图像数据和其真实标签
with torch.no_grad():
    pred = model(x)
    predicted, actual = classes[pred[0].argmax(0)], classes[y]#选择具有最高概率的类别索引
    print(f'Predicted: "{predicted}", Actual: "{actual}"') #模型的预测结果 predicted 与真实标签 actual 进行比较，并使用 print 函数输出这两个值。
#输出图片信息
# 将 x 转换回图像格式
image = x.numpy().transpose(1, 2, 0)
# 显示图像
plt.figure(figsize=(4, 4))
plt.imshow(image)
# 设置中文标题
print('预测结果: "{predicted}", 实际结果: "{actual}"'.format(predicted=predicted, actual=actual))
plt.axis('off')
plt.show()

预测结果： 

三、使用 JupyterLab 体验使用字符级循环神经网络(RNN) 生成姓名

1、数据准备

新建一个命令窗口，输入以下命令，下载资源包并解压

cd /root
wget https://gitee.com/mmliujc/tencent_gpu/raw/master/data.zip
unzip data

2、新建一个 Notebook 页面，选择 Python 3

持续运行以下代码到步骤8。

from __future__ import unicode_literals, print_function, division
from io import open
import glob
import os
import unicodedata
import string

all_letters = string.ascii_letters + " .,;'-"
n_letters = len(all_letters) + 1 # Plus EOS marker

def findFiles(path): return glob.glob(path)

# Turn a Unicode string to plain ASCII, thanks to https://stackoverflow.com/a/518232/2809427
def unicodeToAscii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.category(c) != 'Mn'
        and c in all_letters
    )

# Read a file and split into lines
def readLines(filename):
    with open(filename, encoding='utf-8') as some_file:
        return [unicodeToAscii(line.strip()) for line in some_file]

# Build the category_lines dictionary, a list of lines per category
category_lines = {}
all_categories = []
for filename in findFiles('/root/data/names/*.txt'):
    category = os.path.splitext(os.path.basename(filename))[0]
    all_categories.append(category)
    lines = readLines(filename)
    category_lines[category] = lines

n_categories = len(all_categories)

if n_categories == 0:
    raise RuntimeError('Data not found. Make sure that you downloaded data '
        'from https://download.pytorch.org/tutorial/data.zip and extract it to '
        'the current directory.')

print('# categories:', n_categories, all_categories)
print(unicodeToAscii("O'Néàl"))

创建网络

import torch
import torch.nn as nn

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size

        self.i2h = nn.Linear(n_categories + input_size + hidden_size, hidden_size)
        self.i2o = nn.Linear(n_categories + input_size + hidden_size, output_size)
        self.o2o = nn.Linear(hidden_size + output_size, output_size)
        self.dropout = nn.Dropout(0.1)
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, category, input, hidden):
        input_combined = torch.cat((category, input, hidden), 1)
        hidden = self.i2h(input_combined)
        output = self.i2o(input_combined)
        output_combined = torch.cat((hidden, output), 1)
        output = self.o2o(output_combined)
        output = self.dropout(output)
        output = self.softmax(output)
        return output, hidden

    def initHidden(self):
        return torch.zeros(1, self.hidden_size)

训练网络

import random

# Random item from a list
def randomChoice(l):
    return l[random.randint(0, len(l) - 1)]

# Get a random category and random line from that category
def randomTrainingPair():
    category = randomChoice(all_categories)
    line = randomChoice(category_lines[category])
    return category, line

# One-hot vector for category
def categoryTensor(category):
    li = all_categories.index(category)
    tensor = torch.zeros(1, n_categories)
    tensor[0][li] = 1
    return tensor

# One-hot matrix of first to last letters (not including EOS) for input
def inputTensor(line):
    tensor = torch.zeros(len(line), 1, n_letters)
    for li in range(len(line)):
        letter = line[li]
        tensor[li][0][all_letters.find(letter)] = 1
    return tensor

# ``LongTensor`` of second letter to end (EOS) for target
def targetTensor(line):
    letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]
    letter_indexes.append(n_letters - 1) # EOS
    return torch.LongTensor(letter_indexes)

# Make category, input, and target tensors from a random category, line pair
def randomTrainingExample():
    category, line = randomTrainingPair()
    category_tensor = categoryTensor(category)
    input_line_tensor = inputTensor(line)
    target_line_tensor = targetTensor(line)
    return category_tensor, input_line_tensor, target_line_tensor

criterion = nn.NLLLoss()

learning_rate = 0.0005

def train(category_tensor, input_line_tensor, target_line_tensor):
    target_line_tensor.unsqueeze_(-1)
    hidden = rnn.initHidden()

    rnn.zero_grad()

    loss = 0

    for i in range(input_line_tensor.size(0)):
        output, hidden = rnn(category_tensor, input_line_tensor[i], hidden)
        l = criterion(output, target_line_tensor[i])
        loss += l

    loss.backward()

    for p in rnn.parameters():
        p.data.add_(p.grad.data, alpha=-learning_rate)

    return output, loss.item() / input_line_tensor.size(0)

import time
import math

def timeSince(since):
    now = time.time()
    s = now - since
    m = math.floor(s / 60)
    s -= m * 60
    return '%dm %ds' % (m, s)

3、第八步骤的代码

这里需要运行的时间比较长，需要长时间等待。过程中可以看到显示，官方提示大概21分钟。

rnn = RNN(n_letters, 128, n_letters)

n_iters = 100000
print_every = 5000
plot_every = 500
all_losses = []
total_loss = 0 # Reset every ``plot_every`` ``iters``

start = time.time()

for iter in range(1, n_iters + 1):
    output, loss = train(*randomTrainingExample())
    total_loss += loss

    if iter % print_every == 0:
        print('%s (%d %d%%) %.4f' % (timeSince(start), iter, iter / n_iters * 100, loss))

    if iter % plot_every == 0:
        all_losses.append(total_loss / plot_every)
        total_loss = 0

持续显示过程，注意看显示是否执行。

4、绘制损失

在Notebook中执行

import matplotlib.pyplot as plt

plt.figure()
plt.plot(all_losses)

5、网络采样

进行采样时，向网络中输入一个字母，预测下一个字母是什么，并将其作为下一个输入的字母，重复此过程直到遇到 EOS。

创建输入类别、起始字母和空隐藏状态的张量

使用起始字母创建一个字符串 output_name

在最大输出长度范围内，

将当前字母输入网络
从最近输出中获取下一个字母和下一个隐藏状态
如果字母是 EOS，则停止
如果是普通字母，则将其添加到 output_name 中并继续
返回最终的姓名

注意： 比起要求输入一个起始字母，另一种策略是在训练中加入一个“字符串起始”的标记，并让网络自己选择起始字母。

max_length = 20

# Sample from a category and starting letter
def sample(category, start_letter='A'):
    with torch.no_grad():  # no need to track history in sampling
        category_tensor = categoryTensor(category)
        input = inputTensor(start_letter)
        hidden = rnn.initHidden()

        output_name = start_letter

        for i in range(max_length):
            output, hidden = rnn(category_tensor, input[0], hidden)
            topv, topi = output.topk(1)
            topi = topi[0][0]
            if topi == n_letters - 1:
                break
            else:
                letter = all_letters[topi]
                output_name += letter
            input = inputTensor(letter)

        return output_name

# Get multiple samples from one category and multiple starting letters
def samples(category, start_letters='ABC'):
    for start_letter in start_letters:
        print(sample(category, start_letter))

samples('Russian', 'RUS')

samples('German', 'GER')

samples('Spanish', 'SPA')

samples('Chinese', 'CHI')

执行效果： 

四、使用 JupyterLab 体验视频抠像神器RobustVideoMatting

1、依赖安装

克隆gitee

git clone https://gitee.com/ai-toys/RobustVideoMatting
# 输入你的gitee账号密码
cd RobustVideoMatting

克隆后进行环境安装。

pip install -r requirements_inference.txt

 这里需要等一会，安装完成后显示是：有一个Error没关系哦。

2、下载实验资源

在【RobustVideoMatting】文件夹下上传【rvm_res.zip】文件。

可以直接下载：【https://download.csdn.net/download/feng8403000/88519620】

单独wget也可以

wget https://gitee.com/mmliujc/tencent_gpu/raw/master/rvm_res.zip

下载完成后再【RobustVideoMatting】文件夹下解压即可。

unzip rvm_res.zip

解压完毕后我们创建一个【output】文件夹

mkdir output

 3、运行

创建一个文件，粘贴以下代码，使用【ctrl+s】保存文件，文件名为【test.py】

import torch
import base64


from model import MattingNetwork
from inference import convert_video

model = MattingNetwork('mobilenetv3').eval().cuda()  # 或 "resnet50"
model.load_state_dict(torch.load('rvm_mobilenetv3.pth'))


convert_video(
    model,                           # 模型，可以加载到任何设备（cpu 或 cuda）
    input_source='1917.mp4',        # 视频文件，或图片序列文件夹
    output_type='video',             # 可选 "video"（视频）或 "png_sequence"（PNG 序列）
    output_composition='output/com.mp4',    # 若导出视频，提供文件路径。若导出 PNG 序列，提供文件夹路径
    output_alpha="output/pha.mp4",          # [可选项] 输出透明度预测
    output_foreground="output/fgr.mp4",     # [可选项] 输出前景预测
    output_video_mbps=4,             # 若导出视频，提供视频码率
    downsample_ratio=None,           # 下采样比，可根据具体视频调节，或 None 选择自动
    seq_chunk=12,                    # 设置多帧并行计算
)

保存完毕后在【Terminal】下执行【python test.py】

python test.py

别着急，等到完成。生成完成后可以在output中看到：

创建【Notebook】

4、抠图效果

运行以下代码，如果路径不对自己改一下。

import torch
import base64
from IPython.display import HTML

outpath = "/root/RobustVideoMatting/output/com.mp4"
mp4 = open(outpath,'rb').read()
data_url = "data:video/mp4;base64," + base64.b64encode(mp4).decode()
HTML("""
<video width=400 controls>
      <source src="%s" type="video/mp4">
</video>
""" % data_url)

5、换背景效果

import torch
import base64
from IPython.display import HTML

outpath = "/root/RobustVideoMatting/output/fgr.mp4"
mp4 = open(outpath,'rb').read()
data_url = "data:video/mp4;base64," + base64.b64encode(mp4).decode()
HTML("""
<video width=400 controls>
      <source src="%s" type="video/mp4">
</video>
""" % data_url)

Pytorch2.0总结

这里3个实验示例可以帮助大家在预测、生成姓名、视频抠像上帮助到大家，上手也是非常的快的，自己搞定后希望能在工作中帮助到到家。

现在还有活动呢，下面是活动的连接：

腾讯云 HAI 新品公测产品体验地址 ：https://cloud.tencent.com/act/pro/hai

腾讯云 HAI 新品公测专题页地址：https://marketing.csdn.net/p/b18dedb1166a0d94583db1877e49b039

腾讯云 HAI 新品公测活动报名地址：https://jinshuju.net/f/dHxwJ7

希望大家踊跃参加啊。文章来源地址https://www.toymoban.com/news/detail-713309.html

到了这里，关于【腾讯云 HAI域探秘】——自行搭建Stable Diffusion模型服务用于生成AI图片 | 自行搭建ChatGL M26BAI模型服务用于AI对话的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！