pytorch 入门基础知识一（Pytorch 01）

一 深度学习基础相关

深度学习三个主要的方向：计算机视觉，自然语言，语音识别。

机器学习核心组件：1 数据集(data)，2 前向传播的model(net)，3 目标函数(loss)， 4 调整模型参数和优化函数的算法(adam)。

数据集：用于模型训练的数据。

模型：用于前向传播计算的model, 其中涉及各种复杂的网络，Alexnet, CNN等都属于这个模块的内容，对于传统模型，常规使用公式计算结果的公式其实就是模型的一种，模型主要作用是通过记录的参数计算想要的目标值。

目标函数：常用的均方误差，平方误差都是，目标函数的一直，用于评估预测值和实际结果的偏差。

优化算法：深度学习常用的梯度下降算法，在训练模型参数时用于减小损失误差。

不管是回归还是分类问题其实都是监督学习的内容，就是在训练模型是有一个目标值，而聚类算法，对抗性网络等属于无监督学习。

强化学习更考虑与环境的互动，在实际环境中根据实际结果做反馈实时修正模型。

PS：机器学习很吃数据，如果数据量不够，可能得考虑传统方法，比如之前遇到的一个项目，训练数据不够，属于前期就介入，根本没太多历史数据，不能够拟合出正确应对实际场景的应用，最后使用传统反馈调整的模式解决了问题，做视觉其实也遇到了这个问题，异常数据太少，而且不是很普遍，还是考虑传统方式处理，起码稳定。

计算机算力确实发生了很大的变化，近两年还是风云突变：

二 pytorch 基础操作

2.1 数据生成 (pytorch叫张量)

import torch
import torchvisionx = torch.arange(12)
x   # tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

 查看数据形状：

x.shape# torch.Size([12])

查看张量的总数据量：

x.numel()   # 矩阵元素数量  # 12

调整张量的形状：

X = x.reshape(3, 4)
X
# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11]])

生成指定形状的数组：

torch.zeros((2, 3, 4))
# tensor([[[0., 0., 0., 0.],
#          [0., 0., 0., 0.],
#          [0., 0., 0., 0.]],#         [[0., 0., 0., 0.],
#          [0., 0., 0., 0.],
#          [0., 0., 0., 0.]]])

指定形状数据为1的张量：

torch.ones((2, 3, 4))
# tensor([[[1., 1., 1., 1.],
#          [1., 1., 1., 1.],
#          [1., 1., 1., 1.]],#         [[1., 1., 1., 1.],
#          [1., 1., 1., 1.],
#          [1., 1., 1., 1.]]])

正太分布的张量：

torch.randn(3, 4)
# tensor([[ 1.2365,  0.2051,  1.0180,  1.2629],
#         [-1.2494, -0.3436, -0.7135, -2.0160],
#         [-1.2806,  1.5036, -0.2523, -0.1456]])

直接将列表转换为tensor张量：

torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
# tensor([[2, 1, 4, 3],
#         [1, 2, 3, 4],
#         [4, 3, 2, 1]])

2.2 pytorch 运算符

可以直接 + - * /：

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # **运算符是求幂运算
# (tensor([ 3.,  4.,  6., 10.]),
#  tensor([-1.,  0.,  2.,  6.]),
#  tensor([ 2.,  4.,  8., 16.]),
#  tensor([0.5000, 1.0000, 2.0000, 4.0000]),
#  tensor([ 1.,  4., 16., 64.]))

求幂：

torch.exp(x)   # e^x
# tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

张量拼接，通过dim指定行还是列拼接：

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
# (tensor([[ 0.,  1.,  2.,  3.],
#          [ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.],
#          [ 2.,  1.,  4.,  3.],
#          [ 1.,  2.,  3.,  4.],
#          [ 4.,  3.,  2.,  1.]]),
#  tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
#          [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
#          [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

逻辑运算：

X == Y
# tensor([[False,  True, False,  True],
#         [False, False, False, False],
#         [False, False, False, False]])

所有元素求和：

X.sum()
# tensor(66.)

2.3 广播机制

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
# (tensor([[0],
#          [1],
#          [2]]),
#  tensor([[0, 1]]))

自动广播：

a + b
# tensor([[0, 1],
#         [1, 2],
#         [2, 3]])

2.4 索引和切片

张量切片：

X = torch.arange(12, dtype=torch.float32).reshape((3,4))
X[-1], X[1:3]
# (tensor([ 8.,  9., 10., 11.]),
#  tensor([[ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.]]))

指定位置写入数据：

X[1, 2] = 9
X
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  9.,  7.],
#         [ 8.,  9., 10., 11.]])

同时写入多个值：

X[0:2, :] = 12
X
# tensor([[12., 12., 12., 12.],
#         [12., 12., 12., 12.],
#         [ 8.,  9., 10., 11.]])

2.5 原地更新参数

查看内存地址：

before = id(Y)
Y = Y + X
id(Y) == before
# False

张量原地更新：

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
# id(Z): 2385633027792
# id(Z): 2385633027792

也可以直接写入原地址：

before = id(X)
X += Y
id(X) == before
# True

2.6 转换为python其他数据类型

numpy转换, torch.tensor() :

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)
# (numpy.ndarray, torch.Tensor)

直接转换，a.item() 用于获取张量（Tensor）中单个元素 的值：

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)
# (tensor([3.5000]), 3.5, 3.5, 3)

三 数据预处理

3.1 读取数据集

创建数据写入 house_tiny.csv 文件：

import os
os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')
with open(data_file, 'w') as f:f.write('NumRooms,Alley,Price\n') # 列名f.write('NA,Pave,127500\n') # 每行表示一个数据样本f.write('2,NA,106000\n')f.write('4,NA,178100\n')f.write('NA,NA,140000\n')

pd.read_csv() 读取数据：

import pandas as pd
data = pd.read_csv(data_file)
print(data)
#    NumRooms Alley   Price
# 0       NaN  Pave  127500
# 1       2.0   NaN  106000
# 2       4.0   NaN  178100
# 3       NaN   NaN  140000

3.2 处理缺失值

第一列均值填充：

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
# 使用均值填充第一列的缺失值
inputs.iloc[:, 0] = inputs.iloc[:, 0].fillna(inputs.iloc[:, 0].mean())
print(inputs)
#    NumRooms Alley
# 0       3.0  Pave
# 1       2.0   NaN
# 2       4.0   NaN
# 3       3.0   NaN

第二列独热编码：

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)
#    NumRooms  Alley_Pave  Alley_nan
# 0       3.0        True      False
# 1       2.0       False       True
# 2       4.0       False       True
# 3       3.0       False       True

数据格式转换为张量：

import torch
X = torch.tensor(inputs.to_numpy(dtype=float))
y = torch.tensor(outputs.to_numpy(dtype=float))
X, y
# (tensor([[3., 1., 0.],
#          [2., 0., 1.],
#          [4., 0., 1.],
#          [3., 0., 1.]], dtype=torch.float64),
#  tensor([127500., 106000., 178100., 140000.], dtype=torch.float64))

四 线性代数

标量：

import torch
x = torch.tensor(3.0)
y = torch.tensor(2.0)
x + y, x * y, x / y, x**y
# (tensor(5.), tensor(6.), tensor(1.5000), tensor(9.))

向量可以被视为标量值组成的列表：

x = torch.arange(4)
x
# tensor([0, 1, 2, 3])

下标 取元素：

x[3]
# tensor(3)

向量 长度：

len(x)
# 4

张量形状：

x.shape
# torch.Size([4])

4.1 矩阵

向量将标量从零阶推广到一阶，矩阵将向量从一阶推广到二阶。

A = torch.arange(20).reshape(5, 4)
A
# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11],
#         [12, 13, 14, 15],
#         [16, 17, 18, 19]])

矩阵转置：

A.T
# tensor([[ 0,  4,  8, 12, 16],
#         [ 1,  5,  9, 13, 17],
#         [ 2,  6, 10, 14, 18],
#         [ 3,  7, 11, 15, 19]])

对称矩阵，一个矩阵和它的转置矩阵一样的时候该矩阵为对称矩阵：

B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
B
# tensor([[1, 2, 3],
#         [2, 0, 4],
#         [3, 4, 5]])
B == B.T
# tensor([[True, True, True],
#         [True, True, True],
#         [True, True, True]])

4.2 张量

张量是一个更广泛的概念，可以包括标量、向量以及更高维度的数组。

X = torch.arange(24).reshape(2, 3, 4)
X
# tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]],#         [[12, 13, 14, 15],
#          [16, 17, 18, 19],
#          [20, 21, 22, 23]]])

4.3 张量算法的基本性质

给定具有相同形 状的任意两个张量，任何按元素二元运算的结果都将是相同形状的张量。例如，将两个相同形状的矩阵相加， 会在这两个矩阵上执行元素加法，张量形状不变。

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone() # 通过分配新内存，将A的一个副本分配给B
A, A + B
# (tensor([[ 0.,  1.,  2.,  3.],
#          [ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.],
#          [12., 13., 14., 15.],
#          [16., 17., 18., 19.]]),
#  tensor([[ 0.,  2.,  4.,  6.],
#          [ 8., 10., 12., 14.],
#          [16., 18., 20., 22.],
#          [24., 26., 28., 30.],
#          [32., 34., 36., 38.]]))
A * B
# tensor([[  0.,   1.,   4.,   9.],
#         [ 16.,  25.,  36.,  49.],
#         [ 64.,  81., 100., 121.],
#         [144., 169., 196., 225.],
#         [256., 289., 324., 361.]])

