标签 Python 下的文章

Apache Arrow:驱动列式分析性能和连接性的提升[译]

本文永久链接 – https://tonybai.com/2023/07/01/arrow-columnar-analytics

本文翻译自Voltron Data公司CTO Wes McKinney的文章《Apache Arrow: Driving Columnar Analytics Performance and Connectivity》。这篇文章回顾了现代大数据分析遇到的问题、Arrow项目的起源、生态发展以及对未来的展望。

以下是正文部分。


引言

自MapReduce以来,大数据已经走了很长一段路。Jeffrey Dean和Sanjay Ghemawat在2004年发表于Google的论文催生了Apache Hadoop开源项目,以及一系列其他新项目,这些项目是因大量开发人员有捕获,存储和处理非常大的数据集的需求而创建的。


图:大数据演进的3V(Volume、Variety和Velocity)

虽然像Hadoop这样的第一个MapReduce框架能够处理大型数据集,但它们是为了大规模弹性(通过将每个处理步骤的结果写回分布式存储)而设计的,而并未过多考虑性能。Apache Spark于2010年首次发布,因其基于容错分布式内存处理的新架构而脱颖而出。Spark的核心是用Scala实现的,Scala是Java虚拟机(JVM)的编程语言。Spark为其他编程语言提供了binding实现,例如 C# .NET、Java、Python (PySpark) 和 R(SparkR 和 sparklyr),这有助于Spark在众多编程语言开发者社区的普及使用。


图:数据处理生态系统演进

在过去的十年中,像Python和R这样的解释式编程语言已经不再局限于其在科学计算和学术统计中的利基市场,一跃发展成为现代数据科学,商业分析和AI的主流工具。这些编程语言完全主导了“笔记本电脑规模”的数据处理工作。像Hadoop和Spark这样的大规模数据处理框架为Python等解释型语言提供了编程接口,但与JVM上运行的“本机”接口相比,使用这些语言绑定的性能和资源利用率通常都很差。

解释型语言在使用主流大数据系统时所付出的性能损失主要源于数据互操作性问题。为了将数据从Java应用程序的核心运行时传递给用户的自定义Python函数(“用户定义函数”或“UDF”),必须将数据转换为可以Python所接受的格式,然后再转换为内置的Python对象,如列表、字典或基于数组的对象,如pandas DataFrames。更糟糕的是,许多框架,包括Spark和Hadoop,最初只为用户定义函数提供“一次一值”的执行模型,其中NumPy或pandas等工具则提供了“一次一数组”的执行模型,以避免Python解释器的开销。数据转换和解释器的双重昂贵开销使得Python基于大数据框架进行大规模数据处理变得愈加不现实。

Apache Spark通过引入Spark DataFrames来改善与Python的一些语言互操作性问题,Spark DataFrames是Spark SQL的一种新的类似pandas的API,它无需在Spark运行时和Python之间传输数据。不幸的是,任何需要使用Python的数据科学或机器学习库的应用程序都不走运。这给数据科学家和数据工程师带来了一个艰难的选择:用Python更快地开发,以换取更慢、更昂贵的工作负载,或者用Scala或Java重写关键工作负载。

Apache Arrow项目的起源

Apache Arrow的起源故事有点像微积分的创建:各自独立的开源开发人员团体在2010年代中期的同一时间都有过“尤里卡时刻”(译注:据说阿基米德洗澡时福至心灵,想出了如何测量皇冠体积的方法,因而惊喜地叫出了一声:“Eureka!”)。

2014年底,我加入了Cloudera,开始与分别由Marcel Kornacker和Todd Lipcon领导的Apache Impala和Apache Kudu团队密切合作。我们对在大规模分布式存储和数据处理引擎之上为Python程序员(特别是pandas用户)构建直观和快速的开发人员体验上有一致的兴趣。当时的一个突出的问题是缺乏标准化的、高速的面向列的“数据协议”,以便在引擎和编程语言之间高效地传输数据。我们不想为我们的这个事情创建自定义数据格式,也不想使用像Google的Protocol Buffers或Apache Thrift这样的数据序列化技术,因为这些技术引入了过多的计算开销。我们开始设计一种新的列式数据格式,但我们知道,如果它是一个主要由Cloudera领导的项目,那么在大数据开源项目的高度政治化氛围中,它可能会有失败的风险。

与此同时,Julien Le Dem和Jacques Nadeau,分别是Apache Parquet文件格式和Apache Drill查询引擎的共同创建者,他们正在探索一种方法,将Drill用于查询执行的内存列格式转变为独立的开源项目。这种数据格式被用作Dremio的基础,Dremio是一个基于SQL的开源数据湖引擎,使用它可以使得云中不同存储和数据处理系统之间更快,更高效的进行连接。

值得庆幸的是,Julien、Marcel和Todd在几年前就已经合作设计了Parquet文件格式,所以我们取得了联系并决定共同解决问题,而不是启动单独的、几乎肯定不会兼容的项目。我们举行了一系列快速的面对面会议(现在来看,在2022年那几乎是不可想象的!),我们开始招募其他开源大数据领导者加入我们创建一个新项目,包括 Julian Hyde(Apache Calcite)、Reynold Xin (Apache Spark)、Michael Stack (Apache HBase)等等。

2016年,在将Apache Arrow作为Apache软件基金会的顶级项目推出后,我们一直致力于使Arrow成为需要快速移动和处理数据的数据分析系统的首选项目。从那时起,该项目已成为高效的内存中列式分析和低开销数据传输的事实标准,它支持10多种编程语言。除了提供内存数据格式和互操作性协议外,我们还创建了一个功能全面的模块化计算库工具箱,为下一代分析计算系统打下坚实的基础

