pytorch简单编程

1：用TensorFlow或PyTorch实现两个tensor的矩阵A和B的乘法，其中A为二维，B为N维（n >= 3）
2D张量要和3D张量的后两个维度满足矩阵相乘条件。
点乘——torch.mul(a, b)
python中的广播机制(broadcasting)
broadcasting可以这样理解：如果你有一个(m,n)的矩阵，让它加减乘除一个(1,n)的矩阵，它会被复制m次，成为一个(m,n)的矩阵，然后再逐元素地进行加减乘除操作。同样地对(m,1)的矩阵成立。
矩阵乘
矩阵相乘有torch.mm(a, b)和torch.matmul(a, b)两个函数。
前一个是针对二维矩阵，后一个是高维。
对于维数相同的张量
A.shape =（b,m,n)；B.shape = (b,n,k)
numpy.matmul(A,B) 结果shape为(b,m,k)
要求第一维度相同，后两个维度能满足矩阵相乘条件。
比如 A.shape =（m,n)； B.shape = (b,n,k)； C.shape=(k,l)
numpy.matmul(A,B) 结果shape为(b,m,k)
numpy.matmul(B,C) 结果shape为(b,n,l)
2D张量要和3D张量的后两个维度满足矩阵相乘条件。
2：用Pytorth，实现一个2层的感知机二分类器。需要实现基本功能，包括：定义输入、网络结构、batch的loss、acc、预测结果的label，预测结果的概率分布等。

//生成数据
import matplotlib.pyplot as plt
from sklearn.cluster import SpectralClustering
import sklearn.datasets

X,y = sklearn.datasets.make_moons(200,noise=0.2)
plt.scatter(X[:,0],X[:,1],s=40,c=y,cmap=plt.cm.Spectral)

//接下来将样本数据从 numpy 转成 tensor：
X = torch.from_numpy(X).type(torch.FloatTensor)
y = torch.from_numpy(y).type(torch.LongTensor)
//开始构建神经网络，其中损失函数用交叉熵损失函数，梯度优化器用Adam。 
import torch.nn as nn
import torch.nn.functional as F
 
class MyClassifier(nn.Module):
    def __init__(self):
        super(MyClassifier,self).__init__()
        self.fc1 = nn.Linear(2,3)
        self.fc2 = nn.Linear(3,2)
        
    def forward(self,x):
        x = self.fc1(x)
        x = F.tanh(x)
        x = self.fc2(x)
        return x
             
    def predict(self,x):
        pred = F.softmax(self.forward(x))
        ans = []
        for t in pred:
            if t[0]>t[1]:
                ans.append(0)
            else:
                ans.append(1)
        return torch.tensor(ans)
model = Net()
criterion = nn.CrossEntropyLoss()  #交叉熵损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=0.01) #Adam梯度优化器
    //训练
    epochs = 10000
losses = []
for i in range(epochs):
    y_pred = model.forward(X)
    loss = criterion(y_pred,y)
    losses.append(loss.item())
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
//测试
from sklearn.metrics import accuracy_score
print(accuracy_score(model.predict(X),y))
# Output
0.995