将张量乘以或加上一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘，广播机制。

a = 2
X = torch.arange(24).reshape(2, 3, 4)
a + X, (a * X).shape
# (tensor([[[ 2,  3,  4,  5],
#           [ 6,  7,  8,  9],
#           [10, 11, 12, 13]],#          [[14, 15, 16, 17],
#           [18, 19, 20, 21],
#           [22, 23, 24, 25]]]),
#  torch.Size([2, 3, 4]))

4.4 降维

x = torch.arange(4, dtype=torch.float32)
x, x.sum()
# (tensor([0., 1., 2., 3.]), tensor(6.))

 sum() 可以对所有元素求和，算预测结果损失和有用：

A.shape, A.sum()
# (torch.Size([5, 4]), tensor(190.))

axis 指定张量降维维度：

A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape
# (tensor([40., 45., 50., 55.]), torch.Size([4]))
A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape
# (tensor([ 6., 22., 38., 54., 70.]), torch.Size([5]))
A.sum(axis=[0, 1]) # 结果和A.sum()相同
# tensor(190.)

求所有元素均值：

A.mean(), A.sum() / A.numel()
# (tensor(9.5000), tensor(9.5000))

指定维度均值：

A.mean(axis=0), A.sum(axis=0) / A.shape[0]
# (tensor([ 8.,  9., 10., 11.]), tensor([ 8.,  9., 10., 11.]))

非降维求和：

sum_A = A.sum(axis=1, keepdims=True)
sum_A
# # tensor([[ 6.],
#         [22.],
#         [38.],
#         [54.],
#         [70.]])

 由于sum_A在对每行进行求和后仍保持两个轴，我们可以通过广播将A除以sum_A，求该行每个元素的占比。

A / sum_A
# tensor([[0.0000, 0.1667, 0.3333, 0.5000],
#         [0.1818, 0.2273, 0.2727, 0.3182],
#         [0.2105, 0.2368, 0.2632, 0.2895],
#         [0.2222, 0.2407, 0.2593, 0.2778],
#         [0.2286, 0.2429, 0.2571, 0.2714]])

沿某个轴计算A元素的累积总和，比如axis=0（按行计算），可以调用cumsum函数。

print(A)
A.cumsum(axis=0)
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  6.,  7.],
#         [ 8.,  9., 10., 11.],
#         [12., 13., 14., 15.],
#         [16., 17., 18., 19.]])
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  6.,  8., 10.],
#         [12., 15., 18., 21.],
#         [24., 28., 32., 36.],
#         [40., 45., 50., 55.]])

4.5 点积

深度学习中线性模型在 前向传播中使用的就是点积：

x = torch.arange(4, dtype=torch.float32)
y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)
# (tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))

可以通过执行按元素乘法，然后进行求和来表示两个向量的点积：

torch.sum(x * y)
# tensor(6.)

矩阵向量积，结果是一个新的向量，A的列维数（沿轴1的长度）必须与x的维数（其长度）相同：

print(A)
print(x)
A.shape, x.shape, torch.mv(A, x)
# tensor([[ 0.,  1.,  2.,  3.],
#         [ 4.,  5.,  6.,  7.],
#         [ 8.,  9., 10., 11.],
#         [12., 13., 14., 15.],
#         [16., 17., 18., 19.]])
# tensor([0., 1., 2., 3.])
# (torch.Size([5, 4]), torch.Size([4]), tensor([ 14.,  38.,  62.,  86., 110.]))

矩阵-矩阵乘法，torch.mm 用于计算两个矩阵的乘积：

B = torch.ones(4, 3)
A, B, torch.mm(A, B)
# (tensor([[ 0.,  1.,  2.,  3.],
#          [ 4.,  5.,  6.,  7.],
#          [ 8.,  9., 10., 11.],
#          [12., 13., 14., 15.],
#          [16., 17., 18., 19.]]),
#  tensor([[1., 1., 1.],
#          [1., 1., 1.],
#          [1., 1., 1.],
#          [1., 1., 1.]]),
#  tensor([[ 6.,  6.,  6.],
#          [22., 22., 22.],
#          [38., 38., 38.],
#          [54., 54., 54.],
#          [70., 70., 70.]]))

4.6 范数

欧几里得距离是一个L2范数，向量元素平方和的平方根：

u = torch.tensor([3.0, -4.0])
torch.norm(u)
# tensor(5.)

L1范数，我们将元素绝对值求和 组合起来：

torch.abs(u).sum()
# tensor(7.)

Frobenius范数 满足向量范数的所有性质，它就像是 矩阵形向量的L2范数。

n = torch.ones((4, 9))
n, torch.norm(n)
# (tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1.],
#          [1., 1., 1., 1., 1., 1., 1., 1., 1.],
#          [1., 1., 1., 1., 1., 1., 1., 1., 1.],
#          [1., 1., 1., 1., 1., 1., 1., 1., 1.]]),
#  tensor(6.))

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

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

相关文章

【STM32定时器（一）内部时钟定时与外部时钟 TIM小总结】

【STM32定时器（一）内部时钟定时与外部时钟 TIM小总结】

STM32 TIM详解 TIM介绍定时器类型基本定时器通用定时器高级定时器常用名词时序图预分频时序计数器时序图 定时器中断配置图定时器定时 代码调试代码案例1代码案例2 TIM介绍 定时器（Timer）是微控制器中的一个重要模块，用于生成定时和延时信号…
阅读更多...
mybatis源码阅读系列（一）

mybatis源码阅读系列（一）

源码下载 mybatis 初识mybatis MyBatis 是一个优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解用于配置和原始映射，将接口和 Java 的…
阅读更多...
什么是软件开发？软件开发阶段划分是什么？并以LabVIEW为例进行说明

什么是软件开发？软件开发阶段划分是什么？并以LabVIEW为例进行说明

软件开发是一种创建、设计、编码、测试和维护应用程序、框架或其他软件组件的过程。它涉及从理解需求到设计、实现、测试、部署和最终维护的全过程。软件开发可以用来创建新的软件应用、系统软件、游戏、或开发网络应用等。 软件开发过程通常可以分为以下几个阶段：…
阅读更多...
[蓝桥杯 2021 省 AB2] 完全平方数

[蓝桥杯 2021 省 AB2] 完全平方数

题目链接 [蓝桥杯 2021 省 AB2] 完全平方数 题目描述 一个整数 a a a 是一个完全平方数，是指它是某一个整数的平方，即存在一个 整数 b b b，使得 a b 2 a b^2 ab2。 给定一个正整数 n n n，请找到最小的正整数 x x x&#…
阅读更多...
基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的自动驾驶目标检测系统详解（深度学习+Python代码+PySide6界面+训练数据集）

基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的自动驾驶目标检测系统详解（深度学习+Python代码+PySide6界面+训练数据集）

摘要：开发自动驾驶目标检测系统对于提高车辆的安全性和智能化水平具有至关重要的作用。本篇博客详细介绍了如何运用深度学习构建一个自动驾驶目标检测系统，并提供了完整的实现代码。该系统基于强大的YOLOv8算法，并对比了YOLOv7、YOLOv6、YOLO…
阅读更多...
相机与相机模型（针孔/鱼眼/全景相机）

相机与相机模型（针孔/鱼眼/全景相机）

本文旨在较为直观地介绍相机成像背后的数学模型，主要的章节组织如下： 第1章用最简单的针孔投影模型为例讲解一个三维点是如何映射到图像中的一个像素 第2章介绍除了针孔投影模型外其他一些经典投影模型，旨在让读者建立不同投影模型之间的建模…
阅读更多...
RabbitMQ高级-高级特性

RabbitMQ高级-高级特性

1.消息可靠性传递 在使用RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ为我们提供了两种方式来控制消息的投递可靠性模式 1.confirm 确认模式 确认模式是由exchange决定的 2.return 退回模式 回退模式是由routing…
阅读更多...
LRC转SRT

LRC转SRT

最近看到一首很好的英文MTV原版，没又字幕，自己找字幕，只找到LRC，ffmpeg不支持LRC，网上在线转了SRT。 Subtitle Converter | Free tool | GoTranscript 然后用 ffmpeg 加字幕 ffmpeg -i LoveMeLikeYouDo.mp4 -vf sub…
阅读更多...
nginx配置websocket

nginx配置websocket

非加密的WebSocket连接。 #ws# 这是一个ws配置示例，表示使用非加密的WebSocket连接。 server { listen 8080; server_name example.com; location /websocket { proxy_pass http://backend-server; proxy_http_version 1.1; proxy_set_header Upgrade $http…
阅读更多...
PyTorch学习笔记之基础函数篇（四）

PyTorch学习笔记之基础函数篇（四）

