机器学习 4种常见目标函数介绍+代码实现

目标函数在机器学习中至关重要，不同的目标函数甚至能影像模型的性能。

目标函数类似于损失函数的总称，然后让目标函数优化取得最大或者最小值这样，总而让网络收敛

更多介绍参考本专栏：pytorch 深度学习初体验_喵星人监护人的博客-CSDN博客

1、 线性函数

线性函数是机器学习、深度学习中最简单的目标函数之一

线性函数是一种最简单的核函数，它假设样本在原始特征空间上是线性可分的，因此在不引入额外的复杂度的情况下，直接在原始特征空间上进行内积计算

实验代码如下：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.svm import SVC

# 生成一个线性不可分的数据集
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_clusters_per_class=1, random_state=42)

# 使用线性核函数的 SVM 分类器
svm_linear = SVC(kernel='linear')
svm_linear.fit(X, y)

# 绘制决策边界
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired, marker='o', edgecolors='k')

# 生成网格数据用于绘制决策边界
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 100), np.linspace(ylim[0], ylim[1], 100))
Z = svm_linear.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

# 绘制决策边界和支持向量
plt.contourf(xx, yy, Z, alpha=0.2, cmap=plt.cm.Paired)
plt.scatter(svm_linear.support_vectors_[:, 0], svm_linear.support_vectors_[:, 1], s=100, facecolors='none', edgecolors='k')
plt.title('Linear SVM Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()

代码使用线性目标函数的 SVM对数据进行二分类、线性分类，然后绘制决策边界

关于线性目标函数的实战代码可以参考：

用反向传播实现线性回归_线性回归反向传播算法-CSDN博客

2、 多项式目标函数

多项式目标函数是支持向量机（SVM）中常用的一种目标函数

通过将样本映射到高维空间来实现非线性分类

与线性目标函数不同，多项式目标函数可以处理线性不可分的情况

实验代码：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.svm import SVC

# 生成一个线性不可分的数据集
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_clusters_per_class=1, random_state=42)

# 使用多项式核函数的 SVM 分类器
svm_poly = SVC(kernel='poly', degree=3)  # 3次多项式核函数
svm_poly.fit(X, y)

# 绘制决策边界
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired, marker='o', edgecolors='k')

# 生成网格数据用于绘制决策边界
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 100), np.linspace(ylim[0], ylim[1], 100))
Z = svm_poly.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

# 绘制决策边界和支持向量
plt.contourf(xx, yy, Z, alpha=0.2, cmap=plt.cm.Paired)
plt.scatter(svm_poly.support_vectors_[:, 0], svm_poly.support_vectors_[:, 1], s=100, facecolors='none', edgecolors='k')
plt.title('Polynomial SVM Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()

 

本代码通过多项式目标函数的SVM进行分类，更多的多项式拟合可以参考：

pytorch 多项式回归-CSDN博客

3、 高斯函数

高斯目标函数，也称为径向基函数（RBF）目标函数，是支持向量机（SVM）中常用的一种目标函数

将样本映射到无限维的特征空间，通过衡量样本之间的相似性来进行非线性分类。

实验代码：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.svm import SVC

# 生成一个线性不可分的数据集
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_clusters_per_class=1, random_state=42)

# 使用高斯核函数的 SVM 分类器
svm_rbf = SVC(kernel='rbf', gamma=0.5)  # gamma 控制高斯核的宽度
svm_rbf.fit(X, y)

# 绘制决策边界
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Paired, marker='o', edgecolors='k')

# 生成网格数据用于绘制决策边界
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 100), np.linspace(ylim[0], ylim[1], 100))
Z = svm_rbf.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

# 绘制决策边界和支持向量
plt.contourf(xx, yy, Z, alpha=0.2, cmap=plt.cm.Paired)
plt.scatter(svm_rbf.support_vectors_[:, 0], svm_rbf.support_vectors_[:, 1], s=100, facecolors='none', edgecolors='k')
plt.title('RBF SVM Decision Boundary')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()

高斯目标函数的 SVM 分类器。将高斯核的宽度参数设定为 0.5，然后绘制出了决策边界和支持向量

 4、 sigmoid 函数

sigmoid 函数是机器学习、深度学习常见的函数，可以将样本映射到非线性空间，处理线性不可分的情况

实验代码：

import torch.nn as nn
import matplotlib.pyplot as plt
import torch
from torch import optim
import numpy as np

torch.manual_seed(1)  # 保证程序随机生成数一样

x1 = torch.rand(200) * 2
x2 = torch.rand(200) * 2
data = zip(x1, x2)
pos = []  # 定义类型 1
neg = []  # 定义类型 2


def classification(data):
    for i in data:
        if (i[1] - i[0] < 0):
            pos.append(i)
        else:
            neg.append(i)


classification(data)
pos_x = [i[0] for i in pos]
pos_y = [i[1] for i in pos]
neg_x = [i[0] for i in neg]
neg_y = [i[1] for i in neg]
plt.scatter(pos_x, pos_y, c='r')
plt.scatter(neg_x, neg_y, c='b')
plt.show()

x_data = [[i[0], i[1]] for i in pos]
x_data.extend([[i[0], i[1]] for i in neg])
x_data = torch.Tensor(x_data)  # 输入数据 feature

y_data = [1 for i in range(len(pos))]
y_data.extend([0 for i in range(len(neg))])
y_data = torch.Tensor(y_data).view(-1, 1)  # 对应的标签


class LogisticRegressionModel(nn.Module):  # 定义网络
    def __init__(self):
        super(LogisticRegressionModel, self).__init__()
        self.linear = nn.Linear(2, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.linear(x)
        x = self.sigmoid(x)
        return x


model = LogisticRegressionModel()
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

for epoch in range(10000):
    y_pred = model(x_data)
    loss = criterion(y_pred, y_data)  # 计算损失值

    if epoch % 1000 == 0:
        print(epoch, loss.item())  # 打印损失值

    optimizer.zero_grad()  # 梯度清零
    loss.backward()  # 反向传播
    optimizer.step()  # 梯度更新

w = model.linear.weight[0]  # 取出训练完成的结果
w0 = w[0]
w1 = w[1]
b = model.linear.bias.item()

with torch.no_grad():  # 绘制决策边界，这里不需要计算梯度
    x = torch.arange(0, 3).view(-1, 1)
    y = (- w0 * x - b) / w1
    plt.plot(x.numpy(), y.numpy())

plt.scatter(pos_x, pos_y, c='r')
plt.scatter(neg_x, neg_y, c='b')
plt.xlim(0, 2)
plt.ylim(0, 2)
plt.show()

代码生成包含两个特征的坐标点，然后通过sigmoid实现逻辑回归。

具体参考：pytorch 实现逻辑回归_pytorch 逻辑回归-CSDN博客

训练过程及结果：