深度学习基础

文章目录

  • 1. 数学基础
    • 1.1 标量和向量
    • 1.2 向量运算
    • 1.3 矩阵
    • 1.4 张量
    • 1.5 导数
  • 2. numpy常用操作
  • 3. 梯度下降算法
  • 4. 反向传播
    • 4.1 完整的反向传播过程
    • 4.2 代码演示
  • 5. 网络结构 -- 全连接层
  • 6. 激活函数
    • 6.1 激活函数-Sigmoid
    • 6.2 激活函数-tanh
    • 6.3 激活函数-Relu
    • 6.4 激活函数-Softmax
  • 7. 损失函数
    • 7.1 损失函数-均方差
    • 7.2 损失函数-交叉熵
    • 7.3 损失函数-其他
  • 8. 优化器
  • 9. Pytorch

1. 数学基础

1.1 标量和向量

标量 Scalar
一个标量就是一个单独的数

向量 Vector
一个向量是一列数
可以把向量看做空间中的点,每个元素是不同坐标轴上的坐标
向量中有几个数,就叫几维向量
如4维向量:[1,2,3,4]

1.2 向量运算

向量加和: A +B = B + A 需要维度相同
[1,2] + [3,4] = [4, 6]

向量内积: A * B = B * A 需要维度相同
[1,2] * [3, 4] = 1 * 3 + 2* 4 = 11

1.3 矩阵

矩阵 matrix
是一个二维数组。矩阵中的每一个值是一个标量,可以通过行号和列号进行索引
矩阵加法 需要维度相同

矩阵乘法
不满足交换律 A * B != B* A
当左矩阵A的列数等于右矩阵B的行数时,A与B可以相乘
M x N 矩阵乘以 N x P矩阵得到M x P维度矩阵
在这里插入图片描述

符合分配律
A*(B+C) = A*B + A * C

符合结合律
A * (B * C) = (A * B) * C

另一种矩阵乘法 – 矩阵点乘
两矩阵必须形状一致

1.4 张量

张量 tensor
将三个2 x 2的矩阵排列在一起,就可以称为一个 3 x 2 x 2的张量
将4个3 x 2 x 2的张量排列在一起,就可以成为一个 4 x 3 x 2 x 2维度的张量。
张量是神经网络的训练中最为常见的数据形式。
所有的输入,输出,中间结果,几乎都是以张量的形式存在。

1.5 导数

导数表示函数变化的方向
在这里插入图片描述
在这里插入图片描述

常见导数
在这里插入图片描述
在这里插入图片描述

求导法则
加(减)法则:[f(x)+g(x)]‘=f(x)’+g(x)’

乘法法则:[f(x)*g(x)]‘=f(x)’*g(x)+g(x)'*f(x)

