sigmoid算法代码

下面是使用Python编写的sigmoid算法的代码示例：

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 示例用法
x = np.array([0, 1, 2, 3, 4])
print(sigmoid(x))

此代码定义了一个sigmoid函数，它接受一个数值或一个数组作为输入，并返回对应的sigmoid函数值。在示例中，我们使用NumPy库创建了一个数组`x`，并将其作为参数传递给sigmoid函数，然后打印输出结果。

请注意，sigmoid函数的输入可以是任意实数或数组。这段代码使用了NumPy库中的`exp`函数来计算指数值，因此需要先安装NumPy库才能运行此代码。

相关问题

用sigmoid算法实现前馈神经网络的代码

当使用sigmoid算法实现前馈神经网络时，需要进行以下几个步骤：

1. 初始化参数：初始化权重和偏置值，可以使用随机数或者其他方法进行初始化。

2. 前向传播：通过计算每一层的加权输入和激活函数的输出，将输入数据从输入层传递到输出层。

3. 计算损失：根据预测值和真实值之间的差异，计算损失函数的值。

4. 反向传播：根据损失函数的值，计算每一层的梯度，并更新参数。

5. 重复步骤2-4，直到达到预定的迭代次数或者损失函数收敛。

下面是一个简单的用sigmoid算法实现前馈神经网络的代码示例：

import numpy as np

# 定义sigmoid函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 初始化参数
def initialize_parameters(layer_dims):
    parameters = {}
    L = len(layer_dims)
    
    for l in range(1, L):
        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * 0.01
        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
        
    return parameters

# 前向传播
def forward_propagation(X, parameters):
    caches = []
    A = X
    L = len(parameters) // 2
    
    for l in range(1, L):
        Z = np.dot(parameters['W' + str(l)], A) + parameters['b' + str(l)]
        A = sigmoid(Z)
        caches.append((Z, A))
    
    ZL = np.dot(parameters['W' + str(L)], A) + parameters['b' + str(L)]
    AL = sigmoid(ZL)
    caches.append((ZL, AL))
    
    return AL, caches

# 计算损失
def compute_cost(AL, Y):
    m = Y.shape
    cost = -np.sum(Y * np.log(AL) + (1 - Y) * np.log(1 - AL)) / m
    cost = np.squeeze(cost)
    
    return cost

# 反向传播
def backward_propagation(AL, Y, caches):
    grads = {}
    L = len(caches)
    m = AL.shape
    Y = Y.reshape(AL.shape)
    
    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
    
    dZL = dAL * sigmoid(caches[L-1]) * (1 - sigmoid(caches[L-1]))
    grads['dW' + str(L)] = np.dot(dZL, caches[L-1].T) / m
    grads['db' + str(L)] = np.sum(dZL, axis=1, keepdims=True) / m
    
    for l in reversed(range(L-1)):
        dA = np.dot(parameters['W' + str(l+2)].T, dZ)
        dZ = dA * sigmoid(caches[l]) * (1 - sigmoid(caches[l]))
        grads['dW' + str(l+1)] = np.dot(dZ, caches[l].T) / m
        grads['db' + str(l+1)] = np.sum(dZ, axis=1, keepdims=True) / m
    
    return grads

# 更新参数
def update_parameters(parameters, grads, learning_rate):
    L = len(parameters) // 2
    
    for l in range(L):
        parameters['W' + str(l+1)] -= learning_rate * grads['dW' + str(l+1)]
        parameters['b' + str(l+1)] -= learning_rate * grads['db' + str(l+1)]
    
    return parameters

# 定义前馈神经网络模型
def model(X, Y, layer_dims, learning_rate, num_iterations):
    parameters = initialize_parameters(layer_dims)
    
    for i in range(num_iterations):
        AL, caches = forward_propagation(X, parameters)
        cost = compute_cost(AL, Y)
        grads = backward_propagation(AL, Y, caches)
        parameters = update_parameters(parameters, grads, learning_rate)
        
        if i % 100 == 0:
            print("Cost after iteration {}: {}".format(i, cost))
    
    return parameters

# 示例数据
X = np.array([[0, 0, 1, 1], [0, 1, 0, 1]])
Y = np.array([[0, 1, 1, 0]])

# 定义神经网络结构
layer_dims = [2, 4, 1]

# 训练模型
parameters = model(X, Y, layer_dims, learning_rate=0.01, num_iterations=1000)

这段代码实现了一个简单的前馈神经网络，其中使用了sigmoid函数作为激活函数。你可以根据自己的需求进行修改和扩展。希望对你有帮助！

MATLAB逻辑回归算法代码

MATLAB中可以使用逻辑回归算法进行分类任务。下面是一个简单的逻辑回归算法代码示例：

% 准备训练数据
X = [1 1; 1 2; 2 1; 2 2; 3 3; 4 4]; % 特征矩阵
y = [0; 0; 0; 1; 1; 1]; % 标签向量

% 添加偏置项
X = [ones(size(X,1),1) X];

% 初始化参数
theta = zeros(size(X,2),1);

% 定义逻辑回归假设函数
hypothesis = @(theta, x) sigmoid(x * theta);

% 定义sigmoid函数
sigmoid = @(z) 1 ./ (1 + exp(-z));

% 定义代价函数
costFunction = @(theta, X, y) (-y' * log(hypothesis(theta, X)) - (1 - y') * log(1 - hypothesis(theta, X))) / size(X,1);

% 定义梯度下降函数
gradientDescent = @(theta, X, y, alpha, num_iters) {
    for iter = 1:num_iters
        theta = theta - (alpha / size(X,1)) * X' * (hypothesis(theta, X) - y);
    end
};

% 设置学习率和迭代次数
alpha = 0.01;
num_iters = 1000;

% 运行梯度下降算法
gradientDescent(theta, X, y, alpha, num_iters);

% 输出训练后的参数
disp('训练后的参数：');
disp(theta);

% 预测新样本
newX = [1 5; 2 3];
newX = [ones(size(newX,1),1) newX];
predictions = round(hypothesis(theta, newX));

% 输出预测结果
disp('预测结果：');
disp(predictions);

这段代码实现了逻辑回归算法的训练和预测过程。首先，准备训练数据，其中`X`是特征矩阵，`y`是标签向量。然后，添加偏置项，并初始化参数。接下来，定义逻辑回归的假设函数、sigmoid函数、代价函数和梯度下降函数。然后，设置学习率和迭代次数，并运行梯度下降算法进行训练。最后，输出训练后的参数和预测结果。