当前位置： 首页 > web >正文

C++高效实现AI人工智能实例

web 2025/7/27 6:58:10

C++高效实现AI人工智能实例

摘要：C++在人工智能领域具有独特优势，特别是在高性能计算和实时系统方面。本文展示了C++在多种AI任务中的应用实例，包括神经网络实现、计算机视觉、自然语言处理和机器学习算法。从基础数据结构到高级深度学习框架，涵盖了OpenCV、TensorFlow C++ API、Armadillo、MLPACK等工具的实际应用，以及KCF算法、朴素贝叶斯分类器等具体实现。这些示例突出了C++在内存管理、计算效率和硬件控制方面的优势，同时提供了从理论到实践的完整代码片段，适合不同层次的开发者参考和学习。

C++ 是一种高性能的编程语言，广泛应用于人工智能领域，特别是在深度学习和神经网络的实现中。尽管 Python 在人工智能领域应用广泛，但 C++ 由于其高效性、内存管理灵活性和与硬件的直接交互能力，仍然在许多关键任务中占据重要地位。

深度学习和神经网络

深度学习是一种特殊的机器学习方法，通过多层神经网络模型来学习数据的表示和特征。神经网络模拟人脑神经元结构，由多个神经元组成，每个神经元接收输入信号，通过激活函数产生输出信号。C++ 可以通过高效的计算和内存管理来实现这些复杂的计算任务。

代码示例

以下是一个简单的前馈神经网络示例，展示了如何使用 C++ 构建和训练神经网络：

#include <iostream>
#include "neural_network.h"int main() {// 创建神经网络NeuralNetwork nn;// 添加输入层nn.add_layer(new InputLayer(784));// 添加隐藏层nn.add_layer(new DenseLayer(128, "ReLU"));nn.add_layer(new DenseLayer(64, "ReLU"));// 添加输出层nn.add_layer(new DenseLayer(10, "Softmax"));// 编译神经网络nn.compile("CrossEntropy", "Adam");return 0;}

实际应用场景

C++ 在人工智能中的应用场景包括图像识别、自然语言处理、推荐系统、语音识别和游戏 AI 等。通过使用 C++，可以实现高效的计算和实时响应，这对于自动驾驶、嵌入式系统等要求高性能和低延迟的应用尤为重要。

使用C++训练神经网络的实例方法

环境准备
确保安装以下工具库：

  • Eigen（线性代数运算）
  • OpenCV（可选，图像数据处理）
  • CMake（项目构建）

推荐通过包管理器安装：

sudo apt-get install libeigen3-dev libopencv-dev cmake

基础神经网络实现（全连接层）

定义网络结构
使用Eigen库实现全连接层和ReLU激活函数：

#include <Eigen/Dense>
using namespace Eigen;class DenseLayer {
public:MatrixXd weights;VectorXd bias;DenseLayer(int input_size, int output_size) {weights = MatrixXd::Random(input_size, output_size) * 0.01;bias = VectorXd::Zero(output_size);}MatrixXd forward(const MatrixXd& input) {return input * weights + bias.transpose().replicate(input.rows(), 1);}
};class ReLU {
public:MatrixXd forward(const MatrixXd& input) {return input.cwiseMax(0);}
};

反向传播与训练循环

损失函数与梯度计算
实现均方误差（MSE）损失和梯度下降：

double mse_loss(const MatrixXd& pred, const MatrixXd& target) {return (pred - target).array().square().mean();
}void train_step(DenseLayer& layer, const MatrixXd& input, const MatrixXd& target, double lr = 0.01) {// 前向传播MatrixXd output = layer.forward(input);// 计算梯度MatrixXd error = 2 * (output - target) / target.size();MatrixXd grad_weights = input.transpose() * error;VectorXd grad_bias = error.colwise().sum();// 更新参数layer.weights -= lr * grad_weights;layer.bias -= lr * grad_bias;
}

实例：XOR问题求解

数据准备与训练

int main() {// XOR输入输出MatrixXd X(4, 2);X << 0, 0, 0, 1, 1, 0, 1, 1;MatrixXd y(4, 1);y << 0, 1, 1, 0;DenseLayer layer1(2, 4);DenseLayer layer2(4, 1);ReLU activation;// 训练循环for (int epoch = 0; epoch < 1000; ++epoch) {MatrixXd h1 = activation.forward(layer1.forward(X));MatrixXd pred = layer2.forward(h1);double loss = mse_loss(pred, y);if (epoch % 100 == 0) std::cout << "Epoch " << epoch << " Loss: " << loss << std::endl;// 反向传播（需扩展实现）}return 0;
}

扩展实例：MNIST分类

数据加载与预处理
使用OpenCV读取MNIST图像并归一化：

cv::Mat img = cv::imread("mnist_sample.png", cv::IMREAD_GRAYSCALE);
img.convertTo(img, CV_64F, 1.0/255);
Eigen::Map<VectorXd> flattened(img.ptr<double>(), img.total());

网络结构扩展
增加Softmax输出层和交叉熵损失：

VectorXd softmax(const VectorXd& z) {VectorXd exp_z = (z.array() - z.maxCoeff()).exp();return exp_z / exp_z.sum();
}

性能优化技巧

并行计算
启用Eigen的并行计算：

Eigen::setNbThreads(4);

内存映射
处理大型数据集时使用内存映射文件：

#include <Eigen/Core>
Eigen::MatrixXd data = Eigen::Map<MatrixXd>(mmap_ptr, rows, cols);

基于C++的KANN（轻量级神经网络库）应用实例

以下是基于C++的KANN（轻量级神经网络库）应用实例，涵盖基础操作、模型构建与训练等场景。示例基于KANN库的API，需确保已正确安装并包含头文件kann.h。

基础张量操作
#include "kann.h"// 创建并初始化张量
kad_tensor_t *tensor = kann_new_tensor(3, {2, 3, 4}); // 2x3x4张量
kann_fill(tensor, 1.0f); // 填充值为1.0

全连接层构建

kann_t *model = kann_new();
kann_layer_t *dense = kann_layer_dense(model, 10, KANN_F_LEAKY_RELU); // 10个神经元，激活函数为LeakyReLU

卷积神经网络

kann_t *model = kann_new();
kann_layer_t *conv = kann_layer_conv2d(model, 16, 3, 3, 1, 1, KANN_F_RELU); // 16个3x3卷积核
kann_layer_t *pool = kann_layer_maxpool2d(model, 2, 2); // 2x2最大池化

LSTM网络

kann_t *model = kann_new();
kann_layer_t *lstm = kann_layer_lstm(model, 32, 0); // 32个LSTM单元，无双向

模型编译与训练

kann_train_fnn(model, 0.001f, 64, 10, 0.1f, train_data, train_labels); // 学习率0.001，batch=64，10轮

保存与加载模型

kann_save("model.kan", model); // 保存模型
kann_t *loaded = kann_load("model.kan"); // 加载模型

自定义损失函数

kann_t *model = kann_new();
kann_layer_t *loss = kann_layer_cost(model, 1, KANN_C_CE); // 交叉熵损失
数据标准化
kann_data_norm(train_data, KANN_NORM_MINMAX); // 归一化到[0,1]

Dropout层

kann_layer_t *drop = kann_layer_dropout(model, 0.5f); // 50%丢弃率

模型预测

float *output = kann_apply1(model, input_data); // 单样本预测

多输入模型

kann_t *model = kann_new();
kann_layer_t *in1 = kann_layer_input(model, 10);
kann_layer_t *in2 = kann_layer_input(model, 20);
kann_layer_t *merge = kann_layer_concat(model, 2, in1, in2);

学习率调度

kann_set_learning_rate(model, 0.001f * pow(0.9, epoch)); // 指数衰减

早停机制

kann_train_fnn(model, ..., KANN_EARLY_STOP); // 启用早停

模型评估

float acc = kann_eval_fnn(model, test_data, test_labels, 0); // 计算准确率

批归一化层

kann_layer_t *bn = kann_layer_bnorm(model); // 批归一化

自定义优化器

kann_set_optimizer(model, KANN_OPT_ADAM); // 使用Adam优化器

混合精度训练

kann_enable_mixed_precision(model); // 启用FP16加速

模型剪枝

kann_prune(model, 0.3f); // 剪枝30%权重

模型可视化

kann_dot(model, "graph.dot"); // 生成DOT格式结构图

多任务学习