在启动Arrow项目仅一年后,与Two Sigma的我的新同事以及IBM的合作者的合作,让我们能够加速PySpark与Arrow的使用,在某些情况下实现了10-100倍的性能提升,并显著改善了将Python和pandas与Apache Spark一起使用的体验。看到我们对更快、更具互操作性的未来的愿景开始逐步实现,这真是令人兴奋。

2018年,我与RStudio和Two Sigma合作成立了Ursa Labs,作为一个非营利性行业联盟,其使命是使Arrow成为下一代数据科学工具的强大计算基础。我参与Arrow的工作,除了解决数据互操作性问题外,还旨在解决现代硬件上的内存管理和内存计算效率问题。我們很幸运地获得了NVIDIA、Intel、G-Research、Bloomberg、ODSC和OneSixtyTwo Technologies的额外赞助。

经过4年多的Apache Arrow开发,我们清楚地认识到,要促使Arrow下一阶段的增长和对企业的影响,仅通过行业赞助还不够,还需要获得更大的资本投资才行。于是在2020年底,我们决定将Ursa Labs团队从RStudio(为Ursa Labs提供了大部分资金和运营支持)中剥离出来,组建一家营利性公司Ursa Computing,并在2020年底筹集了一轮风险投资。不久之后,在2021年初,我们有机会与Arrow上的GPU分析、BlazingSQL和RAPIDS领导层的创新者联手,组建了一家统一的Arrow原生(Arrow-native)计算公司Voltron Data。Ursa Labs已成为Voltron Data Labs,Voltron Data内部的一个团队,其持续的使命是发展和支持Arrow生态系统,同时维护Apache Way的开放和透明的治理模型。

Apache Arrow项目的增长

如今,Arrow开发人员社区已发展到700多人,其中67人拥有提交权限。我们以创建跨语言开放标准和构建模块化软件组件为动力,以降低系统复杂性,同时提高性能和效率。我们一直在考虑将该项目视为一个软件开发工具包,旨在使开发人员能够释放Apache Arrow内存格式的好处,并解决随之而来的一阶和二阶问题(例如从云存储中读取Parquet文件,然后进行一些内存分析处理)。如果没有一个可信的、“自带电池”的软件堆栈来构建支持Arrow的计算应用程序来配合它,Arrow的列式格式本质上只能作为一种替代文件格式。

最近,在将Arrow列式格式和协议稳定用于生产用途后,社区一直专注于提供快速的Arrow原生计算组件。这项工作在C++和Rust社区中最为活跃。使用这些语言的查询引擎项目(DataFusion for Rust 和尚未命名的C++子项目),您可以轻松地将嵌入式Arrow原生列式数据处理特性添加到您的应用程序中。这可能包括您可能使用SQL或数据帧(dataframe)库(如 pandas 或 dplyr)表示的工作负载。新的高性能数据帧库(如Polars)从一开始就被构建为Arrow原生。在Voltron Data,我们正在积极努力使这些功能无缝地提供给Python和R程序员。

让这些项目采用Arrow数据互操作性协议的一个令人信服的理由是,与任何其他使用Arrow的项目可以实现简单快速的连接。早期采用者出于信任并收获了巨大的回报。现在,任何可以读写Arrow的项目都可以通过一个快速路径连接到数据帧库(如 pandas 和 R)和许多机器学习系统(PyTorchTensorFlowHugging Face)。

Arrow的贡献者通过与其他开源项目的密切合作,扩展了项目的能力。最近,与DuckDB实验室合作,使用DuckDB作为嵌入式执行引擎实现了无缝查询。R或Python现在能够使用DuckDB无缝查询其Arrow数据,可以使用类似数据帧的API(如dplyr)或SQL。此集成是经由Arrow的C数据接口实现的。

使数据服务和分布式系统更容易使用Arrow的二进制格式是推动Arrow被更广泛接纳的一个重要工作。由于将Arrow协议与一些通用数据服务框架(如 gRPC 或 Apache Thrift)联合最佳使用需要一些中间件代码,因此社区开发了Flight,这是一个用于Arrow原生数据服务的开发者框架和客户端-服务器协议。Flight提供了用于实现服务器和客户端逻辑的高级库,同时使用行业标准gRPC库进行内部通信。通过在客户端和服务器中使用通用内存格式来消除不必要的数据序列化,用户可以实现以前在独立于语言的协议中无法想象的数据吞吐级别(在某些情况下每秒几千兆字节)。Flight库现在在许多Arrow语言库(C++、Python、R、Java、Rust、Go)中可用,未来肯定会添加更多语言。

数据库是最普遍使用的数据服务之一,ODBC和JDBC等标准数据库接口根本上是为实现互操作性和兼容性而设计,而不是为了速度。因此,Flight带来了两全其美的可能性:互操作性而又不影响性能。但是,作为开发者框架和协议的Flight没有任何关于SQL数据库工作方式的内置概念,包括用户会话、执行查询的生命周期或预处理语句等内容。还有一个风险是,每个数据库系统实现其Flight服务器的方式略有不同,因此用户必须使用不同的Flight客户端来访问每种数据库。为了解决这些问题,包括SQL数据库的客户端/服务器标准化以及与ODBC和JDBC相似的高级功能,Arrow创建了一个称为Flight SQL的Flight应用程序扩展。现在,数据库开发人员可以实现一个通用的Flight SQL服务器,用户将能够使用标准的Flight SQL客户端访问任何启用Flight SQL的数据库。


来源:https://www.dremio.com/subsurface/arrow-flight-sql-a-universal-jdbc-driver

Apache Arrow生态系统的发展和采用

