算法实现

import numpy as np

class GradientDescent:
    def __init__(self, learning_rate=0.01, max_iterations=1000):
        self.learning_rate = learning_rate
        self.max_iterations = max_iterations
        self.history = []
    
    def optimize(self, objective_function, gradient_function, initial_params):
        """
        梯度下降优化算法
        
        Args:
            objective_function: 目标函数
            gradient_function: 梯度函数
            initial_params: 初始参数
        
        Returns:
            优化后的参数
        """
        params = np.array(initial_params)
        
        for iteration in range(self.max_iterations):
            # 计算梯度
            gradient = gradient_function(params)
            
            # 更新参数
            params = params - self.learning_rate * gradient
            
            # 记录历史
            loss = objective_function(params)
            self.history.append(loss)
            
            # 检查收敛
            if len(self.history) > 1:
                if abs(self.history[-1] - self.history[-2]) < 1e-6:
                    break
        
        return params

# 使用示例
def objective_function(params):
    """简单的二次函数作为目标函数"""
    return params[0]**2 + params[1]**2

def gradient_function(params):
    """目标函数的梯度"""
    return np.array([2*params[0], 2*params[1]])

# 初始化优化器
optimizer = GradientDescent(learning_rate=0.1, max_iterations=100)

# 开始优化
initial_params = [1.0, 1.0]
optimal_params = optimizer.optimize(objective_function, gradient_function, initial_params)

print(f"最优参数: {optimal_params}")
print(f"最终损失: {objective_function(optimal_params)}")

import numpy as np

def convolution_2d(image, kernel, stride=1, padding=0):
    """
    2D卷积操作实现
    
    Args:
        image: 输入图像 (H, W)
        kernel: 卷积核 (K, K)
        stride: 步长
        padding: 填充大小
    
    Returns:
        卷积结果
    """
    # 添加填充
    if padding > 0:
        image = np.pad(image, padding, mode='constant')
    
    # 获取尺寸
    H, W = image.shape
    K = kernel.shape[0]
    
    # 计算输出尺寸
    out_H = (H - K) // stride + 1
    out_W = (W - K) // stride + 1
    
    # 初始化输出
    output = np.zeros((out_H, out_W))
    
    # 执行卷积
    for i in range(out_H):
        for j in range(out_W):
            # 提取当前窗口
            window = image[i*stride:i*stride+K, j*stride:j*stride+K]
            # 计算卷积
            output[i, j] = np.sum(window * kernel)
    
    return output

# 使用示例
# 创建测试图像
image = np.array([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16]
])

# 创建卷积核（边缘检测）
kernel = np.array([
    [-1, -1, -1],
    [-1,  8, -1],
    [-1, -1, -1]
])

# 执行卷积
result = convolution_2d(image, kernel, stride=1, padding=1)
print("卷积结果:")
print(result)