SOLO代码解读[head]

Sat, 04 Apr 2020 00:00:00 +0000

detectors/solo.py
anchor_heads/solo_head.py

目前在做实例分割相关的课题,这次介绍基于mmdetection的SOLO代码,主要是head部分的代码解读。

detectors/solo.py

这里里面定义了整体的结构,可见直接继承SingleStageInsDetector类，从config文件可以看出，SOLO的backbone为resne，neck为FPN，head为solo head。所以重点是在solo head。

@DETECTORS.register_module
class SOLO(SingleStageInsDetector):

    def __init__(self,
                 backbone,
                 neck,
                 bbox_head,
                 train_cfg=None,
                 test_cfg=None,
                 pretrained=None):
        super(SOLO, self).__init__(backbone, neck, bbox_head, train_cfg,
                                   test_cfg, pretrained)

anchor_heads/solo_head.py

这里就是SOLO的重点介绍部分，包括head的定义，以及loss的计算。

    def _init_layers(self):
        norm_cfg = dict(type='GN', num_groups=32, requires_grad=True)
        self.ins_convs = nn.ModuleList()
        self.cate_convs = nn.ModuleList()
        # 在SOLO中self.stacked_convs=7，category和mas branch都是先经过7个conv block最后输出
        for i in range(self.stacked_convs):
            chn = self.in_channels + 2 if i == 0 else self.seg_feat_channels
            self.ins_convs.append(
                ConvModule(
                    chn,
                    self.seg_feat_channels,
                    3,
                    stride=1,
                    padding=1,
                    norm_cfg=norm_cfg,
                    bias=norm_cfg is None))

            chn = self.in_channels if i == 0 else self.seg_feat_channels
            self.cate_convs.append(
                ConvModule(
                    chn,
                    self.seg_feat_channels,
                    3,
                    stride=1,
                    padding=1,
                    norm_cfg=norm_cfg,
                    bias=norm_cfg is None))
        # 因为mask branch的输出通道数由grid决定，所有这里是个list，
        # 即不同的level对应不同的输出conv block
        self.solo_ins_list = nn.ModuleList()
        for seg_num_grid in self.seg_num_grids:
            self.solo_ins_list.append(
                nn.Conv2d(
                    self.seg_feat_channels, seg_num_grid**2, 1))
		# category branch的输出conv block的通道都是类别数-1
        self.solo_cate = nn.Conv2d(
            self.seg_feat_channels, self.cate_out_channels, 3, padding=1)

定义完网络结构后，下面开始前向计算

    def forward(self, feats, eval=False):
        # self.split_feats将5个level的feature map尺寸重新处理一下
        new_feats = self.split_feats(feats)
        # 取出每个level的尺寸
        featmap_sizes = [featmap.size()[-2:] for featmap in new_feats]
        upsampled_size = (featmap_sizes[0][0] * 2, featmap_sizes[0][1] * 2)
        # 这是前向计算的主体函数，self.forward_single每次处理一个level
        ins_pred, cate_pred = multi_apply(self.forward_single, new_feats, 
                                          list(range(len(self.seg_num_grids))),
                                          eval=eval, upsampled_size=upsampled_size)
        return ins_pred, cate_pred
    
    # 这里为什么将第一个和最后一个feature map的尺寸进行变换
    def split_feats(self, feats):
        return (F.interpolate(feats[0], scale_factor=0.5, mode='bilinear'), 
                feats[1], 
                feats[2], 
                feats[3], 
                F.interpolate(feats[4], size=feats[3].shape[-2:], mode='bilinear'))

下面的self.forward_single就是前向计算的主体部分，不复杂，注意的是在mask branch需要将x、y坐标信息拼接到对应level的feature map上。

    def forward_single(self, x, idx, eval=False, upsampled_size=None):
        '''
        :param x: fpn每个level的feature map [N,C,H,W]
        :param idx:  [0,1,2,3,4]中的一个,用来指示当前的level级别
        :param eval: False
        :param upsampled_size: 最大feature map/C1 的h,w
        :return:
        '''
        # 老规矩,因为这里有两个branch
        ins_feat = x
        cate_feat = x

        # 这里先处理mask分支,1. 将x,y坐标拼接在feature map上,通道数+2,
        # 这里是将坐标信息concat到feature map上
        x_range = torch.linspace(-1, 1, ins_feat.shape[-1], device=ins_feat.device) # w --> x
        y_range = torch.linspace(-1, 1, ins_feat.shape[-2], device=ins_feat.device) # h --> y
        # 对x_range, y_range 进行扩充
        y, x = torch.meshgrid(y_range, x_range)
        # 将两个坐标扩成4维
        y = y.expand([ins_feat.shape[0], 1, -1, -1])
        x = x.expand([ins_feat.shape[0], 1, -1, -1])
        # 将坐标cancat到feature map的通道上
        coord_feat = torch.cat([x, y], 1)
        ins_feat = torch.cat([ins_feat, coord_feat], 1)
        # 将处理好的新的fearure map送进ins_convs
        for i, ins_layer in enumerate(self.ins_convs):
            ins_feat = ins_layer(ins_feat)
        # 这里将feature map上采样到2H*2W,应该是为了提高mask分割的精度
        ins_feat = F.interpolate(ins_feat, scale_factor=2, mode='bilinear')
        # 这里获得了mask分支的结果
        ins_pred = self.solo_ins_list[idx](ins_feat)
        
        # 这里开始处理category分支
        for i, cate_layer in enumerate(self.cate_convs):
            # 如果是第一个conv，则需要进行采样，因为category分支的尺寸是h=w=S
            if i == self.cate_down_pos:
                seg_num_grid = self.seg_num_grids[idx]
                cate_feat = F.interpolate(cate_feat, size=seg_num_grid, mode='bilinear')
            cate_feat = cate_layer(cate_feat)
        # 这里获得了category分支的结果
        cate_pred = self.solo_cate(cate_feat)

        # 如果使测试模式,
        # 将mask分支的结果取sigmoid,并且上采样到原始C1的尺寸
        # category分支的结果进行points_nms,这个待会再看
        if eval:
            ins_pred = F.interpolate(ins_pred.sigmoid(), size=upsampled_size, mode='bilinear')
            cate_pred = points_nms(cate_pred.sigmoid(), kernel=2).permute(0, 2, 3, 1)
        return ins_pred, cate_pred

此时模型的前向计算就结束了，框架很简洁，接下来的loss计算相对繁琐一些。

    def loss(self,
             ins_preds,
             cate_preds,
             gt_bbox_list,
             gt_label_list,
             gt_mask_list,
             img_metas,
             cfg,
             gt_bboxes_ignore=None):

        # featmap_sizes里面包含了五个level的mask branch输出尺寸
        featmap_sizes = [featmap.size()[-2:] for featmap in
                         ins_preds]
		# 接下来又遇到multi_apply函数，说明self.solo_target_single每次处理batch中的一张图片
        # 其实从config文件也可以看出来，SOLO也用到了bbox信息
        # 接下来我们直接跳到self.solo_target_single函数
        ins_label_list, cate_label_list, ins_ind_label_list = multi_apply(
            self.solo_target_single,
            gt_bbox_list,
            gt_label_list,
            gt_mask_list,
            featmap_sizes=featmap_sizes)

self.solo_target_single作用是为category和mask branch分支分配gt label

    def solo_target_single(self,
                               gt_bboxes_raw,
                               gt_labels_raw,
                               gt_masks_raw,
                               featmap_sizes=None):
        '''
        :param gt_bboxes_raw:  [objects,4]
        :param gt_labels_raw:  [objects,1]
        :param gt_masks_raw:   [objects,H,W]
        :param featmap_sizes: []
        :return:
        '''
        device = gt_labels_raw[0].device
        # 这里获得单张图片上所有的object的area [object]
        gt_areas = torch.sqrt((gt_bboxes_raw[:, 2] - gt_bboxes_raw[:, 0]) * (
                gt_bboxes_raw[:, 3] - gt_bboxes_raw[:, 1]))

        ins_label_list = []
        cate_label_list = []
        ins_ind_label_list = []
        # 这里每次遍历一个level
        for (lower_bound, upper_bound), stride, featmap_size, num_grid \
                in zip(self.scale_ranges, self.strides, featmap_sizes, self.seg_num_grids):
            # self.scale_ranges:((1, 96), (48, 192), (96, 384), (192, 768), (384, 2048))
            #     每个level的object的面积范围,这是缓解object重叠的一种方式,
            #     将不同尺度的object分配到不同的level取预测
            # self.strides :[8, 8, 16, 32, 32],对应与原图的采样比例 2**n
            #     这里与之前的split_feat也对应上了,第一个下采样到1/2,最后一个上采样到2倍
            # featmap_sizes : 每个level的尺寸
            # self.seg_num_grids : [40, 36, 24, 16, 12]

            # ins_label的尺寸与输出一致[S*S,H,W]
            ins_label = torch.zeros([num_grid ** 2, featmap_size[0], featmap_size[1]], dtype=torch.uint8, device=device)
            # cate_label的尺寸为[S,S]一个通道直接表示gt的label.
            cate_label = torch.zeros([num_grid, num_grid], dtype=torch.int64, device=device)
            # mask branch中S*S个通道的是否有匹配的gt
            ins_ind_label = torch.zeros([num_grid ** 2], dtype=torch.bool, device=device)

            # 这里返回的是area满足面积范围的索引,
            # bbox是为了将不同大小的object分配到不同level
            hit_indices = ((gt_areas >= lower_bound) & (gt_areas <= upper_bound)).nonzero().flatten()
            # 如果没有满足的object,直接跳掉下一个level
            if len(hit_indices) == 0:
                ins_label_list.append(ins_label)
                cate_label_list.append(cate_label)
                ins_ind_label_list.append(ins_ind_label)
                continue
            # 取出满足面积要求的object
            gt_bboxes = gt_bboxes_raw[hit_indices]
            gt_labels = gt_labels_raw[hit_indices]
            # 这里为什么要.cpu().numpy()?
            # 调试发现gt_masks使numpy,并不是tensor,为什么?
            gt_masks = gt_masks_raw[hit_indices.cpu().numpy(), ...]
            # 为什么要乘self.sigma,不太懂. 0.1*h,0.1*w
            half_ws = 0.5 * (gt_bboxes[:, 2] - gt_bboxes[:, 0]) * self.sigma
            half_hs = 0.5 * (gt_bboxes[:, 3] - gt_bboxes[:, 1]) * self.sigma

            # 因为maks分支输出的h,w是原level的2倍
            output_stride = stride / 2

            # 遍历每个object,先为每个grid分配label,根据矩形框和mask的中心
            for seg_mask, gt_label, half_h, half_w in zip(gt_masks, gt_labels, half_hs, half_ws):
                #如果object的mask小于10个像素,则忽略
                if seg_mask.sum() < 10:
                   continue

                # mass center
                # featmap_sizes[0][0] * 4是原图的尺寸(貌似可能不等于,因为图像尺寸不是统一的)
                upsampled_size = (featmap_sizes[0][0] * 4, featmap_sizes[0][1] * 4)
                # 找出object的中心坐标
                center_h, center_w = ndimage.measurements.center_of_mass(seg_mask)
                # 将object的中心位置映射到grid上
                coord_w = int((center_w / upsampled_size[1]) // (1. / num_grid))
                coord_h = int((center_h / upsampled_size[0]) // (1. / num_grid))

                # left, top, right, down
                # 这里的四个值标定了一个矩形框,大小为0.1的原矩形框
                # 我这样理解,如果一个object的面积稍大,则一个object对应的grid是多个
                top_box = max(0, int(((center_h - half_h) / upsampled_size[0]) // (1. / num_grid)))
                down_box = min(num_grid - 1, int(((center_h + half_h) / upsampled_size[0]) // (1. / num_grid)))
                left_box = max(0, int(((center_w - half_w) / upsampled_size[1]) // (1. / num_grid)))
                right_box = min(num_grid - 1, int(((center_w + half_w) / upsampled_size[1]) // (1. / num_grid)))

                # 判断映射到grid里的中心是否在上述的矩形框里
                # 当top==down==left==right时说明当前object只占S*S中的一个grid
                top = max(top_box, coord_h-1)
                down = min(down_box, coord_h+1)
                left = max(coord_w-1, left_box)
                right = min(right_box, coord_w+1)
                # 将该位置的label记为gt_label
                cate_label[top:(down+1), left:(right+1)] = gt_label

                # 将seg_mask resize到当前level的mask branch的输出尺寸
                seg_mask = mmcv.imrescale(seg_mask, scale=1. / output_stride)
                seg_mask = torch.Tensor(seg_mask)
                # 为mask branch分配gt
                for i in range(top, down+1):
                    for j in range(left, right+1):
                        label = int(i * num_grid + j)
                        ins_label[label, :seg_mask.shape[0], :seg_mask.shape[1]] = seg_mask
                        ins_ind_label[label] = True
            ins_label_list.append(ins_label)
            cate_label_list.append(cate_label)
            ins_ind_label_list.append(ins_ind_label)
        return ins_label_list, cate_label_list, ins_ind_label_list

ins_label_list: 保存了整个batch的mask branch的gt label
cate_label_list: 整个batch的category branch的gt label
ins_ind_label_list: 整个batch标识S*S通道存在object的通道

我们再返回loss函数接着看

        # zip(*ins_label_list) [num_levels, N, S*S, 2H, 2W]
        #    返回值每一组为整个batch的同一个level的mask branch gt label.
        # zip(*ins_ind_label_list)
        #    同上
        # zip(ins_labels_level, ins_ind_labels_level)
        #    每个image的同level
        # 这里是将gt构造成pred的形式,便于后面的loss计算
        ins_labels = [torch.cat([ins_labels_level_img[ins_ind_labels_level_img, ...]
                                 for ins_labels_level_img, ins_ind_labels_level_img in
                                 zip(ins_labels_level, ins_ind_labels_level)], 0)
                      for ins_labels_level, ins_ind_labels_level in zip(zip(*ins_label_list), zip(*ins_ind_label_list))]

        ins_preds = [torch.cat([ins_preds_level_img[ins_ind_labels_level_img, ...]
                                for ins_preds_level_img, ins_ind_labels_level_img in
                                zip(ins_preds_level, ins_ind_labels_level)], 0)
                     for ins_preds_level, ins_ind_labels_level in zip(ins_preds, zip(*ins_ind_label_list))]

        # ins_ind_labels [S*S*batch_size] eg. 40*40*2=3200
        ins_ind_labels = [
            torch.cat([ins_ind_labels_level_img.flatten()
                       for ins_ind_labels_level_img in ins_ind_labels_level])
            for ins_ind_labels_level in zip(*ins_ind_label_list)
        ]
        # flatten_ins_ind_labels [7744]
        flatten_ins_ind_labels = torch.cat(ins_ind_labels)

        num_ins = flatten_ins_ind_labels.int().sum()

最后就是实际的loss计算

        # dice loss
        # mask部分使用dict loss
        loss_ins = []
        for input, target in zip(ins_preds, ins_labels):
            if input.size()[0] == 0:
                continue
            input = torch.sigmoid(input)
            loss_ins.append(dice_loss(input, target))
        loss_ins = torch.cat(loss_ins).mean()
        loss_ins = loss_ins * self.ins_loss_weight

        # cate
        # category部分使用FocalLoss
        cate_labels = [
            torch.cat([cate_labels_level_img.flatten()
                       for cate_labels_level_img in cate_labels_level])
            for cate_labels_level in zip(*cate_label_list)
        ]
        flatten_cate_labels = torch.cat(cate_labels)

        cate_preds = [
            cate_pred.permute(0, 2, 3, 1).reshape(-1, self.cate_out_channels)
            for cate_pred in cate_preds
        ]
        flatten_cate_preds = torch.cat(cate_preds)

        loss_cate = self.loss_cate(flatten_cate_preds, flatten_cate_labels, avg_factor=num_ins + 1)
        return dict(
            loss_ins=loss_ins,
            loss_cate=loss_cate)

双系统ubuntu目录扩容

Wed, 06 Nov 2019 00:00:00 +0000

在windows上释放相应的空间
新建分区
查看分区信息
移动文件
删除目录
挂载目录
重启

原本的ubuuntu硬盘分区不太合理，再加上数据越来越多，所以需要讲其它硬盘上的分区扩展到home目录。当然也可以是其它任意目录，方法是一样的。

在windows上释放相应的空间

直接在磁盘管理里面删除卷即可，相应的存储空间变为灰色

新建分区

进入ubunutu系统，使用gparted在刚才释放的空间上新建分区，格式为ext4 此时，新建的分区就是我们需要挂载的

比如：我之前的\目录一共60G，现在我有一个240G的空闲存储空间，那么我可以将这240G的空间新建一个分区合并到我的\目录

查看分区信息

sudo fdisk -l
sudo blkid

通过观察内存大小，找到对应分区的名称，像我的是/dev/sda2

移动文件

因为我需要扩充/home目录，所以需要将目前的/home目录下的所有文件移动到一个新的分区里

sudo mkdir /media/home_new
sudo mount /dev/sda2 /media/home_new
cd /home
sudo cp -a * /media/home_new

此时，/home目录已经在新分区里面存在了，你可以查看/media/home_new目录，里面与/home目录一样

删除目录

慎重！此时可将/home目录下的个人文件全部删除，因为这个目录已经不在需要了，建议保留系统原本的文件夹，只删除个人创建的文件夹

挂载目录

系统每次开机会根据/etc/fstab里面的配置信息挂载分区

sudo vim /etc/fstab
在文件最后添加 /dev/sda2 /home ext4 defaults 0 0

重启

sudo reboot
df -kh即可看到新分区已挂载到/home目录上，文件夹查看/home属性，可见已成功扩容

DeltaCV之CPU算法优化[加权灰度化及阈值分割]

Mon, 15 Apr 2019 00:00:00 +0000

OpenCV中的过程
DeltaCV中的优化

这篇文章我们先来认识一下DeltaCV中CPU上做的相关优化工作，使用SSE及AVX指令集优化加权灰度化过程,并进行阈值分割。

OpenCV中的过程

    cv::Mat s_colors[3],weighted_gray,opencvOUT;
    cv::split(img,s_colors);
    weighted_gray = s_colors[0]*0.9+s_colors[1]*0.05+s_colors[2]*0.05;
    cv::threshold(weighted_gray,opencvOUT,125,255,cv::THRESH_BINARY);

可以看到，上述过程涉及三个步骤：分离通道，加权计算，阈值分割。

可以优化的地方还是两点：

并行优化
一次遍历

DeltaCV中的优化

函数原型

    /*
     * src: input(BGR image)
     * dst: output
     * width:
     * height:
     * lower: lower boundary: 1 channels
     * upper: upper boundary: 1 channels
     */
    void weightedGrayWithSeg(unsigned char *src, unsigned char *dst,const int width,const int height,scalar_d weights,
                             scalar lower,scalar upper);

加载变量

        // 加载阈值
__m256i ch0_min_sse = _mm256_setr_epi8(lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0]);

__m256i ch0_max_sse = _mm256_setr_epi8(upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0]);

const int Shift = 15;

const int W_B = weights[0] * (1 << Shift), W_G = weights[1] * (1 << Shift), W_R = weights[2] * (1 << Shift);

__m256i SSE_WBG = _mm256_setr_epi16(W_B, W_G, W_B, W_G, W_B, W_G, W_B, W_G, W_B, W_G, W_B, W_G, W_B, W_G, W_B, W_G);

__m256i SSE_WRC = _mm256_setr_epi16(W_R, 0, W_R, 0, W_R, 0, W_R, 0,W_R, 0, W_R, 0, W_R, 0, W_R, 0);

主要是将两个阈值及加权系数加载进变量中，注意这里是使用的__m256i类型，因为我们后面进行的计算和判断都将在AVX指令集上进行。

循环主体

__m128i src1, src2, src3,src4,src5,src6;

src1 = _mm_loadu_si128((__m128i *) (src + 0));
src2 = _mm_loadu_si128((__m128i *) (src + 16));
src3 = _mm_loadu_si128((__m128i *) (src + 32));
src4 = _mm_loadu_si128((__m128i *) (src + 48));
src5 = _mm_loadu_si128((__m128i *) (src + 64));
src6 = _mm_loadu_si128((__m128i *) (src + 80));

__m128i BG0_00 = _mm_shuffle_epi8(src1,_mm_setr_epi8(0,-1,1,-1,3,-1,4,-1,6,-1,7,-1,9,-1,10,-1));
 __m128i BG0_01 = _mm_shuffle_epi8(src1,_mm_setr_epi8(12,-1,13,-1,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
BG0_01 = _mm_or_si128(BG0_01,_mm_shuffle_epi8(src2,_mm_setr_epi8(-1,-1,-1,-1,-1,-1,0,-1,2,-1,3,-1,5,-1,6,-1)));

__m128i BG0_10 = _mm_shuffle_epi8(src2, _mm_setr_epi8(8, -1, 9, -1, 11, -1, 12, -1, 14, -1, 15, -1, -1, -1, -1, -1));
BG0_10 = _mm_or_si128(BG0_10,_mm_shuffle_epi8(src3,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 2, -1)));
__m128i BG0_11 = _mm_shuffle_epi8(src3, _mm_setr_epi8(4, -1, 5, -1, 7, -1, 8, -1, 10, -1, 11, -1, 13, -1, 14, -1));

__m128i BG1_00 = _mm_shuffle_epi8(src4,_mm_setr_epi8(0,-1,1,-1,3,-1,4,-1,6,-1,7,-1,9,-1,10,-1));
__m128i BG1_01 = _mm_shuffle_epi8(src4,_mm_setr_epi8(12,-1,13,-1,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
BG1_01 = _mm_or_si128(BG1_01,_mm_shuffle_epi8(src5,_mm_setr_epi8(-1,-1,-1,-1,-1,-1,0,-1,2,-1,3,-1,5,-1,6,-1)));

__m128i BG1_10 = _mm_shuffle_epi8(src5, _mm_setr_epi8(8, -1, 9, -1, 11, -1, 12, -1, 14, -1, 15, -1, -1, -1, -1, -1));
BG1_10 = _mm_or_si128(BG1_10,_mm_shuffle_epi8(src6,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 2, -1)));
__m128i BG1_11 = _mm_shuffle_epi8(src6, _mm_setr_epi8(4, -1, 5, -1, 7, -1, 8, -1, 10, -1, 11, -1, 13, -1, 14, -1));

__m256i BG0 = _mm256_combine_si128(BG0_00,BG1_00);
__m256i BG1 = _mm256_combine_si128(BG0_01,BG1_01);
__m256i BG2 = _mm256_combine_si128(BG0_10,BG1_10);
__m256i BG3 = _mm256_combine_si128(BG0_11,BG1_11);

__m128i RC0_00 = _mm_shuffle_epi8(src1,_mm_setr_epi8(2,-1,-1,-1,5,-1,-1,-1,8,-1,-1,-1,11,-1,-1,-1));
__m128i RC0_01 = _mm_shuffle_epi8(src1,_mm_setr_epi8(14,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
RC0_01 = _mm_or_si128(RC0_01,_mm_shuffle_epi8(src2,_mm_setr_epi8(-1,-1,-1,-1,1,-1,-1,-1,4,-1,-1,-1,7,-1,-1,-1)));

__m128i RC0_10 = _mm_shuffle_epi8(src2,_mm_setr_epi8(10,-1,-1,-1,13,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
RC0_10 = _mm_or_si128(RC0_10,_mm_shuffle_epi8(src3,_mm_setr_epi8(-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1,3,-1,-1,-1)));
__m128i RC0_11 = _mm_shuffle_epi8(src3,_mm_setr_epi8(6,-1,-1,-1,9,-1,-1,-1,12,-1,-1,-1,15,-1,-1,-1));

__m128i RC1_00 = _mm_shuffle_epi8(src4,_mm_setr_epi8(2,-1,-1,-1,5,-1,-1,-1,8,-1,-1,-1,11,-1,-1,-1));

__m128i RC1_01 = _mm_shuffle_epi8(src4,_mm_setr_epi8(14,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
RC1_01 = _mm_or_si128(RC1_01,_mm_shuffle_epi8(src5,_mm_setr_epi8(-1,-1,-1,-1,1,-1,-1,-1,4,-1,-1,-1,7,-1,-1,-1)));

__m128i RC1_10 = _mm_shuffle_epi8(src5,_mm_setr_epi8(10,-1,-1,-1,13,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
RC1_10 = _mm_or_si128(RC1_10,_mm_shuffle_epi8(src6,_mm_setr_epi8(-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1,3,-1,-1,-1)));
__m128i RC1_11 = _mm_shuffle_epi8(src6,_mm_setr_epi8(6,-1,-1,-1,9,-1,-1,-1,12,-1,-1,-1,15,-1,-1,-1));

__m256i RC0 = _mm256_combine_si128(RC0_00,RC1_00);
__m256i RC1 = _mm256_combine_si128(RC0_01,RC1_01);
__m256i RC2 = _mm256_combine_si128(RC0_10,RC1_10);
__m256i RC3 = _mm256_combine_si128(RC0_11,RC1_11);

上述代码主要是加载图像中的像素，一次加载了96个（与之前的48不同），然后先使用SSE指令构造出BG(B 0 G 0 B 0 G 0…)和RC(R 0 0 0 R 0 0 0…)组合，然后再将它们拼接为__m256i，为什么不直接在AVX上进行呢？因为AVX中的shuffle指令在这里用起来不太合适，当然也能构造出想要的数据，但是会多出很多额外的运算，大家可以试一试，如果更搞笑的方法，请在github的issues提出。

加权计算及阈值分割

__m256i Result;

__m256i gray0 = _mm256_srai_epi32(_mm256_add_epi32(_mm256_madd_epi16(BG0, SSE_WBG), _mm256_madd_epi16(RC0, SSE_WRC)), Shift);
__m256i gray1 = _mm256_srai_epi32(_mm256_add_epi32(_mm256_madd_epi16(BG1, SSE_WBG), _mm256_madd_epi16(RC1, SSE_WRC)), Shift);
__m256i gray2 = _mm256_srai_epi32(_mm256_add_epi32(_mm256_madd_epi16(BG2, SSE_WBG), _mm256_madd_epi16(RC2, SSE_WRC)), Shift);
__m256i gray3 = _mm256_srai_epi32(_mm256_add_epi32(_mm256_madd_epi16(BG3, SSE_WBG), _mm256_madd_epi16(RC3, SSE_WRC)), Shift);

__m256i packed_gray = _mm256_packus_epi16(_mm256_packus_epi32(gray0, gray1), _mm256_packus_epi32(gray2, gray3));
Result = _mm256_cmpge_up_epu8(packed_gray, ch0_min_sse);
Result = _mm256_and_si256(Result, _mm256_cmpge_down_epu8(packed_gray, ch0_max_sse));

_mm256_storeu_si256((__m256i *)dst, Result);

首先将4组数据进行加权运算得到4个__m256i变量，这个就是灰度空间的像素值，然后最后再接上阈值判断，处于范围中的置255，其它置0.

收尾

for (int j = blockSize * block; j < height * width; ++j, src += 3, dst++) {
    uint8_t _ch0 = src[0], _ch1 = src[1], _ch2 = src[2];
    uint8_t gray_ = (W_B * _ch0 + W_G * _ch1 + W_R * _ch2) >> Shift;
    if (gray_ >= lower[0] && gray_ <= upper[0]) 
    {
        dst[0] = 255;
    } else {
        dst[0] = 0;
    }
}

老规矩，不足一个block的单独处理。

性能对比

处理1000次取平均值

Image Size: 1024 x 1280（H x W）

opencv函数耗时: 1.56 - 1.69 ms

DeltaCV函数耗时: 0.39 - 0.46 ms

加速比: 3.39 - 4.33

深度学习中的过拟合

Mon, 08 Apr 2019 00:00:00 +0000

过拟合表现
直观分析
神经网络中导致过拟合的操作
缓解过拟合的方法

这篇文章主要是介绍一下神经网络中的过拟合问题，并总结一下目前都有哪些有效的方法来缓解过拟合问题。

过拟合表现

在深度学习任务中，过拟合最直观的表现就是，模型在测试集的表现远远差于训练集，也就是模型的泛化性能太差。

直观分析

为什么在测试集上的表现差于训练集？最简单的回答，因为模型就是在训练集上训练出来的，它对训练集接触的比较多，好！那为什么测试集和训练集是同一类数据（训练集和测试集同一分布），表现就这么差了呢？难道模型从训练集学错东西了？没有去学习数据内在真实的规律（分布）？

我们都知道设计模型是为了让模型自己归纳出数据的内在规律，那么我们现在有理由怀疑网络自己“学坏了”，没有按照我们的期望去学习。

那更正式的解释呢？我们所有的训练集都是对真实样本的抽样，不管是图片数据，还是语音等，获得的样本是 $X = x(真实值)+u(随机误差)$ ,而我们的神经网络优化的损失函数是模型的输出与 $X$ 之间的误差，所以模型拟合的是 $X$ 的分布，而我们期望的是网络尽可能的找到 $ x(真实值)$ 的分布，所以当网络错误的过分拟合 $X$ 时（即也强行拟合了$u(随机误差)$），当使用测试集时，就算对于同一类图片，当随机误差不一样时，模型也认为它们是不同类的。

其次，我们还可以想到，也有可能是训练数据太少了，不具有代表性，为什么呢？

周所周知，机器学习或者深度学习任务中，一个前提是训练集在待解决问题上必须有足够的代表性，当数据太少时，网络往往只学习到了一部分，大数定理也告诉我们，当样本足够多时，我们可以近似认为样本分布就是真实分布。

神经网络中导致过拟合的操作

训练集大小相对于网络规模偏小。

怎么定义这个小？目前我是不清楚有什么公式或者量化的方式在训练前知道是否会过拟合，通常我的做法就是设计网络结构时根据经验，先从小网络开始，毕竟小网络训练快，一步一步增加网络规模，直到发现训练集误差比上个模型小，但是测试集误差却变大，这里就可以初步知道对于该问题，神经网络的大致规模。

缓解过拟合的方法

获取更多、质量更高的数据。
- 直接采集新的数据，对于图片数据，上网爬，自己去拍等。
- 数据增强（要根据实际问题选取其中的一部分操作，不能无脑用）：标准化、随机旋转、随机裁剪、随机亮度、随机噪声、随机平移，随机缩放，mixup等。
- 生成式数据：利用 GAN来根据已有的数据生成新的数据，没用过，听说效果不太好。
减小模型的规模，上面也说了，模型规模太大，导致模型完美地拟合了训练集，包括噪声。
正则化
- L1、L2范数，对权重施加惩罚项，一般使用L2范数，求导容易，方便优化
- dropout
BN
early stopping
集成学习方法
- bagging：每次有放回的从训练集抽取一个子集训练模型，经过N次抽取，会训练出N个模型，测试时分别使用N个模型，最后再综合决策出结果。
- boosting：同样也是训练N个分类器，不过是根据样本的权重，依次递进的训练，它训练出的分类器成为弱分类器，最后将弱分类器按照各自的”性能得分“组合成一个强分类器。

深度学习中的激活函数总结

Sun, 07 Apr 2019 00:00:00 +0000

Sigmoid
Tanh
ReLU
Leaky ReLU
PReLU
RReLU
ELU
SELU
CReLU
Maxout
Swish
参考

这篇文章主要是总结一下现阶段CNN中已有的各种激活函数，明确每种激活函数的特点，以及存在的问题。

从定义来讲，只要连续可导的函数都可以作为激活函数，但目前常见的多是分段线性和具有指数形状的非线性函数。

Sigmoid

图片来源

特点：

输出范围0-1，很符合人的主观意识，即神经元对感知的也是从不激活(0)到完全激活(1)。
单调连续
容易求导，导数为$f(x)(1-f(x))$，用自己就可以表示自己的导数。

缺陷：

具有软饱和性（左软饱和性指x趋近于负无穷，导数趋近于0，右饱和性指x趋近于正无穷，导数趋近于0），在输出值较大较小时，网络很难更新，因为BP算法是更具梯度来进行的，这也是所谓的梯度消失问题。
输出不是以0为中心，而是0.5。但是相对于前一条缺陷，影响没那么大。

Tanh

图片来源

特点：

收敛速度比sigmoid函数快，原因是：tanh 的输出均值比 sigmoid 更接近 0，SGD会更接近natural gradient（一种二次优化技术），从而降低所需的迭代次数。

缺陷：

依然存在软饱和性。

ReLU

图片来源

当时AlexNet提出的激活函数，非常优秀，很长一段时间是我们设计CNN网络的默认激活函数。

特点：

当输入为正数时，输出导数恒为1，缓解了梯度消失的问题。
为网络带来稀疏性，当输入值小于0，就会被稀疏掉，人的大脑稀疏性高达95%。
不管是正向计算，还是导数计算都非常简单。

缺点：

左硬饱和性，当输入小于零时，导数恒为0，会使很多神经元无法得到更新，出现“神经元死亡”。
relu函数输出无负值。
均值漂移，relu函数的输出均值恒大于0（从relu函数的输出范围就能看出来）。

Leaky ReLU

公式：$f(x) = max(\alpha*x,x)$

特点：

为了解决relu中“神经元死亡”的问题，leaky relu给小于零的输入一个非常小的梯度。

缺点：

公式中的 $\alpha$ 是一个很小的值，一般取0.01，首先这就是个超参数，另外也有文献指出它的性能很不稳定，有时候比relu好，有时候差，可想而知，不太靠谱。

PReLU

公式和Leaky ReLU一样，只不过它的 $\alpha$ 参数是可学习的。

特点：

收敛速度比relu快。
输出均值更接近0。

缺点：

目前还不清楚，只能说表现还不稳定，不够“通用”，其作者何凯明在他的ResNet也没使用，而是使用的ReLU。

RReLU

和PReLU类似，只不过它这里的 $\alpha$ 参数是一个高斯分布上的随机值，在测试时固定。

ELU

特点：

较高的噪声鲁棒性。
输出均值在0附近。

缺点：

存在指数运算，运算量较大。

SELU

牛逼的地方是提出该方法的论文后面有长达93页的论证。

公式：$f(x)=\lambda*ELU(x)$

特点（摘自知乎回答）：

新增的参数 $\lambda$ 大于1，所以在正半轴，函数的导数是大于1的。
激活函数有一个不动点，网络深了以后每一层的输出都会向正态分布靠拢，美其名曰自归一化。

缺点（摘自知乎回答）：

selu的证明部分前提是权重服从正态分布，但是这个假设在实际中并不能一定成立，比如钟形分布？（不太懂）
众多实验发现效果并不比relu好。

CReLU

公式：$CReLU(x)=[ReLU(x),ReLU(-x)]$

作者发现在网络的浅层卷积核更倾向于捕捉正负相位的信息，而ReLU会将负相位的信息归0，所以才有了CReLU操作。

特点：

输出通道数翻倍，相当于利用对称的关系，将负相位的信息人为恢复出来。

缺点：

到底在哪些层使用，太依赖调试了。

Maxout

公式：$max(w_1^Tx+b_1,w_2^Tx+b_2,…,w_n^Tx+b_n)$

它是ReLU的推广，其发生饱和是一个零测集事件（不懂什么意思…），具有一个参数k。

特点：

maxout可以拟合任意的凸函数。
具备relu的所有优点。
不会出现神经元死亡。

缺点：

（不错的解释）参数量巨大（以k倍增加），因为之前我们每个神经元只需要一组权重和偏置，现在不是了，我们添加了冗余的k组权重和偏置，让输入均经过这些权重和偏置计算，只保留激活值最大的输出。

Swish

公式：$f(x) = x*sigmoid(\beta*x)$，其中 $\beta$ 参数可以是常数也可以是训练的。

图片来源

特点：

无上界有下界、平滑、非单调。
Swish函数可以看做是介于线性函数与ReLU函数之间的平滑函数。
论文给出的实验，各种数据集上，各种网络，都比relu性能好（并且在深层网络上优势更大）。

缺点：

只有实验证明，没有理论支持。
在浅层网络上，性能与relu差别不大。

参考

https://www.cnblogs.com/makefile/p/activation-function.html
https://www.cnblogs.com/ranjiewen/p/5918457.html?utm_source=itdadao&utm_medium=referral

CNN网络结构总结[二]

Sun, 07 Apr 2019 00:00:00 +0000

SqueezeNet - 2017
Xception
MobileNet V1 - 2017
ShuffleNet V1 - 2017
MobileNet V2
ShuffleNet V2
总结
感想

这篇文章主要是总结一些经典的轻量级网络,随着神经网络在终端上的应用,网络的精简化和高效化变得越来越重要.轻量级网络大部分是在CNN的卷积方式上做出改变,它们与网络压缩还是有很大的不同,后者是在网络训练完成后做的工作,前者工作是在网络的设计阶段.

SqueezeNet - 2017

特点:

提出fire module(squeeze层+expand层). squeeze层就是1x1的卷积,但是通道数少于上一层,起到了特征压缩的作用,毕竟轻量级网络,要保证计算量尽可能小. expand层有两条路,一路还是1x1的卷积,一路为3x3的卷积,颇有inception结构的意思,最后将两路的输出拼接在一起,在经过激活函数.
不过论文中说模型大小<0.5M(论文名称:SqueezeNet ：AlexNet-level accuracy with 50x fewer parameters and <0.5MB),是进行模型压缩后的数据(标!题!党!)

Xception

特点:

也是采用深度分离卷积形式,但是和MobileNet V1不同的是,它受inception结构的启发,在depth-wise时采用1x1的卷积核,在point-wise时采用3x3的卷积核.

MobileNet V1 - 2017

特点:

采用深度分离卷积代替普通卷积(注意深度分离卷积并不是他提出的).深度分离卷积分为两个步骤:depth-wise和point-wise.这里可以类比group convolution,组卷积最后是采用拼接来完成通道融合,而深度分离卷积是采用一组1x1卷积来进行通道间的融合.另外它还可以看作是组卷积的一种特殊形式(分组数为输入通道数,即每一组只有一个feature map).

深度分离卷积使网络维持准确率的前提下,大大减少了网络参数量和计算量(注意参数量少,计算量不一定小).
网络中没有使用池化层,而是使用strides为2的卷积代替.

ShuffleNet V1 - 2017

图片来源

特点:

提出channel shuffle,为的是解决group convolution中分组之间信息不互通的问题,在组卷积后进行组重排,强行让信息在分组间流动.

在ResNet的残差模块上进行改进,将原来的图(a)1x1+bn+relu -> 3x3+bn+relu -> 1x1+ bn -> add -> relu,结构改为图(b) 1x1 Gconv+ bn+relu - channel shuffle - 3x3+bn -1x1 Gconv+bn - add - relu.图(c)是当输出尺寸小于输入尺寸时,在另外一条支路上添加一个stride为2的池化.

MobileNet V2

特点:

结合了残差模块,但是和残差模块不同的是,它先使用1x1卷积对输入的通道进行扩张,最后再压缩.另外在最后用于压缩的1x1卷积操作后没有激活函数(激活函数在高维特征空间可以有效的增加非线性,但是在较低维度空间时,反而会破坏特征).
在输入输出大小不变时,同样采用了shortcut connection,这点和残差模块一致.

ShuffleNet V2

特点:

提出了FLOPs不能作为衡量目标检测模型运行速度的唯一标准，因为MAC(Memory access cost)也是影响模型运行速度的一大因素.进而作者提出了设计轻量级网络要遵循的准则:
- 1. 卷积操作时，输入输出采用相同通道数可以降低MAC。假设一个1*1卷积层的输入特征通道数是c1，输出特征尺寸是h和w，输出特征通道数是c2， $MAC=hw(c_1+c_2)+c_{1}c_{2}$, $FLOPS=hwc_{1}c_{2}$, 由均值不等式可得:$MAC\ge\sqrt{hw*FLOPS}+FLOPS/hw$, 当$\sqrt{c_1^2-c_2^2}=0$时,即$c_1=c_2$时,MAC取最小值.
- 1. 在group convolution中,分组过多,会使MAC增加.
- 1. 分支数量越少,模型速度越快.
- 1. 尽可能减少element-wise操作.
根据以上提出的四条准则,对ShuffleNet V1进行了改进,具体结构如上图(c)(d)所示.
- 1. 在开始添加一个channel splite操作,将输入通道平均分为两份.对应准则1.
- 1. 取消了组卷积,对应准则2.
- 1. 将channel shuffle移到最后,对应准则3.
- 1. 用拼接操作代替add操作,对应准则4.

总结

总结了上述几种网络,大家对深度分离卷积进行各种魔改,大家冥冥之中,都是在解决通道间信息流通不够的问题,,MobileNet及Xception采用卷积的形式(points wise),而ShuffleNet采用channel shuffle的形式,然后都再加上shortcut connection,计算量和准确率都得到了保证.反正感觉这块没有实质性的进展,都是在前几年的研究上修修补补.

感想

顺着如何加强通道间信息交流的思路,一方面是能不能在chanel shuffle的时候加上个注意力机制,让网络决定哪些信息是需要在通道间流通的,哪些不需要,因为图像毕竟是结构化数据,如果强行让全部通道进行shuffle,会不会破坏某些特征的独特性.
从其它方面来加强网络对特征的利用率,感觉深度分离卷积这条路没什么可以做的了.

CNN网络结构总结[一]

Sat, 06 Apr 2019 00:00:00 +0000

LeNet-1998
AlexNet-2012
VGG-2014
GoogLeNet
ResNet-2015
ResNet V2
ResNeXt
WRN-2016
DenseNet-2017

最近准备找个实习,借此机会将CNN这块的东西回顾一下,准备花两三天时间把绝大部分的CNN网络总结一下,明白网络提出的契机,欲解决的问题等.

本文内容大部分是借鉴网上的资料.

LeNet-1998

特点:

局部感受野（local receptive fields）
权值共享（weight sharing）
下采样（subsampling）
卷积+非线性激活+下采样+全连接

LeNet可以说是开了卷积神经网络的先河,它使用的结构一直沿用到现在.

AlexNet-2012

2012 年，AlexNet 横空出世，在 ILSVRC-2012 上大大超越了第二名的选手，从此深度学习进入高速发展阶段。

特点:

提出了ReLU激活函数,并一直沿用到现在.目前比较优秀的激活函数
提出了Dropout方法,这也是现在还在用的减缓过拟合的技巧.一般也用在全连接层.
提出了最大池化,之前的CNN普遍使用平均池化(具有模糊化效果,同时反向传播也没有最大池化有效).
使用了LRN,这个技巧貌似没有再用了,好像又说是这个东西其实要不要无所谓,但是其动机是好的,可以探究一下.
首次使用了GPU训练网络,并且还是多卡训练.
数据增强,不过使用的都是基本的裁剪,反转等操作

VGG-2014

可以看出,VGG系列有很多变体,但是我们最常用的还是VGG-16,很多物体检测的backbone就是用的它.在很多迁移学习任务中,性能甚至超过了GoogLeNet,但是其参数量较大,达到了140M左右.

特点:

卷积核尺寸全部为3x3
池化的核尺寸为2x2
将网络进一步加深

GoogLeNet

Inception V1

特点:

该结构将CNN中常用的卷积（1x1，3x3，5x5）、池化操作（3x3）堆叠在一起（卷积、池化后的尺寸相同，将通道相加），一方面增加了网络的宽度，另一方面也增加了网络对尺度的适应性。
在3x3，5x5卷积前面,使用1x1的卷积核降低了特征的通道数,主要是减少计算量.
在此之前,全连接层前面的卷积层会先flat成1x1xn的形式, 该版本的网络使用全局池化,将nxnxm的卷积特征转换为1x1xm
为了避免梯度消失,额外添加了两个softmax辅助训练.借用网上的一篇文章的一句话”辅助分类器是将中间某一层的输出用作分类，并按一个较小的权重（0.3）加到最终分类结果中，这样相当于做了模型融合，同时给网络增加了反向传播的梯度信号，也提供了额外的正则化，对于整个网络的训练很有裨益。”

Inception V2

提出了BN,一直存在的神级idea.不多说.

Inception V3

特点:

卷积分解(也就是我们熟知的两个3x3感受野相当于一个5x5,三个3x3相当于一个7x7,但前者的参数量都要少于后者)
非对称卷积,将nxn的卷积核分解为1xn和nx1串联的形式(论文指出当特征图大小为12到20时,才会有效果,其它尺寸下效果不明显,玄学)
使用label smoothing, 之后也有论文指出使用smooth label要好于one hot形式,基于教师-学生的one shot学习也从侧面证实了这一点.

Inception V4

特点:

将Inception结构与ResNet的残差结构(见 ResNet)结合在一起.

ResNet-2015

特点:

提出残差结构,有效地减缓了梯度消失的问题,问什么呢?因为不管网络的权重再怎么小,梯度再怎么小,至少还有个恒等映射,迫使信息进行流动,也正是这个结构使ResNet达到了150多层.

ResNet V2

特点:

在 ResNet V2 中，分支中的层不像传统的 Conv-BN-ReLU 顺序，而是改成了 BN-ReLU-Conv。作者把这个称为预激活（pre-activation），其思想是将非线性激活也看成一个恒等映射（identity mapping），这样，在前向和反向阶段，信号可以直接的从一个单元传递到其他任意一个单元。这样的操作使得优化更加简单，甚至能训练深达 1001 层的 ResNet.

ResNeXt

特点:

借鉴了inception的结构,扩展了模块的宽度,提出了 “cardinality” 概念,即一个模块并联多少个残差块(这里我有个疑问,在图中并联的残差块中,首先256通道直接降低为4通道?这样信息是不是会损失很多,还是我的理解出错了.)

WRN-2016

特点:

增加残差模块中的卷积输出通道,最后得到的结果是40层的WRN和1001层的ResNet结果相当,但是训练速度是后者的8倍,所以结论是:相同参数时,宽度大,网络好训练,并且性能不会差

DenseNet-2017

特点:

密集连接:缓解梯度消失问题，加强特征传播，鼓励特征复用，极大的减少了参数量(可能听到密集连接,大家会想到这样不会大大加重网络的参数量吗?其实不是的,因为既然我们复用了这么多的特征层,那就没必要将新生成的特征层的通道数增大太多,其实参数量反而还能减少,因为对特征的利用率更高了,所以不用将通道扩大很多也行,这就是DenseNet最突出的优点了).
显存占用过大

还要注意一点,密集连接是在一个block中的,是的你没听错,DenseNet是由很多个block组成的,每个block内部才使用密集连接,block之间没有.

Principles of training multi-layer neural network using backpropagation[翻译]

Fri, 05 Apr 2019 00:00:00 +0000

这篇文章是介绍神经网络中的训练方法-BP算法，算是一篇比较经典的文章,最近又自己用SIMD指令集重写一个小型的神经网络，借此机会再好好巩固一下BP算法。

原文链接

使用反向传播算法训练多层神经网络的原理

本项目使用BP算法来介绍多层神经网络的训练过程，下图展示了一个包含三层神经元的网络,具有两个输入,一个输出。

每个神经元有两个操作组成，一个是将系数(包括权重和偏置)和输入信号进行叠加，第二个是引入非线性，我们一般称之为神经元激活函数，其中 $e$ 就是叠加信号，$y=f(e)$ 为非线性部分的输出，$y$也被称为神经元的输出。

为了训练神经网络，我们需要训练集。训练集包含输入信号 $x_1$ 和 $x_2$ 以及它们对应的期望输出 $z$，网络的训练是一个迭代的过程。在每个迭代过程，都会根据当前的训练数据对神经元的系数进行调整，调整的规则如下：每一轮的训练都是从训练集的两个输入开始，经过一系列计算，我们可以得到每个神经元的输出。下图说明了信号是如何在网络中传播的，符号 $W_{(xm)n}$ 表示网络的输入 $x_m$ 和输入层的神经元 $n$ 之间的权重，符号 $y_n$ 表示神经元 $n$ 的输出。

紧接着，信号传递到隐藏层，符号 $W_{mn}$ 表示神经元 $m$ 的输出和下一层的额神经元 $n$ 之间的权重。

信号到达了输出层。

接下来，网络的输出信号 $y$ 会和训练集给出的期望输出进行对比，它们之间的差异被称为输出层的误差 $\delta$。

直接计算中间层的神经元的误差是不现实的，因为它们的输出值我们目前还不知道。很久以来都没有有效的方法去训练多层神经网络，直到80年代中期，反向传播算法才被提出。它的思路是将误差信号 $\delta$ (同一次迭代中)反向传播回所有神经元。

用于反向传播的系数 $W_{mn}$ 和正向计算时候的值一样（它们是共用的），只是信号的方向变了（之前是信号是从前一个神经元到下一个神经元，现在的误差信号是从下一个神经元到前一个神经元，所以才称为“反向传播”），这种操作应用与全部的神经网络层。

当所有神经元的误差都被计算后，它们之间的权重系数就会被更新。公式中的 $df(e)/de$ 表示激活函数的导数。

系数 $\eta$ 用来调节网络训练的速度，目前有很多方法去调节这个参数，第一种方法是在网络训练刚开始时，使用较大的 $\eta$，随着训练的进行，再逐渐减小。第二种相对复杂一点，刚开始训练时，使用较小的 $\eta$，随着训练进行，逐渐增大 $\eta$，然后再逐渐减小 $\eta$ 直到训练结束。

DeltaCV之CPU算法优化[YCrCb空间阈值分割]

Tue, 02 Apr 2019 00:00:00 +0000

OpenCV中的函数
- 函数原型
DeltaCV中的优化

这篇文章我们先来认识一下DeltaCV中CPU上做的相关优化工作，使用SSE指令集优化RGB转YCrCb颜色空间过程,并进行阈值分割。

OpenCV中的函数

在OpenCV中完成RGB图像在YCrCb空间的阈值分割,需要用到两个函数,cv::cvtColor(颜色空间转换)及cv::inRange(阈值处理).

函数原型

void cvtColor( InputArray src, OutputArray dst, int code, int dstCn = 0 );

void inRange(InputArray src, InputArray lowerb,InputArray upperb, OutputArray dst);

DeltaCV中的优化

函数原型

    /**  @brief: more details - >　
     *
     * src: input(BGR image)
     * dst: output
     * width:
     * height:
     * lower: lower boundary
     * upper: upper boundary
     */
    bool ycrcbWithSeg(unsigned char *src, unsigned char *dst,const int width,const int height,scalar lower,scalar upper);

加载变量

assert(lower.channels()==3 && upper.channels()==3);
int blockSize = 48; //16*3
int block = (height * width * 3) / blockSize;

// 加载阈值
__m128i ch0_min_sse = _mm_setr_epi8(lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0]);
__m128i ch1_min_sse = _mm_setr_epi8(lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1]);
__m128i ch2_min_sse = _mm_setr_epi8(lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2]);

__m128i ch0_max_sse = _mm_setr_epi8(upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0]);
__m128i ch1_max_sse = _mm_setr_epi8(upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1]);
__m128i ch2_max_sse = _mm_setr_epi8(upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2]);

const int Shift = 15;
const int HalfV = 1<<(Shift-1);

//这里不能用网上给的转换公式，因为bgr转ycrcb有很多版本，我是直接看opencv源码算出的系数,
// static const float coeffs_crb[] = { R2YF, G2YF, B2YF, YCRF, YCBF }; in /opencv-4.0.1/modules/imgproc/src/color_yuv.cpp
//为什么要和opencv一样的系数?从结果来看，这套系数得到的cr cb通道对比度更大，也就是说红色和蓝色与其他背景区分度更高.
const int Y_B_WT = 0.114f * (1 << Shift), Y_G_WT = 0.587f * (1 << Shift), Y_R_WT = 0.299f * (1 << Shift), Y_C_WT = 1;
const int Cr_B_WT = 0.499f * (1 << Shift), Cr_G_WT = -0.419f * (1 << Shift), Cr_R_WT = -0.081f * (1 << Shift), Cr_C_WT = 257;
const int Cb_B_WT = 0.395f * (1 << Shift), Cb_G_WT = -0.331f * (1 << Shift), Cb_R_WT = -0.064f * (1 << Shift), Cb_C_WT = 257;

// load 上面的权值
__m128i Weight_YBG = _mm_setr_epi16(Y_B_WT, Y_G_WT, Y_B_WT, Y_G_WT, Y_B_WT, Y_G_WT, Y_B_WT, Y_G_WT);
__m128i Weight_YRC = _mm_setr_epi16(Y_R_WT, Y_C_WT, Y_R_WT, Y_C_WT, Y_R_WT, Y_C_WT, Y_R_WT, Y_C_WT);
__m128i Weight_UBG = _mm_setr_epi16(Cr_B_WT, Cr_G_WT, Cr_B_WT, Cr_G_WT, Cr_B_WT, Cr_G_WT, Cr_B_WT, Cr_G_WT);
__m128i Weight_URC = _mm_setr_epi16(Cr_R_WT, Cr_C_WT, Cr_R_WT, Cr_C_WT, Cr_R_WT, Cr_C_WT, Cr_R_WT, Cr_C_WT);
__m128i Weight_VBG = _mm_setr_epi16(Cb_B_WT, Cb_G_WT, Cb_B_WT, Cb_G_WT, Cb_B_WT, Cb_G_WT, Cb_B_WT, Cb_G_WT);
__m128i Weight_VRC = _mm_setr_epi16(Cb_R_WT, Cb_C_WT, Cb_R_WT, Cb_C_WT, Cb_R_WT, Cb_C_WT, Cb_R_WT, Cb_C_WT);
__m128i Half = _mm_setr_epi16(0, HalfV, 0, HalfV, 0, HalfV, 0, HalfV);

刚开始我们进行了阈值的通道检查(因为这个函数输入的数据必须是RGB图像).
紧接着,再将高低两个阈值加载进SSE变量中.
下面是重点,RGB转ycrcb的公式里面是每个系数都是0-1之间的浮点型,而我们前面取到的像素是以8位无符号整形保存在SSE变量中,所以我们需要将系数左移15位,既保证了精度,又满足了计算要求(没有超过16位,正好两个8位).

计算主体

for (int i = 0; i < block; ++i, src += blockSize, dst += 16)
{
	__m128i src1, src2, src3;

    src1 = _mm_loadu_si128((__m128i *) (src + 0)); //一次性读取个字节
    src2 = _mm_loadu_si128((__m128i *) (src + 16));
    src3 = _mm_loadu_si128((__m128i *) (src + 32));

// 在_mm_shuffle_epi8中构造出16位的数据
	__m128i BGLL = _mm_shuffle_epi8(src1,_mm_setr_epi8(0,-1,1,-1,3,-1,4,-1,6,-1,7,-1,9,-1,10,-1));
	__m128i BGLH = _mm_shuffle_epi8(src1,_mm_setr_epi8(12,-1,13,-1,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
	BGLH = _mm_or_si128(BGLH,_mm_shuffle_epi8(src2,_mm_setr_epi8(-1,-1,-1,-1,-1,-1,0,-1,2,-1,3,-1,5,-1,6,-1)));

	__m128i BGHL = _mm_shuffle_epi8(src2, _mm_setr_epi8(8, -1, 9, -1, 11, -1, 12, -1, 14, -1, 15, -1, -1, -1, -1, -1));
	BGHL = _mm_or_si128(BGHL,_mm_shuffle_epi8(src3,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 2, -1)));
	__m128i BGHH = _mm_shuffle_epi8(src3, _mm_setr_epi8(4, -1, 5, -1, 7, -1, 8, -1, 10, -1, 11, -1, 13, -1, 14, -1));

	__m128i RCLL = _mm_shuffle_epi8(src1,_mm_setr_epi8(2,-1,-1,-1,5,-1,-1,-1,8,-1,-1,-1,11,-1,-1,-1));
	RCLL = _mm_or_si128(RCLL,Half);
	__m128i RCLH = _mm_shuffle_epi8(src1,_mm_setr_epi8(14,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
	RCLH = _mm_or_si128(_mm_or_si128(RCLH,_mm_shuffle_epi8(src2,_mm_setr_epi8(-1,-1,-1,-1,1,-1,-1,-1,4,-1,-1,-1,7,-1,-1,-1))),Half);

	__m128i RCHL = _mm_shuffle_epi8(src2,_mm_setr_epi8(10,-1,-1,-1,13,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1));
	RCHL = _mm_or_si128(_mm_or_si128(RCHL,_mm_shuffle_epi8(src3,_mm_setr_epi8(-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1,3,-1,-1,-1))),Half);
	__m128i RCHH = _mm_shuffle_epi8(src3,_mm_setr_epi8(6,-1,-1,-1,9,-1,-1,-1,12,-1,-1,-1,15,-1,-1,-1));
	RCHH = _mm_or_si128(RCHH,Half);

// 下面是进行计算
	__m128i Result;

	__m128i Y_LL = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGLL, Weight_YBG), _mm_madd_epi16(RCLL, Weight_YRC)), Shift);
	__m128i Y_LH = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGLH, Weight_YBG), _mm_madd_epi16(RCLH, Weight_YRC)), Shift);
	__m128i Y_HL = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGHL, Weight_YBG), _mm_madd_epi16(RCHL, Weight_YRC)), Shift);
	__m128i Y_HH = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGHH, Weight_YBG), _mm_madd_epi16(RCHH, Weight_YRC)), Shift);

	__m128i Ch0 = _mm_packus_epi16(_mm_packus_epi32(Y_LL, Y_LH), _mm_packus_epi32(Y_HL, Y_HH));
	Result = _mm_cmpge_up_epu8(Ch0, ch0_min_sse);
	Result = _mm_and_si128(Result, _mm_cmpge_down_epu8(Ch0, ch0_max_sse));

	__m128i U_LL = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGLL, Weight_UBG), _mm_madd_epi16(RCLL, Weight_URC)), Shift);
	__m128i U_LH = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGLH, Weight_UBG), _mm_madd_epi16(RCLH, Weight_URC)), Shift);
	__m128i U_HL = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGHL, Weight_UBG), _mm_madd_epi16(RCHL, Weight_URC)), Shift);
	__m128i U_HH = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGHH, Weight_UBG), _mm_madd_epi16(RCHH, Weight_URC)), Shift);

	__m128i Ch1 = _mm_packus_epi16(_mm_packus_epi32(U_LL, U_LH), _mm_packus_epi32(U_HL, U_HH));
	Result = _mm_and_si128(Result, _mm_cmpge_up_epu8(Ch1, ch1_min_sse));
	Result = _mm_and_si128(Result, _mm_cmpge_down_epu8(Ch1, ch1_max_sse));

	__m128i V_LL = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGLL, Weight_VBG), _mm_madd_epi16(RCLL, Weight_VRC)), Shift);
	__m128i V_LH = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGLH, Weight_VBG), _mm_madd_epi16(RCLH, Weight_VRC)), Shift);
	__m128i V_HL = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGHL, Weight_VBG), _mm_madd_epi16(RCHL, Weight_VRC)), Shift);
	__m128i V_HH = _mm_srai_epi32(_mm_add_epi32(_mm_madd_epi16(BGHH, Weight_VBG), _mm_madd_epi16(RCHH, Weight_VRC)), Shift);

	__m128i Ch2 = _mm_packus_epi16(_mm_packus_epi32(V_LL, V_LH), _mm_packus_epi32(V_HL, V_HH));
	Result = _mm_and_si128(Result, _mm_cmpge_up_epu8(Ch2, ch2_min_sse));
	Result = _mm_and_si128(Result, _mm_cmpge_down_epu8(Ch2, ch2_max_sse));

	_mm_storeu_si128((__m128i *)dst, Result);
}

//剩余不足一个block的单独处理
for (int j = blockSize * block; j < height * width; ++j, src += 3, dst++) {
	uint8_t _ch0 = src[0], _ch1 = src[1], _ch2 = src[2];

	uint8_t YUV_Y = (Y_B_WT * _ch0 + Y_G_WT * _ch1 + Y_R_WT * _ch2 + Y_C_WT * HalfV) >> Shift;
	uint8_t YUV_U = (Cr_B_WT * _ch0 + Cr_G_WT * _ch1 + Cr_R_WT * _ch2 + Cr_C_WT * HalfV) >> Shift;
	uint8_t YUV_V = (Cb_B_WT * _ch0 + Cb_G_WT * _ch1 + Cb_R_WT * _ch2 + Cb_C_WT * HalfV) >> Shift;
	if ((YUV_Y >= lower[0] && YUV_Y <= upper[0] && YUV_U >= lower[1] && YUV_U <= upper[1] && YUV_V >= lower[2] &&
YUV_V <= upper[2])) {
	dst[0] = 255;
	} else {
		dst[0] = 0;
	}
}

这里我们同样先从输入图像中加载待处理的数据.
接着我们将B G R B G R B G R这样的数据拆分成B 0 G 0 B 0 G 0 和R 0 half 0 R 0 half 0这样的形式,为了后面使用_mm_madd_epi16将像素与各自的权重相乘再相加.

Y_C_WT, Cr_C_WT, Cb_C_WT这三个变量是干什么? 我们来看一下rgb转ycrcb的公式:[参考Imageshop])(https://www.cnblogs.com/Imageshop/p/8405517.html)

Y = (Y_B_WT * Blue + Y_G_WT * Green + Y_R_WT * Red + HalfV) >> Shift;
Cr = ((Cr_B_WT * Blue + Cr_G_WT * Green + Cr_R_WT * Red + HalfV) >> Shift) + 128;
Cb = ((Cb_B_WT * Blue + Cb_G_WT * Green + Cb_R_WT * Red + HalfV) >> Shift) + 128;

经过变形成为:

Y = (Y_B_WT * Blue + Y_G_WT * Green + Y_R_WT * Red + 1 * HalfV) >> Shift;
Cr = (U_B_WT * Blue + U_G_WT * Green + U_R_WT * Red + 257 * HalfV) >> Shift;
Cb = (V_B_WT * Blue + V_G_WT * Green + V_R_WT * Red + 257 * HalfV) >> Shift;
这就是Y_C_WT=1,Cr_C_WT=257,Cb_C_WT=257的由来

虽然上面代码量看着较多,但是都是基本运算,而且比OpenCV的函数快了7-8倍.

性能对比

处理1000次取平均值

Image Size: 1024 x 1280（H x W）

opencv函数耗时: 6.68 - 6.75 ms

DeltaCV函数耗时: 0.88 - 0.90 ms

加速比: 7.4 - 7.6

DeltaCV之CPU算法优化[inRange]

Tue, 02 Apr 2019 00:00:00 +0000

OpenCV中的inRange()
- 函数原型
DeltaCV中的优化

这篇文章我们先来认识一下DeltaCV中CPU上做的相关优化工作，使用SSE及AVX指令集对图像处理中的阈值分割操纵进行重构，来提升计算效率。

源文件: https://github.com/DasudaRunner/DeltaCV/blob/master/cpu/src/SIMD/inRange.cpp

OpenCV中的inRange()

OpenCV中的inRange()函数常常用来对图像的各个通道进行阈值分割，但是当图像尺寸过大时，该步骤较为耗时，故我们使用SIMD指令集的并行处理能力来提升像素的处理效率。

函数原型

void inRange(InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst)

他的工作原理就是在src上对每个通道做一次判断，在lowerb和upperb之间的为1，最后输出到dst上，所以dst是一副二值图。

DeltaCV中的优化

针对OpenCV中的inRange()，我们主要做如下改进：当图像是单通道时,使用AVX中的256位数据格式,当图像为三通道时,使用SSE的128位数据格式(由于_mm_shuffle_epi8函数缘故).

函数原型

    /*
     * src: input
     * dst: output
     * width:
     * height:
     * lower: lower boundary
     * upper: upper boundary
     */
    int inRange(unsigned char *src, unsigned char *dst, int width, int height,deltaCV::scalar lower, deltaCV::scalar upper)

其中deltaCV::scalar与cv::Scalar类似,定义见DeltaCV.

assert(lower.channels()==upper.channels());
int channel = lower.channels();
if(channel==3)
{
	...
}else
{
    ...
}

我们这里需要根据输入图像的通道数分别进行处理.当通道数为3时,此时的优化也最明显(毕竟数据规模越大,并行的优势也就越大).

思路

由于SSE中的128位数据结构特点,我们可以每次处理16组像素点,为什么呢?因为在数据存储时,三通道像素点是依次排列的,像B G R B G R这样,而SIMD指令只能对128位数据做同样的处理,所以我们有必要使用三个__m128i分别储存三个通道的值,而且128/8=16,所以我们每次处理16组像素.

载入变量

int blockSize = 16; //16*3
int block = height * width  / blockSize;

__m128i ch0_min_sse = _mm_setr_epi8(lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0]);
__m128i ch1_min_sse = _mm_setr_epi8(lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1],lower[1]);
__m128i ch2_min_sse = _mm_setr_epi8(lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2],lower[2]);
__m128i ch0_max_sse = _mm_setr_epi8(upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0]);
__m128i ch1_max_sse = _mm_setr_epi8(upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1],upper[1]);
__m128i ch2_max_sse = _mm_setr_epi8(upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2],upper[2]);

循环处理

for(int i=0; i<block; ++i,src+=blockSize*channel,dst+=blockSize)
{
	// 读取数据
	__m128i src1 = _mm_loadu_si128((__m128i *) (src + 0));
	__m128i src2 = _mm_loadu_si128((__m128i *) (src + blockSize*1));
	__m128i src3 = _mm_loadu_si128((__m128i *) (src + blockSize*2));

	//三通道分离
    __m128i Ch0 = _mm_shuffle_epi8(src1, _mm_setr_epi8(0, 3, 6, 9, 12, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1));
    Ch0 = _mm_or_si128(Ch0, _mm_shuffle_epi8(src2,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, 2, 5, 8, 11, 14, -1, -1,-1, -1, -1)));
    Ch0 = _mm_or_si128(Ch0, _mm_shuffle_epi8(src3,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 4,7, 10, 13)));
    __m128i Ch1 = _mm_shuffle_epi8(src1,_mm_setr_epi8(1, 4, 7, 10, 13, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1));
    Ch1 = _mm_or_si128(Ch1, _mm_shuffle_epi8(src2,_mm_setr_epi8(-1, -1, -1, -1, -1, 0, 3, 6, 9, 12, 15, -1, -1,-1, -1, -1)));
    Ch1 = _mm_or_si128(Ch1, _mm_shuffle_epi8(src3,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 5,8, 11, 14)));

    __m128i Ch2 = _mm_shuffle_epi8(src1,_mm_setr_epi8(2, 5, 8, 11, 14, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1));
    Ch2 = _mm_or_si128(Ch2, _mm_shuffle_epi8(src2,_mm_setr_epi8(-1, -1, -1, -1, -1, 1, 4, 7, 10, 13, -1, -1, -1,-1, -1, -1)));
    Ch2 = _mm_or_si128(Ch2, _mm_shuffle_epi8(src3,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 3, 6,9, 12, 15)));
    // 阈值判断
    __m128i Result;
    //ch0
    Result = _mm_cmpge_up_epu8(Ch0, ch0_min_sse);
    Result = _mm_and_si128(Result, _mm_cmpge_down_epu8(Ch0, ch0_max_sse));
    //ch1
    Result = _mm_and_si128(Result, _mm_cmpge_up_epu8(Ch1, ch1_min_sse));
    Result = _mm_and_si128(Result, _mm_cmpge_down_epu8(Ch1, ch1_max_sse));
    //ch2
    Result = _mm_and_si128(Result, _mm_cmpge_up_epu8(Ch2, ch2_min_sse));
    Result = _mm_and_si128(Result, _mm_cmpge_down_epu8(Ch2, ch2_max_sse));
	//输出
    _mm_storeu_si128((__m128i *) (dst + 0), Result);
}

从最开始的读取数据可以看出,我们每次加载了48个字节的数据,也就是16组像素点,然后又使用_mm_shuffle_epi8将依次排列的48个像素点重组在3个__m128i变量Ch0,Ch1,Ch2中.

函数原型:__m128i _mm_shuffle_epi8 (__m128i a, __m128i b)
FOR j := 0 to 15
	i := j*8
	IF b[i+7] == 1
		dst[i+7:i] := 0
	ELSE
		index[3:0] := b[i+3:i]
		dst[i+7:i] := a[index*8+7:index*8]
	FI
ENDFOR

其实说白了就是将a中的每一个字节进行重排(但是需要注意的是,真正其索引作用的是每个字节的低4位,也就是索引值范围为0-15,这也是为什么__mm_shuffle_epi8不能配合__m256i类型数据使用,因为__m256i为32个字节,后面的16个字节无法选中,谨记!!!).

比如__m128i Ch0 = _mm_shuffle_epi8(src1, _mm_setr_epi8(0, 3, 6, 9, 12, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1))就是将src1的第1个元素放在第一位,第4个元素放在第二位,第7个元素放在第三位,以此类推.组成一个新的变量,-1表示该字节置0,用数组来表示的话,Ch0中的元素为{src1[0],src1[3],src1[6],src1[12],src1[15],0,0,0,0,0,0,0,0,0,0},这里你会发现,我们这样取正好是将src1中像素的第一个通道值取出来了.Ch0 = _mm_or_si128(Ch0, _mm_shuffle_epi8(src2,_mm_setr_epi8(-1, -1, -1, -1, -1, -1, 2, 5, 8, 11, 14, -1, -1,-1, -1, -1)));又把src2中的像素的第一通道值取出来,然后与前面求得的在进行与操作,所以现在Ch0中储存的就是src1和src2中的像素的第一个通道值,最后我们在把src3中的也取出来进行与操作,此时Ch0中就包含了本次循环所有处理像素的第一通道的值.接下来的Ch1,Ch2也是分别储存了第二,三通道的像素值.

再下面跟的是阈值判断部分,这里主要使用了_mm_cmpge_up_epu8(a,b)和_mm_cmpge_down_epu8(a,b)两个函数,前者是将a中大于等于b的字节置为1,其它置为0,后者是小于等于的置为1,其它置0.这两个函数不在官方库中,官方只提供了有符号的比较函数,所以我们根据网上提供的代码:

#define _mm_cmpge_up_epu8(a, b) _mm_cmpeq_epi8(_mm_max_epu8(a, b), a) //大于等于的留下
#define _mm_cmpge_down_epu8(a, b) _mm_cmpeq_epi8(_mm_min_epu8(a, b), a) //小于等于的留下

通过讲_mm_cmpeq_epi8与_mm_max_epu8巧妙地结合起来,实现无符号比较函数.

 _mm_storeu_si128((__m128i *) (dst + 0), Result);

最后的这句话是将SSE变量中的值载出到外部变量中.

收尾

//剩余不足一个block的单独处理
for (int j = blockSize * block * channel; j < height * width; ++j, src += channel, dst++) 
{
	uint8_t _ch0 = src[0], _ch1 = src[1], _ch2 = src[2];
	if (_ch0 >= lower[0] && _ch0 <= upper[0] && _ch1 >= lower[1] && _ch1 <= upper[1] && _ch2 >= lower[2] &&_ch2 <= upper[2]) 
	{
		dst[0] = 255;
	} else {
		dst[0] = 0;
	}
}

因为数据的总数不一定总是blockSize的整数倍,所以最后再加一个循环将不足一个block的像素单独处理.

单通道图像

当输入的图像为单通道时:

int blockSize = 32;
int block = height * width  / blockSize;

// 这里需要将阈值载入到256位的变量中
__m256i ch0_min_sse = _mm256_setr_epi8(lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lower[0],lbubishiyongower[0],lower[0],lower[0],lower[0],lower[0],lower[0]);

__m256i ch0_max_sse = _mm256_setr_epi8(upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0],upper[0]);

for(int i=0; i<block; ++i,src+=blockSize,dst+=blockSize)
{
	// 一次加载32个像素
	__m256i src1 = _mm256_loadu_si256((__m256i *) (src + 0));
	__m256i Result;
	Result = _mm256_cmpge_up_epu8(src1, ch0_min_sse);
	Result = _mm256_and_si256(Result, _mm256_cmpge_down_epu8(src1,ch0_max_sse));
	_mm256_storeu_si256((__m256i *) (dst + 0), Result);
}

for (int j = blockSize * block * channel; j < height * width; ++j, src += channel, dst++) 
{
	uint8_t _ch0 = src[0], _ch1 = src[1], _ch2 = src[2];
	if (_ch0 >= lower[0] && _ch0 <= upper[0] && _ch1 >= lower[1] && _ch1 <= upper[1] && _ch2 >= lower[2] && _ch2 <= upper[2]) 
	{
		dst[0] = 255;dao
	} else {
		dst[0] = 0;
	}
}

性能对比

处理1000次取平均值

Image Size: 1024 x 1280（H x W） | Function | OpenCV/ms | DeltaCV/ms | Speed-up | |:-:|:-:|:-:|:-:| |inRange|1.06 - 1.18|0.29 - 0.30|3.5 - 4.0|

DeltaCV之共享内存篇

Tue, 02 Apr 2019 00:00:00 +0000

概述
DeltaCV中的共享内存类模板
- 发布器
- 订阅器
- 小技巧
- 演示

这篇文章我们来认识一下线程间通信的一种手段—共享内存，共享内存由于其特殊性—共享内存是存在与每个进程的地址空间中的，通俗点就是这部分数据是对每个进程可见的，这样每个进程都可以在一定条件下直接操作共享内存中的数据，避免了数据的复制等耗时的操作，这也是共享内存比其他几种IPC机制（信号量、管道、消息队列等）的通信方式效率高的原因，但是共享内存也有缺点，那就是需要独立实现消息的同步机制。本文将完成一个基础的共享内存类模板，包含在DeltaCV项目中，欢迎star，fork。

概述

在boost/Interprocess中，提供了很多关于操作系统底层的进程间通信的抽象层，它使用C++将操作系统的底层接口进行封装，并消除了不同操作系统之间各种各样的接口带来的开发困难等问题。

共享内存

先介绍一种最普通的共享内存创建方式，boost::interprocess::shared_memory_object类。

#include <boost/interprocess/shared_memory_object.hpp> 
// boost::interprocess::open_or_create： 第一个参数说明了当前的操作是什么，直接可以根据字面意思猜测到，open_or_create指如果尝试打开名字为DeltaCV的共享内存失败时，就创建它，当然也有create_only，open_only操作。
// "DeltaCV"： 表明当前我们操作的共享内存的名字为DeltaCV。
// boost::interprocess::read_write： 所有进程对此共享内存的操作权限（暂且可以这样认为，感觉不太严谨），read_write即可读写，同时还有read_only供选择。
boost::interprocess::shared_memory_object shm(boost::interprocess::open_or_create, "DeltaCV", boost::interprocess::read_write); 

共享内存创建后大小为0，我们使用truncate()方法来为共享内存设定大小，单位为字节。

// 为刚才创建的共享内存开辟1024个字节大小的空间。
shm.truncate(1024);

然而刚才我们创建的共享内存虽然对所有进程可见，但是现在还不能直接操作，因为每个进程都有自己独立的地址空间，我们还需要将上面的共享内存映射进当前进程的地址空间中，可以使用mapped_region()方法完成。

#include <boost/interprocess/mapped_region.hpp> 
//shm: 传入上文实例化的共享内存对象
//boost::interprocess::read_write： 当前进程对此共享内存的操作权限
/* 
	函数的原型如下
			mapped_region region(
				shm,         //Memory-mappable object  
   				mode,        //Access mode  
				start,       //Offset from the beginning of shm 
				end          //Length of the region  
   			);  
   	当你省略后面两个参数时，将默认映射整个共享内存对象
*/
boost::interprocess::mapped_region region(shm, boost::interprocess::read_write);
// 共享内存的其实地址
std::cout<<region.get_address()<<std::endl;
// 共享内存块的大小
std::cout<<region.get_size()<<std::endl;

接下来就是开始向共享内存中存数据了,跟我们普通的指针操作一样.

// 先将地址的指针强制转换成int指针,因为我们要储存的是int变量
int *n = static_cast<int*>(region.get_address()); 
// 和普通的指针操作一样,这里讲1存放进共享内存中
*n = 1;

// 如果在其它程序中我们已经存放过数据了,而想要取数据,则*n就是我们要取的数据了

那如何删除我们创建的共享内存呢?多数linux系统中,如果不主动删除共享内存,它会一直存在到系统重启.

//返回值指示了是否删除成功
bool removed = boost::interprocess::shared_memory_object::remove("DeltaCV"); 

托管共享内存

然而上述的方式几乎不会用到,因为它每次需要按单个字符的形式读写内存,所以绝大多数情况下我们会使用托管共享内存方式,它会以内存申请的方式对共享内存对象进行初始化.

#include <boost/interprocess/managed_shared_memory.hpp> 
// boost::interprocess::open_or_create: 含义同上
// "Highscore": 共享内存的名称
// 1024: 共享内存的大小
boost::interprocess::managed_shared_memory managed_shm(boost::interprocess::open_or_create, "DeltaCV", 1024);
// 创建了一个包含10个元素的int型数组,起名为"Integer",且值初始化为1,此时n为数组首元素的地址
int *n = managed_shm.construct<int>("Integer")[10](1); //当"Integer"之前不存在

std::pair<int*,size_t > n = managed_shm.find<int>("Integer")[10](1); //当"Integer"已经存在时,我们使用find来找到这个数据,可见此时返回的是pair类型数据,first保存的是数据首元素地址,second保存的是整个数据的长度.

删除托管共享内存

boost::interprocess::shared_memory_object::remove("DeltaCV");

互斥对象

既然共享内存对所有进程都可见,那么怎么保证共享内存的读写不会相互干扰呢?那就是使用互斥对象,当共享内存被使用时,互斥对象被占用,其他进程想要操作同一共享内存时,就需要等待互斥对象释放,这样就保证了共享内存的正确读写,类似于多线程中的锁.

互斥对象的声明

#include <boost/interprocess/sync/interprocess_mutex.hpp> 
// 声明了一个名为"mtx"互斥对象,使用的是find_or_construct,含义同上
boost::interprocess::interprocess_mutex *mtx = managed_shm.find_or_construct<boost::interprocess::interprocess_mutex>("mtx")(); 
// 上锁,也就是占用互斥对象,一般每个共享变量对应一个互斥对象
mtx->lock(); 
/* 
	TODO SOMETHING
*/
//解锁
mtx->unlock(); 

DeltaCV中的共享内存类模板

至此,关于boost下的共享内存编程就简单的介绍一下,应该能满足日常的使用了,下面我将介绍我在DeltaCV中封装的共享内存类模板,整体框架类似与ROS中的topic形式,提供发布者和订阅者.完整代码见DeltaCV.

发布器

template <typename T1>
class shm_publisher{
public:
    shm_publisher(const char* node_name, const int RECEIVE_DATA_LENGTH)
                    :shm_name(string(node_name)), //创建的
                     per_data_bytes(sizeof(T1)),
                     data_length(RECEIVE_DATA_LENGTH+1)
    {
        lock_name = string(node_name)+"_lock"; //定义互斥变量的名称
        data_name = string(node_name)+"_data"; //定义数据的名称
		update_name = string(node_name)+"_update"; //更新标志位
		
		boost::interprocess::shared_memory_object::remove(shm_name.c_str()); 	//首先检查内存是否被释放
        boost::interprocess::named_mutex::remove(lock_name.c_str()); //检查互斥变量是否被释放
        //托管共享内存
        managed_shm = new boost::interprocess::managed_shared_memory(
                        boost::interprocess::create_only,
                        shm_name.c_str(),
                        per_data_bytes*data_length + 4 + 1024);
        // 互斥变量
        named_mtx = new boost::interprocess::named_mutex(
                        boost::interprocess::create_only,
                        lock_name.c_str());
        // 变量
        user_data = managed_shm->construct<T1>(data_name.c_str())[data_length](0);
        update_flag = managed_shm->construct<int>(update_name.c_str())[1](0);
    }
    ~shm_publisher() 
    {
        boost::interprocess::shared_memory_object::remove(shm_name.c_str());
        boost::interprocess::named_mutex::remove(lock_name.c_str());
        managed_shm->destroy<T1>(data_name.c_str());
        managed_shm->destroy<int>(update_name.c_str());
    }
    
    // 发布函数如下:
    void broadcast(T1* data)
    {
        named_mtx->lock();
        memcpy(user_data, data, per_data_bytes*data_length);
        *update_flag = 1;
        named_mtx->unlock();
    }
    
private:
    T1* user_data;
    int* update_flag;
    std::string shm_name;
    std::string lock_name;
    std::string data_name;
    std::string update_name;
    
    boost::interprocess::managed_shared_memory* managed_shm;
    boost::interprocess::named_mutex* named_mtx;
    
    int per_data_bytes,data_length;
};

订阅器

template <typename T2>
class shm_subscriber{
public:
	shm_subscriber(const char* node_name)
                    :shm_name(string(node_name)),
                    per_data_bytes(sizeof(T2))
{
	lock_name = string(node_name) + "_lock"; //这里的命名规则与发布器对应
	data_name = string(node_name) + "_data";
	update_name = string(node_name)+"_update";

	//托管共享内存
	managed_shm = new boost::interprocess::managed_shared_memory(
                        boost::interprocess::open_only,
                        shm_name.c_str());
	//获得互斥对象
	named_mtx = new boost::interprocess::named_mutex(
                        boost::interprocess::open_only,
                        lock_name.c_str());
	//找到两个变量bianlaing
	user_data = managed_shm->find<T2>(data_name.c_str());
	update_flag = managed_shm->find<int>(update_name.c_str());
}

// 返回值表示当前取得值是否更新
bool get(T2* data)
{
	named_mtx->lock();
	if(update_flag.first[0]==1) //检查标志位是否置1
	{
		update_flag.first[0]=0;
		memcpy(data, user_data.first,user_data.second*per_data_bytes);
		named_mtx->unlock();
		return true;
	} else {
		named_mtx->unlock();
		return false;
	}
}

private:
    std::pair<T2*,size_t > user_data;
    std::pair<int*,size_t > update_flag;

    std::string shm_name;
    std::string lock_name;
    std::string data_name;
    std::string update_name;
    uint8_t per_data_bytes;

    boost::interprocess::managed_shared_memory* managed_shm;
    boost::interprocess::named_mutex* named_mtx;
};

小技巧

代码中,我额外添加了一个标志位update_flag,用来指示当前取到的数据是否是最新值,因为只要发布器那边存入一次数据,update_flag这个变量就置为1,而订阅器每取一次数据,就讲update_flag置0,所以当订阅器的获取频率超过发布器时,订阅器取到的数据一部分是未更新的数据,则订阅器能通过get()的返回值来选择是否使用本次获取的数据(若返回值为true,则为最新值,若为false,则说明自上次订阅器取过值后到这次取值之间,发布器没有存入过新的数据).

演示

分别新建两个main函数,代表两个进程,其中一个作为发布器,每5s发布一次数据,另外一个作为订阅器,每1s获取一次数据.

// main1.cpp
#include <iostream>
#include "shm.hpp"
int a[2] = {4,5};
int main() {
    deltaCV::shm_publisher<int> pub("test",2);
    while(1)
    {
        p.broadcast(a);
        sleep(5);
    }
    return 0;
}

// main2.cpp
#include <iostream>
#include "shm.hpp"
int a[2];
int main() {
    deltaCV::shm_subscriber<int> sub("test");
    while(1)
    {
        bool res = sub.get(a);
        cout<<"update: "<<res<<" ,a[0]: "<<a[0]<<" ,a[1]: "<<a[1]<<endl;
        sleep(1);
    }
    return 0;
}

最终输出为:(可以看到5s内,订阅器有4次获取的是未更新的值)

update: 1 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 1 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 1 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5
update: 0 ,a[0]: 4 ,a[1]: 5

参考：http://zh.highscore.de/cpp/boost/interprocesscommunication.html

gcc编译选项[C++]

Sat, 30 Mar 2019 00:00:00 +0000

上一篇博客还是在去年12月份，之后参加了ICRA2019大疆主办的人工智能挑战赛，比赛要做技术方案，又要办理加拿大签证，中间大概忙了三个月的时间，最近刚把最后一次技术报告提交，等待最终的参赛通知，所以把最近一段时间的新的总结一下，ICRA比赛相关的东西我会在赛后总结一下，发布在”ICRA2019”分类下。

GCC下C++的编译选项

为什么会总结一下这个呢？是因为最近在做boost及SSE、AVX指令集优化时，遇到过没有加编译选项的问题，报了一些错误，所以今天先把这个总结一下。

参考文档

-Wreorder 当代码中给出的成员初始化的顺序与它们必须执行的顺序不匹配时发出警告
```
struct A { 
int i; 
int j; 
A()：j(0),i(0){} //会发出警告
};
```
-fconstexpr-depth=n 将C ++ 11 constexpr函数的最大嵌套深度设置为n,标准规定的最小值为512。
-Wunknown-pragmas 当出现无法识别的#pragma 预定义符号时，警告。我印象中只在使openMP时候用过这个预编译指令
-Wunused 启用所有的“未使用”警告，比如某某变量只定义了没有使用，某某函数只定义了没有使用。
-fimplicit-templates 允许模板隐式实例化
-fmudflapth 开启多线程检查mudflap边界
-fopenmp 开启openMP
-fshort-double 将double的字节数规定为和float一样
-fdelete-null-pointer-checks 删除无用的空指针检查
-funsafe-math-optimizations and -funsafe-loop-optimizations 开启有风险的计算和循环优化
-fexpensive-optimizations 一些代价比较大的优化，具体不详
-foptimize-sibling-calls 对sibling call，tail recursive call进行优化。
-fno-defer-pop 函数返回的时候，就立即将栈里面放置的该函数的参数pop出来。这样可以避免函数参数占用过多的栈空间。
-mmmx 支持MMX内建函数
msse 支持 MMX 和 SSE 内建函数及代码生成
-msse2 支持 MMX、SSE 和 SSE2内建函数及代码生成
msse3 支持 MMX、SSE、SSE2 和 SSE3内建函数及代码生成
-msse4 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1和 SSE4.2 内建函数及代码生成
mavx and -mavx2 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2和 AVX 内建函数及代码生成，可以看出内建函数的支持是向前兼容的，兼容顺序为指令集的诞生时间。
-msse-check=[none|error|warning] 检查SSE内联函数语法

之前还遇到过网上流传的40行暴力编译优化，比较玄学，新手慎用，一般最简单的方法是开启-O3优化即可，还是把精力放在算法优化、指令集优化及多线程计算上实用点。

Kaggle比赛kernel学习[小样本学习]

Fri, 07 Dec 2018 00:00:00 +0000

第一次参加kaggle比赛，发现kaggle参赛者们贡献的kernel真是神奇，方法多种多样，感觉自己的思路也别打通了，果然众人拾柴火焰高，一个难题竟然被各种各样的方式解决。但是也是深刻认识到，有些kaggle比赛，比的是硬件，而算法都差不多。

Humpback Whale Identification

座头鲸识别，属于小样本分类方向，有专门的one-shot learning和few-shot learning领域的研究，这类问题特点是样本类别多，每类样本数量极少，在本比赛中，一共5004+1类座头鲸（训练集中有大量的图片为自然界未分类的座头鲸，这一类统称为’new_whale’），其中数量最多的一类为’new_whale’，其余有已知标签的类别数量最多在100张一下，大部分类别下只有一张图片，可见样本少，同时分布非常不平衡。

Whale Recognition Model with score 0.78563

这是playground的座头鲸识别比赛的第一名，使用的方法是改进版孪生网络。之前也只了解过孪生网络，它是用来学习特征空间转换方法，将图像的像素信息投影到可度量的欧式空间或者其它成熟的可度量特征空间。类似还有三重损失网络triplet network等。

训练集处理
- 去除训练集中重复的图片，方法是计算图片的感知哈希（Perceptual Hash ）值，当哈希值一样或者相差小于6比特位，并且图像有相同的尺寸、类型，同时归一化后的图像均方差只差小于阈值，则认为是相同的图像，经计算，作者大于除去了450+张重复图片。
- 去除掉’new_whale’类别。
- 去除掉样本数只有1的类别。
- 去除掉黑名单中的图像，这应该是作者人工筛选的，主要是一些不包含座头鲸尾巴的、一幅图片两个尾巴、图片模糊看不清的等等
网络架构
- 特征提取部分，是仿照ResNet50设计的，将每层的输出通道减小，最终输出512维的向量，可以理解为网络将图像的特征映射进一个512维的特征空间。
- 决策部分，作者设计了四种度量方式，加和、成绩、差值的绝对值、差平方，并让网络来自行学习每种度量方式的权重，最终决策部分输出的是一个0-1的值，当输入的两幅图片属于同一类别时，输出越接近1，反之接近0。
数据预处理
- 灰度化
- 随机翻转
- 放射变换
训练batch选取
- 首先保证了每幅图片作为正例和反例的比例是相同的，防止了一些图片经常被当做反例，使网络不能很好的学习到特征，作者也分析了这样做是为了让网络学习到鲸的特征，而不是记住图片（有点意思）。
- 训练正例pairs的选择，首先按照顺序将所有类别作为pairs的其中一个，然后计算他们的derangment顺序作为pairs中的另一个，这样保证了每个类别都被用了两次（顺序一次，derangment计算的顺序一次）。
- 训练反例pairs的选择（前提，pairs中的两幅图片不是同一个类别），作者加入了主动学习的思想，每次训练中尽量给网络hard sample，作者的思路是，给出一个值为0-1的随机矩阵，称为得分矩阵，正例pairs（即相同类别互相间）的相似性置为10000（因为正例pairs不参与反例pairs的抽取过程，这里的10000只是象征性的大值），此后每个epoch评估一次（这里的评估是将训练集每一幅图片都与除自己外的所有图片进行计算得分-决策部分的输出值，所以输出的得分矩阵大小为数据集图像数量x数据集图像数量，可以看出来非常庞大），然后将输出的评估分数再叠加上一个0-1的随机矩阵，其中随机矩阵会乘一个系数，这个系数也是在训练过程中不断调节的，用来控制选取反例的随机程度，根据得分矩阵使用线性分配算法找出一个组合作为反例pairs，然后讲本次选取的反例pairs对应的得分矩阵中的得分置为10000，为什么这么做呢？是为了让网络每个epoch都接触到不同的反例，假想一下，如果训练集中有一批很难区分的样本，如果不进行这样的处理，那么每次使用线性分配算法得到的组合都包括它们（因为它们的得分很低），这样很多其他的反例样本就得不到训练。
- 总结一下，我认为作者貌似貌似并不是在做主动学习，而是让网络每次都学习分类效果相对好的样本，因为对于反例来说，得分越接近0，说明网络对它们的区分度越好（因为反例pairs的真实标签就是0），那么对于区分度不好的pairs，得分应该是接近1，那么在得分矩阵中我们应该着重考虑那些得分接近1的反例pairs，但是作者使用的线性分配算法算法是寻找‘损失最小的组合’，所以最后找出来的恰好是当前网络表现最好的一个组合，但是由于作者在得分矩阵上又叠加了一个随机矩阵来调控选取的hard samples的程度，总之作者的思路还是比较好的，至少对于我来说受益匪浅。
训练耗时部分
- 每过几个epoch，需要对训练集的所有图片计算得分，从而选取合适的hard sample进行训练。
- 线性分配算法随着矩阵的大小增加，时间复杂度指数增加，作者也只是近似得到了反例pairs组合。
- 在最后的提交部分，需要计算每个测试样本和所有训练样本的得分。
- 训练网络，作者大概用了两天训练模型（GTX1080 i7-8700）
- 总之，没有好的硬件平台，好多比赛根本没精力去做。

结合Keras代码透彻分析SSD网络

Tue, 27 Nov 2018 00:00:00 +0000

之前一直在做分类网路的工作，物体检测网络有了解，但是还没有从头训练过，这次通过几天时间的集中学习，终于理解了整个网络的大部分细节，这里作简要记录。

思维导图

简要总结

网络部分： 最终输出的是一个封装好的数据，封装的什么呢？三部分，1、每个default box的分类损失，2、每个default box的回归损失，3、生成的default box的坐标，长度为8，四个坐标加上四个varance值辅助训练。
数据部分：我么先读取训练数据，可以获得gt box的两个坐标以及所属类别，然后我们也知道，并不是多有的default box都参与训练，而是符合一定要求的才参与训练（IOU大于阈值，并且一个default box只对应一个gt box），经过筛选后，每个gt box会和一个或几个default box对应，此时我们称这些default box为prior box，这也是很多博客里面说的，default box是客观存在的，不管你输入是是什么，而prior box是实际采用的，因为随着图片的不同，gt box的位置不同，prior box也不同。最后再对原始的绝对坐标进行编码。
损失部分：损失是计算上述两者的输出，均是(-1,num_default_box,4+21+8)(在VOC2007下，base model为VGG16)，在损失这部分还有一个值得注意的地方就是hard mining，通过控制正负样本的比例来辅助训练。
代码

随后我会将代码(参考：Github)上传到我的github上，对比参考的代码，我只是在里面添加了中文注释，并根据最新版本的keras进行了API修改。

xml_processor.py

#coding:utf-8
from xml.etree import ElementTree
import numpy as np
import os
import pickle
class xml_processor(object):
    def __init__(self,data_path):
        self.path_prefix = data_path
        self.num_classes = 20 #20 + 1 bg
        self.data = dict()
        self._preprocess_XML()
	#这里读取xml的内容，并将坐标转化为[x_min,y_min,x_max,y_max]的格式
    def _preprocess_XML(self):
        filenames = os.listdir(self.path_prefix)
        for filename in filenames:
            tree = ElementTree.parse(os.path.join(self.path_prefix,filename))
            root = tree.getroot()
            bounding_boxes = []
            one_hot_classes = []
            size_tree = root.find('size')
            width = float(size_tree.find('width').text)
            height = float(size_tree.find('height').text)
            for object_tree in root.findall('object'):
                for bounding_box in object_tree.iter('bndbox'):
                    xmin = float(bounding_box.find('xmin').text) / width
                    ymin = float(bounding_box.find('ymin').text) / height
                    xmax = float(bounding_box.find('xmax').text) / width
                    ymax = float(bounding_box.find('ymax').text) / height
                bounding_box = [xmin, ymin, xmax, ymax]
                bounding_boxes.append(bounding_box)
                class_name = object_tree.find('name').text
                one_hot_class = self._to_one_hot(class_name)
                one_hot_classes.append(one_hot_class)
            image_name = root.find('filename').text
            bounding_boxes = np.asarray(bounding_boxes)
            one_hot_classes = np.asarray(one_hot_classes)
            image_data = np.hstack((bounding_boxes, one_hot_classes))
            self.data[image_name] = image_data

    def _to_one_hot(self, name):
        one_hot_vector = [0] * self.num_classes
        if name == 'aeroplane':
            one_hot_vector[0] = 1
        elif name == 'bicycle':
            one_hot_vector[1] = 1
        elif name == 'bird':
            one_hot_vector[2] = 1
        elif name == 'boat':
            one_hot_vector[3] = 1
        elif name == 'bottle':
            one_hot_vector[4] = 1
        elif name == 'bus':
            one_hot_vector[5] = 1
        elif name == 'car':
            one_hot_vector[6] = 1
        elif name == 'cat':
            one_hot_vector[7] = 1
        elif name == 'chair':
            one_hot_vector[8] = 1
        elif name == 'cow':
            one_hot_vector[9] = 1
        elif name == 'diningtable':
            one_hot_vector[10] = 1
        elif name == 'dog':
            one_hot_vector[11] = 1
        elif name == 'horse':
            one_hot_vector[12] = 1
        elif name == 'motorbike':
            one_hot_vector[13] = 1
        elif name == 'person':
            one_hot_vector[14] = 1
        elif name == 'pottedplant':
            one_hot_vector[15] = 1
        elif name == 'sheep':
            one_hot_vector[16] = 1
        elif name == 'sofa':
            one_hot_vector[17] = 1
        elif name == 'train':
            one_hot_vector[18] = 1
        elif name == 'tvmonitor':
            one_hot_vector[19] = 1
        else:
            print('unknown label: %s' % name)
        return one_hot_vector

if __name__ == '__main__':
    data = xml_processor('./VOC2007/Annotations').data
    print(data['000005.jpg'])
    pickle.dump(data,open('./pkl/VOC2007.pkl','wb'))

最后将读取到的数据（主要是文件名、类别和box坐标）设计成字典：{file_name: [num_box,4+20]}，其中4是四个坐标为物体的坐标，20为one_hot类型的类别标签。这是个通用的处理函数，一般voc格式的xml文件都可以使用。

ssd_train.py

def generate(self, train=True):
    while True:
        #根据模式选择数据集
        if train:
            shuffle(self.train_keys)
            keys = self.train_keys
        else:
            shuffle(self.val_keys)
            keys = self.val_keys

        inputs = []
        targets = []
        #开始遍历数据集
        for key in keys:
            #获得图片路径
            img_path = os.path.join(self.path_prefix,key)
            #读取图片
            img = imread(img_path).astype('float32')
            #获得当前图片的 gt boxes
            y = self.gt[key].copy()
            #训练模式下是否进行裁剪
            if train and self.do_crop:
                #此时的img,y已经更新
                img, y = self.random_sized_crop(img, y)
            #将图片resize到模型需要的尺寸
            img = imresize(img, self.image_size).astype('float32')

            #只在训练模式下进行
            if train:
                #self.color_jitter里面保存了需要做的颜色抖动的函数
                shuffle(self.color_jitter) #几个过程随机
                for jitter in self.color_jitter: #依次进行变换
                    img = jitter(img)
                #光噪声
                if self.lighting_std:
                    img = self.lighting(img)
                #随机水平翻转
                if self.hflip_prob > 0:
                    img, y = self.horizontal_flip(img, y)
                #随机垂直翻转
                if self.vflip_prob > 0:
                    img, y = self.vertical_flip(img, y)
            #
            y = self.bbox_util.assign_boxes(y) #输出的y后面加上了8列，表示的是prior box的8个属性
            inputs.append(img)
            targets.append(y)
            if len(targets) == self.batch_size:
                tmp_inp = np.array(inputs)
                tmp_targets = np.array(targets)
                inputs = []
                targets = []
                yield preprocess_input(tmp_inp), tmp_targets

这里面主要是y = self.bbox_util.assign_boxes(y)这句代码，作用是为gt box（ground truth box）配default box，为什么要分配呢？我们知道，default box的数量是根据feature maps的尺寸决定的，也就是不管你来的是哪张训练图片，图片中有几个gt box，default box就在那里，不增不减，但是我们并不会将所有的default box参与训练，我们只训练那些接近gt box的default box，这也是为了让网络能够顺利训练设计的，选取出来的default box又被成为prior box。

bbox_utils.py

class bbox_utils(object):

    def __init__(self,
                 num_classes,
                 priors=None,
                 overlap_threshold=0.5,
                 nms_thresh=0.45,
                 top_k=400):
		#......

    @property
    def nms_thresh(self):
        #......
    @nms_thresh.setter
    def nms_thresh(self, value):
        #......
    @property
    def top_k(self):
        #......
    @top_k.setter
    def top_k(self, value):
        #......
    def iou(self, box): #(7308,4)
		#......
    def encode_box(self, box, return_iou=True): #这里的box是gt
        iou = self.iou(box) #求所有box与default box的IOU大于阈值的default box，并作为prior box
        encoded_box = np.zeros((self.num_priors, 4 + return_iou))
        assign_mask = iou > self.overlap_threshold #(7308,)
        if not assign_mask.any(): #如果没有一个大于0.5的，那么就取最大的一个
            assign_mask[iou.argmax()] = True
        if return_iou:
            encoded_box[:, -1][assign_mask] = iou[assign_mask] #如果需要返回iou，则将prior box与gt的iou添加在最后一列
        assigned_priors = self.priors[assign_mask] #这里的assigned_priors其实就是已经过筛选符合要求的default box，之后就称之为prior box 形状为(-1,8)
        box_center = 0.5 * (box[:2] + box[2:]) #求gt box得到中心(cx,cy)
        box_wh = box[2:] - box[:2] #(cw,ch) gt box的宽高
        assigned_priors_center = 0.5 * (assigned_priors[:, :2] + assigned_priors[:, 2:4]) #求出所有prior box的中心
        assigned_priors_wh = (assigned_priors[:, 2:4] - assigned_priors[:, :2]) #求出所有prior box的宽高
        # we encode variance
        #求出了l_cx和l_cy
        encoded_box[:, :2][assign_mask] = box_center - assigned_priors_center
        encoded_box[:, :2][assign_mask] /= assigned_priors_wh
        #将误差计算在内，不太明白为什么这样做
        encoded_box[:, :2][assign_mask] /= assigned_priors[:, -4:-2]
        #求出l_w和l_h
        encoded_box[:, 2:4][assign_mask] = np.log(box_wh / assigned_priors_wh)
        encoded_box[:, 2:4][assign_mask] /= assigned_priors[:, -2:]
        return encoded_box.ravel()

    def assign_boxes(self, boxes):
       assignment = np.zeros((self.num_priors, 4 + self.num_classes + 8)) #(7308,4+21+8)
        assignment[:, 4] = 1.0 #全部初始化为背景
        if len(boxes) == 0: #如果boxes为空，即图片中没有目标
            return assignment
        encoded_boxes = np.apply_along_axis(self.encode_box, 1, boxes[:, :4]) #对box的坐标进行编码,其中encoded_boxes是ravel后的值，形状为(num_gt_box,7308*(4+1))
        encoded_boxes = encoded_boxes.reshape(-1, self.num_priors, 5) #再变回来(num_gt_box,7308,5)
        #这里是为了满足一个prior box只对应一个gt box的要求，进行二次筛选
        best_iou = encoded_boxes[:, :, -1].max(axis=0) #iou最大的那个prior box (7308,)
        best_iou_idx = encoded_boxes[:, :, -1].argmax(axis=0) #最大iou的索引 (7308,)
        best_iou_mask = best_iou > 0 #best_iou_mask下的prior box才是最终的prior box

        best_iou_idx = best_iou_idx[best_iou_mask]
        assign_num = len(best_iou_idx)
        encoded_boxes = encoded_boxes[:, best_iou_mask, :] #(1,?,5)
        assignment[:, :4][best_iou_mask] = encoded_boxes[best_iou_idx,
                                           np.arange(assign_num),
                                           :4]
        assignment[:, 4][best_iou_mask] = 0 #这里将所有prior box的背景那个类别置为0，因为只要是prior box肯定不属于背景
        assignment[:, 5:-8][best_iou_mask] = boxes[best_iou_idx, 4:] #这里是one hot类型的概率
        assignment[:, -8][best_iou_mask] = 1 #最后的8列没有意义，只是为了使shape与网络输出的shape保持一致
        return assignment

    def decode_boxes(self, mbox_loc, mbox_priorbox, variances):
        prior_width = mbox_priorbox[:, 2] - mbox_priorbox[:, 0]
        prior_height = mbox_priorbox[:, 3] - mbox_priorbox[:, 1]
        prior_center_x = 0.5 * (mbox_priorbox[:, 2] + mbox_priorbox[:, 0])
        prior_center_y = 0.5 * (mbox_priorbox[:, 3] + mbox_priorbox[:, 1])
        decode_bbox_center_x = mbox_loc[:, 0] * prior_width * variances[:, 0]
        decode_bbox_center_x += prior_center_x
        decode_bbox_center_y = mbox_loc[:, 1] * prior_width * variances[:, 1]
        decode_bbox_center_y += prior_center_y
        decode_bbox_width = np.exp(mbox_loc[:, 2] * variances[:, 2])
        decode_bbox_width *= prior_width
        decode_bbox_height = np.exp(mbox_loc[:, 3] * variances[:, 3])
        decode_bbox_height *= prior_height
        decode_bbox_xmin = decode_bbox_center_x - 0.5 * decode_bbox_width
        decode_bbox_ymin = decode_bbox_center_y - 0.5 * decode_bbox_height
        decode_bbox_xmax = decode_bbox_center_x + 0.5 * decode_bbox_width
        decode_bbox_ymax = decode_bbox_center_y + 0.5 * decode_bbox_height
        decode_bbox = np.concatenate((decode_bbox_xmin[:, None],
                                      decode_bbox_ymin[:, None],
                                      decode_bbox_xmax[:, None],
                                      decode_bbox_ymax[:, None]), axis=-1)
        decode_bbox = np.minimum(np.maximum(decode_bbox, 0.0), 1.0)
        return decode_bbox

    def detection_out(self, predictions, background_label_id=0, keep_top_k=200,
                      confidence_threshold=0.01):
        mbox_loc = predictions[:, :, :4]
        variances = predictions[:, :, -4:]
        mbox_priorbox = predictions[:, :, -8:-4]
        mbox_conf = predictions[:, :, 4:-8]
        results = []
        for i in range(len(mbox_loc)):
            results.append([])
            decode_bbox = self.decode_boxes(mbox_loc[i],
                                            mbox_priorbox[i], variances[i])
            for c in range(self.num_classes):
                if c == background_label_id:
                    continue
                c_confs = mbox_conf[i, :, c]
                c_confs_m = c_confs > confidence_threshold
                if len(c_confs[c_confs_m]) > 0:
                    boxes_to_process = decode_bbox[c_confs_m]
                    confs_to_process = c_confs[c_confs_m]
                    feed_dict = {self.boxes: boxes_to_process,
                                 self.scores: confs_to_process}
                    idx = self.sess.run(self.nms, feed_dict=feed_dict)
                    good_boxes = boxes_to_process[idx]
                    confs = confs_to_process[idx][:, None]
                    labels = c * np.ones((len(idx), 1))
                    c_pred = np.concatenate((labels, confs, good_boxes),
                                            axis=1)
                    results[-1].extend(c_pred)
            if len(results[-1]) > 0:
                results[-1] = np.array(results[-1])
                argsort = np.argsort(results[-1][:, 1])[::-1]
                results[-1] = results[-1][argsort]
                results[-1] = results[-1][:keep_top_k]
        return results

