2024年1月7日学习总结

目录

  • 今日计划学习内容
  • 今日学习内容
    • 1、argparse——命令行选项、参数、子命令解释器
    • 2、Python中的元组
      • (1)访问元组
      • (2)修改元组
      • (3)删除元组
      • (4)元组的运算
      • (5)元组索引和截取
      • (6)元组内置函数
    • 3、Python中的字典
      • (1)创建字典
      • (2)访问字典
      • (3)删除字典
      • (4)字典key的特性
      • (5)字典内置函数
    • 4、使用pytorch创建MLP模型
      • 之前用keras创建模型:
      • 现在看看如何使用pytorch创建模型:
      • 拆解一下这个模型的神经网络层
      • 查看模型
        • 1、查看模型结构
        • 2、查看模型每个参数model.named_parameters
    • 5、流量预测中的类:**TimeSeriesDataSet**

今日计划学习内容

  • 论文部分写一部分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。

你可能感兴趣的:(每日学习总结,学习,人工智能,深度学习)