【深度学习实验】循环神经网络（四）：基于 LSTM 的语言模型训练

news2024/11/18 14:41:13

目录

一、实验介绍

二、实验环境

1. 配置虚拟环境

2. 库版本介绍

三、实验内容

0. 导入必要的工具包

1. RNN与梯度裁剪

2. LSTM模型

3. 训练函数

a. train_epoch

b. train

4. 文本预测

5. GPU判断函数

6. 训练与测试

7. 代码整合

        经验是智慧之父，记忆是智慧之母。

——谚语

一、实验介绍

         基于 LSTM 的语言模型训练

二、实验环境

        本系列实验使用了PyTorch深度学习框架，相关操作如下：

1. 配置虚拟环境

conda create -n DL python=3.7 
conda activate DL
pip install torch==1.8.1+cu102 torchvision==0.9.1+cu102 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html

conda install matplotlib
 conda install scikit-learn

2. 库版本介绍

软件包本实验版本目前最新版
matplotlib3.5.33.8.0
numpy1.21.61.26.0
python3.7.16
scikit-learn0.22.11.3.0
torch1.8.1+cu1022.0.1
torchaudio0.8.12.0.2
torchvision0.9.1+cu1020.15.2

三、实验内容

0. 导入必要的工具包

import torch
from torch import nn
from d2l import torch as d2l

1. RNN与梯度裁剪

【深度学习实验】循环神经网络（一）：循环神经网络（RNN）模型的实现与梯度裁剪_QomolangmaH的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133742433?spm=1001.2014.3001.5501

2. LSTM模型

【深度学习实验】循环神经网络（三）：门控制——自定义循环神经网络LSTM（长短期记忆网络）模型-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_63834988/article/details/133864731?spm=1001.2014.3001.5501

3. 训练函数

a. train_epoch

def train_epoch(net, train_iter, loss, updater, device, use_random_iter):
    state, timer = None, d2l.Timer()
    metric = d2l.Accumulator(2)  # 训练损失之和,词元数量
    for X, Y in train_iter:
        if state is None or use_random_iter:
            # 在第一次迭代或使用随机抽样时初始化state
            state = net.begin_state(batch_size=X.shape[0], device=device)
        if isinstance(net, nn.Module) and not isinstance(state, tuple):
            # state对于nn.GRU是个张量
            state.detach_()
        else:
            # state对于nn.LSTM或对于我们从零开始实现的模型是个张量
            for s in state:
                s.detach_()
        y = Y.T.reshape(-1)
        X, y = X.to(device), y.to(device)
        y_hat, state = net(X, state)
        l = loss(y_hat, y.long()).mean()
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()
            l.backward()
            grad_clipping(net, 1)
            updater.step()
        else:
            l.backward()
            grad_clipping(net, 1)
            # 因为已经调用了mean函数
            updater(batch_size=1)
        metric.add(l * d2l.size(y), d2l.size(y))
    return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()

  • 参数：

    • net：神经网络模型
    • train_iter：训练数据迭代器
    • loss：损失函数
    • updater：更新模型参数的方法（如优化器）
    • device：计算设备（如CPU或GPU）
    • use_random_iter：是否使用随机抽样

  • 函数内部定义了一些辅助变量：

    • state：模型的隐藏状态变量
    • timer：计时器，用于记录训练时间
    • metric：累加器，用于计算训练损失之和和词元数量

  • 函数通过迭代train_iter中的数据进行训练。每次迭代中，执行以下步骤：

    • 如果是第一次迭代或者使用随机抽样，则初始化隐藏状态state
    • 如果net是nn.Module的实例并且state不是元组类型，则将state的梯度信息清零（detach_()函数用于断开与计算图的连接，并清除梯度信息）
    • 对于其他类型的模型（如nn.LSTM或自定义模型），遍历state中的每个元素，将其梯度信息清零
    • 将输入数据X和标签Y转移到指定的计算设备上
    • 使用神经网络模型net和当前的隐藏状态state进行前向传播，得到预测值y_hat和更新后的隐藏状态state
    • 计算损失函数loss对于预测值y_hat和标签y的损失，并取均值
    • 如果updater是torch.optim.Optimizer的实例，则执行优化器的相关操作（梯度清零、梯度裁剪、参数更新）
    • 否则，仅执行梯度裁剪和模型参数的更新（适用于自定义的更新方法）
    • 将当前的损失值乘以当前批次样本的词元数量，累加到metric中

  • 训练完成后，函数返回以下结果：

    • 对数似然损失的指数平均值（通过计算math.exp(metric[0] / metric[1])得到）
    • 平均每秒处理的词元数量（通过计算metric[1] / timer.stop()得到）