OpenCV中CUDA代码分析之hist篇

Tue, 20 Nov 2018 00:00:00 +0000

这篇文章是分析OpenCV中直方图部分的CUDA代码，代码位于~/opencv-3.4.1/modules/cudaimgproc/src/cuda/hist.cu，代码量：少。

histogram256Kernel

__global__ void histogram256Kernel(const uchar* src, int cols, int rows, size_t step, int* hist)
{
    __shared__ int shist[256]; //声明共享内存，用于提高计算效率，每个block分别计算完后，在进行汇总

    const int y = blockIdx.x * blockDim.y + threadIdx.y; //求出thread的全局y值
    const int tid = threadIdx.y * blockDim.x + threadIdx.x;//thread在block中的全局ID

    shist[tid] = 0; //清空共享内存
    __syncthreads(); //同步

    if (y < rows)
    {
        const unsigned int* rowPtr = (const unsigned int*) (src + y * step); //获得当前thread需要处理的数据地址，step应该是Mat中的step相同定义，但是这里的运算运应该是被重载了，不清楚具体含义
        const int cols_4 = cols / 4; //应为每次要处理一个字节，所以看看列数能被分成几组
        for (int x = threadIdx.x; x < cols_4; x += blockDim.x)
        {
            unsigned int data = rowPtr[x];
			//每个thread每次读取4个字节（也就是说一个thread每次处理4个像素），也是就是一个warp读取128个字节，充分利用存储带宽
            Emulation::smem::atomicAdd(&shist[(data >>  0) & 0xFFU], 1);
            Emulation::smem::atomicAdd(&shist[(data >>  8) & 0xFFU], 1);
            Emulation::smem::atomicAdd(&shist[(data >> 16) & 0xFFU], 1);
            Emulation::smem::atomicAdd(&shist[(data >> 24) & 0xFFU], 1);
        }
		//前面处理的是满足被4整除的部分，因为图像的尺寸可能不是4的整数倍，所以这里单独处理一下剩余的部分
        if (cols % 4 != 0 && threadIdx.x == 0)
        {
            for (int x = cols_4 * 4; x < cols; ++x)//也就是遍历了cols_4 * 4到cols部分，循环次数<=3
            {
                unsigned int data = ((const uchar*)rowPtr)[x];
                Emulation::smem::atomicAdd(&shist[data], 1);
            }
        }
    }
    __syncthreads();
	//当所有现成完成计算后，将所有block计算的结果进行汇总，当某一bin的个数为0时，不必参与运算，减少了内存从冲突的情况zongjie
    const int histVal = shist[tid];
    if (histVal > 0)
        ::atomicAdd(hist + tid, histVal);
}

//主机函数
void histogram256(PtrStepSzb src, int* hist, cudaStream_t stream)
{
    const dim3 block(32, 8);
    const dim3 grid(divUp(src.rows, block.y));//向上取整

    histogram256Kernel<<<grid, block, 0, stream>>>(src.data, src.cols, src.rows, src.step, hist);
    cudaSafeCall( cudaGetLastError() );

    if (stream == 0)
        cudaSafeCall( cudaDeviceSynchronize() );
}

其中divUp函数的定义为，其实就是个向上取整的作用，现在我们的grid尺寸依然沿用这种方式：

__host__ __device__ __forceinline__ int divUp(int total, int grain)
{
    return (total + grain - 1) / grain;
}

分析

首先从主机函数下手，看到block和grid的尺寸设计，不禁浮想联翩，为什么要设计成这样（其实blcok的大小刚好为256），为什么不每个线程分配一个像素，也就是thread数目 = 图像尺寸？他这样做意味着一个thread有可能需要处理多个像素，但是毕竟编写的人员肯定是这块的大佬，所以我们慢慢来分析这样做的优势，分析分为两块：存储和逻辑。

我们简要分析一下读取，程序里最大化读取效率，每次读取4个字节，也就是warp的合并访问达到了最大效率—128个字节。存储上，首先每个block计算结果储存到自己的shares memory上，原子加法存在延迟，另外，为了能够每次读取4个字节，程序中使用了类型强制转换，这在GPU上是低效的。

另外在《CUDA并行程序设计》一书中也分析了在这种情况下，原子操作的延迟远大于存储延迟。那么我们怎样才能减少这种延迟呢，那就是使用共享内存，将一部分全局内存存储的工作替换为共享内存的储存。

在计算能力为6.1的设备上发现一次读取4字节的方法比一次单字节读取还慢，而且使用共享内存也比不用慢,应该是图像本来就小(480*640)，所以太复杂的逻辑可能导致计算效率下降。

直方图均衡化

OpenCV中的实现各种跳转，均衡化过程非常简单，不知为何长达五六层的调用，而且找到最终的实现，发现一堆模板，重载运算符的，果断放弃，直接给出我在DelataCV中的实现代码。

CUDA实现图像二值化

Fri, 16 Nov 2018 00:00:00 +0000

着重介绍了阈值二值化及ostu二值化的实现，算法本身很简单，主要是将算法并行化，有点费事，同时也注意到了对于时序性较强的算法，cuda移植后性能并不会得到大幅度提升，提升往往在10倍左右，值得深思。

算法实现：DeltaCV 使用例子：Samples

阈值二值化

阈值二值化，这里是指阈值是人为设定的，简单的二值化，鲁棒性低，但计算量小。

/*
 * Compare 'threshold()' funciton in OpenCV
 * When:
 *      thresholdMin = thresholdMax and valMin = 0  ==> THRESH_BINARY
 *      thresholdMin = thresholdMax and valMax = 0  ==> THRESH_BINARY_INV
 *      thresholdMax = valMax and thresholdMin = 0  ==> THRESH_TRUNC
 *      thresholdMax = 255 and valMin = 0  ==> THRESH_TOZERO
 *      thresholdMin = 0 and valMax = 0  ==> THRESH_TOZERO_INV
 */

__global__ void thresholdBinarization(unsigned char* dataIn,
                                      unsigned char* dataOut,
                                      short int imgRows,
                                      short int imgCols,
                                      unsigned char thresholdMin,
                                      unsigned char thresholdMax,
                                      unsigned char valMin,
                                      unsigned char valMax)
{
    int xIndex = threadIdx.x + __umul24(blockIdx.x, blockDim.x);
    int yIndex = threadIdx.y + __umul24(blockIdx.y, blockDim.y);

    int tid = __umul24(yIndex,imgCols)+xIndex;

    unsigned char val=dataIn[tid];
    unsigned char res = val;

    if(xIndex < imgCols && yIndex < imgRows)
    {

        if(val>thresholdMax)
        {
            res = valMax;
        }

        if(val<=thresholdMin)
        {
            res = valMin;
        }

        dataOut[tid] = res;
    }
}

这个算法非常简单，设置与图像像素数一样的thread，thread读取每个像素值，直接进行判断，这里使用分支语句的影响很小，貌似可以被编译器优化，不必太担心效率。而且通过适当的参数设置（见代码中的注释部分），可以得到与opencv中threshold函数一样的效果。

OSTU二值化

OSTU又称为自适应阈值二值化，它的主要思想是迭代，从灰度级0到255，每次按照当前的灰度值将图像分为出背景和前景，如果当前两个部分（背景和前景）的类间方差最大，则说明此时的阈值是最优的。

求直方图：

__global__ void getHist(unsigned char* dataIn, unsigned int* hist)
{
    int xdx = threadIdx.x + __umul24(blockIdx.x, blockDim.x);
    int ydx = threadIdx.y + __umul24(blockIdx.y, blockDim.y);

    int tid = xdx + ydx*gridDim.x*blockDim.x;

    if(tid < 256)
    {
        hist[tid]=0;
    }
    __syncthreads();
    atomicAdd(&hist[dataIn[tid]],1);
}

这里需要注意的是，由于我们面向视频处理，像atomicAdd这类的操作，之前需要将整个数组清空，因为上一帧的处理结果还在内存中，并没有删除。并且还需要同步一下线程，确保整个hist都已被清空。

计算类间方差

/*
 * w_A:前景像素级占的比例，Pi的和
 * u_A:前景像素级的均值，i×Pi的和除以w_A
 */
__global__ void ostu(unsigned int* hist,
                     float* sum_Pi,
                     float* sum_i_Pi,
                     float* u_0,
                     float* varance,
                     short int imgRows,
                     short int imgCols)
{

    //清空相关数组，清空上一次的计算结果
    if(blockIdx.x == 0)
    {
        sum_Pi[threadIdx.x] = 0.0f;
        sum_i_Pi[threadIdx.x] = 0.0f;
        if(threadIdx.x==0)
        {
            u_0[0] = 0.0f;
        }
    }
    __syncthreads();

    //计算整幅图的平均灰度、前景的概率、前景的平均灰度值
    unsigned int current_val = hist[threadIdx.x];
    if(blockIdx.x==0)
    {
        atomicAdd(&u_0[0],current_val*threadIdx.x);//sum(i*Pi)+sum(j*Pj)
    }
    else
    {
        if(threadIdx.x < blockIdx.x)
        {
            atomicAdd(&sum_Pi[blockIdx.x-1],current_val);//sum()
            atomicAdd(&sum_i_Pi[blockIdx.x-1],current_val*threadIdx.x);//sum(i*Pi)
        }
    }
    __syncthreads();
    //now we get sum_Pi[256] and sum_i_Pi[256] and w_0
    //下面开始计算类间方差
    int imgSize = imgRows*imgCols;
    if(blockIdx.x>0)
    {
        float f_sum_pi = sum_Pi[blockIdx.x-1]/imgSize;
        float f_sum_pj = 1-f_sum_pi;
        if(f_sum_pj==0)
        {
            varance[blockIdx.x-1]=0;
        }else
        {
            float temp = (u_0[0]/imgSize-sum_i_Pi[blockIdx.x-1]/(f_sum_pi*imgSize));
            varance[blockIdx.x-1] = temp*temp*f_sum_pi/f_sum_pj;
        }
    }
}

最后面计算类间方差的公式是化简后得到公式，参考。上述程序会得到一个大小为256的类间方差数组，里面的值对应每个灰度级作为二值化阈值时对应的类间方差。

寻找最优阈值

__global__ void tree_max(float* varance,int* thres)
{
        __shared__ float var[256];
        __shared__ int varId[256]; // 512*4/1024 = 2KB
        varId[threadIdx.x] = threadIdx.x;
        var[threadIdx.x] = varance[threadIdx.x];
        for (int i = 1; i < 256; i*=2)
        {
            if(threadIdx.x%(2*i)==0)
            {
                if(var[threadIdx.x]<var[threadIdx.x+i])
                {
                    var[threadIdx.x] = var[threadIdx.x+i];
                    varId[threadIdx.x] = varId[threadIdx.x+i];
                }
            }
            __syncthreads();
        }
        if(threadIdx.x == 0)
        {
            thres[0] = varId[0];
        }
}

这一步是借用并行求和的思想，来并行求最大值，由于我们最终是要得到类间方差最大时的阈值，也就是类间方差最大那个值的索引，所以我们又定义了一个varId变量来保存每一次树型对比时获得的最大类间方差对应的索引，则对比完后，varId[0]保存的就是最大类间方对应的索引。最后我们再使用之前的阈值二值化进行二值化即可。

整体流程及thread、block设置

void ostu_gpu(unsigned char* dataIn,
              unsigned char* dataOut,
              unsigned int* hist,
              float* sum_Pi,
              float* sum_i_Pi,
              float* u_0,
              float* varance,
              int* thres,
              short int imgRows,
              short int imgCols)
{

    dim3 tPerBlock_hist(32,32);
    dim3 bPerGrid_hist((imgCols+32-1)/32,(imgRows+32-1)/32);
    //求直方图
    getHist_gpu(dataIn,hist,tPerBlock_hist,bPerGrid_hist);

    dim3 tPerBlock_ostu(256,1);
    dim3 bPerGrid_ostu(257,1);
    //计算类间方差
    ostu<<<bPerGrid_ostu,tPerBlock_ostu>>>(hist,sum_Pi,sum_i_Pi,u_0,varance,imgRows,imgCols);
    //寻找最优阈值
    tree_max<<<1,256>>>(varance,thres);
    //阈值值化
    thresholdBinarization_inner<<<bPerGrid_hist,tPerBlock_hist>>>(dataIn,dataOut,imgRows,imgCols,thres);
}

CUDA编程中的blockIdx及threadIdx等预定义变量的具体含义

Thu, 01 Nov 2018 00:00:00 +0000

最近在用CUDA复现图像处理算法时，发现对threadIdx等这类基本概念还是模棱两可，故在此详细总结一下，加深印象。

看图说来

图中，红色的小格子表示一个thread，黄色的2*2格子表示一个block，thread中的黑色数字x表示threadIdx.x，y表示threadIdx.y。block中的红色加粗x表示blockIdx.x，y表示blockIdx.y。

threadIdx：它是相对于它所在的block而言的，x表示当前thread所在的列数，y表示所在的行数，你会发现第一个block的第一个thread为（x:0 , y:0），第二个block的第一个thread也为（x:0 , y:0）。
blockIdx：它是相对grid而言的，x表示当前block所在的列数，y表示所在的行数。
blockDim：blockDim.x表示一个block中一共有几列thread，blockDim.y表示一个block中一共有几行thread。
gridDim：gridDim.x表示一个grid中一共有几列block，blockDim.y表示一个grid中一共有几行block。

实际应用

在编程中，当处理图像这类高维矩阵时，我们也会使用三维的block和grid，所以thread的全局ID计算会常用到。

const unsigned int idx = threadIdx.x + blockDim.x * blockIdx.x;
const unsigned int idy = threadIdx.y + blockDim.y * blockIdx.y;

//tid即thread的全局ID
const unsigned int tid = idx + blockDim.x * gridDim.x * idy;

参考：CUDA官方论坛回答

The best way to understand these values is to look at some of the schematics in the Introduction to CUDA Programming document, but I'll an explanation a shot.

Basically threadIdx.x and threadIdx.y are the numbers associated with each thread within a block. Let's say you declare your block size to be one dimensional with a size of 8 threads (normally you would want something in multiples of 32 like 192 or 256 depending on your specific code). The variable threadIdx.x would be simultaneously 0,1,2,3,4,5,6 and 7 inside each block. If you declared a two dimensional block size (say (3,3) ) then threadIdx.x would be 0,1,2 and you would now have a threadIdx.y value corresponding to 0,1,2. There are actually nine threads associated with the (3,3) block size. For instance, the thread indices (0,0) (0,1) (1,2) etc refer to independent threads. This convention is very useful for two dimensional applications like working with matrices. Remember, threadIdx.x starts at 0 for each block. Your block can be up to three dimensions which allows for a threadIdx.z index as well.

The blockIdx.x and blockIdx.y refers to the label associated with a block in a grid. You are allowed up to a 2-dimensional grid (allowing for blockIdx.x and blockIdx.y). Basically, the blockIdx.x variable is similar to the thread index except it refers to the number associated with the block. 

Let's say you want 2 blocks in a 1D grid with 5 threads in each block. Your threadIdx.x would be 0, 1,.....,4 for each block and your blockIdx.x would be 0 and 1 depending on the specific block.

Now, let's say you want to load an array of 10 values into a kernel using these two blocks of 5 threads. How would you do this since your thread index only goes 0 - 4 for each block? You would use a third parameter given in CUDA -- blockDim.x. This holds the size of the block (in this case blockDim.x = 5). You can refer to the specific element in the array by saying something like...

int idx = blockDim.x*blockIdx.x + threadIdx.x

This makes idx = 0,1,2,3,4 for the first block because blockIdx.x for the first block is 0. The second block picks up where the first left off because blockIdx.x = 1 and blockDim.x = 5. This makes idx = 5,6,7,8,9 for the second block.

Once again, refer to the beginner manual for more on this subject. Hope this helps.

CMakeLists快速入门

Thu, 25 Oct 2018 00:00:00 +0000

编写CMakeLists文件是一个程序员的基本素养，如何优雅地编写CMakeLists，是快乐编程的第一步。之前一直是用的最简单形式的CMakeLists文件，但随着开发的项目越来越庞大，不禁发觉CMakeLists的学问还是蛮大的。

最简单的CMakeLists

本例只包含一个目录，所有的工程文件都在根目录，想当年，我把整个工程的源文件、头文件都放在根目录，就是为了CMakeLists.txt好写一点。

project/
|— CMakeLists.txt
|— main_1.cpp
|— main_2.hpp

#指定了cmake的最低版本
cmake_minimum_required(VERSION 3.2)
#工程名字，自己起的
project(testProject)
#生成可执行文件main，我们在后面将工程中用到的源文件和头文件列出来
add_executable(main main_1.cpp main_2.hpp)

我猜，这可能是最简单的CMakeLists文件了吧。

增加工程文件

project/
|— CMakeLists.txt
|— main.cpp
|— main_1.cpp
...
|— main_100.cpp

假如像我之前一样，把工程的所有文件都放在一个目录下，如果还按照上面的写法把所有的源文件都列在add_executable中，不仅效率低，而且很不优雅。

#指定了cmake的最低版本
cmake_minimum_required(VERSION 3.2)
#工程名字，自己起的
project(testProject)

#新增加的语句
aux_source_directory(. ALL_SRCS)

#生成可执行文件main，我们在后面将工程中用到的源文件和头文件列出来
add_executable(main ${ALL_SRCS})

只需稍微修改一下，即可优雅地完成我们的要求，那就是aux_source_directory，它的作用的搜索指定目录dir下的所有源文件（注意是源文件），将文件名当作列表保存在variable中，用法为aux_source_directory(< dir > < variable >)。上述例子中是将101个源文件储存在ALL_SRCS变量中，所以add_executable中只需引用变量ALL_SRCS即可（这里写${ALL_SRCS}等同于手动列出那101个源文件）。

调整工程目录

但是稍微有开发经验的程序员都不会像我们那样组织工程目录，我们会按照函数的功能对整个工程进行划分，以及头文件和源文件分离等等易于组织的结构。

project/
| — CMakeLists.txt
| — main.cpp
| — function/
    | — func1.cpp
    | — func1.hpp

这里我们将功能函数单独放在function目录下，使整个工程变得有条理一点，此时你的CMakeLists.txt可以这样写，仿照上面的例子。

#指定了cmake的最低版本
cmake_minimum_required(VERSION 3.2)
#工程名字，自己起的
project(testProject)
#生成可执行文件main，我们在后面将工程中用到的源文件和头文件列出来
add_executable(main main.cpp function/func1.cpp function/func1.hpp)

这样完全OK的，但是不够优雅，你可以这样来写

#指定了cmake的最低版本
cmake_minimum_required(VERSION 3.2)
#工程名字，自己起的
project(testProject)

#新增语句1
add_subdirectory(function)
#新增语句2
include_directories(function)

#生成可执行文件main，我们在后面将工程中用到的源文件和头文件列出来
add_executable(main main.cpp)
#新添加语句3
target_link_libraries(main funcLib)

然后我们再在function目录下新建一个CMakeLists.txt文件

#将该目录下的所有的源文件名字保存在DIR_FUNC_SRCS中
aux_source_directory(. DIR_FUNC_SRCS)
#生成链接库，名字为funcLib
add_library(funcLib ${DIR_FUNC_SRCS})

这里采用的思路是将function目录下的源文件作为链接库供工程使用，在根目录下的CMakeLists.txt中：

新增语句1是告诉编译器工程还包含一个子目录function，里面还有一个CmakeList文件，其实也就是告诉编译器先去编译那个子CmakeList文件。
新增语句2添加了头文件目录，因为在function目录下含有工程使用的头文件，也就是说你在程序里#include本地头文件时，编译器搜索的目录，更直观一点说，没有这句，你在main里面应该这样写#include "function/func1.hpp"，如果你写了这句，则可以这样写#include "func1.hpp"，也就是编译器知道去哪里去找这个头文件。
新增语句3是将生成的链接库funcLib链接到可执行文件上。

Git完全教程

Thu, 25 Oct 2018 00:00:00 +0000

git是程序员必备技能之一，学会git，再也不怕瞎**乱改代码，再也不会忘记上次修改了什么地方，用git，快乐编程。

Git前言

Git只记录每次修改的内容，即当前提交的内容和当前的内容的差值，这也是Git比其它版本控制系统优秀的地方。

新建仓库

这里的仓库指本地仓库，至于远程仓库的新建诸如Github，全界面操作，简单易懂，只需轻轻点几下（百度教程一大堆，不会编程的童鞋也能看懂）。

你可以新建一个目录来当作本地仓库，也可以在你已有的工程目录直接新建仓库，但是一般情况下，我们会新建一个目录。

$ git init

执行上述命令就会在当前目录新建一个本地仓库，并且输出

Initialized empty Git repository in E:/Projects/testgit/.git/

但此时细心的你会发现，目录下什么也没有，其实它已经生成了一个.git目录，只不过它是隐藏文件，所以现在你可能有疑问，这个.git目录就是我们的仓库吗？它里面保存的是版本控制的相关文件，反正不要人为地去修改它，否则的话会导致你的本地仓库被破坏。

修改工作区

这里的修改包括新添加文件和修改原有文件内容。而修改文件名，会被当作一次文件删除和文件添加。我们现在仓库中新建一个test.txt文件，在里面写上

echo 'this is a new file' > test.txt

此时使用git status来查看仓库的状态，会发现，git检测到新建文件了，但是并不知道你里面有什么内容，所以它是Untracked状态。

使用git add test.txt将test.txt从提交到暂存区，此时我们再使用git status来查看仓库的状态

$ git status
On branch master
No commits yet
Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   test.txt

此时说明test.txt已经被git追踪，git检测到test.txt是新添加的文件

我们使用git commit -m "增加一个新文件"来将暂存区提提交到master分支。

$ git commit -m "增加一个新文件"
[master (root-commit) db05952] 增加一个新文件
 1 file changed, 1 insertion(+)
 create mode 100644 test.txt

此时我们再使用git status来查看仓库的状态

$ git status
On branch master
nothing to commit, working tree clean
 test.txt

发现当我们执行commit指令时，暂存区在提交到master分支时自身也会清空。

分支操作

我们可以通过git branch命令查看当前仓库的所有分支

当我们新建git工作区，还没进行commit操作时，我们的工作区内是没有任何branch，而我们第一次commit操作会自动创建一个master分支。

$ git init
$ git branch 
 ==> 输出空
$ git add .
$ git commit -m 'add new file.'
$ git branch
* master

新建分支 / 切换分支

$ git checkout -b branch1 
Switched to a new branch 'branch1'

$ git branch
* branch1
  master
  
$ git checkout master
Switched to branch 'master'
$ git branch
  branch1
* master

此时我们新建了分支branch1并将它设置为当前分支，此时branch分支和master分支一致，此后我们就可以分别向两个分支提交更改，它们并不会相互影响（在分支合并之前）,可理解为在你创建branch1分支时，在仓库新建了一个岔路口。

合并分支当你需要将branch1分支合并到master分支时（比如已完成某个bug修复，或者添加新的功能测试）

**<注意>** 合并分支前，请确保已经将修改commit到仓库。

$ git checkout master
Switched to branch 'master'
$ git merge branch1
Updating 0b801ef..c4ecd99
Fast-forward
 b1.txt | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 b1.txt

这里可以看到我在branch1分支添加的文件b1.txt现在已经合并到master分支

**<注意>** 当出现合并冲突时，需要手动修改冲突部分

版本回退

修改test.txt

这是仓库中的第一个文件，用来测试添加文件
这是我新添加的内容，用来测试版本回退

然后我们再对test.txt执行add和commit操作，这时，你突然发现上次添加的那句话不太正确，需要回退到之前的版本，当然这对于（删除某些内容）更能体现版本回退的用处。

此时你可以使用git log命令查看你的commit记录

$ git log
commit 875449ad625b785cc7cd03fe5f48c930cf2b32c6 (HEAD -> master)
Author: ********
Date:   ********

    测试版本回退

commit db05952ae47fa8f897d8cf52488c350fd8e765c8
Author: ********
Date:   ********

    增加一个新文件

可以发现，之前的commit操作都有记录，这里回退有两种方法

git reset --hard commit-id
git reset --hard HEAD~回退的次数

在git log输出的信息中，有一项需要我们注意commit加一长串数字，这个叫做commit id，用来唯一指示一次commit操作，我们可以凭借commit id来回退到指定版本，当然你也可以使用HEAD~回退的次数来将HEAD指针往回移动，比如HEAD~100就是回退到前第100次的commit操作（可能比较拗口，比如这里HEAD~1表示回退到“增加一个新文件”那次操作，因为你当前处于“测试版本回退”）

$ git reset --hard HEAD~1
HEAD is now at db05952 增加一个新文件

$ git reset --hard 875449
HEAD is now at 875449a 测试版本回退

命令总结

新建仓库

git init：初始化本地仓库
git clone https://www.github.com/***：克隆远程仓库

设置用户名和邮箱

git config --global user.name "Your Name"：设置用户名
git config --global user.email "email@example.com"：设置邮箱

提交

git add .：将工作区的文件全部提交到暂存区
git add file：将单独的文件提交到暂存区
git commit -m "更新信息"：将暂存区提交到本地仓库分支

撤销操作

git checkout -- file：撤销在工作区上的修改，add前。
git reset HEAD file：撤销暂存区的操作，add后、commit前。
git reset --hard commit-id/HEAD~回退的次数：在commit之后又想取消本次的修改，直接进行版本回退，commit后。

同步远程分支到本地分支

git pull origin master：将远程origin仓库的master分支下载到本地分支，并进行合并。

CUDA中常用的host端及device端函数理解

Tue, 16 Oct 2018 00:00:00 +0000

总结一些常用的host及device端函数，解释其内部具体的运行流程，包括一些重要结构体里面的变量，学习CUDA编程之后才发现，GTX 1070性能是真的差啊，被老黄阉割的不忍直视，不过这系列的显卡定位也不是数据计算的。

cudaMalloc

函数原型：extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaMalloc(void **devPtr, size_t size);

用法：

int* gpudata；
cudaMalloc((void**)&gpudata, sizeof(int)*1024);

用途：向GPU申请空间，类型为int型一维数组，大小为1024，GPU上的申请到的空间的地址保存在指针gpudata中，可能有同学会对(void**)&gpudata产生疑问，为什么是这种形式？下面解释一下，指针也是变量，只不过它里面的值是另外普通变量的地址，既然是变量，那它也就有地址，也就是说指针也是有地址的，我们也可以对指针进行取址操作。

第一个&，获得了gpudata的地址
靠近&的*，或得了gpudata里面储存的地址
第二个*，获得了gpudata里面地址对应的数据

cudaDeviceProp结构体

name[256]：保存GPU的名字，例如：GeForce GTX 1070
totalGlobalMem：我们通常说的显存，例如GTX 1070 8G为 8504868864 bytes
sharedMemPerBlock：block中share memory的大小，速度比全局存储空间快，例如GTX 1070 8G为 49152 bytes
regsPerBlock：block中register memory的大小，里面存储的寄存器
warpSize：线程束大小
maxThreadsPerBlock：每个block最多的thread数量
maxThreadsDim[3]：block每个维度的最大值
maxGridSize[3]：grid每个维度的最大值
clockRate：GPU的时钟频率
multiProcessorCount：GPU上SM的数量，说实话老黄真是一个好刀客，本来性能就不行，还不停地砍性能

CUDA中共享内存中的bank conflict问题

Tue, 16 Oct 2018 00:00:00 +0000

在进行block内的thread同步时，会使用shared memory，那就不得不考虑它的bank conflict问题，当程序里面出现bank conflict时，程序运行效率会受到较大影响

Bank in Shared Memory

在软件中，每个block都会有自己的共享内存（shared memory），同一个blcok中的所有thread可以使用共享内存进行通信及同步。在硬件中，每个SM具有96KB的共享内存（GTX 1070）来分给下面的block，而共享内存又被分为多个bank，而bank的个数则根据每个bank占用的字节数来决定的，在计算能力3.0之后，每个bank占用的字节数用户是可以配置的

/**
 * CUDA shared memory configuration
 */
enum __device_builtin__ cudaSharedMemConfig
{
    cudaSharedMemBankSizeDefault   = 0,
    cudaSharedMemBankSizeFourByte  = 1,
    cudaSharedMemBankSizeEightByte = 2
};

例如：我们在调用内核函数时动态申请了128字节的共享内存，并且我们每个bank占用的字节数使用默认配置，即4字节，那么一共会有96/4=24个bank，则0-3字节分配在bank[0]，4-7分配在bank[1]，…，92-95分配在bank[23]，而96-99会分配在bank[0]，以此类推，也就是说GPU是采用平衡负载的思路去将共享内存分配给bank。

Bank Conflict Problem

bank conflict问题发生在不同的thread对同一bank进行操作的时候，此时调度器会强制让这些冲突的thread顺序访问bank，这样就会使我们的程序效率降低，但我们一般可以在设计程序时避免这种情况

C++中的引用和指针

Mon, 15 Oct 2018 00:00:00 +0000

最近在写C++代码的时候，对于函数形参什么时候用&，什么时候用*，比较模棱两可，故总结一下，将相关的知识点巩固一下。

指针

说起指针，我们应该很自然而然的想到地址，指针用*来表示，int *a = &b就表示变量b的地址保存在指针a中，我们也可以说a是指向int的一个指针，a里面储存的是地址，并不是b的值。解引用*符号表示根据地址取值，例如*a表示指针a中储存的地址指向的值，取址符号&表示获得变量的地址，例如&b表示获得变量b的地址。

另外需要说明的是，数组的名称代表的是首元素的地址

int b = 10; //a是变量

//这里其实写法也有两种，*靠近类型还是变量，都是对的，即int* a和int *a，以及int*a都是可以的
int* a = &b; //a就是一个指针，a里面储存的是地址，&b表示取出变量b的地址，整体就是指针a指向变量b

int b[3];//这里声明了一个int类型的数组，变量名b就是一个int*类型的指针，它指向b[0]元素的地址。

引用

引用之前几乎没怎么用过，也没怎么了解过，它更多的是在函数形参传值时回用，这个我们稍后和指针一起来总结。

先看引用变量的代码：

int a = 3;
int &b = a; //这里的b就是个引用，b和a拥有共同的地址，共同的变量，相当于python中的deepcopy()

指针和引用在函数中的使用

//func1说明需要给我传递指针，也就是地址
void func1(int* dat1){//something...}
//func2传递的就是普通变量，只不过函数又给传入的变量起了另外一名字
void func2(int &dat2){//something...}
//这里是按值传递，和引用传值作对比
void func3(int dat3){//something...}

int a[3]={0,0,0};//数组
int b=0；

func1(a);
func1(&b)；//这里是取址，因为func1需要的是地址

func2(b);//这里直接传入变量名，因为函数定义的是引用，而且在func2里面改变dat2的值，b的值也是随之改变

func3(b);//在这个函数里，会生成一个b的副本，也就是dat3，可以这么理解，dat3就是b的完整拷贝

从上述代码的最后两行也能看出来，按值传递和引用传值光从调用上是区分不开的，只能看函数的定义来区分

PyQt5中line_edit控件不能输入中文

Fri, 12 Oct 2018 00:00:00 +0000

在用PyQt5写界面的时候，测试的时候发现选中line_edit时，输入法不能切换到中文，即不能在line_edit中输入中文，之前在windows平台上开发的时候并没有出现此问题，所以怀疑是qt对ubuntu下的输入法不支持。

解决方法

原因： PyQt5的包缺少一个动态链接库
找到链接库： /usr/lib/x86_64-linux-gnu/qt5/plugins/platforminputcontexts/libfcitxplatforminputcontextplugin.so
将上述链接库复制到PyQt5包所在目录： 一般包的位置在/usr/local/lib/python3.5/dist-packages下，但我的不是在这里，而是在home目录下的一个叫做.local的隐藏文件夹里，而且我后面安装的包都在这里。通过pip show package-name命令可以查看包的详细安装路径。则你需要将链接库libfcitxplatforminputcontextplugin.so复制到your_PyQt5_path/Qt/plugins/platforminputcontexts/目录下即可
重新运行软件即可在line_edit中输入中文

CUDA编程入门

Wed, 10 Oct 2018 00:00:00 +0000

感觉熟悉并行计算也是比较有竞争力的一项能力，且不说这个的应用场景还非常广泛，只要部署平台有显卡，只要有程序的地方，基本都可以考虑进行并行优化，可见它的应用还是听广泛的，并且现在支持cuda编程的语言也在增加，相信CUDA将会是以后GPU编程的主要框架。最近听说按摩店的新显卡也要支持CUDA了

GPU计算架构一览

简单的画一幅图来说明一下GPU的基本计算架构以及相关专有名词。

thread

在硬件上对应SP（Streaming Processor），流处理器，是运行程序的最小单位，cuda程序的并行计算具体体现在大量的SP并行运行指令。

block

在硬件上对应SM（Streaming Multi-Processor），流处理器簇，程序中定义的block也是运行在SM上的，它里面包含了一组SP，具体数量视GPU的架构和型号而定，例如：GTX 1070 一个block最多可容纳1024个thread，共有15个SM，1920个SP（也就是CUDA core），每个SM最多运行2048个SP，例如：你定义每个block有256个thread，那么在实际硬件中，每个SM上最多有8个block

grid

这个其实还是block层面的划分，当一些block正在运行同一个程序时，这堆block可以被划分为一个grid

小结：

thread、block和grid是在软件层面的定义，在硬件的层面，实际执行的“机构”是SP和SM，这点一定要熟记于心，比如在GTX 1070上，你会发现硬件上只有1920个核心，在程序中你却可以定义核函数使用上万个thread，也就是说硬件会把你程序定义的众多thread进行分配，分多次完成，也正是这一机制，使cuda核心可以指数级的扩展
在实际执行的时候，调度器并不是具体去调度每个SP，而是让少量SP形成一个warp，可以有效地隐藏指令执行的延迟，一般为32个，即每32个SP组成一组，调度和执行的基本单位为warp，存储器操作的基本单位为half-warp（~~即half_warp个SP执行的存储器读取或写入指令会被合并，有效的避免了内存操作产生的延迟~~，更新：在计算能力2.x以上的设备，存储器调度的单位也是warp）

register

这个是寄存器文件，供SP去访问，储存了SP内部活跃的寄存器

local memory

供SP使用的内部存储空间

共享存储空间，是每个SM内部的SP共用一份，不同的SM有不同的share memory

global memory、constant memory、texture memory

global memory就是全局内存，共多个SM进行访问，constant memory、texture memory都是针对global memory建立的特殊视图，constant memory用于存储一些只读的数据，texture memory用来存储插值计算需要的数据。

小结：

GPU上的存储器均为DRAM，这就说明连续存取数据是效率最高的方式

未完待续

Keras[2]-模型保存与加载

Tue, 02 Oct 2018 00:00:00 +0000

这篇文章记录了keras中常用的四种模型保存和加载，包括h5（常用）、json和yaml、pb（这种模式我知道的在tensorflow和 opencv中可以直接读取）。

keras可以保存的模型种类

h5：此格式需要python提前安装h5py库，sudo pip install h5py
json
yaml
pb

几种文件格式的区别

h5

我们可以将网络结构和权重一起保存为.h5文件，另外还包括模型训练时的配置（包括损失函数、优化器等），以及优化器的状态，比如优化器中变化的参数的状态等，优点是：操作非常方便，代码很少，缺点是：占用空间较大

model.save('my_model.h5') #用于保存模型

model = load_model('my_model.h5') #用于加载模型

当然，我们也可以单独将网络的权重保存为.h5文件，并不保存结构。

#只保存了网络的权重
model.save_weights('my_model_weights.h5') 

#将网络初始化
...

#加载权重到搭建的网络
model.load_weights('my_model_weights.h5')

json和yaml

一般只保存网络的结构，并不保存权重，配合save_weights和load_weights使用

import json
import yaml

json_model = model.to_json() #将网络结构保存为json字符串
open('model.json', 'w').write(json_model) #写入json文件

# yaml_model = model.to_yaml() #将网络结构保存为yaml字符串
# open('model.yaml', 'w').write(yaml_model) #写入yaml文件

model.save_weights('my_model_weights.h5') #单独保存权重参数

from keras.models import model_from_json，model_from_yaml
#从文件中加载网络结构
json_model = model_from_json(open('model.json').read()) 

# yaml_model = model_from_yaml(open('model.yaml').read())

#单独加载权重参数
model.load_weights('my_model_weights.h5') 

pb

pb格式的文件里是保存了网络的结构和权重的，方便tensorflow和opencv调用。

#1、定义网络结构
model = ...

#2、输出节点名称，用于查看output_node_names
for layer in model.layers:
    print(layer.output.name)
    
#3、生成pb格式的模型
sess = K.get_session() #获得当前的sess

#这个是将模型的结构和权重固化，注意第二步输出的节点名称形式为dense_1/Softmax:0，但是这里传入时需要将:0删除，不然会提示找不到tensor，不太清楚原因，之前用tensorflow时是需要写全的
frozen_def = tf.graph_util.convert_variables_to_constants(sess,sess.graph.as_graph_def(),output_node_names=['dense_1/Softmax']) 

tf.train.write_graph(frozen_def, './', 'test_model.pb', as_text=False) #将网络的结构和权重写进pb文件中


#4、在tensorflow中使用pb模型
with tf.Graph().as_default():
    output_graph_def = tf.GraphDef()
    
    with open('test_model.pb', "rb") as f: #打开pb模型文件
        output_graph_def.ParseFromString(f.read()) #进行解析
        _ = tf.import_graph_def(output_graph_def, name="")
        
    with tf.Session() as sess: #下面就是使用模型
        sess.run(tf.global_variables_initializer()) 
        #下面的input_1:0和dense_1/Softmax:0都是通过步骤2查看的
        #然而这里节点名称却带了:0，我猜测是keras的graph中保存的节点名是不包含:0的，当你选择保存为pb格式时，此时注意我们是使用tensorflow的形式进行保存的，所以又都被加上了:0，当你读取的时候自然也要加上:0
        input_x = sess.graph.get_tensor_by_name("input_1:0")
        output = sess.graph.get_tensor_by_name("dense_1/Softmax:0")
        print(sess.run(output, feed_dict={input_x: img}))

Keras[1]-图像预处理

Tue, 02 Oct 2018 00:00:00 +0000

这篇文章主要介绍了keras中的图像生成器ImageDataGenerator的用法，详细介绍了每个参数什么意思，哪些参数比较常用，这个函数也是工程中一般都会用的。

ImageDataGenerator

位于from tensorflow.keras.preprocessing.image import ImageDataGenerator

参数介绍：

featurewise_center：使输入的均值为0，这个是以整个数据集的分布来处理的，所以变换后整体变化不大
samplewise_center：使每个样本的均值为0，这个是针对每幅图片进行的，处理后的图像与原图差别很大
featurewise_std_normalization：输入除以自身标准差
samplewise_std_normalization：每个样本除以自身标准差
zca_epsilon：ZCA白化中的epsilon参数，默认为1e-6
zca_whitening：是否开启ZCA白化，取出图像颜色的冗余信息
rotation_range：随机旋转的角度范围，整型，范围为[0，target]
width_shift_range：图像水平偏移的范围
height_shift_range：图像垂直偏移的范围，这两个一般不用
brightness_range：亮度变化范围，包含两个浮点型的tuple或者list#旋转
shear_range：错切变换，保持所有点的x坐标(或者y坐标)保持不变，而对应的y坐标(或者x坐标)则按比例发生平移，且平移的大小和该点到x轴(或y轴)的垂直距离成正比，效果像是图像被拉伸
zoom_range：让图片在长或宽的方向进行放大，可以理解为某方向的resize，参数大于0小于1时，执行的是放大操作，当参数大于1时，执行的是缩小操作
channel_shift_range：随机的通道偏移
fill_mode：填充模式，”constant”, “nearest”, “reflect” or “wrap”，默认是”nearest”，比如在旋转时，超出尺寸的部分会怎么处理
cval：填充的值，只有在fill_mode = "constant"时才有作用
horizontal_flip：随机水平翻转
vertical_flip：随机垂直翻转
rescale：缩放因子，会乘在像素值上，默认是None
preprocessing_function：自定义的处理函数，在其它预处理方法之后运行
data_format：这个设置的是通道的模式，有channels_first和channels_last两种
validation_split：生成验证集的比例（在0和1之间）
dtype：制定生成的数据格式

flow_from_directory，只介绍一般情况下用到的参数

directory：数据的路径，要求：将数据分为train和test两个文件夹，每个文件夹下每一类别再存放进一个子文件夹
target_size：读取的每个图片都会resize到这个尺寸
color_mode：默认rgb，一般不改变
classes：识别的类别名称，类似于[“dog”,”cat”,”fish”]，训练和测试要一致
class_mode：分类模式，默认是categorical，表示多分类
batch_size：一批的大小
shuffle：是否打乱数据，这个是必须的，默认为True
seed：随机操作的随机种子

例子

train_generator = ImageDataGenerator(rotation_range=5, #旋转
                                     horizontal_flip=True, #翻转
                                     vertical_flip=True)
test_generator = ImageDataGenerator()#一般情况下，测试图像不做增强


train_generator = train_generator.flow_from_directory('./re/train/',
                                                      target_size=(144,144),
                                                      batch_size=32,
                                                      classes=['bus','dinosaurs','elephants','flowers','horse']) #注意这里的classes貌似必须要声明，但是源码里说的是，不声明时，安装目录下的文件夹名来当做class。就我测试而言，同样的程序，不显式定义classes的话，准确率在80，显然是不正常的，显式声明的话，就达到99，所以我猜测是train_generator和test_generator都是读取子文件夹的名称为类别名，估计是按照读取的顺序来确定类别顺序，这样的话，上下两个flow_from_directory得到的类别列表就有可能不一样
test_generator = test_generator.flow_from_directory('./re/test/',
                                                    target_size=(144,144),
                                                    batch_size=32,
                                                    classes=['bus', 'dinosaurs', 'elephants', 'flowers', 'horse'])
                                                    
#此处是在网络中使用数据，fit_generator是将数据一批一批的送往GPU
history_tl = model.fit_generator(train_generator,
                                 epochs=10,
                                 steps_per_epoch=400/32,
                                 validation_data=test_generator)

安装、编译踩坑

Mon, 01 Oct 2018 00:00:00 +0000

本篇文章长期更新，主要记录ubuntu上各种库和程序安装的问题，在此做几个集锦，一方面以后在遇到能够快速地找到解决方法，另一方面也分享给大家，避免重复踩坑。

OpenCV

编译期间提示：/home/××××/opencv-3.4.1/opencv_contrib/modules/rgbd/src/odometry.cpp:41:45: fatal error: unsupported/Eigen/MatrixFunctions: 没有那个文件或目录。解决方法：在复制Eigen文件夹时，没有连同eigen3文件夹下的unsupported子文件夹一起复制，正确目录为/usr/local/inclue/下有Eigen和unsupported两个文件夹。

CUDA

如果之前安装过cuda8.0，相信也安装过nvidia-cuda-toolkit，在命令nvcc -V下可以查看cuda的版本，当安装cuda9.0后，如果没有卸载nvidia-cuda-toolkit，会发现nvcc -V显示的版本仍然是7.5，可明明我装的是9.0，怎么回事？解决方法：安装cuda9.0后，在/usr/local/cuda/bin如果没有nvcc可执行程序，则表示安装就有问题，重新安装cuda，若有，先卸载nvidia-cuda-toolkit，suao apt-get autoremove nvidia-cuda-toolkit,再将/usr/local/cuda/bin加入环境变量即可，export PATH=$PATH:/usr/local/cuda/bin

Keras

在keras中的模型可视化功能里面，有一个函数是将网络拓扑结构生成为一个png图片文件，但是当运行的时候却提示ImportError: Failed to import pydot. You must install pydot and graphviz for “pydotprint” to work.，当你按照提示pip install pydot和graphviz时候，却还是报一样的错误。解决方法：sudo pip install pydot-ng和sudo apt-get install graphviz，通过这两条命令进行安装即可

Keras[0]

Mon, 01 Oct 2018 00:00:00 +0000

之前一直使用tensorflow，后面又用了tensorlayer，怎么说吧，虽然封装的越来越高级，但是总缺点什么东西，当遇到keras时，我发现了它的方便是有道理的，把一些实用的功能考虑到了，比如友好的数据增强，自适应学习率，简便的层定义，超方便的迁移学习，所以打算花费一点时间熟悉一下keras，毕竟这个年轻的库也越来越受开发者的青睐。

Keras中的网络层一览

核心层：这里我们只介绍计算机视觉中图像识别可能使用到的层

Dense：全连接层
Dropout：经典的dropout，但现在越来越少用了，理由可以自行查找，破坏分布，特别是网络前面有BN时
Activation：激活层，在一般的层中会有activation参数来设置激活函数类型
Flatten：展平层，将多维的数据展成一维，例如（3,3,12）-> （108,）
Reshape：类比numpy中的reshape，符合质量守恒定律，前后的数据量是不变的，当该层作为首层时，需要制定input_shape参数
```
model.add(Reshape((3, 4), input_shape=(12,)))
```
Permute：维度重排层
RepeatVector：将输入向量重复并形成新的一批数据，（None,32）- > （None,n,32）
Lambda：自定义函数层，可以对输入的数据进行任意表达式的运算

#第一种：就是对输入数据平方
model.add(Lambda(lambda x: x ** 2))
#第二种：定义更复杂的函数
def antirectifier(x):
    x -= K.mean(x, axis=1, keepdims=True)
    x = K.l2_normalize(x, axis=1)
    pos = K.relu(x)
    neg = K.relu(-x)
    return K.concatenate([pos, neg], axis=1)
    
model.add(Lambda(antirectifier))#当使用tensorflow时，output_shape可自动推断

ActivityRegularizer：目前不清楚有什么作用，文档介绍为：经过本层的数据不会有任何变化，但会基于其激活值更新损失函数值
Masking：是RNN中的用法，暂不做介绍，文档中的介绍为：使用给定的值对输入的序列信号进行“屏蔽”，用以定位需要跳过的时间步

卷积层

Conv1D：一维滤波，有点像时域上的信号卷积
Conv2D：我们熟悉的CNN中常用的卷积层，二维卷积操作，注意：激活函数不设置默认为恒等变换
SeparableConv2D：高效的深度可分离卷积，将传统卷积分为两步走，巧妙的减少了参数，和Conv2D参数设置一致
Conv2DTranspose：转置的卷积操作（反卷积）
Conv3D：三维卷积操作，暂时没有用到
Cropping1D：对一维的数据进行裁剪
Cropping2D：对二维图像在长和宽上进行裁剪
Cropping3D：暂不清楚
UpSampling1D：上采样层
UpSampling2D：类比同上
UpSampling3D：类比同上
ZeroPadding1D：在一维上进行0填充
ZeroPadding2D：类比同上
ZeroPadding3D：类比同上
MaxPooling1D：一维信号上的最大池化
MaxPooling2D：池化在CNN发展初期很重要的一种层，但是在后期被卷积层逐步替代（strides为2的卷积操作也能降低特征图尺寸，增大特征的感受野，也能学习出类似最大池化的计算形式，但是池化层的计算效率是比卷积高效很多的，就目前来说。）
MaxPooling3D：对三维信号进行池化操作
AveragePooling1D：平均池化，同上
AveragePooling2D：平均池化，同上
AveragePooling3D：平均池化，同上
GlobalMaxPooling1D：全局最大池化
GlobalMaxPooling2D：这个是现在流行起来的使用GAP或者GMP来代替全连接层，将每一单幅的特征图直接输出为一个值，要么是整张特征图的最大值要么是平均值，听说一片论文还做了实验，通过热图之类的图像，说明了全局池化可以帮助定位到识别的物体。
GlobalAveragePooling1D：全局平均池化，同上
GlobalAveragePooling2D：全局平均池化，同上

融合层：首字母小写后的函数即为他们对应封装，比如Add对应的就是add

Add：顾名思义就是将多个tensor进行相加，输出shape不变（毋庸置疑），注意：接收的参数是一个列表[x1,x2,…]
SubStract：输出的是两个tensor的差，输出shape不变，注意：接收的参数是一个列表[x1,x2,…]
Multiply：接收一个列表，返回他们对应位置的乘积
Average：接收一个列表，返回对应位置上的均值
Maximum：接收一个列表，返回对应位置上的最大值
Concatenate：接收一个列表，按照指定的维度进行拼接
Dot：两个矩阵的张量乘积，注意里面的正则化参数。

高级激活层

LeakyReLU：修正线性整流函数，是relu的修正版，relu在网络层的输出值在负值时，是出于死亡状态的，这对网络的性能是不利的，LeakyReLU正好抓住了这一点，在输出小于0时，仍会有输出值，公式为：f(x)=alpha*x when x<0，其中alpha为认为设置的参数
PReLU：参数化的relu函数，公式和LeakyReLU差不多，但是它的alpha是可以学习的
ELU：指数线性单元，f(x) = alpha * (exp(x) - 1.) when x < 0
ThresholdedReLU：带有门限的激活函数，没用过，f(x) = x when x > theta, f(x) = 0 otherwise

批规范化层

BatchNormalization：该层在每个batch上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1，注意：其中的center参数要设置为True。一般来说，偏置是单独加在BN层中的。

Keras中的网络配置一览

初始化方法

一般来说，权重的初始化为kernel_initializer，偏置的初始化为bias_initializer，后面既可以跟具体的函数名，如：kernel_initializer=initializers.random_normal(stddev=0.01)，可以跟预定义的字符串，如：kernel_initializer='random_normal')，但是区别已经很显而易见了，使用具体的函数时可以设置参数。

Zeros：全0初始化
Ones：全1初始化
Constant：初始化为固定值
RandomNormal：正态分布初始化，当然需要设置均值和方差
RandomUniform：均匀分布
TruncatedNormal：截断的正态分布，位于两个标准差之外会被舍弃，该方法在之前是网络的标准初始化方式
VarianceScaling：当scale为2.0时，即为he_normal
Orthogonal：随机正交矩阵进行初始化，暂时没用到过
Identiy：单位矩阵初始化，暂时没用到过
lecun_uniform：[-limit, limit]的区间中均匀采样，其中limit=sqrt(3/fan_in)
lecun_normal：由0均值，标准差为stddev = sqrt(1 / fan_in)的正态分布产生
glorot_normal：就是Xavier正态分布初始化，与sigmoid函数配合使用
he_normal：名的Kaiming初始化，和relu搭配之用效果更佳，它是一种自适应的初始化方法，根据输入和输出神经元的个数来决定截断正态分布的方差，可配置为三种模式：fan_in，fan_out,fan_avg，推导

激活函数

Keras中可以使用单独的激活层，也可以在网络层中传递activation参数来实现

softmax
relu
tanh
sigmoid
hard_sigmoid
linear
elu
selu：可伸缩的指数线性单元
softplus
softsign

正则项

kernel_regularizer：施加在权重上的惩罚项
bias_regularizer：施加在偏置上的惩罚项
activity_regularizer：施加在输出上的惩罚项，这个没用过

损失函数

mean_squared_error或mse
mean_absolute_error或mae
mean_absolute_percentage_error或mape
mean_squared_logarithmic_error或msle
squared_hinge
hinge
categorical_hinge
binary_crossentropy
logcosh
categorical_crossentropy：softmax交叉熵损失函数，标签为one_hot类型，可用

from keras.utils.np_utils import to_categorical

categorical_labels = to_categorical(int_labels, num_classes=None)

sparse_categorical_crossentrop
kullback_leibler_divergence：预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异
poisson
cosine_proximity：预测值与真实标签的余弦距离平均值的相反数

优化算法

SGD：随机梯度下降法
RMSprop：常用在递归神经网络中，建议除学习率外，其他参数保持默认
Adagrad：保持默认参数
Adadelta：保持默认参数
Adam：比较常用的优化器，保持默认参数
Adamax：Adamax优化器来自于Adam的论文的Section7，该方法是基于无穷范数的Adam方法的变体
Nadam：Adam本质上像是带有动量项的RMSprop，Nadam就是带有Nesterov 动量的Adam RMSprop

性能评估

在compile我们常常还会设置一个参数metrics，它是用来制定评估方式。性能评估函数类似与目标函数, 只不过该性能的评估结果讲不会用于训练.

binary_accuracy：对二分类问题,计算在所有预测值上的平均正确率
categorical_accuracy：对多分类问题,计算再所有预测值上的平均正确率
top_k_categorical_accracy：计算top-k正确率,当预测值的前k个值中存在目标类别即认为预测正确，在一些比赛中会让你给出top-k的准确率

Keras中的预训练模型

模型的预训练权重将下载到~/.keras/models/，并在载入模型时自动载入

模型	大小	Top-1准确率	Top-5准确率	参数数目	深度
Xception	88MB	0.790	0.945	22,910,480	126
VGG16	528MB	0.715	0.901	138,357,544	23
VGG19	549MB	0.727	0.910	143,667,240	26
ResNet50	99MB	0.759	0.929	25,636,712	168
InceptionV3	92MB	0.788	0.944	23,851,784	159
MobileNet	17MB	0.665	0.871	4,253,864	88

Ubuntu下切换Python的版本

Sat, 29 Sep 2018 00:00:00 +0000

这篇文章也是一直躺在我的有道云笔记里面，最近又有人问我这个问题，就索性写在这里吧，但是随着官方对 python2版本不再维护，大家还是主要使用python3，不能把这个坑越挖越大，现在注意一点，利人利己。

Python2和Python3共存情况下的默认版本切换

第1种方法

切换默认版本为Python2

sudo update-alternatives --install /usr/bin/python python /usr/bin/python2 100

sudo update-alternatives --config python

切换默认版本为Python3

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3 150

sudo update-alternatives --config python

第二种方法

切换默认版本为Python2

#查看python版本
python --version
sudo rm /usr/local/bin/python
#将python2.x换成你的版本
sudo ln -s /usr/bin/python2.x /usr/local/bin/python

切换默认版本为Python3

#查看python版本
python3 --version
sudo rm /usr/local/bin/python
#将python3.x换成你的版本
sudo ln -s /usr/bin/python3.x /usr/local/bin/python

验证

最后在命令行输入python回车后会进入python编程环境，即可查看当前系统默认的Python版本。

卸载cuda8和cudnn6以及安装cuda9和cudnn7

Wed, 26 Sep 2018 00:00:00 +0000

我本来的环境是cuda8.0+cudnn6.0+driver384.130+tensorflow-gpu==1.4。真是逼着你升级，我已经坚持1.4很久了，但是很多新的特性不能用，无奈只能升级，不然的话谁愿意折腾，其中显卡驱动不需要变。

卸载cuda8.0及cudnn6.0

sudo apt-get remove cuda 

sudo apt-get autoclean

sudo apt-get remove cuda*

cd /usr/local/

sudo rm -r cuda-8.0

其实上面已经卸载完cuda和cudnn，用库方式配置过cudnn的都知道，cudnn只是一个头文件和一堆链接库，在cuda文件夹里，删除即可。

卸载nvidia-cuda-toolkit

sudo apt-get autoremove nvidia-cuda-toolkit

下载cuda9.0和cudnn7.1.4

下载需要nvidia开发者账号
下载链接：cuda9.0及cudnn7.1.4
其中cudnn选择cuDNN v7.1.4 Library for Linux下载，下来为压缩文件。

安装cuda9.0及cudnn7.1.4

cuda安装

sudo dpkg -i cuda-repo-ubuntu1604-9-0-local_9.0.176-1_amd64.deb 

sudo apt-key add /var/cuda-repo-9-0-local/7fa2af80.pub

sudo apt-get update

sudo apt-get install cuda

cuda环境变量设置

export PATH=/usr/local/cuda-9.0/bin${PATH:+:${PATH}}

#64位系统
export LD_LIBRARY_PATH=/usr/local/cuda-9.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

#32位系统
export LD_LIBRARY_PATH=/usr/local/cuda-9.0/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

cudnn安装

在~/Download目录下，解压下载cudnn文件夹

sudo cp cuda/include/cudnn.h /usr/local/cuda/include

sudo cp -a cuda/lib64/libcudnn* /usr/local/cuda/lib64

安装nvidia-cuda-toolkit (10月5号修正：此步骤不需要，详见安装、编译踩坑中的”nvcc -V显示版本和实际安装版本不一致”问题)

sudo apt-get install nvidia-cuda-toolkit

验证

nvcc -V #最后一行可显示cuda版本，可验证是否安装成功

cat /usr/local/cuda/version.txt #输出的是cuda版本，但只是验证版本，不代表安装一定成功

cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2 #从输出的宏定义可以查看cudnn的版本，只能验证版本，不代表安装成功

结语

/usr/local/cuda文件夹是安装cuda时安装的，我最开始一次的顺序是：卸载cuda8.0和cudnn6.0，安装cuda9.0和cudnn7.1，卸载nvidia-cuda-toolkit，在安装nvidia-cuda-toolkit，发现cuda/文件夹没了，尴尬，应该是卸载nvidia-cuda-toolkit时删掉了，所以要安装上文的顺序去卸载和安装，一般不会出错。

OpenCV4.0-pre更新日志

Mon, 24 Sep 2018 00:00:00 +0000

该版本发布于2018.09，是正式版本之前的一个过渡版本。我也没着急编译这个版本，等正式版出来之后再看看效果。

C++11

现在的OpenCV 4.0-pre使用了C++ 11库，所以需要编译器支持C++ 11，在之前的OpenCV 3.x版本，需要在cmake中使用-DENABLE_CXX11=ON手动开启，现在因为OpenCV主体就需要C++11，所以这个选项不需要手动开启，它默认就是支持的。

也正是因为支持C++11，之前OpenCV版本中的cv::String和cv::Ptr会被C++11标准中的str::string和str::shared_ptr代替。

DNN方面的改进

增加了对Mask-RCNN模型的支持，更多以及Python例程。
整合了ONNX 解析器，现在支持多种分类网络，而YOLO目前只能部分支持（因为YOLO所使用的ONNX版本对最后预测矩形框的层不太支持）。
当在编译的时候开启Intel DLDT 支持时，可以大大提升DNN模块的性能，
默认情况下，blobFromImage一族的函数不会交换red和blue通道，而且也不会对图像进行裁剪。

性能提升

大量的核心程序利用所谓的wide universal intrinsics进行重写，这些intrinsics映射到SSE2, SSE4, AVX2, NEON，VSX中的intrinsics函数，当然开不开启要取决于目标平台是否支持以及编译时候的flag设置。使用这一特性可以显著提升程序的性能，就算一些函数已经优化了，依然可以再提升其性能。如果你在OpenCV编译的时候配置CPU_BASELINE=AVX2，那么图像处理函数一般会得到15-30%的性能提升，在4.0正式版本中我们还将优化更多的函数来提升程序的性能。
二维码检测器已经整合进OpenCV中，我们也提供了例程，在正式版本中我们还会将二维码解码部分也整合进去，这样才是一个完整的解决方案，一家人整整齐齐。
Kinect Fusion也被整合进opencv_contrib/rgbd，在CPU和GPU(OpenCL)都经过了优化。将来Kinect 2 会在opencv/videoio中支持。

Opencv Github：更新日志

LeetCode链表反转(206-234)

Sun, 23 Sep 2018 00:00:00 +0000

这篇文章主要介绍了两个重要思想：1、怎样以一次就找到链表的中间节点。2、在空间复杂度为O(1)的情况下反转链表

进阶条件下，判断回文链表

题目链接，主要讲解进阶要求下的方法。

class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if not head or not head.next:
            return True
        
        p_fast = head
        p_slow = head
        
        while True:
            if not p_fast.next:
                break
            elif not p_fast.next.next:
                p_slow = p_slow.next
                break
            p_fast = p_fast.next.next
            p_slow = p_slow.next
        
        # get mid point
        p_slow = self.reverseList(p_slow)
        while p_slow:
            if head.val!=p_slow.val:
                return False
            head = head.next
            p_slow = p_slow.next
        return True
        
    def reverseList(self,head):
        new_head=None
        while head:
            _secend = head
            head = head.next
            _secend.next = new_head
            new_head = _secend
        return new_head

之前做过判断过数字是否为回文数，思路主要是找到中点，然后判断前半部分和后半部分的反转是否相等，或者正序遍历前半部分，逆序遍历后半部分，依次比对。现在在链表不能直接得到长度，所以采用快慢指针的思路找中点。

p_fast = head
p_slow = head
while True:
    if not p_fast.next:
        break
    elif not p_fast.next.next:
        p_slow = p_slow.next
        break
    p_fast = p_fast.next.next
    p_slow = p_slow.next

其中慢指针总是指向头部和快指针的中点，当遍历束时，慢指针刚好指向整个链表的中点，ok，那这里会有朋友问了，一般涉及中点，就要考虑两种情况，长度为偶数或奇数，当然我们这里考虑了，两个if判断就是将奇偶两种长度的链表区分开来，如果是偶数长度，则慢指针再往后移动一步，因为此时直接跳出的话，慢指针是停在中点左面的。如果是奇数长度，则直接跳出，此时慢指针已经指在中点了。

def reverseList(self,head):
    new_head=None
    while head:
        _secend = head
        head = head.next
        _secend.next = new_head
        new_head = _secend
    return new_head

链表反转题目链接

这里我们先介绍一下这个空间复杂度为O(1)的链表反转函数，我主要说一下思路，我刚开始时没想到，是百度之后才明白的。弹出新的头部指向上一次产生的头部，比如：链表为1->2->3，当前弹出1称为新的头部指向上一次的头部(此时储存上一次的头部的节点刚初始化为None)，下一次，弹出2为新的头部指向上一次的头部1，此时的链表为两个(原本的链表被断开了)：2->1->None和3。

# get mid point
p_slow = self.reverseList(p_slow)
while p_slow:
    if head.val!=p_slow.val:
        return False
    head = head.next
    p_slow = p_slow.next
return True

接着我们继续讨论回文判断，此时我们得到了中间节点，直接进行反转，然后以得到的反转链表为基准，进行遍历，只要对应位置的值都相等就返回True。

Python中双向链表的框架实现

Sat, 22 Sep 2018 00:00:00 +0000

这篇文章记录的是leetcode上的一道题目，从头实现一个链表，考察的比较全面，如果都实现处理，那么leetcode 上关于链表的简单类型题目应该秒懂。

Python中的链表

单向链表

|data|next| |:—:|:—:|

双向链表

|pre|data|next| |:—:|:—:|:—:|

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

双向链表实现

主要是在刷leetcode链表类题目时遇到的题目，感觉这样的题目挺不错的，考察的知识点比较系统，特此记录。

实现双向链表数据结构

class ListNode():
    def __init__(self,val):
        self.val = val
        self.next = None
        self.pre = None

链表类的主体结构

class MyLinkedList(object):

    def __init__(self):
        
    def get(self, index):
        
    def addAtHead(self, val):

    def addAtTail(self, val):

    def addAtIndex(self, index, val):    
          
    def deleteAtIndex(self, index):     
      
    def printList(self):

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
printList(self)：自己定义的，用来debug。

def __init__(self):
    """
    Initialize your data structure here.
    """
    self.start = None
    self.listLegth=0
    self.end = None

我这里定义了两个节点索引标识，用来指示链表的头部和尾部，另外还定义了一个链表长度变量，在查询、插入和删除时用来判断index是否有效。

def get(self, index):
    temp = self.start
    if index>=self.listLegth or self.listLegth==0:
        return -1
    for i in xrange(index):
        temp = temp.next
    return temp.val

这个函数是用来获取指定索引处的值，ok，那我们主要来讨论特殊情况：

index大于等于链表长度，那肯定是无效的，直接返回-1。
当前链表长度为0时，你查询肯定是无效的，直接返回-1。

def addAtHead(self, val):
    start = ListNode(val)
    start.next = self.start
    if self.start: #当之前没有头部时，不需要设置pre的指向
        self.start.pre = start
    start.pre = None
    self.start = start
    if not self.end:
        self.end = self.start
    self.listLegth+=1

这个函数是用来为链表头部增加一个节点，这里要注意一点的是，当你添加头部时，需要判断当前链表有没有尾部，如果没有，同时也要初始化尾部。为什么？因为只要你的链表有节点存在，那么头部和尾部一定也同时存在。这在添加尾部的函数里面一样需要注意这个问题。

def addAtTail(self, val):
    if not self.end:
        self.addAtHead(val)
    else:
        end = ListNode(val)
        self.end.next = end
        end.pre = self.end
        end.next = None
        self.end = end
        self.listLegth+=1

这里先判断self.end是否指向节点，其实就是判断链表是否为空，若为空，则直接调用self.addAtHead()，效果一样，若不为空，则添加新的尾部，注意这里的链表是双向链表，next和pre都需要设置。

def addAtIndex(self, index, val):
    if index==self.listLegth:
        self.addAtTail(val)
    elif self.listLegth==0 and index>=1:
        pass 
    elif index<self.listLegth:
        temp = self.start
        for i in xrange(index):
            temp = temp.next
        before = temp.pre
        new_list = ListNode(val)
        new_list.pre = before
        before.next = new_list
        new_list.next = temp
        temp.pre = new_list
        self.listLegth+=1

我们先考虑特殊情况：

如果index等于当前链表长度，则等同于添加一个尾部。
如果当前链表为空时，若index==0，相当于添加一个头部。
如果当前链表为空，index>=1，则是非法的，不做任何动作。

步骤很直观，先循环到需要添加的位置，生成一个新的节点，然后设置好新节点的pre和next属性就OK了。

def deleteAtIndex(self, index):
    if self.listLegth==0:
        pass
    elif index<self.listLegth:
        temp = self.start
        for i in xrange(index):
            temp = temp.next
        if not temp.next:
            temp.pre.next = None
            self.end = temp.pre
        elif not temp.pre:
            temp.next.pre = None
            self.start = temp.next
        else:
            temp.pre.next = temp.next
            temp.next.pre = temp.pre
        self.listLegth-=1

特殊情况：

当前链表为空时，不做动作。
index大于等于self.listLegth，此时不做动作。
当此时删除的节点为头部时，我们还要更新一下self.start。
当此时删除的节点为尾部时，我们还要更新一下self.end。

循环到制定的index处，断开需要删除的节点，将删除节点和前面和后面的节点进行连接，注意双向链表需要设置pre和next。

相关题目- 203. 删除链表中的节点，237. 删除链表中的节点

def printList(self):
    temp = self.start
    out_array=[]
    while temp:
        out_array.append(temp.val)
        temp = temp.next
    print(out_array)

从self.start遍历到self.end，将所有值储存在列表中，最后输出。

Python中函数传入的参数到底是值还是地址

Sat, 22 Sep 2018 00:00:00 +0000

Pyhton中函数传入的参数是变量值还是引用？说实话，在这之前还没考虑过，因为直接返回就行，也是因为Python的特性，变量可以指向任何类型的对象，所以就没太在意，等到遇到这道题后才发现是时候学习一下了。题目链接

Python中变量的特性

a = [1,2,3]  # type(a):list
a = (1,2,3) # type(a):tuple
a = 0 # type(a):int

直观上，一个变量可以随时的改变类型，这在C/C++中是不允许的。但是仔细探究Python语言的特性，变量可以看作是一个任何类型的特殊指针（当然在Python中是没有指针一说的，但是我们可以这样理解），它指向的对象没有限制，但是对象是确定的，即它本身可以是任何类型，但是对象的类型是固定的。

def test1(val):
    val[1]=0
    print('test1:'+str(id(val)))

b1=[0,1,2,3]
print('b1:'+str(id(b1)))
test1(b1)
print(b1)

Output：
	b1:2232273138760
	test1:2232273138760
	[0, 0, 2, 3]
	
def test2(val):
    val=[0,2,5]
    print('test2:'+str(id(val)))

b2=[0,1,2,3]
print('b2:'+str(id(b2)))
test2(b2)
print(b2)

Output：
	b2:2232273138824
	test2:2232273139144
	[0, 1, 2, 3]

下面着重结合上述的一个例子来讲述Python中函数的传值问题。

先看test1()函数，发现我们把b1传进去，然后对b1[1]进行操作，然后在主程序中输出发现，函数内和函数外操作的对象是同一个(看输出的两个id一样，就表示在内存中存储的位置一样)，这不禁让我想到C++中函数传入指针。
在看test2()函数，我们这次直接对b2进行重新赋值，按照上面的分析，按我们应该得到新的b2，但是结果却是大相径庭，id不一样，而且b2的内容没有变化，这是什么情况？

现在，我们综合分析一下，Python中函数的形参到底是什么？先说答案吧，传入的是变量指向的对象的地址。

test1()中，当b1传入函数后，现在我们b1指向[0,1,2,3]的首地址，而val也同样指向[0,1,2,3]的首地址，下面的操作实际上并并没有让val指向的地址发生改变，只是修改了[0,1,2,3]对应位置上的值，所以从头至尾，b1和val指向同一个对象，你修改了val指向对象对应位置的值，等同于修改了b1指向的对象对应位置的值。
test2()中，当b2传入函数后，b2和val同样指向相同对象的首地址，这个和上面一样，但是注意这里它是赋值操作，而这一操作改变了val指向的对象，本来val指向[0,1,2,3]，现在一赋值，它就指向了[0,2,5]的首地址，这样本次操作，包括后面对val的操作对不会影响b2，可以说正是赋值操作使val和b2脱离了关系。

所以说，函数中对参数做的实际操作，决定了你是改变形参指向的对象（test1()），还是改变新生成的传入参数的副本（test2()）。

LeetCode简单类型02(20-21-26-27-28)

Wed, 19 Sep 2018 00:00:00 +0000

这篇文章记录了leetcode上20.有效的括号、21.合并两个有序链表、26.删除排序数组中的重复项、27.移除元素、28.实现strStr()五道题目的答案和解析。

20、有效的括号

给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串，判断字符串是否有效。有效字符串需满足：1、左括号必须用相同类型的右括号闭合。2、左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。

python代码：

class Solution(object):
    def trans(self,t):
        if t=='(':
            return 1
        elif t==')':
            return -1
        elif t=='[':
            return 2
        elif t==']':
            return -2
        elif t=='{':
            return 3
        elif t=='}':
            return -3
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        len_s = len(s)
        if len_s%2!=0:
            return False
        if s=='':
            return True
        if self.trans(s[0])<0:
            return False
        left_s=''
        for i in xrange(len_s):
            if self.trans(s[i])>0:
                left_s+=s[i]
            elif self.trans(s[i])<0 and len(left_s)>=1:
                if self.trans(s[i])+self.trans(left_s[-1])==0:
                    if len(left_s)==1:
                        left_s=''
                    else:
                        left_s=left_s[:-1]
                else:
                    return False
            else:
                return False
        if left_s=='':
            return True
        else:
            return False

well，well，well，这个题目重点应该不再算法上，而是在编程实现上，思路很明确，就是左括号不能出现在对应右括号的右边，括号必须成对出现。

def trans(self,t):
    if t=='(':
        return 1
    elif t==')':
        return -1
    elif t=='[':
        return 2
    elif t==']':
        return -2
    elif t=='{':
        return 3
    elif t=='}':
        return -3

这个函数将字符转换为了数字，以便于判断是否配对问题，这个我感觉应该是最直观的方法吧，左括号为一个正数，右括号为负数，对应的相加刚好为0。

len_s = len(s)
if len_s%2!=0:
    return False
if s=='':
    return True
if self.trans(s[0])<0:
    return False

这里我考虑了三种特殊情况，1、长度不是偶数的话，那肯定至少有一组没有配对。2、根据题目要求。3、如果第一个括号为右括号的话，也是直接返回错误，因为违法了顺序规则。

for i in xrange(len_s):
    if self.trans(s[i])>0:
        left_s+=s[i]
    elif self.trans(s[i])<0 and len(left_s)>=1:
        if self.trans(s[i])+self.trans(left_s[-1])==0:
            if len(left_s)==1:
                left_s=''
            else:
                left_s=left_s[:-1]
        else:
            return False
    else:
        return False

ps：第一次提交这次题目时候写了一个有bug的程序，但是通过了，已经反馈到他们网站，这里是修正后的程序。

这段程序是算法的精髓，首先我们至少要把字符串遍历一遍，我们使用了一个新的字符串left_s用来保存左括号，意思就是我从头开始遍历s，遇到左括号就放进left_s，遇到右括号我先判断是不是和left_s最后面的是对应的，如果是那么就抵消，继续往后遍历，如果不对应，则结束。
这里还有点要注意的，之前的错误就是在if self.trans(s[i])+self.trans(left_s[-1])==0:时，没有提前判断left_s的长度，如果刚好在此时之前都成功配对，那么left_s='',也就是你在根据索引取值就要报错，但是网站没有此类测试数据。

21、合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

python程序：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        _rootNode=ListNode(0)
        rNode = _rootNode
        while l1 and l2:
            if l1.val<=l2.val:
                rNode.next = ListNode(l1.val)
                rNode = rNode.next
                l1 = l1.next
            else:
                rNode.next = ListNode(l2.val)
                rNode = rNode.next
                l2 = l2.next
        while l1:
            rNode.next = ListNode(l1.val)
            rNode = rNode.next
            l1 = l1.next
        while l2:
            rNode.next = ListNode(l2.val)
            rNode = rNode.next
            l2 = l2.next

        return _rootNode.next

这道题属于链表操作，最多需要遍历最长链表的长度。属于常规题目，但是链表的操作有一套定式，开始先声明头部，然而头部用两个变量来表示，因为链表的特性，你只能依次的回溯，不能直接跳到你想要的位置，所以用两个变量，一个只是在最后返回的时候用，一次则参与主要运算。

while l1 and l2:
    if l1.val<=l2.val:
        rNode.next = ListNode(l1.val)
        rNode = rNode.next
        l1 = l1.next
    else:
        rNode.next = ListNode(l2.val)
        rNode = rNode.next
        l2 = l2.next

第一个循环，是算法的第一部分，因为两个链表的长度不一定相同，则这个循环会在短链表结束时停止，说明合并工作已经完成大部分了，接下来只需要将长链表的剩余部分接在合并的链表后面就行了，思路就是谁的值小我就加进合并的链表。

while l1:
    rNode.next = ListNode(l1.val)
    rNode = rNode.next
    l1 = l1.next
while l2:
    rNode.next = ListNode(l2.val)
    rNode = rNode.next
    l2 = l2.next

这里就是上面所说的将长链表剩余的添加进合并链表里面，因为从上面我们并不能得知哪个链表长，所以两个都要检查。

26、删除排序数组中的重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

python程序：

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        len_nums = len(nums)
        if len_nums==0:
            return 0
        i=0
        for j in xrange(1,len_nums):
            if nums[i]==nums[j]:
                continue
            else:
                i+=1
                nums[i]=nums[j]
        return i+1

思路很常规，使用快慢指针，遍历一遍就可以。

len_nums = len(nums)
if len_nums==0:
    return 0

特殊情况处理，当给的字符串长度为0时，返回0。

i=0
for j in xrange(1,len_nums):
    if nums[i]==nums[j]:
        continue
    else:
        i+=1
        nums[i]=nums[j]

这一块是快慢指针的使用，i代表慢指针，j是快指针，快指针按照正常顺序遍历列表，慢指针指示不重复的元素的位置，快指针每次循环都会增加，慢指针只有在遇到不重复元素时才增加。

27、移除元素

给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

python代码：

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        len_nums = len(nums)
        if len_nums==0:
            return 0
        i=0
        for j in xrange(len_nums):
            if nums[j]==val:
                if j==len_nums-1:
                    return i
                continue
            else:
                nums[i]=nums[j]
                i+=1
        return i

这道题目仍是考察编程能力，思路很简单很直观。

len_nums = len(nums)
if len_nums==0:
    return 0

老样子，先把特殊情况搞定。

i=0
for j in xrange(len_nums):
    if nums[j]==val:
        if j==len_nums-1:
            return i
        continue
    else:
        nums[i]=nums[j]
        i+=1

继续运用快慢指针，这类题目让你就地进行操作的，感觉快慢指针是首选的方法。

28、实现strStr()

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

python代码：

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        len_hays = len(haystack)
        len_need = len(needle)
        if len_need==0:
            return 0
        for i in xrange(len_hays):
            if i+len_need>len_hays:
                return -1
            if haystack[i]==needle[0]:
                for k in xrange(len_need):
                    if haystack[i+k]!=needle[k]:
                        break
                    if k==len_need-1:
                        return i
        return -1

这道题比较常规，虽然是一次通过，但是花费时间有点长，主要是数组越界问题总是要想好一会，到底是总长还是总长-1。

len_hays = len(haystack)
len_need = len(needle)
if len_need==0:
    return 0

老规矩，既然题目中提示了，那就把needle长度为0的情况单独考虑。

for i in xrange(len_hays):
    if i+len_need>len_hays:
        return -1
    if haystack[i]==needle[0]:
        for k in xrange(len_need):
            if haystack[i+k]!=needle[k]:
                break
            if k==len_need-1:
                return i
return -1

我们把needle想象成图像处理里面模板匹配算法的模板，我们主体依旧是遍历haystack，每个元素都与needle[0]进行比较，只有相同了，才有继续往下谈的必要。假如haystack[i]与needle[0]相同了，那我们就进入循环，从i开始两个字符串依次进行比对，只要有不一样的，就结束，继续判断haystack[i+1]与needle[0]是否相同。其中没当进行新的迭代时，都要判断一下haystack剩余部分的长度是否小于needle的长度，若小于，直接结束，不可能匹配到，大于等于才继续。

LeetCode简单类型01(1-7-9-13-14)

Wed, 19 Sep 2018 00:00:00 +0000

这篇文章记录了leetcode上1.两数之和、7.反转整数、9.回文数、13.罗马数字转整数、14.最长公共前缀五道题目的答案和解析。

1、两数之和

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例：

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

python代码：

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        length = len(nums)
        rlist=[]
        if length==0:
            return False
        for i in xrange(length-1): # n
            #print(nums[i+1:length])
            if (target-nums[i]) in nums[i+1:length]:
                rlist.append(i)
                rlist.append(nums[i+1:length].index(target-nums[i])+i+1)
                return rlist

首先呢，这道题的考点在于算法，因为你可以暴力解决，但显然有更高效的方法，所以我们就要想办法不去一次又一次的遍历整个列表，如果过一遍就能找到答案？或者更少的遍历？

if length==0:
    return False

这是排除掉极端情况，给的列表为空的时候，这也是最容易忽视的，虽然对于整个算法来说不是那么复杂，不是那么重要，但是没有它，你的算法一定会出bug。

for i in xrange(length-1):

用来遍历整个数组，因为你要找到整个数组中符合要求的索引，那么最优算法的最坏情况就是遍历一遍。

if (target-nums[i]) in nums[i+1:length]:

这句是算法的精髓，我们从头开始遍历整个列表，遇到一个元素使用in来判断一下target-nums[i]是否在剩下的列表中nums[i+1:length]（想一下为什么是在剩余的列表中找，而不是在整个列表中），若没有，则可以肯定，当前的num[i]一定不是我们想要的，继续往后找，如果发现差值存在与列表的剩余部分，则现在我们已经找到了和为target的两个值，最后只需使用list.index(value),即可找到他们对应的索引。

rlist.append(i)
rlist.append(nums[i+1:length].index(target-nums[i])+i+1)

7、反转整数

给定一个 32 位有符号整数，将整数中的数字进行反转。假设我们的环境只能存储 32 位有符号整数，其数值范围是 [ − 2^31 , 2^31 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。

python代码：

class Solution(object):
    def __init__(self):
	    self.min_int = -pow(2,31)
        self.max_int = pow(2,31)-1
        self.maxint_10 = self.max_int//10
        self.maxint__10 = self.max_int%10
    def reverse(self, x):
        import sys
        """
        :type x: int
        :rtype: int
        """
        rSum = 0
        neg_flag=0
        if x==self.min_int:
	        return 0
        if x<0:
            x = -x
            neg_flag=1
        while(x!=0):
            a = x%10
            x = x//10
            if (rSum > self.maxint_10) or (rSum == self.maxint_10 and a>self.maxint__10):
                return 0
            else:
                rSum = rSum*10+a
        if neg_flag:
            rSum = -rSum
        return rSum

这道题重点不在算法，解法比较直观，考察了怎么判断变量值是否溢出，下面根据代码来梳理一下思路：

def __init__(self):
    self.min_int = -pow(2,31)
    self.max_int = pow(2,31)-1
    self.maxint_10 = self.max_int//10
    self.maxint__10 = self.max_int%10

这里我新添加了构造函数，用来生成几个频繁使用的大数，因为他们每一次循环都要使用，如果用的时候在计算浪费时间。

rSum = 0
neg_flag=0
if x==self.min_int:
	return 0
if x<0:
    x = -x
    neg_flag=1

这里为什么要进行最小值的判断呢？在下一段在解释，由于本题的极端情况就是溢出，所以在开始并不需要进行额外的判断，在这里我们要说明一点，也是比较坑爹的一点，关于C++和Python的不同：

c++: 
	int a = -123 % 10; // a = -3
	int b = -123 / 10; // b = -12

python:
	a = -123 % 10 # a = 7
	b = -123 % 10 # b = -13

知道以上区别后，我第一反应是赶紧把负数取反，当作正数来处理，但是你的正数的最大值是2^31-1，而最小值是-2^31，如果给你一个最小值，你直接取反，那就会溢出了，所以需要提前判断一下，若等于最小值，则直接判定为溢出。

while(x!=0):
    a = x%10
    x = x//10
    if (rSum > self.maxint_10) or (rSum == self.maxint_10 and a>self.maxint__10):
        return 0
    else:
        rSum = rSum*10+a

while里面的判断是整个解决方法中最精髓的地方，你要判断的数还不是一下就给你了，而是每循环一次增加着，这就会出现一个问题，你每次增加的时候不能判断是否溢出，只有你增加完后才能进行判断，这就需要我们进行超前判断，就是在溢出值之前就进行判断，提前预知是否可能会溢出。结合本题中数值增长的特点，我们取self.max_int//10做为判断点，如果当前值大于这个数，那么你的下一次增长一定溢出，如果等于，则需要再判断一下预增长的量是否大于self.max_int%10这个值，如果大于则还是会溢出，当上面都不满足的时候才进行增加。

if neg_flag:
    rSum = -rSum

最后，我们再将得到的数根据实际情况求相反数，毕竟我们是把所有数都当作正数处理了，最后还是要对应上的。

9、回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

进阶: 你能不将整数转为字符串来解决这个问题吗？

python代码：

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        str_x = str(x)
        if str_x[0]=='-':
            return False
        len_x = len(str_x) 
        if len_x==1:
            return True
        inv_x = str_x[len_x-1]
        for i in xrange(1,len_x//2):
            inv_x += str_x[len_x-1-i]
            
        if inv_x == str_x[:len_x//2]:
            return True
        else:
            return False

这个解决方法也有技巧，最直接方法是暴力遍历法，但是不可取，因为这种有规律性的问题，一般都有更高效率的方法，你想一下回文数，正反都一样，规律性很强。

str_x = str(x)
if str_x[0]=='-':
    return False
len_x = len(str_x) 
if len_x==1:
    return True

按照惯例，先把特征情况给解决了，首先，负数肯定不是回文数，因为它有负号，并且个位数（正数）一定是回文数，这个不需要过多解释了，一点就知道。

inv_x = str_x[len_x-1]
for i in xrange(1,len_x//2):
    inv_x += str_x[len_x-1-i]
if inv_x == str_x[:len_x//2]:
    return True
else:
    return False

这是算法的主要部分，排除完特殊情况，剩下的回文数中，假设一个数字是由a和b组成，其中a代表前半段，b代表后半段，如果数字的个数是奇数个，则中间剩余一个数字不用管。所以回文数符合 -b = a，其中-b表示b段的倒序，则我们只需要遍历整个数字长度的一半构造出-b就可以了。

13、罗马数字转整数

给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

python代码：

class Solution(object):
    def trans(self,r):
        if r=='I':
            return 1
        elif r=='V':
            return 5
        elif r=='X':
            return 10
        elif r=='L':
            return 50
        elif r=='C':
            return 100
        elif r=='D':
            return 500
        elif r=='M':
            return 1000
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        len_s = len(s)
        r_int = 0
        cur_t = 0
        next_t = 0
        i=0
        if len_s==1:
            return self.trans(s)
        while i<len_s:
            cur_t = self.trans(s[i])
            next_t = self.trans(s[i+1])
            if next_t>cur_t:
                r_int = r_int+next_t-cur_t
                i+=2
            else:
                r_int = r_int+cur_t
                i+=1
            if i==(len_s-1):
                r_int+=self.trans(s[i])
                break
        return r_int

这道题感觉不是靠算法的，就是逻辑测试，常规的思路结题。

def trans(self,r):
    if r=='I':
        return 1
    elif r=='V':
        return 5
    elif r=='X':
        return 10
    elif r=='L':
        return 50
    elif r=='C':
        return 100
    elif r=='D':
        return 500
    elif r=='M':
        return 1000

这个函数很直观，就是对于单独的一个罗马数字，通过这个函数找到对应的阿拉伯数字。

len_s = len(s)
if len_s==1:
    return self.trans(s)

首先判断特殊情况，字符串长度为1时，直接转换，不同考虑左置情况。

while i<len_s:
    cur_t = self.trans(s[i])
    next_t = self.trans(s[i+1])
    if next_t>cur_t:
        r_int = r_int+next_t-cur_t
        i+=2
    else:
        r_int = r_int+cur_t
        i+=1
    if i==(len_s-1):
        r_int+=self.trans(s[i])
        break

算法的精髓，最优情况肯定是只遍历一遍，就能得到结果，由于罗马数字向阿拉伯数字进行转换的时候存在左置问题，所以我们每次都需要同时考虑前后两个数。当前面的大于或者等于后面的，ok，当前的这个可以直接加了，没问题，因为左置情况中左面一定是小于右面，并将索引加1；当前面的小于后面时，就出现了左置情况，我们要根据定义，加上右面值和左面值的差值，然后索引加2。当遍历到最后一位时（如果最后两位是左置情况，索引会超出数字的长度），说明最后一位是单独的，此时需要特殊处理，因为不能再取它的后面一位了。

14、最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ““，所有输入只包含小写字母 a-z。

python代码：

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        
        #**********method-1**********
        # r_str = ''
        # for _ ,i in enumerate(zip(*strs)):
        #     if len(set(i))>1:
        #         return r_str
        #     else:
        #         r_str += i[0]
        # return r_str

		#**********method-2**********
        r_str=''
        if len(strs)==0:
            return r_str
        max_len = len(strs[0])
        for i in xrange(max_len):
            temp_str = strs[0][i]
            for item in strs:
                if i>=len(item) or temp_str!=item[i]:
                    return r_str
            r_str+=temp_str
        return r_str

这道题我的理解是属于考察编程能力的题，思路不难。我这实现了两种方法，其中第一种是用了特殊的函数，比较凑巧；第二种比较常规。

r_str = ''
for _ ,i in enumerate(zip(*strs)):
	if len(set(i))>1:
		return r_str
	else:
		r_str += i[0]
return r_str

这是第一种方法，使用了zip()和set()函数，其中zip(*list)表示将list中的每个元素拆分开，对应位置形成一个元组，并且按照最短元素的长度对其它元组进行截断，然后整个元组再形成列表，set()函数是去除给定元组中的重复值。

strs= ['flower','flow','flat']
zip(*strs):
	[('f','f','f'),
	('l','l','l'),
	('o','o','a'),
	('w','w','t')]

item = strs[0]
item:
	('f')

使用zip()函数很容易看出来，当item的长度等于1时，说明还处于公共前缀中，因为所有元素当前位置的元素都相等，只要不等于1，那就说明至少有一个是和其它不一样的，那么公共前缀也就到此为止了。

r_str=''
if len(strs)==0:
    return r_str
max_len = len(strs[0])
for i in xrange(max_len):
    temp_str = strs[0][i]
    for item in strs:
        if i>=len(item) or temp_str!=item[i]:
            return r_str
    r_str+=temp_str

第二种方法比较常规，首先考虑特殊情况，当输出的列表为空时，返回空列表。取第一个元素的长度为遍历范围，为什么？这样想，剩下的元素长度要么大于它，要么小于它，大于的就不考虑了，因为公共前缀最长是最短元素的长度。所以我们现在只要每遍历到一个元素就判断是不是它的最后一位，若是就直接结束，反之则继续。第一次取strs[0]的第一位字符，然后遍历剩余元素的第一位，只要遇到不相同的就退出u，如果都一样，则读取strs[0]的第二位字符，继续进行判断，直到遇到不相同的，或者strs[0]遍历完了，或者遇到了比strs[0]更短的元素，提前结束。

Python访问网页返回503错误

Tue, 18 Sep 2018 00:00:00 +0000

当我们使用python爬取网页时，经常会遇到503错误，这里简单分析了可能出现的情况，并给出解决方案

正文：

当请求网页返回：

Traceback (most recent call last):
  File "test.py", line 30, in <module>
    gethtml()
  File "test.py", line 13, in scanurl
    src = urllib2.urlopen(url).read()
  File "/usr/lib/python2.6/urllib2.py", line 126, in urlopen
    return _opener.open(url, data, timeout)
  File "/usr/lib/python2.6/urllib2.py", line 397, in open
    response = meth(req, response)
  File "/usr/lib/python2.6/urllib2.py", line 510, in http_response
    'http', request, response, code, msg, hdrs)
  File "/usr/lib/python2.6/urllib2.py", line 435, in error
    return self._call_chain(*args)
  File "/usr/lib/python2.6/urllib2.py", line 369, in _call_chain
    result = func(*args)
  File "/usr/lib/python2.6/urllib2.py", line 518, in http_error_default
    raise HTTPError(req.get_full_url(), code, msg, hdrs, fp)
urllib2.HTTPError: HTTP Error 503: Service Temporarily Unavailable

则原因有可能为一下两点：

若浏览器能打开响应网页，则是你的请求头header有问题，修改header。
若浏览器也打不开，则一般会有两种可能，第一种是对方服务器被动式拒绝服务，比如对方服务器瘫痪，网络问题等，一般很快会被修复。第二种主动式拒绝服务，有可能是因为你短时间内多次访问服务器（一般爬虫会遇到这个问题），这种情况就要看对方服务器的拉黑时间，像我，之前被拉黑过12小时的，所以你需要使用代理IP进行访问目标服务器。

Python中的中文问题

Tue, 18 Sep 2018 00:00:00 +0000

文章中说的两个问题都是新手经常遇到的，一个是注释包含中文会报错，一个是在图表中使用中文报错

1、文档编码中的中文错误问题：

这种错误一般会出现在程序中文注释时，运行程序会报错：

SyntaxError: Non-ASCII character ‘\xe4’ in file E:/Projects/pytext/test/test.py on line 8, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details

原因分析

在未指定utf-8编码时，文件里有非ASCII字符(即中文注释)，需要在第一行或第二行指定编码声明，目的是让python解释器按你指定的编码方式去保存文件，读取的时候就不会出项上述错误。

解决方法

三种方法任选一种即可,放在文档的开头

#-*- coding:utf-8 -*-
#encoding:utf-8
#coding:utf-8

2、matplotlib画图中文不能显示的问题：

解决方法

在程序开头添加以下程序：

from pylab import *
mpl.rcParams['font.sans-serif'] = ['SimHei']

效果

Python中正则表达式的学习记录

Tue, 18 Sep 2018 00:00:00 +0000

这篇文章记录了python中的正则匹配规则的相关语法，当然也不局限于python中，大部分是通用的，这些规则个人认为只需记住常用的两三个，当你真正大量使用的时候，再去查阅，完全ok，不要浪费时间苦恼怎么去记住那多么的匹配规则。

1、纯字符串匹配：

这一类是最简单的，也是字符串操作可以代替的，但是我们还是以这种匹配开始我们的教程，介绍正则的基本思想。

import re
str = "hello,everyone,I am HelloHaibo,thank u for watching my blog"
pattern = re.compile(r'Haibo')
content = re.findall(pattern,str)

content: ['Haibo']

说明在str中找到了我们需要的纯字符串，如果我把pattern = re.compile(r'Haibo')换成pattern = re.compile(r'haibo')，则会提示没有找到元素，说明匹配的内容与你事先定义的是要完全匹配的，区分大小写。

事实上述做法并没有太大意义(对于纯字符串正则匹配来说)，普通的字符串操作即可满足要求，并且可能更有效的解决问题。但是正则表达式的灵活性却是字符串操作不可比拟的，下面的几种匹配是我们常用的。

2、单字符匹配：

其实我们大多数时候并不知道我们匹配的字符具体是什么，我们只知道他们是属于那一类，像它属于数字啊，小写字母啊，特殊字符啊这样的，这样就需要我们正则表达式出马。我们来先看看单字符匹配。

第一种：单一个 .，匹配任何一个字符，但是除了\n（换行符）

import re
str = "hello,everyone,I am HelloHaibo,thank u for watching my blog"
pattern = re.compile(r'.ello')
content = re.findall(pattern,str)

content: ['hello', 'Hello']

说明 . 把H和h都匹配到了，其实就算字符串里存在这样的，fello、dello、8ello这样字符串，它也是能查找到的。但是一个 . 只匹配一个任意字符，想匹配多个任意字符就要写多个. 。

第二种: \d、\D, 其中\d匹配单一个纯数字，\D匹配除了数字之外的字符，两个集合刚好互为补集

import re
str2 = "1 + 2 = 3,yeah"
pattern = re.compile(r'\d')
content = re.findall(pattern,str2)

content: ['1', '2', '3']

可见\d把数字都匹配出来了，让我们再用\D匹配一下：

import re
str2 = "1 + 2 = 3,yeah"
pattern = re.compile(r'\D')
content = re.findall(pattern,str2)

content: [' ', '+', ' ', ' ', '=', ' ', ',', 'y', 'e', 'a', 'h']

可见，\D把除了数字以外的全部都匹配了。

第三种: \w \W，其中\w匹配字符a-z A-Z 0-9，\W反之

import re
str2 = "1 + 2 = 3,Yeah"
pattern = re.compile(r'\w')
content = re.findall(pattern,str2)

content: ['1', '2', '3', 'Y', 'e', 'a', 'h']

\w把字符串里的数字，小写字母，大写字母都匹配出来了。

import re
str2 = "1 + 2 = 3,Yeah"
pattern = re.compile(r'\W')
content = re.findall(pattern,str2)

content: [' ', '+', ' ', ' ', '=', ' ', ',']

\W把除了数字，小写字母，大写字母以外的都匹配出来了。

3、单字符匹配：

第一种: []方括号，代表字符集合

第二种: -连字符，标识一个范围（对应ASCII表）0-4，表示匹配，0 1 2 3 4，它需要跟[]配套使用。

import re
str2 = "1 + 2 = 3,yeah"
pattern = re.compile(r'[0-4]')
content = re.findall(pattern,str2)

content: ['1', '2', '3']

import re
str2 = "1 + 2 = 3,yeah"
pattern = re.compile(r'[a-z]')
content = re.findall(pattern,str2)

content: ['y', 'e', 'a', 'h']

第三种: * ? + 这三个字符用的几率非常大,下面分别举例说明一下。

* 匹配前一个字符零次或者无限次

import re
str1 = "http https httpes httpsss"
pattern = re.compile(r'https*')
content = re.findall(pattern,str1)

content: ['http', 'https', 'http', 'httpsss']

+ 表示匹配前面的字符一次或者无限次

import re
str1 = "http https httpes httpsss"
pattern = re.compile(r'https+')
content = re.findall(pattern,str1)

content: ['https', 'httpsss']

可以看出http没有被匹配上，因为s至少要匹配一次

? 表示匹配前一个字符零次或者一次

import re
str1 = "http https httpsss"
pattern = re.compile(r'https?')
content = re.findall(pattern,str1)

content: ['http', 'https', 'https']

结果怎么出现了两个https？可见，httpsss中的https部分也被匹配到了，这是我们不想遇到的，所以我们有时候需要规定匹配的次数，而并不是让算法自己无休止的匹配下去。

第四种：{m,n}匹配前一个字符m-n次，即m-n中的任意次数都行，包括m和n，将上述代码稍加修改。

import re
str1 = "http https httpsss"
pattern = re.compile(r'https{0,1}')
content = re.findall(pattern,str1)

content: ['http', 'https']

这样匹配的就是https或者http啦，当然{}里面也可以只有一个数字，那表示匹配前一个字符固定次数。

第五种：以上各种规则可以自由组合，形成功能强大的正则表达式。

import re
str1 = "hello,everyone,I am HelloHaibo,thank u for watching my blog"
pattern = re.compile(r'[Hh]ello')
content = re.findall(pattern,str1)

content: ['hello', 'Hello']

这个规则只匹配Hello或者hello，[ ]虽然表示一个集合，但是也是匹配单个字符的。

import re
str1 = "<h1>www.baidu.com</h1><h2>www.imooc.com</h2><span>tttt</span>"
pattern = re.compile(r'<h[\d]>www\.[a-zA-Z]+\.com</h[\d]>')
content = re.findall(pattern,str1)

content: ['<h1>www.baidu.com</h1>', '<h2>www.imooc.com</h2>']

我们来分析一下：外围的<h[\d]>和</h[\d]>表示匹配<h1></h1>或者h2、h3、h4这样的标签；www\.表示匹配www.那为什么要加一个\呢，因为 . 在正则表达式中已经有特殊意义了，如果你直接写www.他会匹配www后面跟一个任意字符，所以我们需要一个转义符号，来说明我们就想匹配 . 本身；[a-zA-Z]+要匹配a-zA-Z这些字符一次或者任意次；\.com表示匹配.com这个字符串，当然实际中要考虑网址的多样性，后缀的多样性等等。

4、断言匹配(这个里面的核心思想是判断):

(?<=...)和(?=...)两个分别称为后向匹配和前向匹配，它们判断是否成立，但是不参与匹配输出。

import re
str1 = "<h1>www.baidu.com</h1><h2>www.imooc.com</h2><span>tttt</span>"
pattern = re.compile(r'(?<=<h[\d]>)www\.[\w]+\.com(?=</h[\d]>)')
content = re.findall(pattern,str1)

content: ['www.baidu.com', 'www.imooc.com']

可以看到我把之前的<h[\d]>和</h[\d]>修改为(?<=<h[\d]>)和(?=</h[\d]>)，说明我要判断我要匹配的字符串开头是不是以<h1>、<h2>、<h3>….这样的标签开头，以</h1>、</h2>、</h3>…这样的标签结束，但是输出结果可以看出，并没有标签本身，只是把标签中间的内容输出，这在我们分析网页内容时候至关重要。

Jetson TX2刷机及安装TensorFlow gpu注意事项

Tue, 18 Sep 2018 00:00:00 +0000

这是在2017年12月份时候用TX2做目标跟踪时，搭建的深度学习系统，奈何TX2的运算能力还是不太够，就没在继续再使用这个平台了

正文：

新买的TX2建议直接刷机，不要用自带系统，刷机时安装jetpack中所有包。
刷机：当安装完系统镜像时，会提示你重启，先重启，再安装其他的包（cuda、cudnn等）(注意：将系统镜像那一项以上的都选为no action，只安装target board)。
等待安装完成后，开始安装tensorflow，采用编译安装，详见链接,该链接教程已实验成功，不过tensorflow版本为1.0。
推荐安装jupyter notebook。

注意事项：

编译前增加swap空间为8G。
测试程序记得配置session：

sess =tf.Session(config=tf.ConfigProto(log_device_placement=True,allow_soft_placement=True))

之前一直没设置 allow_soft_placement参数，导致没有成功使用gpu，根据官方doc说明，这个是当指定设备不可用时寻找替代设备的标志位，至于为什么这样就可以了，还不太清楚。

Github Pages绑定阿里云买的域名

Tue, 18 Sep 2018 00:00:00 +0000

使用Github Pages搭建完博客之后，总觉得用原始的域名太长了，又听说在阿里云注册新域名也挺便宜的，索性就买了一个域名，三年才五十多块，也不贵，本文记录了将新买的域名解析到Github Pages所在的IP。

1、购买域名

我是从阿里云购买的域名dasuda.top（其实haibo.lnk也挺便宜的），买了三年，花费55元，想着刚好硕士三年，等毕业后找到工作了，是不续费还是续费，到时候看这个域名的价值吧。

2、查看GithubPages的IP

有趣的是在这，按照网上99%的教程都是说在域名解析里面新建两条记录，记录类型为A，记录值为ping username.github.io查到的IP，但是当你连续ping的时候会发现，IP是不固定的，最后在Setting up an apex domain知道，GithubPages服务器现在的IP为4个：

199.108.153
199.109.153
199.110.153
199.111.153

所以以前的ping方法不适用了，至少没有直接查看Setting up an apex domain网页更方便、更准确了，那么域名解析里面的条目就需要添加8个。另外记录类型为CHAME，记录值为username.github.io，经测试不成功。

3、网站根目录CHAME文件设置

在网站根目录的CHAME文件（没有则新建一个）里面添加dasuda.top，整个文件就只需写进购买的域名即可。

第一个博客献给林小鱼同学

Mon, 17 Sep 2018 00:00:00 +0000

经过几天的查阅资料，我使用Github Pages+jekyll搭建了个人主页，博客主要用来记录学习过程，分享经验，每隔一段时间能够回顾自己的学习历程。

如果对本站的文章有疑问或者有合作需求，可以联系QQ: 827091497，或者发送邮件到：haibo.david@qq.com。