Arrow项目及其生态系统的发展得益于其早期采纳者的成功。总的来说,Arrow已经成为Python用户与以Parquet等文件格式存储的数据集进行交互的标准工具。如上所述,在项目早期,我们与Spark社区合作,使用Arrow更快地将数据传输到pandas来加速PySpark。在这些早期成功案例之后,许多其他项目都采用了Arrow来实现更快的互操作性和内存处理,并删除了以前的定制解决方案。

通过采用Arrow进行数据传输,Streamlit能够删除自定义代码,同时大幅提高应用程序性能。Streamlit的传统序列化框架基于Protocol Buffers,用于将表格数据从Python后端发送到JavaScript前端。通过将自定义序列化程序替换为Arrow,Streamlit的性能提高了15倍,并且能够通过使用现成的解决方案来简化其代码库。


来源: https://blog.streamlit.io/content/images/2021/07/legacy-vs-arrow-2-1.png#shadow

Dremio是从头开始就以Apache Arrow为核心构建的系统。Dremio由Jacques Nadeau共同创立,是一个用于数据湖的分布式查询引擎。Dremio开发了一种基于LLVM的即时表达式编译器,称为Gandiva(现在是Arrow项目的一部分),它可以针对Arrow列式内存的操作生成高效的机器代码。与在JVM中执行的解释表达式相比,这可实现更快的性能。

最近,Databricks发布了Cloud Fetch connector,用于将商业智能工具(如Tableau或Power BI)与存储在云中的数据连接起来。过去,从传统数据仓库检索数据的速度受到了在单个线程上从单个SQL端点提取数据的速度的限制。这限制了交互式数据探索工具的有用性。Cloud Fetch 使用Arrow wire协议从云存储并行流式传输数据,与传统方法相比,性能提高了12倍。

这些只是使用Arrow项目的某些部分来加速数据移动或在内存中处理数据的项目的几个示例。随着越来越多的项目启用Arrow,用户将获得复合效率的优势。例如,在Snowflake实现以Arrow格式从其系统中检索数据后,他们的Python和JDBC客户端的数据检索速度提高了5倍。这不仅使Snowflake查询运行得更快,而且使得与Snowflake集成的产品运行得更快。例如,人工智能驱动的分析平台Tellius能够使用Arrow将他们与Snowflake的集成速度提高3倍,相比于之前的实现。

社区

Apache Arrow的受欢迎程度正在不断增长。事实上,Arrow的Python库PyArrow在2022年1月的下载量为4600w次,这一数字比2021年10月份创造的之前的记录增加了近800w次。我们预计,随着越来越多的项目采用Arrow作为依赖项,这一趋势将继续下去。


资料来源:https://pypistats.org/,沃尔创数据

Arrow为数据传输、对二进制文件(如 Parquet)的高速访问以及快速发展的计算引擎提供了坚实的基础。这需要多年的工作和一个庞大的社区才能实现。在过去的6年里,Arrow开发者社区得到了相当大的发展:自2016年首次发布以来,已有676名独立的开发人员为该项目做出了贡献,其中105名贡献者参与了Arrow 7.0.0版本的开发。

与Apache软件基金会中的所有项目一样,我们遵循Apache Way,这是一个开放透明的开源项目治理框架。项目讨论和决策必须在公开场合进行,例如在邮件列表或GitHub上。贡献者以个人身份参与,而不是作为他们工作的公司的代表。通过公开开展所有项目业务,我们可以保持包容和专业的氛围,欢迎来自世界各地的贡献者的不同观点。Apache Way重视多种贡献:回答用户问题、分类错误报告和编写文档与提出拉取请求一样重要。Arrow项目主要的开发人员邮件列表是dev@arrow.apache.org。

在项目中持续工作一段时间后,贡献者可以通过项目管理委员会(PMC)的投票被提升为“提交者”(对项目git存储库具有写入权限)。表现出致力于发展和指导项目社区的提交者以后可能会被提升加入PMC。PMC成员是项目指导委员会,对项目中的发布和其他重大决策具有约束力的投票权。目前Arrow项目有67个提交者和38个PMC 成员。

未来

随着Arrow开发者社区的发展,项目范围也在扩大。该项目始于六年前,旨在设计一个独立于语言的标准来表示面向列的数据,以及一个二进制协议,用于在应用程序之间移动数据。从那时起,该项目稳步发展,提供了一个自带电池的开发工具箱,以简化构建涉及处理大型数据集的高性能分析应用程序。我们预计Arrow将成为下一代大数据系统的关键组成部分。

我们期望开放标准和接口方面的工作能够继续团结和简化分析计算生态系统。我们参与了Substrait,这是一个新的开源框架,提供标准化的中间查询语言(低于SQL级别),将前端用户界面(如SQL或data frame库)与后端分析计算引擎连接起来。Substrait由Arrow项目联合创始人Jacques Nadeau创立,并且发展迅速。我们认为,有了这个新项目提供的执行引擎支持,编程语言接口与分析性计算将更容易发展。

加入我们!

发展Apache Arrow项目是我们Voltron Data使命的重要组成部分!我们期待继续与社区合作,推动生态系统向前发展。您可以订阅我们的新闻通讯以随时了解情况,并考虑在Twitter上关注我们@voltrondata以获取更多新闻。您还可以探索Voltron Data Enterprise Support订阅选项,这个订阅列表旨在帮助在Apache Arrow生态系统中工作的开发人员和公司。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Go与神经网络:张量运算

本文永久链接 – https://tonybai.com/2023/05/21/go-and-nn-part1-tensor-operations

0. 背景

2023年年初,我们很可能是见证了一次新工业革命的起点,也可能是见证了AGI(Artificial general intelligence,通用人工智能)孕育的开始。ChatGPT应用以及后续GPT-4大模型的出现,其震撼程度远超当年AlphaGo战胜人类顶尖围棋选手。相对于AlphaGo在一个狭窄领域的建树,ChatGPT则是以摧枯拉朽之势横扫几乎所有脑力劳动行业

