transformers架构实现

目录

架构代码如下

模型打印如下


架构代码如下

import numpy as np
from torch.autograd import Variable
import copy
from torch import softmax
import math
import torch
import torch.nn.functional as F
import torch.nn as nn
# 构建Embedding类来实现文本嵌入层
class Embeddings(nn.Module):def __init__(self,vocab,d_model):""":param vocab: 词表的大小:param d_model: 词嵌入的维度"""super(Embeddings,self).__init__()self.lut = nn.Embedding(vocab,d_model)self.d_model = d_modeldef forward(self,x):""":param x: 因为Embedding层是首层,所以代表输入给模型的文本通过词汇映射后的张量:return:"""return self.lut(x) * math.sqrt(self.d_model)
class PositionalEncoding(nn.Module):def __init__(self,d_model,dropout,max_len=5000):""":param d_model: 词嵌入的维度:param dropout: 随机失活,置0比率:param max_len: 每个句子的最大长度,也就是每个句子中单词的最大个数"""super(PositionalEncoding,self).__init__()self.dropout = nn.Dropout(p=dropout)pe = torch.zeros(max_len,d_model) # 初始化一个位置编码器矩阵,它是一个0矩阵,矩阵的大小是max_len * d_modelposition = torch.arange(0,max_len).unsqueeze(1) # 初始一个绝对位置矩阵 max_len * 1div_term = torch.exp(torch.arange(0,d_model,2)*-(math.log(1000.0)/d_model)) # 定义一个变换矩阵,跳跃式的初始化# 将前面定义的变换矩阵进行奇数、偶数的分别赋值pe[:,0::2] = torch.sin(position*div_term)pe[:,1::2] = torch.cos(position*div_term)pe = pe.unsqueeze(0)  # 将二维矩阵扩展为三维和embedding的输出(一个三维向量)相加self.register_buffer('pe',pe) # 把pe位置编码矩阵注册成模型的buffer,对模型是有帮助的,但是却不是模型结构中的超参数或者参数,不需要随着优化步骤进行更新的增益对象。注册之后我们就可以在模型保存后重加载时,将这个位置编码与模型参数一同加载进来def forward(self, x):""":param x: 表示文本序列的词嵌入表示:return: 最后使用self.dropout(x)对对象进行“丢弃”操作,并返回结果"""x = x + Variable(self.pe[:, :x.size(1)],requires_grad = False)   # 不需要梯度求导,而且使用切片操作,因为我们默认的max_len为5000,但是很难一个句子有5000个词汇,所以要根据传递过来的实际单词的个数对创建的位置编码矩阵进行切片操作return self.dropout(x)def subsequent_mask(size):""":param size: 生成向后遮掩的掩码张量,参数 size 是掩码张量的最后两个维度大小,它的最后两个维度形成一个方阵:return:"""attn_shape = (1,size,size) # 定义掩码张量的形状subsequent_mask = np.triu(np.ones(attn_shape),k = 1).astype('uint8') # 定义一个上三角矩阵,元素为1,再使用其中的数据类型变为无符号8位整形return torch.from_numpy(1 - subsequent_mask) # 先将numpy 类型转化为 tensor,再做三角的翻转,将位置为 0 的地方变为 1,将位置为 1 的方变为 0
def attention(query, key, value, mask=None, dropout=None):""":param query: 三个张量输入:param key: 三个张量输入:param value: 三个张量输入:param mask: 掩码张量:param dropout: 传入的 dropout 实例化对象:return:"""d_model = query.size(-1)  # 得到词嵌入的维度,取 query 的最后一维大小scores = torch.matmul(query,key.transpose(-2,-1)) / math.sqrt(d_model)     # 按照注意力公式,将 query 和 key 的转置相乘,这里是将 key 的最后两个维度进行转置,再除以缩放系数,得到注意力得分张量 scores# query(2,8,4,64) key.transpose(-2,-1) (2,8,64,4) 进行矩阵乘法为 (2,8,4,4)if mask is not None:scores = torch.masked_fill(scores,mask == 0,-1e9)  # 使用 tensor 的 mask_fill 方法,将掩码张量和 scores 张量中每一个位置进行一一比较,如果掩码张量处为 0 ,则使用 -1e9 替换# scores = scores.masked_fill(mask == 0,-1e9)p_attn = softmax(scores, dim = -1) # 对 scores 的最后一维进行 softmax 操作,使用 F.softmax 方法,第一个参数是 softmax 对象,第二个参数是最后一个维度,得到注意力矩阵if dropout is not None:p_attn = dropout(p_attn)return torch.matmul(p_attn,value),p_attn  # 返回注意力表示class MultiHeadAttention(nn.Module):def __init__(self, head, embedding_dim , dropout=0.1):""":param head: 代表几个头的参数:param embedding_dim: 词向量维度:param dropout: 置零比率"""super(MultiHeadAttention, self).__init__()assert embedding_dim % head == 0     # 确认一下多头的数量可以整除词嵌入的维度 embedding_dimself.d_k = embedding_dim // head  # 每个头获得词向量的维度self.head = headself.linears = nn.ModuleList([copy.deepcopy(nn.Linear(embedding_dim, embedding_dim)) for _ in range(4)])   # 深层拷贝4个线性层,每一个层都是独立的,保证内存地址是独立的,分别是 Q、K、V以及最终的输出线性层self.attn = None   # 初始化注意力张量self.dropout = nn.Dropout(p=dropout)def forward(self, query, key, value, mask=None):""":param query: 查询query [batch size, sentence length, d_model]:param key: 待查询key [batch size, sentence length, d_model]:param value: 待查询value [batch size, sentence length, d_model]:param mask: 计算相似度得分时的掩码(设置哪些输入不计算到score中)[batch size, 1, sentence length]:return:"""if mask is not None:mask = mask.unsqueeze(1) # 将掩码张量进行维度扩充,代表多头中的第 n 个头batch_size = query.size(0)query, key, value = [l(x).view(batch_size, -1, self.head, self.d_k).transpose(1, 2) for l, x in zip(self.linears, (query, key, value))]  # 将1、2维度进行调换,目的是让句子长度维度和词向量维度靠近,这样注意力机制才能找到词义与句子之间的关系# 将每个头传递到注意力层x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout)# 得到每个头的计算结果是 4 维的张量,需要形状的转换# 前面已经将1,2两个维度进行转置了,所以这里要重新转置回来# 前面已经经历了transpose,所以要使用contiguous()方法,不然无法使用 view 方法x = x.transpose(1, 2).contiguous() \.view(batch_size, -1, self.head * self.d_k)return self.linears[-1](x)  # 在最后一个线性层中进行处理,得到最终的多头注意力结构输出class LayerNormalization(nn.Module):def __init__(self, features, eps=1e-6):""":param features: 词嵌入的维度:param eps: 出现在规范化公式的分母中,防止分母为0"""super(LayerNormalization, self).__init__()# a 系数的默认值为1,模型的参数self.a = nn.Parameter(torch.ones(features))# b 系统的初始值为0,模型的参数self.b = nn.Parameter(torch.zeros(features))# 把 eps 传递到类中self.eps = epsdef forward(self, x):# 在最后一个维度上求 均值,并且输出维度保持不变mean = x.mean(-1, keepdim=True)std = x.std(-1, keepdim=True)return self.a * (x - mean) / (std + self.eps) + self.bclass PositionFeedForward(nn.Module):def __init__(self, d_model, d_ff, dropout=0.1):""":param d_model: 输入维度,词嵌入的维度:param d_ff: 第一个的输出连接第二个的输入:param dropout: 置零比率"""super(PositionFeedForward, self).__init__()self.linear1 = nn.Linear(d_model, d_ff)self.linear2 = nn.Linear(d_ff, d_model)self.dropout = nn.Dropout(p = dropout)def forward(self, x):return self.linear2(self.dropout(torch.relu(self.linear1(x))))class SublayerConnection(nn.Module):def __init__(self, size, dropout=0.1):super(SublayerConnection,self).__init__()# 实例化了一个 LN 对象self.norm = LayerNormalization(size)self.dropout = nn.Dropout(p = dropout)def forward(self,x,sublayer):""":param x: 接受上一个层或者子层的输入作为第一个参数:param sublayer: 该子层连接中的子层函数胡作为第二个参数:return:""""首先对输出进行规范化,然后将结果交给子层处理,之后对子层进行 dropout处理" \"随机失活一些神经元,来防止过拟合,最后还有一个add操作" \"因此存在跳跃连接,所以是将输入x与dropout后的子层输出结果相加作为最终的子层连接输出"return x + self.dropout(sublayer(self.norm(x)))class EncoderLayer(nn.Module):def __init__(self, size, self_attn, feed_forward, dropout):""":param size: 词嵌入的维度:param self_attn: 传入多头自注意力子层实例化对象,并且是自注意力机制:param feed_forward: 前馈全连接层实例化对象:param dropout: 置零比率"""super(EncoderLayer,self).__init__()self.self_attn = self_attnself.feed_forward = feed_forwardself.sublayer = nn.ModuleList([copy.deepcopy(SublayerConnection(size,dropout)) for _ in range(2)])self.size = sizedef forward(self, x, mask):""":param x: 上一层的输出:param mask: 掩码张量:return:""""首先通过第一个子层连接结构,其中包含多头自注意力子层""然后通过第二个子层连接结构,其中包含前馈全连接子层,最后返回结果"x = self.sublayer[0](x,lambda x:self.self_attn(x,x,x,mask))return self.sublayer[1](x,self.feed_forward)
class Encoder(nn.Module):def __init__(self, layer, N):""":param layer: 编码器层:param N: 编码器的个数"""super(Encoder,self).__init__()self.layers = nn.ModuleList([copy.deepcopy(layer) for _ in range(N)])"初始化一个规范化层,用于最后的输出"self.norm = LayerNormalization(layer.size)# print('layer.size',layer.size) 512def forward(self, x, mask):for layer in self.layers:x = layer(x,mask)return self.norm(x)
class DecoderLayer(nn.Module):def __init__(self, size, self_attn, src_attn, feed_forward, dropout):""":param size: 代表词嵌入的维度,同时也代表解码器层的尺寸:param self_attn: 多头自注意力对象 Q = K = V:param src_attn:  多头自注意力对象,Q! = K = V:param feed_forward: 前馈全链连接层:param dropout: 置零比率"""super(DecoderLayer,self).__init__()self.size = sizeself.self_attn = self_attnself.src_attn = src_attnself.feed_forward = feed_forwardself.sublayer = nn.ModuleList([copy.deepcopy(SublayerConnection(size,dropout))for _ in range(3)])def forward(self, x, memory, source_mask, target_mask):""":param x: 来自上一层的输入x:param memory: 来自编码器层的语义存储变量 mermory:param source_mask: 源数据掩码张量:param target_mask: 目标数据掩码张量:return:""""将x传入第一个子层结构,输入分别是x 和 self_attn函数,因为是自注意力机制,所以Q、K、V相等 ""最后一个数据是目标数据的掩码张量,这时要对目标数据进行遮掩,因为这个时候模型还没有生成任何的目标数据""比如在解码器生成第一个字符或者词汇的时候,我们其实已经传入进来了滴哟个字符以便计算损失,但是我们不希望在生成第一个字符时模型能利用这个信息,同样在生成第二个字符或者词汇时,模型只能使用第一个字符或者词汇信息,第二个词汇以及以后的信息都不被模型允许使用"x = self.sublayer[0](x,lambda x:self.self_attn(x,x,x,target_mask))"进入第二个子层,这个子层中是常规的自注意力机制,q是输入x ,而k、v是编码层输出memory""传入source_mask,进行源数据遮掩并非是抑制信息泄露,而是遮蔽掉对结果没有意义的字符而产生的注意力值,加快模型的训练速度"x = self.sublayer[1](x,lambda x:self.self_attn(x,memory,memory,source_mask))"全连接子层,返回结果"return self.sublayer[2](x,self.feed_forward)
class Decoder(nn.Module):def __init__(self, layer, N):""":param layer: 编码器层:param N: 编码器的个数"""super(Decoder,self).__init__()self.layers = nn.ModuleList([copy.deepcopy(layer) for _ in range(N)])"初始化一个规范化层,用于最后的输出"self.norm = LayerNormalization(layer.size)# print('layer.size',layer.size) 512def forward(self, x, memory, source_mask, target_mask):for layer in self.layers:x = layer(x, memory, source_mask, target_mask)return self.norm(x)
class Generator(nn.Module):def __init__(self, vocab_size, d_model):""":param vocab_size: 词表大小:param d_model: 词向量维度"""super(Generator,self).__init__()self.out = nn.Linear(d_model, vocab_size)def forward(self,x):x = self.out(x)return F.log_softmax(x, dim=-1) # 在词嵌入的维度上进行softmax
class EncoderDecoder(nn.Module):def __init__(self,encoder,decoder,source_embed,target_embed,generator):""":param encoder: 编码器对象:param decoder: 解码器对象:param source_embed: 源输入嵌入函数:param target_embed: 目标数据嵌入函数:param generator: 输出部分的类别生成器对象"""super(EncoderDecoder,self).__init__()self.encoder = encoderself.decoder = decoderself.source_embed = source_embedself.target_embed = target_embedself.generator = generatordef Encode(self,source,source_mask):""":param source: 源数据:param source_mask: 源数据掩码:return:"""return self.encoder(self.source_embed(source),source_mask)def Decode(self,memory,source_mask,target,target_mask):""":param memory: 编码函数结果输出:param source_mask: 源数据掩码:param target: 经过嵌入层输入到解码函数中的目标数据:param target_mask: 目标数据掩码:return:"""return self.decoder(self.target_embed(target),memory,source_mask,target_mask)def forward(self,source,target,source_mask,target_mask):""":param source: 代表源数据:param target: 代表目标数据:param source_mask: 源数据的源码张量:param target_mask: 目标数据的源码张量:return:"""return self.Decode(self.Encode(source,source_mask),source_mask,target,target_mask)
def make_model(source_vocab, target_vocab, N=6, d_model=512, d_ff=2048,head=8, dropout=0.1):c = copy.deepcopyattn = MultiHeadAttention(head, d_model)ff = PositionFeedForward(d_model,d_ff,dropout)position = PositionalEncoding(d_model, dropout)model = EncoderDecoder(Encoder(EncoderLayer(d_model, c(attn), c(ff),dropout),N),Decoder(DecoderLayer(d_model, c(attn), c(attn), c(ff),dropout),N),nn.Sequential(Embeddings(source_vocab, d_model),c(position)),nn.Sequential(Embeddings(target_vocab, d_model),c(position)),Generator(target_vocab, d_model))for p in model.parameters():if p.dim() > 1:nn.init.xavier_uniform_(p)return model
if __name__ == "__main__":V = 11model = make_model(V, V, N=2)print(model)

