精华内容
下载资源
问答
  • col
    千次阅读
    2022-01-27 15:31:42

    在这里贴上了关于im2col和col2im函数的代码,已覆盖了基本功能,供大家调用学习。

    实现im2col函数:

    import numpy as np
    
    
    def im2col(img, kernel_size, strides=1, paddings=0, dilations=1):
        if not isinstance(kernel_size, list):
            k = kernel_size
            kernel_size = [k, k]
        k_h, k_w = kernel_size
    
        if isinstance(strides, list):
            s_h, s_w = strides
        else:
            s_h = s_w = strides
    
        if isinstance(paddings, list):
            if len(paddings) == 4:
                ps = paddings
            else:
                p_h, p_w = paddings
                ps = [p_h, p_w, p_h, p_w]
        else:
            p = paddings
            ps = [p, p, p, p]
    
        if not isinstance(dilations, list):
            d = dilations
            dilations = [d, d]
        d_h, d_w = dilations
    
        img = np.pad(img, ((0, 0), (0, 0), (ps[0], ps[2]), (ps[1], ps[3])), 'constant')
    
        N, C, H, W = img.shape
    
        dk_h = (d_h * (k_h - 1) + 1)
        dk_w = (d_w * (k_w - 1) + 1)
        out_h = (H - dk_h) // s_h + 1
        out_w = (W - dk_w) // s_w + 1
    
        outsize = out_w * out_h
        col = np.empty((N, C, k_w * k_h, outsize))
    
        for y in range(out_h):
            y_start = y * s_h
            y_end = y_start + dk_h
            for x in range(out_w):
                x_start = x * s_w
                x_end = x_start + dk_w
                col[:, :, 0:, y * out_w + x] = img[:, :, y_start:y_end:d_h, x_start:x_end:d_w].reshape([N, C, k_h * k_w])
        return paddle.to_tensor(col.reshape([N, -1, outsize]))
    
    
    import paddle
    
    x = paddle.to_tensor([[48, 38, 38, 59, 38],
                          [38, 11, 25, 52, 44],
                          [60, 69, 49, 93, 66],
                          [88, 8, 47, 14, 47],
                          [96, 37, 56, 86, 54]], dtype='float32'
                         ).unsqueeze(0).unsqueeze(0)
    
    result = im2col(x, [3, 3], strides=1, paddings=0, dilations=2)
    print(result)

    实现col2im函数:

    import numpy as np
    
    
    def col2im(mtx, image_size, kernel_size, strides=1, paddings=0, dilations=1):
        if not isinstance(kernel_size, list):
            k = kernel_size
            kernel_size = [k, k]
        k_h, k_w = kernel_size
    
        if isinstance(strides, list):
            s_h, s_w = strides
        else:
            s_h = s_w = strides
    
        if isinstance(paddings, list):
            if len(paddings) == 4:
                ps = paddings
            else:
                p_h, p_w = paddings
                ps = [p_h, p_w, p_h, p_w]
        else:
            p = paddings
            ps = [p, p, p, p]
    
        if isinstance(image_size, list):
            image_h, image_w = image_size
        else:
            image_h = image_w = image_size
    
        if not isinstance(dilations, list):
            d = dilations
            dilations = [d, d]
        d_h, d_w = dilations
    
        N, kC, _ = mtx.shape
        r_C = kC // (k_h * k_w)
        img = np.zeros([N, r_C, image_h, image_w])
    
        result = np.pad(img, ((0, 0), (0, 0), (ps[0], ps[2]), (ps[1], ps[3])), 'constant')
        weight = np.pad(img, ((0, 0), (0, 0), (ps[0], ps[2]), (ps[1], ps[3])), 'constant')
    
        dk_h = (d_h * (k_h - 1) + 1)
        dk_w = (d_w * (k_w - 1) + 1)
    
        out_h = (result.shape[-2] - dk_h) // s_h + 1
        out_w = (result.shape[-1] - dk_w) // s_w + 1
    
        col = 0
        for i in range(out_h):
            for j in range(out_w):
                result[:, :, i * s_h:i * s_h + dk_h:d_h, j * s_w:j * s_w + dk_w:d_w] += \
                    mtx[:, :, col].reshape([N, r_C, k_h, k_w]).numpy()
                weight[:, :, i * s_h:i * s_h + dk_h:d_h, j * s_w:j * s_w + dk_w:d_w] += \
                    np.ones([N, r_C, k_h, k_w])
                col += 1
    
        with np.errstate(divide='ignore', invalid='ignore'):
            result_avg = result / weight
            result_avg[~ np.isfinite(result_avg)] = 0
    
        return paddle.to_tensor(result_avg[:, :, ps[0]:image_h + ps[0], ps[1]:image_w + ps[1]])
    
    
    import paddle
    
    x = paddle.to_tensor(
        [[[48.],
          [38.],
          [38.],
          [60.],
          [49.],
          [66.],
          [96.],
          [56.],
          [54.]]])
    
    result = col2im(x, [5, 5], [3, 3], strides=1, paddings=0, dilations=2)
    print(result)

    更多相关内容
  • Element-Plus el-col、el-row快速布局

    千次阅读 2022-05-10 18:54:01
    一篇博客学会el-col布局工具的使用


    前言

    拖拉了一晚, 总结了一些Layout布局工具的使用方法.


    一、el-col

    本来打算先说row的… 写完看了一遍感觉还是换过来的好(捂脸).
    el-col是el-row的子元素.

    在el-row添加

    style="flex-direction: column;" 
    

    可以实现纵向排列el-col, 在需要纵向布局时可以使用, 横向col现在填满默认自动换行, 不需要特别规定;

    span

    规定一个col占据24份中的多少份.
    倒也不是必加的属性…
    当el-row中仅有一个el-col时, 该el-col默认占据全部的24份, 填满el-row.
    但是如果多个el-col情况下不加, 效果会比较糟糕, 第一个el-col依旧占据第一行的全部24份, 但是其他el-col会被挤到换行(倒也不会挤出el-row), 就像这样:
    黄, 蓝, 绿, 分别为第一二三个el-col, 都不传span值.
    在这里插入图片描述

      <el-row class="dark">
        <el-col class="yellow">
          <sy-author-1></sy-author-1>
        </el-col>
        <!-- 分隔 -->
        <el-col class="blue">
          <div></div>
        </el-col>
        <!-- 分隔 -->
        <el-col class="green" >
          <div></div>
        </el-col>
      </el-row>
    
    * {
      transition: 1s;
    }
    
    .dark {
      background-color: rgb(137, 133, 133);
    }
    
    .yellow {
      background-color: rgb(176, 170, 80);
    }
    
    .green {
      background-color: rgb(85, 144, 135);
    }
    
    .blue {
      background-color: rgb(65, 115, 153);
    }
    

    就说正常加span的情况下, 页面使用el-row后, 横向距离被等量的分为24份, el-col的span属性决定的是"这个el-col在横向占据24分之几个el-row".
    在这里插入图片描述
    比如这次span分别是8、5、8, 那么剩下3份空间没用上, 也就是右边的灰色部分, 暴露出el-row的颜色.

    push & pull

    pull和push控制col的横向位移, 以份为单位 最大值24超出无效.
    push和pull不会影响“横向被分为24份”这个规则, 比如第一个el-col被:push=“1”, 最后一个el-col被:pull=“1”, 中间的三个el-col还是可以各占8份, 只不过会有重叠的情况.

    <el-row class="dark">
      <el-col :span="8" class="yellow" :push="2"> <!-- 左边push两份 -->
        <sy-author-1></sy-author-1>
      </el-col>
        <!-- 分隔 -->
      <el-col class="blue" :span="8">
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col class="green" :span="8" :pull="2"> <!-- 右边pull两份 -->
        <div></div>
      </el-col>
    </el-row>
    

    虽然依旧各占8份, 但是蓝盒子被左右两侧遮盖了.
    在这里插入图片描述
    所有el-col没有发生尺寸上的变化.


    响应式

    提供一个专门的属性, 让使用者规定在该属性对应的分辨率下, col要怎样进行排列.
    响应式属性(xs, lg等)接受传入对象类型和数字类型;
    对象类型可用于规定offset和span等属性, 针对每个分辨率范围定制一套合适的样式:

    属性说明
    xs小于768
    sm大等于768
    md大等于992
    lg大等于1200
    xl大等于1920

    来写个栗子看一下, 规定小于768, 大于992, 大于1200时的排列:
    这个例子有一些缺陷, 请读完例子下面的部分.

    <el-row class="dark">
      <el-col
        :xs="{ span: 22, push: 1, pull: 1 }"
        :md="{ span: 18, push: 3 }"
        :lg="{ span: 8, push: 1 }"
        class="yellow"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        :xs="{ span: 22, pull: 1, push: 1 }"
        :md="{ span: 16, push: 2 }"
        :lg="{ span: 8, push: 0 }"
        class="blue"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        class="green"
        :xs="{ push: 1, pull: 1, span: 22 }"
        :md="{ span: 14, push: 1 }"
        :lg="{ span: 7, pull: 1, push: 0 }"
      >
        <div
        ></div>
      </el-col>
    </el-row>
    

    在这里插入图片描述

    其实写案例的时候还发现了一个问题, 响应式方案里的属性是可以继承的, 这样说倒也不准确…

    表现出来就是:
    设置了md的push, span后, 如果不设置lg的push, 那么lg方案会采用用md方案的push / pull, 而不是默认的pull / push为0, 这个问题会发生在各组方案之间, 只要有一组方案缺少属性, 它就从上一组方案里拿属性:

    <!-- 这里pull无效, 所以没写... -->
    <!-- 因为蓝色块出的问题, 所以只放个蓝色块 -->
    <el-col
      :md="{ span: 16, push: 2 }"
      :lg="{ span: 8 }"
      class="blue"
    >
      <div></div>
    </el-col>
    

    然后lg状态就变成这样了, 你可以看到蓝块左侧空出来了一块, 这就是lg方案从md偷的push:2.
    在这里插入图片描述
    这个时候再规定lg的push为0:

    <el-col
      :md="{ span: 16, push: 2 }"
      :lg="{ span: 8, push:0 }"
      class="blue"
    >
      <div></div>
    </el-col>
    

    在这里插入图片描述
    所以用响应式的时候, 规定方案要把每一项都详细规定好, 避免从其他方案继承到属性, 出现一些奇怪的效果.

    pull在响应式方案里有时会失效, 比如我们现在这个例子, 我给了第三个col一个lg状态下的pull:1, 什么效果都没有:
    在这里插入图片描述
    但是在xs方案中, pull:1生效了:
    在这里插入图片描述
    也不是因为没有多余空间可以移动的问题, 事实是有多余空间它也无效…
    没能解决这个问题.

    offset

    我把这个放在最后是因为写案例的时候出现了一点小状况, 我发现我的offset不能生效, 是那种…怎么改都不生效.
    然后一次偶然, 我把css里的:

    * {
      margin: 0;
      padding: 0;
      }
    

    删了, 然后解决了, 就挺无语的, 可能是el组件里的样式优先级比较低, 被覆盖了吧.

    好吧, 那步入正题
    offset规定col左侧的间隔份数, 它是真的能把col给挤到下一行的

    <el-row class="dark">
      <el-col
        :lg="{ span: 8, push: 0 }"
        class="yellow"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        :lg="{ span: 8, push: 0, pull: 0, offset: 9}"
        class="blue"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        class="green"
        :lg="{ span: 8, pull: 0, push: 0 }"
      >
        <div></div>
      </el-col>
    </el-row>
    

    效果:
    在这里插入图片描述
    不要offset来做换行, 用响应式或者在el-row添加

    style="flex-direction: column;" 
    

    会更好, offset达成的换行, 左侧会有空间, 就像上面动图的蓝块就是offset导致的换行, 不稳定而且难看.


    二、el-row

    “row” 中文即"排, 行"的意思, el-row组件即创建一行.
    使用后自动占据页面横向全部空间, 并且把横向空间不可见的分割为24份.
    在el-row添加

    style="flex-direction: column;" 
    

    可以实现纵向排列el-col, 在需要纵向布局时可以使用, 横向col现在填满默认自动换行, 不需要特别规定;

    gutter

    官方给的解释是"控制栅格间距", 我理解的是控制el-col之间的横向间距, 其实这有点像justify-content,写在外面控制里面.
    但是我写了一个demo来测试的时候, 发现它控制的似乎是el-col的子元素与el-col左边框的间距, 而并非el-col之间的间距.
    以下面这段代码为例, 一个el-row里装了三个el-col, 初始gutter为0.

    <el-row class="dark" :gutter="0">
    
      <el-col :span="8" class="yellow">
        <sy-author-1></sy-author-1>
      </el-col>
        <!-- 分隔 -->
      <el-col class="blue" :span="8">
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col class="green" :span="8">
        <div></div>
      </el-col>
    
    </el-row>
    

    在这里插入图片描述

    现在把gutter增加到80, 可以看到, el-col之间的距离始终是不变的:0, 但是除去最左边的组件, 每个el-col的子元素和它们所在el-col的左边距都增加了.

    这次增加是由el-col宽度的双向扩大和子元素向右位移共同完成的:
    在这里插入图片描述
    那么这是对于一个子元素, 如果对于多个同在一行的子元素, 全部子元素的左边距也并不会都增加:
    在这里插入图片描述
    这些子元素更像是被看作一个整体.


    justify

    el-row中所有el-col的横向对齐方式.
    但这是建立在el-row横向还有空间的前提下, 如果el-row横向24份已经塞得满满当当, 那这个属性给什么值都不会有效果的.

    属性可取值
    justifystart / end / center / space-around / space-between / space-evenly

    那还是用第一段代码举例:

    <el-row class="dark" justify="center"> <!-- 居中对齐 -->
      <el-col :span="8" class="yellow">
        <sy-author-1></sy-author-1>
      </el-col>
        <!-- 分隔 -->
      <el-col class="blue" :span="5"> <!-- 注意这里改成5了, 我们不能把el-row填满 -->
        <div></div>
        <span>哦哦哦</span>
      </el-col>
        <!-- 分隔 -->
      <el-col class="green" :span="8">
        <div></div>
      </el-col>
    </el-row>
    

    那现在可以看到现在el-col都挤到中央了, 其实这个挺像justify-content的.(弹性布局)
    他们封装的时候是不是就拿这个直接给justify-content传值的…我猜…
    在这里插入图片描述
    然后space-between情况下:
    在这里插入图片描述
    均匀分布两侧贴边.

    在el-col分多行的情况下:justify=“end”:

    <el-row class="dark" justify="end">
      <el-col
        :lg="{ span: 8, push: 0 }"
        class="yellow"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        :lg="{ span: 8, push: 0, pull: 0, offset: 9}"
        class="blue"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        class="green"
        :lg="{ span: 8, pull: 0, push: 0 }"
      >
        <div></div>
      </el-col>
    </el-row>
    

    效果:
    在这里插入图片描述

    align

    el-row中所有el-col的纵向对齐方式, 前提是纵向还有空间, 所以规定el-col的高度应该会是不错的选择, 不然纵向默认填满el-row, 这个属性就彻底失效了.
    三个可用值:

    属性可用值
    aligntop / middle / bottom

    默认是top, 这个情况下不给el-col高度, el-col也会在纵向占满el-row, 但是另外两个属性…

    align="bottom"
    

    在这里插入图片描述

    align="middle"
    

    在这里插入图片描述
    多行情况:

    <el-row class="dark" align="middle">
      <el-col
        :lg="{ span: 8, push: 0 }"
        class="yellow"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        :lg="{ span: 8, push: 0, pull: 0, offset: 9 }"
        class="blue"
      >
        <div></div>
      </el-col>
        <!-- 分隔 -->
      <el-col
        class="green"
        :lg="{ span: 8, pull: 0, push: 0 }"
      >
        <div></div>
      </el-col>
    </el-row>
    
    * {
      transition: 1s;
    }
    
    .dark {
      height: 500px;
      background-color: rgb(137, 133, 133);
    }
    
    .yellow {
      background-color: rgb(176, 170, 80);
      height: 100px;
    }
    .green {
      background-color: rgb(85, 144, 135);
      height: 100px;
    }
    
    .blue {
      background-color: rgb(65, 115, 153);
      height: 100px;
    }
    

    在这里插入图片描述


    总结

    约到一场15日的面试, 但是封校不得不推掉了, 很难受.

    如果这篇文章帮到你, 我很荣幸.

    展开全文
  • 'constant', constant_values=0) # Img2Col col_input = img2col(pad_input, out_height, out_width, kernel_h, kernel_w, stride) # merge channel col_input = col_input.reshape(col_input.shape[0], -1, col_...

    本文主要实现卷积神经网络(Convolutional Neural Network, CNN)中卷积操作的forwardbackward函数。CNN主要包括卷积(Convolution),池化(pooling),全连接(Fully Connected)操作。相信点进来的同学对这些操作的细节已经很熟悉了,不熟悉的同学可以参考这一篇博文(本人看过讲CNN最简单易懂、最好的博文,没有之一):An Intuitive Explanation of Convolutional Neural Networks

    img2col

    在讲img2col之前,我们先回顾一下卷积操作,假设我们有一个3*3的kernel如下:
    kernel
    那么用这个kernel对一幅二维图像做卷积的操作可以用如下动图表示:
    conv
    你可以使用numpy的切片操作来进行切片,按照上面动图的操作一步一步来,但是这种naive的方法非常慢,通常我们会用img2col操作把kernel变成行向量,把kernel对应的局部数据(receptive field)变成列向量,这样卷积操作就变成了矩阵乘法,速度成倍提升。img2col的操作细节,如下图可以概括:
    img2col
    具体代码如下,各种参数的含义可以参考上图:

    def img2col(input, h_out, w_out, h_k, w_k, stride):
        """
            Stacking ONLY Single Channel
        :input: (batch, channel, height, weight)
        :return: (batch, channel, h_k*w_k, h_out*w_out)
        """
        b, c, h, w = input.shape
        out = np.zeros((b, c, h_k*w_k, h_out*w_out))
        convhIdx = 0
        convwIdx = 0
        for i in range(b):
            for j in range(c):
                # For each channel, scan from left-top
                convwIdx = 0
                convhIdx = 0
                for k in range(h_out*w_out):
                    if convwIdx + w_k > w:
                        convwIdx = 0
                        convhIdx += stride
                    out[i, j, :, k] = input[i, j, convhIdx:convhIdx+h_k, convwIdx:convwIdx+w_k].flatten()
                    convwIdx += stride
        return out
    

    需要说明的是,卷积操作需要对所有channel的数据进行求和(大部分彩色图片都是3通道的,上图示例只显示了单通道的情况),但是池化操作需要分开计算各个channel的数据。考虑到复用问题,上面的img2col函数也是每个通道分开处理的,这样可以直接应用于池化操作。在卷积操作时需要对img2col输出的各个通道的数据进行合并。

    卷积操作forward

    代码如下:

        def forward(self, input, weights, bias):
            """
            # Arguments
                input: numpy array with shape (batch, in_channel, in_height, in_width)
                weights: numpy array with shape (out_channel, in_channel, kernel_h, kernel_w)
                bias: numpy array with shape (out_channel)
    
            # Returns
                output: numpy array with shape (batch, out_channel, out_height, out_width)
            """
            kernel_h = self.conv_params['kernel_h']  # height of kernel
            kernel_w = self.conv_params['kernel_w']  # width of kernel
            pad = self.conv_params['pad']
            stride = self.conv_params['stride']
            in_channel = self.conv_params['in_channel']
            out_channel = self.conv_params['out_channel']
    
            batch, in_channel, in_height, in_width = input.shape
            #####################################################################################
            # computing output shape
            out_h = int((in_height + pad - kernel_h)/stride) + 1
            out_w = int((in_width + pad - kernel_w)/stride) + 1
    
            # padding
            pad_input = np.pad(input, ((0,0),(0,0),(int(pad/2), pad-int(pad/2)),(int(pad/2), pad-int(pad/2))), 'constant', constant_values=0)
            in_height += pad
            in_width += pad
    
            # Img2Col
            col_input = img2col(pad_input, out_h, out_w, kernel_h, kernel_w, stride)
            # merge channel
            col_input = col_input.reshape(col_input.shape[0], -1, col_input.shape[3])
    
            # reshape kernel
            weights_flatten = weights.reshape(weights.shape[0], -1)
            
            # compute convolution
            output = weights_flatten @ col_input + bias.reshape(-1, 1)
    
            # reshape convolution result
            output = output.reshape(output.shape[0], output.shape[1], out_h, out_w)
            #####################################################################################
            return output
    

    col2img

    在讲卷积操作的backward之前,需要先说一下col2img这个函数。卷积backward的时候需要把计算得到的梯度进行img2col的逆操作,也就是col2imgcol2img实现如下:

    def col2img(input_col, pad_h, pad_w, kernel_h, kernel_w, channel, pad, stride):
        """
            Unstack columns to image
        :input_col: (batch, channel*kernel_h*kernel_w, out_h*out_w)
        :return: (batch, channel, pad_h - pad, pad_w - pad)
        """
        batch = input_col.shape[0]
        pad_out = np.zeros((batch, channel, pad_h, pad_w))
        # unchannel input, get shape (batch, channel, kernel_h*kernel_w, out_h*out_w)
        unchannel_input = input_col.reshape(input_col.shape[0], channel, -1, input_col.shape[2])
        col_idx = 0
        for i in range(batch):
            for j in range(channel):
                widx = 0
                hidx = 0
                # for each column in one channel
                for col_idx in range(unchannel_input.shape[-1]):
                    #                 print(i, j, hidx, widx)
                    pad_out[i, j, hidx:hidx + kernel_h, widx:widx + kernel_w] += unchannel_input[i, j, :, col_idx].reshape(
                        kernel_h, -1)
                    widx += stride
                    if widx + kernel_w > pad_w:
                        widx = 0
                        hidx += stride
        if pad<1:
            result = pad_out
        else:
            result = pad_out[:, :, int(pad / 2):-(pad - int(pad / 2)), int(pad / 2):-(pad - int(pad / 2))]
        return result
    

    卷积操作backward

    实现细节如下图:
    在这里插入图片描述
    c i c_i ci表示图片channel的数目,即输入通道; c o c_o co表示kernel的数目,即输出通道。
    本文backward的实现参考这篇博文:Convnet: Implementing Convolution Layer with Numpy

        def backward(self, out_grad, input, weights, bias):
            """
            # Arguments
                out_grad: gradient to the forward output of conv layer, with shape (batch, out_channel, out_height, out_width)
                input: numpy array with shape (batch, in_channel, in_height, in_width)
                weights: numpy array with shape (out_channel, in_channel, kernel_h, kernel_w)
                bias: numpy array with shape (out_channel)
    
            # Returns
                in_grad: gradient to the forward input of conv layer, with same shape as input
                w_grad: gradient to weights, with same shape as weights
                b_bias: gradient to bias, with same shape as bias
            """
            kernel_h = self.conv_params['kernel_h']  # height of kernel
            kernel_w = self.conv_params['kernel_w']  # width of kernel
            pad = self.conv_params['pad']
            stride = self.conv_params['stride']
            in_channel = self.conv_params['in_channel']
            out_channel = self.conv_params['out_channel']
    
            batch, in_channel, in_height, in_width = input.shape
            #################################################################################
            batch, out_channel, out_height, out_width = out_grad.shape
            """
               compute b_grad
            """
            b_grad = np.sum(out_grad, axis=(0, 2, 3))
            b_grad = b_grad.reshape(out_channel)
    
            # pad zero to input
            pad_input = np.pad(input, ((0,0),(0,0),(int(pad/2), pad-int(pad/2)),(int(pad/2), pad-int(pad/2))), 'constant', constant_values=0)
            # Img2Col
            col_input = img2col(pad_input, out_height, out_width, kernel_h, kernel_w, stride)
            # merge channel
            col_input = col_input.reshape(col_input.shape[0], -1, col_input.shape[3])
            
            # transpose and reshape col_input to 2D matrix
            X_hat = col_input.transpose(1, 2, 0).reshape(in_channel*kernel_h*kernel_w, -1)
            # transpose and reshape out_grad
            out_grad_reshape = out_grad.transpose(1, 2, 3, 0).reshape(out_channel, -1)
            
            """
                compute w_grad
            """
            w_grad = out_grad_reshape @ X_hat.T
            w_grad = w_grad.reshape(weights.shape)
    
            """
                compute in_grad
            """
            # reshape kernel
            W = weights.reshape(out_channel, -1)
            in_grad_column = W.T @ out_grad_reshape
    
            # Split batch dimension and transpose batch to first dimension
            in_grad_column = in_grad_column.reshape(in_grad_column.shape[0], -1, batch).transpose(2, 0, 1)
    
            in_grad = col2img(in_grad_column, in_height+pad, in_width+pad, kernel_h, kernel_w, in_channel, pad, stride)
            #################################################################################
            return in_grad, w_grad, b_grad
    

    池化操作pooling

    池化操作相对简单,对每个通道的数据分开计算即可:

    class pool(operator):
        def __init__(self, pool_params):
            """
            # Arguments
                pool_params: dictionary, containing these parameters:
                    'pool_type': The type of pooling, 'max' or 'avg'
                    'pool_h': The height of pooling kernel.
                    'pool_w': The width of pooling kernel.
                    'stride': The number of pixels between adjacent receptive fields in the horizontal and vertical directions.
                    'pad': The total number of 0s to be added along the height (or width) dimension; half of the 0s are added on the top (or left) and half at the bottom (or right). we will only test even numbers.
            """
            super(pool, self).__init__()
            self.pool_params = pool_params
    
        def forward(self, input):
            """
            # Arguments
                input: numpy array with shape (batch, in_channel, in_height, in_width)
    
            # Returns
                output: numpy array with shape (batch, in_channel, out_height, out_width)
            """
            pool_type = self.pool_params['pool_type']
            pool_height = self.pool_params['pool_height']
            pool_width = self.pool_params['pool_width']
            stride = self.pool_params['stride']
            pad = self.pool_params['pad']
    
            batch, in_channel, in_height, in_width = input.shape
            #####################################################################################
            # computing output shape
            out_h = int((in_height + pad - pool_height) / stride) + 1
            out_w = int((in_width + pad - pool_width) / stride) + 1
    
            # padding
            pad_input = np.pad(input,
                               ((0, 0), (0, 0), (int(pad / 2), pad - int(pad / 2)), (int(pad / 2), pad - int(pad / 2))),
                               'constant', constant_values=0)
            in_height += pad
            in_width += pad
    
            # Img2Col
            col_input = img2col(pad_input, out_h, out_w, pool_height, pool_width, stride)
            if pool_type == 'max':
                output = col_input.max(axis=2).reshape(batch, in_channel, out_h, out_w)
            elif pool_type == 'avg':
                output = np.average(col_input, axis=2).reshape(batch, in_channel, out_h, out_w)
            else:
                output = None
            #####################################################################################
            return output
    
        def backward(self, out_grad, input):
            """
            # Arguments
                out_grad: gradient to the forward output of conv layer, with shape (batch, in_channel, out_height, out_width)
                input: numpy array with shape (batch, in_channel, in_height, in_width)
    
            # Returns
                in_grad: gradient to the forward input of pool layer, with same shape as input
            """
            pool_type = self.pool_params['pool_type']
            pool_height = self.pool_params['pool_height']
            pool_width = self.pool_params['pool_width']
            stride = self.pool_params['stride']
            pad = self.pool_params['pad']
    
            batch, in_channel, in_height, in_width = input.shape
            out_height = 1 + (in_height - pool_height + pad) // stride
            out_width = 1 + (in_width - pool_width + pad) // stride
    
            pad_scheme = (pad//2, pad - pad//2)
            input_pad = np.pad(input, pad_width=((0,0), (0,0), pad_scheme, pad_scheme),
                               mode='constant', constant_values=0)
    
            recep_fields_h = [stride*i for i in range(out_height)]
            recep_fields_w = [stride*i for i in range(out_width)]
    
            input_pool = nnFimg2col(input_pad, recep_fields_h,
                                 recep_fields_w, pool_height, pool_width)
            input_pool = input_pool.reshape(
                batch, in_channel, -1, out_height, out_width)
    
            if pool_type == 'max':
                input_pool_grad = (input_pool == np.max(input_pool, axis=2, keepdims=True)) * \
                    out_grad[:, :, np.newaxis, :, :]
    
            elif pool_type == 'avg':
                scale = 1 / (pool_height*pool_width)
                input_pool_grad = scale * \
                    np.repeat(out_grad[:, :, np.newaxis, :, :],
                              pool_height*pool_width, axis=2)
    
            input_pool_grad = input_pool_grad.reshape(
                batch, in_channel, -1, out_height*out_width)
    
            input_pad_grad = np.zeros(input_pad.shape)
            idx = 0
            for i in recep_fields_h:
                for j in recep_fields_w:
                    input_pad_grad[:, :, i:i+pool_height, j:j+pool_width] += \
                        input_pool_grad[:, :, :, idx].reshape(
                            batch, in_channel, pool_height, pool_width)
                    idx += 1
            in_grad = input_pad_grad[:, :, pad:pad+in_height, pad:pad+in_width]
            return in_grad
    
    
    展开全文
  • Twitter Bootstrap中的col-lg-* , col-md-*和col-sm-* col-md-*什么区别?

    本文翻译自:What is the difference among col-lg-*, col-md-* and col-sm-* in Bootstrap?

    Twitter Bootstrap中的col-lg-*col-md-*col-sm-* col-md-*什么区别?


    #1楼

    参考:https://stackoom.com/question/1LLpm/Bootstrap中的col-lg-col-md-和col-sm-有什么区别


    #2楼

    From Twitter Bootstrap documentation : Twitter Bootstrap文档中

    • small grid (≥ 768px) = .col-sm-* , 小网格(≥768px)= .col-sm-*
    • medium grid (≥ 992px) = .col-md-* , 中格(≥992px)= .col-md-*
    • large grid (≥ 1200px) = .col-lg-* . 大网格(≥1200px)= .col-lg-*

    #3楼

    Updated 2019... 2019年更新...

    The Bootstrap 3 grid comes in 4 tiers (or "breakpoints")... Bootstrap 3网格分为4层(或“断点”)...

    • Extra small (for smartphones .col-xs-* ) 特小(适用于智能手机.col-xs-*
    • Small (for tablets .col-sm-* ) 小(适用于平板电脑.col-sm-*
    • Medium (for laptops .col-md-* ) 中(适用于笔记本电脑.col-md-*
    • Large (for laptops/desktops .col-lg-* ). 大(适用于笔记本电脑/台式机.col-lg-* )。

    These grid sizes enable you to control grid behavior on different widths. 这些网格大小使您可以控制不同宽度上的网格行为。 The different tiers are controlled by CSS media queries . 不同的层由CSS 媒体查询控制。

    So in Bootstrap's 12-column grid... 因此,在Bootstrap的12列网格中...

    col-sm-3 is 3 of 12 columns wide (25%) on a typical small device width (> 768 pixels) 在典型的小型设备宽度(> 768像素)上, col-sm-3是12列宽(25%)中的3列

    col-md-3 is 3 of 12 columns wide (25%) on a typical medium device width (> 992 pixels) col-md-3在典型的中等设备宽度(> 992像素)上为12列宽(25%)中的3列


    The smaller tier ( xs , sm or md ) also defines the size for larger screen widths . 较小的层( xssmmd )还定义了较大屏幕宽度的大小 So, for the same size column on all tiers, just set the width for the smallest viewport... 因此,对于所有层上相同大小的列,只需设置最小视口的宽度即可。

    <div class="col-lg-3 col-md-3 col-sm-3">..</div> is the same as, <div class="col-lg-3 col-md-3 col-sm-3">..</div>

    <div class="col-sm-3">..</div>

    Larger tiers are implied. 隐含更大的层 Because col-sm-3 means 3 units on sm-and-up , unless specifically overridden by a larger tier that uses a different size. 因为col-sm-3 3 units on sm-and-up意味着3 units on sm-and-up ,除非被使用不同大小的较大层特别覆盖。

    xs (default) > overridden by sm > overridden by md > overridden by lg xs (默认值)>被sm覆盖>被md覆盖>被lg覆盖


    Combine the classes to use change column widths on different grid sizes . 组合类以在不同的网格大小上使用更改列宽 This creates a responsive layout. 这将创建一个响应式布局。

    <div class="col-md-3 col-sm-6">..</div>

    The sm , md and lg grids will all "stack" vertically on screens/viewports less than 768 pixels. smmdlg网格都将在小于768像素的屏幕/视口上垂直“堆叠”。 This is where the xs grid fits in. Columns that use the col-xs-* classes will not stack vertically, and continue to scale down on the smallest screens. 这就是xs网格所在的地方。使用col-xs-*类的col-xs-*不会垂直堆叠,并且会继续在最小的屏幕上按比例缩小。

    Resize your browser using this demo and you'll see the grid scaling effects. 使用此演示调整浏览器的大小,您将看到网格缩放效果。


    Bootstrap 4 引导程序4

    In Bootstrap 4 there is a new -xl- size, see this demo . Bootstrap 4中有一个新的-xl-大小,请参阅此演示 Also the -xs- infix has been removed , so smallest columns are simply col-1 , col-2 .. col-12 , etc.. -xs-缀也已删除 ,因此最小的列只是col-1col-2 .. col-12等。

    col-* - 0 (xs) col-* -0(xs)
    col-sm-* - 576px col-sm-* sm- col-sm-* -576像素
    col-md-* - 768px col-md-*
    col-lg-* - 992px col-lg-* -992px
    col-xl-* - 1200px col-xl-* -1200px

    Bootstrap 4 Grid Demo Bootstrap 4网格演示

    Additionally, Bootstrap 4 includes new auto-layout columns . 此外,Bootstrap 4包括新的自动布局列 These also have responsive breakpoints ( col , col-sm , col-md , etc..), but don't have defined % widths. 这些也具有响应断点( colcol-smcol-md等),但是没有定义宽度百分比。 Therefore, the auto-layout columns fill equal width across the row. 因此,自动布局列在行中的宽度相等


    This article explains more about the Bootstrap grid 本文介绍了有关Bootstrap网格的更多信息


    #4楼

    I think the confusing aspect of this is the fact that BootStrap 3 is a mobile first responsive system and fails to explain how this affects the col-xx-n hierarchy in that part of the Bootstrap documentation. 我认为这令人困惑的方面是,BootStrap 3是一个移动优先响应系统,并且无法在Bootstrap文档的那部分中解释这如何影响col-xx-n层次结构。 This makes you wonder what happens on smaller devices if you choose a value for larger devices and makes you wonder if there is a need to specify multiple values. 这使您想知道如果为较大的设备选择一个值,在较小的设备上会发生什么,并且使您怀疑是否需要指定多个值。 (You don't) (你不)

    I would attempt to clarify this by stating that... Lower grain types (xs, sm) attempt retain layout appearance on smaller screens and larger types (md,lg) will display correctly only on larger screens but will wrap columns on smaller devices. 我将尝试通过声明以下内容来澄清这一点:较小的晶粒类型(xs,sm)尝试在较小的屏幕上保留布局外观,而较大的晶粒类型(md,lg)仅在较大的屏幕上正确显示,但在较小的设备上会包裹列。 The values quoted in previous examples refer to the threshold as which bootstrap degrades the appearance to fit the available screen estate. 先前示例中引用的值是指阈值,因为该引导会降低外观以适合可用的屏幕空间。

    What this means in practice is that if you make the columns col-xs-n then they will retain correct appearance even on very small screens, until the window drops to a size that is so restrictive that the page cannot be displayed correctly. 实际上,这意味着,如果将列col-xs-n设置为n,则即使在很小的屏幕上,它们也将保持正确的外观,直到窗口大小减小到无法正确显示页面的程度为止。 This should mean that devices that have a width of 768px or less should show your table as you designed it rather than in degraded (single or wrapped column form). 这应该意味着宽度为768px或更小的设备应在设计时显示表格,而不是以降级(单列或包裹列的形式)显示。 Obviously this still depends on the content of the columns and that's the whole point. 显然,这仍然取决于列的内容,这就是重点。 If the page attempts to display multiple columns of large data, side by side on a small screen then the columns will naturally wrap in a horrible way if you did not account for it. 如果页面尝试在小屏幕上并排显示大数据的多列,那么如果您不考虑这些列,这些列自然会以一种可怕的方式包装。 Therefore, depending on the data within the columns you can decide the point at which the layout is sacificed to display the content adequately. 因此,根据列中的数据,您可以确定要布局的点,以充分显示内容。

    eg If your page contains three col-sm-n columns bootstrap would wrap the columns into rows when the page width drops below 992px. 例如,如果您的页面包含三个col-sm-n列,则当页面宽度降至992px以下时,引导程序会将这些列包装为行。 This means that the data is still visible but will require vertical scrolling to view it. 这意味着数据仍然可见,但需要垂直滚动才能查看。 If you do not want your layout to degrade, choose xs (as long as your data can be adequately displayed on a lower resolution device in three columns) 如果您不希望布局降级,请选择xs(只要您的数据可以在三列中以较低分辨率的设备充分显示)

    If the horizontal position of the data is important then you should try to choose lower granularity values to retain the visual nature. 如果数据的水平位置很重要,则应尝试选择较低的粒度值以保持外观。 If the position is less important but the page must be visible on all devices then a higher value should be used. 如果位置不太重要,但页面必须在所有设备上可见,则应使用更高的值。

    If you choose col-lg-n then the columns will display correctly until the screen width drops below the xs threshold of 1200px. 如果选择col-lg-n,则列将正确显示,直到屏幕宽度降至1200像素的xs阈值以下。


    #5楼

    The bootstrap docs do explain it, but it still took me a while to get it. 引导文档确实对此进行了解释,但是仍然花了我一段时间。 It makes more sense when I explain it to myself in one of two ways: 当我以两种方式之一向自己解释时,它更有意义:

    If you think of the columns starting out horizontally, then you can choose when you want them to stack . 如果您想到的列是水平开始的,那么可以选择何时堆叠它们

    For example, if you start with columns: ABC 例如,如果您从以下列开始:ABC

    You decide when should they stack to be like this: 您可以决定何时堆叠它们,如下所示:

    A 一种

    B

    C C

    If you choose col-lg, then the columns will stack when the width is < 1200px. 如果选择col-lg,则当宽度<1200px时,列将堆叠。

    If you choose col-md, then the columns will stack when the width is < 992px. 如果选择col-md,则当宽度<992px时,列将堆叠。

    If you choose col-sm, then the columns will stack when the width is < 768px. 如果选择col-sm,则宽度小于768px时,列将堆叠。

    If you choose col-xs, then the columns will never stack. 如果选择col-xs,则列将永远不会堆叠。

    On the other hand, if you think of the columns starting out stacked, then you can choose at what point they become horizontal : 另一方面,如果您考虑从堆叠开始的列,则可以选择它们在何时变为水平

    If you choose col-sm, then the columns will become horizontal when the width is >= 768px. 如果选择col-sm,则宽度> = 768px时,列将变为水平。

    If you choose col-md, then the columns will become horizontal when the width is >= 992px. 如果选择col-md,则宽度> = 992px时,列将变为水平。

    If you choose col-lg, then the columns will become horizontal when the width is >= 1200px. 如果选择col-lg,则当宽度> = 1200px时,列将变为水平。


    #6楼

    Device Sizes and class prefix: 设备大小和类前缀:

    • Extra small devices Phones (<768px) - .col-xs- 超小型设备电话(<768px)-. .col-xs-
    • Small devices Tablets (≥768px) - .col-sm- 小型设备平板电脑(≥768px)-.col .col-sm-
    • Medium devices Desktops (≥992px) - .col-md- 中型设备台式机(≥992px)-. .col-md-
    • Large devices Desktops (≥1200px) - .col-lg- 大型设备台式机(≥1200px)-.col .col-lg-

    Grid options: 网格选项:

    Bootstarp网格系统

    Reference: Grid System 参考: 网格系统

    展开全文
  • bootstrap栅栏系统css中的col-xs-,col-sm-,col-md-* 的意义: .col-xs-*超小屏幕手机(768px),.col-sm-*小屏幕平板(≥768px),.col-md-*中等屏幕桌面显示器 说明: 1、col-列; 2、xs-maxsmall,超小;sm-small,小;...
  • im2col原理详解

    千次阅读 2021-11-19 23:37:51
    图像的卷积计算有很多种算法,目前各个开源框架常用的都是im2col+gemm的方式 该方法的做法,就是将卷积过程转化为矩阵乘法,其好处在于可以通过优化矩阵乘算法,优化计算过程,并且有利于CUDA等并行计算 设有图像A...
  • 本文翻译自:Meaning of numbers in “col-md-4”,“ col-xs-1”, “col-lg-2” in Bootstrap I am confused with the grid system in the new Bootstrap, particularly these classes: 我对新Bootstrap中的网格系统...
  • col的用法

    千次阅读 2021-04-30 08:36:26
    col 的用法以前就接触过,可是后来一直用pl/sql developer。就一直没有用到结果遇到在sqlplus中执行select d.file_name,d.tablespace_name from Dba_Data_Files d显示却不是想要的结果后来上网询问了大虾col file_...
  • bootstrap4中col-sm col-md col-lg col-xl

    千次阅读 2020-11-14 10:10:56
    col-xs , col-sm , col-md , col-lg是什么意思?什么时候用? .col-xs- 超小屏幕 手机 (<768px) .col-sm- 小屏幕 平板 (≥768px) .col-md- 中等屏幕 桌面显示器 (≥992px) .col-lg- 大屏幕 大桌面显示器 (≥...
  • 卷积实现之im2col算法

    万次阅读 2020-03-09 11:53:54
    卷积详解之im2col算法                                                            
  • im2col是将一个[C,H,W]矩阵变成一个[H,W]矩阵的一个方法,其原理是利用了行列式进行等价转换。im2col原本是matlab中的一个操作 在Pytorch中可以用torch.unfold,torch.cat和torch.transpose的组合实现im2col操作. ...
  • df[col]与df[[col]]的区别

    千次阅读 2021-11-13 13:42:34
    其实这个也非常好理解,因为【col】其实也就是列表格式的,【col】是【col1、col2、col3、col5…]这种一般情况中的一个特例,而很明显这种一般情况对应多列的情形,自然也只可能是dataframe类型了。 观察不难发现,...
  • HTML5 之 Col Colgroup 标签

    千次阅读 2020-10-16 09:59:18
    col   col 用于定义表格中的列。   col为表格内单标签元素,只能在table元素或者colgroup元素中使用。   其属性值主要包括如下几种,均能通过CSS属性实现。 span:指定col元素横跨的列数,此属性值为正整数,...
  • 在使用bootstrap做前端开发的时候,经常会用到列移动、列排列,那么对col--offset,col--push,col-*-pull一定不会默认,下面对其使用说明做简单介绍。 首先看这3个英文单词的中文含义解释: offset 本意:补偿...
  • col-xs , col-sm , col-md , col-lg的理解

    千次阅读 2020-10-13 09:49:37
    摘要: bootstrap栅栏系统css中的col-xs-、col-sm-、col-md-* 的意义: .col-xs- 超小屏幕 手机 (<768px) .col-sm- 小屏幕 平板 (≥768px) .col-md- 中等屏幕 桌面显示器 (≥992px) .col-lg- 大屏幕 大桌面显示器 ...
  • ORACLE COL SET 设置显示参数

    千次阅读 2021-05-01 01:47:35
    conn letu/ouc@coreset line 200set pagesize 10000set heading offcol EMPLOYEE_ID FOR 9999col FIRST_NAME FOR A15col LAST_NAME FOR A15col EMAIL FOR A8col PHONE_NUMBER FOR A20col HIRE_DATE FOR A15col JOB_I...
  • Ant 表单中label-col和wrapper-col

    千次阅读 2021-10-09 10:57:50
    :label-col='{span:5, offset:1}' :wrapper-col='{span:18}' 意思如下: 总共: 5+1+18 = 24 份。 文字label部分占比 总共 6/24,宽度5,向右移动1. input部分占比 18/24.
  • Element el-row el-col 布局组件详解

    万次阅读 多人点赞 2021-01-27 10:18:12
    1. 背景 element的布局方式与bootstrap原理是一样的,将网页划分成若干行,然后每行等...el-col>标识,至于每列整行的宽度比例,则使用:span属性进行设置。 如下代码,即为将1行等分为2列,为了便于区分列,我们为列
  • Oracle中 col 命令

    千次阅读 2019-03-21 19:33:37
    COL命令: 主要格式化列的显示形式。 该命令有许多选项,具体如下: COL[UMN] [{ column|expr} [ option ...]] Option选项可以是如下的子句: ALI[AS] alias CLE[AR] FOLD_A[FTER] FOLD_B[EFORE] FOR[MAT] format HEA...
  • 这两个函数其实完成的功能比较简单,im2col就是把矩阵按卷积乘法所需,变换成列向量,col2im是一个逆过程 从下面这张图你一眼就能看明白im2col的操作(caffe中卷积计算都是Matrix_Kernel * Matrix_Col),因为都列...
  • 关注微信公共号:小程在线 ...FAILED: SemanticException org.apache.hadoop.hive.ql.metadata.HiveException: The column KEY._col1:0._col0 is not in the vectorization context column map {KEY._col0=0, KEY._col1
  • Element源码系列——Row以及Col组件

    万次阅读 多人点赞 2018-08-06 13:43:02
    Element源码系列——Row以及Col组件 Element源码系列——Row以及Col组件 序言 Row Col 总结 序言 官网中对Layout 布局的定义是: 通过基础的 24 分栏,迅速简便地创建布局. Element中的栅格系统...
  • 1. 输入 4 维数据 2. 基于im2col 的展开 3. 卷积层实现
  • 根据row和col-python确定字母

    千次阅读 2020-12-20 17:44:53
    所以我很难过,因为我非常精通Java,所以我无法想象这个看似微不足道的东西,但无论如何,我的Python教授为我们分配了一个实验室,我们必须创建一个...col:return 'T'else:return 'W'会屈服:WWWWWWWWWWWWWWWWWWWWTWWWWW...
  • 关于如何在一个用循环写的el-row里面单独设置el-col,并且给fileCause失败原因加一个自适应滚动条,刚开始不给el-col加div,只在span里面加滚动条是不生效的,加了div,在div里面加滚动条让这个div包裹这个el-col就...
  • vue vue-element-ui组件 row col布局

    千次阅读 2021-08-05 16:01:32
    col 列概念 <el-col></el-col> col组件的:span属性的布局调整,一共分为24栏: 代码示例: <el-row> <el-col :span="24"><div class="grid-content"></div></el-col> &...
  • 关于index_col参数的用法

    千次阅读 2021-02-23 15:47:19
    index_col是read_csv中的一个参数。用来指定表格的索引值。 index_col的值有三种,整数型,序列,布尔,并且是可选的,默认是None 如果您的文件格式不正确,每行末尾都有分隔符,则可以考虑使用index_col=false...
  • 576px的,我查阅很多博客看他们好多写的是.col-xs-,我按照那种方法试不行,我用的是bootstrapvue4.3根本没有什么.col-xs- 这一说 于是亲自用浏览器F12手机模式调试,亲测.col-对于手机才可行!这点bootstrap更新了,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 671,519
精华内容 268,607
关键字:

col