如今大家更多将ChatGPT及相关应用当做生产力工具,作为程序员,自然会首当其冲的加入到借助AI提升生产力的阵营。但对于程序员来说,如果对一个计算机科学方面的技术没有基本工作原理认知或是完全看不懂,那么就会有一种深深的危机感

什么是深度学习、什么是神经网络、什么是大模型、上千亿的参数究竟指的是什么、什么是大模型的量化等都是萦绕在头脑中的未知但又急切想知道的东西。

有人会说,深度学习发展都十多年了,现在学还来得及么?其实大多数人不是从事机器学习的,普通程序员只需要了解机器学习、深度学习(神经网络)的基本运作原理即可。此外,有了ChatGPT相关工具后,获取和理解知识的效率可以大幅提升,以前需要以年来计算学习新知识技能,现在可能仅需以月来计算,甚至更短。

作为程序员,了解深度学习,了解神经网络,其实也是去学习一种新的、完全不同于以往的编程范式。以前我们的编程范式是这样的: 人类学习规则,然后通过手工编码将规则内置到系统中,系统运行后,根据明确的规则对输入数据做处理并给出答案(如下图所示):

这个大编程范式通常又细分为下面几类,大家根据自己的喜好和工作要求选择不同的编程范式以及编程语言:

  • 命令式编程范式(C、Go等);
  • 面向对象编程范式(Java、Ruby);
  • 函数式编程范式(Haskell、Lisp、Clojure等);
  • 声明式编程范式(SQL)。

这类范式都归属于符号主义人工智能(symbolic AI),即都是用来手工编写明确的规则的。符号主义人工智能适合用来解决定义明确的逻辑问题,比如下国际象棋,但它难以给出明确规则来解决更复杂、更模糊的问题,比如图像分类、语音识别或自然语言翻译。

而机器学习或者说机器学习的结果人工神经网络则是另外一种范式,如下图所示:

在这个范式中,程序员无需再学习什么规则,因为规则是模型自己通过数据学习来的。程序员只需准备好高质量的训练数据以及对应的答案(标注),然后建立初始模型(初始神经网络)即可,之后的事情就交给机器了(机器学习并非在数学方面做出什么理论突破,而是“蛮力出奇迹”一个生动案例)。模型通过数据进行自动训练(学习)并生成包含规则的目标模型,而目标模型即程序

了解两类截然不同的范式之后,我再来澄清几个问题:

  • Go与神经网络系列文章的目的?不是教你如何自己搞出一个大模型,而是将经典机器学习、深度学习(与建立人工神经网络)的来龙去脉搞清楚。
  • Why Go? 帮助Go程序员学习机器学习。虽然Python代码看起来很容易理解,代码量也会少很多(像Keras这样的框架,甚至将training dataset都集成在框架中了)。

注:通过阅读Python的机器学习/深度学习代码,我觉得不会有什么语言可以代替Python作为AI主力了。用Python做数据准备、训练模型简直简单的不要不要的了。

  • 从何处开始?张量以及相关运算。

张量在深度学习中扮演着非常重要的角色,因为它们是存储和处理数据的基本单位。张量可以看作是一个“容器”,可以表示向量、矩阵和更高维度的数据结构。深度学习中的神经网络模型使用张量来表示输入数据、模型参数和输出结果,以及在计算过程中的各种中间变量。通过对张量进行数学运算和优化,深度学习模型能够从大量的数据中学习到特征和规律,并用于分类、回归、聚类等任务。因此,张量是深度学习中必不可少的概念之一。最流行的深度学习框架tensorflow都以tensor命名。我们也将从张量(tensor)出发进入机器学习和神经网络世界。

不过大家要区分数学领域与机器学习领域张量在含义上的不同。在数学领域,张量是一个多维数组,而在机器学习领域,张量是一种数据结构,用于表示多维数组和高维矩阵。两者的相同点在于都是多维数组,但不同点在于它们的应用场景和具体实现方式不同。如上一段描述那样,在机器学习中,张量通常用于表示数据集、神经网络的输入和输出等。

下面我们就来了解一下张量与张量的运算,包括如何创建张量、执行基本和高级张量操作,以及张量广播(broadcast)与重塑(reshape)操作。

1. 理解张量

张量是目前所有机器学习系统都使用的基本数据结构。张量这一概念的核心在于,它是一个数据容器。它包含的数据通常是同类型的数值数据,因此它是一个同构的数字容器

前面提到过,张量可以表示数字、向量、矩阵甚至更高维度的数据。很多语言采用多维数组来实现张量,不过也有采用平坦数组(flat array)来实现的,比如:gorgonia/tensor

无论实现方式是怎样的,从逻辑上看,张量的表现是一致的,即张量是一个有如下属性的同构数据类型。

1.1 阶数(ndim)

张量的维度通常叫作轴(axis),张量轴的个数也叫作阶(rank)。下面是从0阶张量到4阶张量的示意图:

  • 0阶张量

仅包含一个数字的张量,也被称为标量(scalar),也叫标量张量。0阶张量有0个轴。

  • 1阶张量

1阶张量,也称为向量(vector),有一个轴。这个向量可以是n维向量,与张量的阶数没有关系。比如在上面图中的一阶张量表示的就是一个4维向量。所谓维度即沿着某个轴上的元素的个数。这个图中一阶张量表示的向量中有4个元素,因此是一个4维向量。

  • 2阶张量

2阶张量,也称为矩阵(matrix),有2个轴。在2阶张量中,这两个轴也称为矩阵的行(axis-0)和列(axis-1),每个轴上的向量都有自己的维度。例如上图中的2阶张量的axis-0轴上有3个元素(每个元素又都是一个向量),因此是axis-0的维度为3,由此类推,axis-1轴的维度为4。