kann_t *model = kann_new();
kann_layer_t *shared = kann_layer_dense(model, 64, KANN_F_RELU);
kann_layer_t *task1 = kann_layer_cost(model, 1, KANN_C_MSE);
kann_layer_t *task2 = kann_layer_cost(model, 1, KANN_C_CE);

以上示例需结合具体数据和需求调整参数。KANN的轻量级特性使其适合嵌入式或资源受限场景，更多高级功能。

基于C++和OpenCV的实用案例

以下是一些基于C++和OpenCV的实用案例，涵盖图像处理、计算机视觉等常见任务。案例按功能分类，代码简洁可直接运行（需配置OpenCV环境）。

图像基本操作

读取/显示/保存图像
#include <opencv2/opencv.hpp>
using namespace cv;
int main() {Mat img = imread("image.jpg");imshow("Display", img);imwrite("output.jpg", img);waitKey(0);return 0;
}
灰度图转换
Mat gray;
cvtColor(img, gray, COLOR_BGR2GRAY);
调整亮度对比度
Mat adjusted;
img.convertTo(adjusted, -1, 1.5, 30); // alpha=1.5, beta=30

图像处理技术

边缘检测（Canny）
Mat edges;
Canny(img, edges, 50, 150);
直方图均衡化
Mat histEq;
equalizeHist(gray, histEq);
高斯模糊
GaussianBlur(img, img, Size(5,5), 0);

特征检测与匹配

SIFT特征点
Ptr<SIFT> sift = SIFT::create();
std::vector<KeyPoint> kp;
Mat desc;
sift->detectAndCompute(img, Mat(), kp, desc);
ORB特征匹配
Ptr<ORB> orb = ORB::create();
BFMatcher matcher(NORM_HAMMING);
std::vector<DMatch> matches;
matcher.match(desc1, desc2, matches);

对象识别与跟踪

Haar人脸检测
CascadeClassifier face_cascade;
face_cascade.load("haarcascade_frontalface_default.xml");
std::vector<Rect> faces;
face_cascade.detectMultiScale(gray, faces, 1.1, 3);
YOLOv3目标检测
Net net = readNet("yolov3.weights", "yolov3.cfg");
net.setInput(blob);
Mat detections = net.forward();

视频处理

读取摄像头帧
VideoCapture cap(0);
while (true) {Mat frame;cap >> frame;imshow("Camera", frame);if (waitKey(30) == 27) break;
}
视频背景减除
Ptr<BackgroundSubtractorMOG2> bg_model = createBackgroundSubtractorMOG2();
Mat fg_mask;
bg_model->apply(frame, fg_mask);

高级应用

图像拼接（Panorama）
Stitcher::Mode mode = Stitcher::PANORAMA;
Ptr<Stitcher> stitcher = Stitcher::create(mode);
stitcher->stitch(imgs, panorama);
AR标记检测（ArUco）
Ptr<aruco::Dictionary> dict = aruco::getPredefinedDictionary(aruco::DICT_6X6_250);
aruco::detectMarkers(img, dict, corners, ids);

实用工具

绘制文本
putText(img, "Hello", Point(50,50), FONT_HERSHEY_SIMPLEX, 1, Scalar(255,0,0), 2);
鼠标事件交互
setMouseCallback("Window", [](int event, int x, int y, int flags, void* userdata) {if (event == EVENT_LBUTTONDOWN) {circle(img, Point(x,y), 5, Scalar(0,0,255), -1);}
});

注意事项

  1. 所有案例需链接OpenCV库（如opencv_core, opencv_highgui等）
  2. 部分功能（如YOLO、SIFT）需额外模型文件
  3. OpenCV4.x中部分模块（如SIFT）需opencv_contrib支持

完整项目可参考OpenCV官方示例库或GitHub上的开源项目（如OpenCV-Cookbook）。

基于C++的YOLO（目标检测）

以下是基于C++的YOLO（目标检测）和SIFT（特征提取）的实例分类及实现方法。内容涵盖基础应用、进阶优化及实际场景案例，均以代码片段或逻辑描述呈现。

YOLO 实例

目标检测基础
// 示例1: 加载YOLOv3模型并检测图像中的对象
cv::dnn::Net net = cv::dnn::readNetFromDarknet("yolov3.cfg", "yolov3.weights");
cv::Mat img = cv::imread("image.jpg");
cv::Mat blob = cv::dnn::blobFromImage(img, 1/255.0, cv::Size(416, 416));
net.setInput(blob);
std::vector<cv::Mat> outputs;
net.forward(outputs, net.getUnconnectedOutLayersNames());
视频流处理
// 示例2: 实时摄像头YOLO检测
cv::VideoCapture cap(0);
while (true) {cv::Mat frame;cap >> frame;cv::Mat blob = cv::dnn::blobFromImage(frame, 1/255.0, cv::Size(416, 416));net.setInput(blob);net.forward(outputs, net.getUnconnectedOutLayersNames());// 绘制检测框逻辑
}
多线程推理
// 示例3: 使用异步加速推理
std::future<void> fut = std::async(std::launch::async, [&]() {net.forward(outputs, net.getUnconnectedOutLayersNames());
});
自定义对象训练
// 示例4: 训练YOLOv4-tiny自定义数据集
// 需准备darknet框架及配置文件
./darknet detector train data/obj.data cfg/yolov4-tiny-custom.cfg yolov4-tiny.weights
模型量化
// 示例5: 使用OpenVINO优化YOLO模型
cv::dnn::Net net = cv::dnn::readNet("yolov5.xml", "yolov5.bin");
net.setPreferableBackend(cv::dnn::DNN_BACKEND_INFERENCE_ENGINE);
ROS集成
// 示例6: 在ROS中发布YOLO检测结果
ros::Publisher pub = nh.advertise<sensor_msgs::Image>("detections", 10);
cv_bridge::CvImage cv_img;
cv_img.image = output_frame;
pub.publish(cv_img.toImageMsg());
边缘设备部署
// 示例7: 在Jetson Nano上运行YOLOv5
// 需使用TensorRT引擎转换模型
nvinfer1::ICudaEngine* engine = runtime->deserializeCudaEngine(trtModelStream);

性能评估

// 示例8: 计算mAP指标
./darknet detector map data/obj.data cfg/yolov3.cfg yolov3.weights

非极大值抑制优化

// 示例9: 自定义NMS阈值
void NMSBoxes(const std::vector<cv::Rect>& boxes, float score_threshold, float nms_threshold) {cv::dnn::NMSBoxes(boxes, scores, score_threshold, nms_threshold, indices);
}

多尺度检测

// 示例10: 多尺度输入提升小目标检测
std::vector<cv::Mat> pyramid;
cv::buildPyramid(img, pyramid, 3);
for (auto& level : pyramid) {cv::Mat blob = cv::dnn::blobFromImage(level, 1/255.0, cv::Size(416, 416));net.setInput(blob);net.forward(outputs);
}

类别过滤

// 示例11: 只检测特定类别（如行人）
if (class_ids[i] == 0) {  // COCO数据集中0为personcv::rectangle(img, boxes[i], cv::Scalar(0,255,0), 2);
}

模型剪枝

// 示例12: 使用Torch-Pruning裁剪YOLO模型
prune_model(model, 0.3);  // 裁剪30%的通道

TensorRT加速

// 示例13: 转换ONNX模型为TensorRT引擎
trtexec --onnx=yolov5s.onnx --saveEngine=yolov5s.trt --fp16

动态输入支持

// 示例14: 处理可变分辨率输入
net.enableWinograd(false);  // 关闭Winograd加速以支持动态尺寸

异常处理

// 示例15: 模型加载失败检测
if (net.empty()) {std::cerr << "Failed to load model" << std::endl;return -1;
}

SIFT 实例

特征提取基础
// 示例16: 提取SIFT特征点
cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
sift->detectAndCompute(img, cv::noArray(), keypoints, descriptors);
特征匹配
// 示例17: 暴力匹配器
cv::BFMatcher matcher(cv::NORM_L2);
std::vector<cv::DMatch> matches;
matcher.match(descriptors1, descriptors2, matches);

RANSAC筛选
// 示例18: 几何一致性验证
std::vector<cv::Point2f> points1, points2;
cv::Mat H = cv::findHomography(points1, points2, cv::RANSAC, 5.0);

