目录
本文概述
作者介绍
第一步、购买服务器并远程登录服务器
第二步、配置环境并训练手写数字识别网络
第三步、部署手写数字识别网络到云耀云服务器L实例
第四步、启动本地客户端并进行手写数字识别
本文概述
华为云云耀云服务器L实例是一款轻量化的服务器，具有新手友好，即开即用，部署轻松等特点。今天作者就用华为新出的云耀云服务器L实例来整个活——使用云耀云服务器L实例来训练手写数字识别神经网络，并将该模型部署在云耀云服务器L实例上实现远程调用数字识别服务。测试集准确率99.3%，并提供神经网络代码、服务端代码、客户端代码
效果展示
作者介绍
作者本人是一名人工智能炼丹师，目前在实验室主要研究的方向为生成式模型，对其它方向也略有了解，希望能够在CSDN这个平台上与同样爱好人工智能的小伙伴交流分享，一起进步。谢谢大家鸭~~~
如果你觉得这篇文章对您有帮助，麻烦点赞、收藏或者评论一下，这是对作者工作的肯定和鼓励。
第一步、购买服务器并远程登录服务器
购买链接： 云耀云服务器L实例 _【最新】_轻量云服务器_轻量服务器_轻量应用服务器-华为云
这里我们选择的镜像是ubuntu22.04的系统镜像
然后我们使用shell远程登录云耀云服务器
没有工具的可以看我的另一篇文章：Shell和Xftp免费版工具下载
第二步、配置环境并训练手写数字识别网络
首先我们需要使用下列命令安装Anaconda,用于后面配置运行环境
wget https://repo.anaconda.com/archive/Anaconda3-2023.07-1-Linux-x86_64.sh
等待下载完成~
bash Anaconda3-2023.07-1-Linux-x86_64.sh
然后我们使用上面的命令运行Anaconda安装程序 ，具体安装过程由于篇幅原因略过
这里提示失败不用管，关闭shell重新启动会话窗口就可以了
然后我们使用下列命令创建一个conda环境来安装后续所用到的库
conda create -n dl python=3.8
安装完后，使用下列命令，进入我们刚才创建的conda环境
conda activate dl
然后我们使用下列命令安装一个CPU版本的pytorch
conda install pytorch==1.10.0 torchvision==0.11.0 torchaudio==0.10.0 cpuonly -c pytorch
安装完成了，接下来我们将手写数字识别的神经网络代码上传到云耀云服务器L实例
import torch
import numpy as np
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import os
import random
import time
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
def seed_torch(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed) # 为了禁止hash随机化，使得实验可复现
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
class Network(torch.nn.Module):
def __init__(self):
super(Network, self).__init__()
self.conv = torch.nn.Sequential(
torch.nn.Conv2d(1, 16, kernel_size=5),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2),
torch.nn.Conv2d(16, 32, kernel_size=5),
torch.nn.ReLU(),
torch.nn.MaxPool2d(kernel_size=2),
)
self.fc = torch.nn.Sequential(
torch.nn.Linear(512, 128),
torch.nn.Dropout(0.1),
torch.nn.Linear(128, 10),
)
def forward(self, x):
x = self.conv(x)
x = x.view(-1, 512)
x = self.fc(x)
return x
def train(epoch,batch_size,learning_rate):
train_dataset = datasets.MNIST(root='/root/MNIST/data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='/root/MNIST/data', train=False, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
model = Network()
criterion = torch.nn.CrossEntropyLoss() # 交叉熵损失
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) # lr学习率，momentum冲量
scheduler=torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.7)
running_loss = 0.0 # 这整个epoch的loss清零
train_total = 0
train_correct = 0
for ep in range(epoch):
time_start=time.time()
model.train()
for batch_idx, data in enumerate(train_loader, 0):
inputs, target = data
optimizer.zero_grad()
# forward + backward + update
outputs = model(inputs)
loss = criterion(outputs, target)
loss.backward()
optimizer.step()
# 把运行中的loss累加起来，为了下面300次一除
# 把运行中的准确率acc算出来
_, predicted = torch.max(outputs.data, dim=1)
train_total += inputs.shape[0]
train_correct += (predicted == target).sum().item()
time_end = time.time()
train_acc=100 * train_correct / train_total
print('[%d/ %d]: train acc: %.2f %% time:%.2f s'% (ep + 1, epoch,train_acc,(time_end-time_start)))
train_total = 0
train_correct = 0
scheduler.step()
correct = 0
total = 0
model.eval()
with torch.no_grad(): # 测试集不用算梯度
for data in test_loader:
images, labels = data
outputs = model(images)
_, predicted = torch.max(outputs.data, dim=1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
test_acc = 100*correct / total
print('(%d / %d): test acc: %.1f %% ' % (ep+1, epoch, test_acc)) # 求测试的准确率，正确数/总数
state_dict = {"net": model.state_dict(), "optimizer": optimizer.state_dict(), "epoch": epoch,
"lr": optimizer.param_groups[0]['lr']}
if not os.path.isdir('/root//MNIST/model/'):
os.makedirs('/root//MNIST/model/')
torch.save(state_dict,
'/root//MNIST/model/' + f"model_{ep}_{train_acc}%_{test_acc}%.pth")
if __name__ == '__main__':
batch_size = 64
learning_rate = 0.001
epoch = 10
seed_torch(77)#固定随机种子，保证结果可复现
train(epoch,batch_size,learning_rate)#开始训练复制代码，然后保存为MNIST_train.py
接下来使用xftp软件远程连接云耀云服务器L实例并在root目录下新建一个MNIST文件夹
然后我们将刚才的MNIST_train.py文件上传到MNIST文件夹下
然后我们使用下列命令，开始训练手写数字识别神经网络
python /root/MNIST/MNIST_train.py
如图我们已经完成的手写数字识别神经网络的训练了，从图中我们可以看到每轮训练耗时19.4S左右，这可以看出我们云耀云服务器L实例的CPU还是非常强劲的啊！！！同时我们在MNIST的测试集中正确率也达到了99.3%。
第三步、部署手写数字识别网络到云耀云服务器L实例
首先将下列服务端的代码复制并保存为MNIST_server.py然后上传到云耀云服务器L实例/root/MNIST目录下
import io
import torch
from torchvision import transforms
from PIL import Image
from flask import Flask, jsonify, request
from flask_cors import CORS
from MNIST_train import Network
app = Flask(__name__)
CORS(app, resources=r'/*')
model = Network()
checkpoint = torch.load("/root/MNIST/model/model_10_99.77666666666667%_99.3%.pth",
map_location='cpu')
model.load_state_dict(checkpoint['net'])
model.eval()
def transform(image_bytes):
Transforms = transforms.Compose([transforms.Resize(28),
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))])
image = Image.open(io.BytesIO(image_bytes))
return Transforms(image)
def get_prediction(image_bytes):
image = transform(image_bytes=image_bytes)
image=image.reshape(1,1,28,28)
outputs = model(image)
_, predicted = outputs.max(1)
predicted_idx = str(predicted.item())
return predicted_idx
@app.route('/predict')
def predict():
if request.method == 'GET':
file = request.files['file']
img_bytes = file.read()
predict_id= get_prediction(image_bytes=img_bytes)
return jsonify({'predict_id': predict_id})
if __name__ == '__main__':
app.run(host='0.0.0.0',port=3777)上传后如下图所示
接下来为了能让客户端跟服务端通信，我们需要开放云耀云服务器L实例的3777端口(这个端口跟服务端上的相同即可)
这样就是成功开放3777端口了
然后，使用下列命令在云耀云服务器L实例中安装flask、flask_cors和screen库
pip install flask -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install flask_cors -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install screen -i https://pypi.tuna.tsinghua.edu.cn/simple然后使用下列命令创建一个screen窗口,这可以让你结束远程访问云耀云服务器L实例后，让你的云耀云服务器L实例进程仍然可以运行，不会中断。
screen -S mnist
如上图所示，我们已经进入一个叫做mnist的screen窗口了。然后我们需要重新进入我们之前的conda环境，并使用下列命令运行手写数字识别的服务端程序
python /root/MNIST/MNIST_server.py如下图，我们的服务端就成功运行起来了
第四步、启动本地客户端并进行手写数字识别
手写数字识别客户端的代码如下
import tkinter as tk
from tkinter import filedialog, ttk
import requests
from PIL import Image, ImageTk
from ttkthemes import ThemedStyle
# 创建上传图像的函数
def upload_image():
file_path = filedialog.askopenfilename(filetypes=[("Image files", "*.jpg")])
print(file_path)
if file_path:
# 打开图像并显示在GUI中
image = Image.open(file_path)
image = image.resize((200, 200), Image.ANTIALIAS)
photo = ImageTk.PhotoImage(image=image)
image_label.config(image=photo)
image_label.image = photo
with open(file_path, 'rb') as image_file:
files = {'file': (image_file.name, image_file, 'image/jpeg')}
response = requests.get(f'{server_url}/predict', files=files)
if response.status_code == 200:
result = response.json()
predict_id = result.get('predict_id')
result_label.config(text=f'该图像的数字为: {predict_id}')
else:
result_label.config(text='请求失败，请检查网络是否正常。')
# 定义服务器地址和端口
server_url = 'http://120.46.178.145:3777' # 请根据您的实际服务器地址和端口进行修改
# 创建GUI窗口
root = tk.Tk()
root.title("MNIST 图像分类器")
root.geometry("300x350")
style = ThemedStyle(root)
style.set_theme("plastik")
title_label = ttk.Label(root, text="手写数字识别", font=("Helvetica", 16))
title_label.pack(pady=10)
image_label = ttk.Label(root)
image_label.pack()
# 上传按钮
upload_button = ttk.Button(root, text="上传图像", command=upload_image)
upload_button.pack(pady=10)
# 预测结果的标签
result_label = ttk.Label(root, text="", font=("Helvetica", 12))
result_label.pack()
root.mainloop()我们运行后，会出现如下界面
选择图片并上传后，会出现预测的结果
此时我们的云耀云服务器L实例也会提示状态码200
至此，我们的整个项目就完成啦~~~~~~~~~~~~
为了方便大家测试，我将MNIST的图片版数据集也上传到网盘分享出来啦~
链接：百度网盘 请输入提取码
提取码：gskb
--来自百度网盘超级会员V4的分享
总结
初次体验华为云云耀云服务器L实例，整体使用下来非常的棒，性能强，操作方便，非常适合新手入门。强烈推荐各位一定要去尝试一下。PS：后续会出更多与云耀云服务器相关的教学文章~。文章来源：https://www.toymoban.com/news/detail-722174.html
如果您觉得这篇文章对您有帮忙，请点赞、收藏。您的点赞是对作者工作的肯定和鼓励，这对作者来说真的非常重要。如果您对文章内容有任何疑惑和建议，欢迎在评论区里面进行评论，我将第一时间进行回复。文章来源地址https://www.toymoban.com/news/detail-722174.html
到了这里，关于华为云云耀云服务器L实例评测｜在服务器上训练手写数字识别模型并部署到服务器上实现远程调用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
