numpy中reshape，multiply函数

multiply(a,b)就是个乘法。

一. 如果a,b是两个数组，那么对应元素相乘.

1. 先来介绍下reshape（）

>>> from numpy import *
>>> a = array([[1,2,3], [4,5,6]])
>>> reshape(a, (3,-1))
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> 

其中的参数-1表示懒得计算该填什么数字，由python通过a和另一个参数3推测出来。

例：下面是两张2*3大小的照片(不知道有几张照片用-1代替)，如何把所有二维照片给摊平成一维

>>> image = array([[[1,2,3], [4,5,6]], [[1,1,1], [1,1,1]]])
>>> image.shape
(2L, 2L, 3L)
>>> image.reshape((-1, 6))
array([[1, 2, 3, 4, 5, 6],
       [1, 1, 1, 1, 1, 1]])
>>> 

从上面可以看出(2L, 2L, 3L)代表的是2张图片，每张图片是2行3列的数组；而reshape((-1, 6)处理之后，得到的是6列的数组，至于多少行由python匹配原数组后判断。

又一例：tensorflow在做卷积神经网络入门的手写数字识别时
源码：x_image = tf.reshape(x, [-1, 28, 28, 1])
这里是将一组图像矩阵x重建为新的矩阵，该新矩阵的维数为（a，28，28，1），其中-1表示a由实际情况来定。例如，x是一组图像的矩阵（假设是50张，大小为56×56），则执行x_image = tf.reshape(x, [-1, 28, 28, 1])可以计算a=50×56×56/(28*28*1)=200。即x_image的维数为（200，28，28，1）。其中x_image的维数为（200，28，28，1）意思是：表示200张28x28的图像。因为tensorflow做图像处理时的input一般是一组图像，那么（200，28，28，3）就表示200张28x28的3通道彩色图像。

参考： https://www.zhihu.com/question/52684594

2. multiply是ufunc函数
当我们使用ufunc函数对两个数组进行计算时，ufunc函数会对这两个数组的对应元素进行计算，因此它要求这两个数组有相同的大小(shape相同)。如果两个数组的shape不同的话，会进行如下的广播(broadcasting)处理：

1. 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
2. 输出数组的shape是输入数组shape的各个轴上的最大值
3. 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错
4. 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值

实例：

这是两个数组加的情况：先创建一个二维数组a，其shape为(6,1)：

# -*- coding: utf-8 -*-
import numpy as np
a = np.arange(0, 60, 10).reshape(-1, 1)
print "a:",a
b = np.arange(0, 5)
print 'b:',b
c = a + b
print "c:",c ,c.shape
>>> 

运行结果：

>>> runfile('C:/Users/LiLong/Desktop/test.py', wdir='C:/Users/LiLong/Desktop')
a: [[ 0]
 [10]
 [20]
 [30]
 [40]
 [50]]
b: [0 1 2 3 4]  (5L,)
c: [[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]
 [50 51 52 53 54]] (6L, 5L)
>>> 

计算a和b的和，得到一个加法表，它相当于计算a,b中所有元素组的和，得到一个shape为(6,5)的数组。

注：

• 由于a和b的shape长度不同，此时需要让b的shape向a对齐，于是将b的shape前面加1，补齐为(1,5)。相当于做了如下计算：

>>> b
array([0, 1, 2, 3, 4])
>>> b.shape=1,5
>>> b
array([[0, 1, 2, 3, 4]])
>>> 

这一步可以看出处理前后的区别。
（其中：arange和range的一个区别就是使用arange前先引入numpy，range不需要，使用一个参数看看range和arange有什么表现。range返回从0到4的5个数构成的列表（list），而arange返回一个数组（array）对象。不过他们的元素都是一样的）

In [1]range(5)
Out[1]: [0, 1, 2, 3, 4]

In [2]:from numpy import *

In [3]:arange(5)
Out[3]: array([0, 1, 2, 3, 4])

• 这样加法运算的两个输入数组的shape分别为(6,1)和(1,5)，根据规则2，输出数组的各个轴的长度为输入数组各个轴上的长度的最大值，可知输出数组的shape为(6,5)。由于b的第0轴上的长度为1，而a的第0轴上的长度为6，因此为了让它们在第0轴上能够相加，需要将b在第0轴上的长度扩展为6，这相当于：

>>> b.repeat(6,axis=0)
array([[0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4]])
>>> 

由于a的第1轴的长度为1，而b的第一轴长度为5，因此为了让它们在第1轴上能够相加，需要将a在第1轴上的长度扩展为5，这相当于：

>>> a = a.repeat(5, axis=1)
>>> a
array([[ 0,  0,  0,  0,  0],
       [10, 10, 10, 10, 10],
       [20, 20, 20, 20, 20],
       [30, 30, 30, 30, 30],
       [40, 40, 40, 40, 40],
       [50, 50, 50, 50, 50]])
>>> 

经过上述处理之后，a和b就可以按对应元素进行相加运算了。

同理得到两个数组相乘的情况：

>>> x1=arange(9).reshape((3, 3))
>>> x2 = arange(3)
>>> x1
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> x2
array([0, 1, 2])
>>> multiply(x1, x2)
array([[ 0,  1,  4],
       [ 0,  4, 10],
       [ 0,  7, 16]])
>>> 

分析过程和相加的相同，只不过换成对应元素相乘。

参考： http://blog.csdn.net/qq_18433441/article/details/54868889

二. 如果a,b是两个矩阵

矩阵点乘：矩阵对应元素相乘

>>> a1=mat([1,1]);
>>> a2=mat([2,2])
>>> multiply(a1,a2)
matrix([[2, 2]])
>>> 

得到的是和矩阵相乘相同的形式

矩阵相乘：

>>> a1=mat([1,2]);  
>>> a2=mat([[1],[2]])
>>> a1
matrix([[1, 2]])
>>> a2
matrix([[1],
        [2]])
>>> shape(a1)
(1L, 2L)
>>> shape(a2)
(2L, 1L)
>>> a1*a2
matrix([[5]])
>>> 

1*2的矩阵乘以2*1的矩阵，得到1*1的矩阵

以后遇到别的再学习。。