python数据分析——numpy基本用法

numpy数据类型

在NumPy中，有多种数据类型可用于表示数组的元素。以下是一些常见的NumPy数据类型：

  • int - 整数类型，如int8、int16、int32、int64等。
  • uint -无符号整数类型，如uint8、uint16、uint32、uint64等。
  • float -浮点数类型，如float16、float32、float64等。
  • complex - 复数类型，如complex64、complex128等。 bool - 布尔类型，表示True或False。
  • object -对象类型，可以存储任意Python对象。 string - 字符串类型，如string_。
  • datetime -日期和时间类型，如datetime64。

dtype

检测数据类型

a = np.array([2, 5, 0, 6, 7],dtype=bool)
print(a)
#[ True  True False  True  True]

a = np.array(range(6))
print(a.dtype)

astype

转换类型

b = np.array(range(6))
print("b转换类型后的值为{}".format(b.astype(bool)))
# b转换类型后的值为[False  True  True  True  True  True]

arange

随机数

c=np.arange(1,6,2)
# [1 3 5]

数组的形状

shape

shape是NumPy数组的一个属性，用于返回数组的维度信息。它返回一个元组，其中的每个元素表示数组在对应维度上的大小

例如：（2，3）
shape属性返回了一个元组(2, 3)，表示数组的第一维度大小为2，第二维度大小为3。

reshape

reshape是NumPy数组的一个方法，用于改变数组的形状。它接受一个参数，即新的形状，可以是一个元组或整数列表。reshape方法将返回一个具有新形状的新数组，而原始数组保持不变。

如果在reshape方法中指定的新形状中有一个维度为-1，NumPy将根据数组的大小自动计算该维度的大小。

例如，如果原始数组有12个元素，可以将其重塑为(3, -1)，-1将被自动计算为4

import numpy as npa = np.arange(24)
new_a1 = a.reshape((4,6))
new_a2 = a.reshape((2,2,6))print(a)
#[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
print(new_a1)
# [ [ 0  1  2  3  4  5]
#   [ 6  7  8  9 10 11]
#   [12 13 14 15 16 17]#  [18 19 20 21 22 23] ]
print(new_a2)
#[[[ 0  1  2  3  4  5]
# [ 6  7  8  9 10 11]]# [[12 13 14 15 16 17]
#  [18 19 20 21 22 23]]]print(a.shape)
#(24,)
print(new_a1.shape)
#(4, 6)
print(new_a2.shape)
#(2, 2, 6)

np.flatten()

是NumPy数组的一个方法，用于将多维数组转换为一维数组。

np.eyes()

np.eye() 是一个 NumPy 函数，用于创建一个二维的单位矩阵（identity matrix）。单位矩阵是一个对角线上的元素都为 1，其余元素都为 0 的方阵。

np.eye(N) 接受一个整数 N 作为参数，并返回一个形状为 (N, N) 的单位矩阵。每个对角线上的元素都是 1，其他位置上的元素都是 0。

以下是 np.eye() 的使用示例：

import numpy as np# 创建一个形状为 (3, 3) 的单位矩阵
identity_matrix = np.eye(3)
print(identity_matrix)
# 输出
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]

在上面的示例中，np.eye(3) 创建了一个形状为 (3,3) 的单位矩阵。该单位矩阵在主对角线上的元素值均为1，其他位置上的元素值均为0。

你还可以通过指定 k 参数来创建具有偏移主对角线的单位矩阵。例如：

import numpy as np# 创建一个形状为 (4,4) 偏移主对角线两位的单位矩阵
identity_matrix = np.eye(4, k=2)
print(identity_matrix)
# 输出
# [[0.  0  1  0]
# [0.  0  0  1]
# [0.  0   0   0]
# [0.  0   0   0]]

在上面的示例中，np.eye(4, k=2) 创建了一个形状为 (4,4) 的单位矩阵，其中主对角线向右偏移两位。因此，在第三行和第四行上的主对角线元素值为1。

np.argmax()/np.argmin()

argmax 是 NumPy 中的一个函数，用于返回数组中最大元素的索引值。

语法：numpy.argmax(a, axis=None, out=None)
参数： a：输入的数组。
axis：可选参数，指定沿着哪个轴计算最大值。如果不提供该参数，则返回整个数组中最大元素的索引。默认为 None。
out：可选参数，用于指定输出结果的位置。 返回值：

如果没有指定 axis 参数，则返回整个数组中最大元素的索引。
如果指定了 axis 参数，则根据给定轴计算每行/列/深度维度上最大元素，并返回相应维度上最大元素所在位置的索引。
以下是使用 argmax() 函数获取数组中最大元素索引值的示例：

import numpy as nparr = np.array([1, 3, 2, 5, 4])
index = np.argmax(arr)print(f"Array: {arr}")
print(f"Index of maximum element: {index}")
# 输出
# Array: [1 3 2 5 4]
# Index of maximum element: 3

在上面的示例中，我们有一个一维数组 [1, 3, 2, 5, 4]。通过调用 np.argmax(arr) 函数，我们找到了该数组中最大数字5所在位置（索引为3）。

import numpy as nparr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
indices = np.argmax(arr, axis=1)print(f"Array:\n{arr}")
print(f"Indices of maximum elements along each row: {indices}")
# 输出
# Array:
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# Indices of maximum elements along each row: [2 2 2]

在上面的示例中，我们有一个二维数组 [[1,2,3], [4,5,6], [7,8,9]]。通过调用 np.argmax(arr,axis=1) 函数，我们找到了每一行中最大数字所在位置（索引）。返回结果为一个一维数组 [2,2.2]，其中 [2] 表示第一行最大元素（值为3）所在位置的索引，以此类推。

数组和数的计算

算术运算

import numpy as nparr = np.array([1, 2, 3])add_result = arr + 5
sub_result = arr - 5
mul_result = arr * 5
div_result = arr / 5print(add_result)  # [6 7 8]
print(sub_result)  # [-4 -3 -2]
print(mul_result)  # [5 10 15]
print(div_result)  # [0.2 0.4 0.6]

平方根和指数运算

import numpy as nparr = np.array([1, 4, 9])sqrt_result = np.sqrt(arr)
exp_result = np.exp(arr)print(sqrt_result)  # [1. 2. 3.]
print(exp_result)   # [  2.71828183  54.59815003 810.7788846 ]

数组和数组的计算

算术运算

一维数组

import numpy as np# 一一对应做运算
arr1 = np.array([1,2,3])
arr2 = np.array([4,5,6])add_result = arr1 + arr2
sub_result = arr1 - arr2
mul_result = arr1 * arr2
div_result = arr1 / arr2print(add_result)  # [5 7 9]
print(sub_result)  # [-3 -3 -3]
print(mul_result)  # [4 10 18]
print(div_result)  # [0.25 0.4  0.5]

多维数组

import numpy as nparr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])add_result = arr1 + arr2
sub_result = arr1 - arr2
mul_result = arr1 * arr2
div_result = arr1 / arr2print(add_result)
# [[ 6  8]
#  [10 12]]print(sub_result)
# [[-4 -4]
#  [-4 -4]]print(mul_result)
# [[ 5 12]
#  [21 32]]print(div_result)
# [[0.2        0.33333333]
#  [0.42857143 0.5       ]]

统计计算

import numpy as nparr = np.array([[1, 2], [3, 4], [5, 6]])max_value = np.max(arr, axis=0)  # 沿着轴0计算每列的最大值
min_value = np.min(arr, axis=1)  # 沿着轴1计算每行的最小值
mean_value = np.mean(arr)        # 计算整个数组的平均值
std_value = np.std(arr, axis=None)  # 计算整个数组的标准差print(max_value)   # [5 6]
print(min_value)   # [1 3 5]
print(mean_value)  # 3.5
print(std_value)   # 1.707825127659933