除法法则:[f(x)/g(x)]‘=[f(x)’*g(x)-g(x)'*f(x)]/g(x)2

链式法则:若h(x)=f(g(x)),则h’(x)=f’(g(x))g’(x)

2. numpy常用操作

NumPy 是 Python 中的一个开源库,提供大量的数学函数和多维数组对象,以及各种派生对象(如掩码数组和矩阵),这些工具可用于各种数学和逻辑操作。它是大多数数据科学和科学计算Python工具的基础。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码示例

#coding:utf8import torch
import numpy as np#numpy基本操作
x = np.array([[1,2,3],[4,5,6]])
#
print(x.ndim)
print(x.shape)
print(x.size)
print(np.sum(x))
print(np.sum(x, axis=0))
print(np.sum(x, axis=1))
print(np.reshape(x, (3,2)))
print(np.sqrt(x))
print(np.exp(x))
print(x.transpose())
print(x.flatten())#
# print(np.zeros((3,4,5)))
# print(np.random.rand(3,4,5))
#
# x = np.random.rand(3,4,5)
x = torch.FloatTensor(x)
print(x.shape)
print(torch.exp(x))
print(torch.sum(x, dim=0))
print(torch.sum(x, dim=1))
print(x.transpose(1, 0))
print(x.flatten())

3. 梯度下降算法

梯度下降算法是一个用于寻找函数最小值的迭代优化算法。在机器学习和深度学习中,通常使用梯度下降来优化损失函数,从而训练模型的参数。

梯度下降的核心思想是使用函数的梯度(或近似梯度)来确定在函数值减小的方向上迭代更新参数。换句话说,如果你站在山坡上并想找到最短的路径下山,那么在每一步,你应该朝着最陡峭的下坡方向走。

算法步骤:

  1. 初始化参数(通常是随机的)。
  2. 计算损失函数的梯度。
  3. 更新参数,使其沿着梯度的负方向移动:
    θ=θ−α×∇θ ,其中 α 是学习率。
  4. 重复步骤 2 和 3,直到满足停止准则(例如,梯度接近于零,达到最大迭代次数,或损失变化很小)。

在这里插入图片描述

学习率 α 决定了每次迭代时参数更新的步长。太大的学习率可能会使算法在最小值附近震荡,而太小的学习率可能会导致算法收敛得太慢。很多高级的优化算法(如 Adam、RMSprop 等)都是为了在训练过程中自动调整学习率。

权重更新方式

Gradient descent
所有样本一起计算梯度(累加)

Stochastic gradient descent
每次使用一个样本计算梯度

Mini-batch gradient descent
每次使用n个样本计算梯度(累加)

找极小值问题
在这里插入图片描述

函数f(x)的值受x影响

目标:找到合适的x值,使得f(x)最小

方法:

  1. 任取一点x0,计算在这一点的导数值f(x0)
  2. 根据导数的正负,决定x0应当调大还是调小
  3. 迭代进行1,2直到x不在变化(或变化极小)

在这里插入图片描述
原函数为 y = x2 导函数为 y = 2*x
在x = -1这个点,导数值为 -2
该点导数为负数,说明在这一点,如果x增大,y会减小
所以f(x)最小值的点应当在-1的右侧(大于-1)

在这里插入图片描述
原函数为 y = x2 导函数为 y = 2*x
在x = 1这个点,导数值为 2
该点导数为正数,说明在这一点,如果x增大,y会增大
所以f(x)最小值的点应当在-1的左侧(小于1)

梯度

  • 梯度:可以理解为多元函数的导数,意义与导数基本一致

原函数:y = 3x2
导函数: y = 6x
在x=1处的导数值:6
在这里插入图片描述

原函数:y = 3x12 + 4x22 + 5x32
导函数:y = {6x1 , 8x2 , 10x3}
在[1,1,1]处的梯度是[6,8,10]
梯度是个向量
在这里插入图片描述

4. 反向传播

4.1 完整的反向传播过程

  1. 根据输入x和模型当前权重,计算预测值y’
  2. 根据y’和y使用loss函数计算loss
  3. 根据loss计算模型权重的梯度
  4. 使用梯度和学习率,根据优化器调整模型权重

4.2 代码演示

# coding:utf8import torch
import torch.nn as nn
import numpy as np
import copy"""
基于pytorch的网络编写
手动实现梯度计算和反向传播
加入激活函数
"""class TorchModel(nn.Module):def __init__(self, hidden_size):super(TorchModel, self).__init__()self.layer = nn.Linear(hidden_size, hidden_size, bias=False)self.activation = torch.sigmoidself.loss = nn.functional.mse_loss  # loss采用均方差损失# 当输入真实标签,返回loss值;无真实标签,返回预测值def forward(self, x, y=None):y_pred = self.layer(x)y_pred = self.activation(y_pred)if y is not None:return self.loss(y_pred, y)else:return y_pred# 自定义模型,接受一个参数矩阵作为入参
class DiyModel:def __init__(self, weight):self.weight = weightdef forward(self, x, y=None):y_pred = np.dot(self.weight, x)y_pred = self.diy_sigmoid(y_pred)if y is not None:return self.diy_mse_loss(y_pred, y)else:return y_pred# sigmoiddef diy_sigmoid(self, x):return 1 / (1 + np.exp(-x))# 手动实现mse,均方差lossdef diy_mse_loss(self, y_pred, y_true):return np.sum(np.square(y_pred - y_true)) / len(y_pred)# 手动实现梯度计算def calculate_grad(self, y_pred, y_true, x):# 前向过程# wx = np.dot(self.weight, x)# sigmoid_wx = self.diy_sigmoid(wx)# loss = self.diy_mse_loss(sigmoid_wx, y_true)# 反向过程# 均方差函数 (y_pred - y_true) ^ 2 / n 的导数 = 2 * (y_pred - y_true) / ngrad_loss_sigmoid_wx = 2/len(x) * (y_pred - y_true)# sigmoid函数 y = 1/(1+e^(-x)) 的导数 = y * (1 - y)grad_sigmoid_wx_wx = y_pred * (1 - y_pred)# wx对w求导 = xgrad_wx_w = x# 导数链式相乘grad = grad_loss_sigmoid_wx * grad_sigmoid_wx_wxgrad = np.dot(grad.reshape(len(x), 1), grad_wx_w.reshape(1, len(x)))return grad# 梯度更新def diy_sgd(grad, weight, learning_rate):return weight - learning_rate * grad# adam梯度更新def diy_adam(grad, weight):# 参数应当放在外面,此处为保持后方代码整洁简单实现一步alpha = 1e-3  # 学习率beta1 = 0.9  # 超参数beta2 = 0.999  # 超参数eps = 1e-8  # 超参数t = 0  # 初始化mt = 0  # 初始化vt = 0  # 初始化# 开始计算t = t + 1gt = gradmt = beta1 * mt + (1 - beta1) * gtvt = beta2 * vt + (1 - beta2) * gt ** 2mth = mt / (1 - beta1 ** t)vth = vt / (1 - beta2 ** t)weight = weight - (alpha / (np.sqrt(vth) + eps)) * mthreturn weightx = np.array([1, 2, 3, 4])  # 输入
y = np.array([0.1, -0.1, 0.01, -0.01])  # 预期输出# torch实验
torch_model = TorchModel(len(x))
torch_model_w = torch_model.state_dict()["layer.weight"]
print(torch_model_w, "初始化权重")
numpy_model_w = copy.deepcopy(torch_model_w.numpy())
# numpy array -> torch tensor, unsqueeze的目的是增加一个batchsize维度
torch_x = torch.from_numpy(x).float().unsqueeze(0)
torch_y = torch.from_numpy(y).float().unsqueeze(0)
# torch的前向计算过程,得到loss
torch_loss = torch_model(torch_x, torch_y)
print("torch模型计算loss:", torch_loss)
# #手动实现loss计算
diy_model = DiyModel(numpy_model_w)
diy_loss = diy_model.forward(x, y)
print("diy模型计算loss:", diy_loss)# #设定优化器
learning_rate = 0.1
optimizer = torch.optim.SGD(torch_model.parameters(), lr=learning_rate)
# optimizer = torch.optim.Adam(torch_model.parameters())
optimizer.zero_grad()
#
# #pytorch的反向传播操作
torch_loss.backward()
print(torch_model.layer.weight.grad, "torch 计算梯度")  # 查看某层权重的梯度# #手动实现反向传播
grad = diy_model.calculate_grad(diy_model.forward(x), y, x)
print(grad, "diy 计算梯度")
#
# #torch梯度更新
# optimizer.step()
# #查看更新后权重
# update_torch_model_w = torch_model.state_dict()["layer.weight"]
# print(update_torch_model_w, "torch更新后权重")
#
# #手动梯度更新
# diy_update_w = diy_sgd(grad, numpy_model_w, learning_rate)
# diy_update_w = diy_adam(grad, numpy_model_w)
# print(diy_update_w, "diy更新权重")

5. 网络结构 – 全连接层

全连接层又称线性层
计算公式:y = w * x + b
W和b是参与训练的参数
W的维度决定了隐含层输出的维度,一般称为隐单元个数(hidden size)
举例:
输入:x (维度1 x 3)
隐含层1:w(维度3 x 5)
隐含层2: w(维度5 x 2)
在这里插入图片描述

代码示例

#coding:utf8import torch
import torch.nn as nn
import numpy as np"""
numpy手动实现模拟一个线性层
"""#搭建一个2层的神经网络模型
#每层都是线性层
class TorchModel(nn.Module):def __init__(self, input_size, hidden_size1, hidden_size2):super(TorchModel, self).__init__()self.layer1 = nn.Linear(input_size, hidden_size1)self.layer2 = nn.Linear(hidden_size1, hidden_size2)def forward(self, x):hidden = self.layer1(x)   #shape: (batch_size, input_size) -> (batch_size, hidden_size1)y_pred = self.layer2(hidden) #shape: (batch_size, hidden_size1) -> (batch_size, hidden_size2)return y_pred#自定义模型
class DiyModel:def __init__(self, w1, b1, w2, b2):self.w1 = w1self.b1 = b1self.w2 = w2self.b2 = b2def forward(self, x):hidden = np.dot(x, self.w1.T) + self.b1y_pred = np.dot(hidden, self.w2.T) + self.b2return y_pred#随便准备一个网络输入
x = np.array([34.1, 0.3, 1.2])
#建立torch模型
torch_model = TorchModel(len(x), 5, 2)
print(torch_model.state_dict())
print("-----------")
#打印模型权重,权重为随机初始化
torch_model_w1 = torch_model.state_dict()["layer1.weight"].numpy()
torch_model_b1 = torch_model.state_dict()["layer1.bias"].numpy()
torch_model_w2 = torch_model.state_dict()["layer2.weight"].numpy()
torch_model_b2 = torch_model.state_dict()["layer2.bias"].numpy()
print(torch_model_w1, "torch w1 权重")
print(torch_model_b1, "torch b1 权重")
print("-----------")
print(torch_model_w2, "torch w2 权重")
print(torch_model_b2, "torch b2 权重")
print("-----------")
#使用torch模型做预测
torch_x = torch.FloatTensor([x])
y_pred = torch_model.forward(torch_x)
print("torch模型预测结果:", y_pred)
#把torch模型权重拿过来自己实现计算过程
diy_model = DiyModel(torch_model_w1, torch_model_b1, torch_model_w2, torch_model_b2)
#用自己的模型来预测
y_pred_diy = diy_model.forward(np.array([x]))
print("diy模型预测结果:", y_pred_diy)

6. 激活函数

模型添加非线性因素,使模型具有拟合非线性函数的能力

6.1 激活函数-Sigmoid

一种非线性映射,将任意输入映射到0-1之间
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

缺点:

  1. 计算耗时,包含指数运算
  2. 非0均值,会导致收敛慢
  3. 易造成梯度消失

代码示例

import numpy as npdef sigmoid(z):return 1 / (1 + np.exp(-z))# 示例
z = np.array([-1.0, 0.0, 1.0])
print(sigmoid(z))

6.2 激活函数-tanh

以0为均值,解决了sigmoid的一定缺点,但是依然存在梯度消失问题计算同样非常耗时
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

import numpy as npdef tanh(z):return np.tanh(z)# 示例
z = np.array([-1.0, 0.0, 1.0])
print(tanh(z))

6.3 激活函数-Relu

在正区间不易发生梯度消失
计算速度非常快
一定程度上降低过拟合的风险
在这里插入图片描述

在这里插入图片描述

import numpy as npdef relu(z):return np.maximum(0, z)# 示例
z = np.array([-1.0, 0.0, 1.0])
print(relu(z))

6.4 激活函数-Softmax

在这里插入图片描述
在这里插入图片描述

代码示例

#coding:utf8
import torch
import numpy'''
softmax的计算
'''def softmax(x):res = []for i in x:res.append(numpy.exp(i))res = [r / sum(res) for r in res]return res#e的1次方
print(numpy.exp(1))x = [1,2,3,4]
#torch实现的softmax
print(torch.softmax(torch.Tensor(x), 0))
#自己实现的softmax
print(softmax(x))

7. 损失函数

损失函数(也称为代价函数或误差函数)是一个核心组件于许多机器学习、统计学和优化任务中。它用于描述模型预测值与真实值之间的差异。通过最小化损失函数,我们可以找到模型的最佳参数,使模型的预测更加接近实际值。

7.1 损失函数-均方差

MSE mean square error
对均方差在做开根号,可以得到根方差
在这里插入图片描述
在这里插入图片描述

import numpy as npdef mean_squared_error(y_true, y_pred):return ((y_true - y_pred) ** 2).mean()# 示例
y_true = np.array([2.0, 4.0, 6.0])
y_pred = np.array([2.5, 3.5, 5.5])
print(mean_squared_error(y_true, y_pred))

7.2 损失函数-交叉熵

Cross Entropy
常用于分类任务
分类任务中,网络输出经常是所有类别上的概率分布
公式:
在这里插入图片描述

假设一个三分类任务,某样本的正确标签是第一类,则p = [1, 0, 0], 模型预测值假设为[0.5, 0.4, 0.1], 则交叉熵计算如下:
在这里插入图片描述

代码示例

import torch
import torch.nn as nn
import numpy as np'''
手动实现交叉熵的计算
'''#使用torch计算交叉熵
ce_loss = nn.CrossEntropyLoss()
#假设有3个样本,每个都在做3分类
pred = torch.FloatTensor([[0.3, 0.1, 0.3],[0.9, 0.2, 0.9],[0.5, 0.4, 0.2]])
#正确的类别分别为1,2,0
target = torch.LongTensor([1, 2, 0])
loss = ce_loss(pred, target)
print(loss, "torch输出交叉熵")#实现softmax函数
def softmax(matrix):return np.exp(matrix) / np.sum(np.exp(matrix), axis=1, keepdims=True)#验证softmax函数
# print(torch.softmax(pred, dim=1))
# print(softmax(pred.numpy()))#将输入转化为onehot矩阵
def to_one_hot(target, shape):one_hot_target = np.zeros(shape)for i, t in enumerate(target):one_hot_target[i][t] = 1return one_hot_target#手动实现交叉熵
def cross_entropy(pred, target):batch_size, class_num = pred.shapepred = softmax(pred)target = to_one_hot(target, pred.shape)entropy = - np.sum(target * np.log(pred), axis=1)return sum(entropy) / batch_sizeprint(cross_entropy(pred.numpy(), target.numpy()), "手动实现交叉熵")

7.3 损失函数-其他

指数损失
在这里插入图片描述

对数损失
在这里插入图片描述

0/1损失
在这里插入图片描述

Hinge损失(二分类)
在这里插入图片描述

8. 优化器

优化器-Adam

  1. 实现简单,计算高效,对内存需求少
  2. 超参数具有很好的解释性,且通常无需调整或仅需很少的微调
  3. 更新的步长能够被限制在大致的范围内(初始学习率)
  4. 能够表现出自动调整学习率
  5. 很适合应用于大规模的数据及参数的场景
  6. 适用于不稳定目标函数
  7. 适用于梯度稀疏或梯度存在很大噪声的问题

9. Pytorch

代码示例

# coding:utf8import torch
import torch.nn as nn
import numpy as np
import random
import json
import matplotlib.pyplot as plt"""基于pytorch框架编写模型训练
实现一个自行构造的找规律(机器学习)任务
规律:x是一个5维向量,如果第1个数>第5个数,则为正样本,反之为负样本"""class TorchModel(nn.Module):def __init__(self, input_size):super(TorchModel, self).__init__()self.linear = nn.Linear(input_size, 1)  # 线性层self.activation = torch.sigmoid  # sigmoid归一化函数self.loss = nn.functional.mse_loss  # loss函数采用均方差损失# 当输入真实标签,返回loss值;无真实标签,返回预测值def forward(self, x, y=None):x = self.linear(x)  # (batch_size, input_size) -> (batch_size, 1)y_pred = self.activation(x)  # (batch_size, 1) -> (batch_size, 1)if y is not None:return self.loss(y_pred, y)  # 预测值和真实值计算损失else:return y_pred  # 输出预测结果# 生成一个样本, 样本的生成方法,代表了我们要学习的规律
# 随机生成一个5维向量,如果第一个值大于第五个值,认为是正样本,反之为负样本
def build_sample():x = np.random.random(5)if x[0] > x[4]:return x, 1else:return x, 0# 随机生成一批样本
# 正负样本均匀生成
def build_dataset(total_sample_num):X = []Y = []for i in range(total_sample_num):x, y = build_sample()X.append(x)Y.append([y])return torch.FloatTensor(X), torch.FloatTensor(Y)# 测试代码
# 用来测试每轮模型的准确率
def evaluate(model):model.eval()test_sample_num = 100x, y = build_dataset(test_sample_num)print("本次预测集中共有%d个正样本,%d个负样本" % (sum(y), test_sample_num - sum(y)))correct, wrong = 0, 0with torch.no_grad():y_pred = model(x)  # 模型预测for y_p, y_t in zip(y_pred, y):  # 与真实标签进行对比if float(y_p) < 0.5 and int(y_t) == 0:correct += 1  # 负样本判断正确elif float(y_p) >= 0.5 and int(y_t) == 1:correct += 1  # 正样本判断正确else:wrong += 1print("正确预测个数:%d, 正确率:%f" % (correct, correct / (correct + wrong)))return correct / (correct + wrong)def main():# 配置参数epoch_num = 10  # 训练轮数batch_size = 20  # 每次训练样本个数train_sample = 5000  # 每轮训练总共训练的样本总数input_size = 5  # 输入向量维度learning_rate = 0.001  # 学习率# 建立模型model = TorchModel(input_size)# 选择优化器optim = torch.optim.Adam(model.parameters(), lr=learning_rate)log = []# 创建训练集,正常任务是读取训练集train_x, train_y = build_dataset(train_sample)# 训练过程for epoch in range(epoch_num):model.train()watch_loss = []for batch_index in range(train_sample // batch_size):x = train_x[batch_index * batch_size : (batch_index + 1) * batch_size]y = train_y[batch_index * batch_size : (batch_index + 1) * batch_size]optim.zero_grad()  # 梯度归零loss = model(x, y)  # 计算lossloss.backward()  # 计算梯度optim.step()  # 更新权重watch_loss.append(loss.item())print("=========\n第%d轮平均loss:%f" % (epoch + 1, np.mean(watch_loss)))acc = evaluate(model)  # 测试本轮模型结果log.append([acc, float(np.mean(watch_loss))])# 保存模型torch.save(model.state_dict(), "model.pth")# 画图print(log)plt.plot(range(len(log)), [l[0] for l in log], label="acc")  # 画acc曲线plt.plot(range(len(log)), [l[1] for l in log], label="loss")  # 画loss曲线plt.legend()plt.show()return# 使用训练好的模型做预测
def predict(model_path, input_vec):input_size = 5model = TorchModel(input_size)model.load_state_dict(torch.load(model_path))  # 加载训练好的权重# print(model.state_dict())model.eval()  # 测试模式with torch.no_grad():  # 不计算梯度result = model.forward(torch.FloatTensor(input_vec))  # 模型预测for vec, res in zip(input_vec, result):print("输入:%s, 预测类别:%d, 概率值:%f" % (vec, round(float(res)), res))  # 打印结果if __name__ == "__main__":main()test_vec = [[0.47889086,0.15229675,0.31082123,0.03504317,0.18920843],[0.94963533,0.5524256,0.95758807,0.95520434,0.84890681],[0.78797868,0.67482528,0.13625847,0.34675372,0.99871392],[0.1349776,0.59416669,0.92579291,0.41567412,0.7358894]]predict("model.pth", test_vec)

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

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

相关文章

Linux权限

Linux中一切皆文件&#xff0c;那么文件就应该有相对于的类型&#xff0c;而在Linux当中&#xff0c;类型不是直接看后缀来决定的。 -普通文件、文本、可执行、归档文件等d目录b块设备、block、磁盘c字符设备、键盘、显示器p管道文件s网络socket文件l链接文件 link 然后后面的九…

2023年京东儿童智能手表行业数据分析(京东销售数据分析)

儿童消费市场向来火爆&#xff0c;儿童智能手表作为能够实现定位导航&#xff0c;信息通讯&#xff0c;SOS求救&#xff0c;远程监听&#xff0c;智能防丢等多功能的智能可穿戴设备&#xff0c;能够通过较为精准的定位功能和安全防护能力保障儿童的安全&#xff0c;因而广受消费…

Oracle字段长度不足位数补零

Oracle字段长度不足位数补零 有时候从数据库中取出的月份值是1&#xff0c;而不是01&#xff0c;该怎么办呢 SELECTLPAD( CODE_MONTH, 2, 0 ) FROMtb_cube_TY001 WHERECODE_BM_MEATYPE TY20 AND code_measure MYLX01 AND code_month <> ~ AND CODE_ENTITY 01A AND…

k8s 安装istio (一)

前置条件 已经完成 K8S安装过程十&#xff1a;Kubernetes CNI插件与CoreDNS服务部署 部署 istio 服务网格与 Ingress 服务用到了 helm 与 kubectl 这两个命令行工具&#xff0c;这个命令行工具依赖 ~/.kube/config 这个配置文件&#xff0c;目前只在 kubernetes master 节点中…

Centos 7 安装系列(8):openGauss 3.0.0

安装依赖包&#xff1a; yum -y install libaio-devel flex bison ncurses-devel glibc-devel patch redhat-lsb-core readline-devel openssl-devel sqlite-devel libnsl 安装插件&#xff1a; yum install -y bzip2 net-tools为什么要安装这两个&#xff1f; 安装bzip2 是…

Ansible 创建使用角色

使用 Ansible Galaxy 和要求文件 /ansible/roles/requirements.yml 。从以下 URL 下载角色并安装到 /ansible/roles &#xff1a; http://materials/haproxy.tar 此角色的名称应当为 balancer http://materials/phpinfo.tar 此角色的名称应当为 phpinfo #创建 vim /ansible/r…

Wlan——锐捷零漫游网络解决方案以及相关配置

目录 零漫游介绍 一代零漫游 二代单频率零漫游 二代双频率零漫游 锐捷零漫游方案总结 锐捷零漫游方案的配置 配置无线信号的信道 开启关闭5G零漫游 查看配置 零漫游介绍 普通的漫游和零漫游的区别 普通漫游 漫游是由一个AP到另一个AP或者一个射频卡到另一个射频卡的漫…

工程管理与工作流

1 统一开发环境/ 协作工具 你知道开发环境指的是什么吗&#xff1f; 开发环境&#xff1a; 工程运行环境、开发工具/ 编辑器 、开发依赖环境、 配置文件 软件环境&#xff1a; “仿真预演”环境 Staging 生产环境前最终验证、 这一环境尽可能的仿真了真实的生产环境 、另一个…

MinIO线上扩容实战

硬件投入肯定是随着业务的增长而增长&#xff0c;这就要求中间件平台必须提供水平伸缩机制&#xff0c;MinIO对象存储服务也不例外&#xff0c;本文就详细介绍MinIO的扩容。 Minio支持通过增加新的Server Pool来扩容老的集群。每个Server Pool都是一个相对独立的故障域&#x…

SpeedBI数据可视化工具:浏览器上做分析

SpeedBI数据分析云是一种在浏览器上进行数据可视化分析的工具&#xff0c;它能够将数据以可视化的形式呈现出来&#xff0c;并支持多种数据源和图表类型。 所有操作&#xff0c;均在浏览器上进行 在浏览器中打开SpeedBI数据分析云官网&#xff0c;点击【免费使用】进入&#…

SQL Monitor Crack,PostgreSQL监控的传入复制图表

SQL Monitor Crack,PostgreSQL监控的传入复制图表  现在&#xff0c;您可以在从Estate页面导出的Microsoft Excel报告的摘要标题中看到UTC偏移量。 添加了PostgreSQL监控的传入复制图表。 Microsoft PowerShell API现在支持将使用New-SqlMonitorWindowsHost和New-SqlMonitorin…

【脚踢数据结构】图(纯享版)

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言&#xff0c;Linux基础&#xff0c;ARM开发板&#xff0c;软件配置等领域博主&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff01;送给自己和读者的…

vellum (Discovering Houdini VellumⅡ柔体系统)学习笔记

视频地址&#xff1a; https://www.bilibili.com/video/BV1ve411u7nE?p3&spm_id_frompageDriver&vd_source044ee2998086c02fedb124921a28c963&#xff08;搬运&#xff09; 个人笔记如有错误欢迎指正&#xff1b;希望可以节省你的学习时间 ~享受艺术 干杯&#x1f37b…

STP知识点总结

目录 一.什么是STP协议 二.STP生成树协议产生的原因 三. STP生成树协议涉及的算法 一.802.1D 二.PVST 三.PVST 四. 快速生成树 五.MSTP 一.什么是STP协议 在一个二层交换网络中&#xff0c;生成一棵树型结构&#xff0c;逻辑的阻塞部分接口&#xff0c;使得从根到所有的…

深度学习入门(三):卷积神经网络(CNN)

引入 给定一张图片&#xff0c;计算机需要模型判断图里的东西是什么&#xff1f; &#xff08;car、truck、airplane、ship、horse&#xff09; 一、卷积神经网络整体架构 CONV&#xff1a;卷积计算层&#xff0c;线性乘积求和RELU&#xff1a;激励层&#xff0c;激活函数P…

【欧拉计划】偶数斐波那契数

题目链接&#xff1a;偶数斐波那契数 解法一&#xff1a;暴力枚举 看见题目&#xff0c;第一反应就是先找到小于400万的所有斐波那契数&#xff0c;再从这些斐波那契数中筛选出偶数进行求和。 由于递归方法求斐波那契数的时间复杂度较高&#xff0c;故这里采用迭代的方法。 先…

谈谈对 GMP 的简单认识

犹记得最开始学习 golang 的时候&#xff0c;大佬们分享 GMP 模型的时候&#xff0c;总感觉云里雾里&#xff0c;听了半天&#xff0c;并没有一个很清晰的概念&#xff0c;不知 xmd 是否会有这样的体会 虽然 golang 入门很简单&#xff0c;但是对于理解 golang 的设计思想和原…

python、numpy、pytorch中的浅拷贝和深拷贝

1、Python中的浅拷贝和深拷贝 import copya [1, 2, 3, 4, [11, 22, 33, [111, 222]]] b a c a.copy() d copy.deepcopy(a)print(before modify\r\n a\r\n, a, \r\n,b a\r\n, b, \r\n,c a.copy()\r\n, c, \r\n,d copy.deepcopy(a)\r\n, d, \r\n)before modify a [1, 2…

从C语言到C++_33(C++11_上)initializer_list+右值引用+完美转发+移动构造/赋值

目录 1. 列表初始化initializer_list 2. 前面提到的一些知识点 2.1 小语法 2.2 STL中的一些变化 3. 右值和右值引用 3.1 右值和右值引用概念 3.2 右值引用类型的左值属性 3.3 左值引用与右值引用比较 3.4 右值引用的使用场景 3.4.1 左值引用的功能和短板 3.4.2 移动…

static相关知识点详解

文章目录 一. 修饰成员变量二. 修饰成员方法三. 修饰代码块四. 修饰类 一. 修饰成员变量 static 修饰的成员变量&#xff0c;称为静态成员变量&#xff0c;该变量不属于某个具体的对象&#xff0c;是所有对象所共享的。 public class Student {private String name;private sta…