并行矩阵乘法（C++ mpi 并行实现）

news2025/1/26 15:43:33

矩阵乘法有2种思路，我最先想到的是第一种思路，但是时间、空间复杂度都比较高。后面参考了一些资料，实现了第二种思路。

一、思路1：按行、列分块

矩阵乘法有一个很好的性质，就是结果矩阵的每个元素是不互相依赖的，因此我们可以很好地实现并行。

假如想要计算的矩阵如下：

在这里插入图片描述

如果有8个进程，0号进程用于数据分发，其它进程用于计算，具体的分块如下图所示：

在这里插入图片描述

但是这种思路实现后会报错 Out of memory，具体原因后面分析。

在这里插入图片描述

思路1因为只传递了单行的数组，而二维vector单行数组是连续的，因此这里直接用二维vector表示矩阵就可以，代码如下：

#include <stdio.h>
#include <mpi.h>
#include<iostream>
#include<vector>
#include <cstdlib>
using namespace std;

int main(int argc, char* argv[])

{
    int myrank, processNum; // myrank: 进程号; processNum: 进程总数
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    int namelen;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
    MPI_Comm_size(MPI_COMM_WORLD, &processNum);
    MPI_Get_processor_name(processor_name, &namelen); // 获取处理器名称

    double startTime, endTime; // 开始时间和结束时间

    // 如果是 0 号进程，随机初始化矩阵数据
    int row = 3000, middleColumn = 200, column = 300; // 矩阵 A 的行数、矩阵 A 的列数和 B 的行数、矩阵 B 的行数
    if (myrank == 0) { // 地主进程
        vector<vector<int>> A(row, vector<int>(middleColumn));
        vector<vector<int>> B(middleColumn, vector<int>(column));
        // 随机初始化矩阵 A 和 B
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < middleColumn; j++) {
				A[i][j] = rand() % 10;
			}
		}
        for (int i = 0; i < middleColumn; i++) {
            for (int j = 0; j < column; j++) {
                B[i][j] = rand() % 10;
            }
        }

        // 打印矩阵 A 和 B
  //      cout << "A:" << endl;
  //      for (int i = 0; i < row; i++) {
		//	cout << "    ";
  //          for (int j = 0; j < middleColumn; j++) {
		//		cout << A[i][j] << " ";
		//	}
		//	cout << endl;
		//}

  //      cout << "B:" << endl;
  //      for (int i = 0; i < middleColumn; i++) {
  //          cout << "    ";
  //          for (int j = 0; j < column; j++) {
		//		cout << B[i][j] << " ";
		//	}
  //          cout << endl;
  //      }


        startTime = MPI_Wtime(); // 开始计时
        int farmersProcessNum = processNum - 1; // 农民进程数
        // 分发矩阵 A 和 B
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                int destProcess = (i * row + j) % farmersProcessNum + 1; // 目标进程号
                MPI_Send(A[i].data(), middleColumn, MPI_INT, destProcess, 0, MPI_COMM_WORLD);
                vector<int> BColumn(middleColumn);
                for (int k = 0; k < middleColumn; k++) {
					BColumn[k] = B[k][j];
				}
                MPI_Send(BColumn.data(), middleColumn, MPI_INT, destProcess, 0, MPI_COMM_WORLD);
            }
        }
    }
    else { // 农民进程 (进程号 > 0 的进程)
        int count = (row * column) / (processNum - 1);      // 每个进程计算的数量
        int remainder = (row * column) % (processNum - 1);  // 均分后多出来的待计算数
        if (myrank <= remainder) {
			count++;
		}
        
        for (int i = 0; i < count; i++) {
            // 接收矩阵 ARow 和 BColumn
            vector<int> ARow(middleColumn);
            vector<int> BColumn(middleColumn);
            MPI_Recv(ARow.data(), middleColumn, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            MPI_Recv(BColumn.data(), middleColumn, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            // 计算矩阵乘法
            int result = 0;
            for (int j = 0; j < middleColumn; j++) {
                result += ARow[j] * BColumn[j];
            }
            // 发送计算结果
            MPI_Send(&result, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
        }
    }

    // 收集计算结果
    if (myrank == 0) {
		vector<vector<int>> C(row, vector<int>(column));
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                // 计算农民进程的数量
                int farmersProcessNum = processNum - 1;
                // 计算接收的进程号
                int sourceProcess = (i * row + j) % farmersProcessNum + 1;
                MPI_Recv(&C[i][j], 1, MPI_INT, sourceProcess, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
            }
        }
        endTime = MPI_Wtime(); // 结束计时

        // 打印矩阵 C
        //cout << "C:" << endl;
        //for (int i = 0; i < row; i++) {
        //    cout << "    ";
        //    for (int j = 0; j < column; j++) {
        //        cout << C[i][j] << " ";
        //    }
        //    cout << endl;
        //}

        // 打印计算时间
        cout << "Time: " << endTime - startTime << "s" << endl;
    }


    MPI_Finalize();

    return 0;
}

二、思路2：矩阵分块乘法

如果我们想要计算的矩阵如下：

在这里插入图片描述

同时，如果我们采用4个进程来计算这个矩阵乘法，0号进程用于数据分发，其它进程用于计算，如图：

在这里插入图片描述

1维数组表示2维数组

思路2的算法实现，由于我们进行MPI_Send发送数组的时候，必须提供一个连续地址的数组的首地址，而思路2不同于思路1只发送1行数据，它是要发送多行的。

这就要求我们不可以使用二维数组来实现，因为二维数组不同行的首尾地址并不是连续的。具体见这篇文章：https://blog.csdn.net/weixin_44560698/article/details/120566680.

所以，这里我们使用1维数组，表示2维数组，代码如下：

#include<iostream>
#include<vector>
#include<mpi.h>

using namespace std;

// 输入：两个一维vector，表示矩阵，输出矩阵的row，middleColumn，column
// 输出：一维vector，表示两个输入vector的乘积
vector<int> matrixMultiplication(vector<int> A, vector<int> B, int row, int middleColumn, int column) {
	vector<int> res(row * column);
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < column; j++) {
			int tmp = 0;
			for (int k = 0; k < middleColumn; k++) {
				// A[i][k] * B[k][j]
				tmp += A[i * middleColumn + k] * B[k * column + j];
			}
			// res[i][j] = tmp
			res[i * column + j] = tmp;
		}
	}
	return res;
}