文章目录 2.8 torch.logspace函数讲解2.9 torch.ones函数2.10 torch.rand函数2.11 torch.randn函数2.12 torch.zeros函数 2.8 torch.logspace函数讲解 torch.logspace 函数在 PyTorch 中用于生成一个在对数尺度上均匀分布的张量（tensor）。这意味着张量中…
阅读更多...
【vue2源码】模版编译

【vue2源码】模版编译

文章目录 一、mount 基本流程二、执行 $mount 方法三、模版编译1、入口代码2、parse2.1 parseHTML2.2 parseText 3、generategenElement 函数 4、createCompileToFunctionFn 4、mountComponent 一、mount 基本流程 在执行 _init (new Vue时) 的方法中，调用了 vm.$m…
阅读更多...
力扣热题100_矩阵_240_搜索二维矩阵 II

力扣热题100_矩阵_240_搜索二维矩阵 II

文章目录 题目链接解题思路解题代码 题目链接 240. 搜索二维矩阵 II 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性： 每行的元素从左到右升序排列。 每列的元素从上到下升序排列。 示例 1： 输入&#xf…
阅读更多...
pytorch DDP模式下, 获取数据的的preftech + stream

pytorch DDP模式下, 获取数据的的preftech + stream

直接上代码 - DDP forward if self.device_ids:if len(self.device_ids) 1:inputs, kwargs self.to_kwargs(inputs, kwargs, self.device_ids[0])output self.module(*inputs[0], **kwargs[0])else:inputs, kwargs self.scatter(inputs, kwargs, self.device_ids)outputs …
阅读更多...
GAMES104-现代游戏引擎 1

GAMES104-现代游戏引擎 1

主要学习重点还是面向就业，重点复习八股和算法 每天早上八点到九点用来学习这个课程 持续更新中... 第一节 游戏引擎导论 第二节 引擎架构分层
阅读更多...
OLLAMA：如何像云端一样运行本地大语言模型

OLLAMA：如何像云端一样运行本地大语言模型

简介：揭开 OLLAMA 本地大语言模型的神秘面纱 您是否曾发现自己被云端语言模型的网络所缠绕，渴望获得更本地化、更具成本效益的解决方案？那么，您的探索到此结束。欢迎来到 OLLAMA 的世界，这个平台将彻底改变我们与大型…
阅读更多...
橡胶工厂5G智能制造数字孪生可视化平台，推进橡胶工业数字化转型

橡胶工厂5G智能制造数字孪生可视化平台，推进橡胶工业数字化转型

橡胶5G智能制造工厂数字孪生可视化平台，推进橡胶工业数字化转型。随着信息技术的迅猛发展和智能制造的不断推进，数字化转型已成为制造业转型升级的重要方向。橡胶工业作为传统制造业的重要领域，正面临着产业升级和转型的迫切需求。橡胶5G智能…
阅读更多...
软考79-上午题-【面向对象技术3-设计模式】-结构型设计模式02

软考79-上午题-【面向对象技术3-设计模式】-结构型设计模式02

一、组合模式 1-1、意图 将对象组合成树型结构，以表示"部分-整体"的层次结构。Composite使得用户对单个对象和组 合对象的使用具有一致性。 示例：对象：文件、文件夹 1-2、结构 Component 为组合中的对象声明接口；在适…
阅读更多...
决策树 | 分类树回归树：算法逻辑

决策树 | 分类树回归树：算法逻辑

目录 一. 决策树(Decision Tree)1. 决策树的构建1.1 信息熵(Entropy)1.1.1 信息量&信息熵 定义1.1.2 高信息熵&低信息熵 定义1.1.3 信息熵 公式 1.2 信息增益(Information Gain)1.2.1 信息增益的计算1.2.2 小节 2. 小节2.1 算法分类2.2 决策树算法分割选择2.3 决策树算…
阅读更多...
C# 单例模式

C# 单例模式

单例模式介绍 单例模式只允许被其自身实例化一次，且向外部提供了一个访问该实例的接口。 通常来说，单例对象进行实例化时一般不带参数，因为如果不同的实例化请求传递的参数不同的话会导致问题的产生。 单例模式主要特点 全局唯一性&#xf…
阅读更多...
提升物流效率，快递平台实战总结与分享

提升物流效率，快递平台实战总结与分享

随着电商行业的蓬勃发展，物流配送服务变得愈发重要。快递平台作为连接电商企业和消费者的桥梁，扮演着至关重要的角色。本篇博客将分享快递平台实战经验，总结关键要点，帮助物流从业者提升物流效率、优化服务质量。 ### 快递平台实…
阅读更多...
最新文章

Copyright @ 2022~2023