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

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

引用

CSDN

1.

https://blog.csdn.net/qq_44886601/article/details/140891151

目标函数在机器学习中扮演着至关重要的角色，它直接影响模型的性能和学习效果。本文将介绍四种常见的目标函数：线性函数、多项式函数、高斯函数和sigmoid函数，并通过具体的代码实现帮助读者理解它们在实际应用中的效果。

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 对数据进行二分类、线性分类，并绘制了决策边界。

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 进行分类，展示了多项式核函数在处理非线性可分数据时的效果。

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 实现逻辑回归。训练过程及结果如下：