int main(int argc, char* argv[])

{

	int myrank, processNum;
	char processor_name[MPI_MAX_PROCESSOR_NAME];
	int namelen;

	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
	MPI_Comm_size(MPI_COMM_WORLD, &processNum);
	MPI_Get_processor_name(processor_name, &namelen);

	// 如果是 0 号进程，随机初始化矩阵数据
	int row = 3000, middleColumn = 2000, column = 3000;
	int farmerProcessNum = processNum - 1; // farmer 进程的数量
	int chunkSize = row / farmerProcessNum; // 每个 farmer 进程处理的行数
	int chunkSizeRemainder = row % farmerProcessNum; // 均分后的余数
	double startTime, endTime; // 记录开始和结束时间
	if (myrank == 0) { // 地主进程
		vector<int> A(row * middleColumn);
		vector<int> B(middleColumn * column);
		// 随机初始化矩阵 A 和 B
		for (int i = 0; i < row * middleColumn; i++) {
			A[i] = rand() % 10;
		}
		for (int i = 0; i < middleColumn * column; i++) {
			B[i] = rand() % 10;
		}

		// 打印矩阵 A 和 B
		//cout << "A:" << endl;
		//for (int i = 0; i < row; i++) {
		//	cout << "    ";
		//	for (int j = 0; j < middleColumn; j++) {
		//		cout << A[i * middleColumn + j] << " ";
		//	}
		//	cout << endl;
		//}

		//cout << "B:" << endl;
		//for (int i = 0; i < middleColumn; i++) {
		//	cout << "    ";
		//	for (int j = 0; j < column; j++) {
		//		cout << B[i * column + j] << " ";
		//	}
		//	cout << endl;
		//}

		// 记录程序开始时间
		startTime = MPI_Wtime();

		int startRow = 0, endRow = 0; // 每个 farmer 进程处理的起始行和结束行

		// 将矩阵 A 和 B 分发给其他进程
		for (int i = 1; i < processNum; i++) {
			// 计算下一个进程处理的结束行
			endRow = startRow + chunkSize - 1;
			if (i <= chunkSizeRemainder) {
				endRow++;
			}

			int tmpRow = endRow - startRow + 1;
			// 将矩阵 A 部分的数据分发给其他进程
			MPI_Send(A.data() + startRow * middleColumn, tmpRow * middleColumn, MPI_INT, i, 0, MPI_COMM_WORLD);
			// 将矩阵 B 所有的数据分发给其他进程
			MPI_Send(B.data(), middleColumn * column, MPI_INT, i, 0, MPI_COMM_WORLD);
			// 更新下一个进程处理的起始行
			startRow = endRow + 1;
		}
	}
	else { // 农民进程 (进程号 >= 1)
		// 计算行数
		int tmpRow = chunkSize;

		if (myrank <= chunkSizeRemainder) {
			tmpRow++;
		}

		// 计算列数
		int tmpColumn = column;
		// 计算中间列数
		int tmpMiddleColumn = middleColumn;

		// 接收矩阵 A 的数据
		vector<int> A(tmpRow * tmpMiddleColumn);
		MPI_Recv(A.data(), tmpRow * tmpMiddleColumn, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

		// 接收矩阵 B 的数据
		vector<int> B(tmpMiddleColumn * tmpColumn);
		MPI_Recv(B.data(), tmpMiddleColumn * tmpColumn, MPI_INT, 0, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);

		// 计算矩阵乘法
		vector<int> res = matrixMultiplication(A, B, tmpRow, tmpMiddleColumn, tmpColumn);

		// 将计算结果返回给 0 号进程
		MPI_Send(res.data(), tmpRow * tmpColumn, MPI_INT, 0, 0, MPI_COMM_WORLD);
	}

	// 0 号进程接收其他进程的计算结果
	if (myrank == 0) {
		vector<int> res(row * column);
		int startRow = 0, endRow = 0; // 每个 farmer 进程处理的起始行和结束行
		for (int i = 1; i < processNum; i++) {
			// 计算下一个进程处理的结束行
			endRow = startRow + chunkSize - 1;
			if (i <= chunkSizeRemainder) {
				endRow++;
			}
			int tmpRow = endRow - startRow + 1;
			// 将矩阵 A 部分的数据分发给其他进程
			MPI_Recv(res.data() + startRow * column, tmpRow * column, MPI_INT, i, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
			// 更新下一个进程处理的起始行
			startRow = endRow + 1;
		}

		// 记录程序结束时间
		endTime = MPI_Wtime();
		
		// 打印计算结果
		//cout << "res:" << endl;
		//for (int i = 0; i < row; i++) {
		//	cout << "    ";
		//	for (int j = 0; j < column; j++) {
		//		cout << res[i * column + j] << " ";
		//	}
		//	cout << endl;
		//}

		// 打印计算时间
		cout << "Time: " << endTime - startTime << "s" << endl;
	}

	MPI_Finalize();

	return 0;

}

三、算法性能对比

1. 时间复杂度

思路一 300 × 200 300\times 200 300×200 和 200 × 300 200 \times 300 200×300 相乘所耗费的时间为8.83s。

在这里插入图片描述

相同规模的矩阵相乘，思路2的时间是0.07s。

在这里插入图片描述

可以看到差距还是很大的。

我们再来看一下串行程序的运行时间：

在这里插入图片描述
串行程序的运行时间是0.321s，看来如果我们采用思路一的并行方法就真有点得不偿失了。

这里给出我写的串行代码：

#include<iostream>
#include<vector>

using namespace std;

// 输入：两个一维vector，表示矩阵，输出矩阵的row，middleColumn，column
// 输出：一维vector，表示两个输入vector的乘积
vector<int> matrixMultiplication(vector<int> A, vector<int> B, int row, int middleColumn, int column) {
	vector<int> res(row * column);
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < column; j++) {
			int tmp = 0;
			for (int k = 0; k < middleColumn; k++) {
				// A[i][k] * B[k][j]
				tmp += A[i * middleColumn + k] * B[k * column + j];
			}
			// res[i][j] = tmp
			res[i * column + j] = tmp;
		}
	}
	return res;
}

