深度学习常用函数

一。流程
1.数据处理（数据读取：批量选择问题）
2.模型参数初始化
3.模型定义（net选取）
4.损失函数定义（采取什么损失函数形式，即y_hat和y的处理数学形式）
5.优化算法定义（sgd这种优化算法，和loss损失函数不一样）
6.模型训练

以上只有1,2,6需要自己写，其余的直接可以调用pytorch函数

二。常用函数
torch.index_select(torch,dim,input)
torch.randn
np.random.normal(loc,scale,size)
torch.Tensor/tensor
random.shuffle(list)
list[i:i+batch_size]
torch.mm(X,w)
torch.view()
param.data-=param.grad/batch_size 不会影响反向传播
backward()
torch.zeros/ones()
torch.requires_grad_(requires_grad=True)  候补票设置梯度求导
import torch.utils.data as Data
dataset = Data.TensorDataset(features, labels)   将特征和标签组合到一起
data_iter = Data.DataLoader(dataset, batch_size, shuffle=True)  随机读取小批量，传入数据集，批量大小，乱序取值
torch.nn
self.linear=nn.Linear(num_inputs,num_outs)   网络层设置，只定义这个网络层的形状
self.linear(features)       这里传入了网络层的输入特征
net1=nn.Sequential(         第二种网络层定义方式
    nn.Linear(num_inputs,num_outs)
    ...
)

init.normal_(net.linear.weight,mean=0,std=0.01) 正太初始化权重
init.constant_(net.linear.bias,val=0)   设置偏置初始值

loss=nn.MSELoss()
optim.SGD(net.parameters(),lr=0.01) 设置统一学习率
optim.SGD([
    {'params':net.subnet1.parameters()},
    {'params':net.subnet2.parameters(),'lr':0.0.1}      单独设置网络层学习率，微调使用
],lr=0.03)

for param_group in optimizer.param_groups:
    param_group['lr']+=0.01  学习率动态增加0.0.1


torchvision.datasets:加载数据的函数以及常用的数据集接口
torchvision.models:包含常用的模型结构（韩语训练模型），例如AlexNet、VGG、ResNet
torchvision.transforms:常用的图片变换，例如剪裁、旋转等
torchvision.utils:其他的一些常用的方法

transfor=transforms.ToTensor()将所有数据转换为Tensor，如果不进行转换则回PIL图片
    transform.ToTensor()将尺寸为（HxWxC）且数据位于0-255的范围内的PIL图片或者数据类型为np.uint8的NumPy数组
    转换为（CxHxW）格式且数据类型为torch.float32且位于【0.0,1.0】的tensor

_,figs=plt.subplots(1,len(images),figsize=(12,12))  #画图 # 设置一行 len（images）个数量，每个figsize大小的画布
for fig,img,lbl in zip(figs,images,labels):   zip将里面的打包成块一起便利

torch.gather(dim,input):用于从批量tensor中选取出指定索引下的数据，该索引是高度自定义化的，可乱序的
dim:0行索引，1列索引
input：行向量索引序列

eg:
   import torch
   tensor_0=torch.arrange(3,12).view(3,3)
   index=torch.tensor([[2,1,0]])
   tensor_1=tensor_0.gather(0,input)  按行索引  第一行的第三个，第二行的第2个，第三行的第一个
   tensor_1=([9,7,5])

   tensor_0=[[3,4,5],
             [6,7,8],
             [9,10,11]]

   输入input形状=输出tensor_1形状                      输入input值：[2,1,0]
                                当形状为行向量时：
   1.根据输入，tensor_0设置预先得到输出部分值（（0，0），（0，1），（0，2））

   2.1.dim=0则根据输入补全输出中缺失的行位置元素（（2,0），（1,1），（0,2））  = （9,7,5）

   2.2.dim=1则根据输入补全输出中缺失的列位置元素 （（0,2），（0,1），（0,0））  =（5,4,3）
                                当形状为列向量时：
   1.根据输入，tensor_0预先得到输出部分值（（0,0），（1,0），（2,0））.t()

   2.1.dim=0则根据输入补全输出中缺失的行位置元素（（2,0），（1,0），（0,0））.t()   =（9,6,3）.t()

   2.2.dim=1补全列素位置  （（0，2），（1,1），（2,0）） =（5,7,9）.t()

