2D函数优化、逻辑回归

def hime1blau(x):
    return (x[0] ** 2 + x[1]-11) ** 2 + (x[0] + x[1] ** 2 - 7) ** 2
import numpy as np
x = np.arange(-6,6,0.1)#相隔0.1
y = np.arange(-6,6,0.1)
x,y
x.shape,y.shape
X,Y=np.meshgrid(x,y)#延伸
X.shape,Y.shape
Z=hime1blau([X,Y])#函数

Z=hime1blau([X,Y])#函数
import matplotlib.pyplot as plt #导入绘图
fig = plt.figure('hime1blau')
ax = fig.gca(projection = '3d')
ax.plot_surface(X,Y,Z)
ax.view_init(60,-30)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.show()

import torch
x = torch.tensor([0.,0.],requires_grad=True)
x
optimizer = torch.optim.Adam([x],lr = 1e-3)
optimizer
#随机梯度
for step in range(20000):
    pred = hime1blau(x)#预测
    optimizer.zero_grad()#优化
    pred.backward()
    #x'=x-lr*delta
    #y'=y-lr*delta
    optimizer.step()
    if step %2000 == 0:
        print(f"step{step}:x={x.tolist()}f(x)={pred.item()}")

x = torch.tensor([-6,0.],requires_grad=True)
#设置优化器（待优化变量，lr=学习率）
optimizer = torch.optim.Adam([x],lr = 1e-3)
for step in range(20000):
    pred = hime1blau(x)#预测
    optimizer.zero_grad()#优化
    pred.backward()
    #x'=x-lr*delta
    #y'=y-lr*delta
    optimizer.step()
    if step %2000 == 0:
        print(f"step{step}:x={x.tolist()}f(x)={pred.item()}")
        

逻辑回归

logistic回归介绍
logistic回归是一种广义线性回归（generalized linear model），与多重线性回归分析有很多相同之处。它们的模型形式基本上相同，都具有 wx + b，其中w和b是待求参数，其区别在于他们的因变量不同，多重线性回归直接将wx+b作为因变量，即y =wx+b,而logistic回归则通过函数L将wx+b对应一个隐状态p，p =L(wx+b),然后根据p 与1-p的大小决定因变量的值。如果L是logistic函数，就是logistic回归，如果L是多项式函数就是多项式回归。
说的更通俗一点，就是logistic回归会在线性回归后再加一层logistic函数的调用。
logistic回归主要是进行二分类预测，我们在激活函数时候讲到过 Sigmod函数，Sigmod函数是最常见的logistic函数，因为Sigmod函数的输出的是是对于0~1之间的概率值，当概率大于0.5预测为1，小于0.5预测为0。
下面我们就来使用公开的数据来进行介绍
UCI German Credit 数据集
UCI German Credit是UCI的德国信用数据集，里面有原数据和数值化后的数据。
German Credit数据是根据个人的银行贷款信息和申请客户贷款逾期发生情况来预测贷款违约倾向的数据集，数据集包含24个维度的，1000条数据，

代码

先导入数据

data=np.loadtxt("german.data-numeric")

归一化处理

n,l=data.shape
for j in range(l-1):
    meanVal=np.mean(data[:,j])
    stdVal=np.std(data[:,j])
    data[:,j]=(data[:,j]-meanVal)/stdVal

将数据打乱

np.random.shuffle(data)

划分数据集和测试集

train_data=data[:900,:l-1]
train_lab=data[:900,l-1]-1
test_data=data[900:,:l-1]
test_lab=data[900:,l-1]-1

定义模型

class LR(nn.Module):
    def __init__(self):
        super(LR,self).__init__()
        self.fc=nn.Linear(24,2) # 由于24个维度已经固定了，所以这里写24
    def forward(self,x):
        out=self.fc(x)
        out=torch.sigmoid(out)
        return out

测试集的准确率

def test(pred,lab):
    t=pred.max(-1)[1]==lab
    return torch.mean(t.float())

设置损失函数和优化以及训练次数

net=LR() 
criterion=nn.CrossEntropyLoss() # 使用CrossEntropyLoss损失
optm=torch.optim.Adam(net.parameters()) # Adam优化
epochs=1000 # 训练1000次

训练，要注意数组的类型以及维度

for i in range(epochs):
    # 指定模型为训练模式，计算梯度
    net.train()
    # 输入值都需要转化成torch的Tensor
    x=torch.from_numpy(train_data).float()
    y=torch.from_numpy(train_lab).long()
    y_hat=net(x)
    loss=criterion(y_hat,y) # 计算损失
    optm.zero_grad() # 前一步的损失清零
    loss.backward() # 反向传播
    optm.step() # 优化
    if (i+1)%100 ==0 : # 这里我们每100次输出相关的信息
        # 指定模型为计算模式
        net.eval()
        test_in=torch.from_numpy(test_data).float()
        test_l=torch.from_numpy(test_lab).long()
        test_out=net(test_in)
        # 使用我们的测试函数计算准确率
        accu=test(test_out,test_l)
        print("Epoch:{},Loss:{:.4f},Accuracy：{:.2f}".format(i+1,loss.item(),accu))

结果: