机器学习基础算法及其实现

线性回归

知识点：
1. 线性回归模型可以使用不同的目标函数，最常用的是最小二乘法、最小绝对值法和最大似然法。
2. 在最小二乘法中，目标是最小化实际值与预测值之间的误差平方和，这可以通过求导数等方法来求解。
3. 在最小绝对值法中，目标是最小化实际值与预测值之间的误差绝对值和，这可以使用线性规划等方法来求解。
4. 在最大似然法中，目标是估计模型参数，使得在给定自变量的条件下，因变量的概率最大化。
5. 线性回归模型的参数估计可以使用基于梯度下降的算法，如批量梯度下降、随机梯度下降、小批量梯度下降等。
6. 在应用线性回归模型时，需要注意多重共线性、异方差性、自相关等问题，并采取相应的处理措施。
7. 除了传统的线性回归模型，还有多项式回归、岭回归、lasso回归、弹性网络回归等变种模型。

逻辑回归

import numpy as np

class LogisticRegression:
    def __init__(self, learning_rate=0.01, num_iterations=10):
        self.learning_rate = learning_rate
        self.num_iterations = num_iterations
        self.weights = None
        self.bias = None
    
    def fit(self, X, y):
        num_samples, num_features = X.shape
        print(num_samples,num_features)
        self.weights = np.zeros(num_features)
        print(X)
        print(self.weights)
        self.bias = 0
        
        # 梯度下降算法
        for i in range(self.num_iterations):
            linear_model = np.dot(X, self.weights) + self.bias
            print(linear_model)
            y_pred = self._sigmoid(linear_model)
            print("sigmoid")
            print(y_pred)
            print("end")
            # 计算损失函数的梯度
            dw = (1 / num_samples) * np.dot(X.T, (y_pred - y))
            db = (1 / num_samples) * np.sum(y_pred - y)
            
            # 更新权重和偏移量
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db
    
    def predict(self, X):
        print("pre")
        print(X)
        linear_model = np.dot(X, self.weights) + self.bias
        y_pred = self._sigmoid(linear_model)
        y_pred_class = [1 if i > 0.5 else 0 for i in y_pred]
        return np.array(y_pred_class)
    
    def _sigmoid(self, x):
        return 1 / (1 + np.exp(-x))


# 创建训练数据
X_train = np.array([[1,2,3],
                    [2,3,4],
                    [3,4,5],
                    [4,5,6], 
                    [5,6,7]])
y_train = np.array([0, 0, 1, 1, 1])

# 创建逻辑回归模型
lr_model = LogisticRegression()

# 训练模型
lr_model.fit(X_train, y_train)

# 预测新数据
X_new = np.array([[2,4,6], [3,5,7]])
y_pred = lr_model.predict(X_new)

print(y_pred)

SVM

基于sklearn库实现SVM：

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# 加载数据集
iris = datasets.load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=42)
# 创建 SVM 模型对象
svm_model = SVC(kernel='linear', C=1)

# 训练 SVM 模型
svm_model.fit(X_train, y_train)

# 预测测试集数据
y_pred = svm_model.predict(X_test)

# 计算准确率
acc = accuracy_score(y_test, y_pred)
print('Accuracy:', acc)

具体代码实现：（复习后再过来研究）

import numpy as np

# 定义 SVM 模型类
class SVM:
    def __init__(self, C=1.0, kernel='linear', gamma=1.0):
        self.C = C               # 惩罚系数
        self.kernel = kernel     # 核函数类型
        self.gamma = gamma       # 核函数参数
        self.alpha = None        # 拉格朗日乘子
        self.b = 0               # 阈值
        self.X = None            # 训练数据
        self.y = None            # 训练标签
        
    # 核函数
    def _kernel_function(self, x1, x2):
        if self.kernel == 'linear':
            return np.dot(x1, x2)
        elif self.kernel == 'rbf':
            return np.exp(-self.gamma * np.linalg.norm(x1 - x2) ** 2)
        else:
            raise ValueError('Unsupported kernel function type')

    # 训练模型
    def fit(self, X, y):
        n_samples, n_features = X.shape          # 5 3 
        self.alpha = np.zeros(n_samples)
        self.X = X
        self.y = y

        # 计算 Gram 矩阵
        K = np.zeros((n_samples, n_samples))     # 5 5
        for i in range(n_samples):
            for j in range(n_samples):
                K[i, j] = self._kernel_function(X[i], X[j]) # np.dot

        # 定义优化目标函数
        def objective_function(alpha):
            return 0.5 * np.dot(alpha, np.dot(alpha, K)) - np.sum(alpha)

        # 定义约束条件
        def zero_sum_constraint(alpha):
            return np.dot(alpha, y)

        # 定义不等式约束条件
        bounds = [(0, self.C) for i in range(n_samples)]
        cons = [{'type': 'eq', 'fun': zero_sum_constraint}]
        
        # 使用优化算法求解拉格朗日乘子
        from scipy.optimize import minimize
        res = minimize(objective_function, self.alpha, bounds=bounds, constraints=cons)
        self.alpha = res.x

        # 计算阈值
        support_vectors = self.alpha > 1e-5
        support_vectors_idx = np.where(support_vectors)[0]
        self.b = np.mean(y[support_vectors] - np.dot(K[support_vectors_idx, :], self.alpha * y))

    # 预测新数据
    def predict(self, X):
        n_samples = X.shape[0]
        y_pred = np.zeros(n_samples)

        for i in range(n_samples):
            s = 0
            for alpha, x, y in zip(self.alpha, self.X, self.y):
                s += alpha * y * self._kernel_function(X[i], x)
            y_pred[i] = s + self.b

        return np.sign(y_pred)
    
# 创建训练数据
X_train = np.array([[1,2,3],
                    [2,3,4],
                    [3,4,5],
                    [4,5,6], 
                    [5,6,7]])
y_train = np.array([0, 0, 1, 1, 1])

# 创建逻辑回归模型
model = SVM()

# 训练模型
model.fit(X_train, y_train)

# 预测新数据
X_new = np.array([[2,4,6], [3,5,7]])
y_pred = model.predict(X_new)

print(y_pred)