2024年1月7日学习总结

今日计划学习内容

• 论文部分写一部分introduction
• 对代码进行改进争取更加规范

今日学习内容

1、argparse——命令行选项、参数、子命令解释器

argparse 模块对命令行接口的支持是围绕argparse.ArgumentParser 的实例建立的。

举个栗子：

import argparse

# 创建一个解析器对象
parser = argparse.ArgumentParser(description='A simple example of argparse usage')

# 添加参数
parser.add_argument('--input_file', type=str, required=True, help='Path to the input file')
parser.add_argument('--output_file', type=str, required=True, help='Path to the output file')
parser.add_argument('--num_epochs', type=int, default=10, help='Number of epochs to train the model')
parser.add_argument('--learning_rate', type=float, default=0.01, help='Learning rate for the optimizer')

# 解析参数
args = parser.parse_args()

# 使用参数
print(args.input_file)
print(args.output_file)
print(args.num_epochs)
print(args.learning_rate)

说明：我们首先创建了一个argparse.ArgumentParser对象，并添加了三个参数：input_file、output_file和num_epochs。然后，我们调用parse_args()函数来解析命令行参数，并将解析结果存储在args对象中。最后，我们可以使用args对象访问解析结果

2、Python中的元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

• 元组中只包含一个元素时，需要在元素后面添加逗号
• 元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

（1）访问元组

使用下标

#!/usr/bin/python
 
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print "tup1[0]: ", tup1[0] # tup1[0]:  physics
print "tup2[1:5]: ", tup2[1:5] # tup2[1:5]:  (2, 3, 4, 5)

（2）修改元组

元组中的元素是不能修改的
但是可以对两个元组进行连接

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3 # (12, 34.56, 'abc', 'xyz')

（3）删除元组

元组中的元素值是不能删除的
但是可以删除整个元组

tup = ('physics', 'chemistry', 1997, 2000)
del tup

（4）元组的运算

• len(元组)：计算元组中元素的个数
• 元组+元组：把元组连接起来
• 元组*4：把元组复制4次
• 元素 in 元组：判断元素是否存在
• for 元素 in 元组：迭代元组中的元素

（5）元组索引和截取

L = (‘spam’, ‘Spam’, ‘SPAM!’)

• L[2]： ‘SPAM!’ 读取第三个元素
• L[-2]： ‘Spam’ 反向读取，读取倒数第二个元素
• L[1:]： (‘Spam’, ‘SPAM!’) 截取第二个元素到最后一个元素

（6）元组内置函数

• cmp(tuple1, tuple2)：比较两个元组元素
• len(tuple)：计算元组元素个数。
• max(tuple)：返回元组中元素最大值。
• min(tuple)：返回元组中元素最小值。
• tuple(seq)：将列表转换为元组。
  参考：https://www.runoob.com/python/python-tuples.html

3、Python中的字典

字典是可变容器模型，且可存储任意类型对象。
字典的每个键值 key:value 对用冒号分割，每个键值对之间用逗号分割，整个字典包括在花括号 {} 中

d = {key1 : value1, key2 : value2 }

• 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

（1）创建字典

• 直接赋值

dic = {'name': 'Jack', 'age': 18, 'height': 180}
print(dic)
# 输出结果：{'name': 'Jack', 'age': 18, 'height': 180}

• dict和参数创建

dic = dict(name='Jack', age=18, height=180)
print(dic)
# 输出结果：{'name': 'Jack', 'age': 18, 'height': 180}

• dict和二元组的列表创建

lis = [('name', 'Jack'), ('age', 18), ('height', 180)]
dic = dict(lis)
print(dic)
# 输出结果：{'name': 'Jack', 'age': 18, 'height': 180}

• dict和zip创建

dic = dict(zip('abc', [1, 2, 3]))
print(dic)
# 输出结果：{'a': 1, 'b': 2, 'c': 3}

• 字典推导式创建

dic = {i: i ** 2 for i in range(1, 5)}
print(dic)
# 输出结果：{1: 1, 2: 4, 3: 9, 4: 16}

（2）访问字典

通过key访问value

#!/usr/bin/python
 
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
print "tinydict['Name']: ", tinydict['Name'] # tinydict['Name']:  Zara
print "tinydict['Age']: ", tinydict['Age'] # tinydict['Age']:  7

（3）删除字典

分为三种：删除字典里面的某一个key的value、删除字典的所有key-value对、删除字典

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典

（4）字典key的特性

字典value可以是任意的类型，但是key有具体的要求

• 同一个key不能出现两次，如果出现了两次，之后后一个的value会被记住
• key必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

（5）字典内置函数

• cmp(dict1, dict2)：比较两个字典元素。
• len(dict)：计算字典元素个数，即键的总数。
• str(dict)：输出字典可打印的字符串表示。
• type(variable)：返回输入的变量类型，如果变量是字典就返回字典类型。
• dict.clear()：删除字典内所有元素
• dict.copy()：返回一个字典的浅复制
• dict.fromkeys(seq[, val])：创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

dic = dict.fromkeys(range(4), 'x')
print(dic)
# 输出结果：{0: 'x', 1: 'x', 2: 'x', 3: 'x'}

• dict.get(key, default=None)：返回指定key的value，如果值不在字典中返回default值
• dict.has_key(key)：如果键在字典dict里返回true，否则返回false。Python3 不支持。
• dict.items()：以列表返回可遍历的(键, 值) 元组数组
• dict.keys()：以列表返回一个字典所有的键
• dict.setdefault(key, default=None)：和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
• dict.update(dict2)：把字典dict2的键/值对更新到dict里
• dict.values()：以列表返回字典中的所有值
• pop(key[,default])：删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
• popitem()：返回并删除字典中的最后一对键和值。

4、使用pytorch创建MLP模型

之前用keras创建模型：

model_mlp = Sequential()
model_mlp.add(Dense(100, activation='relu', input_dim=X_train.shape[1]))
model_mlp.add(Dense(1))
model_mlp.compile(loss='mse', optimizer=adam)
model_mlp.summary()

现在看看如何使用pytorch创建模型：

class MLP(nn.Module):
  '''
    Multilayer Perceptron.
  '''
  def __init__(self):
    super().__init__()
    self.layers = nn.Sequential(
      nn.Flatten(),
      # input shape = 28*28
      # neurons in first dense layer = 64
      nn.Linear(28*28, 64),
      # relu activation
      nn.ReLU(),
      # 64 = neurons in first dense layer
      # 32 = neurons in second dense layer
      nn.Linear(64, 32),
      nn.ReLU(),
      # 32 = neurons in second dense layer
      # 10 = neurons in output layer (number of classes)
      nn.Linear(32, 10)
    )
  def forward(self, x):
    '''Forward pass'''
    return self.layers(x)

pytorch创建神经网络模型（MLP）需要继承nn.Module类，有两个组成部分：init/构造函数、forward

• init：定义模型中的参数，权重、偏置等
• forward：定义模型接收输入时，数据要怎么传递、经过哪些激活函数等

其中在init里面通过nn.Sequential创建一个“存储仓”模型，一个接一个的往里填入layers，存储在变量self.layers中

拆解一下这个模型的神经网络层

• 输入：数据维度是(3,28,28)
• nn.Flatten：输入为一批数据，第一维为batch，通常要把一个数据拉成一维，而不是将一批数据拉为一维。默认从第二维开始平坦化。
  (3,28,28)??(3,784)
• nn.Linear：线性变换 nn.Linear(in_features=28*28, out_features=64)
  (3,784)??(3,64)
• nn.Relu：非线性激活函数
  (3,64)??(3,64)
• nn.Linear：线性变换 nn.Linear(in_features=64, out_features=32)
  (3,64)??(3,32)
• nn.Relu：非线性激活函数
  (3,32)??(3,32)
• nn.Linear：线性变换 nn.Linear(in_features=32, out_features=10)
  (3,32)??(3,10)

查看模型

1、查看模型结构

print(f"Model structure: {model}\n\n")

2、查看模型每个参数model.named_parameters

for name, param in model.named_parameters():
    print(f"Layer: {name} | Size: {param.size()} | Values : {param[:2]} \n")

5、流量预测中的类：TimeSeriesDataSet

功能：时间序列预测的时候对数据进行预处理的“好帮手”
功能包括：

• 变量缩放和编码：对于不同的变量，可以通过指定缩放方法和编码方法来将其归一化，并减少变量之间的差异性，从而提高模型的效果。
• 目标变量归一化：对于时间序列中的目标变量，可以对其进行归一化，以便更好地适应模型。
  数据转换：该类提供了一些方法，可以将时间序列数据从 pandas 数据框中转换为 PyTorch 张量，以便更好地适应 PyTorch 模型。
• 变量信息的保存：该类可以保存关于未来已知和未知的静态和时变变量的信息，以便更好地处理多个时间步长的时间序列数据。
• 相关类别信息的保存：该类可以保存与时间序列数据相关的类别信息，例如假日信息等，以便更好地处理具有类别信息的时间序列数据。
• 数据增强：该类提供了下采样的功能，可以对时间序列数据进行降采样，以便更好地处理长时间序列数据。
• 数据集生成：该类可以自动生成训练、验证和测试数据集，以便更好地进行模型评估和测试。

class pytorch_forecasting.data.timeseries.TimeSeriesDataSet(
data: DataFrame, 
time_idx: str, 
target: str | List[str], 
group_ids: List[str],
weight: str | None = None, 
max_encoder_length: int = 30, 
min_encoder_length: int | None = None, 
min_prediction_idx: int | None = None, 
min_prediction_length: int | None = None, 
max_prediction_length: int = 1, 
static_categoricals: List[str] = [], 
static_reals: List[str] = [],
time_varying_known_categoricals: List[str] = [], 
time_varying_known_reals: List[str] = [], 
time_varying_unknown_categoricals: List[str] = [], 
time_varying_unknown_reals: List[str] = [], 
variable_groups: Dict[str, List[int]] = {}, 
constant_fill_strategy: Dict[str, str | float | int | bool] = {}, 
allow_missing_timesteps: bool = False,
lags: Dict[str, List[int]] = {}, 
add_relative_time_idx: bool = False, 
add_target_scales: bool = False, 
add_encoder_length: bool | str = 'auto', 
target_normalizer: TorchNormalizer | NaNLabelEncoder | EncoderNormalizer | str | List[TorchNormalizer | NaNLabelEncoder | EncoderNormalizer] | Tuple[TorchNormalizer | NaNLabelEncoder | EncoderNormalizer] = 'auto', categorical_encoders: Dict[str, NaNLabelEncoder] = {}, 
scalers: Dict[str, StandardScaler | RobustScaler | TorchNormalizer | EncoderNormalizer] = {}, randomize_length: None | Tuple[float, float] | bool = False, predict_mode: bool = False)

参数：

• data：包含时间序列的DataFrame或numpy数组
• time_idx: str。表示时间的列名。该列用于确定样本的时间序列。
• target: Union[str, List[str]]。目标列或目标列的列表，可以是分类变量或连续变量。
• group_ids: List[str]。表示时间序列的列名的列表。这意味着 group_ids 与 time_idx 一起确定样本。如果只有一个时间序列，则将其设置为恒定的列名即可。
• weight: Union[str, None]。权重的列名。默认为 None。