deeplearning 常用python工具包使用

matplotlib.plot

plt.scatter()

功能

绘制点图

源码

1
2
3
def scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None,
vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None,
hold=None, data=None, **kwargs)

主要参数解释:

s表示点点的大小,c就是color,marker就是点点的形状哦o,x,*><^,都可以
alpha表示点点的亮度,label是标签(图例)

用法

1
2
3
4
5
6

def testScatter():
c1=[1,2,3]
c2=[1,2,3]
plt.scatter(c1,c2,s=30,c='red',marker='o',alpha=0.5,label='C1')
plt.show()

结果:

image-20181112084050719

plt.contourf()

功能

绘制等高线

用法

contourf有三个主要参数:

  • x:x数据
  • y:y数据
  • z:z数据,实际上z的数值决定了对应(x,y)点的颜色

此外,还可以设置将等高线分为几个部分。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 定义等高线高度函数
def f(x, y):
return x-y



def testContourf():
# 数据数目
n = 256
# 定义x, y
x = np.linspace(-3, 3, n)
y = np.linspace(-3, 3, n)

# 生成网格数据
X, Y = np.meshgrid(x, y)

# 填充等高线的颜色,4是将区域分为几个部分
plt.contourf(X, Y, f(X, Y), 4,alpha=0.75, cmap=plt.cm.Spectral)
# 绘制等高线
C = plt.contour(X, Y, f(X, Y), 4, colors='black', linewidth=0.5)
# 绘制等高线数据
plt.clabel(C, inline=True, fontsize=10)

# 去除坐标轴
plt.xticks(())
plt.yticks(())
plt.show()

结果:

image-20181114124929977

numpy

np.squeeze()

功能

从数组的形状中删除单维条目,即把shape中为1的维度去掉

源码

1
def squeeze(a, axis=None):

a时待处理的数组/矩阵,axis是待删除的维度,默认为所有维度为1的维度,注意如果要手动指定axis,则必须要求设定的axis对应的维度必须为1,否则会报错。

用法

1
2
3
4
a=np.random.randn(1,3,1)
b=np.squeeze(a)
print(a.shape)
print(b.shape)

输出:

image-20181112093151895

可以看到当数组中含有维度1时squeeze会删除维度为1的维度。

np.power()

功能

计算元素的n次方

源码

1
def power(x1, x2, *args, **kwargs):

x1是被次方对象,x2时指数,可以是数字也可以是数组,但是要保证x1和x2的列数相同。

使用

1
2
3
4
5
a = np.array([1,2,3])
print(a)
c=np.array([1,2,3])
b=np.power(a,c)
print(b)

输出:

image-20181112093855210

np.meshgrid()

功能

用两个坐标轴上的点在平面上画网格

源码

1
2
3

# Based on scitools meshgrid
def meshgrid(*xi, **kwargs)

使用

  • [X,Y]=meshgrid(x,y)
  • [X,Y]=meshgrid(x)与[X,Y]=meshgrid(x,x)是等同的
  • [X,Y,Z]=meshgrid(x,y,z)生成三维数组,可用来计算三变量的函数和绘制三维立体图

以[X,Y]=meshgrid(x,y)为例,其意义是将向量x和y定义的区域转换成矩阵X和Y,其中矩阵X的行向量是向量x的简单复制,而矩阵Y的列向量是向量y的简单复制,假设x是长度为m的向量,y是长度为n的向量,则最终生成的矩阵X和Y的维度都是 (n,m) (注意不是(m,n))。

1
2
3
4
5
6
7
8
9
10
11
12

def testMeshgrid():
a = [1, 2, 3]
b = [4, 5, 6]
print(a)
print(b)
[x, y] = np.meshgrid(a, b)
print(x)
print(y)
plt.figure()
plt.scatter(x,y)
plt.show()

image-20181113232921431

np.c&np.r

  • np.r_是按连接两个矩阵,就是把两矩阵上下相加,要求列数相等,类似于pandas中的concat()。

  • np.c_是按连接两个矩阵,就是把两矩阵左右相加,要求行数相等,类似于pandas中的merge()。

使用

1
2
3
4
5
6
7
8
9
10

def testNumpy_r_c():
a=np.array([[1,2,3],[4,5,6]])
b=np.array([[7,8,9],[10,11,12]])
c=np.r_[a,b]
d=np.c_[a,b]
print(a)
print(b)
print(c)
print(d)

输出:

image-20181113233738216

注意

1
2
3
np.r_[a,b] 而不是np.r_(a,b)

np.c_[a,b] 而不是np.c_(a,b)

np.flatten()&np.ravel()

功能

两者所要实现的功能是一致的(将多维数组降位一维),两者的区别在于返回拷贝(copy)还是返回视图(view):

  • numpy.flatten()返回一份拷贝,对拷贝所做的修改不会影响(reflects)原始矩阵,对原来数组做的操作也不会影响拷贝的数组。

  • numpy.ravel()返回的是视图(view,也颇有几分C/C++引用reference的意味),会影响(reflects)原始矩阵。

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def test_ravel_flatten():
x = np.array([[1, 2], [3, 4]])
print(x)
print()

a=x.flatten()
print(x)
print(a)
x[0][0] = 10
x[0][1] = 20
print(a)

a[0]=-1
print(x)
print()


b=x.ravel()
print(x)
print(b)
x[0][0] = 30
x[0][1] = 40
print(b)
b[0]=-1
print(x)

输出:

image-20181113235643730

注意看对a和b与x之间的互相影响关系。

numpy除法运算

保留小数部分的除法

  • np.divide(x,n)
  • np.true_divide(x,n)
  • x/n

向下取整的除法

  • np.floor_divide(x,n)
  • x//n

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
x = np.array([[1, 3], [5, 7]])
print(x)
d_x=np.divide(x,2)
print(d_x)
d_x2=x/2
print(d_x2)

d_x3=np.true_divide(x,2)
print(d_x3)

d_x4=np.floor_divide(x,2)
print(d_x4)

d_x5=x//2
print(d_x5)

运行结果:

image-20181123175610209

np.square()

功能

计算矩阵中每个元素的平方

使用

1
2
3
4
5
def testSquare():
x = np.arange(5, 10)
print(x)
y=np.square(x)
print(y)

输出:

image-20181213163717096

randn&rand

功能

  • numpy.random.randn(d0, d1, …, dn)*是从标准正态分布中返回一个或多个样本值。*
  • numpy.random.rand(d0, d1, …, dn)的随机样本位于[0, 1)中。

使用

1
2
3
4
5
6
7
8
9
import numpy as np

arr1 = np.random.randn(1,10)
print("np.random.randn结果如下:")
print(arr1)
print('******************************************************************')
print("np.random.rand结果如下:")
arr2 = np.random.rand(1,10)
print(arr2)

输出:

v2-c2d3ef17157e94783bfe116bf4b9c292_hd

np.linalg.norm()

功能

linalg=linear(线性)+algebra(代数),norm则表示范数,所以就是求矩阵的范数,范数一般是对一批数据求的,比如[x1,x2,x3]具体参数如下:

1
x_norm=np.linalg.norm(x, ord=None, axis=None, keepdims=False)
  • x:表示矩阵,可以是一维的

  • ord表示范数的类型,具体类型如下:

    屏幕快照 2018-12-13 20.52.14

ord=1:列和的最大值

ord=2(默认):|λE-ATA|=0,求特征值,然后求最大特征值的算术平方根

ord=∞:行和的最大值

  • axis:处理类型

    axis=1:表示按行向量处理,求多个行向量的范数

    axis=0:表示按列向量处理,求多个列向量的范数

    axis=None(默认):表示矩阵范数。

  • keepdims:是否保持矩阵的二维特性

    True表示保持矩阵的二维特性,False相反

np.copy()

功能

copy()用来拷贝矩阵,这个拷贝属于复制即deep copy,而直接的‘=’是numpycopy,效果来说就是通过copy拷贝的目标矩阵和原矩阵没关系,而‘=’拷贝的目标矩阵会和原矩阵有关联,修改‘=’拷贝后的值会和原来的矩阵互相有影响。

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def testCopy():
print('')
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
b=np.copy(a)
c=a
print(b)
print(a)
b[0][0]=100
print(a)
c[0][0]=101
print(a)
a[0][0]=200
print(b)
print(c)

运行结果:

image-20181214091042506

np.pad()

功能

用于对指定数组进行padding填充

源码

pad(array, pad_width, mode, **kwargs)

返回值:数组

参数解释:

array——表示需要填充的数组;

pad_width——表示每个轴(axis)边缘需要填充的数值数目。

pad_width参数输入方式为:((before_1, after_1), … (before_N, after_N)),其中(before_1, after_1)表示第1轴两边缘分别填充before_1个和after_1个数值。取值为:{sequence, array_like, int}

mode——表示填充的方式(取值:str字符串或用户提供的函数),总共有11种填充模式;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
‘constant’——表示连续填充相同的值,每个轴可以分别指定填充值,constant_values=(x, y)时前面用x填充,后面用y填充,缺省值填充0

‘edge’——表示用边缘值填充

‘linear_ramp’——表示用边缘递减的方式填充

‘maximum’——表示最大值填充

‘mean’——表示均值填充

‘median’——表示中位数填充

‘minimum’——表示最小值填充

‘reflect’——表示对称填充

‘symmetric’——表示对称填充

‘wrap’——表示用原数组后面的值填充前面,前面的值填充后面

使用

1
2
3
4
5
6
7
8

def testNpPad():
print('')
a = np.random.randn(3, 2)
#第0轴(行)的左边填1个1,第0轴的右边填2个2
b = np.pad(a, ((1, 2), (2, 1)), 'constant', constant_values=((1, 2),(3,4)))
print(a)
print(b)

output:

image-20181225224440499

np.mean和np.average的区别

区别

np.mean直接计算平均数

1
def mean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue):

np.average计算加权平均数(如果有权重weight的话)

1
def average(a, axis=None, weights=None, returned=False):

使用

1
2
3
4
5
6
7
8
def testMeanAverage():
print('')
a = [1,2,3]
c=np.mean(a)
d=np.average(a,weights=[0.1,0.2,0.7])
print(a)
print(c)
print(d)

output:

image-20181226222907785

tf

tf.reduce_sum()

  • 求和

    tf.reduce_sum(x) ==> 6

  • 按列求和

    tf.reduce_sum(x, 0) ==> [2, 2, 2]

  • 按行求和

    tf.reduce_sum(x, 1) ==> [3, 3]

  • 按照行的维度求和

    tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]]

  • 行列求和

    tf.reduce_sum(x, [0, 1]) ==> 6

tf.square()

1
tf.square()

对a里的每一个元素求平方

tf.subtract()

减法:

1
2
3
4
5
tf.math.subtract(
x,
y,
name=None
)

返回x-y

tf.add()

加法:

1
2
3
4
5
tf.math.add(
x,
y,
name=None
)

返回x+y

tf.maximum()

1
2
3
4
5
tf.math.maximum(
x,
y,
name=None
)

返回x和y中较大的值

tf.argmax()

求最大值对应的下标

tf.reduce_max()

计算最大值

tf.boolean_mask(a,b)

对张量(维度维m维)应用布尔掩码,并将结果展开到m-1维。。Numpy 等同于 tensor[mask]。

1
2
3
4
5
boolean_mask ( 
tensor ,
mask ,
name = 'boolean_mask'

ARGS:

  • tensor:N 维 张量。
  • mask:K 维布尔张量,K <= N 和 K 必须是静态已知的。
  • name:此操作的名称(可选)。

返回:

返回(N-K + 1)维张量由条目中填充的 tensor 对应于 mask 中的 True 值。

注意:

  • ValueError:如果形状不符合时。

使用实例:

1
2
3
4
2-D示例 
tensor = [ [ 12 ] , [ 34 ] , [ 56 ] ] #shape:(3,2)
mask = np.array([TrueFalseTrue] ) #shape:(1,3)
tf.boolean_mask (tensor,mask) == > [ [ 12 ] , [ 56 ] ]#shape:(2,2)

tf.image.non_max_suppression

1
2
3
4
5
6
7
8
tf.image.non_max_suppression(
boxes,
scores,
max_output_size,
iou_threshold=0.5,
score_threshold=float('-inf'),
name=None
)

实现非极大值抑制non max suppression,其中boxes是不同boxes的坐标,scores是不同boxes预测的分数,max_output_size是保留的最大box的个数。

iou_threshold是一个阈值,去掉大于这个阈值的所有boxes。

返回:

  • selected_indices:形状为[M]的一维整数Tensor,表示从box张量中选择的指数,其中M <= max_output_size。

tf.transpose

功能

参数:

1
tf.transpose(input, [dimension_1, dimenaion_2,..,dimension_n])

这个函数主要适用于交换输入张量的不同维度用的,如果输入张量是二维,就相当是转置。dimension_n是整数,如果张量是三维,就是用0,1,2来表示。这个列表里的每个数对应相应的维度。如果是[2,1,0],就把输入张量的第三维度和第一维度交换。

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
import tensorflow as tf;
import numpy as np;

A = np.array([[1,2,3],[4,5,6]])
x = tf.transpose(A, [1,0])

B = np.array([[[1,2,3],[4,5,6]]])
y = tf.transpose(B, [2,1,0])
with tf.Session() as sess:
print A[1,0]
print sess.run(x[0,1])
print B[0,1,2]
print sess.run(y[2,1,0])

Output:

1
2
3
4
4
4
6
6

tf.reshape()

功能

参数:

1
tf.reshape(tensor, shape, name=None)

作用是将tensor变换为参数shape的维度。
其中shape为一个列表形式,特殊的一点是列表中可以存在-1。-1代表的含义是不用我们自己指定这一维的大小,函数会自动计算,但列表中只能存在一个-1。(当然如果存在多个-1,就是一个存在多解的方程了)

tf.matmul

功能

参数:

1
tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)

计算两个矩阵的乘法,可以通过参数 transpose_a或transpose_b来设置矩阵在乘法之前进行转置,这时这些标志位应该设置为True,默认是False。

如果知道某一个矩阵有比较多0元素存在,也就是说存在稀疏矩阵,这时候可以通过设置参数a_is_sparse 或 b_is_sparse标志为True,这样可以大大优化矩阵的乘法计算。但张量的形式必须为2,数据类型为 float16 or float32。

keras

K.gather()

1
gather(reference,indices)

在给定的张量中搜索给定下标的向量。

参数:reference表示被搜寻的向量;

indices表示整数张量,要查询的元素的下标。

返回值:一个与参数reference数据类型一致的张量。

参考

1:https://blog.csdn.net/lanchunhui/article/details/50354978

2:https://www.cnblogs.com/xieshengsen/p/6822772.html

3:https://morvanzhou.github.io/tutorials/data-manipulation/np-pd/2-8-np-copy/

4:https://www.jianshu.com/p/802c399a96ba

5:https://www.tensorflow.org/api_docs/python/tf/math

6:https://blog.csdn.net/jacke121/article/details/80087823

如果觉得有帮助就请我喝杯咖啡鼓励我继续创作吧^_^