众所周知,python性能比较差,尤其在计算密集型的任务当中,所以机器学习领域的算法开发,大多是将python做胶水来用,他们会在项目中写大量的C/C++代码然后编译为so动态文件供python加载使用。那么时至今日,对于不想学习c/c++的朋友们,rust可以是一个不错的替代品,它有着现代化语言的设计和并肩c/c++语言的运行效率。

本文简单介绍使用rust为python计算性质的代码做一个优化,使用pyo3库为python写一个扩展供其调用,咱们下面开始,来看看具体的过程和效率的提升。(PS:本文只是抛砖引玉,初级教程)

我的台式机环境:

  1. 设备名称 DESKTOP
  2. 处理器 12th Gen Intel(R) Core(TM) i7-12700 2.10 GHz
  3. 机带 RAM 32.0 GB (31.8 GB 可用)
  4. 系统类型 64 位操作系统, 基于 x64 的处理器

1. python代码

首先给出python代码,这是一个求积分的公式:

  1. import time
  2. def integrate_f(a, b, N):
  3. s = 0
  4. dx = (b - a) / N
  5. for i in range(N):
  6. s += 2.71828182846 ** (-((a + i * dx) ** 2))
  7. return s * dx
  8. s = time.time()
  9. print(integrate_f(1.0, 100.0, 200000000))
  10. print("Elapsed: {} s".format(time.time() - s))

执行这段代码花费了: Elapsed: 32.59504199028015 s

2. rust

  1. use std::time::Instant;
  2. fn main() {
  3. let now = Instant::now();
  4. let result = integrate_f(1.0, 100.0, 200000000);
  5. println!("{}", result);
  6. println!("Elapsed: {:.2} s", now.elapsed().as_secs_f32())
  7. }
  8. fn integrate_f(a: f64, b: f64, n: i32) -> f64 {
  9. let mut s: f64 = 0.0;
  10. let dx: f64 = (b - a) / (n as f64);
  11. for i in 0..n {
  12. let mut _tmp: f64 = (a + i as f64 * dx).powf(2.0);
  13. s += (2.71828182846_f64).powf(-_tmp);
  14. }
  15. return s * dx;
  16. }

执行这段代码花费了: Elapsed: 10.80 s

3. 通过pyo3写扩展

首先创建一个项目,并安装 maturin 库:

  1. # (replace demo with the desired package name)
  2. $ mkdir demo
  3. $ cd demo
  4. $ pip install maturin

然后初始化一个pyo3项目:

  1. $ maturin init
  2. What kind of bindings to use? · pyo3
  3. Done! New project created demo

整体项目结构如下:

Cargo.toml中的一些字段含义:https://doc.rust-lang.org/cargo/reference/manifest.html

  1. .
  2. ├── Cargo.toml // rust包管理文件,会在[lib]中声明目标扩展包的名称
  3. ├── src // rust源文件目录, 你的扩展文件就写在这里,这个目录是maturin初始化的时候自动创建
  4. └── lib.rs // 扩展文件
  5. ├── pyproject.toml // python包管理文件,里面有python的包名字定义
  6. ├── .gitignore
  7. ├── Cargo.lock
  8. └── demo // 我们的目标模块名称,需手动创建
  9. ├── main.py // 用来测试的文件
  10. └── demo.cp312-win_amd64.pyd // 编译生成的动态链接库文件,供import给python使用

src/lib.rs 下写入:

  1. use pyo3::prelude::*;
  2. /// Caculate the integrate.
  3. #[pyfunction]
  4. fn integrate_f(a: f64, b: f64, n: i32) -> f64 {
  5. let mut s: f64 = 0.0;
  6. let dx: f64 = (b - a) / (n as f64);
  7. for i in 0..n {
  8. let mut _tmp: f64 = (a + i as f64 * dx).powf(2.0);
  9. s += (2.71828182846_f64).powf(-_tmp);
  10. }
  11. return s * dx;
  12. }
  13. /// A Python module implemented in Rust. The name of this function must match
  14. /// the `lib.name` setting in the `Cargo.toml`, else Python will not be able to
  15. /// import the module.
  16. #[pymodule]
  17. fn demo(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
  18. m.add_function(wrap_pyfunction!(integrate_f, m)?)?;
  19. Ok(())
  20. }

然后我们通过两种途径来使用它:

3.1 将扩展安装为python包

  1. $ maturin develop

这个命令会将rust代码转为python的包,并安装在当前python环境内。通过 pip list 就能看到。

3.2 编译成动态文件从python加载

  1. $ maturin develop --skip-install

--skip-install 命令会产生一个 pyd 文件而不是将其安装为python的包 - demo.cp312-win_amd64.pyd 文件在当前目录下,然后python可以直接导入使用。

另外还有一个指令替换 --skip-install--release 会生成一个 xxxx.whl 文件,也就是Python pip安装的包源文件。

首先我们在rust项目下,与 Cargo.toml 同级目录下,创建一个 demo 目录,然后我们写一个python文件 demo/main.py,下面是扩展的执行效果:

  1. import time
  2. import demo
  3. s = time.time()
  4. print(demo.integrate_f(1.0, 100.0, 200000000))
  5. print("Elapsed: {} s".format(time.time() - s))

花费时间为:Elapsed: 10.908721685409546 s

可以看到python的执行时间是rust和rust扩展的3倍时长,单进程看着好像不太大是吧,下面还有并行版本。

4 并行加速

4.1 python多进程效果

Python多进程很神奇,你写的不好的话,他比单进程下还要慢。

  1. import math
  2. import os
  3. import time
  4. from functools import partial
  5. from multiprocessing import Pool
  6. def sum_s(i: int, dx: float, a: int):
  7. return math.e ** (-((a + i * dx) ** 2))
  8. def integrate_f_parallel(a, b, N):
  9. s: float = 0.0
  10. dx = (b - a) / N
  11. sum_s_patrial = partial(sum_s, dx=dx, a=a)
  12. with Pool(processes=os.cpu_count()) as pool:
  13. tasks = pool.map_async(sum_s_patrial, range(N), chunksize=20000)
  14. for t in tasks.get():
  15. s += t
  16. return s * dx
  17. if __name__ == "__main__":
  18. s = time.time()
  19. print(integrate_f_parallel(1.0, 100.0, 200000000))
  20. print("Elapsed: {} s".format(time.time() - s))

花费时间: Elapsed: 18.86696743965149 s,比单进程下时间少了不到一半。

4.2 rust多线程加速给python使用

如果我们使用rust的并行库,将rust进一步加速,速度效果更明显:

将上面的 integrate_f 替换为下面的多线程版本:

  1. use pyo3::prelude::*;
  2. use rayon::prelude::*;
  3. #[pyfunction]
  4. fn integrate_f_parallel(a: f64, b: f64, n: i32) -> f64 {
  5. let dx: f64 = (b - a) / (n as f64);
  6. let s: f64 = (0..n)
  7. .into_par_iter()
  8. .map(|i| {
  9. let x = a + i as f64 * dx;
  10. (2.71828182846_f64).powf(-(x.powf(2.0)))
  11. })
  12. .sum();
  13. return s * dx;
  14. }
  15. /// A Python module implemented in Rust. The name of this function must match
  16. /// the `lib.name` setting in the `Cargo.toml`, else Python will not be able to
  17. /// import the module.
  18. #[pymodule]
  19. fn demo(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
  20. m.add_function(wrap_pyfunction!(integrate_f_parallel, m)?)?;
  21. Ok(())
  22. }

执行上一个标题3.2的步骤,然后在引入python使用:

  1. import time
  2. import demo
  3. s = time.time()
  4. print(demo.integrate_f_parallel(1.0, 100.0, 200000000))
  5. print("Elapsed: {} s".format(time.time() - s))

花费时间为:Elapsed: 0.9684994220733643 s。这比原先的单线程rust版本又快了10倍。但是差不多是python并行版本的18倍左右,是python单进程版本的32倍左右。如果我们将一些关键的性能通过rust重写,可以节省的时间成本是十分可观的。

总体来看,整体的使用过程相当简洁方便,难点就是rust的学习曲线高,使用起来需要花费精力,但是还是可以慢慢尝试去使用它优化已有的项目性能,哪怕只是一个功能函数,熟能生巧,一切慢慢来。

以上数据比较仅供参考,不同机器可能差异也不同。