b. train

def train(net, train_iter, vocab, lr, num_epochs, device, use_random_iter=False):
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', ylabel='perplexity',
                            legend=['train'], xlim=[10, num_epochs])

    if isinstance(net, nn.Module):
        updater = torch.optim.SGD(net.parameters(), lr)
    else:
        updater = lambda batch_size: d2l.sgd(net.params, lr, batch_size)

    for epoch in range(num_epochs):
        ppl, speed = train_epoch(
            net, train_iter, loss, updater, device, use_random_iter)
        if (epoch + 1) % 10 == 0:
            animator.add(epoch + 1, [ppl])
    print('Train Done!')
    torch.save(net.state_dict(), 'chapter6.pth')
    print(f'困惑度 {ppl:.1f}, {speed:.1f} 词元/秒 {str(device)}')
  • 参数
    • net（神经网络模型）
    • train_iter（训练数据迭代器）
    • vocab（词汇表）
    • lr（学习率）
    • num_epochs（训练的轮数）
    • device（计算设备）
    • use_random_iter（是否使用随机抽样）。
  • 在函数内部，它使用交叉熵损失函数（nn.CrossEntropyLoss()）计算损失，创建了一个动画器（d2l.Animator）用于可视化训练过程中的困惑度（perplexity）指标。
  • 根据net的类型选择相应的更新器（updater）
    • 如果net是nn.Module的实例，则使用torch.optim.SGD作为更新器；
    • 否则，使用自定义的更新器（d2l.sgd）。
  • 通过迭代训练数据迭代器train_iter来进行训练。在每个训练周期（epoch）中
    • 调用train_epoch函数来执行训练，并得到每个周期的困惑度和处理速度。
    • 每隔10个周期，将困惑度添加到动画器中进行可视化。
  • 训练完成后，打印出训练完成的提示信息，并将训练好的模型参数保存到文件中（'chapter6.pth'）。
  • 打印出困惑度和处理速度的信息。

4. 文本预测

        定义了给定前缀序列,生成后续序列的predict函数。

def predict(prefix, num_preds, net, vocab, device):
    state = net.begin_state(batch_size=1, device=device)
    outputs = [vocab[prefix[0]]]
    get_input = lambda: torch.reshape(torch.tensor(
        [outputs[-1]], device=device), (1, 1))
    for y in prefix[1:]:  # 预热期
        _, state = net(get_input(), state)
        outputs.append(vocab[y])
    for _ in range(num_preds):  # 预测num_preds步
        y, state = net(get_input(), state)
        outputs.append(int(y.argmax(dim=1).reshape(1)))
    return ''.join([vocab.idx_to_token[i] for i in outputs])
  • 使用指定的device和批大小为1调用net.begin_state()，初始化state变量。
  • 使用vocab[prefix[0]]将第一个标记在prefix中对应的索引添加到outputs列表中。
  • 定义了一个get_input函数，该函数返回最后一个输出标记经过reshape后的张量，作为神经网络的输入。
  • 对于prefix中除第一个标记外的每个标记，通过调用net(get_input(), state)进行前向传播。忽略输出的预测结果，并将对应的标记索引添加到outputs列表中。

5. GPU判断函数

def try_gpu(i=0):
    """如果存在，则返回gpu(i)，否则返回cpu()"""
    if torch.cuda.device_count() >= i + 1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')

6. 训练与测试

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
vocab_size, num_hiddens, num_epochs, lr= 28, 256, 200, 1
device = try_gpu()
lstm_layer = nn.LSTM(vocab_size, num_hiddens)
model_lstm = RNNModel(lstm_layer, vocab_size)
train(model_lstm, train_iter, vocab, lr, num_epochs, device)

  • 训练中每个小批次（batch）的大小和每个序列的时间步数（time step）的值分别为32，25

  • 加载的训练数据迭代器和词汇表

  • vocab_size 是词汇表的大小，num_hiddens 是 LSTM 隐藏层中的隐藏单元数量，num_epochs 是训练的迭代次数，lr 是学习率。

  • 选择可用的 GPU 设备进行训练，如果没有可用的 GPU，则会使用 CPU。

  • 训练模型

7. 代码整合

# 导入必要的库
import torch
from torch import nn
import torch.nn.functional as F
from d2l import torch as d2l
import math


class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(LSTM, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        # 初始化模型，即各个门的计算参数
        self.W_i = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_f = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_o = nn.Parameter(torch.randn(input_size, hidden_size))
        self.W_a = nn.Parameter(torch.randn(input_size, hidden_size))
        self.U_i = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.U_f = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.U_o = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.U_a = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_i = nn.Parameter(torch.randn(1, hidden_size))
        self.b_f = nn.Parameter(torch.randn(1, hidden_size))
        self.b_o = nn.Parameter(torch.randn(1, hidden_size))
        self.b_a = nn.Parameter(torch.randn(1, hidden_size))
        self.W_h = nn.Parameter(torch.randn(hidden_size, hidden_size))
        self.b_h = nn.Parameter(torch.randn(1, hidden_size))

    # 初始化隐藏状态
    def init_state(self, batch_size):
        hidden_state = torch.zeros(batch_size, self.hidden_size)
        cell_state = torch.zeros(batch_size, self.hidden_size)
        return hidden_state, cell_state

    def forward(self, inputs, states=None):
        batch_size, seq_len, input_size = inputs.shape
        if states is None:
            states = self.init_state(batch_size)
        hidden_state, cell_state = states
        outputs = []
        for step in range(seq_len):
            inputs_step = inputs[:, step, :]
            i_gate = torch.sigmoid(torch.mm(inputs_step, self.W_i) + torch.mm(hidden_state, self.U_i) + self.b_i)
            f_gate = torch.sigmoid(torch.mm(inputs_step, self.W_f) + torch.mm(hidden_state, self.U_f) + self.b_f)
            o_gate = torch.sigmoid(torch.mm(inputs_step, self.W_o) + torch.mm(hidden_state, self.U_o) + self.b_o)
            c_tilde = torch.tanh(torch.mm(inputs_step, self.W_a) + torch.mm(hidden_state, self.U_a) + self.b_a)
            cell_state = f_gate * cell_state + i_gate * c_tilde
            hidden_state = o_gate * torch.tanh(cell_state)
            y = torch.mm(hidden_state, self.W_h) + self.b_h
            outputs.append(y)
        return torch.cat(outputs, dim=0), (hidden_state, cell_state)

class RNNModel(nn.Module):

    def __init__(self, rnn_layer, vocab_size, **kwargs):
        super(RNNModel, self).__init__(**kwargs)
        self.rnn = rnn_layer
        self.vocab_size = vocab_size
        self.num_hiddens = self.rnn.hidden_size
        self.num_directions = 1
        self.linear = nn.Linear(self.num_hiddens, self.vocab_size)

    def forward(self, inputs, state):
        X = F.one_hot(inputs.T.long(), self.vocab_size)
        X = X.to(torch.float32)
        Y, state = self.rnn(X, state)
        # 全连接层首先将Y的形状改为(时间步数*批量大小,隐藏单元数)
        # 它的输出形状是(时间步数*批量大小,词表大小)。
        output = self.linear(Y.reshape((-1, Y.shape[-1])))
        return output, state

# 在第一个时间步，需要初始化一个隐藏状态，由此函数实现
    def begin_state(self, device, batch_size=1):
        if not isinstance(self.rnn, nn.LSTM):
            # nn.GRU以张量作为隐状态
            return  torch.zeros((self.num_directions * self.rnn.num_layers,
                                 batch_size, self.num_hiddens),
                                device=device)
        else:
            # nn.LSTM以元组作为隐状态
            return (torch.zeros((
                self.num_directions * self.rnn.num_layers,
                batch_size, self.num_hiddens), device=device),
                    torch.zeros((
                        self.num_directions * self.rnn.num_layers,
                        batch_size, self.num_hiddens), device=device))


def train(net, train_iter, vocab, lr, num_epochs, device, use_random_iter=False):
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', ylabel='perplexity',
                            legend=['train'], xlim=[10, num_epochs])

    if isinstance(net, nn.Module):
        updater = torch.optim.SGD(net.parameters(), lr)
    else:
        updater = lambda batch_size: d2l.sgd(net.params, lr, batch_size)

    for epoch in range(num_epochs):
        ppl, speed = train_epoch(
            net, train_iter, loss, updater, device, use_random_iter)
        if (epoch + 1) % 10 == 0:
            animator.add(epoch + 1, [ppl])
    print('Train Done!')
    torch.save(net.state_dict(), 'chapter6.pth')
    print(f'困惑度 {ppl:.1f}, {speed:.1f} 词元/秒 {str(device)}')