模型打印如下

F:\Anaconda\envs\py38\python.exe G:/python_files/transformers/transformers.py
EncoderDecoder(
  (encoder): Encoder(
    (layers): ModuleList(
      (0): EncoderLayer(
        (self_attn): MultiHeadAttention(
          (linears): ModuleList(
            (0): Linear(in_features=512, out_features=512, bias=True)
            (1): Linear(in_features=512, out_features=512, bias=True)
            (2): Linear(in_features=512, out_features=512, bias=True)
            (3): Linear(in_features=512, out_features=512, bias=True)
          )
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (feed_forward): PositionFeedForward(
          (linear1): Linear(in_features=512, out_features=2048, bias=True)
          (linear2): Linear(in_features=2048, out_features=512, bias=True)
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (sublayer): ModuleList(
          (0): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (1): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
      )
      (1): EncoderLayer(
        (self_attn): MultiHeadAttention(
          (linears): ModuleList(
            (0): Linear(in_features=512, out_features=512, bias=True)
            (1): Linear(in_features=512, out_features=512, bias=True)
            (2): Linear(in_features=512, out_features=512, bias=True)
            (3): Linear(in_features=512, out_features=512, bias=True)
          )
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (feed_forward): PositionFeedForward(
          (linear1): Linear(in_features=512, out_features=2048, bias=True)
          (linear2): Linear(in_features=2048, out_features=512, bias=True)
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (sublayer): ModuleList(
          (0): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (1): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
      )
    )
    (norm): LayerNormalization()
  )
  (decoder): Decoder(
    (layers): ModuleList(
      (0): DecoderLayer(
        (self_attn): MultiHeadAttention(
          (linears): ModuleList(
            (0): Linear(in_features=512, out_features=512, bias=True)
            (1): Linear(in_features=512, out_features=512, bias=True)
            (2): Linear(in_features=512, out_features=512, bias=True)
            (3): Linear(in_features=512, out_features=512, bias=True)
          )
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (src_attn): MultiHeadAttention(
          (linears): ModuleList(
            (0): Linear(in_features=512, out_features=512, bias=True)
            (1): Linear(in_features=512, out_features=512, bias=True)
            (2): Linear(in_features=512, out_features=512, bias=True)
            (3): Linear(in_features=512, out_features=512, bias=True)
          )
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (feed_forward): PositionFeedForward(
          (linear1): Linear(in_features=512, out_features=2048, bias=True)
          (linear2): Linear(in_features=2048, out_features=512, bias=True)
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (sublayer): ModuleList(
          (0): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (1): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (2): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
      )
      (1): DecoderLayer(
        (self_attn): MultiHeadAttention(
          (linears): ModuleList(
            (0): Linear(in_features=512, out_features=512, bias=True)
            (1): Linear(in_features=512, out_features=512, bias=True)
            (2): Linear(in_features=512, out_features=512, bias=True)
            (3): Linear(in_features=512, out_features=512, bias=True)
          )
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (src_attn): MultiHeadAttention(
          (linears): ModuleList(
            (0): Linear(in_features=512, out_features=512, bias=True)
            (1): Linear(in_features=512, out_features=512, bias=True)
            (2): Linear(in_features=512, out_features=512, bias=True)
            (3): Linear(in_features=512, out_features=512, bias=True)
          )
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (feed_forward): PositionFeedForward(
          (linear1): Linear(in_features=512, out_features=2048, bias=True)
          (linear2): Linear(in_features=2048, out_features=512, bias=True)
          (dropout): Dropout(p=0.1, inplace=False)
        )
        (sublayer): ModuleList(
          (0): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (1): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (2): SublayerConnection(
            (norm): LayerNormalization()
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
      )
    )
    (norm): LayerNormalization()
  )
  (source_embed): Sequential(
    (0): Embeddings(
      (lut): Embedding(11, 512)
    )
    (1): PositionalEncoding(
      (dropout): Dropout(p=0.1, inplace=False)
    )
  )
  (target_embed): Sequential(
    (0): Embeddings(
      (lut): Embedding(11, 512)
    )
    (1): PositionalEncoding(
      (dropout): Dropout(p=0.1, inplace=False)
    )
  )
  (generator): Generator(
    (out): Linear(in_features=512, out_features=11, bias=True)
  )
)

Process finished with exit code 0
 

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

百度车牌识别AI Linux使用方法-armV7交叉编译

1、获取百度ai的sdk 百度智能云-登录 (baidu.com) 里面有两个版本的armV7和armV8架构。v7架构的性能比较低往往需要交叉编译,v8的板子性能往往比较好,可以直接在板子上编译。 解压到ubuntu里面。这里介绍v7架构的。 2、ubuntu环境配置 ubuntu下安装软件…

1373. 二叉搜索子树的最大键值和

1373. 二叉搜索子树的最大键值和 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val0, leftNone, rightNone): # self.val val # self.left left # self.right right class Solution:def __init__(self):self…

网络编程基础知识总结——IP,端口,协议

目录 1. 什么是网络编程? 2. 网络编程的三要素 3. IP 3.1 IP地址的概念 3.2 IP地址的分类 3.3 IPv4解析 3.4 Ipv6解析 4. IPv4 的使用细节 5. 特殊IP地址 4. 端口号 5. 协议 5.1 UDP协议 5.2 TCP协议 1. 什么是网络编程? 总的来说就是一句…

[计算机提升] Windows系统权限

1.2 Windows系统权限 在Windows操作系统中,权限是指授予用户或用户组对系统资源进行操作的权利。权限控制是操作系统中重要的安全机制,通过权限控制可以限制用户对系统资源的访问和操作,从而保护系统安全。 Windows操作系统中包含以下几种权…

Leetcode算法解析——查找总价格为目标值的两个商品

1. 题目链接:LCR 179. 查找总价格为目标值的两个商品 2. 题目描述: 商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况,返回任一结果即可。 示例 1: 输入:price …

大语言模型迎来重大突破!找到解释神经网络行为方法

前不久,获得亚马逊40亿美元投资的ChatGPT主要竞争对手Anthropic在官网公布了一篇名为《朝向单义性:通过词典学习分解语言模型》的论文,公布了解释经网络行为的方法。 由于神经网络是基于海量数据训练而成,其开发的AI模型可以生成…

以单颗CMOS摄像头重构三维场景,维悟光子发布单目红外3D成像模组

维悟光子近期发布全新单目红外3D成像模组,现可提供下游用户进行测试导入。通过结合微纳光学元件编码和人工智能算法解码,维悟光子单目红外3D成像模组采用单颗摄像头,通过单帧拍摄,可同时获取像素级配准的3D点云和红外图像信息,可被应用于机器人、生物识别等广阔领域。 市场…

Qt 5.12.12 静态编译(MinGW)

前置准备 系统环境 版本 Windows 11 专业版 版本 22H2 安装日期 ‎2023/‎6/‎18 操作系统版本 22621.2428 体验 Windows Feature Experience Pack 1000.22674.1000.0依赖工具 gcc Qt 5.12.12 安装 MinGW 后自动安装 https://download.qt.io/archive/qt/5.12/5.12.12/qt-ope…

三防PDA手持终端开发板-联发科MTK6765平台安卓主板方案

三防手持终端安卓主板方案采用了联发科12nm八核MT6765处理器,配备4G64GB内存(可选配6GB256GB),并搭载最新的Android 10.0操作系统。该方案支持许多功能,包括高亮显示屏、高清摄像头、NFC、3A快速充电、1D/2D扫描(可选配)、高精度定位(可选配)…

如何编写lua扩展库

很多人都听过lua,也见过lua脚本,但可能不理解为什么lua脚本里面会有这么多没见过的函数, 而且这些函数功能是如此强大,能上天入地,无所不能 其实这些函数并不是lua自带的,都是由程序作者造出来的隐藏在了他们的主程序里 一般运行lua脚本,我们会使用自带的解释器,当你拿到一份…

VMware _ Ubuntu _ root 密码是什么,怎么进入 root 账户

文章目录 进入 root 账户设置 root 密码小结 在 VMware 安装 ubuntu 虚拟机之后,root 用户的密码是什么?安装的过程也没有提示输入 root 用户的密码,只有创建第一个非 root 用户的密码。但是 root 用户是存在的,又怎么切换到 root…

红帽Linux的安装和部署

目录 一、红帽Linux的安装阶段 1、下载redhat7.9的iso镜像 2、安装阶段 二、红帽Linux的配置阶段 1、第一次进入装机配置 2、进入机器后的一些配置 三、远程连接阶段 1、关闭防火墙 2、使用Xshell远程连接(其他连接工具也行) 1.开启SSH服务 2.连…

利达卓越:关注环保事业,持续赋能科技

随着全球环境问题的日益突出,绿色金融作为一种新兴的金融模式逐渐受到各国的重视。绿色金融是指在金融活动中,通过资金、信贷和风险管理等手段,支持环境友好和可持续发展的项目和产业。绿色金融的出现是为了应对气候变化、资源短缺、污染问题等现实挑战,促进经济的绿色转型和可…

基于海洋捕食者优化的BP神经网络(分类应用) - 附代码

基于海洋捕食者优化的BP神经网络(分类应用) - 附代码 文章目录 基于海洋捕食者优化的BP神经网络(分类应用) - 附代码1.鸢尾花iris数据介绍2.数据集整理3.海洋捕食者优化BP神经网络3.1 BP神经网络参数设置3.2 海洋捕食者算法应用 4…

Delay-Based 拥塞控制算法

上班七天了,有点崩溃,看一篇论文提神:A Delay-Based Approach for Congestion Avoidance in Interconnected Heterogeneous Computer networks,来自 Raj Jain,1989 年。这篇论文基于下图展开: 是不是很熟…

SiC外延片测试方案

外延材料是实现器件制造的关键,主要技术指标有外延层厚度、晶格布局,材料结构,形貌以及物理性质,表面粗糙度和掺杂浓度等。下面阐述SiC外延表面常见的测试手段: 1. 外延层厚度(傅里叶变换红外FT-IR&#xf…

SpringBoot通过配置切换注册中心(多注册中心nacos和eureka)

场景: 因项目需要,一个springcloud微服务工程需要同时部署到A,B两个项目使用,但A项目使用Eureka注册中心,B项目使用Nacos注册中心,现在需要通过部署时修改配置来实现多注册中心的切换。 解决思路: 如果同时…

Eslint配置 Must use import to load ES Module(已解决)

最近在配置前端项目时,eslint经常会碰到各种报错(灰常头疼~) Syntax Error Error No ESLint configuration found.Syntax Error: Error: D:\dmq\dmq-ui.eslintrc.js: Environment key “es2021” is unknown at Array.forEach ()error in ./…

UE4 快速入门 1

安装 https://www.unrealengine.com/zh-CN/download Launcher ue4.23 editor visual studio 2019 社区版 文档学习

IO流:java中解码和编码出现乱码说明及代码实现

IO流:java中解码和编码的代码实现 一、UTF-8和GBK编码方式二、idea和eclipse的默认编码方式三、解码和编码方法四、代码实现编码解码 五、额外知识扩展 一、UTF-8和GBK编码方式 如果采用的是UTF-8的编码方式,那么1个英文字母 占 1个字节,1个…