cs231n assignment2 q1

最新推荐文章于 2023-08-04 21:29:22 发布
最新推荐文章于 2023-08-04 21:29:22 发布
阅读量908 收藏 5
点赞数 4
分类专栏： cs231n 文章标签： python 机器学习 人工智能 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leezed525/article/details/132040116
版权

文章目录

嫌啰嗦看源码

Q1 Multi-Layer Fully Connected Neural Networks 多层全连接神经网络

在这里插入图片描述
在layers.py中我们可以直接用assignment1 里面的已经写好的affine_forward ,affine_backward,relu_forward,relu_backward的几个方法，不用重新再写了

fc_net

这里的fc_net跟之前assignment1 q4的神经网络不同，之前的神经网络层数是固定的两层，这一次的神经网络是任意多层，因此我们需要使用循环来实现层数的定义，总之具体的细节看代码就能理解

__init__

题面

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
下面是机翻

初始化网络的参数，将所有值存储在self.params字典中。
将第一层的权重和偏差存储在W1和b1中；对于第二层，使用W2和b2等。
权重应从以0为中心的正态分布初始化，标准偏差等于weight_scale。
偏差应初始化为零。
当使用批量归一化时，将第一层的缩放和偏移参数存储在gamma1和beta1中；
对于第二层，使用gamma2和beta2等。缩放参数应初始化为1，移位参数应初始化至0。

可以看到init函数跟之前的有了很大的不同
翻译一下其中初始化的时候传进来的参数的释义

  • hidden_dims ：一个整数类型列表，代表中隐藏层各层的维度
  • input_dim: 一个整数代表输入数据的维度
  • num_classes:一个整数代表着需要去分类的数量，也就是最后一层输出层的维度
  • dropout_keep_ratio:丢弃强度，0和1之间的标量，如果drop_keep_ratio = 1 则网络不会丢弃层
  • normalization:网络会使用哪种正则类型，可用的选择有"batchnorm","layernorm"或者None代表着不适用正则（默认）
  • reg:给出L2正则化强度的标量
  • weight_scale: 标量，给出权重随机初始化的标准偏差。
  • dtype:数据类型
  • seed：如果不是None，那么将这个随机种子传递给丢弃层。这将使丢弃层具有决定性，这样我们就可以对模型进行梯度检查。
解析

注意最后一层不需要正则项的参数

