函数与泛函在机器学习中的重要性

    import numpy as np
    
    # 数据生成
    X = np.random.rand(100, 1)
    y = 3 * X + 2 + np.random.randn(100, 1) * 0.5
    
    # 初始化模型参数
    theta = np.zeros(1)
    
    # 学习率
    alpha = 0.01
    
    # 迭代次数
    iterations = 1000
    
    # 梯度下降算法
    for i in range(iterations):
    predictions = theta * X
    errors = predictions - y
    gradient = (1 / X.size) * X.dot(errors)
    theta -= alpha * gradient
    
    # 预测
    X_test = np.array([[0], [1], [2], [3], [4]])
    predictions = theta * X_test
    print("Predictions:", predictions)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import numpy as np
    from sklearn import datasets
    from sklearn.preprocessing import StandardScaler
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 数据加载
    iris = datasets.load_iris()
    X = iris.data
    y = iris.target
    
    # 数据预处理
    scaler = StandardScaler()
    X = scaler.fit_transform(X)
    
    # 训练集和测试集分割
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # 支持向量机实现
    def svm(X_train, y_train, X_test, kernel='linear'):
    C = 1.0
    epsilon = 0.01
    max_iter = 1000
    
    # 线性核
    if kernel == 'linear':
        K = np.outer(X_train, X_train)
    
    # 高斯核
    else:
        K = np.exp(-np.linalg.norm(X_train, axis=1) ** 2 / (2 * epsilon))
    
    # 泛函优化
    alpha = np.zeros(len(y_train))
    alpha_star = np.zeros(len(y_train))
    while np.sum(alpha) < C and np.sum(alpha) > C:
        for i in range(len(y_train)):
            if alpha[i] < C:
                alpha[i] += 1
        for i in range(len(y_train)):
            if alpha[i] > C:
                alpha[i] -= 1
    
        # 更新alpha
        alpha_star = alpha.copy()
        for i in range(max_iter):
            for j in range(len(y_train)):
                if y_train[j] != y_train[i]:
                    alpha[j] += 1
                else:
                    alpha[j] -= 1
    
    # 计算分类器参数
    w = np.zeros(X_train.shape[1])
    b = 0
    for i in range(len(y_train)):
        if alpha_star[i] > 0:
            w += y_train[i] * X_train[i]
    for i in range(len(y_train)):
        if alpha_star[i] > 0:
            b += y_train[i]
    
    # 预测
    y_pred = np.zeros(len(y_test))
    for i in range(len(y_test)):
        score = 0
        for j in range(len(y_train)):
            if alpha_star[j] > 0:
                score += y_train[j] * K[i][j]
        if kernel == 'linear':
            score += b
        if score > 0:
            y_pred[i] = 1
        else:
            y_pred[i] = 0
    
    # 评估
    accuracy = accuracy_score(y_test, y_pred)
    print("Accuracy:", accuracy)
    
    # 调用支持向量机实现
    svm(X_train, y_train, X_test, kernel='linear')
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import numpy as np
    import tensorflow as tf
    from sklearn.datasets import make_classification
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 数据生成
    X, y = make_classification(n_samples=1000, n_features=20, n_informative=2, n_redundant=10, random_state=42)
    
    # 数据分割
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # 神经网络实现
    def neural_network(X_train, y_train, X_test, layers, activation='relu', learning_rate=0.01, epochs=100):
    # 参数初始化
    weights = np.random.randn(layers[0], layers[1])
    biases = np.zeros((layers[0], 1))
    
    # 训练
    for epoch in range(epochs):
        # 前向传播
        z = np.dot(X_train, weights) + biases
        a = np.vectorize(activation)(z)
    
        # 后向传播
        d_a = 2 * (y_train - a)
        d_z = d_a.dot(weights.T)
        d_weights = X_train.T.dot(d_a)
        d_biases = np.sum(d_a, axis=0, keepdims=True)
    
        # 更新参数
        weights -= learning_rate * d_weights
        biases -= learning_rate * d_biases
    
    # 预测
    weights = np.random.randn(layers[-1], layers[-2])
    biases = np.zeros((layers[-1], 1))
    a = np.vectorize(activation)(np.dot(X_test, weights) + biases)
    predictions = np.vectorize(activation)(np.dot(a, weights) + biases)
    
    # 评估
    accuracy = accuracy_score(y_test, predictions)
    print("Accuracy:", accuracy)
    
    # 调用神经网络实现
    neural_network(X_train, y_train, X_test, layers=[10, 10, 1], activation='relu', learning_rate=0.01, epochs=100)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读