x_vals.detach().numpy() 将张量x分离出梯度计算，（其具体用处还不清楚）

torch.relu(linear)
torch.matmul(H,w2)+b2  matmul()是tensor的乘法，当输入都是二维的时候，就是普通的矩阵乘法，同torch.mm()用法一样

    eg：
        1.二维矩阵相乘
            a:3x4   b:4x2
            torch.matmul(a,b):  3x2
        2.多出一维      当输入有多维的时候，多出来的一维作为batch提出来，其他部分作矩阵乘法
            a:5x3x4   b:4x2
            torch.matmul(a,b):  5x3x2
        3.都是3维
            a: 2x5x3    b:1x3x4
            torch.matmul(a,b):  2x5x4

torch.log()  是以自然数e为底的对数函数

torch.cat((tensor1,tensor2,tensor3.....),dim=?):在给定维度上对输入的张量序列进行连接操作，返回Tensor
                                                要求inputs 的shape是一样的，dim<=任一tensor维度
    x1:2x3
    x2:2x3
    inputs=[x1,x2]
    torch.cat(inputs,dim=0).shape: 4x3
                     dim=1       : 2x6
                     dim=2       : dimension out of range

Tensor切片操作：
    features=tensor([[-9.3947e-01,  8.8260e-01, -8.2917e-01],
                    [-6.5963e-01,  4.3511e-01, -2.8701e-01],
                    [ 2.0171e+00,  4.0688e+00,  8.2073e+00],
                    [-1.3276e+00,  1.7625e+00, -2.3398e+00],
                    [-1.5200e+00,  2.3105e+00, -3.5120e+00],
                    [-1.2756e+00,  1.6271e+00, -2.0756e+00],
                    [ 1.8365e-01,  3.3728e-02,  6.1942e-03],
                    [ 9.4120e-02,  8.8586e-03,  8.3377e-04],
                    [-1.2142e+00,  1.4743e+00, -1.7901e+00],
                    [-1.5848e+00,  2.5116e+00, -3.9804e+00]])
    features[:,2]  :是获取所有行但仅限于第三列数据

    features[:2]   :是获取前两行所有列数据

    features[:,:2] :是获取所有行前三列之外所有列的数据

    !!!!当取行的时候，原来的维度能够得到保留
        当取列的时候，原来的维度会消失，取到的值会成为一个一维张量，除非使用[]对列进行限制，比如features[:,[1]],
        这样取得的值就是第二列所有的值，且保留有原来的维度


tensor.shape[-1]  返回的是张量最后一个纬度的大小，eg:tensor.size()=(3,5),则tensor.shape[-1]=5
                   相应的 .shape[0] 返回的是张量第一个维度 此处返回3

pytorch中矢量计算时，相乘时最好是同形状tensor X tensor，相加可以是单元素scalar/tensor+tensor  因为有广播机制

一个张量/矩阵的平方，如W**2,是W中的元素的平方，而不是WxW  并且(W**2).sum()是W中所有平方元素的和

assert  用于检查程序，不符合条件就终止程序
a=3
assert a>4 报错
assert a<4 运行成功


pandas 相关库

data=pd.read_csv("文件路径")  data是一个DataFrame的数据结构对象

import pandas as pd

# 读取CSV文件并创建DataFrame
data = pd.read_csv("xxx.csv")

head(): 用于查看 DataFrame 的前几行数据，默认显示前5行。
tail(): 用于查看 DataFrame 的末尾几行数据，默认显示后5行。
info(): 用于显示 DataFrame 的基本信息，包括列名、非空值数量、数据类型等。
describe(): 生成描述性统计信息，如均值、标准差、最小值、最大值等。
shape: 返回一个元组，表示 DataFrame 的行数和列数。 shape[0]、shape[1]
columns: 返回 DataFrame 的列名。
index: 返回 DataFrame 的行索引。
values: 用于获取Numpy格式数据
    1. 将df转化为列表： list=df.values
    2. 获取某一列的数据： df['列名'].values、df.列名.values

