详解Numpy中的广播原则/机制-6ren

详解Numpy中的广播原则/机制

转载作者：qq735679552 更新时间：2022-09-27 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章详解Numpy中的广播原则/机制由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

广播的原则。

如果两个数组的后缘维度(从末尾开始算起的维度)的轴长度相符或其中一方的长度为1，则认为它们是广播兼容的。广播会在缺失维度和(或)轴长度为1的维度上进行.

在上面的对arr每一列减去列平均值的例子中，arr的后缘维度为3，arr.mean(0)后缘维度也是3，满足轴长度相符的条件，广播会在缺失维度进行.

这里有点奇怪的是缺失维度不是axis=1，而是axis=0，个人理解是缺失维度指的是两个arr除了轴长度匹配的维度，在上面的例子中,正好是axis=0。这块欢迎指正。

arr.mean(0)沿着axis=0广播，可以看作是把arr.mean(0)沿着竖直方向复制4份,即广播的时候arr.mean(0)相当于一个shape=(4,3)的数组,数组的每一行均相同,均为arr.mean(0) 。

为了了解这个原则，首先我们来看一组例子:

 
    ? 
   
 
     
       
       
         # 数组直接对一个数进行加减乘除，产生的结果是数组中的每个元素都会加减乘除这个数。 
        
 
         In [ 
         12 
         ]:  
         import 
         numpy as np 
        
 
         In [ 
         13 
         ]: a  
         = 
         np.arange( 
         1 
         , 
         13 
         ).reshape(( 
         4 
         ,  
         3 
         )) 
        
 
         In [ 
         14 
         ]: a  
         * 
         2 
        
 
         Out[ 
         14 
         ]: array([[  
         2 
         ,  
         4 
         ,  
         6 
         ], 
        
 
              
         [  
         8 
         ,  
         10 
         ,  
         12 
         ], 
        
 
              
         [ 
         14 
         ,  
         16 
         ,  
         18 
         ], 
        
 
              
         [ 
         20 
         ,  
         22 
         ,  
         24 
         ]]) 
        
 
         # 接下来我们看一下数组与数组之间的计算 
        
 
         In [ 
         17 
         ]: b  
         = 
         np.arange( 
         12 
         , 
         24 
         ).reshape(( 
         4 
         , 
         3 
         )) 
        
 
         In [ 
         18 
         ]: b 
        
 
         Out[ 
         18 
         ]: array([[ 
         12 
         ,  
         13 
         ,  
         14 
         ], 
        
 
              
         [ 
         15 
         ,  
         16 
         ,  
         17 
         ], 
        
 
              
         [ 
         18 
         ,  
         19 
         ,  
         20 
         ], 
        
 
              
         [ 
         21 
         ,  
         22 
         ,  
         23 
         ]]) 
        
 
         In [ 
         19 
         ]: a  
         + 
         b 
        
 
         Out[ 
         19 
         ]: array([[ 
         13 
         ,  
         15 
         ,  
         17 
         ], 
        
 
              
         [ 
         19 
         ,  
         21 
         ,  
         23 
         ], 
        
 
              
         [ 
         25 
         ,  
         27 
         ,  
         29 
         ], 
        
 
              
         [ 
         31 
         ,  
         33 
         ,  
         35 
         ]]) 
        
 
         In [ 
         20 
         ]: c  
         = 
         np.array([ 
         1 
         , 
         2 
         , 
         3 
         ]) 
        
 
         In [ 
         21 
         ]: a 
         + 
         c 
        
 
         Out[ 
         21 
         ]: array([[  
         2 
         ,  
         4 
         ,  
         6 
         ], 
        
 
              
         [  
         5 
         ,  
         7 
         ,  
         9 
         ], 
        
 
              
         [  
         8 
         ,  
         10 
         ,  
         12 
         ], 
        
 
              
         [ 
         11 
         ,  
         13 
         ,  
         15 
         ]]) 
        
 
         In [ 
         22 
         ]: d  
         = 
         np.arange( 
         10 
         , 
         14 
         ).reshape(( 
         4 
         , 
         1 
         )) 
        
 
         In [ 
         23 
         ]: d 
        
 
         Out[ 
         23 
         ]: array([[ 
         10 
         ], 
        
 
              
         [ 
         11 
         ], 
        
 
              
         [ 
         12 
         ], 
        
 
              
         [ 
         13 
         ]]) 
        
 
         In [ 
         24 
         ]: a  
         + 
         d 
        
 
         Out[ 
         24 
         ]: array([[ 
         11 
         ,  
         12 
         ,  
         13 
         ], 
        
 
              
         [ 
         15 
         ,  
         16 
         ,  
         17 
         ], 
        
 
              
         [ 
         19 
         ,  
         20 
         ,  
         21 
         ], 
        
 
              
         [ 
         23 
         ,  
         24 
         ,  
         25 
         ]]) 
        
 
         # 从上面可以看出，和线性代数中不同的是，m*n列的m行的一维数组或者n列的一维数组也是可以计算的。 
        
 
     
 
   

这是为什么呢？这里要提到numpy的广播原则:

如果两个数组的后缘维度(从末尾开始算起的维度)的轴长度相符或其中一方的长度为1，则认为它们是广播兼容的。广播会在缺失维度和(或)轴长度为1的维度上进行.

在上面的代码中，a的维度是（4，3），c的维度是（1，3）；d的维度是（4，1）。所以假设有两个数组，第一个的维度是（x_1, y_1, z_1），另一个数组的维度是（x_2, y_2, z_2），要判断这两个数组能不能进行计算，可以用如下方法来判断:

这里需要注意：（3，3，2）和（3，2）是可以运算的，因为对于二维数组（3，2）也可以表示为（1，3，2），套用上述的规则是完全适用的，同理：（4，2，5，4）和（2，1，4）也是可以进行运算的.

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：https://segmentfault.com/a/1190000016460482 。

最后此篇关于详解Numpy中的广播原则/机制的文章就讲到这里了,如果你想了解更多关于详解Numpy中的广播原则/机制的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐：国外idc当下较流行的欧美机房和线路

文章推荐： PHP之uniqid()函数用法

文章推荐： PHP实现Soap通讯的方法

文章推荐： Python 读写文件的操作代码

了解更好的软件工作流程的 OpenGitOps 原则
GitOps描述了一种使用植根于 Git 版本控制系统的方法来操作和管理软件的方法。使用基于 GitOps 的工作流，通过要求将系统的特征定义为 Git 存储库中的文件，可以更轻松地开发、部署、维护和
package - 封装和组件设计指南/原则
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。我们不允许提问寻求书籍、工具、软件库等的推荐。您可以编辑问题，以便用事实和引用来回答。关闭 6 年前。
Java货币转换器秉承OO(面向对象)原则
命令行货币转换器应用程序，提示用户输入源货币、源货币代码和目标货币代码，例如 C:\workspace> java CurrencyConverter 100.50 EUR GBP 应用程序返回源金额
php - 原则 - 在两个日期之间获得销售
得到这个实体: /** * @ORM\Table(name="shop_payment_details") * @ORM\Entity(repositoryClass="Acme\ShopBund
php - 为什么空交易会保留我的实体(原则)？
我有一个原则实体，无需调用 persist 或 flush 即可持久保存到数据库中。我在下面很简单地重现了这个问题。正如您将看到的，此脚本从名为 MyEntity 的数据库表中加载一行，并获取一个以
oop - 前端和后端之间的 DRY 原则
在我的编程实践中，我经常遇到客户端和服务器端脚本之间数据重复的问题。在这种情况下，我们可以讨论客户端的 JavaScript 和服务器端的 PHP 或 C# (ASP.NET)。比方说，我有一段
oop - 违反了哪些 SOLID 原则？
简介我在写关于继承问题的硕士论文并解决了一些问题表明存在继承问题的指标。像下面的例子: 示例 public static String getAnimalNoise(Animal animal)
oop - 更重要的是代码的可测试性还是遵守 OOP 原则？
就目前而言，这个问题不适合我们的问答形式。我们希望答案得到事实、引用资料或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the
python - 在子类型中使用额外的构造函数参数违反了 LSP 原则
当我注意到this answer时，我一直在阅读里氏替换原理。。它有一个 Circle 和一个 ColoredCircle 类型，其中 ColoredCircle 的构造函数需要一个额外的参数；颜
javascript - 具有多个返回值的代码是否违反了 DRY 原则？
这段代码是否违反了DRY原则？ if (notAuthorized) { return sendErrorCode(new ForbiddenException()) } else if (n
caching - 原则 2 结果缓存失效
我在查询中使用 Doctrine 2 的结果缓存来检索用户(消息传递应用程序)的新消息数量: $query->useResultCache(true, 500, 'messaging.nb_new_m
java - 重构代码以尊重 OOP 原则
关闭。这个问题需要多问focused 。目前不接受答案。想要改进此问题吗？更新问题，使其仅关注一个问题 editing this post . 已关闭 8 年前。 Improve this ques
java - 尊重包含类名的变量的 DRY 原则
如何设置包含类名的变量，例如 android.util.Log 中的 TAG，同时尊重 Dont-Repeat-Yourself？以下是一些可能性: 在 Google 代码中，它的常用用法如下 pu
symfony - 原则 2 使用选项数组搜索数组字段
我有以下查询: $roles = array(); $roles[] = 'ROLE_SUPER_ADMIN'; $roles[] = 'ROLE_ADMIN';
java - 下面的代码违反了哪一条 SOLID 原则？
下面的代码违反了哪一条 SOLID 原则？ public class A { void hello(){ //some code here } } public class B ext
php - OOP 原则 - 如何构造类
我目前有一个 Message_Repository 类，它有如下方法: getLocationDetailsByID($messageId), getCustomerDetailsById($mess
c# - 在新的非空测试上使用 ref 原则
我不知道它到底叫什么，但现在我将它称为“非空测试”。在 C# 8 中有一个新的行为允许测试一个对象是否不为空，例如: Foo foo = new Foo(); if(foo is { }) {
php - 原则 2 - 如何在没有特定文章的情况下获取类别
我正在学习 Doctrine。我在多对多关系中有两个实体 Article 和 Category，我正在尝试获取所有不是特定文章的类别。文章实体: class Article extends Base
c# - 重构 SOLID 原则
在阅读了一本书和一篇在线文章中有关 SOLID 代码的内容后，我想重构一个现有的类，使其与“SOLID”兼容。但我想我迷路了，尤其是依赖注入(inject):当我想实例化类的一个对象时，我需要“注入
c# - 这是否违反了 SOLID 原则？
我的项目中有类似的东西，这个项目已经完成了(它正在运行)我只想知道 SOLID 原则是否可以接受 static public class Tools { static public GetPr

qq735679552

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

详解Numpy中的广播原则/机制