C++.神经网络与深度学习（赶工版）（会二次修改）

Rachelhi2025-05-15 9:21

神经网络与深度学习

  • [1. 神经网络基础](#1. 神经网络基础)
    • [1.1 神经元模型与激活函数](#1.1 神经元模型与激活函数)
    • [1.2 神经网络结构与前向传播](#1.2 神经网络结构与前向传播)
    • [2.1 损失函数与优化算法](#2.1 损失函数与优化算法)
    • [2.2 反向传播与梯度计算](#2.2 反向传播与梯度计算)
    • [3.1 神经元类设计与实现](#3.1 神经元类设计与实现)
    • [3.2 神经网络类构建](#3.2 神经网络类构建)
    • [4.1 神经元模型与激活函数](#4.1 神经元模型与激活函数)
    • [4.2 神经网络结构与前向传播](#4.2 神经网络结构与前向传播)
    • [4.3 深度学习框架中的关键组件](#4.3 深度学习框架中的关键组件)
    • [4.4 反向传播与梯度计算](#4.4 反向传播与梯度计算)
    • [4.5 神经网络类的构建与实现](#4.5 神经网络类的构建与实现)

1. 神经网络基础

1.1 神经元模型与激活函数

神经元是神经网络的基本单元，其模型可以类比为生物神经元。一个神经元接收多个输入信号，对这些信号进行加权求和，然后通过一个激活函数进行非线性变换，最终输出一个信号。以下是用 C++ 实现一个简单神经元的代码示例：

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>

// 定义激活函数
double sigmoid(double x) {
    return 1.0 / (1.0 + exp(-x));
}

// 神经元类
class Neuron {
private:
    std::vector<double> weights; // 权重
    double bias; // 偏置

public:
    // 构造函数
    Neuron(int input_size) {
        weights.resize(input_size, 0.0); // 初始化权重为0
        bias = 0.0; // 初始化偏置为0
    }

    // 设置权重和偏置
    void set_weights(const std::vector<double>& w, double b) {
        weights = w;
        bias = b;
    }

    // 前向传播，计算输出
    double forward(const std::vector<double>& inputs) {
        double sum = bias;
        for (size_t i = 0; i < inputs.size(); ++i) {
            sum += inputs[i] * weights[i];
        }
        return sigmoid(sum); // 使用Sigmoid激活函数
    }
};

int main() {
    // 创建一个输入大小为2的神经元
    Neuron neuron(2);

    // 设置权重和偏置
    std::vector<double> weights = {0.5, -0.3};
    double bias = 0.1;
    neuron.set_weights(weights, bias);

    // 输入信号
    std::vector<double> inputs = {1.0, -2.0};

    // 计算输出
    double output = neuron.forward(inputs);
    std::cout << "Neuron output: " << output << std::endl;

    return 0;
}

代码思路：

  • 激活函数：Sigmoid 函数是一个常用的激活函数，它将输入映射到 (0, 1) 区间，具有平滑的梯度，适用于神经元的非线性变换。
  • 神经元类 ：
    • 成员变量 ：weights 存储输入信号的权重，bias 是偏置项。
    • 构造函数：根据输入信号的数量初始化权重和偏置。
    • 设置权重和偏置 ：通过 set_weights 函数设置权重和偏置。
    • 前向传播 ：forward 函数计算输入信号的加权和，加上偏置后通过激活函数输出结果。
  • 主函数 ：
    • 创建一个神经元实例，设置权重和偏置。
    • 提供输入信号，调用 forward 函数计算输出。

1.2 神经网络结构与前向传播

神经网络由多个神经元组成，通常分为输入层、隐藏层和输出层。前向传播是指从输入层到输出层逐层计算的过程。以下是一个简单的两层神经网络的 C++ 实现：

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>

// 激活函数
double sigmoid(double x) {
    return 1.0 / (1.0 + exp(-x));
}

// 神经元类
class Neuron {
private:
    std::vector<double> weights;
    double bias;

public:
    Neuron(int input_size) {
        weights.resize(input_size, 0.0);
        bias = 0.0;
    }

    void set_weights(const std::vector<double>& w, double b) {
        weights = w;
        bias = b;
    }

    double forward(const std::vector<double>& inputs) {
        double sum = bias;
        for (size_t i = 0; i < inputs.size(); ++i) {
            sum += inputs[i] * weights[i];
        }
        return sigmoid(sum);
    }
};

// 神经网络类
class NeuralNetwork {
private:
    std::vector<Neuron> hidden_layer; // 隐藏层
    Neuron output_neuron; // 输出层

public:
    NeuralNetwork(int input_size, int hidden_size) {
        hidden_layer.resize(hidden_size, Neuron(input_size));
        output_neuron = Neuron(hidden_size);
    }

    void set_weights(const std::vector<std::vector<double>>& hidden_weights,
                     const std::vector<double>& hidden_biases,
                     const std::vector<double>& output_weights,
                     double output_bias) {
        for (size_t i = 0; i < hidden_layer.size(); ++i) {
            hidden_layer[i].set_weights(hidden_weights[i], hidden_biases[i]);
        }
        output_neuron.set_weights(output_weights, output_bias);
    }

    double forward(const std::vector<double>& inputs) {
        std::vector<double> hidden_outputs(hidden_layer.size());
        for (size_t i = 0; i < hidden_layer.size(); ++i) {
            hidden_outputs[i] = hidden_layer[i].forward(inputs);
        }
        return output_neuron.forward(hidden_outputs);
    }
};

int main() {
    // 创建一个输入大小为2，隐藏层大小为2的神经网络
    NeuralNetwork nn(2, 2);

    // 设置权重和偏置
    std::vector<std::vector<double>> hidden_weights = {{0.5, -0.3}, {0.2, 0.1}};
    std::vector<double> hidden_biases = {0.1, -0.2};
    std::vector<double> output_weights = {0.4, -0.5};
    double output_bias = 0.3;
    nn.set_weights(hidden_weights, hidden_biases, output_weights, output_bias);

    // 输入信号
    std::vector<double> inputs = {1.0, -2.0};

    // 计算输出
    double output = nn.forward(inputs);
    std::cout << "Neural Network output: " << output << std::endl;

    return 0;
}

代码思路：

  • 神经网络类 ：
    • 成员变量 ：hidden_layer 存储隐藏层的神经元，output_neuron 是输出层的神经元。
    • 构造函数：根据输入层大小和隐藏层大小初始化神经网络。
    • 设置权重和偏置 ：通过 set_weights 函数设置隐藏层和输出层的权重和偏置。
    • 前向传播 ：
      • 隐藏层的每个神经元对输入信号进行前向传播，计算隐藏层的输出。
      • 将隐藏层的输出作为输出层神经元的输入，计算最终输出。
  • 主函数 ：
    • 创建一个神经网络实例，设置权重和偏置。
    • 提供输入信号，调用 forward 函数计算输出。# 2. 深度学习框架

2.1 损失函数与优化算法

在深度学习中，损失函数用于衡量模型的预测值与真实值之间的差异，优化算法则用于调整模型的参数以最小化损失函数。以下是几种常见的损失函数和优化算法的实现及讲解。

均方误差损失函数

均方误差（MSE）损失函数是回归任务中常用的损失函数，它计算预测值与真实值之间差的平方的均值。

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>

// 均方误差损失函数
double mse_loss(const std::vector<double>& predictions, const std::vector<double>& targets) {
    double loss = 0.0;
    for (size_t i = 0; i < predictions.size(); ++i) {
        loss += std::pow(predictions[i] - targets[i], 2);
    }
    return loss / predictions.size();
}

int main() {
    // 示例：预测值和真实值
    std::vector<double> predictions = {0.5, 1.2, -0.3};
    std::vector<double> targets = {0.4, 1.0, -0.5};

    // 计算损失
    double loss = mse_loss(predictions, targets);
    std::cout << "MSE Loss: " << loss << std::endl;

    return 0;
}

代码思路：

  • 损失计算：遍历预测值和真实值，计算每个样本的预测值与真实值之差的平方。将所有样本的损失值求和后除以样本总数，得到均方误差损失。

交叉熵损失函数

交叉熵损失函数常用于分类任务，它衡量模型输出的概率分布与真实标签的概率分布之间的差异。

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

// Softmax函数
std::vector<double> softmax(const std::vector<double>& logits) {
    double max_logit = *std::max_element(logits.begin(), logits.end());
    double sum = 0.0;
    std::vector<double> probabilities(logits.size());
    for (size_t i = 0; i < logits.size(); ++i) {
        probabilities[i] = std::exp(logits[i] - max_logit);
        sum += probabilities[i];
    }
    for (size_t i = 0; i < logits.size(); ++i) {
        probabilities[i] /= sum;
    }
    return probabilities;
}

// 交叉熵损失函数
double cross_entropy_loss(const std::vector<double>& logits, int target_class) {
    std::vector<double> probabilities = softmax(logits);
    return -std::log(probabilities[target_class]);
}

int main() {
    // 示例：模型输出的logits和目标类别
    std::vector<double> logits = {2.0, 1.0, 0.1};
    int target_class = 0;

    // 计算损失
    double loss = cross_entropy_loss(logits, target_class);
    std::cout << "Cross-Entropy Loss: " << loss << std::endl;

    return 0;
}

代码思路：

  • Softmax函数 ：
    • 对输入的logits进行归一化处理，使其转换为概率分布。
    • 首先计算每个logit的最大值，用于防止数值溢出。
    • 计算每个logit的指数值并归一化，得到概率分布。
  • 交叉熵损失 ：
    • 使用Softmax函数计算模型输出的概率分布。
    • 计算目标类别的概率的负对数，得到交叉熵损失。

梯度下降优化算法

梯度下降是深度学习中最常用的优化算法之一，它通过计算损失函数对参数的梯度，更新参数以最小化损失。

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>

// 梯度下降优化器
class GradientDescentOptimizer {
private:
    double learning_rate; // 学习率

public:
    GradientDescentOptimizer(double lr) : learning_rate(lr) {}

    // 更新参数
    void update(std::vector<double>& params, const std::vector<double>& gradients) {
        for (size_t i = 0; i < params.size(); ++i) {
            params[i] -= learning_rate * gradients[i];
        }
    }
};

int main() {
    // 示例：参数和梯度
    std::vector<double> params = {1.0, 2.0};
    std::vector<double> gradients = {0.5, -0.3};
    double learning_rate = 0.1;

    // 创建优化器
    GradientDescentOptimizer optimizer(learning_rate);

    // 更新参数
    optimizer.update(params, gradients);

    // 输出更新后的参数
    std::cout << "Updated parameters: ";
    for (double param : params) {
        std::cout << param << " ";
    }
    std::cout << std::endl;

    return 0;
}

代码思路：

  • 优化器类 ：
    • 成员变量 ：learning_rate 存储学习率。
    • 更新参数 ：update 函数根据梯度和学习率更新参数。
  • 主函数 ：
    • 初始化参数和梯度。
    • 创建优化器实例，调用 update 函数更新参数。

2.2 反向传播与梯度计算

反向传播是深度学习中用于计算损失函数对模型参数梯度的关键算法。它通过链式法则从输出层向输入层逐层计算梯度。

神经元的反向传播

以下是一个简单神经元的反向传播实现，包括前向传播和反向传播的代码。

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>

// 激活函数及其导数
double sigmoid(double x) {
    return 1.0 / (1.0 + std::exp(-x));
}

double sigmoid_derivative(double x) {
    return sigmoid(x) * (1.0 - sigmoid(x));
}

// 神经元类
class Neuron {
private:
    std::vector<double> weights;
    double bias;

public:
    Neuron(int input_size) {
        weights.resize(input_size, 0.0);
        bias = 0.0;
    }

    void set_weights(const std::vector<double>& w, double b) {
        weights = w;
        bias = b;
    }

    // 前向传播
    double forward(const std::vector<double>& inputs) {
        double sum = bias;
        for (size_t i = 0; i < inputs.size(); ++i) {
            sum += inputs[i] * weights[i];
        }
        return sigmoid(sum);
    }

    // 反向传播
    std::vector<double> backward(const std::vector<double>& inputs, double output, double target) {
        double error = target - output;
        double delta = error * sigmoid_derivative(output);

        std::vector<double> gradients(inputs.size());
        for (size_t i = 0; i < inputs.size(); ++i) {
            gradients[i] = delta * inputs[i];
        }
        return gradients;
    }
};

int main() {
    // 创建一个输入大小为2的神经元
    Neuron neuron(2);

    // 设置权重和偏置
    std::vector<double> weights = {0.5, -0.3};
    double bias = 0.1;
    neuron.set_weights(weights, bias);

    // 输入信号和目标值
    std::vector<double> inputs = {1.0, -2.0};
    double target = 1.0;

    // 前向传播
    double output = neuron.forward(inputs);
    std::cout << "Neuron output: " << output << std::endl;

    // 反向传播
    std::vector<double> gradients = neuron.backward(inputs, output, target);

    // 输出梯度
    std::cout << "Gradients: ";
    for (double gradient : gradients) {
        std::cout << gradient << " ";
    }
    std::cout << std::endl;

    return 0;
}

代码思路：

  • 激活函数及其导数 ：
    • sigmoid 函数用于前向传播，将输入映射到 (0, 1) 区间。
    • sigmoid_derivative 函数用于计算激活函数的导数，用于反向传播。
  • 神经元类 ：
    • 前向传播：计算输入信号的加权和，加上偏置后通过激活函数输出结果。
    • 反向传播 ：
      • 计算误差：error = target - output。
      • 计算梯度：delta = error * sigmoid_derivative(output)。
      • 计算每个输入对应的梯度：gradients[i] = delta * inputs[i]。
  • 主函数 ：
    • 创建神经元实例，设置权重和偏置。
    • 提供输入信号和目标值，调用 forward 函数计算输出。
    • 调用 backward 函数计算梯度。# 3. C++实现神经网络

3.1 神经元类设计与实现

神经元是神经网络的基本构建块，其设计需要考虑前向传播和反向传播两个过程。以下是基于C++标准库实现的神经元类，包含详细的代码和思路讲解。

神经元类代码实现

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>

// 激活函数及其导数
double sigmoid(double x) {
    return 1.0 / (1.0 + std::exp(-x));
}

double sigmoid_derivative(double x) {
    return sigmoid(x) * (1.0 - sigmoid(x));
}

// 神经元类
class Neuron {
private:
    std::vector<double> weights; // 权重
    double bias; // 偏置

public:
    // 构造函数：初始化权重和偏置
    Neuron(int input_size) {
        weights.resize(input_size, 0.0); // 初始化权重为0
        bias = 0.0; // 初始化偏置为0
    }

    // 设置权重和偏置
    void set_weights(const std::vector<double>& w, double b) {
        weights = w;
        bias = b;
    }

    // 前向传播：计算输出
    double forward(const std::vector<double>& inputs) {
        double sum = bias;
        for (size_t i = 0; i < inputs.size(); ++i) {
            sum += inputs[i] * weights[i];
        }
        return sigmoid(sum); // 使用Sigmoid激活函数
    }

    // 反向传播：计算梯度
    std::vector<double> backward(const std::vector<double>& inputs, double output, double target) {
        double error = target - output; // 计算误差
        double delta = error * sigmoid_derivative(output); // 计算梯度

        std::vector<double> gradients(inputs.size());
        for (size_t i = 0; i < inputs.size(); ++i) {
            gradients[i] = delta * inputs[i]; // 计算每个输入对应的梯度
        }
        return gradients;
    }
};

代码思路

  • 激活函数及其导数 ：
    • sigmoid 函数用于前向传播，将输入映射到 (0, 1) 区间。
    • sigmoid_derivative 函数用于计算激活函数的导数，用于反向传播。
  • 神经元类 ：
    • 成员变量 ：
      • weights：存储输入信号的权重。
      • bias：存储偏置项。
    • 构造函数 ：
      • 根据输入信号的数量初始化权重和偏置，权重初始化为0，偏置初始化为0。
    • 设置权重和偏置 ：
      • 通过 set_weights 函数设置权重和偏置。
    • 前向传播 ：
      • 计算输入信号的加权和，加上偏置后通过激活函数输出结果。
    • 反向传播 ：
      • 计算误差：error = target - output。
      • 计算梯度：delta = error * sigmoid_derivative(output)。
      • 计算每个输入对应的梯度：gradients[i] = delta * inputs[i]。

3.2 神经网络类构建

神经网络由多个神经元组成，通常分为输入层、隐藏层和输出层。以下是基于C++标准库实现的简单神经网络类，包含前向传播和反向传播的代码。

神经网络类代码实现

cpp 复制代码 
#include <iostream>
#include <vector>
#include <cmath>

// 激活函数及其导数
double sigmoid(double x) {
    return 1.0 / (1.0 + std::exp(-x));
}

double sigmoid_derivative(double x) {
    return sigmoid(x) * (1.0 - sigmoid(x));
}

// 神经元类
class Neuron {
private:
    std::vector<double> weights;
    double bias;

public:
    Neuron(int input_size) {
        weights.resize(input_size, 0.0);
        bias = 0.0;
    }

    void set_weights(const std::vector<double>& w, double b) {
        weights = w;
        bias = b;
    }

    double forward(const std::vector<double>& inputs) {
        double sum = bias;
        for (size_t i = 0; i < inputs.size(); ++i) {
            sum += inputs[i] * weights[i];
        }
        return sigmoid(sum);
    }

    std::vector<double> backward(const std::vector<double>& inputs, double output, double target) {
        double error = target - output;
        double delta = error * sigmoid_derivative(output);

        std::vector<double> gradients(inputs.size());
        for (size_t i = 0; i < inputs.size(); ++i) {
            gradients[i] = delta * inputs[i];
        }
        return gradients;
    }
};

// 神经网络类
class NeuralNetwork {
private:
    std::vector<Neuron> hidden_layer; // 隐藏层
    Neuron output_neuron; // 输出层

public:
    // 构造函数：初始化隐藏层和输出层
    NeuralNetwork(int input_size, int hidden_size) {
        hidden_layer.resize(hidden_size, Neuron(input_size));
        output_neuron = Neuron(hidden_size);
    }

    // 设置权重和偏置
    void set_weights(const std::vector<std::vector<double>>& hidden_weights,
                     const std::vector<double>& hidden_biases,
                     const std::vector<double>& output_weights,
                     double output_bias) {
        for (size_t i = 0; i < hidden_layer.size(); ++i) {
            hidden_layer[i].set_weights(hidden_weights[i], hidden_biases[i]);
        }
        output_neuron.set_weights(output_weights, output_bias);
    }

    // 前向传播：计算输出
    double forward(const std::vector<double>& inputs) {
        std::vector<double> hidden_outputs(hidden_layer.size());
        for (size_t i = 0; i < hidden_layer.size(); ++i) {
            hidden_outputs[i] = hidden_layer[i].forward(inputs);
        }
        return output_neuron.forward(hidden_outputs);
    }

    // 反向传播：计算梯度
    std::vector<std::vector<double>> backward(const std::vector<double>& inputs, double output, double target) {
        std::vector<double> hidden_outputs(hidden_layer.size());
        for (size_t i = 0; i < hidden_layer.size(); ++i) {
            hidden_outputs[i] = hidden_layer[i].forward(inputs);
        }
        double output_error = target - output;
        double output_delta = output_error * sigmoid_derivative(output);

        std::vector<double> output_gradients(hidden_layer.size());
        for (size_t i = 0; i < hidden_layer.size(); ++i) {
            output_gradients[i] = output_delta * hidden_outputs[i];
        }

        std::vector<std::vector<double>> hidden_gradients(hidden_layer.size());
        for (size_t i = 0; i < hidden_layer.size(); ++i) {
            double hidden_error = output_delta * output_neuron.weights[i];
            double hidden_delta = hidden_error * sigmoid_derivative(hidden_outputs[i]);

            hidden_gradients[i].resize(inputs.size());
            for (size_t j = 0; j < inputs.size(); ++j) {
                hidden_gradients[i][j] = hidden_delta * inputs[j];
            }
        }

        return hidden_gradients;
    }
};

代码思路

  • 神经网络类 ：
    • 成员变量 ：
      • hidden_layer：存储隐藏层的神经元。
      • output_neuron：存储输出层的神经元。
    • 构造函数 ：
      • 根据输入层大小和隐藏层大小初始化神经网络。
    • 设置权重和偏置 ：
      • 通过 set_weights 函数设置隐藏层和输出层的权重和偏置。
    • 前向传播 ：
      • 隐藏层的每个神经元对输入信号进行前向传播，计算隐藏层的输出。
      • 将隐藏层的输出作为输出层神经元的输入，计算最终输出。
    • 反向传播 ：
      • 计算输出层的误差和梯度。
      • 通过链式法则计算隐藏层的误差和梯度。
      • 返回所有层的梯度，用于后续的参数更新。# 4. 总结

在本章中，我们详细探讨了神经网络的基础知识，包括神经元模型、激活函数、神经网络结构以及深度学习框架中的关键组件。通过这些内容，我们逐步构建了一个完整的神经网络模型，并实现了前向传播和反向传播算法。

4.1 神经元模型与激活函数

神经元是神经网络的基本单元，其设计灵感来源于生物神经元。一个神经元接收多个输入信号，对这些信号进行加权求和，并通过激活函数进行非线性变换，最终输出一个信号。激活函数是神经网络中不可或缺的一部分，它为网络引入了非线性因素，使得神经网络能够学习和模拟复杂的非线性关系。在本章中，我们使用了 Sigmoid 激活函数，它将输入映射到 (0, 1) 区间，具有平滑的梯度，适用于神经元的非线性变换。通过 C++ 实现的神经元类，我们展示了如何设置权重和偏置，并通过前向传播计算输出结果。

4.2 神经网络结构与前向传播

神经网络由多个神经元组成，通常分为输入层、隐藏层和输出层。前向传播是指从输入层到输出层逐层计算的过程。在本章中，我们构建了一个简单的两层神经网络，并通过 C++ 实现了其前向传播过程。隐藏层的每个神经元对输入信号进行前向传播，计算隐藏层的输出，然后将这些输出作为输出层神经元的输入，最终计算出整个网络的输出。通过设置权重和偏置，我们可以调整神经网络的行为，使其能够学习特定的任务。

4.3 深度学习框架中的关键组件

深度学习框架中的损失函数和优化算法是训练神经网络的关键。损失函数用于衡量模型的预测值与真实值之间的差异，而优化算法则用于调整模型的参数以最小化损失函数。在本章中，我们介绍了两种常见的损失函数：均方误差损失函数和交叉熵损失函数。均方误差损失函数适用于回归任务，而交叉熵损失函数则常用于分类任务。此外，我们还介绍了梯度下降优化算法，它通过计算损失函数对参数的梯度，更新参数以最小化损失。通过 C++ 实现的梯度下降优化器，我们展示了如何根据梯度和学习率更新参数。

4.4 反向传播与梯度计算

反向传播是深度学习中用于计算损失函数对模型参数梯度的关键算法。它通过链式法则从输出层向输入层逐层计算梯度。在本章中，我们详细介绍了神经元的反向传播过程，并通过 C++ 实现了相应的代码。在反向传播中，我们首先计算输出层的误差和梯度，然后通过链式法则计算隐藏层的误差和梯度。最终，我们得到了所有层的梯度，这些梯度将用于后续的参数更新。

4.5 神经网络类的构建与实现

在本章的最后，我们基于 C++ 标准库实现了一个简单的神经网络类，该类包含了前向传播和反向传播的功能。神经网络类的成员变量包括隐藏层和输出层的神经元。通过构造函数，我们根据输入层大小和隐藏层大小初始化神经网络。设置权重和偏置的函数允许我们调整网络的参数。在前向传播中，隐藏层的每个神经元对输入信号进行前向传播，计算隐藏层的输出，然后将这些输出作为输出层神经元的输入，最终计算出整个网络的输出。在反向传播中，我们计算输出层的误差和梯度，并通过链式法则计算隐藏层的误差和梯度。最终，我们得到了所有层的梯度，这些梯度将用于后续的参数更新。

  1. List item
相关推荐
仙人掌_lz5 分钟前
用PyTorch在超大规模下训练深度学习模型：并行策略全解析
人工智能·pytorch·深度学习
视觉语言导航12 分钟前
AAAI-2025 | 中科院无人机导航新突破！FELA：基于细粒度对齐的无人机视觉对话导航
人工智能·深度学习·机器人·无人机·具身智能
灏瀚星空21 分钟前
地磁-惯性-视觉融合制导系统设计：现代空战导航的抗干扰解决方案
图像处理·人工智能·python·深度学习·算法·机器学习·信息与通信
泽020224 分钟前
C++类和对象之相关特性
java·开发语言·c++
feiyangqingyun1 小时前
Qt/C++开发监控GB28181系统/录像文件查询/录像回放/倍速播放/录像文件下载
c++·qt·gb28181·录像回放·录像文件下载
郜太素1 小时前
PyTorch 中神经网络相关要点（损失函数，学习率）及优化方法总结
人工智能·pytorch·python·深度学习·神经网络·学习
健康胡1 小时前
仿射变换 与 透视变换
图像处理·人工智能·深度学习·opencv·算法·机器学习·计算机视觉
2301_807611491 小时前
310. 最小高度树
c++·算法·leetcode·深度优先·回溯
音视频牛哥1 小时前
灰度图像和RGB图像在数据大小和编码处理方式差别
人工智能·深度学习·计算机视觉·大牛直播sdk·灰度图像·灰度图像编码·rgb和灰度图像差别
深度学习机器学习1 小时前
计算机视觉最不卷的方向：三维重建学习路线梳理
人工智能·深度学习·学习·yolo·目标检测·机器学习·计算机视觉
热门推荐
01YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03KGG转MP3工具|非KGM文件|解密音频04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05Coze扣子平台完整体验和实践（附国内和国际版对比）06DeepSeek各版本说明与优缺点分析07【解决】Android Gradle Sync 报错 Could not read workspace metadata08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09苍穹外卖面试总结10yolov10来了！用yolov10训练自己的数据集（原理、训练、部署、应用）