int main() {
	// 矩阵 A 的行数、矩阵 A 的列数和 B 的行数、矩阵 B 的行数
	int row = 300, middleColumn = 200, column = 300;
	vector<int> A(row * middleColumn);
	vector<int> B(middleColumn * column);
	// 随机初始化矩阵 A 和 B
	for (int i = 0; i < row * middleColumn; i++) {
		A[i] = rand() % 10;
	}
	for (int i = 0; i < middleColumn * column; i++) {
		B[i] = rand() % 10;
	}
	// 记录开始和结束时间
	double startTime, endTime;
	startTime = clock();
	vector<int> res = matrixMultiplication(A, B, row, middleColumn, column);
	endTime = clock();
	cout << "Time: " << (endTime - startTime) / CLOCKS_PER_SEC << "s" << endl;
	// 输出 res
	//for (int i = 0; i < row; i++) {
	//	for (int j = 0; j < column; j++) {
	//		cout << res[i * column + j] << " ";
	//	}
	//	cout << endl;
	//}
	//cout << endl;
}

我们将矩阵的大小扩大10倍，再来看：

思路1运行时间：

在这里插入图片描述

可以看到思路1直接out of memory了，其实是在意料之中的，具体原因可以看文章最后一部分 四、复杂度分析 。

思路2运行时间：

