1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Display an image on the axes.

Parameters
----------
X : array_like, shape (n, m) or (n, m, 3) or (n, m, 4)
    Display the image in `X` to current axes.  `X` may be an
    array or a PIL image. If `X` is an array, it
    can have the following shapes and types:

    - MxN -- values to be mapped (float or int)
    - MxNx3 -- RGB (float or uint8)
    - MxNx4 -- RGBA (float or uint8)

    The value for each component of MxNx3 and MxNx4 float arrays should  
    be in the range 0.0 to 1.0. MxN arrays are mapped to colors based on
    the `norm` (mapping scalar to scalar) and the `cmap`  
    (mapping the normed scalar to a color).

1
2
3
# python2中 / 是截断除法；在python3中 / 是精确除法, //是截断除法。导入后，/变为精确除法
from __future__ import division
from __future__ import absolute_import

1
2
3
4
# Some more magic so that the notebook will reload external python modules;
# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython
%load_ext autoreload
%autoreload 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
num_classes = len(classes)
samples_per_class = 7
for y, cls in enumerate(classes):    #y is idx
    idxs = np.flatnonzero(y_train == y)
    idxs = np.random.choice(idxs, samples_per_class, replace=False)
    for i, idx in enumerate(idxs):
        plt_idx = i * num_classes + y + 1
        plt.subplot(samples_per_class, num_classes, plt_idx)  #plt_idx从1开始
        plt.imshow(X_train[idx].astype('uint8'))
        plt.axis('off')
        if i == 0:
            plt.title(cls)
plt.show()

1
2
difference = np.linalg.norm(dists - dists_one, ord='fro')
#当difference很小时，人为两个矩阵相等

1
2
3
4
5
6
7
8
9
10
11
12
def time_function(f, *args):
    """
    Call a function f with args and return the time (in seconds) that it took to execute.
    """
    import time
    tic = time.time()
    f(*args)
    toc = time.time()
    return toc - tic

two_loop_time = time_function(classifier.compute_distances_two_loops, X_test)
print('Two loop version took %f seconds' % two_loop_time)

1
2
3
4
5
6
7
8
9
10
11
12
for k in k_choices:
    accuracies = k_to_accuracies[k]
    plt.scatter([k] * len(accuracies), accuracies) # 散点图，同一个横坐标扩展为len(accuracies)个

# plot the trend line with error bars that correspond to standard deviation
accuracies_mean = np.array([np.mean(v) for k,v in sorted(k_to_accuracies.items())])
accuracies_std = np.array([np.std(v) for k,v in sorted(k_to_accuracies.items())])
plt.errorbar(k_choices, accuracies_mean, yerr=accuracies_std)
plt.title('Cross-validation on k')
plt.xlabel('k')
plt.ylabel('Cross-validation accuracy')
plt.show()

1
2
3
closest_y = self.y_train[np.argsort(dists[i])[:k]]
# self.y_train是训练数据label，np.argsort(dists[i])是第i行距离的升序index，取出前k个。
# 注意，y_train[list]这种用法前提是type(y_train)=np.ndarray，通过list中的索引直接取出y_train对应元素

1
2
3
4
5
6
7
Split an array into multiple sub-arrays.
Examples
--------
>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
    [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]
# 最后如果不是整除，剩几个取几个

1
2
3
4
X_val_train = np.vstack(X_train_folds[:i]+X_train_folds[i+1:]) # 垂直拼接
# eg a=[[1,2,3]] b=[[4,5,6]] X_val_train = [[1,2,3],[4,5,6]]
y_val_train = np.hstack(y_train_folds[:i]+y_train_folds[i+1:]) # 水平拼接
# eg a=[[1,2,3]] b=[[4,5,6]] y_val_train = [[1,2,3,4,5,6]]

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
Matrix or vector norm.

This function is able to return one of eight different matrix norms（可以计算8种范数，  
因此如果计算距离，需要输入x-y作为范数求解）,  
or one of an infinite number of vector norms (described below), depending  
on the value of the ``ord`` parameter.


The following norms can be calculated:  

=====  ============================  ==========================  
ord    norm for matrices             norm for vectors  
=====  ============================  ==========================  
None   Frobenius norm                2-norm  
'fro'  Frobenius norm                --  
'nuc'  nuclear norm                  --  
inf    max(sum(abs(x), axis=1))      max(abs(x))  
-inf   min(sum(abs(x), axis=1))      min(abs(x))  
0      --                            sum(x != 0)  
1      max(sum(abs(x), axis=0))      as below  
-1     min(sum(abs(x), axis=0))      as below  
2      2-norm (largest sing. value)  as below  
-2     smallest singular value       as below  
other  --                            sum(abs(x)**ord)**(1./ord)  
=====  ============================  ==========================  

1
2
3
4
d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
   print('A %s has %d legs' % (animal, legs))
# Prints "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs

1
2
3
# X原本为(10000,3072)，3072=3*32*32，即RGB相邻存储。
# 通过transpose可以得到第一个三原色X[0][0][0][i]，i=0，1，2
X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1)

1
self.W = 10^()-n) * np.random.randn(dim, num_classes)