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

news2024/11/24 20:42:20

一 深度学习基础相关

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

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

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

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

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

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

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

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

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

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

二 pytorch 基础操作

2.1 数据生成 (pytorch叫张量)

import torch
import torchvision

x = 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.coloradmin.cn/o/1522401.html

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

相关文章

【研发管理】产品经理-基础认知

【研发管理】产品经理-基础认知

导读：产品经理（Product Manager）是一个负责产品的全周期管理的职位，他们不仅参与产品的设计、开发、推广和销售，还涉及到产品的市场调研、用户需求分析、竞争分析、产品规划、产品测试以及后续的产品迭代等多个环节。产…
阅读更多...
安装snap再安装flutter再安装localsend@Ubuntu（FreeBSD下未成功）

安装snap再安装flutter再安装localsend@Ubuntu（FreeBSD下未成功）

Localsend介绍 localsend是一个跨平台的文件传送软件，可以在Windows、MacOS、Linux、Android和IOS下互相传送文件，只要在同一个局域网即可。 localsend官网：LocalSend 尝试安装localsend，发现需要使用flutter， 安装f…
阅读更多...
【AI】Ubuntu系统深度学习框架的神经网络图绘制

【AI】Ubuntu系统深度学习框架的神经网络图绘制

一、Graphviz 在Ubuntu上安装Graphviz，可以使用命令行工具apt进行安装。 安装Graphviz的步骤相对简单。打开终端，输入以下命令更新软件包列表：sudo apt update。之后，使用命令sudo apt install graphviz来安装Graphviz软件包。为…
阅读更多...
挑战杯 机器视觉人体跌倒检测系统 - opencv python

挑战杯 机器视觉人体跌倒检测系统 - opencv python

0 前言 🔥 优质竞赛项目系列，今天要分享的是 🚩 机器视觉人体跌倒检测系统 该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！ 🥇学长这里给一个题目综合评分(每项满分5分) 难度系数&…
阅读更多...
前端之CSS 创建css--行内引入、内联样式、外联样式

前端之CSS 创建css--行内引入、内联样式、外联样式

创建css有三种创建样式&#xff0c;行内引入、内联引入、外联引入。 行内引入 在行内标签引入 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>行内样式</title> </head> <body>…
阅读更多...
【安全类书籍-3】XSS跨站脚剖析与防御

【安全类书籍-3】XSS跨站脚剖析与防御

目录 内容简介 作用 下载地址 内容简介 这本书涵盖以下几点： XSS攻击原理：解释XSS是如何利用Web应用未能有效过滤用户输入的缺陷，将恶意脚本注入到网页中，当其他用户访问时被执行，实现攻击者的目的，例如窃取用户会话凭证、实施钓鱼攻击等。 XSS分类：分为存储型XSS（…
阅读更多...
单片机FLASH深度解析和编程实践（下）

单片机FLASH深度解析和编程实践（下）

本篇文章将同大家分享单片机FLASH编程的相关寄存器和寄存器操作及库函数操作。本篇文章依然以STM32单片机为例进行解析。有关FLASH的基本原理和实现方法&#xff0c;大家可以参考上一篇文章&#xff1a;单片机FLASH深度解析和编程实践&#xff08;上&#xff09;-CSDN博客 目录…
阅读更多...
ChatGPT编程—实现小工具软件(文件查找和筛选)

ChatGPT编程—实现小工具软件(文件查找和筛选)