矩阵运算

  • np.dot()函数执行矩阵乘法
  • .T矩阵转置
import numpy as nparr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])dot_result = np.dot(arr1, arr2)
transpose_result = arr1.Tprint(dot_result)
# [[19 22]
#  [43 50]]print(transpose_result)
# [[1 3]
#  [2 4]]

在这里插入图片描述

广播规则

当两个数组的形状不同的时候，NumPy会使用广播规则来自动调整数组的形状，以使它们能够参与运算。

广播规则的基本原则是，当两个数组的维度不匹配时，NumPy会尝试通过在缺失的维度上扩展数组来使它们具有相同的形状。广播的过程是自动完成的，无需手动操作。

import numpy as nparr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([1, 2, 3])add_result = arr1 + arr2
mul_result = arr1 * arr2print(add_result)
# [[2 4 6]
#  [5 7 9]]print(mul_result)
# [[ 1  4  9]
#  [ 4 10 18]]
import numpy as nparr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[1], [2]])add_result = arr1 + arr2
mul_result = arr1 * arr2print(add_result)
# [[2 3 4]
#  [6 7 8]]print(mul_result)
# [[ 1  2  3]
#  [ 8 10 12]]

numpy读取数据

在这里插入图片描述
np.loadtxt()函数来读取文本文件中的数据。该函数可以接受文件名作为参数，并返回一个包含文件中数据的NumPy数组

# data = np.loadtxt('data.txt',delimiter=',',skiprows=1)
data = np.loadtxt('data.txt',delimiter=',',dtype='str')
# data = np.loadtxt('data.txt',delimiter=',',skiprows=1,unpack=True)

索引和切片

获取数据

在这里插入图片描述

# 第二行
data[2]
# 第二列
data[:,2]
# 2-4行
data[2:,:]
# 2-4列
data[:,2:]
# 1 3 4行
data[[1,3,4]]
# 1 3 4列
data[:,[1,3,4]]

花式索引：获取不连续的多个点

a是一个二维数组，在花式索引中，第一个列表 [1, 1, 3] 表示要获取的行索引，第二个列表 [2, 3, 0]表示要获取的列索引。
代码的含义是获取数组 a 中的 (1, 2)，(1, 3) 和 (3, 0) 这三个位置的元素。

a = np.array([[1, 2, 3, 4],[5, 6, 7, 8],[9, 5, 2, 1],[0, 6, 8, 2]
])
t = a[[1, 1, 3], [2, 3, 0]]
print(t)

在这里插入图片描述

数值修改

a = np.array([[1, 2, 3, 4],[5, 6, 7, 8],[9, 5, 2, 1],[0, 6, 8, 2]
])print(a < 5)
# [[ True  True  True  True]
#  [False False False False]
#  [False False  True  True]
#  [ True False False  True]]print(a < 5)
a[a < 5] = 0
print(a)
# [[0 0 0 0]
#  [5 6 7 8]
#  [9 5 0 0]
#  [0 6 8 0]]

where

np.where(condition, x, y)

import numpy as np# 示例1：根据条件选择元素
a = np.array([1, 2, 3, 4, 5])
b = np.where(a > 2, a, 0)
print(b)  # [0 0 3 4 5]# 示例2：根据条件选择元素，同时处理多维数组
c = np.array([[1, 2, 3],[4, 5, 6]])
d = np.where(c > 3, c, -1)
print(d)
# [[-1 -1 -1]
#  [ 4  5  6]]# 示例3：根据条件选择元素，同时处理多个数组
x = np.array([1, 2, 3, 4, 5])
y = np.array([10, 20, 30, 40, 50])
z = np.where(x > 3, x, y)
print(z)  # [10 20 30  4  5]
  • 在示例1中，我们根据条件 a > 2 选择数组 a 中大于2的元素，对应位置上选择 a 中的元素，否则选择0。
  • 在示例2中，我们根据条件 c > 3 选择数组 c 中大于3的元素，对应位置上选择 c 中的元素，否则选择-1。注意，这里的条件和数组 c
    都是多维的。
  • 在示例3中，我们根据条件 x > 3 选择数组 x 中大于3的元素，对应位置上选择 x 中的元素，否则选择 y 中的元素。

