Numpy Tricks

程序设计

Element Wise Max

np.maximum.reduce([a,b])

Ground Truth

Y = np.hstack([ np.eye(k), np.zeros(k, n - k) ])
Y = Y[:, y]

Random Integer Matrix

a = np.random.randint(10, size=(3,3))

Set Some Rows Zeros

a[a < 0] = 0

Count True

np.sum(a)

Stack Matrix

np.tile(m, (w, h))

Bool Matrix To Binary Matrix

np.array(b, dtype=int)

Add Rows With Same Classes

Add only rows with same classes, by convert row class vector to ground true table.

n = 3
m = 4
k = 2
X = np.random.randint(10, size=(n, m))
y = [0, 1, 0]
# Add row 0 and row 2 into one row, and row 1 into another row.
Y = np.hstack([ np.eye(k), np.zeros(k, n - k) ])
Y = Y[:, y]
np.dot(Y, X.T)

Random Pickup

np.random.choice(range, n)

Reverse array

a[:, :, -1]

Diagonal line

np.diag(M)

Make Read-only

M.flags.writeable = False

Row Mean

M.mean(axis=1, keepdims=True)

Sorted Index

M.argsort()

Use Generator

def gen():
    for i in xrange(10):
        yield i
a = np.fromiter(gen(), dtype=float, count=-1)

Find Unique Elements

np.unique(z)

Sum Over Axis

A = np.random.randint(10, size=(2,2,3,4))
B = A.reshape(A.shape[:, -2] + (-1,))
print np.sum(B, axis=-1)

Diagonal of Matrix Product

np.sum(A * B.T, axis=1)
# Faster version
np.einsum("ij,ji->i", A, B)

Swap 2 Rows

A[[r1, r2]] = A[[r2, r1]]

Construct Gaussian Kernel

import scipy.ndimage.filters as flt
inp = np.zeros((ksize, ksize))
inp[ksize / 2, ksize / 2] = 1
kern = flt.gaussian_filter(inp, sigma)

SciPY Image Operations

NOTE: It's different from cv2 ops, DO NOT mix them.

from scipy.misc import imread, imsave, imresize
# imread('x.png', True) returns gray-scale
img = imread('x.png')
print img.dtype, img.shape  # Prints "uint8 (400, 248, 3)"
img_tinted = img * [1, 0.95, 0.9]
img_tinted = imresize(img_tinted, (300, 300))
imsave('y.png', img_tinted)

Matplotlib

Plot:

import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on sine and cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
# Plot the points using matplotlib
plt.plot(x, y_sin)
plt.plot(x, y_cos)
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('Sine and Cosine')
plt.legend(['Sine', 'Cosine'])
plt.show()

Subplot:

import numpy as np
import matplotlib.pyplot as plt
# Compute the x and y coordinates for points on sine and cosine curves
x = np.arange(0, 3 * np.pi, 0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
# Set up a subplot grid that has height 2 and width 1,
# and set the first such subplot as active.
plt.subplot(2, 1, 1)
# Make the first plot
plt.plot(x, y_sin)
plt.title('Sine')
# Set the second subplot as active, and make the second plot.
plt.subplot(2, 1, 2)
plt.plot(x, y_cos)
plt.title('Cosine')
# Show the figure.
plt.show()

Show image:

import numpy as np
from scipy.misc import imread, imresize
import matplotlib.pyplot as plt
img = imread('assets/cat.jpg')
img_tinted = img * [1, 0.95, 0.9]
# Show the original image
plt.subplot(1, 2, 1)
plt.imshow(img)
# Show the tinted image
plt.subplot(1, 2, 2)
# A slight gotcha with imshow is that it might give strange results
# if presented with data that is not uint8. To work around this, we
# explicitly cast the image to uint8 before displaying it.
plt.imshow(np.uint8(img_tinted))
plt.show()

Show Gray-Scale Image:

plt.imshow(img, cmap="Greys_r")

Change All sign or Negate all boolean

np.logical_not(a)
np.negative(b)

For Each Row / Column in Matrix

# ufunc can be add / multiply
np.ufunc.reduce(A, axis)

Generate Gaussian random

g = np.random.normal(scale=0, size=(2,2))

Matrix max index

(i, j) = np.unravel_index(x.argmax(), x.shape)

Swap dimension

# I is a list of 8 1*28*28 images.
# Show them in one image.
imshow(I.transpose(1, 0, 2).reshape(28, 8*28), cmap='gray')
# Or, diff is a 20 5*5 images list.
imshow(diff.reshape(4, 5, 5, 5)
    .transpose(0, 2, 1, 3).reshape(4*5, 5*5), cmap='gray')

[W1, W2] * [x1; x2]

Not necessary to produce temporary array [ x1; x2 ], all you need is W1 * x1 + W2 * x2.