### 使用Python实现逻辑回归算法 #### 数据准备与预处理 为了构建逻辑回归模型，首先需要加载并预处理数据。这里假设已经有一个二分类的数据集。 ```python import numpy as np import pandas as pd def load_data(file_path): """Load dataset from CSV file.""" data = pd.read_csv(file_path) X = data.iloc[:, :-1].values # Features y = data.iloc[:, -1].values # Labels return X, y ``` 接着对特征进行标准化处理，以便更好地收敛： ```python from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_scaled = scaler.fit_transform(X) ``` #### 定义Sigmoid函数 逻辑回归的核心在于sigmoid函数，它能够将实数值映射到0和1之间，表示概率[^2]。 ```python def sigmoid(z): """ Compute the sigmoid of z. Parameters: z -- A scalar or numpy array of any size. Returns: s -- Sigmoid(z) """ s = 1 / (1 + np.exp(-z)) return s ``` #### 初始化参数 初始化权重`w`和偏置项`b`为零向量/标量。 ```python def initialize_with_zeros(dim): w = np.zeros((dim, 1)) b = 0 assert(w.shape == (dim, 1)) assert(isinstance(b, float) or isinstance(b, int)) return w, b ``` #### 计算成本及其梯度 定义计算损失的成本函数以及相应的梯度下降更新规则。采用的是负对数似然作为成本函数[^4]。 ```python def propagate(w, b, X, Y): m = X.shape[1] # FORWARD PROPAGATION (FROM X TO COST) A = sigmoid(np.dot(w.T, X) + b) # compute activation cost = (-1/m)*np.sum(Y*np.log(A)+(1-Y)*(np.log(1-A))) # compute cost # BACKWARD PROPAGATION (TO FIND GRADIENT) dw = (1/m)*np.dot(X,(A-Y).T) db = (1/m)*np.sum(A-Y) grads = {"dw": dw, "db": db} return grads, cost ``` #### 更新规则 利用上述得到的梯度来进行参数更新操作。 ```python def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost=False): costs = [] for i in range(num_iterations): grads, cost = propagate(w, b, X, Y) # Retrieve derivatives from grads dw = grads["dw"] db = grads["db"] # Update rule w -= learning_rate * dw b -= learning_rate * db # Record the costs every 100 training examples if i % 100 == 0: costs.append(cost) # Print the cost every 100 training iterations if print_cost: print ("Cost after iteration %i: %f" %(i, cost)) params = {"w": w, "b": b} grads = {"dw": dw, "db": db} return params, grads, costs ``` #### 预测功能 最后一步是创建一个用于做出预测的功能。 ```python def predict(w, b, X): ''' Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b) Arguments: w -- weights, a numpy array of size (num_features, 1) b -- bias, a scalar X -- data of size (num_features, number_of_examples) Returns: Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X ''' m = X.shape[1] Y_prediction = np.zeros((1,m)) w = w.reshape(X.shape[0], 1) # Compute vector "A" predicting the probabilities of being cat A = sigmoid(np.dot(w.T,X)+b) for i in range(A.shape[1]): # Convert probabilities into actual predictions Y_prediction[0,i] = 1 if A[0,i]>0.5 else 0 return Y_prediction ``` #### 整合所有部分 现在有了所有的组件之后就可以把它们组合起来形成完整的逻辑回归模型了。 ```python def model(X_train, Y_train, X_test=None, Y_test=None, num_iterations=2000, learning_rate=0.5, print_cost=False): """ Builds the logistic regression model by calling previously defined functions. """ dim = X_train.shape[0] w, b = initialize_with_zeros(dim) # Gradient descent parameters, _, _ = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost) # Retrieve parameters w and b from dictionary "parameters" w = parameters["w"] b = parameters["b"] # Predict test/train set examples Y_prediction_test = None if X_test is not None: Y_prediction_test = predict(w, b, X_test) Y_prediction_train = predict(w, b, X_train) # Print train/test Errors if Y_test is not None: print("train accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100)) print("test accuracy: {}