注:张量的轴的下标从0开始,如axis-0、axis-1、…、axis-n。

2阶张量也可以看成是1阶张量的数组。

  • 3阶或更高阶张量

3阶张量有3个轴,如上图中的3阶张量,可以看成是多个2阶张量组成的数组。

以此类推,扩展至N阶张量,可以看成是N-1阶张量的数组。

1.2 形状(shape)。

张量有一个属性为shape,shape由张量每个轴上的维度(轴上元素的个数)组成。以上图中的3阶张量为例,其axis-0轴上有2个元素,axis-1轴上有3个元素,axis-2轴上有4个元素,因此该3阶张量的shape为(2, 3, 4)。axis-0轴也被称为样本轴,下图是按照每一级张量的样本轴对张量做拆解的示意图:

我们首先对3阶张量(shape(2,3,4))沿着其样本轴方向进行拆解,我们将其拆解2个2阶张量(shape(3,4))。接下来,我们对得到的2阶张量进行拆解,同样沿着其样本轴方向拆解为3个1阶张量(shape(4,))。我们看到,每个1阶张量是一个4维向量,可拆解为4个0阶张量。

1.3 元素数据类型dtype

张量是同构数据类型,无论是几阶张量,最终都是由一个个标量组合而成,标量的类型就是张量的元素数据类型(dtype),在上图中,我们的张量的dtype为float32。浮点数与整型数是机器学习中张量最常用的元素数据类型。

了解了张量的概念与属性后,我们就来看看在Go中如何创建张量。

2. 在Go中创建张量

Go提供了几个机器学习库,可以用来创建和操作张量。在Go中执行张量操作的两个流行库是TensorflowGorgonia

不过Tensorflow官方团队已经不再对go binding API提供维护支持了(由Go社区第三方负责维护),并且该binding需要依赖cgo调用tensorflow的库,因此在本文中,我们使用gorgonia来定义张量以及进行张量运算。

Gorgonia提供了tensor包用来定义tensor并提供基于tensor的基本运算函数。下面的例子使用tensor包定义了对应上面图中1阶到3阶的三个张量:

// https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations/tensor.go
package main

import (
    "fmt"

    "gorgonia.org/tensor"
)

func main() {
    // define an one-rank tensor
    oneRankTensor := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3, 3.2}), tensor.WithShape(4))
    fmt.Println("\none-rank tensor:")
    fmt.Println(oneRankTensor)
    fmt.Println("ndim:", oneRankTensor.Dims())
    fmt.Println("shape:", oneRankTensor.Shape())
    fmt.Println("dtype", oneRankTensor.Dtype())

    // define an two-rank tensor
    twoRankTensor := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3, 3.2,
        2.7, 2.8, 1.5, 2.9,
        3.7, 2.4, 1.7, 3.1}), tensor.WithShape(3, 4))
    fmt.Println("\ntwo-rank tensor:")
    fmt.Println(twoRankTensor)
    fmt.Println("ndim:", twoRankTensor.Dims())
    fmt.Println("shape:", twoRankTensor.Shape())
    fmt.Println("dtype", twoRankTensor.Dtype())

    // define an three-rank tensor
    threeRankTensor := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3, 3.2,
        2.7, 2.8, 1.5, 2.9,
        3.7, 2.4, 1.7, 3.1,
        1.5, 2.7, 1.4, 3.3,
        2.5, 2.8, 1.9, 2.9,
        3.5, 2.5, 1.7, 3.6}), tensor.WithShape(2, 3, 4))
    fmt.Println("\nthree-rank tensor:")
    fmt.Println(threeRankTensor)
    fmt.Println("ndim:", threeRankTensor.Dims())
    fmt.Println("shape:", threeRankTensor.Shape())
    fmt.Println("dtype", threeRankTensor.Dtype())
}

tensor.New接受一个变长参数列表,这里我们显式传入了存储张量数据的平坦数组数据以及tensor的shape属性,这样我们便能得到一个满足我们要求的tensor变量。运行上面程序,你将看到下面内容:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run tensor.go

one-rank tensor:
[1.7  2.6  1.3  3.2]
ndim: 1
shape: (4)
dtype float32

two-rank tensor:
⎡1.7  2.6  1.3  3.2⎤
⎢2.7  2.8  1.5  2.9⎥
⎣3.7  2.4  1.7  3.1⎦

ndim: 2
shape: (3, 4)
dtype float32

three-rank tensor:
⎡1.7  2.6  1.3  3.2⎤
⎢2.7  2.8  1.5  2.9⎥
⎣3.7  2.4  1.7  3.1⎦

⎡1.5  2.7  1.4  3.3⎤
⎢2.5  2.8  1.9  2.9⎥
⎣3.5  2.5  1.7  3.6⎦

ndim: 3
shape: (2, 3, 4)
dtype float32

tensor.New返回的*tensor.Dense类型实现了fmt.Stringer接口,可以按shape形式打印出tensor,但是人类肉眼也就识别到3阶tensor吧。3阶以上的tensor输出的格式用人眼识别和理解就有些困难了。

此外,我们看到Gorgonia的tensor包基于平坦的数组来存储tensor数据,tensor包根据shape属性对数组中数据做切分,划分出不同轴上的数据。数组的元素类型可以自定义,如果我们使用float64的切片,那么tensor的dtype就为float64。

3. Go中的基本张量运算

现在我们知道了如何使用Gorgonia/tensor创建张量了,让我们来探索Go中的一些基本张量运算。

3.1. 加法和减法

两个相同形状(shape)的张量相加或相减是机器学习算法中的一个常见操作。在Go中,我们可以使用Gorgonia/tensor提供的Add和Sub函数进行加减操作。下面是一个使用tensor包进行加减运算的示例代码片断:

// https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations/tensor_add_sub.go

func main() {

    // define two two-rank tensor
    ta := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3, 3.2,
        2.7, 2.8, 1.5, 2.9,
        3.7, 2.4, 1.7, 3.1}), tensor.WithShape(3, 4))
    fmt.Println("\ntensor a:")
    fmt.Println(ta)

    tb := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3, 3.2,
        2.7, 2.8, 1.5, 2.9,
        3.7, 2.4, 1.7, 3.1}), tensor.WithShape(3, 4))
    fmt.Println("\ntensor b:")
    fmt.Println(ta)

    tc, _ := tensor.Add(ta, tb)
    fmt.Println("\ntensor a+b:")
    fmt.Println(tc)

    td, _ := tensor.Sub(ta, tb)
    fmt.Println("\ntensor a-b:")
    fmt.Println(td)

    // add in-place
    tensor.Add(ta, tb, tensor.UseUnsafe())
    fmt.Println("\ntensor a+b(in-place):")
    fmt.Println(ta)

    // tensor add scalar
    tg, err := tensor.Add(tb, float32(3.14))
    if err != nil {
        fmt.Println("add scalar error:", err)
        return
    }
    fmt.Println("\ntensor b+3.14:")
    fmt.Println(tg)

    // add two tensors of different shape
    te := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3,
        3.2, 2.7, 2.8}), tensor.WithShape(2, 3))
    fmt.Println("\ntensor e:")
    fmt.Println(te)

    tf, err := tensor.Add(ta, te)
    fmt.Println("\ntensor a+e:")
    if err != nil {
        fmt.Println("add error:", err)
        return
    }
    fmt.Println(tf)
}

运行该示例:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run tensor_add_sub.go

tensor a:
⎡1.7  2.6  1.3  3.2⎤
⎢2.7  2.8  1.5  2.9⎥
⎣3.7  2.4  1.7  3.1⎦

tensor b:
⎡1.7  2.6  1.3  3.2⎤
⎢2.7  2.8  1.5  2.9⎥
⎣3.7  2.4  1.7  3.1⎦

tensor a+b:
⎡3.4  5.2  2.6  6.4⎤
⎢5.4  5.6    3  5.8⎥
⎣7.4  4.8  3.4  6.2⎦

tensor a-b:
⎡0  0  0  0⎤
⎢0  0  0  0⎥
⎣0  0  0  0⎦

tensor a+b(in-place):
⎡3.4  5.2  2.6  6.4⎤
⎢5.4  5.6    3  5.8⎥
⎣7.4  4.8  3.4  6.2⎦

tensor b+3.14:
⎡     4.84       5.74       4.44       6.34⎤
⎢     5.84       5.94  4.6400003       6.04⎥
⎣     6.84       5.54       4.84       6.24⎦

tensor e:
⎡1.7  2.6  1.3⎤
⎣3.2  2.7  2.8⎦

tensor a+e:
add error: Add failed: Shape mismatch. Expected (2, 3). Got (3, 4)

我们看到:tensor加减法是一个逐元素(element-wise)进行的操作,要求参与张量运算的张量必须有相同的shape,同位置的两个元素相加,否则会像示例中最后的a+e那样报错;tensor加法支持tensor与一个scalar(标量)进行加减,原理就是tensor中每个元素都与这个标量相加减;此外若传入tensor.Unsafe这个option后,参与加减法操作的第一个tensor的值会被结果重写掉(override)。

3.2. 乘法和除法

两个张量的相乘或相除是机器学习算法中另一个常见的操作。在Go中,我们可以使用Gorgonia/tensor提供的Mul和Div函数进行乘除运算。下面是一个使用Gorgonia/tensor进行乘法和除法运算的示例代码:

// https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations/tensor_mul_div.go

func main() {

    // define two two-rank tensor
    ta := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3, 3.2,
        2.7, 2.8, 1.5, 2.9,
        3.7, 2.4, 1.7, 3.1}), tensor.WithShape(3, 4))
    fmt.Println("\ntensor a:")
    fmt.Println(ta)

    tb := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3, 3.2,
        2.7, 2.8, 1.5, 2.9,
        3.7, 2.4, 1.7, 3.1}), tensor.WithShape(3, 4))
    fmt.Println("\ntensor b:")
    fmt.Println(tb)

    tc, err := tensor.Mul(ta, tb)
    if err != nil {
        fmt.Println("multiply error:", err)
        return
    }
    fmt.Println("\ntensor a x b:")
    fmt.Println(tc)

    // multiple tensor and a scalar
    td, err := tensor.Mul(ta, float32(3.14))
    if err != nil {
        fmt.Println("multiply error:", err)
        return
    }
    fmt.Println("\ntensor ta x 3.14:")
    fmt.Println(td)

    // divide two tensors
    td, err = tensor.Div(ta, tb)
    if err != nil {
        fmt.Println("divide error:", err)
        return
    }
    fmt.Println("\ntensor ta / tb:")
    fmt.Println(td)

    // multiply two tensors of different shape
    te := tensor.New(tensor.WithBacking([]float32{1.7, 2.6, 1.3,
        3.2, 2.7, 2.8}), tensor.WithShape(2, 3))
    fmt.Println("\ntensor e:")
    fmt.Println(te)

    tf, err := tensor.Mul(ta, te)
    fmt.Println("\ntensor a x e:")
    if err != nil {
        fmt.Println("mul error:", err)
        return
    }
    fmt.Println(tf)
}

运行该示例,我们可以看到如下结果:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run tensor_mul_div.go

tensor a:
⎡1.7  2.6  1.3  3.2⎤
⎢2.7  2.8  1.5  2.9⎥
⎣3.7  2.4  1.7  3.1⎦