ChatGPT编程—实现小工具软件(文件查找和筛选) 今天借助[小蜜蜂AI][https://zglg.work]网站的ChatGPT编程实现一个功能&#xff1a;根据特定需求结合通配符和其他条件来进行文件查找和筛选。在这个例子中&#xff0c;我们将创建一个函数find_files&#xff0c;它接受用户输入的…
阅读更多...
solr/ES 分词插件Jcseg设置自定义词库

solr/ES 分词插件Jcseg设置自定义词库

步骤&#xff1a; 1、找到配置文件jcseg-core/target/classes/jcseg.properties修改配置&#xff1a; 下载地址: https://gitee.com/lionsoul/jcseg#5-如何自定义使用词库 lexicon.path {jar.dir}/../custom-word 设置lexicon路径&#xff0c;我们这个配置可以自定义&#xf…
阅读更多...
Java 与 Go：可变数组

Java 与 Go：可变数组

可变数组&#xff08;也称为动态数组&#xff09;是一种可以在运行时动态增加或减少其大小的数据结构。由于其动态分配大小&#xff0c;灵活性增删改查&#xff0c;动态地管理内存&#xff08;在需要时动态分配内存空间&#xff0c;以适应数据结构的大小变化&#xff0c;而不会…
阅读更多...
NCV1117ST50T3G线性稳压器芯片中文资料规格书PDF数据手册引脚图图片价格参数

NCV1117ST50T3G线性稳压器芯片中文资料规格书PDF数据手册引脚图图片价格参数

产品概述&#xff1a; NCP1117系列为低压差&#xff08;LDO&#xff09;正向线性电压稳压器&#xff0c;能够提供超过1.0A的输出电流&#xff0c;800mA时温度范围内最大压差为1.2V。这一系列包括八个固定输出电压&#xff1a;1.5V、1.8V、2.0V、2.5V、2.85V、3.3V、5.0V 和 12…
阅读更多...
​​SQLiteC/C++接口详细介绍之sqlite3类（十一）

​​SQLiteC/C++接口详细介绍之sqlite3类（十一）

返回目录&#xff1a;SQLite—免费开源数据库系列文章目录 上一篇&#xff1a;​​SQLiteC/C接口详细介绍之sqlite3类&#xff08;十&#xff09; 下一篇&#xff1a;​​SQLiteC/C接口详细介绍之sqlite3类&#xff08;十二&#xff09;&#xff08;未发表&#xff09; 33.sq…
阅读更多...
【RS422】基于未来科技FT4232HL芯片的多波特率串口通信收发实现

【RS422】基于未来科技FT4232HL芯片的多波特率串口通信收发实现

功能简介 串行通信接口常常用于在计算机和低速外部设备之间传输数据。串口通信存在多种标准&#xff0c;以RS422为例&#xff0c;它将数据分成多个位&#xff0c;采用异步通信方式进行传输。   本文基于Xilinx VCU128 FPGA开发板&#xff0c;对RS422串口通信进行学习。   根…
阅读更多...
openlayers 入门教程（二）：map 篇

openlayers 入门教程（二）：map 篇

还是大剑师兰特&#xff1a;曾是美国某知名大学计算机专业研究生&#xff0c;现为航空航海领域高级前端工程师&#xff1b;CSDN知名博主&#xff0c;GIS领域优质创作者&#xff0c;深耕openlayers、leaflet、mapbox、cesium&#xff0c;canvas&#xff0c;webgl&#xff0c;ech…
阅读更多...
基于CNN多阶段图像超分+去噪(超级简单版)

基于CNN多阶段图像超分+去噪(超级简单版)

这是之前的一项工作&#xff0c;非常简单&#xff0c;简单的复现了两个算法&#xff0c;然后把它们串起来了。 可执行的程序链接&#xff1a;CSDN; Github 我们分成两部分进行讲解&#xff1a; 1. 图像去噪 1.1 基本思路 图像的去噪工作基于很普通的CNN去噪&#xff0c;效…
阅读更多...
Java基础 - 9 - 集合进阶（二）

Java基础 - 9 - 集合进阶（二）

一. Collection的其他相关知识 1.1 可变参数 可变参数就是一种特殊形参&#xff0c;定义在方法、构造器的形参列表里&#xff0c;格式是&#xff1a;数据类型…参数名称; 可变参数的特点和好处 特点&#xff1a;可以不传数据给它&#xff1b;可以传一个或者同时传多个数据给…
阅读更多...
2核4g服务器够用吗？

2核4g服务器够用吗？

2核4G服务器够用吗&#xff1f;够用。阿腾云以2核4G5M服务器搭建网站为例&#xff0c;5M带宽下载速度峰值可达640KB/秒&#xff0c;阿腾云以搭建网站为例&#xff0c;假设优化后平均大小为60KB&#xff0c;则5M带宽可支撑10个用户同时在1秒内打开网站&#xff0c;并发数为10&am…
阅读更多...
Github Copilot 工具，无需账号，一键激活

Github Copilot 工具，无需账号，一键激活

① 无需账号&#xff0c;100%认证成功&#xff01;0风险&#xff0c;可联网可更新&#xff0c;&#xff0c;支持copilot版本升级&#xff0c;支持chat ② 支持windows、mac、linux系统等设备 ③一号通用&#xff0c;支持所有IDE(AppCode,CLion,DataGrip,GoLand,IntelliJ IDEA …
阅读更多...
基于FPGA的光纤通信系统设计

基于FPGA的光纤通信系统设计

文章目录 光纤通信系统的组成发送端FPGA端口定义状态机设计代码示例 接收端功能模块端口定义状态机设计 光纤通信系统的组成 发送端FPGA 发送控制逻辑、数据编码、校验码生成、缓存控制、时钟控制 端口定义 状态机设计 代码示例 接收端功能模块 接收端控制逻辑、数据解码、…
阅读更多...
【PHP + 代码审计】函数详解

【PHP + 代码审计】函数详解

&#x1f36c; 博主介绍&#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 hacker-routing &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【应急响应】 【Java、PHP】 【VulnHub靶场复现】【面试分析】 &#x1f389;点赞➕评论➕收…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023