数组的拼接

np.concatenate

np.concatenate：可以在指定的轴上连接两个或多个数组
np.concatenate([a, b])会将数组a和b按照第一个轴（默认为0）进行连接

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])res=np.concatenate([a,b])[[1 2][3 4][5 6]]

在这里插入图片描述

a = np.array([[1, 2], [3, 4]])
b = np.array([[5],[6]])res=np.concatenate([a,b],axis=1)
[[1 2 5][3 4 6]]

在这里插入图片描述

np.vstack

可以垂直（沿着行方向）堆叠两个或多个数组

import numpy as npa = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])result = np.vstack([a, b])
print(result)
# 输出
# [[1 2]
# [3 4]
# [5 6]]

np.hstack

可以水平（沿着列方向）堆叠两个或多个数组。例如，np.hstack([a, b])会将数组a和b按照列方向进行堆叠。

import numpy as npa = np.array([[1], [2], [3]])
b = np.array([[4], [5], [6]])result = np.hstack([a, b])
print(result)
# 输出
# [[1 4]
# [2 5]
# [3 6]]

np.dstack

可以深度堆叠两个或多个三维数组。例如，如果有两个形状为 (M,N) 的二维数组 a 和 b，则 np.dstack([a, b]) 会返回一个形状为 (M,N,2) 的三维数组。

import numpy as npa = np.array([[1,2],[3,4]])
b = a * -1result= np.dstack((a,b))
print(result)
# [[[ 1 -1]# [ 2 -2]]# [[ 3 -3]# [ 4 -4]]]

np.column_stack

可以将一维的列向量转换为二维的列，并且能够水平地连接它们在一起。它等效于 hstack 只不过对于 1D 数组工作得更好.

import numpy as nppx= npp.arange(10)
y= npp.arange(10,20)result = npp.column_stack((x,y))
print(result)
# 输出
# [[ 0 10]
# [ 1 11]
# [ 2 12]
# [ 3 13]
# [ 4 14]
# [ 5 15]
#[6 16]
#[7 17] 
#[8         
#[9

np.row_stack

就像 vstack只是它通过追加行来工作而不是列

import numpy as npa = np.array([1,2,3])
b = np.array([4,5,6])result = np.row_stack((a,b))
print(result)
# 输出
# [[1 2 3]
#[4 5 6]]

numpy生成随机数

  • np.random.rand()：生成一个指定形状的数组，数组中的元素是从[0, 1)区间内均匀分布的随机浮点数
import numpy as np# 生成一个形状为 (2, 3) 的随机浮点数数组
random_array = np.random.rand(2, 3)
print(random_array)
  • np.random.randint()：生成一个指定范围内整型数据类型的随机整数或整型数组
import numpy as np# 生成一个范围在 [0, 10) 内大小为 (3,) 的一维整型数组
random_int_array = np.random.randint(0, 10, size=(3,))
print(random_int_array)# 可以通过多个参数控制维度和范围，例如：
random_matrix = np.random.randint(low=1, high=10, size=(2, 4))
print(random_matrix)

  • 对于 size=(3,) 来说：

    • 3 表示数组在第一个维度上有 3 个元素。
    • , 表示这是一个只有一个维度的数组。

    因此，根据给定的 size=(3,) 参数，生成的数组将是一维、包含三个元素（长度为 3）的数组。

  • 对于 size=(3,1) 来说：

    • 第一个数字 3 表示数组在第一个维度上有 3 个元素。
    • 第二个数字 1 表示数组在第二个维度上有 1 个元素。

    因此，根据给定的 size=(3,1) 参数，生成的数组将是一个包含三行、一列的二维数组。

  • np.random.randn()：从标准正态分布（平均值为0，标准差为1）中返回一个样本或样本数组
import numpy as np# 返回一个标准正态分布样本数组
random_array = np.random.randn(3, 4)
print(random_array)
  • np.random.choice()：从给定的一维数组中随机选择元素
import numpy as np# 从 [1, 2, 3, 4, 5] 中随机选择一个数值
random_choice = np.random.choice([1, 2, 3, 4, 5])
print(random_choice) # 1# 可以指定选择多个元素和是否允许重复选择，例如：
random_choices = np.random.choice([1, 2, 3], size=(2,), replace=True)
print(random_choices) # [1 3]
  • np.random.uniform()：从指定范围内均匀分布中返回一个样本或样本数组。
import numpy as np# 返回一个在 [0, 10) 范围内均匀分布的样本数组
random_uniform = np.random.uniform(0, 10, size=(3,))
print(random_uniform)# 可以通过多个参数控制维度和范围，例如：
random_uniform_matrix = np.random.uniform(low=1, high=10, size=(2, 4))
print(random_uniform_matrix)
  • np.random.normal()：从正态（高斯）分布中返回一个或多个样本值
import numpy as np# 返回满足标准正态分布（平均值为0，标准差为1）的样本数组
random_normal = np.random.normal(size=(3,))
print(random_normal)
  • np.random.shuffle()：随机打乱数组的顺序
import numpy as np# 随机打乱一维数组的顺序
arr = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr)
print(arr)[5 2 1 4 3]# 可以通过多个参数控制维度和范围，例如：
matrix = np.array([[1, 2], [3, 4], [5, 6]])
np.random.shuffle(matrix)
print(matrix)
[[3 4][1 2][5 6]]
  • numpy.random.seed() 函数设置种子
import numpy as npnp.random.seed(123)  # 设置种子为 123random_value = np.random.rand()
print(random_value)
输出：
0.6964691855978616

在上述示例中，我们使用 np.random.seed(123) 将种子设置为 123。然后，我们调用 np.random.rand() 生成一个随机浮点数，并将结果打印出来。由于我们设置了相同的种子，在每次运行代码时都会得到相同的结果。

通过设置相同的种子值，可以使得每次运行程序时都产生相同的随机序列。这对于需要可重复性和可验证性的实验或模型训练非常有用。

np.copy和np.view

  • copy() 创建一个独立的副本，对副本进行修改不会影响到原始数组。
  • view()创建一个共享内存块的视图，对视图进行修改可能会影响到原始数组
import numpy as nparr = np.array([1, 2, 3])
arr_copy = arr.copy()arr_copy[0] = 10print(arr)       # 输出: [1 2 3]
print(arr_copy)  # 输出: [10 2 3]
import numpy as nparr = np.array([1, 2, 3])
arr_view = arr.view()arr_view[0] = 10print(arr)      # 输出: [10 2 3]
print(arr_view) # 输出: [10 2 3]

inf和nan

在 NumPy 中，inf（无穷大）和 nan（非数值）是特殊的浮点数常量

inf

inf 表示正无穷大，用于表示超过浮点数范围的值。可以通过使用 numpy.inf 来表示。

示例：
import numpy as npprint(np.inf)  # 输出: infx = np.array([1, 2, np.inf])
print(x)       # 输出: [ 1.  2. inf]

nan

nan 表示非数值（Not a Number），用于表示不可定义或未定义的结果。可以通过使用 numpy.nan 来表示。

示例：
import numpy as npprint(np.nan)  # 输出: nanx = np.array([1, 2, np.nan])
print(x)       # 输出: [ 1.  2. nan]

nan 的传播：在进行计算时，如果任何操作涉及到 nan，结果将会是 nan。

