基础项目架构的知识点整理

Posted on Edited on In

0. 目录

1. 项目参数的处理

  • 一般程序会将项目运行的参数统一放到config文件中，但同样也可以利用argparse模块，设置参数在命令行运行程序时添加

1.1 config文件

1.1.1 作用

  • 将项目中的各种设置，参数和常量集中在一起配置
  • 便于不同环境间切换配置
  • 一般都是以字典的形式呈现

1.2 argparse 模块

  • argument parser（参数解析器）

1.2.1 基本结构示例

1
2
3
4
5
6
7
import argparse

parser = argparse.ArgumentParser(description="example")
parser.add_argument('--name', type=str, help='username')
args = parser.parse_args()

print(f"hello，{args.name}")

1.2.2 基本流程

  1. 创建解析器对象：ArgumentParser()
  2. 添加参数：add_argument(...)
  3. 解析参数：parse_args()
  4. 使用参数：通过 args.参数名 获取

1.2.3 add_argument 常用参数详解

参数名 含义
name 参数名称，如 –name
type 参数类型，如 int, str
help 参数说明文档
required 是否为必须参数（默认 False）
default 默认值

2. 数据集和调用

2.1 数据集

  • 一般的数据集由数据加载器来调用

2.1.1 数据加载器作用

  • 将数据加载，预处理和模型训练逻辑分离出来
  • 确保数据流程的一致性
  • 数据预处理，标签处理，维度处理

2.2 数据处理常用函数

函数/方法 所属库 基本功能
linspace NumPy 创建等间隔数值序列
ones NumPy 创建全1数组
zeros NumPy 创建全0数组
unique NumPy 提取数组中的唯一值
enumerate Python内置 在循环中同时获取索引和值
reshape NumPy 改变数组维度而保持元素不变
shape NumPy 获取数组的维度大小
append NumPy 在数组末尾添加元素
randint NumPy 生成随机整数或随机整数数组

2.2.1 linspace

  • 全称是 “linear space”（线性间隔）

  • 作用：在一个指定的范围内，生成指定数量的等间隔数值。

  • 标准格式：

    1
    2
    3
    4
    5
    6
    7
    8
    np.linspace(
    start,      # 起始值
    stop,       # 结束值
    num=50,     # 生成的等间隔样本数量
    endpoint=True,  # 是否包含结束值
    retstep=False,  # 是否返回样本间距
    dtype=None      # 输出数组的数据类型
    )

  • 例子：

    1
    2
    t = np.linspace(0, 4, 5, dtype=int)
    # 结果是 [0 1 2 3 4]

2.2.2 ones

  • 语法：np.ones(shape, dtype=float, order='C')
  • 作用：创建一个所有元素都为 1 的数组。
  • 示例:
    np.ones(5)
    array([1., 1., 1., 1., 1.])
  • zeros函数同理

2.2.3 unique

  • 语法： np.unique(ar, return_index=False, return_inverse=False, return_counts=False)

    参数 说明
    ar 输入数组（可以是一维或多维，会被展平成一维处理）
    return_index 如果为 True，返回原数组中唯一值的首次出现索引
    return_inverse 如果为 True，返回可用于重构原数组的索引数组
    return_counts 如果为 True，返回每个唯一元素出现的次数

  • 作用：

  • 示例：

    1
    2
    a = np.array([3, 1, 2, 3, 2, 1, 4])
    np.unique(a)

    结果：

    1
    array([1, 2, 3, 4])

2.2.4 enumerate

  • 循环的传统方式

    1
    2
    3
    for i in range(len(X)):
        x = X[i]
        print(f"View {i+1} shape: {X[i].shape}")

  • 使用enumerate

    1
    2
    for i, x in enumerate(X):
        print(f"View {i+1} shape: {x.shape}")
    • X是一个包含多个视图数据的列表
    • i索引值，整数类型，自动获取当前迭代的索引值(从0开始)
    • x元素值，任何数据类型，获取列表中对应位置的元素(视图数据)，x 本质上等同于 X[i]

  • 使用enumerate时，可以只有索引，也可以只有值，缺失的用_来代替，两个不一定要用得到，但两个要素再enumerate方法中都要有

2.2.5 reshape

  • 定义：reshape是NumPy数组的一个方法，用于改变数组的维度形状而不改变其数据内容

  • 作用：用来重塑数据的维度

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    import numpy as np

    # 一维转二维
    x = np.array([1, 2, 3, 4, 5, 6])
    x_2d = x.reshape(2, 3)
    # 结果: array([[1, 2, 3], [4, 5, 6]])

    # 使用-1自动计算维度
    y = np.array([[1, 2], [3, 4], [5, 6]])
    y_flat = y.reshape(-1)  # 展平为一维
    # 结果: array([1, 2, 3, 4, 5, 6])

    # 添加维度
    z = np.array([1, 2, 3])
    z_new = z.reshape(3, 1)  # 变为列向量
    # 结果: array([[1], [2], [3]])

2.2.6 shape

  • 定义：shape 是NumPy数组的一个属性，用于获取数组的维度信息

  • 返回值：返回一个元组，表示数组在每个维度上的大小

  • 基本用法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import numpy as np
    # 一维数组
    arr1 = np.array([1, 2, 3, 4])
    print(arr1.shape)  # 输出: (4,)

    # 二维数组
    arr2 = np.array([[1, 2, 3], [4, 5, 6]])
    print(arr2.shape)  # 输出: (2, 3)

    # 三维数组
    arr3 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
    print(arr3.shape)  # 输出: (2, 2, 2)

2.2.7 append

  • 定义：append 是 NumPy 的一个函数，用于将值添加到数组的末尾

  • 语法：np.append(arr, values, axis=None)

  • 参数：

    参数名 说明
    arr 要添加值的输入数组
    values 要添加的值（可以是数组）
    axis 沿着添加值的轴，默认为None（数组会先被展平）

  • 返回值：返回添加了值的新数组副本，不会修改原数组

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    import numpy as np

    # 一维数组添加值
    a = np.array([1, 2, 3])
    b = np.append(a, 4)
    print(b)  # 输出: [1 2 3 4]

    # 添加多个值
    c = np.append(a, [4, 5, 6])
    print(c)  # 输出: [1 2 3 4 5 6]

    # 沿特定轴添加（二维数组）
    arr = np.array([[1, 2, 3], [4, 5, 6]])

    # 沿行添加(axis=0)
    row_append = np.append(arr, [[7, 8, 9]], axis=0)
    print(row_append)
    # 输出:
    # [[1 2 3]
    #  [4 5 6]
    #  [7 8 9]]

    # 沿列添加(axis=1)
    col_append = np.append(arr, [[10], [11]], axis=1)
    print(col_append)
    # 输出:
    # [[ 1  2  3 10]
    #  [ 4  5  6 11]]

  • 注意，即使用append函数处理list数据结构，并不会将list转换为array数据类型，只有显式转换才会有效，如下:

    1
    2
    my_list = [1, 2, 3]
    my_array = np.array(my_list)  # 列表→NumPy数组

2.2.8 randint

  • 定义：randint 是 NumPy 的一个函数，用于生成随机整数。

  • 语法：np.random.randint(low, high=None, size=None, dtype=int)

  • 参数：

    参数名 说明
    low 随机整数的下界（包含）。
    high 随机整数的上界（不包含）。如果未指定，则生成范围为 [0, low)。
    size 输出随机数的形状（可以是整数或元组）。
    dtype 输出数组的数据类型，默认是 int。

  • 返回值：返回一个随机整数或随机整数数组。

  • 示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import numpy as np

    # 生成一个随机整数，范围是 [0, 10)
    random_int = np.random.randint(0, 10)
    print(random_int)  # 输出示例: 7

    # 生成一个随机整数数组，范围是 [1, 5)，形状为 (3, 2)
    random_array = np.random.randint(1, 5, size=(3, 2))
    print(random_array)
    # 输出示例:
    # [[4 2]
    #  [1 3]
    #  [2 4]]

    # 生成一个一维随机整数数组，范围是 [0, 100)，长度为 5
    random_1d_array = np.random.randint(0, 100, size=5)
    print(random_1d_array)  # 输出示例: [23 45 67 12 89]

  • 注意事项：

    • 如果只提供 low 参数，则生成的随机整数范围是 [0, low)。
    • 如果指定了 high 参数，则生成的随机整数范围是 [low, high)。
    • size 参数可以用来指定输出的形状，支持多维数组。
    • 随机的数组会产生重复!!而不是所有的选出的数据是不重复的

2.3 数据维度的处理

2.3.1 数据维度的表示

  • 在python中，三维数组和一维数组但元素是二维数组是两种完全不一样的东西

  • 特征 三维数组 a 一维对象数组 b
    类型 np.ndarray np.ndarray（元素是 ndarray）
    shape (2, 3, 4) (2,)
    是否结构化 是 否
    内存连续性 是 否
    支持的操作 广播、切片等 只能逐个处理元素