tensor b:
⎡1.7  2.6  1.3  3.2⎤
⎢2.7  2.8  1.5  2.9⎥
⎣3.7  2.4  1.7  3.1⎦

tensor a x b:
⎡     2.89  6.7599993  1.6899998  10.240001⎤
⎢7.2900004  7.8399997       2.25   8.410001⎥
⎣13.690001       5.76       2.89       9.61⎦

tensor ta x 3.14:
⎡5.3380003      8.164      4.082     10.048⎤
⎢ 8.478001      8.792       4.71   9.106001⎥
⎣11.618001  7.5360007  5.3380003      9.734⎦

tensor ta / tb:
⎡1  1  1  1⎤
⎢1  1  1  1⎥
⎣1  1  1  1⎦

tensor e:
⎡1.7  2.6  1.3⎤
⎣3.2  2.7  2.8⎦

tensor a x e:
mul error: Mul failed: Shape mismatch. Expected (2, 3). Got (3, 4)

我们看到,和加减法一样,tensor的乘除法也是逐元素进行的,同时也支持与scalar的乘除。但对于shape不同的两个tensor,Mul和Div会报错。

了解了加减、乘除等基本操作后,下面我们再探索一写更高级的张量操作。

4. Go中的高级张量操作

除了基本的张量操作外,Go还提供了一些高级的张量操作,用于复杂的机器学习算法中。让我们来探讨一下Go中的一些高级张量操作。

4.1. 点积

点积运算,也叫张量积(tensor product,不要与上面的逐元素的乘积弄混),是线性代数和机器学习算法中的一个作最常见也最有用的张量运算。与逐元素的运算不同,它将输入张量的元素合并在一起。

它涉及到将两个张量元素相乘,然后将结果相加。这里借用鱼书中的图来直观的看一下二阶tensor计算过程:

图中是两个shape为(2, 2)的tensor的点积。

下面是更一般的两个二阶tensor t1和t2:

tensor t1: shape(a, b)
tensor t2: shape(c, d)

t1和t2可以做点积的前提是b == c,即第一个tensor t1的shape[1] == 第二个tensor t2的shape[0]。

在Go中,我们可以Dot函数来实现点积操作。下面是使用Gorgonia/tensor进行点积操作的例子:

// https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations/tensor_dot.go

func main() {

    // define two two-rank tensor
    ta := tensor.New(tensor.WithBacking([]float32{1, 2, 3, 4}), tensor.WithShape(2, 2))
    fmt.Println("\ntensor a:")
    fmt.Println(ta)

    tb := tensor.New(tensor.WithBacking([]float32{5, 6, 7, 8}), tensor.WithShape(2, 2))
    fmt.Println("\ntensor b:")
    fmt.Println(tb)

    tc, err := tensor.Dot(ta, tb)
    if err != nil {
        fmt.Println("dot error:", err)
        return
    }
    fmt.Println("\ntensor a dot b:")
    fmt.Println(tc)

    td := tensor.New(tensor.WithBacking([]float32{5, 6, 7, 8, 9, 10}), tensor.WithShape(2, 3))
    fmt.Println("\ntensor d:")
    fmt.Println(td)
    te, err := tensor.Dot(ta, td)
    if err != nil {
        fmt.Println("dot error:", err)
        return
    }
    fmt.Println("\ntensor a dot d:")
    fmt.Println(te)

    // three-rank tensor dot two-rank tensor
    tf := tensor.New(tensor.WithBacking([]float32{23: 12}), tensor.WithShape(2, 3, 4))
    fmt.Println("\ntensor f:")
    fmt.Println(tf)

    tg := tensor.New(tensor.WithBacking([]float32{11: 12}), tensor.WithShape(4, 3))
    fmt.Println("\ntensor g:")
    fmt.Println(tg)

    th, err := tensor.Dot(tf, tg)
    if err != nil {
        fmt.Println("dot error:", err)
        return
    }
    fmt.Println("\ntensor f dot g:")
    fmt.Println(th)
}

运行该示例,我们可以看到如下结果:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run tensor_dot.go

tensor a:
⎡1  2⎤
⎣3  4⎦

tensor b:
⎡5  6⎤
⎣7  8⎦

tensor a dot b:
⎡19  22⎤
⎣43  50⎦

tensor d:
⎡ 5   6   7⎤
⎣ 8   9  10⎦

tensor a dot d:
⎡21  24  27⎤
⎣47  54  61⎦

tensor f:
⎡ 0   0   0   0⎤
⎢ 0   0   0   0⎥
⎣ 0   0   0   0⎦

⎡ 0   0   0   0⎤
⎢ 0   0   0   0⎥
⎣ 0   0   0  12⎦

tensor g:
⎡ 0   0   0⎤
⎢ 0   0   0⎥
⎢ 0   0   0⎥
⎣ 0   0  12⎦

tensor f dot g:
⎡  0    0    0⎤
⎢  0    0    0⎥
⎣  0    0    0⎦

⎡  0    0    0⎤
⎢  0    0    0⎥
⎣  0    0  144⎦

我们看到大于2阶的高阶tensor也可以做点积,只要其形状匹配遵循与前面2阶张量相同的原则:

(a, b, c, d) . (d,) -> (a, b, c)
(a, b, c, d) . (d, e) -> (a, b, c, e)

4.2. 转置

转置张量包括翻转其行和列。这是机器学习算法中的一个常见操作,广泛应用在图像处理和自然语言处理等领域。在Go中,我们可以使用tensor包提供的Transpose函数对tensor进行转置:

// https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations/tensor_transpose.go

