标量（scalar）与向量

标量，仅包含⼀个数值，只有⼀个元素的张量表⽰。可将向量视为标量值组成的列表。这些标量值称为向量的元素（elements）或分量（components）

x = torch.arange(4)  #tensor([0, 1, 2, 3])
若⽂献认为列向量是向量的默认⽅向，则描述为4X1矩阵，x[3] == tensor(3)

当一个向量由n各实体值标量组成时，可以用 len(x) 函数来计算长度；
当用张量表示一个向量(只有一个轴)时，需要用.shape属性来访问向量的长度，返回各轴的长度(维度)

哈达玛积与矩阵乘法

两个矩阵的按元素乘法称为 哈达玛积（Hadamard product）（数学符号 ⊙）

#两个张量A和B只是进行A*B运算即是哈达玛积
#矩阵运算，则需要调用torch.matmul()函数
a = torch.Tensor([[1,2],[3,4]])
b = torch.Tensor([[5,6],[7,8]])

hadamard = a *b
print("hadamard product:",hadamard)  #hadamard product: tensor([[ 5., 12.], [21., 32.]])

matrix_mul = torch.matmul(a,b)
print("matrix mul product :",matrix_mul)  #matrix mul product : tensor([[19., 22.],[43., 50.]])

矩阵向量求和：
a = torch.arange(4,dtype=torch.float32)
b = torch.tensor([[1,2,3],[4,5,6]])
print("x.sum() = ",a.sum())  #x.sum() =  tensor(6.)
print("y.sum()=",b.sum())    #y.sum()= tensor(21)

#通过设置axis 来指定张量沿哪⼀个轴来通过求和降低维度。[压成了一位向量]
bx_sum_axis0 = b.sum(axis=0) #沿x轴求和
by_sum_axis1 = b.sum(axis=1) #沿y轴求和
print("bx_sum_axis0 = ", bx_sum_axis0)  #bx_sum_axis0 =  tensor([5, 7, 9]) 一维
print("by_sum_axis1 = ", by_sum_axis1)  #by_sum_axis1 =  tensor([ 6, 15]) 一维

# Same as `b.sum()` 向两个轴求和
bxy_sum_axis01 = b.sum(axis=[0,1])
print("bxy_sum_axis01 = ",bxy_sum_axis01) #bxy_sum_axis01 =  tensor(21)

平均值（mean或average）,可来计算任意形状张量的平均值,要求值为浮点。
b = torch.tensor([[1.0,2,3],[4.0,5,6]])
print("b.mean() = ",b.mean())
print("b.sum()/b.numel() = ", b.sum()/b.numel()) #b.sum()/b.numel() =  tensor(3.5000)

均值的函数也可通过axis指定张量沿指定轴求均值
print("b.mean(axis = 0 ) = ", b.mean(axis = 0))  #b.mean(axis = 0 ) =  tensor([2.5000, 3.5000, 4.5000])
print("b.sum(axis=0)/b.shape[0] = ", b.sum(axis=0)/b.shape[0])  #b.mean(axis = 0 ) =  tensor([2.5000, 3.5000, 4.5000])

#计算总和或均值时保持轴数不变
b = torch.tensor([[1.0, 2, 3], [4.0, 5, 6]])
sum_keepdims_x = b.sum(axis=0,keepdims=True)
sum_keepdims_y = b.sum(axis=1, keepdims=True)
print('b.sum(axis=0,keepdims=True) = ',sum_keepdims_x) #b.sum(axis=0,keepdims=True) =  tensor([[5., 7., 9.]]) #沿行压，列不变
print('b.sum(axis=1,keepdims=True) = ', sum_keepdims_y) #b.sum(axis=1,keepdims=True) =  tensor([[ 6.], [15.]]) #沿列压，行不变
print("b / sum_keepdims_y = ", b/sum_keepdims_y) # b / sum_keepdims_y =  tensor([[0.1667, 0.3333, 0.5000], [0.2667, 0.3333, 0.4000]]) 2X3 矩阵除于2X1矩阵

print("b.cumsum(axis=0) = ",b.cumsum(axis=0)) # 沿X轴计算累计和 b.cumsum(axis=0) =  tensor([[1., 2., 3.], [5., 7., 9.]])
print("b.cumsum(axis=1) = ", b.cumsum(axis=1)) #沿y轴计算累计和 b.cumsum(axis=1) =  tensor([[ 1.,  3.,  6.],[ 4.,  9., 15.]])