代码
    def __init__(
            self,
            hidden_dims,
            input_dim=3 * 32 * 32,
            num_classes=10,
            dropout_keep_ratio=1,
            normalization=None,
            reg=0.0,
            weight_scale=1e-2,
            dtype=np.float32,
            seed=None,
    ):
        """Initialize a new FullyConnectedNet.

        Inputs:
        - hidden_dims: A list of integers giving the size of each hidden layer.
        - input_dim: An integer giving the size of the input.
        - num_classes: An integer giving the number of classes to classify.
        - dropout_keep_ratio: Scalar between 0 and 1 giving dropout strength.
            If dropout_keep_ratio=1 then the network should not use dropout at all.
        - normalization: What type of normalization the network should use. Valid values
            are "batchnorm", "layernorm", or None for no normalization (the default).
        - reg: Scalar giving L2 regularization strength.
        - weight_scale: Scalar giving the standard deviation for random
            initialization of the weights.
        - dtype: A numpy datatype object; all computations will be performed using
            this datatype. float32 is faster but less accurate, so you should use
            float64 for numeric gradient checking.
        - seed: If not None, then pass this random seed to the dropout layers.
            This will make the dropout layers deteriminstic so we can gradient check the model.
        """
        self.normalization = normalization
        self.use_dropout = dropout_keep_ratio != 1
        self.reg = reg
        self.num_layers = 1 + len(hidden_dims)
        self.dtype = dtype
        self.params = {}

        ############################################################################
        # TODO: Initialize the parameters of the network, storing all values in    #
        # the self.params dictionary. Store weights and biases for the first layer #
        # in W1 and b1; for the second layer use W2 and b2, etc. Weights should be #
        # initialized from a normal distribution centered at 0 with standard       #
        # deviation equal to weight_scale. Biases should be initialized to zero.   #
        #                                                                          #
        # When using batch normalization, store scale and shift parameters for the #
        # first layer in gamma1 and beta1; for the second layer use gamma2 and     #
        # beta2, etc. Scale parameters should be initialized to ones and shift     #
        # parameters should be initialized to zeros.                               #
        ############################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        # 获取所有层数的维度
        layer_dims = [input_dim] + hidden_dims + [num_classes]
        # 初始化所有层的参数 (这里的层数是上面的layer_dims的长度减1,因此不会下标越界)
        for i in range(self.num_layers):
            self.params['W' + str(i + 1)] = np.random.normal(0, weight_scale, size=(layer_dims[i], layer_dims[i + 1]))
            self.params['b' + str(i + 1)] = np.zeros(layer_dims[i + 1])
            # 接下来添加batch normalization 层，注意最后一层不需要添加
            if self.normalization == 'batchnorm' and i < self.num_layers - 1:
                self.params['gamma' + str(i + 1)] = np.ones(layer_dims[i + 1])
                self.params['beta' + str(i + 1)] = np.zeros(layer_dims[i + 1])

            # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        ############################################################################
        #                             END OF YOUR CODE                             #
        ############################################################################

        # When using dropout we need to pass a dropout_param dictionary to each
        # dropout layer so that the layer knows the dropout probability and the mode
        # (train / test). You can pass the same dropout_param to each dropout layer.
        self.dropout_param = {}
        if self.use_dropout:
            self.dropout_param = {"mode": "train", "p": dropout_keep_ratio}
            if seed is not None:
                self.dropout_param["seed"] = seed

        # With batch normalization we need to keep track of running means and
        # variances, so we need to pass a special bn_param object to each batch
        # normalization layer. You should pass self.bn_params[0] to the forward pass
        # of the first batch normalization layer, self.bn_params[1] to the forward
        # pass of the second batch normalization layer, etc.
        self.bn_params = []
        if self.normalization == "batchnorm":
            self.bn_params = [{"mode": "train"} for i in range(self.num_layers - 1)]
        if self.normalization == "layernorm":
            self.bn_params = [{} for i in range(self.num_layers - 1)]

        # Cast all parameters to the correct datatype.
        for k, v in self.params.items():
            self.params[k] = v.astype(dtype)

loss

题面

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
跟之前也差不了太多，就是计算loss和梯度，一步一步来就是了

解析

因为目前我们还用不上batchnorm，所以我就先不写batchnorm了,分解工作量

看代码注释就好了

代码
    def loss(self, X, y=None):
        """Compute loss and gradient for the fully connected net.
        
        Inputs:
        - X: Array of input data of shape (N, d_1, ..., d_k)
        - y: Array of labels, of shape (N,). y[i] gives the label for X[i].

        Returns:
        If y is None, then run a test-time forward pass of the model and return:
        - scores: Array of shape (N, C) giving classification scores, where
            scores[i, c] is the classification score for X[i] and class c.

        If y is not None, then run a training-time forward and backward pass and
        return a tuple of:
        - loss: Scalar value giving the loss
        - grads: Dictionary with the same keys as self.params, mapping parameter
            names to gradients of the loss with respect to those parameters.
        """
        X = X.astype(self.dtype)
        mode = "test" if y is None else "train"

        # Set train/test mode for batchnorm params and dropout param since they
        # behave differently during training and testing.
        if self.use_dropout:
            self.dropout_param["mode"] = mode
        if self.normalization == "batchnorm":
            for bn_param in self.bn_params:
                bn_param["mode"] = mode
        scores = None
        ############################################################################
        # TODO: Implement the forward pass for the fully connected net, computing  #
        # the class scores for X and storing them in the scores variable.          #
        #                                                                          #
        # When using dropout, you'll need to pass self.dropout_param to each       #
        # dropout forward pass.                                                    #
        #                                                                          #
        # When using batch normalization, you'll need to pass self.bn_params[0] to #
        # the forward pass for the first batch normalization layer, pass           #
        # self.bn_params[1] to the forward pass for the second batch normalization #
        # layer, etc.                                                              #
        ############################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        # 我们网络的结果是这样的 {affine - [batch/layer norm] - relu - [dropout]} x (L - 1) - affine - softmax

        # 用一个变量保存上一层的输出
        layer_input = X
        caches = {}
        # 对前面 L - 1层进行操作，因为最后一层的操作和前面的不一样
        for i in range(1, self.num_layers):
            W = self.params['W' + str(i)]
            b = self.params['b' + str(i)]

            # 计算affine层的输出
            affine_out, affine_cache = affine_forward(layer_input, W, b)
            # 计算relu层的输出
            relu_out, relu_cache = relu_forward(affine_out)

            # 保存cache
            caches['affine_cache' + str(i)] = affine_cache
            caches['relu_cache' + str(i)] = relu_cache

            # 更新layer_input
            layer_input = relu_out

        # 最后一层的操作
        W = self.params['W' + str(self.num_layers)]
        b = self.params['b' + str(self.num_layers)]

        scores, affine_cache = affine_forward(layer_input, W, b)
        caches['affine_cache' + str(self.num_layers)] = affine_cache

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        ############################################################################
        #                             END OF YOUR CODE                             #
        ############################################################################

        # If test mode return early.
        if mode == "test":
            return scores

        loss, grads = 0.0, {}
        ############################################################################
        # TODO: Implement the backward pass for the fully connected net. Store the #
        # loss in the loss variable and gradients in the grads dictionary. Compute #
        # data loss using softmax, and make sure that grads[k] holds the gradients #
        # for self.params[k]. Don't forget to add L2 regularization!               #
        #                                                                          #
        # When using batch/layer normalization, you don't need to regularize the   #
        # scale and shift parameters.                                              #
        #                                                                          #
        # NOTE: To ensure that your implementation matches ours and you pass the   #
        # automated tests, make sure that your L2 regularization includes a factor #
        # of 0.5 to simplify the expression for the gradient.                      #
        ############################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        # 计算loss
        loss, dscores = softmax_loss(scores, y)

        # 先计算最后一层的梯度
        W = self.params['W' + str(self.num_layers)]
        affine_cache = caches['affine_cache' + str(self.num_layers)]
        d_relu_out, dW, db = affine_backward(dscores, affine_cache)
        grads['W' + str(self.num_layers)] = dW + self.reg * W
        grads['b' + str(self.num_layers)] = db

        # 计算前面的梯度
        for i in range(self.num_layers - 1, 0, -1):
            W = self.params['W' + str(i)]
            affine_cache = caches['affine_cache' + str(i)]
            relu_cache = caches['relu_cache' + str(i)]

            # 先计算relu层的梯度
            d_affine_out = relu_backward(d_relu_out, relu_cache)
            # 再计算affine层的梯度
            d_relu_out, dW, db = affine_backward(d_affine_out, affine_cache)

            # 保存梯度
            grads['W' + str(i)] = dW + self.reg * W
            grads['b' + str(i)] = db
         
        # 加上正则化项
        for i in range(1, self.num_layers + 1):
            W = self.params['W' + str(i)]
            loss += 0.5 * self.reg * np.sum(W * W)

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        ############################################################################
        #                             END OF YOUR CODE                             #
        ############################################################################

        return loss, grads

输出

在这里插入图片描述

调整一个三层神经网络使其过拟合

题面

在这里插入图片描述
在这里插入图片描述
让我们调整学习率和权重规模来使其过拟合

解析

学习率对于拟合效果的影响我就不赘述了，说一下Weight_scale对拟合效果的影响吧
在这里插入图片描述

没啥好说的，调参！

结果

有好几种方法，我随便列几个

weight_scale = 1e-2  # Experiment with this!
learning_rate = 1e-2  # Experiment with this!

在这里插入图片描述

weight_scale = 3e-2  # Experiment with this!
learning_rate = 4e-3  # Experiment with this!

在这里插入图片描述

调整一个五层神经网络使其过拟合

在这里插入图片描述
在这里插入图片描述

结果

weight_scale = 4e-2   # Experiment with this!
learning_rate = 1e-2  # Experiment with this!

在这里插入图片描述

Inline Question 1

题面

在这里插入图片描述
粗浅的翻译就是三层网络和五层网络哪个训练起来更难？那个网络对weight_scale更敏感

答案

如果你自己调试过，就会发现五层网络更难
因为他的准确率更加依赖于初始化，所以他对weight_scale更敏感

update_rules

接下来一部分就是让我们来实现参数更新的规则的视线，除了最基础的梯度下降，还有几个新学的更新算法，具体的可以看这个网站https://cs231n.github.io/neural-networks-3/#sgd

sgd_momentum

题面

在这里插入图片描述

解析

在这里插入图片描述

代码

def sgd_momentum(w, dw, config=None):
    """
    Performs stochastic gradient descent with momentum.

    config format:
    - learning_rate: Scalar learning rate.
    - momentum: Scalar between 0 and 1 giving the momentum value.
      Setting momentum = 0 reduces to sgd.
    - velocity: A numpy array of the same shape as w and dw used to store a
      moving average of the gradients.
    """
    if config is None:
        config = {}
    config.setdefault("learning_rate", 1e-2)
    config.setdefault("momentum", 0.9)
    v = config.get("velocity", np.zeros_like(w))

    next_w = None
    ###########################################################################
    # TODO: Implement the momentum update formula. Store the updated value in #
    # the next_w variable. You should also use and update the velocity v.     #
    ###########################################################################
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    v = config["momentum"] * v - config["learning_rate"] * dw
    next_w = w + v

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
    ###########################################################################
    #                             END OF YOUR CODE                            #
    ###########################################################################
    config["velocity"] = v

    return next_w, config

输出

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

RMSProp

题面

在这里插入图片描述
在这里插入图片描述

解析

在这里插入图片描述

代码

def rmsprop(w, dw, config=None):
    """
    Uses the RMSProp update rule, which uses a moving average of squared
    gradient values to set adaptive per-parameter learning rates.

    config format:
    - learning_rate: Scalar learning rate.
    - decay_rate: Scalar between 0 and 1 giving the decay rate for the squared
      gradient cache.
    - epsilon: Small scalar used for smoothing to avoid dividing by zero.
    - cache: Moving average of second moments of gradients.
    """
    if config is None:
        config = {}
    config.setdefault("learning_rate", 1e-2)
    config.setdefault("decay_rate", 0.99)
    config.setdefault("epsilon", 1e-8)
    config.setdefault("cache", np.zeros_like(w))

    next_w = None
    ###########################################################################
    # TODO: Implement the RMSprop update formula, storing the next value of w #
    # in the next_w variable. Don't forget to update cache value stored in    #
    # config['cache'].                                                        #
    ###########################################################################
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    cache = config["cache"]
    cache = config["decay_rate"] * cache + (1 - config["decay_rate"]) * dw ** 2
    next_w = w - config["learning_rate"] * dw / (np.sqrt(cache) + config["epsilon"])
    config["cache"] = cache

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
    ###########################################################################
    #                             END OF YOUR CODE                            #
    ###########################################################################

    return next_w, config

输出

在这里插入图片描述

Adam

题面

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

解析

在这里插入图片描述

代码

def adam(w, dw, config=None):
    """
    Uses the Adam update rule, which incorporates moving averages of both the
    gradient and its square and a bias correction term.

    config format:
    - learning_rate: Scalar learning rate.
    - beta1: Decay rate for moving average of first moment of gradient.
    - beta2: Decay rate for moving average of second moment of gradient.
    - epsilon: Small scalar used for smoothing to avoid dividing by zero.
    - m: Moving average of gradient.
    - v: Moving average of squared gradient.
    - t: Iteration number.
    """
    if config is None:
        config = {}
    config.setdefault("learning_rate", 1e-3)
    config.setdefault("beta1", 0.9)
    config.setdefault("beta2", 0.999)
    config.setdefault("epsilon", 1e-8)
    config.setdefault("m", np.zeros_like(w))
    config.setdefault("v", np.zeros_like(w))
    config.setdefault("t", 0)

    next_w = None
    ###########################################################################
    # TODO: Implement the Adam update formula, storing the next value of w in #
    # the next_w variable. Don't forget to update the m, v, and t variables   #
    # stored in config.                                                       #
    #                                                                         #
    # NOTE: In order to match the reference output, please modify t _before_  #
    # using it in any calculations.                                           #
    ###########################################################################
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    t = config["t"] + 1
    m = config["beta1"] * config["m"] + (1 - config["beta1"]) * dw
    mt = m / (1 - config["beta1"] ** t)
    v = config["beta2"] * config["v"] + (1 - config["beta2"]) * dw ** 2
    vt = v / (1 - config["beta2"] ** t)
    next_w = w - config["learning_rate"] * mt / (np.sqrt(vt) + config["epsilon"])

    config["t"] = t
    config["m"] = m
    config["v"] = v


    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
    ###########################################################################
    #                             END OF YOUR CODE                            #
    ###########################################################################

    return next_w, config

输出

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

train you best model

题面

在这里插入图片描述

解析

没啥好说的

代码

best_model = None

################################################################################
# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #
# find batch/layer normalization and dropout useful. Store your best model in  #
# the best_model variable.                                                     #
################################################################################
# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

best_val = -1
best_params = {}
# 重新定义一下训练数量
num_train = 500

small_data = {
    'X_train': data['X_train'][:num_train],
    'y_train': data['y_train'][:num_train],
    'X_val': data['X_val'],
    'y_val': data['y_val'],
}

#随机训练30次，每次随机生成学习率和正则化强度，先用小数据集训练一下
for i in range(30):
    lr = 10 ** np.random.uniform(-5, -3)  # 学习速度
    ws = 10 ** np.random.uniform(-3, -1)  # 权重缩放
    reg = 10 ** np.random.uniform(-3, -1)  # 正则化强度

    # 创建一个四层模型
    model = FullyConnectedNet([256, 128, 64],
                              weight_scale=ws,
                              reg=reg)

    # 使用adam更新策略
    solver = Solver(model, small_data,
                    num_epochs=20, batch_size=256,
                    update_rule='adam',
                    optim_config={
                        'learning_rate': lr,
                    },
                    verbose=False)
    solver.train()
    new_val = solver.best_val_acc

    if new_val > best_val:
        best_val = new_val
        best_model = model
        best_params['lr'] = lr
        best_params['reg'] = reg
        best_params['ws'] = ws
    print('lr: %e reg: %e ws: %e val accuracy: %f' % (
        lr, reg, ws, new_val))

print('best validation accuracy using small dataset: %f' % best_val)

# 拿效果最好的参数训练全部数据
best_model = FullyConnectedNet([256, 128, 64, 32],
                               weight_scale=best_params['ws'],
                               reg=best_params['reg'])

solver = Solver(best_model, data,
                num_epochs=20, batch_size=256,
                update_rule='adam',
                optim_config={
                    'learning_rate': best_params['lr'],
                },
                verbose=False)
solver.train()
print('best validation accuracy using full dataset: %f' % solver.best_val_acc)


# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
################################################################################
#                              END OF YOUR CODE                                #
################################################################################

输出

在这里插入图片描述
在这里插入图片描述

理智点
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cs231n-2018-Assignment3
03-03
spring1718-Assignment3 --cs231n's the newest source code and learning source
CS231n assignment1 KNN部分用到的函数
12-22
1. plt.rcParams 摘自：https://www.cnblogs.com/pacino12134/p/9776882.html 作用 设置matplotlib的配置参数，pylot使用rc配置文件来自定义图形的各种默认属性，称之为rc配置或rc参数。通过rc参数可以修改默认的属性，包括窗体大小、每英寸的点数、线条宽度、颜色、样式、坐标轴、坐标和网络属性、文本、字体等。 用法 rc参数存储在字典变量中，通过字典的方式进行访问。 例子 %matplotlib inline plt.rcParams['figure.figsize'] = (10.0, 8.0) # set defaul
cs231n-assigment2完整代码
07-09
斯坦福cs231n的assignment2，完整代码
cs231n作业assignment1
08-09
CS231N计算机视觉公开课的作业答案，只有assignment1，其中包含了作业，还有作业的答案，还有在网上下载的数据集，都在里面了。这个作业是用的anaconda的jupyter来做的。 如果后期的软件下载，或者如何打开使用，欢迎私信，
CS231n深度学习课程作业2实现
03-07
CS231n深度学习课程作业2实现，内含作业2实现的代码。实现完整的作业2。
CS231n assignment2
03-12
斯坦福CS231n assignment2整个代码 基于python，利用numpy编写两层神经网络。
cs231n assignment 2 q2 batchnormalization
Leezed525的博客
08-04 938
对于这两个normalization ,我是这么理解的，batch normalization 是对输入矩阵的每一列求平均值和方差，而layer normalization 是对输入矩阵的每一行求平均值和方差，所以batch normalziation 对输入数据的数量敏感，而layer normalization 因为是对每一行求方差，而每一行有多少元素是固定的，因此对输入数据的数量不敏感。就是让我们实现两种，一种是训练时的前向计算，一种是测试时的前向计算，具体怎么实现看上面的推导。
cs231n-2022-assignment2#Q1：多层全连接神经网络
chenxy_bwave的专栏
05-24 2186
cs231n-2022-assignment2#Q1：多层全连接神经网络，关键实现解说及相应代码。
CS231n+assignment2（一）
qq_56551150的博客
07-31 1584
cs231n作业二详解+代码
CS231n Assignment2--Q1
lovefreedom22的博客
03-07 937
Q1: Fully-connected Neural NetworkFullyConnectedNets.ipynbFully-Connected Neural NetsX_val: (1000, 3, 32, 32) X_train: (49000, 3, 32, 32) X_test: (1000, 3, 32, 32) y_val: (1000,) y_train: (490
cs231n-Assignment-2 python.
12-27
CS231n的Assignment, 用Python3.6.3写的，大家可以参考一下，
CS231n (winter 2016) : Assignment2
Just for fun的专栏
09-13 1294
http://www.jianshu.com/p/9c4396653324 前言： 以斯坦福cs231n课程的python编程任务为主线，展开对该课程主要内容的理解和部分数学推导。建议PC端阅读，该课程的学习资料和代码如下： 视频和PPT 笔记 assignment2初始代码 Part 1：深层全连接神经网络（python编程任务） 我们在Assignment1中完成了简单的
CS231N assignment2 SVM
CloudCver
02-17 231
CS231N assignment2 SVM CS231N Assignment2 Support Vector Machine Begin 本文主要介绍CS231N系列课程的第一项作业，写一个SVM无监督学习训练模型。 课程主页：网易云课堂CS231N系列课程 语言：Python3.6 1线形分类器 以图像为例，一幅图像像素为32*32*3代...
cs231n 课程作业 Assignment 2
热门推荐
张小彬的专栏
04-07 2万+
上一次作业基本已经讲了构建一个多层神经网络的基本知识，包括其结构，公式推导，训练方法。这一次主要关注卷积神经网络（CNN, Convolution Neural Network），要先读完课程笔记 CS231n Convolutional Neural Networks for Visual Recognition，基本就懂了。特别是那个解释卷积的动态图，非常形象。CNN 主要多了卷积层（convo
CS231n-assignment2-Fully-connected Neural Network
Esaka
07-18 1206
全神经网络 在前面的作业中，您在CIFAR-10上实现了一个完全连接的两层神经网络。实现是简单的，但不是非常模块化，因为损耗和梯度计算在一个单一的单片函数。对于一个简单的两层网络来说，这是可以管理的，但是当我们转向更大的模型时，这将变得不切实际。理想情况下，我们希望使用更模块化的设计来构建网络，这样我们就可以孤立地实现不同的层类型，然后将它们组合到具有不同架构的模型中。 在本练习中，我们将使用更模块化的方法实现全连接网络。对于每个层，我们将实现一个前向函数和一个后向函数。forward函数将接收输入、权重和
cs231n：assignment2——Q1: Fully-connected Neural Network
xieyi4650的博客
12-23 7850
视频里 Andrej Karpathy上课的时候说,这次的作业meaty but educational,确实很meaty,作业一般是由.ipynb文件和.py文件组成,这次因为每个.ipynb文件涉及到的.py文件较多,且互相之间有交叉,所以每篇博客只贴出一个.ipynb或者一个.py文件.(因为之前的作业由于是一个.ipynb文件对应一个.py文件,所以就整合到一篇博客里) 还是那句话,有错误
CS231N作业：A2Q1 完成FullyConnectedNets
weixin_72100405的博客
06-01 557
在这个文件里实现了如下任务：1、梯度检查（解析梯度与数值计算梯度进行比较，确定自己编写的梯度代码（forward和backward）没有问题）2、对小数据集（这里是50个data），确认模型可以过拟合。以确定自己的模型对这个问题是可以有用的3、更改update rules，查看了SGD,SGD+MOMENTUN,ADAM,ADAGRAD的不同又温习一遍每个优化器的不同和优缺点；学会了用Matplotlib把不同优化方法的acc,loss画在同一张图里的代码；
CS231n assignment2 Q1 Fully-connected Neural Network
weixin_30454481的博客
12-28 360
有句话叫“懂得了很多道理，依然过不好这一生。”用在这道题里很合适“懂得了每个过程的原理，依然写不好这代码。” 但抄完之后还是颇有收获的。 1、完成放射变换前向传播，f = wx + b def affine_forward(x, w, b): """ Computes the forward pass for an affine (fully-connected) lay...
cs231n作业 assignment 1 q1 q2 q3
Leezed525的博客
07-24 2029
请先看课程作业地址。有两种做作业的方法，一种是在google Colab上做 （需魔法），另一种就是下载到本地，但是我懒得在本地配置环境，太麻烦了，还得修改一些基础代码，我就直接在google colab上做了google colab 配置环境只需要跟着教程走就好了最后还有一题解答题懒得做的，这个题目做的没啥意思。让我们用简单写法来实现softmax的loss函数与梯度计算。
cs231n svm
最新发布
09-26
SVM，即支持向量机(Support Vector Machine)，是一种常用的机器学习算法，用于分类和回归任务。在图像分类中，SVM被广泛应用。 SVM的基本原理是通过在特征空间中找到一个最优的超平面，将不同类别的样本分开。这个超平面被选择为能最大化不同类别之间的间隔，并且能最小化分类错误。支持向量是离超平面最近的样本点，它们对于定义超平面起到关键作用。 在CS231n课程中，SVM模型的实现是基于将图像特征向量化，然后将这些特征向量输入到SVM模型中进行训练和分类。具体来说，SVM模型通过使用一个损失函数来最小化分类错误，并通过添加正则化项来控制模型的复杂度。 通过CS231n课程的学习，你可以深入了解SVM模型的原理和实现方法，以及在图像分类任务中的应用。如果你对SVM模型还有其他问题，我会很乐意回答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值