func main() {

    // define two-rank tensor
    ta := tensor.New(tensor.WithBacking([]float32{1, 2, 3, 4, 5, 6}), tensor.WithShape(3, 2))
    fmt.Println("\ntensor a:")
    fmt.Println(ta)

    tb, err := tensor.Transpose(ta)
    if err != nil {
        fmt.Println("transpose error:", err)
        return
    }
    fmt.Println("\ntensor a transpose:")
    fmt.Println(tb)

    // define three-rank tensor
    tc := tensor.New(tensor.WithBacking([]float32{1, 2, 3, 4, 5, 6,
        7, 8, 9, 10, 11, 12,
        13, 14, 15, 16, 17, 18,
        19, 20, 21, 22, 23, 24}), tensor.WithShape(2, 3, 4))
    fmt.Println("\ntensor c:")
    fmt.Println(tc)
    fmt.Println("tc shape:", tc.Shape())

    td, err := tensor.Transpose(tc)
    if err != nil {
        fmt.Println("transpose error:", err)
        return
    }
    fmt.Println("\ntensor c transpose:")
    fmt.Println(td)
    fmt.Println("td shape:", td.Shape())
}

运行上面示例:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run tensor_transpose.go

tensor a:
⎡1  2⎤
⎢3  4⎥
⎣5  6⎦

tensor a transpose:
⎡1  3  5⎤
⎣2  4  6⎦

tensor c:
⎡ 1   2   3   4⎤
⎢ 5   6   7   8⎥
⎣ 9  10  11  12⎦

⎡13  14  15  16⎤
⎢17  18  19  20⎥
⎣21  22  23  24⎦

tc shape: (2, 3, 4)

tensor c transpose:
⎡ 1  13⎤
⎢ 5  17⎥
⎣ 9  21⎦

⎡ 2  14⎤
⎢ 6  18⎥
⎣10  22⎦

⎡ 3  15⎤
⎢ 7  19⎥
⎣11  23⎦

⎡ 4  16⎤
⎢ 8  20⎥
⎣12  24⎦

td shape: (4, 3, 2)

接下来,我们再来探讨两个张量的高级操作:重塑(也叫变形)与广播。

5. 在Go中重塑与广播张量

在机器学习算法中,经常需要对张量进行重塑和广播,使其与不同的操作兼容。Go提供了几个函数来重塑和广播张量。让我们来探讨如何在Go中重塑和广播张量。

5.1. 重塑张量

重塑一个张量涉及到改变它的尺寸到一个新的形状。在Go中,我们可以使用Gorgonia/tensor提供的Dense类型的Reshape方法来重塑张量自身。

下面是一个使用Gorgonia重塑张量的示例代码:

// https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations/tensor_reshape.go

func main() {

    // define two-rank tensor
    ta := tensor.New(tensor.WithBacking([]float32{1, 2, 3, 4, 5, 6}), tensor.WithShape(3, 2))
    fmt.Println("\ntensor a:")
    fmt.Println(ta)
    fmt.Println("ta shape:", ta.Shape())

    err := ta.Reshape(2, 3)
    if err != nil {
        fmt.Println("reshape error:", err)
        return
    }
    fmt.Println("\ntensor a reshape(2,3):")
    fmt.Println(ta)
    fmt.Println("ta shape:", ta.Shape())

    err = ta.Reshape(1, 6)
    if err != nil {
        fmt.Println("reshape error:", err)
        return
    }
    fmt.Println("\ntensor a reshape(1, 6):")
    fmt.Println(ta)
    fmt.Println("ta shape:", ta.Shape())

    err = ta.Reshape(2, 1, 3)
    if err != nil {
        fmt.Println("reshape error:", err)
        return
    }
    fmt.Println("\ntensor a reshape(2, 1, 3):")
    fmt.Println(ta)
    fmt.Println("ta shape:", ta.Shape())
}

运行上述代码,我们将看到:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run tensor_reshape.go

tensor a:
⎡1  2⎤
⎢3  4⎥
⎣5  6⎦

ta shape: (3, 2)

tensor a reshape(2,3):
⎡1  2  3⎤
⎣4  5  6⎦

ta shape: (2, 3)

tensor a reshape(1, 6):
R[1  2  3  4  5  6]
ta shape: (1, 6)

tensor a reshape(2, 1, 3):
⎡1  2  3⎤
⎡4  5  6⎤

ta shape: (2, 1, 3)

由此看来,张量转置其实是张量重塑的一个特例,只是将将轴对调。

5.2. 广播张量

广播张量涉及到扩展其维度以使其与其他操作兼容。下面是鱼书中关于广播(broadcast)的图解:

我们看到图中这个标量(Scalar)扩展维度后与第一个张量做乘法操作,与我们前面说到的张量与标量(scalar)相乘是一样的。如上图中这种标量10被扩展成了2 × 2的形状后再与矩阵A进行乘法运算,这个的功能就称为广播(broadcast)。

在鱼书中还提到了“借助这个广播功能,不同形状的张量之间也可以顺利地进行运算”以及下面图中这个示例:

但Gorgonia/tensor包目前并不支持除标量之外的“广播”。

6. 小结

张量操作在机器学习和数据科学中是必不可少的,它允许我们有效地操纵多维数组。在这篇文章中,我们探讨了如何使用Go创建和执行基本和高级张量操作。我们还学习了广播和重塑张量,使它们与不同的机器学习模型兼容。

我希望这篇文章能为后续继续探究深度学习与神经网络奠定一个基础,让你开始探索Go中的张量操作,并使用它们来解决现实世界的问题。

注:说实话,Go在机器学习领域的应用并不广泛,前景也不明朗,零星的几个开源库似乎也不是很活跃。这里也仅是基于Go去学习理解机器学习的概念和操作,真正为生产编写和训练的机器学习模型与程序还是要使用Python。

本文涉及的源码可以在这里下载 – https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations

7. 参考资料


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats