Numpy Tips

[lamb]

Numpy Tips

（CS231assignment1博客链接）

np.ewaxis

• insert new dimension

a = np.array([1,2,3,4,5])
b = a[np.newaxis,:]
print a.shape,b.shape
print a
print b

(5,)(1, 5)

[1 2 3 4 5]

[[1 2 3 4 5]]

a = np.array([1,2,3,4,5])
b = a[:,np.newaxis]
print a.shape,b.shape
print a
print b

(5,) (5, 1)
[1 2 3 4 5]
[[1]
 [2]
 [3]
 [4]
 [5]]

squeeze

a = np.arange(10).reshape(1,10)
b = np.squeeze(a)

array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

change to

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

zero_like

>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
       [3, 4, 5]])
>>> np.zeros_like(x)
array([[0, 0, 0],
       [0, 0, 0]])

np.random.randn

• np.random.randn(10,3200)

np.argmax

• y_pred = np.argmax(score,axis=1)

tuple

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 可使用del tup1
 
    
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3

results = {}

results[(lr,rs)] = train_accuracy, val_accuracy

lambda

add = lambda x, y: x + y

print(add(3, 5))
# Output: 8

a = [(1, 2), (4, 1), (9, 10), (13, -3)]
a.sort(key=lambda x: x[1])

print(a)
# Output: [(13, -3), (4, 1), (1, 2), (9, 10)]

array_split，setdefault，.items()

X_train_folds=np.array(np.array_split(X_train,5))

X_train.shape
>>>(5000, 3072)
X_train_folds.shape
>>>(5,1000, 3072)

• tip:在进行交叉验证时，在切分数据集前，可先令y_train_ = y_train.reshape(-1, 1)，再用np.vstack ，最后y_val_train = y_val_train[:,0]

• tip:字典处理。k_to_accuracies = {}然后k_to_accuracies.setdefault(k_, [])，再用list记录对应k的正确率（每种数据集，每个k对应一个正确率）k_to_accuracies[k_] = k_to_accuracies[k_] + [accuracy]。

  example:

  num_folds = 5
  k_choices = [1, 3, 5, 8, 10, 12, 15, 20, 50, 100]
  
  X_train_folds = []
  y_train_folds = []
  
  y_train_ = y_train.reshape(-1, 1)
  X_train_folds , y_train_folds = np.array_split(X_train, 5), np.array_split(y_train_, 5)
  
  k_to_accuracies = {}
  
  for k_ in k_choices:
      k_to_accuracies.setdefault(k_, [])
  for i in range(num_folds):
      classifier = KNearestNeighbor()
      X_val_train = np.vstack(X_train_folds[0:i] + X_train_folds[i+1:])
      y_val_train = np.vstack(y_train_folds[0:i] + y_train_folds[i+1:])
      y_val_train = y_val_train[:,0]
      classifier.train(X_val_train, y_val_train)
      for k_ in k_choices:
          y_val_pred = classifier.predict(X_train_folds[i], k=k_)
          num_correct = np.sum(y_val_pred == y_train_folds[i][:,0])
          accuracy = float(num_correct) / len(y_val_pred)
          k_to_accuracies[k_] = k_to_accuracies[k_] + [accuracy]
          
  # Print out the computed accuracies
  for k in sorted(k_to_accuracies):
      for accuracy in k_to_accuracies[k]:
          print('k = %d, accuracy = %f' % (k, accuracy))
  

• k_to_accuracies.items()取出字典对应值。

  for k,v in sorted(k_to_accuracies.items()):
      print(k)
      print(v)
  >>>
  [0.263, 0.257, 0.264, 0.278, 0.266]
  3
  [0.239, 0.249, 0.24, 0.266, 0.254]
  5
  [0.248, 0.266, 0.28, 0.292, 0.28]
  ……
  

np.maximum

np.mean

np.std

• X /= np.std(X, axis = 0)

.copy()

• dscores = softmax_output.copy()

example of cs231

• scores_correct=scores[np.arange(num_train),y]
• np.mean(Yte_predict == Yte)