点积：相同位置的按元素乘积的和，只针对一维。
a = torch.ones(4, dtype=torch.float32)
b = torch.Tensor([1,2,3, 4])

hadamard = a * b
dotmul = torch.dot(a,b)              # 1*1+1*2+1*3+1*4
print("hadamard product:", hadamard)      #hadamard product: tensor([1., 2., 3., 4.])
print("sum(a*b) = ", torch.sum(hadamard))      #sum(a*b) =  tensor(10.)

print("dotmul = ", dotmul)              #dotmul =  tensor(10.) 点积

matrix_mul = torch.matmul(a, b.T)         #矩阵乘法
print("matrix mul product :", matrix_mul)      #matrix mul product : tensor(10.)

给定⼀组由向量x∈Rd 表⽰的值，和⼀组由向量∑w∈R 表⽰的权重。x中的值根据权重 w 的加权和可以表⽰为点积 xTw。当权重为⾮负数且和为1时，点积表⽰加权平均（weighted average）。将两个向量归⼀化得到单位⻓度后，点积表⽰它们夹⻆的余弦。

torch.mul()   矩阵的点乘，即对应的位相乘，要求shape一样, 返回的还是个矩阵
torch.dot()   类似于mul()，它是向量(即只能是一维的张量)的对应位相乘再求和，返回一个tensor数值

torch.mv()  矩阵和向量相乘，类似于torch.mm()
torch.mm()   矩阵相乘

A = torch.Tensor([[1,2,3],[4,5,6],[7,8,9]])
x = torch.Tensor([1,1,1])
y = torch.Tensor([[1, 1], [2, 2],[3,3]])
z = torch.Tensor([2,2,2])
B = torch.Tensor([[1,1,1],[2,2,2],[3,3,3]])

print("torch.mv(A,x) = ", torch.mv(A,x)) #第一个参数是矩阵，第二个参数只能是一维向量 torch.mv(A,x) =  tensor([ 6., 15., 24.])
print("torch.mm(A,y) = ", torch.mm(A, y)) #两个都是矩阵  torch.mm(A,y) =  tensor([[14., 14.],[32., 32.],[50., 50.]])

print("torch.dot(x, z) = ", torch.dot(x, z)) #向量(即只能是一维的张量)的对应位相乘再求和  torch.dot(x, z) =  tensor(6.)
print("torch.mul(A, B) = ", torch.mul(A, B)) #矩阵的点乘，即对应的位相乘  torch.mul(A, B) =  tensor([[ 1.,  2.,  3.],[ 8., 10., 12.],[21., 24., 27.]])

 监督机器学习问题就是在规则化参数的同时最小化误差。 最小化误差是为了让模型拟合训练数据，而规则化参数是防止模型过分拟合训练数据。
 由于参数过多，会导致模型复杂度上升，容易过拟合，也就是训练误差会很小。
 但目标并不是训练误差小，而是模型的测试误差小，即可准确的预测新的样本。
 故需要保证模型“简单”的基础上最小化训练误差，这样得到的参数才具有好的泛化性能（也就是测试误差也小），而模型“简单”就是通过规则函数来实现的。
 
其中规则项用于约束模型的特性，目的是将对这个模型的先验知识融入到模型的学习当中，强行地让学习到的模型具有想要的特性，例如稀疏、低秩、平滑等等。
规则化符合奥卡姆剃刀(Occam's razor)原理：在所有可能选择的模型中，我们应该选择能够很好地解释已知数据并且十分简单的模型。从贝叶斯估计的角度看，规则化项对应于模型的先验概率。规则化也是结构风险最小化策略的实现，是在经验风险上加一个正则化项(regularizer)或惩罚项(penalty term)。

Loss函数：（不同的loss函数，具有不同的拟合特性）
a) Square loss，是最小二乘；
b) Hinge Loss，是SVM；
c) exp-Loss，是Boosting；
d) log-Loss，是Logistic Regression

规则化函数Ω(w)也有很多种选择，一般是模型复杂度的单调递增函数，模型越复杂，规则化值就越大。
比如，规则化项可以是模型参数向量的范数。然而，不同的选择对参数w的约束不同，取得的效果也不同。

机器学习中的范数规则化之（一）L0、L1与L2范数_zouxy09的专栏-CSDN博客_l0范数

机器学习中的范数规则化之（二）核范数与规则项参数选择_zouxy09的专栏-CSDN博客_核范数