pd.get_dummies(all_features, dummy_na=True) ：
    完成离散特征的指示转换,dummy_na=True代表缺失值也会进行合法指示特征创建

df.astype({col: 'int' for col in df.columns if df[col].dtype == 'bool'}):
    这段代码会将bool类型的列中的二分类元素有bool转化为int类型：0、1


loc[]: 通过标签名称选择行和列的数据。
    选择第1到4行的前4列和最后3列
    data.loc[0:3, ['column1', 'column2', 'column3', 'column4', 'column-3', 'column-2', 'column-1']]

iloc[]: 通过整数位置选择行和列的数据。
    选择第1到4行的前4列和最后3列
    data.iloc[0:4, [0, 1, 2, 3, -3, -2, -1]]

drop(): 用于删除指定行或列。
    # 使用 inplace=True 来在原地修改 DataFrame   删除名为 'column_to_drop' 的列
    data.drop(columns=['column_to_drop'], inplace=True)

set_index(): 将一个或多个列设置为新的索引。
    将 'new_index_column' 列设置为新的索引
    data.set_index('new_index_column', inplace=True)

reset_index(): 重新设置索引，将当前索引列变为普通的列。
    data.reset_index(inplace=True)

groupby(): 用于进行分组操作，通常与聚合函数一起使用。
    grouped = data.groupby('grouping_column')

sort_values(): 根据指定列的值对 DataFrame 进行排序。
    data.sort_values(by='sort_column', ascending=False, inplace=True)

filter(): 根据条件过滤数据。
    筛选 'column' 列中大于 100 的行
    filtered_data = data[data['column'] > 100]

pivot(): 用于数据透视，将数据从长格式转换为宽格式。
    需要指定行、列和值的列
    pivoted_data = data.pivot(index='row_column', columns='column_column', values='value_column')

merge(): 用于合并不同的 DataFrame。
    根据共同的列进行合并
    merged_data = pd.merge(left_df, right_df, on='common_column')

fillna(): 用于填充缺失值。
    使用均值填充缺失值
    data.fillna(data.mean(), inplace=True)

drop_duplicates(): 删除重复的行。
    data.drop_duplicates(inplace=True)

apply(): 对每列或每行应用自定义函数。

    def custom_function(column):
    # 你的自定义操作
    return result

    data['new_column'] = data['existing_column'].apply(custom_function)

dropna():
    data.dropna(axis=0, inplace=True)  # 删除包含缺失值的行
    data.dropna(axis=1, inplace=True)  # 删除包含缺失值的列

isnull(): 用于检查DataFrame中的缺失值，并返回一个布尔值的DataFrame，指示每个单元格是否为缺失值。
    is_null = data.isnull()

notnull(): 与 isnull() 相反，用于检查非缺失值的情况。
    not_null = data.notnull()

value_counts(): 用于统计一列中各个唯一值的出现次数。
    value_counts = data['column_name'].value_counts()

concat():将两个或多个 Pandas DataFrame 沿特定轴（行或列）进行连接
    沿行轴（axis=0）合并DataFrame，将它们垂直堆叠
    axis 控制连接的轴（0 表示行，1 表示列）
    result = pd.concat([df1, df2], axis=0)

apply():可以直接对 Series 或者 DataFrame 中元素进行逐元素遍历操作，方便且高效，
     使用时，通常放入一个 lambda 函数表达式、或一个函数作为操作运算

lambda表达式：
    df.apply(lambda x: x-1)      lambda x是固定函数格式，后面的x-1才是函数方法，表示df中所有元素减一


均值可以通过一组数据中所有数据和除以数据个数获得。
标准差通过数据中每个数据与均值的差的平方和除以数据个数在进行开根号即可获得，
标准差反映了一个数据集的离散程度，值越大越离散，即个体之间的差异越大

标准误差：用于描述样本标准差与总体标准差的近似程度，值越小，样本越能代表总体数据
  一般标准误差通常由样本的标准差除以样本容量的开根号来估算

标准化/正则化：用一个样本数据减去均值再除以标准差即可获得

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    数据处理先从dataframe转化为numpy，再转化成Tensor格式
    其中使用转化数据的顺序为：
    1. df.values  获取numpy格式数据
    2. torch.tensor(df.values,dtype=torch.float)


loss 损失函数计算方式：
    1. MSELoss():
        均方误差，是预测值与真实值之差的平方和的平均值
    2.

torch.sqrt()
torch.log()
torch.maximum(a,b)


!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
nn.Linear(feature_num,1):

    nn.Linear(feature_num, 1)层被设计为从feature_num个特征映射到1个输出。
    因此，对于输入X的每一个样本，net都会输出一个对应的预测值。
    net(X)
    如果X的大小是[n, feature_num]，其中n是样本的数量，feature_num是每个样本的特征数量，
    那么net(X)的输出将是一个形状为[n, 1]的张量，表示n个样本的预测值。每个样本都有一个对应的预测值

//: 向下取整运算符
    当num1/num2 =2.9时，向下取整就是说num1//num2 的取值为2，即便是2.99999，仍然是2

slice(start,stop,step): 切片
    a = ("a", "b", "c", "d", "e", "f", "g", "h")
    x = slice(0, 8, 3)
    a[x]

原函数：
    train(net, train_features, train_labels, test_features, test_labels, num_epochs,
          learning_rate, weight_decay, batch_size):
调用函数：
    train(net, *data, num_epochs, learning_rate, weight_decay, batch_size):
    这里传输中参数前的*代表data有多个值传入，对应于原train函数中的几个参数，之后的就依次按照原参数顺序进行传输

isinstance(args[0],OrderedDict)  :判断第一个参数的类型是不是第二个参数表明的类型

enumerate(X): 包装X生成一个迭代器，返回索引id和内容
eg：
    X='success'
    for idx,docu in enumerate(X):
        print(idx,docu,'\n')
    ···
    ···
        0 s
        1 u
        2 c
        3 c
        4 e
        5 s
        5 s

str(docu): 将docu内容转化成字符串类型

torch.norm(input,p,dim,keepdim): 对tensor张量进行dim维的p范式计算

nn.ReLU()和nn.functional.relu()的区别：
    nn.ReLU()是层级结构，必须要用在nn.Module()容器中  即按已学知识，理解为只能用在__init__()函数中
    nn.functional.relu() 则是函数调用，可以应用在别处。    而这个则可以用在forward函数或者其他函数中

    但是nn.functional.relu() 一般是没有状态参数的，具体是指：
        可学习的参数，如卷积层的权重和偏置，或根据需要自定义的一些可学习参数。
        直接用F.X，则其中涉及的参数一般是超参，无法利用反向传播进行学习。
    综上，使用nn.ReLU()就好目前

torch.nn.parameter.Parameter(data=None, requires_grad=True):
    data (Tensor) – parameter tensor. —— 输入得是一个tensor
    Parameters是Tensor的子类,当与 Modules一起使用时具有一个非常特殊的属性
    当它们被分配为Module attributes时,它们会自动添加到其参数列表中，并将出现例如在parameters()迭代器中

    torch.nn.Parameter()将一个不可训练的tensor转换成可以训练的类型parameter，
    并将这个parameter绑定到这个module里面。即在定义网络时这个tensor就是一个可以训练的参数了。
    使用这个函数的目的也是想让某些变量在学习的过程中不断的修改其值以达到最优化。

Tensor可以根据data来访问参数数值，根据grad来访问参数梯度
    tensor.data
    tensor.grad

init.constant_(param, val=0) : 这里是使用常数来初始化参数
init.normal_(param,mean=0,std=0.01)：这里是使用正态分布随机数来初始化

inplace方法： 就是会改变调用者值的方法，一般最后以下划线结尾

    如a,b=torch.randn(2,3),torch.randn(2,3)
    a.add(b)，a本身值是不会变的，但是如果是a.add_(b) 则a的值就会变成a+b

tensor.uniform_(-10,20): 从-10到20的均匀分布中抽样数值进行填充

tensor的基础运算：
    tensor.abs() / torch.abs(tensor)   : 绝对值运算
    sqrt()                             : 平方根
    div()                              ： 除法
    exp()                              ： 指数
    fmod()                             ： 求余
    pow()                              ： 求幂