引用

本笔记为斯坦福大学课程CS231n的课堂+课后作业的笔记。由于理解能力有限,有部分内容将借鉴于国内大神整理的优秀的笔记来进行进一步的理解与学习,本笔记只适用于个人,强烈建议观看大神整理好的笔记。写得非常好,如果看原视频不清楚的朋友,可以先详细的阅读该大佬的笔记,再去看原视频课程。

CS231n课程笔记翻译:线性分类笔记(上) - 杜客的文章 - 知乎

CS231n课程笔记翻译:线性分类笔记(中) - 杜客的文章 - 知乎

CS231n课程笔记翻译:线性分类笔记(下) - 杜客的文章 - 知乎

笔记将会结合个人所理解的方式来进行整理,方便本人在外阅读和查看(为此特地将博客设计成响应式布局)

课后作业的部分可以登录网易云课程进行观看:

https://study.163.com/course/courseLearn.htm?courseId=1003223001&from=study#/learn/text?lessonId=1050980818&courseId=1003223001

参考了lightaime的代码:https://github.com/lightaime/cs231n

本笔记只针对个人理解的方向为出发点记录,所以一些地方如果我理解比较透彻了,就不会记录太多。

课堂笔记

softmax分类器

softmax分类器和之前提到的svm分类器是两个最常用的分类器。两个分类器的损失函数是不同的。根据上一篇笔记中所记录,SVM将输出f(x[i] , W)每个分类的评分,这个评分是无定标的,他有负数也有正数,结果经常令人匪夷所思。softmax分类器可以理解为逻辑回归分类器面对多个分类的一般归纳。在Softmax分类器中,函数映射f(x_i;W)=Wx_i保持不变,但将这些评分值视为每个分类的未归一化的对数概率,并且将折叶损失(hinge loss)替换为交叉熵损失(cross-entropy loss)。公式如下:

arrvtar http://www.zhihu.com/equation?tex=L_i%3D-f_%7By_i%7D%2Blog%28%5Csum_je%5E%7Bf_j%7D%29

上面的公式中,使用f[j]来表示分类评分向量f中的第j个元素。和之前一样,整个数据集 的损失值是数据集中所有样本数据的损失之L[i]的均值正则化损失R(W)之和,其中函数http://www.zhihu.com/equation?tex=f_j%28z%29%3D%5Cfrac%7Be%5E%7Bz_j%7D%7D%7B%5Csum_ke%5E%7Bz_k%7D%7D 被称为softmax函数:输入一个向量,向量中元素为任意实数的评分,函数对其进行压缩,输出一个向量,其中每个元素值在0到1之间,且所有元素之和为1。所以包含softmax函数的完整交叉熵损失看起唬人,实际上还是比较容易理解的。

实操事项:编程实现softmax函数计算的时候,中间项e^f[u[i]]和sum(e^f[j]])因为存在指数函数,所以数值可能非常大。除以大数值可能导致数值计算的不稳定,所以学会使用归一化技巧非常重要。如果在分式的分子和分母都乘以一个常数C,并把它变换到求和之中,就能得到一个从数学上等价的公式:

avatar

C的值可自由选择,不会影响计算结果,通过使用这个技巧可以提高计算中的数值稳定性。通常将C设为logC=-max(x[j]*f[j])。该技巧简单地说,就是应该将向量f中的数值进行平移,使得最大值为0。代码实现如下:

f = np.array([123, 456, 789]) # 例子中有3个分类,每个评分的数值都很大
p = np.exp(f) / np.sum(np.exp(f)) # 不妙:数值问题,可能导致数值爆炸

# 那么将f中的值平移到最大值为0
f -= np.max(f) # f becomes [-666, -333, 0]
p = np.exp(f) / np.sum(np.exp(f)) # 现在OK了,将给出正确结果

让人迷惑的命名规则:精确地说,SVM分类器使用的是折叶损失(hinge loss),有时候又被称为最大边界损失(max-margin loss)。Softmax分类器使用的是交叉熵损失(corss-entropy loss)。Softmax分类器的命名是从softmax函数那里得来的,softmax函数将原始分类评分变成正的归一化数值,所有数值和为1,这样处理后交叉熵损失才能应用。注意从技术上说“softmax损失(softmax loss)”是没有意义的,因为softmax只是一个压缩数值的函数。但是在这个说法常常被用来做简称。

SVM和Softmax的比较

arrtar

针对一个数据点,SVM和Softmax分类器的不同处理方式的例子。两个分类器都计算了同样的分值向量f(本节中是通过矩阵乘来实现)。不同之处在于对f中分值的解释:SVM分类器将它们看做是分类评分,它的损失函数鼓励正确的分类(本例中是蓝色的类别2)的分值比其他分类的分值高出至少一个边界值。Softmax分类器将这些数值看做是每个分类没有归一化的对数概率,鼓励正确分类的归一化的对数概率变高,其余的变低。SVM的最终的损失值是1.58,Softmax的最终的损失值是0.452,但要注意这两个数值没有可比性。只在给定同样数据,在同样的分类器的损失值计算中,它们才有意义。

Softmax分类器为每个分类提供了“可能性”:SVM的计算是无标定的,而且难以针对所有分类的评分值给出直观解释。Softmax分类器则不同,它允许我们计算出对于所有分类标签的可能性。举个例子,针对给出的图像,SVM分类器可能给你的是一个[12.5, 0.6, -23.0]对应分类“猫”,“狗”,“船”。而softmax分类器可以计算出这三个标签的”可能性“是[0.9, 0.09, 0.01],这就让你能看出对于不同分类准确性的把握。为什么我们要在”可能性“上面打引号呢?这是因为可能性分布的集中或离散程度是由正则化参数λ直接决定的,λ是你能直接控制的一个输入参数。举个例子,假设3个分类的原始分数是[1, -2, 0],那么softmax函数就会计算:

arrtat

现在,如果正则化参数λ更大,那么权重W就会被惩罚的更多,然后他的权重数值就会更小。这样算出来的分数也会更小,假设小了一半吧[0.5, -1, 0],那么softmax函数的计算就是:

arrtar

现在看起来,概率的分布就更加分散了。还有,随着正则化参数λ不断增强,权重数值会越来越小,最后输出的概率会接近于均匀分布。这就是说,softmax分类器算出来的概率最好是看成一种对于分类正确性的自信。和SVM一样,数字间相互比较得出的大小顺序是可以解释的,但其绝对值则难以直观解释。在实际使用中,SVM和Softmax经常是相似的:通常说来,两种分类器的表现差别很小,不同的人对于哪个分类器更好有不同的看法。相对于Softmax分类器,SVM更加“局部目标化(local objective)”,这既可以看做是一个特性,也可以看做是一个劣势。考虑一个评分是[10, -2, 3]的数据,其中第一个分类是正确的。那么一个SVM()会看到正确分类相较于不正确分类,已经得到了比边界值还要高的分数,它就会认为损失值是0。SVM对于数字个体的细节是不关心的:如果分数是[10, -100, -100]或者[10, 9, 9],对于SVM来说没设么不同,只要满足超过边界值等于1,那么损失值就等于0。对于softmax分类器,情况则不同。对于[10, 9, 9]来说,计算出的损失值就远远高于[10, -100, -100]的。换句话来说,softmax分类器对于分数是永远不会满意的:正确分类总能得到更高的可能性,错误分类总能得到更低的可能性,损失值总是能够更小。但是,SVM只要边界值被满足了就满意了,不会超过限制去细微地操作具体分数。这可以被看做是SVM的一种特性。举例说来,一个汽车的分类器应该把他的大量精力放在如何分辨小轿车和大卡车上,而不应该纠结于如何与青蛙进行区分,因为区分青蛙得到的评分已经足够低了。

arrtar

作者实现了一个交互式的网页原型,来帮助读者直观地理解线性分类器。原型将损失函数进行可视化,画面表现的是对于2维数据的3种类别的分类。原型在课程进度上稍微超前,展现了最优化的内容,最优化将在下一节课讨论。

课后任务:

这次联系跟SVM联系类似,将完成以下任务: - 通过矩阵运算为softmax分类器实现一个损失函数 - 为了这个损失函数的分析梯度实验一个完全矢量化的表达式 - 用数值梯度检查上面的分析梯度的值 - 使用验证集找到最好的学习率和正则化强度 - 用随机梯度下降法优化损失函数 - 可视化最终学习到的权重

初始化代码

import random
import numpy as np
from cs231n.data_utils import load_CIFAR10
import matplotlib.pyplot as plt

# This is a bit of magic to make matplotlib figures appear inline in the
# notebook rather than in a new window.
%matplotlib inline
plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

# 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

获取数据

# 把获取数据和数据处理的过程封装进一个函数里
def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):
    """
    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare
    it for the linear classifier. These are the same steps as we used for the
    SVM, but condensed to a single function.  
    """
    # 加载原型CIFAR-10数据
    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'

    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)

    # 从数据集中取数据子集用于后面的练习
    mask = list(range(num_training, num_training + num_validation))
    X_val = X_train[mask]
    y_val = y_train[mask]
    mask = list(range(num_training))
    X_train = X_train[mask]
    y_train = y_train[mask]
    mask = list(range(num_test))
    X_test = X_test[mask]
    y_test = y_test[mask]
    mask = np.random.choice(num_training, num_dev, replace=False)
    X_dev = X_train[mask]
    y_dev = y_train[mask]

    # 数据预处理:将一张图片变成一行存在相应的矩阵里
    X_train = np.reshape(X_train, (X_train.shape[0], -1))
    X_val = np.reshape(X_val, (X_val.shape[0], -1))
    X_test = np.reshape(X_test, (X_test.shape[0], -1))
    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))

    # 标准化数据:先求平均图像,再将每个图像都减去其平均图像
    mean_image = np.mean(X_train, axis = 0)
    X_train -= mean_image
    X_val -= mean_image
    X_test -= mean_image
    X_dev -= mean_image

    # 添加偏置维度,在原矩阵后来加上一个全是1的列
    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])
    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])
    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])
    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])

    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev


# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)
try:
   del X_train, y_train
   del X_test, y_test
   print('Clear previously loaded data.')
except:
   pass

# 调用该函数以获取我们需要的数据,然后查看数据集大小
X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()
print('Train data shape: ', X_train.shape)
print('Train labels shape: ', y_train.shape)
print('Validation data shape: ', X_val.shape)
print('Validation labels shape: ', y_val.shape)
print('Test data shape: ', X_test.shape)
print('Test labels shape: ', y_test.shape)
print('dev data shape: ', X_dev.shape)
print('dev labels shape: ', y_dev.shape)
Train data shape:  (49000, 3073)
Train labels shape:  (49000,)
Validation data shape:  (1000, 3073)
Validation labels shape:  (1000,)
Test data shape:  (1000, 3073)
Test labels shape:  (1000,)
dev data shape:  (500, 3073)
dev labels shape:  (500,)

我们的数据集是一个形状为(N,D)的矩阵,N代表图像的个数,D代表每个图像包含的像素值多少。而我们的标签向量则是一个一维的向量,包含N个值,对应了每一个图像的类别。

朴素版的softmax损失函数

打开文件cs231n/classifiers/softmax.py,在softmax_loss_naive里用嵌套的方式实现朴素版的softmax损失函数

def softmax_loss_naive(W, X, y, reg):
  """
  Softmax loss function, naive implementation (with loops)

  Inputs have dimension D, there are C classes, and we operate on minibatches
  of N examples.

  Inputs:
  - W: A numpy array of shape (D, C) containing weights.
  - X: A numpy array of shape (N, D) containing a minibatch of data.
  - y: A numpy array of shape (N,) containing training labels; y[i] = c means
    that X[i] has label c, where 0 <= c < C.
  - reg: (float) regularization strength

  Returns a tuple of:
  - loss as single float
  - gradient with respect to weights W; an array of same shape as W
  """

  # Initialize the loss and gradient to zero.
    loss = 0.0
    dW = np.zeros_like(W)

  #############################################################################
  # TODO: Compute the softmax loss and its gradient using explicit loops.     #
  # Store the loss in loss and the gradient in dW. If you are not careful     #
  # here, it is easy to run into numeric instability. Don't forget the        #
  # regularization!                                                           #
  #############################################################################
    for i in range(X.shape[0]):
        # 计算分值的量
        f = np.dot(X[i], W)
        expf = np.exp(f)

        # 计算损失值
        sum_expf = np.sum(expf)
        loss += - np.log(expf[y[i]] / sum_expf)

        # 计算梯度
        for j in range(W.shape[1]):
            dW[:, j] += expf[j] / sum_expf * X[i]
        dW[:, y[i]] -= X[i]

    loss /= X.shape[0]
    loss += reg * np.sum(W * W)
    dW /= X.shape[0]
    dW += reg * W * 2

  #############################################################################
  #                          END OF YOUR CODE                                 #
  #############################################################################

  return loss, dW
# 加载刚刚写好的函数
from cs231n.classifiers.softmax import softmax_loss_naive
# 导入time模块,之后统计函数执行时间的时候会用到
import time

# 随机生成softmax权重矩阵并用它来计算损失值
W = np.random.randn(3073, 10) * 0.0001
loss , grad = softmax_loss_naive(W , X_dev , y_dev , 0.0)

# 作为一个粗略的检查,我们的损失应该是一个接近 -log(0.1)的值
print('loss: %f' % loss)
print('sanity check: %f' % (-np.log(0.1)))
loss: 2.356171
sanity check: 2.302585

问题1

为什么我们期待损失值接近-log(0.1)?

因为我们的权重矩阵乘0.001之后导致里面的值都非常小,接近于0,所以我们得到的分支向量里的值也接近于0。0经过指数化接近1,因为一共有10个类别,之后的归一化会导致正确的类别的概率值接近于0.1(等概括1/10),所以根据损失函数的定义得到损失值将近-log(0.1)

梯度的代码实现

# 实现一个朴素版的softmax损失函数,用循环嵌套的方式时间简单的梯度计算
loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)

# 就像我们之前在做SVM做的一样,使用数值梯度检查的方法作为调试工具
# 数值梯度应该接近分析梯度
# grad_check_sparse这个函数随机抽取10个位置,然后打印出改位置的数值梯度和分析梯度
from cs231n.gradient_check import grad_check_sparse
f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]
grad_numerical = grad_check_sparse(f, W, grad, 10)

# 就像我们之前在SVM做的一样,加入正则在进行一次检验
loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)
f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]
grad_numerical = grad_check_sparse(f, W, grad, 10)
numerical: 2.107063 analytic: 2.107063, relative error: 1.079779e-08
numerical: 0.494901 analytic: 0.494901, relative error: 1.196919e-07
numerical: -0.131712 analytic: -0.131712, relative error: 8.841983e-08
numerical: -0.767175 analytic: -0.767175, relative error: 5.834748e-08
numerical: 2.651003 analytic: 2.651003, relative error: 1.379860e-08
numerical: 3.186021 analytic: 3.186021, relative error: 1.435167e-08
numerical: 0.877289 analytic: 0.877289, relative error: 6.475186e-08
numerical: 0.600997 analytic: 0.600997, relative error: 5.260928e-08
numerical: 2.697258 analytic: 2.697258, relative error: 5.671268e-09
numerical: -0.248831 analytic: -0.248831, relative error: 1.006870e-07
numerical: 1.218436 analytic: 1.218436, relative error: 4.031817e-08
numerical: -2.017313 analytic: -2.017313, relative error: 3.293871e-09
numerical: -1.094623 analytic: -1.094623, relative error: 3.429286e-08
numerical: 0.538324 analytic: 0.538324, relative error: 1.704410e-08
numerical: 2.474781 analytic: 2.474781, relative error: 3.687080e-09
numerical: 1.194595 analytic: 1.194595, relative error: 8.818694e-09
numerical: 1.692044 analytic: 1.692044, relative error: 1.099621e-08
numerical: -1.718105 analytic: -1.718105, relative error: 2.815841e-08
numerical: -0.497212 analytic: -0.497212, relative error: 2.208495e-08
numerical: 2.368606 analytic: 2.368606, relative error: 2.800955e-08

向量版的softmax损失函数

我们已经有了一个朴素版的softmax损失函数其梯度的实现,现在softmax_loss_vectorized函数中再实现一个向量版的函数。这个两函数的结果应该是一样的,只是向量版的运算速度回快得很多。

def softmax_loss_vectorized(W, X, y, reg):
  """
  Softmax loss function, vectorized version.

  Inputs and outputs are the same as softmax_loss_naive.
  """
  # Initialize the loss and gradient to zero.
    loss = 0.0
    dW = np.zeros_like(W)

  #############################################################################
  # TODO: Compute the softmax loss and its gradient using no explicit loops.  #
  # Store the loss in loss and the gradient in dW. If you are not careful     #
  # here, it is easy to run into numeric instability. Don't forget the        #
  # regularization!                                                           #
  #############################################################################
    f = np.dot(X, W)
    expf = np.exp(f)
    expf_sum = np.sum(expf, axis = 1)
    expf_norm = np.divide(expf, np.matrix(expf_sum).T * np.ones((1, W.shape[1])))
    expf_each = np.divide(expf[range(f.shape[0]), y], expf_sum)
    loss = - np.mean(np.log(expf_each)) + np.sum(W * W) * reg
    expf_norm[range(expf_norm.shape[0]), y] -= 1
    dW = np.dot(X.T, expf_norm) / X.shape[0] + reg * W * W

  #############################################################################
  #                          END OF YOUR CODE                                 #
  #############################################################################

    return loss, dW

可以看到向量版里不再包含循环和嵌套,代码更简洁和清爽

#  函数执行前的时间,以浮点数的形式存储在tic中
tic = time.time()
loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)
# 函数执行完毕的时间,同样是浮点数
toc = time.time()
print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))

from cs231n.classifiers.softmax import softmax_loss_vectorized
tic = time.time()
loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)
toc = time.time()
print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))

# As we did for the SVM, we use the Frobenius norm to compare the two versions of the gradient.
# 正如我们在SVM做的一样,利用弗罗贝尼乌斯范数来比较这两个版本的梯度
grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')
print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))
print('Gradient difference: %f' % grad_difference)
naive loss: 2.356171e+00 computed in 0.106207s
vectorized loss: 2.356171e+00 computed in 0.036108s
Loss difference: 0.000000
Gradient difference: 0.000000

从输出结果可以看到向量版的函数计算速度要快的很多。但是得到的损失值和梯度并没有差别

超参数调优

# 利用验证集来调整超参数(正则化强度和学习率),应该分别不同的学习速率和正规化强度的范围;
# 如果你小心,你应该能够做到在验证集上获得超过0.35的分类精度。
from cs231n.classifiers import Softmax
results = {}
best_val = -1
best_softmax = None
learning_rates = [ i * 1e-7 for i in range(1, 6, 1)]
regularization_strengths = [i * 1e3 for i in range(25, 55, 5)]

################################################################################
# TODO:                                                                        #
# Use the validation set to set the learning rate and regularization strength. #
# This should be identical to the validation that you did for the SVM; save    #
# the best trained softmax classifer in best_softmax.                          #
################################################################################
for lr in learning_rates:
    for reg in regularization_strengths:
        svm = Softmax()
        loss_hist = svm.train(X_train, y_train, learning_rate=lr, reg=reg,
                      num_iters=1500, verbose=False)
        train_accuracy = np.mean(svm.predict(X_train) == y_train)
        val_accuracy = np.mean(svm.predict(X_val) == y_val)
        if val_accuracy > best_val:
            best_val = val_accuracy
            best_softmax = svm
        results[(lr, reg)] = (train_accuracy, val_accuracy)
################################################################################
#                              END OF YOUR CODE                                #
################################################################################

# Print out results.
for lr, reg in sorted(results):
    train_accuracy, val_accuracy = results[(lr, reg)]
    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (
                lr, reg, train_accuracy, val_accuracy))

print('best validation accuracy achieved during cross-validation: %f' % best_val)
lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.249959 val accuracy: 0.237000
lr 1.000000e-07 reg 3.000000e+04 train accuracy: 0.247265 val accuracy: 0.254000
lr 1.000000e-07 reg 3.500000e+04 train accuracy: 0.246490 val accuracy: 0.237000
lr 1.000000e-07 reg 4.000000e+04 train accuracy: 0.250776 val accuracy: 0.249000
lr 1.000000e-07 reg 4.500000e+04 train accuracy: 0.246633 val accuracy: 0.249000
lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.247224 val accuracy: 0.264000
lr 2.000000e-07 reg 2.500000e+04 train accuracy: 0.267755 val accuracy: 0.261000
lr 2.000000e-07 reg 3.000000e+04 train accuracy: 0.281163 val accuracy: 0.292000
lr 2.000000e-07 reg 3.500000e+04 train accuracy: 0.276918 val accuracy: 0.283000
lr 2.000000e-07 reg 4.000000e+04 train accuracy: 0.275857 val accuracy: 0.291000
lr 2.000000e-07 reg 4.500000e+04 train accuracy: 0.279102 val accuracy: 0.284000
lr 2.000000e-07 reg 5.000000e+04 train accuracy: 0.275347 val accuracy: 0.281000
lr 3.000000e-07 reg 2.500000e+04 train accuracy: 0.300245 val accuracy: 0.315000
lr 3.000000e-07 reg 3.000000e+04 train accuracy: 0.293551 val accuracy: 0.295000
lr 3.000000e-07 reg 3.500000e+04 train accuracy: 0.296265 val accuracy: 0.298000
lr 3.000000e-07 reg 4.000000e+04 train accuracy: 0.293204 val accuracy: 0.301000
lr 3.000000e-07 reg 4.500000e+04 train accuracy: 0.300490 val accuracy: 0.296000
lr 3.000000e-07 reg 5.000000e+04 train accuracy: 0.293714 val accuracy: 0.296000
lr 4.000000e-07 reg 2.500000e+04 train accuracy: 0.306939 val accuracy: 0.307000
lr 4.000000e-07 reg 3.000000e+04 train accuracy: 0.308592 val accuracy: 0.313000
lr 4.000000e-07 reg 3.500000e+04 train accuracy: 0.305061 val accuracy: 0.310000
lr 4.000000e-07 reg 4.000000e+04 train accuracy: 0.308510 val accuracy: 0.301000
lr 4.000000e-07 reg 4.500000e+04 train accuracy: 0.313327 val accuracy: 0.313000
lr 4.000000e-07 reg 5.000000e+04 train accuracy: 0.307918 val accuracy: 0.291000
lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.316429 val accuracy: 0.307000
lr 5.000000e-07 reg 3.000000e+04 train accuracy: 0.312102 val accuracy: 0.293000
lr 5.000000e-07 reg 3.500000e+04 train accuracy: 0.317224 val accuracy: 0.308000
lr 5.000000e-07 reg 4.000000e+04 train accuracy: 0.311041 val accuracy: 0.321000
lr 5.000000e-07 reg 4.500000e+04 train accuracy: 0.318816 val accuracy: 0.322000
lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.312571 val accuracy: 0.302000
best validation accuracy achieved during cross-validation: 0.322000

测试结果以及准确率计算

# 在测试集上验证我们得到的最好的softmax分类器
y_test_pred = best_softmax.predict(X_test)
test_accuracy = np.mean(y_test == y_test_pred)
print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))
softmax on raw pixels final test set accuracy: 0.310000
# 可视化学习到的每一个类别的权重
# Visualize the learned weights for each class
w = best_softmax.W[:-1,:] # strip out the bias
w = w.reshape(32, 32, 3, 10)

w_min, w_max = np.min(w), np.max(w)

classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
for i in range(10):
    plt.subplot(2, 5, i + 1)

    # 重新设置成0~255中间的值
    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)
    plt.imshow(wimg.astype('uint8'))
    plt.axis('off')
    plt.title(classes[i])

png


版权声明:如无特殊说明,文章均为本站原创,转载请注明出处

本文链接:http://tunm.top/article/q3/