在这里插入图片描述

串行运行时间：

在这里插入图片描述

2. 空间复杂度

四、复杂度分析

首先，我们设：

r o w : 矩阵 A 行数 row:矩阵A行数 row:矩阵A行数

m i d d l e C o l u m n : 矩阵 A 列数和矩阵 B 行数 middleColumn:矩阵A列数和矩阵B行数 middleColumn:矩阵A列数和矩阵B行数

c o l u m n : 矩阵 B 列数 column:矩阵B列数 column:矩阵B列数

f a r m e r P r o c e s s N u m : 农民进程数 farmerProcessNum:农民进程数 farmerProcessNum:农民进程数

由于mpi主要是在并行程序之间进行通信。

对于思路1，是每次计算结果矩阵的一个元素，因此，它的总发送的数据量如下：

r o w × c o l u m n × m i d d l e C o l u m n 2 ( i n t ) row\times column \times middleColumn^2\quad (int) row×column×middleColumn2(int)

对于思路2，总发送的是A矩阵的所有+B矩阵的全部乘以进程数(因为每次都要发送B矩阵)，如下：

r o w × m i d d l e C o l u m n + f a r m e r P r o c e s s N u m × m i d d l e C o l u m n × c o l u m n row\times middleColumn+farmerProcessNum\times middleColumn\times column row×middleColumn+farmerProcessNum×middleColumn×column

我们带入 r o w = 3000 , m i d d l e C o l u m n = 2000 , c o l u m n = 3000 row=3000,middleColumn=2000,column=3000 row=3000,middleColumn=2000,column=3000来计算一下上述思路1需要传输的内存：
r o w × c o l u m n × m i d d l e C o l u m n 2 ( i n t ) = 3000 × 3000 × 2000 × 2000 ( i n t ) = 36 0000 0000 0000 ( i n t ) = 4 × 36 0000 0000 0000 ( B y t e ) ≈ 131 ( T B ) \begin{aligned} &row\times column \times middleColumn^2\quad (int) \\ =&3000\times 3000 \times 2000\times 2000\quad (int) \\ =&36\quad 0000\quad 0000\quad 0000\quad (int) \\ =&4\times 36 \quad 0000\quad 0000\quad 0000\quad (Byte)\\ \approx&131 \quad (TB) \end{aligned} ===≈​row×column×middleColumn2(int)3000×3000×2000×2000(int)36000000000000(int)4×36000000000000(Byte)131(TB)​

具体转化结果如下：
在这里插入图片描述

传输的数据不管是传给哪个进程都是要放在内存里的，因此这种方式的空间数量级根本不可取= =。

再来看下思路2：

r o w × m i d d l e C o l u m n + f a r m e r P r o c e s s N u m × m i d d l e C o l u m n × c o l u m n ( i n t ) = 3000 × 2000 + 7 × 2000 × 3000 ( i n t ) = 4800 0000 ( i n t ) = 19200 0000 ( B y t e ) \begin{aligned} &row\times middleColumn+farmerProcessNum\times middleColumn\times column \quad (int) \\ =&3000\times 2000+7 \times 2000 \times 3000 \quad (int) \\ =&4800\quad 0000 \quad (int) \\ =&19200 \quad 0000 \quad (Byte) \end{aligned} ===​row×middleColumn+farmerProcessNum×middleColumn×column(int)3000×2000+7×2000×3000(int)48000000(int)192000000(Byte)​

在这里插入图片描述

可以看到 思路2 消耗的内存仅有 183MB ，与 思路1 的 131TB 的空间复杂度完全不在一个数量级。

结论：所以对于矩阵并行乘法，思路1是不可行的，至少也是应该是采用思路2来进行实现的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/924267.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

如何快速开发一个软件？这篇文章讲明白了

如何快速开发一个软件？这篇文章讲明白了

在当今快节奏的数字化世界中&#xff0c;软件开发已成为企业和个人必不可少的一环。然而&#xff0c;传统的软件开发流程往往耗时费力&#xff0c;需要大量的编码和测试工作。幸运的是&#xff0c;现代技术已经带来了许多创新的方式来加速软件开发过程。其中&#xff0c;利用简…
阅读更多...
使用ChatGPT创造商业价值变现的思路 | 纯分享

使用ChatGPT创造商业价值变现的思路 | 纯分享

​ 谷歌的Bard和OpenAI的ChatGPT等人工智能工具风靡全球。尽管关于AI如何以及是否应该被广泛使用&#xff0c;甚至关于它们是否真正具有“智能”这一说法&#xff0c;仍存在许多争议和激烈的讨论&#xff0c;但是这些工具早已潜移默化地出现在我们身边。 最大的原因之一在于这…
阅读更多...
总结：Git 撤销操作

总结：Git 撤销操作

1、还未添加到暂存区&#xff1a;git checkout -- filename 执行命令后&#xff0c;会回退到未修改之前的状态 2、已经添加到暂存区&#xff1a;git reset HEAD filename 执行命令后&#xff0c;会回退到工作区之前的状态 3、已经 commit&#xff0c;但是还未 push git reset…
阅读更多...
lab6 cow

lab6 cow

task cow的目标就是延迟分配&#xff0c;并且直到必须要复制的时候才会分配物理内存 cow的fork只为child创造了一个页表&#xff0c;其中的PTE指向了父进程的物理页面cow的fork将父进程和孩子进程的用户态的PTE都标记为不可写当某个进程想要去写一个cow的页面时&#xff0c;c…
阅读更多...
MyBatis 框架的搭建及使用

MyBatis 框架的搭建及使用

目录 什么是 MyBatisMyBatis 环境的搭建添加 MyBatis 依赖设置 MyBatis 配置 根据 MyBatis 写法完成数据库操作查询操作(无参)定义接口使用 XML 实现接口类中的属性名与数据库表中字段名不一致怎么办 ? 查询操作(有参)${} 和 #{} 有啥区别 ?使用 ${} 会出现的问题like 查询 删…
阅读更多...
CypherRAT、CraxsRATAndroid系列恶意软件“始作俑者”曝光！

CypherRAT、CraxsRATAndroid系列恶意软件“始作俑者”曝光！

近日&#xff0c;恶意软件系列 CypherRAT 和 CraxsRAT 的创建者曝光&#xff0c;是一位名为 EVLF 的叙利亚威胁行为者。 网络安全公司Cyfirma在上周发布的一份报告中提到&#xff1a;这些RAT旨在允许攻击者远程执行实时操作&#xff0c;并控制受害者设备的摄像头、位置和麦克风…
阅读更多...
职场的心灵疗愈：如何战胜压力与燃尽？

职场的心灵疗愈：如何战胜压力与燃尽？

职场压力的根源 当代职场的变革与挑战 在数字化时代，职场的变革速度前所未有。新的技术和工具不断涌现，要求员工持续学习和适应。例如，云计算、大数据和人工智能等技术正在改变许多行业的工作方式。这些技术为我们带来了便利，但同时也带来了学习和适应的压力。 此外，全球…
阅读更多...
keepalived+lvs（DR）（四十六）

keepalived+lvs（DR）（四十六）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 目录 前言 一、作用 二、调度器配置 三、web节点配置 一、作用 使用keepalived解决lvs的单点故障 高可用集群 二、调度器配置 安装keepalived yum install -y k…
阅读更多...
leetcode：电话号码的字母组合（详解）

leetcode：电话号码的字母组合（详解）

题目 给定一个仅包含数字 2-9 的字符串&#xff0c;返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下&#xff08;与电话按键相同&#xff09;。注意 1 不对应任何字母。 示例 1&#xff1a; 输入&#xff1a;digits "23" 输出…
阅读更多...
基于javaweb的新生报到系统

基于javaweb的新生报到系统

摘 要 随着信息技术和网络技术的飞速发展&#xff0c;人类已进入全新信息化时代&#xff0c;传统管理技术已无法高效&#xff0c;便捷地管理信息。为了迎合时代需求&#xff0c;优化管理效率&#xff0c;各种各样的管理系统应运而生&#xff0c;各行各业相继进入信息管理时代&…
阅读更多...
用Idea把SpringBoot项目打包镜像上传至docker