初探: 通过pyo3用rust为python写扩展加速的更多相关文章

  1. Python之美[从菜鸟到高手]--一步一步动手给Python写扩展(异常处理和引用计数)

    我们将继续一步一步动手给Python写扩展,通过上一篇我们学习了如何写扩展,本篇将介绍一些高级话题,如异常,引用计数问题等.强烈建议先看上一篇,Python之美[从菜鸟到高手]--一步一步动手给Pyt ...

  2. Python写各大聊天系统的屏蔽脏话功能原理

    Python写各大聊天系统的屏蔽脏话功能原理 突然想到一个视频里面弹幕被和谐的一满屏的*号觉得很有趣,然后就想用python来试试写写看,结果还真玩出了点效果,思路是首先你得有一个脏话存放的仓库好到时 ...

  3. python写红包的原理流程包含random,lambda其中的使用和见简单介绍

    Python写红包的原理流程 首先来说说要用到的知识点,第一个要说的是扩展包random,random模块一般用来生成一个随机数 今天要用到ramdom中unifrom的方法用于生成一个指定范围的随机 ...

  4. Python写地铁的到站的原理简易版

    Python地铁的到站流程及原理(个人理解) 今天坐地铁看着站牌就莫名的想如果用Python写其工作原理 是不是很简单就小试牛刀了下大佬们勿喷纯属小弟个人理解 首先来看看地铁上显示的站牌如下: 就想这 ...

  5. 用Python写一个简单的Web框架

    一.概述 二.从demo_app开始 三.WSGI中的application 四.区分URL 五.重构 1.正则匹配URL 2.DRY 3.抽象出框架 六.参考 一.概述 在Python中,WSGI( ...

  6. 读书笔记汇总 --- 用Python写网络爬虫

    本系列记录并分享:学习利用Python写网络爬虫的过程. 书目信息 Link 书名: 用Python写网络爬虫 作者: [澳]理查德 劳森(Richard Lawson) 原版名称: web scra ...

  7. Python写UTF8文件,UE、记事本打开依然乱码的问题

    Python写UTF8文件,UE.记事本打开依然乱码的问题 Leave a reply 现象:使用codecs打开文件,写入UTF-8文本,正常无错误.用vim打开正常,但记事本.UE等打开乱码. 原 ...

  8. python 写的http后台弱口令爆破工具

    今天来弄一个后台破解的Python小程序,哈哈,直接上代码吧,都有注释~~ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ...

  9. python写xml文件

    为了便于后续的读取处理,这里就将信息保存在xml文件中,想到得到的文件如下: 1 <?xml version="1.0" encoding="utf-8" ...

  10. 教你用python写:HDU刷题神器

    声明:本文以学习为目的,请不要影响他人正常判题 HDU刷题神器,早已被前辈们做出来了,不过没有见过用python写的.大一的时候见识了学长写这个,当时还是一脸懵逼,只知道这玩意儿好屌-.时隔一年,决定 ...

随机推荐

  1. Kubernetes:kube-apiserver 和 etcd 的交互

    kubernetes:kube-apiserver 系列文章: Kubernetes:kube-apiserver 之 scheme(一) Kubernetes:kube-apiserver 之 sc ...

  2. 一篇文章带你掌握测试基础语言——Python

    一篇文章带你掌握测试基础语言--Python 本篇文章针对将Python作为第二语言的用户观看(已有Java或C基础的用户) 因为之前学习过Java语言,所以本篇文章主要针对Python的特征和一些基 ...

  3. JUC并发编程学习笔记(十五)JMM

    JMM 请你谈谈对Volatile的理解 Volatile是java虚拟机提供的轻量级的同步机制 1.保证可见性 2.不保证原子性 3.禁止指令重排 什么是JMM JVM->java虚拟机 JM ...

  4. STM32F103 CAN通信波特率的计算方法

    前言 以下的波特率计算和实例仅针对 STM32F1系列 最近看一下CAN通信,翻出来之前做过的STM32 CAN通信的项目代码,有些概念比较模糊了,如波特率是怎么计算的. 最近接触rt-thread比 ...

  5. OpenCL任务调度基础介绍

    当前,科学计算需求急剧增加,基于CPU-GPU异构系统的异构计算在科学计算领域得到了广泛应用,OpenCL由于其跨平台特性在异构计算领域渐为流行,其调度困难的问题也随之暴露,传统的OpenCL任务调度 ...

  6. DataGrip安装与使用

    写在前面:同学们记得以命令为主,图形界面为辅.了解图形怎么操作即可 一.DataGrip软件的安装和初始化 首先在浏览器上搜索datagrip,然后打开连接 点击DOWNLOAD   按照你电脑系统来 ...

  7. UNI-APP之微信小程序转H5

    开始 最近有个需求,需要将微信小程序中一些页面和功能改成h5,这次功能开发的时间有点紧,而且重新写一套有点来不及.考虑到微信小程序与uni-app有着一些共通之处,所以打算直接转成uni-app.un ...

  8. Python读取Ansible playbooks返回信息

    一.背景及概要设计 当公司管理维护的服务器到达一定规模后,就必然借助远程自动化运维工具,而ansible是其中备选之一.Ansible基于Python开发,集合了众多运维工具(puppet.chef. ...

  9. JAVA学习week1

    本周: 认识到Java是一门面向对象的编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承.指针等概念,因此Java语言具有功能强大和简单易用两个特征.Java语言作为静态面向对 ...

  10. 2020ICPC上海 C题(数位dp, 记忆化搜索)

    先复习了下之前做的数位DP又做了道新题才看的这道题,对我来说还是一种新类型,涉及到非线性计算,之前做的都是形如 \(dp[x]-dp[y]\)这样的只用处理一个上限做下差即可.一开始想分别枚举 \(x ...