图像拼接
// 示例19: 全景图生成
cv::Stitcher stitcher = cv::Stitcher::createDefault();
cv::Mat panorama;
stitcher.stitch(images, panorama);
3D重建
// 示例20: 从匹配点计算深度
cv::triangulatePoints(P1, P2, points1, points2, points4D);
相机位姿估计
// 示例21: 求解PnP问题
cv::solvePnP(object_points, image_points, camera_matrix, dist_coeffs, rvec, tvec);
特征点可视化
// 示例22: 绘制关键点
cv::drawKeypoints(img, keypoints, out_img, cv::Scalar(0,0,255), cv::DrawMatchesFlags::DRAW_RICH_KEYPOINTS);
描述子聚类
// 示例23: 构建视觉词袋
cv::BOWKMeansTrainer bow_trainer(100);  // 100个聚类中心
bow_trainer.add(descriptors);
cv::Mat vocabulary = bow_trainer.cluster();
实时跟踪
// 示例24: 基于特征点的光流跟踪
cv::calcOpticalFlowPyrLK(prev_img, next_img, prev_pts, next_pts, status, err);
多模态匹配
// 示例25: 红外与可见光图像配准
cv::xfeatures2d::matchGMS(img1.size(), img2.size(), keypoints1, keypoints2, matches);
GPU加速
// 示例26: 使用CUDA加速SIFT
cv::cuda::SIFT_CUDA sift_gpu;
sift_gpu.detectAndComputeAsync(gpu_img, cv::noArray(), gpu_kpts, gpu_desc);
尺度不变验证
// 示例27: 验证特征点尺度响应
if (keypoints[i].octave > 2) {  // 过滤低尺度特征filtered_kpts.push_back(keypoints[i]);
}
动态场景处理
// 示例28: 运动目标分割
cv::absdiff(prev_frame, curr_frame, diff_frame);
cv::threshold(diff_frame, mask, 25, 255, cv::THRESH_BINARY);
嵌入式部署
// 示例29: 在树莓派上优化SIFT
cv::SIFT::create(0, 3, 0.04, 10);  // 减少特征点数量
异常检测
// 示例30: 匹配质量评估
double max_dist = *std::max_element(matches.begin(), matches.end());
if (max_dist > 300) {std::cout << "Low matching quality" << std::endl;
}

以上实例均需依赖OpenCV（建议4.5+版本）及相关扩展库实现。实际应用时需根据硬件环境调整参数，部分高阶功能需要额外配置CUDA或OpenCL支持。

基于C++ Armadillo库的实例

以下是基于C++ Armadillo库的实用示例，涵盖矩阵操作、线性代数、统计计算等常见场景。所有示例需包含<armadillo>头文件，并使用arma命名空间。

基础矩阵操作

创建矩阵并初始化
arma::mat A = {{1, 2}, {3, 4}};  // 2x2矩阵
arma::mat B = arma::randu(3, 4); // 3x4随机矩阵
arma::mat C = arma::eye(5, 5);   // 5x5单位矩阵
矩阵转置
arma::mat D = A.t();  // 转置
矩阵乘法
arma::mat E = A * B;  // 矩阵乘法（需维度匹配）
逐元素操作
arma::mat F = A % B;  // 逐元素乘法
arma::mat G = A + B;  // 逐元素加法
矩阵求逆
arma::mat H = arma::inv(A);  // 逆矩阵（需方阵）

线性代数运算

解线性方程组
arma::vec b = {5, 6};
arma::vec x = arma::solve(A, b);  // Ax = b
特征值与特征向量
arma::cx_vec eigval;
arma::cx_mat eigvec;
arma::eig_gen(eigval, eigvec, A);  // 广义特征分解
奇异值分解（SVD）
arma::mat U, V;
arma::vec s;
arma::svd(U, s, V, A);  // A = U*diagmat(s)*V.t()
Cholesky分解
arma::mat L = arma::chol(A, "lower");  // A需对称正定

统计计算

计算均值与方差
double mean_val = arma::mean(A);
double var_val = arma::var(A);
矩阵行列式
double det_val = arma::det(A);
矩阵迹
double trace_val = arma::trace(A);
相关系数矩阵
arma::mat corr_mat = arma::cor(B);

高级操作