示例：import numpy as npx = np.array([1, 2, np.nan])
y = np.array([3, 4, 5])z = x + y
print(z)  # 输出: [nan nan nan]w = x * y
print(w)  # 输出: [nan nan nan]

比较操作：使用比较运算符（如 <, >, ==）进行比较时，涉及到 nan 的元素会返回布尔值 False。

示例：import numpy as npx = np.array([1, 2, np.nan])print(x < 3)     # 输出: [ True  True False]

计算函数和 nan：许多 NumPy 中的计算函数对于输入包含 nan 的情况都有特殊处理。这些函数通常会忽略或跳过 nan 值，并返回有效的结果。

示例：import numpy as npx = np.array([1, 2, np.nan])print(np.sum(x))       # 输出: nanprint(np.nansum(x))    # 输出: 3.0

检测 nan：可以使用函数如 np.isnan() 来检测数组中的 nan 值。

示例：import numpy as npx = np.array([1, 2, np.nan])print(np.isnan(x))     # 输出: [False False  True]

统计函数

  • np.mean()：计算数组的平均值
  • np.median()：计算数组的中位数
  • np.sum()：计算数组元素的总和
  • np.min()：找到数组中的最小值
  • np.max()：找到数组中的最大值
  • np.var()：计算数组元素的方差
  • np.std()：计算数组元素的标准差
import numpy as nparr = np.array([[1, 2, 3], [4, 5, 6]])mean = np.mean(arr)
print(mean)     # 输出: 3.5median = np.median(arr)
print(median)   # 输出: 3.5sum = np.sum(arr)
print(sum)      # 输出: 21min_val = np.min(arr)
print(min_val)  # 输出: 1max_val = np.max(arr)
print(max_val)  # 输出: 6variance = np.var(arr)
print(variance) # 输出: 2.9166666666666665std_deviation = np.std(arr)
print(std_deviation)   # 输出: 1.707825127659933

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

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

相关文章

PaddleNLP 如何打包成Windows环境可执行的exe？

PaddleNLP 如何打包成Windows环境可执行的exe？

当我们使用paddleNLP完成业务开发后&#xff0c;需要将PaddleNLP打包成在Windows操作系统上可执行的exe程序。操作流程&#xff1a; 1.环境准备&#xff1a; python环境&#xff1a;3.7.4 2.安装Pyinstaller pip install pyinstaller 3.目录结构&#xff0c;main.py为可执…
阅读更多...
测试开发基础 | 计算机网络篇(二)：物理层与数据链路层

测试开发基础 | 计算机网络篇(二)：物理层与数据链路层

【摘要】 计算机网络知识是自动化测试等技术基础&#xff0c;也是测试面试必考题目。霍格沃兹测试学院特别策划了本系列文章&#xff0c;将带大家一步步夯实计算机网络的基础知识。由于物理层知识在互联网软件研发工作中用到的并不多&#xff0c;所以可以仅做一个简单的了解。物…
阅读更多...
jQuery语法知识（DOM操作）

jQuery语法知识（DOM操作）

一、class 属性: .addClass&#xff08;&#xff09;、.hasClass&#xff08;&#xff09;.removeClass&#xff08;&#xff09;、.toggleClass&#xff08;&#xff09; 二、DOM 插入并包裹现有内容 1、.wrap( wrappingElement): 在每个配的元素外层包上一个html元素。 …
阅读更多...
Buildroot显示kernel logo

Buildroot显示kernel logo

buildroot开机时DSI屏幕变成跟uart一样输出log&#xff0c;现在想显示logo 1、failed to show loader logo [ 2.467479] mmcblk1: p1 p2 p3 p4 p5 p6 p7 p8 p9 [ 2.468827] rockchip-drm display-subsystem: cant not find any loader display [ 2.468859] rockc…
阅读更多...
Windows Service 2008 r2的安装

Windows Service 2008 r2的安装

创建虚拟机–&#xff08;操作非常简单&#xff0c;跟着图片的数据下一步即可&#xff09; 选择自己要安装的虚拟机版本 在这里可以更改虚拟机存放的位置 这里的40个G并不会马上占用&#xff0c;当虚拟机里的东西到40个G的大小就不会再存储东西了 选择和自己虚拟…
阅读更多...
春运倒计时，AR 引领铁路运输安全新风向

春运倒计时，AR 引领铁路运输安全新风向

根据中国交通新闻网发布最新消息&#xff0c;今年春运全国跨区域人员流动量预计达 90 亿人次。 随着春运期间旅客数量不断创下新高&#xff0c;铁路运输面临着空前的挑战与压力。 图源&#xff1a;pixabay 聚焦铁路运输效率与旅客安全保障问题&#xff0c;本期行业趋势将探讨 …
阅读更多...
51-16 FusionAD 用于自动驾驶预测与规划任务的多模态融合论文精读

51-16 FusionAD 用于自动驾驶预测与规划任务的多模态融合论文精读

今天要分享的是基于BEV的多模态、多任务、端到端自动驾驶模型FusionAD&#xff0c;其专注于自动驾驶预测和规划任务。这项工作首次发表于2023年8月2日&#xff0c;性能超越了2023 CVPR最佳论文UniAD模型。论文题目是FusionAD: Multi-modality Fusion for Prediction and Planni…
阅读更多...
记录一些随机约束的控制方法

记录一些随机约束的控制方法

文章目录 前言一、内嵌约束控制二、控制rand变量是否随机三、选择随机控制的变量四、控制约束块是否随机五、约束的嵌套控制总结 前言 在运用UVM验证过程中&#xff0c;经常会用到大量的随机&#xff0c;这个时候我们需要控制随机约束的打开或者关闭&#xff0c;来实现不同模式…
阅读更多...
linux显示系统内存使用情况--free命令

linux显示系统内存使用情况--free命令

free 命令是Linux系统中用于显示系统内存使用情况的一个常用工具。通过该命令&#xff0c;用户可以轻松了解系统的内存分配、使用情况以及性能状况。本文将深入介绍free命令的各个方面&#xff0c;并提供详细的示例。 安装与基本用法 通常来说&#xff0c;free命令已经预装在大…
阅读更多...
基于Python实现人脸识别相似度对比

基于Python实现人脸识别相似度对比

目录 引言背景介绍目的和意义 人脸识别的原理人脸图像获取人脸检测与定位人脸特征提取相似度计算 基于Python的人脸相似度对比实现数据集准备人脸图像预处理特征提取相似度计算 引言 背景介绍 人脸识别技术是一种通过计算机对人脸图像进行分析和处理&#xff0c;从而实现自动识…
阅读更多...
2023.1.17 关于 Redis 持久化 AOF 策略详解

2023.1.17 关于 Redis 持久化 AOF 策略详解

目录 引言 AOF 策略 实例演示一 缓冲区 重写机制 手动触发 自动触发 AOF 重写流程 实例演示二 引言 Redis 实现持久化的两大策略 RDB ——> Redis DataBase&#xff08;定期备份&#xff09;AOF ——> Append Only File&#xff08;实时备份&#xff09; 注意&…
阅读更多...
JavaEE：多线程(2)：线程状态，线程安全

JavaEE：多线程(2)：线程状态，线程安全

目录 线程状态 线程安全 线程不安全 加锁 互斥性 可重入 死锁 死锁的解决方法 Java标准库中线程安全类 内存可见性引起的线程安全问题 等待和通知机制 线程饿死 wait notify 线程状态 就绪&#xff1a;线程随时可以去CPU上执行&#xff0c;也包含在CPU上执行的…
阅读更多...
漏洞补丁修复之openssl版本从1.1.1q升级到1.1.1t以及python版本默认2.7.5升级到2.7.18新版本和Nginx版本升级到1.24.0

漏洞补丁修复之openssl版本从1.1.1q升级到1.1.1t以及python版本默认2.7.5升级到2.7.18新版本和Nginx版本升级到1.24.0

​ 一、Openssl升级 1、查看Openssl安装的版本 openssl version 2、查看Openssl路径 which openssl 3、上传openssl安装包到服务器：openssl-1.1.1t.tar.gz，并且解压，安装： mv /usr/local/openssl /usr/local/backup_openssl_1.1.1q_20240120 mkdir /usr/local/openssl tar…
阅读更多...
强化学习：MuJoCo机器人强化学习仿真入门

强化学习：MuJoCo机器人强化学习仿真入门

声明&#xff1a;我们跳过mujoco环境的搭建&#xff0c;搭建环境不难&#xff0c;可自行百度 下面开始进入正题&#xff08;需要有一定的python基础与xml基础&#xff09;&#xff1a; 下面进入到建立机器人模型的部分&#xff1a; 需要先介绍URDF模型文件和导出MJCF格式 介绍完…
阅读更多...
K8S--安装Nginx

K8S--安装Nginx

原文网址&#xff1a;K8S--安装Nginx-CSDN博客 简介 本文介绍K8S安装Nginx的方法。 1.创建Nginx目录及配置文件 mkdir -p /work/devops/k8s/app/nginx/{config,html} 在config目录下创建nginx.conf配置文件&#xff0c;内容如下&#xff1a; # events必须要有 events {wo…
阅读更多...
PALWORLD linux centos7开服教程

PALWORLD linux centos7开服教程

开放端口8211 iptables -A INPUT -p udp -p tcp --dport 8211 -j ACCEPT iptables -A INPUT -p udp -p udp --dport 8211 -j ACCEPT yum -y install glibc.i686 libstdc.i686 screen libcurl.i686 yum install glibc-devel.i686 yum install libstdc-devel.i686 yum -y ins…
阅读更多...
逆序对数量（归并排序做法）

逆序对数量（归并排序做法）

先给出上一篇文章归并排序模板-CSDN博客里的归并排序模板&#xff1a; #include<iostream> using namespace std;const int N 100010;int n; int q[N], temp[N];void merge_sort(int q[], int l, int r) {if(l > r) return;int mid (lr) >> 1;merge_sort(q, …
阅读更多...
爬虫安居客新房

爬虫安居客新房

一、首先看网址 后面有全部代码 https://hf.fang.anjuke.com/loupan/baohequ/p3 这种形式很好分析&#xff0c;https://hf.fang.anjuke.com/loupan/行政区域页码 xinfang_area ["feixixian", "baohequ", "shushanqu", "luyangqu",…
阅读更多...
#GPU|LLM|AIGC#集成显卡与独立显卡|显卡在深度学习中的选择与LLM GPU推荐

#GPU|LLM|AIGC#集成显卡与独立显卡|显卡在深度学习中的选择与LLM GPU推荐

区别 核心区别&#xff1a;显存&#xff0c;也被称作帧缓存。独立显卡拥有独立显存&#xff0c;而集成显卡通常是没有的&#xff0c;需要占用部分主内存来达到缓存的目的 集成显卡&#xff1a; 是集成在主板上的&#xff0c;与主处理器共享系统内存。 一般会在很多轻便薄型的…
阅读更多...
机械臂雅可比矩阵的矢量积理解和matlab实现

机械臂雅可比矩阵的矢量积理解和matlab实现

雅可比矩阵的第Ji列&#xff1a; 关于一些基本概念可以参考博客&#xff0c;部分细节如下&#xff1a; 每个移动关节&#xff0c;Ji可以这样计算&#xff1a; 每个旋转关节&#xff0c;Ji这样计算&#xff1a; 有时候要求按照末端执行器坐标系{n}来执行一些位移旋转之类的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023