用Idea把SpringBoot项目打包镜像上传至docker

1、设置docker把2375端口开起来 命令查看docker装在哪里 vim docker.service 新增 -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock 2、配置Dockerfile 我在跟pom同一层 3、配置docker-maven-plugin <plugin><groupId>com.spotify</groupId><arti…
阅读更多...
LAMP架构介绍配置命令讲解

LAMP架构介绍配置命令讲解

LAMP架构介绍配置命令讲解 一、LAMP架构介绍1.1概述1.2LAMP各组件的主要作用1.3各组件的安装顺序 二、编译安装Apache httpd服务---命令讲解1、关闭防火墙&#xff0c;将安装Apache所需的软件包传到/opt/目录下2、安装环境依赖包3、配置软件模块4、编译安装5、优化配置文件路径…
阅读更多...
API接口管理平台：提高开发效率和节省时间的解决方案

API接口管理平台：提高开发效率和节省时间的解决方案

随着互联网的迅速发展&#xff0c;很多业务已经可以通过API接口实现&#xff0c;使得开发者可以更快速地开发出高质量的软件。然而&#xff0c;随着API数量的增加&#xff0c;管理这些API也变得尤为困难。因此&#xff0c;API接口管理平台应运而生。本文将探讨如何使用API接口管…
阅读更多...
中国人民大学与加拿大女王大学合办金融硕士毕业证书是双证么？

中国人民大学与加拿大女王大学合办金融硕士毕业证书是双证么？

中国人民大学与加拿大女王大学合办金融硕士毕业证书是双证么&#xff1f; 无需参加全国联考获国家承认双证中国教育部留学服务中心可认证 是的 双证的 学位授予 1、完成本项目十门课程&#xff0c;通过考核符合毕业要求的学生将获得由女王大学颁发的金融硕士学位证书&#x…
阅读更多...
论文笔记： MOGRIFIER LSTM

论文笔记： MOGRIFIER LSTM

2020 ICLR 修改传统LSTM 当前输入和隐藏状态充分交互&#xff0c;从而获得更佳的上下文相关表达 1 Mogrifier LSTM LSTM的输入X和隐藏状态H是完全独立的 机器学习笔记&#xff1a;GRU_gruc_UQI-LIUWJ的博客-CSDN博客这篇论文想探索&#xff0c;如果在输入LSTM之前&#xf…
阅读更多...
亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？

亿级月活的社交 APP，陌陌如何做到 3 分钟定位故障？

一分钟精华速览 本文概述了挚文集团&#xff08;陌陌和探探母公司&#xff09;在微服务架构下解决故障定位问题中遇到的痛点、解决方案以及取得的效果。通过构建统一可观测平台&#xff0c;实现了故障快速定位&#xff0c;大幅提升了问题定位的效率。文中还讨论了存储优化、数…
阅读更多...
SpringBoot案例-配置文件-@ConfigurationProperties

SpringBoot案例-配置文件-@ConfigurationProperties

问题分析 在往期的配置参数的文章中&#xff0c;对于阿里云OSS的参数时设置在yml配置文件中&#xff0c;然后使用Value&#xff08;”${}“&#xff09;对参数进行赋值&#xff0c;具体如下&#xff1a; 此种方法比较繁琐 问题解决 使用注解 Data 为变量自动生成get/set方…
阅读更多...
CrystalNet .Net VCL for Delphi Crack

CrystalNet .Net VCL for Delphi Crack

CrystalNet .Net VCL for Delphi Crack VCL或更为人所知的可视化组件库是基于一个面向对象的框架&#xff0c;什么是用户对开发人员和事件的Microsoft Windows应用程序的接口。可视化组件库是用对象Pascal编写的。它主要是为使用Borland而开发的&#xff0c;它具有与Delphi以及…
阅读更多...
vue关闭弹窗刷新父页面 this.$refs

vue关闭弹窗刷新父页面 this.$refs

代码截图 主页面 弹出框页面 接这一篇文章后续 参考链接
阅读更多...
专题-【B树的构建与删除】

专题-【B树的构建与删除】

构建&#xff1a; 删除&#xff1a; 叶子结点直接删&#xff1b; 非叶结点 找前驱&#xff08;左子树最右边&#xff09;/后继&#xff08;右子树最左边&#xff09;元素覆盖即可&#xff08;满足关键字个数取值范围&#xff09;&#xff1b; 这个更详细 『数据结构与算法』…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023