def train_epoch(net, train_iter, loss, updater, device, use_random_iter):
    state, timer = None, d2l.Timer()
    metric = d2l.Accumulator(2)  # 训练损失之和,词元数量
    for X, Y in train_iter:
        if state is None or use_random_iter:
            # 在第一次迭代或使用随机抽样时初始化state
            state = net.begin_state(batch_size=X.shape[0], device=device)
        if isinstance(net, nn.Module) and not isinstance(state, tuple):
            # state对于nn.GRU是个张量
            state.detach_()
        else:
            # state对于nn.LSTM或对于我们从零开始实现的模型是个张量
            for s in state:
                s.detach_()
        y = Y.T.reshape(-1)
        X, y = X.to(device), y.to(device)
        y_hat, state = net(X, state)
        l = loss(y_hat, y.long()).mean()
        if isinstance(updater, torch.optim.Optimizer):
            updater.zero_grad()
            l.backward()
            grad_clipping(net, 1)
            updater.step()
        else:
            l.backward()
            grad_clipping(net, 1)
            # 因为已经调用了mean函数
            updater(batch_size=1)
        metric.add(l * d2l.size(y), d2l.size(y))
    return math.exp(metric[0] / metric[1]), metric[1] / timer.stop()


def predict(prefix, num_preds, net, vocab, device):
    state = net.begin_state(batch_size=1, device=device)
    outputs = [vocab[prefix[0]]]
    get_input = lambda: torch.reshape(torch.tensor(
        [outputs[-1]], device=device), (1, 1))
    for y in prefix[1:]:  # 预热期
        _, state = net(get_input(), state)
        outputs.append(vocab[y])
    for _ in range(num_preds):  # 预测num_preds步
        y, state = net(get_input(), state)
        outputs.append(int(y.argmax(dim=1).reshape(1)))
    return ''.join([vocab.idx_to_token[i] for i in outputs])


def grad_clipping(net, theta):
    if isinstance(net, nn.Module):
        params = [p for p in net.parameters() if p.requires_grad]
    else:
        params = net.params
    norm = torch.sqrt(sum(torch.sum((p.grad ** 2)) for p in params))
    if norm > theta:
        for param in params:
            param.grad[:] *= theta / norm

def try_gpu(i=0):
    """如果存在，则返回gpu(i)，否则返回cpu()"""
    # if torch.cuda.device_count() >= i + 1:
    #     return torch.device(f'cuda:{i}')
    return torch.device('cpu')

batch_size, num_steps = 32, 35
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)
vocab_size, num_hiddens, num_epochs, lr= 28, 256, 200, 1
device = try_gpu()
lstm_layer = nn.LSTM(vocab_size, num_hiddens)
model_lstm = RNNModel(lstm_layer, vocab_size)
train(model_lstm, train_iter, vocab, lr, num_epochs, device)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1099558.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

详解 ElasticSearch 集群搭建

详解 ElasticSearch 集群搭建

🌹 以上分享 ElasticSearch 安装部署，如有问题请指教写。🌹🌹 如你对技术也感兴趣，欢迎交流。🌹🌹🌹 如有需要，请👍点赞💖收藏🐱‍&a…
阅读更多...
【微信小程序】6天精准入门（第2天：小程序的视图层、逻辑层、事件系统及页面生命周期）

【微信小程序】6天精准入门（第2天：小程序的视图层、逻辑层、事件系统及页面生命周期）

一、视图层 View 1、什么是视图层 框架的视图层由 WXML 与 WXSS 编写，由组件来进行展示。将逻辑层的数据反映成视图，同时将视图层的事件发送给逻辑层。WXML(WeiXin Markup language) 用于描述页面的结构。WXS(WeiXin Script) 是小程序的一套脚本语言&am…
阅读更多...
【每日一题】倍数求和

【每日一题】倍数求和

文章目录 Tag题目来源题目解读解题思路方法一：一次遍历 其他语言cpython3 写在最后 Tag 【一次遍历】【数组】【2023-10-17】 题目来源 2652. 倍数求和 题目解读 找出 [1. n] 范围内可以被 3、5、7 整除的所有整数之和。 解题思路 方法一：一次遍历 …
阅读更多...
字符串排序程序

字符串排序程序

字符串排序程序，对一个字符串中的数值进行从小到大的排序 例如排序前给定的字符串为" 20 78 9 -7 88 36 29" 排序后： -7 9 20 29 36 78 88 要求使用包装类对数值类型的字符串转换成整型进行排序。 public class StringSort {public static vo…
阅读更多...
【MySQL】MySQL的安装

【MySQL】MySQL的安装

MySQL安装路径：MySQL 安装MySQL 1、都是选择红框 2、选择社区版 3、 4、 5、确保安装路径中没有中文字符，否则可能会出现问题 ； 以上操作之后就会生成这个，再双击它； 6、点击next，也许每个人进入的界面不…
阅读更多...
ICMP协议(二)

ICMP协议(二)

一 ping工作原理 ① 为什么ping不通 "ping不通分为两类" 1) 请求没有到目标服务器2) 请求到了目标服务器,但是没有回包 "常见原因" 1、对方关机/ip不存在备注： ping同网段不存在的ip地址2、网段不同,通过路由也无法找到3、防火墙 [安全组…
阅读更多...
Springboot结合Mockito写单元测试实践和原理

Springboot结合Mockito写单元测试实践和原理

文章目录 前言一、使用最佳实践使用场景SpyBean失效场景解决Mock失效的问题避免FactoryBean的实现方式使用MockBean，但是要指定name 个人推荐 二、原理1. MockBean2.SpyBean方法调用 总结 前言 相信看我博客的都是javaer，工作中一般都是使用Springboot框…
阅读更多...
分类算法-逻辑回归与二分类

分类算法-逻辑回归与二分类

1、逻辑回归的应用场景 广告点击率是否为垃圾邮件是否患病金融诈骗虚假账号 看到上面的例子，我们可以发现其中的特点，那就是都属于两个类别之间的判断。逻辑回归就是解决二分类问题的利器。 2、 逻辑回归的原理 2.1 输入 逻辑回归的输入就是一个线性…
阅读更多...
Flutter 知识集锦 | 监听与通知 ChangeNotifier

Flutter 知识集锦 | 监听与通知 ChangeNotifier

theme: cyanosis 1. 数据的提供者与消费者 今天想要和大家好好聊聊 ChangeNotifier 这个东西，从名字上来看它由 change(改变) 和 Notifier(通知器) 构成。打个比方： 有三个铁粉跟我说: "你发新文章的时候跟我说一声"。 之后我发布文章后&…
阅读更多...
基于nodejs+vue网课学习平台

基于nodejs+vue网课学习平台

各功能简要描述如下: 1个人信息管理:包括对学生用户、老师和管理员的信息进行录入、修改，以及老师信息的审核等 2在库课程查询:用于学生用户查询相关课程的功能 3在库老师查询:用于学生用户查询相关老师教学的所有课程的功能。 4在库学校查询:用于学生用户查询相关学…
阅读更多...
怎么把flac音频变为mp3？

怎么把flac音频变为mp3？

怎么把flac音频变为mp3？FLAC音频格式在许多平台和应用程序中都得到支持和应用。FLAC音频格式被广泛支持和应用。许多平台、设备和应用程序都支持FLAC格式，如Windows、macOS和Linux操作系统、各种音乐播放器软件、智能手机和平板电脑、在线音乐平台和流媒…
阅读更多...
Kaggle - LLM Science Exam（三）：Wikipedia RAG

Kaggle - LLM Science Exam（三）：Wikipedia RAG

文章目录 一、赛事概述1.1 OpenBookQA Dataset1.2 比赛背景1.3 评估方法和代码要求1.4 比赛数据集1.5 优秀notebook 二、 [EDA, Data gathering] LLM-SE ~ Wiki STEM | 1k DS2.1 Data overview2.2 Data gathering 三、如何高效收集数据3.1 概述3.2 与训练数据关联的维基百科类别…
阅读更多...
Q-learning如何与ABC等一些元启发式算法能够结合在一起？

Q-learning如何与ABC等一些元启发式算法能够结合在一起？

1、出现的问题 Q-learning能和元启发式算法（如ABC、PSO、GA、SSA等）结合在一起，实现工作流调度问题？ Q-learning和ABC (Artificial Bee Colony) 等元启发式算法可以结合在一起以解决特定类型的问题。Q-learning是一种强化学习算法…
阅读更多...
http代理有什么好处，怎么通过http代理服务安全上网呢？

http代理有什么好处，怎么通过http代理服务安全上网呢？

通过http代理上网是一种常见的网络代理方式。http代理是指通过代理服务器进行网络连接，以实现隐藏自己的真实IP地址、保护个人隐私等目的。下面我们将介绍通过http代理上网的好处以及如何使用http代理服务来安全上网。 一、通过http代理上网的好处 1. 保护个人隐私 …
阅读更多...
LabVIEW建立生产者消费者

LabVIEW建立生产者消费者

LabVIEW建立生产者消费者 生产者/消费者设计模式由并行循环组成，这些循环分为两类：生产者循环和消费者循环。生产者循环和消费者循环间的通信可以使用队列或通道连线来实现。 队列 LabVIEW内置的队列操作VI可在函数选板>>数据通信>>队列操…
阅读更多...
Stable Diffusion绘画

Stable Diffusion绘画

正向提示词： 1girl, brown hair, multicolored hair, green eyes, maid, maid headdress, maid apron, cherry blossoms, sunbeam, wallpaper, 一个女孩，棕色头发，五彩头发，绿色眼睛，女仆，女仆头饰&#xf…
阅读更多...
一个字符串模式匹配开源库

一个字符串模式匹配开源库

1 简介 theFuzz 是一个用于模糊字符串匹配和相似度计算的强大工具。它可以帮助我们在处理文本数据时进行模糊匹配和字符串比较，例如拼写纠正、字符串相似度计算和模糊搜索等。 2 基本原理 theFuzz 库的基本原理是使用不同的算法来计算字符串之间的相似度。其中最常用…
阅读更多...
医疗机器人技术研究现状

医疗机器人技术研究现状

医疗机器人技术是近年来快速发展的领域，它在医疗领域的应用已经取得了显著的成果。本文对医疗机器人技术的研究现状进行了综述，包括机器人手术、康复机器人、辅助诊断和治疗机器人等方面的研究进展。同时，本文还对医疗机器人技术的挑战和未来…
阅读更多...
【python高级】设计模式、类工厂、对象工厂

【python高级】设计模式、类工厂、对象工厂

一、说明 最近试着读Design pattern， 不过有些概念实在太抽象了， 整理一下自己所学抽象工厂的精神，就是要有abstract class（not implement），而所有不同种类的对象，都是继承这个abstract class&a…
阅读更多...
Ubuntu 环境配置 Minecraft 基岩版服务器

Ubuntu 环境配置 Minecraft 基岩版服务器

文章目录 Part 1 搭建服务器Part 2 配置服务器Part 3 管理服务器一、手动备份服务器二、手动恢复服务器备份三、升级服务器 Part 1 搭建服务器 更新软件包信息 sudo apt-get update sudo apt-get upgrade安装所需工具 sudo apt-get vim sudo apt-get install zip sudo apt-g…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023