矩阵拼接
arma::mat J = arma::join_rows(A, B);  // 水平拼接
arma::mat K = arma::join_cols(A, B);  // 垂直拼接
矩阵重塑
arma::mat L = arma::reshape(A, 4, 1);  // 重塑为4x1向量
条件筛选
arma::uvec idx = find(A > 2);  // 返回满足条件的索引
arma::mat M = A.elem(idx);     // 提取对应元素
保存与加载矩阵
A.save("matrix.bin", arma::arma_binary);  // 二进制保存
arma::mat N;
N.load("matrix.bin");  // 二进制加载

稀疏矩阵操作

创建稀疏矩阵
arma::sp_mat S(100, 100);
S(1, 2) = 3.0;  // 设置非零元素
稀疏矩阵乘法
arma::sp_mat T = S * S.t();  // 稀疏矩阵乘法
稀疏矩阵求解
arma::vec y = arma::spsolve(S, b);  // 稀疏求解器

性能优化

预分配内存
arma::mat P;
P.set_size(1000, 1000);  // 预分配内存
多线程加速
arma::mat Q = arma::randn(1000, 1000);
arma::mat R = Q * Q.t();  // 自动使用OpenMP多线程（需编译支持）

实用函数

生成序列
arma::vec seq = arma::linspace(0, 10, 100);  // 0到10的100个等间隔点
随机数生成
arma::mat rand_mat = arma::randn(5, 5);  // 标准正态分布
复数矩阵
arma::cx_mat Z = arma::randu<arma::cx_mat>(3, 3);  // 复数随机矩阵
逻辑运算
arma::umat logic = (A > B);  // 返回布尔矩阵
按索引访问
double elem = A(1, 1);  // 访问(1,1)元素

Armadillo 基础矩阵操作

以下示例展示如何在 C++ 中使用 Armadillo 进行基础的矩阵创建和运算：

#include <armadillo>
using namespace arma;// 创建 3x3 单位矩阵
mat A = eye<mat>(3, 3);// 创建随机矩阵（范围 0-1）
mat B = randu<mat>(3, 3);// 矩阵乘法
mat C = A * B;// 逐元素乘法
mat D = A % B;// 输出结果
cout << "Matrix C:\n" << C << endl;
cout << "Matrix D:\n" << D << endl;

解线性方程组

使用 solve() 函数求解线性方程组 ( Ax = b )：

mat A = {{1, 2}, {3, 4}};
vec b = {5, 6};
vec x = solve(A, b);cout << "Solution x:\n" << x << endl;

特征值与特征向量

计算矩阵的特征值和特征向量：

mat A = randu<mat>(5, 5);
cx_vec eigval;
mat eigvec;eig_gen(eigval, eigvec, A);cout << "Eigenvalues:\n" << eigval << endl;
cout << "Eigenvectors:\n" << eigvec << endl;

奇异值分解（SVD）

分解矩阵为 ( U \Sigma V^T )：

mat A = randu<mat>(4, 5);
mat U, V;
vec s;svd(U, s, V, A);cout << "Singular values:\n" << s << endl;

矩阵求逆

使用 inv() 函数求逆矩阵：

mat A = randu<mat>(3, 3);
mat A_inv = inv(A);cout << "Inverse of A:\n" << A_inv << endl;

矩阵伪逆

对于非方阵或病态矩阵，使用 pinv()：

mat A = randu<mat>(2, 3);
mat A_pinv = pinv(A);cout << "Pseudoinverse of A:\n" << A_pinv << endl;

Cholesky 分解

对对称正定矩阵进行分解：

mat A = randu<mat>(5, 5);
mat L = chol(A); // A = L^T * Lcout << "Cholesky factor L:\n" << L << endl;

QR 分解

分解矩阵为 ( Q ) 和 ( R )：

mat A = randu<mat>(4, 4);
mat Q, R;qr(Q, R, A);cout << "Q matrix:\n" << Q << endl;
cout << "R matrix:\n" << R << endl;

LU 分解

分解矩阵为 ( P ), ( L ), 和 ( U )：

mat A = randu<mat>(4, 4);
mat P, L, U;lu(P, L, U, A);cout << "Lower triangular L:\n" << L << endl;
cout << "Upper triangular U:\n" << U << endl;

矩阵范数

计算矩阵的 1-范数、2-范数和 Frobenius 范数：

mat A = randu<mat>(3, 3);
double norm1 = norm(A, 1);  // 1-范数
double norm2 = norm(A, 2);  // 2-范数
double normF = norm(A, "fro"); // Frobenius 范数cout << "1-Norm: " << norm1 << endl;
cout << "2-Norm: " << norm2 << endl;
cout << "Frobenius Norm: " << normF << endl;

矩阵拼接

水平或垂直拼接矩阵：

mat A = randu<mat>(2, 2);
mat B = randu<mat>(2, 2);mat C = join_horiz(A, B); // 水平拼接
mat D = join_vert(A, B);  // 垂直拼接cout << "Horizontal concatenation:\n" << C << endl;
cout << "Vertical concatenation:\n" << D << endl;

子矩阵提取

提取矩阵的子块或特定行/列：

mat A = randu<mat>(5, 5);
mat B = A.submat(1, 1, 3, 3); // 提取 1:3 行和 1:3 列
vec col = A.col(0);           // 提取第 0 列
vec row = A.row(1);           // 提取第 1 行cout << "Submatrix B:\n" << B << endl;
cout << "First column:\n" << col << endl;
cout << "Second row:\n" << row << endl;

矩阵转置

转置矩阵或共轭转置：

mat A = randu<mat>(3, 2);
mat B = A.t();  // 普通转置
mat C = A.st(); // 共轭转置（复数矩阵）cout << "Transpose of A:\n" << B << endl;

矩阵逐元素函数

应用逐元素函数（如指数、对数）：

mat A = randu<mat>(3, 3);
mat B = exp(A); // 逐元素指数
mat C = log(A); // 逐元素自然对数cout << "Element-wise exp:\n" << B << endl;
cout << "Element-wise log:\n" << C << endl;

统计操作

计算矩阵的均值、方差等统计量：

mat A = randu<mat>(4, 4);
double mean_val = mean(mean(A)); // 整体均值
vec col_means = mean(A, 0);      // 列均值
vec row_means = mean(A, 1);      // 行均值cout << "Overall mean: " << mean_val << endl;
cout << "Column means:\n" << col_means << endl;
cout << "Row means:\n" << row_means << endl;

稀疏矩阵操作

创建和操作稀疏矩阵：

sp_mat A(5, 5); // 5x5 稀疏矩阵
A(1, 2) = 3.0;  // 设置非零元素
A(3, 4) = 4.0;mat B = randu<mat>(5, 5);
sp_mat C = sp_mat(B); // 稠密矩阵转稀疏矩阵cout << "Sparse matrix A:\n" << A << endl;

矩阵重新整形

改变矩阵的维度但不改变元素总数：

http://www.xdnf.cn/news/16445.html

相关文章：

  • Flutter开发实战之原生平台集成
  • Flutter开发实战之动画与交互设计
  • 06-ES6
  • Ubuntu22.04提示找不到python命令的解决方案
  • Java 注解（Annotation）详解：从基础到实战，彻底掌握元数据驱动开发
  • 微信小程序 自定义带图片弹窗
  • Windows Server容器化应用的资源限制设置
  • 用户中心项目部署上线03
  • 基于FPGA的SPI控制FLASH读写
  • 服务器：数字世界的隐形引擎
  • JavaScript里的string
  • 使用Python实现单词记忆软件
  • Zookeeper的简单了解
  • 兼容性问题记录
  • Baumer工业相机堡盟工业相机如何通过YoloV8深度学习模型实现轮船检测识别（C#代码UI界面版）
  • 【C/C++】Undefined reference: memset_s
  • 港股历史逐笔十档分钟级订单簿行情数据分析
  • 黑屏运维OceanBase数据库的常见案例
  • 【算法】前缀和经典例题
  • Kubernetes 监控完全指南：PromQL 通用查询与最佳实践
  • Claude 4.0 终极编程指南：模型对比、API配置与IDE集成实战
  • 深度解析【JVM】三大核心架构：运行时数据区、类加载与垃圾回收机制
  • OGG同步Oracle到Kafka不停库,全量加增量
  • 《汇编语言：基于X86处理器》第9章 编程练习
  • 新房装修是中央空调还是壁挂空调好？
  • 背包DP之完全背包
  • Agentic RAG理解和简易实现
  • UG创建的实体橘黄色实体怎么改颜色？
  • HCIP上HCIA复习静态综合实验
  • 【Java、C、C++、Python】飞机订票系统---文件版本