逻辑回归原理参考链接：线性分类|机器学习推导系列（四）
一、逻辑回归从零开始实现
1. 导入所需要的库
import numpy as np import matplotlib.pyplot as plt
2. 人工构造数据集
构造一个比较简单的二分类数据集，满足高斯分布，并进行了数据的可视化。
def create_data(size): X0=np.random.normal(2,1,(size,2)) y0=np.zeros(size) X1=np.random.normal(-2,1,(size,2)) y1=np.ones(size) X=np.concatenate((X0,X1),axis=0) y=np.concatenate((y0,y1),axis=0) return X,y X,y=create_data(1000) X_test,y_test=create_data(100) # 可视化数据 plt.scatter(X[:,0],X[:,1],c=y,s=40,lw=0, cmap='RdYlGn') plt.show() # 添加偏置 X=np.insert(X,0,1,axis=1) y=y.reshape(y.shape[0],-1) X_test=np.insert(X_test,0,1,axis=1) y_test=y_test.reshape(y_test.shape[0],-1)
3. 初始化模型参数
n_samples,n_features=np.shape(X) limit=np.sqrt(n_features) w=np.random.uniform(-limit,limit,(n_features,1)) # 学习参数 lr=.1 # 学习率 iters=1001 # 迭代次数
4. 定义sigmoid函数
def sigmoid(x): return 1/(1+np.exp(-x))
5. 定义优化算法
def gradient_descent(X,y,w,lr): y_pred=sigmoid(X@w) gradient=-((y-y_pred)*X).sum(axis=0) gradient=gradient.reshape(gradient.shape[0],-1) w=w-lr*gradient return w
6. 定义损失函数
def loss(X,y,w): y_pred=sigmoid(X@w) delta=1e-7 left_log=np.log(y_pred+delta) right_log=np.log(1-y_pred+delta) l=-(y*left_log+(1-y)*right_log).sum() return l
7. 训练模型
定义测试函数。
def test(X_test,y_test): y_test_pred=sigmoid(X_test@w) y_test_pred[y_test_pred>=0.5]=1.0 y_test_pred[y_test_pred<0.5]=0.0 correct_list=[] for i,pred in enumerate(y_test_pred): is_correct = 1 if pred==y_test[i] else 0 correct_list.append(is_correct) acc = sum(correct_list) / len(y_test) return acc
定义训练过程，并且进行记录。
iter_num=[] acc_num=[] loss_num=[] for i in range(iters): w=gradient_descent(X,y,w,lr) if i%50 == 0: iter_num.append(i) acc_num.append(test(X_test,y_test)) loss_num.append(loss(X,y,w))
8. 结果可视化
plt.subplot(221) plt.plot(iter_num,acc_num,color='r',label='acc') plt.xlabel('epochs') plt.ylabel('acc') plt.title("acc") plt.legend() plt.show() plt.subplot(222) plt.plot(iter_num,loss_num,color='r',label='loss') plt.xlabel('epochs') plt.ylabel('loss') plt.title("loss") plt.legend() plt.show()
二、使用torch.nn实现逻辑回归
1. 导入所需要的库
import torch import torch.nn as nn import numpy as np import matplotlib.pyplot as plt
2. 人工构造数据集
使用与之前同样的数据。
def create_data(size): n_data=torch.ones(size,2) X0=torch.normal(2*n_data,1) y0=torch.zeros(size) X1=torch.normal(-2*n_data,1) y1=torch.ones(size) X=torch.cat((X0,X1),0).type(torch.FloatTensor) y=torch.cat((y0,y1),0).type(torch.FloatTensor) return X,y X,y=create_data(1000) X_test,y_test=create_data(100) plt.scatter(X.data.numpy()[:,0],X.data.numpy()[:,1],c=y.data.numpy(),s=40,lw=0,cmap='RdYlGn') plt.show()
3. 定义模型
逻辑回归相当于一个两层神经网络，输出层只有一个节点，并且激活函数为sigmoid函数。
class LogisticRegression(nn.Module): def __init__(self): super(LogisticRegression,self).__init__() self.lr = nn.Linear(2,1) self.sigmoid = nn.Sigmoid() def forward(self,X): X=self.lr(X) X=self.sigmoid(X) return X model = LogisticRegression()
4. 定义损失函数和优化器
criterion=nn.BCELoss() optimizer=torch.optim.Adam(model.parameters(),lr=1e-3)
5. 训练模型
iter_num=[] acc_num=[] loss_num=[] for epoch in range(3): logit=model(X) loss=criterion(logit,y) y_pred=logit.ge(0.5).float() correct=(y_pred==y).sum() acc=correct.item()/X.size(0) optimizer.zero_grad() loss.backward() optimizer.step() if (epoch+1)%1==0: iter_num.append(epoch) acc_num.append(acc) loss_num.append(loss.data.item()) print('epoch:{}'.format(epoch+1),',','loss:{:.4f}'.format(loss.data.item()),',','acc:{:.4f}'.format(acc))
6. 结果可视化
plt.subplot(221) plt.plot(iter_num,acc_num,color='r',label='acc') plt.xlabel('epochs') plt.ylabel('acc') plt.title("acc") plt.legend() plt.show() plt.subplot(222) plt.plot(iter_num,loss_num,color='r',label='loss') plt.xlabel('epochs') plt.ylabel('loss') plt.title("loss") plt.legend() plt.show()
