今天记录一下归一化(Normalization)、标准化(Standardization)与正则化(Regularization)。

归一化(Normalization)

归一化是特征缩放的一种形式，归一化是把数据压缩到一个区间内，比如$[0,1], [-1, 1]$。常用的方法有：

Rescaling:

$$ x' = \frac{x - min(x)}{max(x) - min(x)} $$

Mean normalization:

$$ x' = \frac{x - mean(x)}{max(x)-min(x)} $$

标准化(Standardization)

标准化，与归一化一样，也是特征缩放的一种形式。标准化是减去均值后再除以方差，公式如下：

$$ x'= \frac{x - \overline{x}}{\sigma} $$

需要注意的是，标准化之后的数据分布并不一定是正态分布，标准化并不会改变原始数据的分布。可以浏览一下这篇博客，这篇博客中有使用例子来说明，标准化，并不会改变它的分布。

拓展知识：z分数（z-score），也叫标准分数（standard score）是一个数与平均数的差再除以标准差的过程。 因此上面的标准化公式也被称为z-score标准化。

正则化(Regularization)

正则化是指为解决适定性问题或过拟合而加入额外信息的过程。常用的有L1正则化，L2正则化。这篇文章理解泛化能力、weight decay讲的比较好，它推理了了L2正则化就是权重衰减是怎么来的，而在知乎的另一个回答中，讲到了它们是不完全一样，一个改变了目标函数（损失函数），一个是体现在更新参数的过程。

其他的一些数据变换方式

数据变换方式很多，不同的数据变换有不同的用途。 Softmax、RELU、Sigmoid等等都是数据变换，不过用途不一样。

再宽泛一点讲，其实每一个函数（映射）都是一种变换方式，只是有一些函数（映射）常用于机器学习。

Q&A

这里综合了一下，下面两篇论文中我觉得不错的问题以及解释。

标准化和归一化，请勿混为一谈，透彻理解数据变换

【python数据预处理笔记】——特征缩放（标准化 & 归一化）

1. 为什么需要做标准化或者归一化？

   a. 目的是使其不同尺度之间的特征具有可比性，同时不改变原始数据的分布。例如$y=x_1+x_2+7$是一个简单的线性函数，如果$x_1$的尺度为$[0,1]$，$x_2$的尺度为$[0,10000]$，那么$x_2$的变动将会产生更大的影响。这个时候就要对特征进行缩放，也就是标准化或者规范化。简单来说就是让模型不会偏向于某一个特征。

   b. 参数估计时使用梯度下降，在使用梯度下降的方法求解最优化问题时，归一化/标准化后可以加快梯度下降的求解速度，即提升模型的收敛速度。

2. 哪些数据不能做特征缩放？

   稀疏数据不能进行特征缩放，因为特征缩放相当于对原数据进平移和缩放。而对于稀疏数据来说，数据中含有大量的0，一旦进行平移，那么稀疏特征将会变为密集特征，这会产生很大的影响，比如特征向量中包含没有在文章中出现的所有单词，那么当它变为密集向量的时候，特征的意义会发生巨大的改变。

3. 什么时候Standardization，什么时候Normalization？

   a. 如果对处理后的数据范围有严格要求，那肯定是归一化；

   b. 如果无从下手，可以直接使用标准化；

   c. 如果数据不稳定，存在极端的最大最小值，不要用归一化。

   d. 在分类、聚类算法中，需要使用距离来度量相似性的时候、或者使用PCA技术进行降维的时候，标准化表现更好；在不涉及距离度量、协方差计算的时候，可以使用归一化方法。

   PS：PCA中标准化表现更好的原因可以参考(PCA标准化)

4. 所有情况都应当Standardization或Normalization么?

   a. 当原始数据不同维度特征的尺度(量纲)不一致时，需要标准化步骤对数据进行标准化或归一化处理，反之则不需要进行数据标准化。

   b. 也不是所有的模型都需要做归一的，比如模型算法里面有没关于对距离的衡量，没有关于对变量间标准差的衡量。比如决策树，他采用算法里面没有涉及到任何和距离等有关的，所以在做决策树模型时，通常是不需要将变量做标准化的；

   c. 另外，概率模型不需要归一化，因为它们不关心变量的值，而是关心变量的分布和变量之间的条件概率。

参考链接

标准化和归一化什么区别？

标准化和归一化，请勿混为一谈，透彻理解数据变换

【python数据预处理笔记】——特征缩放（标准化 & 归一化）

Deep Learning-1.5 理解泛化能力、weight decay

权重衰减和L2正则化是一个意思吗？

前一段时间跑代码，而跑代码的人比较多，然后资源有限，需要抢占先机才行，然后就写了这段代码。

主要思路

执行命令行nvidia-smi -q -x，获取到命令行输出，解析xml，获取到GPU使用情况，判断是否有空闲GPU，发送邮件。

主要代码

下面主要给出执行命令行，以及解析返回结果代码，发送邮件仅给出之前的的一篇博客作为参考，参考:【折腾记录】定时获取成绩，新出一门成绩使用邮件提醒。

NVIDIA-SMI相关命令，参考NVIDIA-SMI系列命令总结。

解析xml，参考python 官方文档 xml.etree.ElementTree -- The ElementTree XML API

获取进程相关信息的包psutil (python system and process utilities)。

# references:
#     https://www.cnblogs.com/omgasw/p/10218180.html
#     https://docs.python.org/3/library/xml.etree.elementtree.html
#     https://psutil.readthedocs.io/en/latest/

import os
import psutil
import xml.etree.ElementTree as ET
import time
from pprint import pprint
from datetime import timedelta, datetime

def execute_command(command_str):
    p = os.popen(command_str)
    text = p.read()
    p.close()
    return text

# command_str = 'nvidia-smi dmon -c 1'
# pwr：功耗，temp：温度，sm：流处理器，mem：显存，enc：编码资源，dec：解码资源，mclk：显存频率，pclk：处理器频率
# # gpu   pwr  temp    sm   mem   enc   dec  mclk  pclk
# Idx     W     C     %     %     %     %   MHz   MHz
#     0   112    87    19     7     0     0  5005  1480
#     1   177    83    78     8     0     0  5005  1809
#     2    93    81    31    10     0     0  5005  1809
#     3   150    83    93    54     0     0  5005  1784

def get_process_info(pid):
    p = psutil.Process(pid)
#     print(p.as_dict())
    return p.as_dict()

def get_gpu_info():
    command_str = 'nvidia-smi -q -x'
    # 查询所有GPU的当前详细信息并将查询的信息以xml的形式输出
    gpus_info_dict = {}
    text = execute_command(command_str)
    root = ET.fromstring(text)
    for i, gpu_info in enumerate(root.findall('gpu')):
        gpu_info_dict = {}
        gpu_name = gpu_info.find('product_name').text
        fb_memory_usage = gpu_info.find('fb_memory_usage')
        total = fb_memory_usage.find('total').text
        used = fb_memory_usage.find('used').text
        free = fb_memory_usage.find('free').text
        rate = int(used.split(' ')[0]) / int(total.split(' ')[0])
        gpu_info_dict.update({'gpu name': gpu_name})
        gpu_info_dict.update({'memory usage':{'total': total, 'used': used, 'free': free}})
        gpu_info_dict.update({'gpu utilization':rate})

        processes = gpu_info.find('processes')
        processes_dict = {}
        for process_info in processes.findall('process_info'):
            pid = process_info.find('pid').text
            infos = get_process_info(int(pid))
            create_time = infos['create_time']
            current_time = time.time()
            time_difference = time.gmtime(current_time - create_time)
            run_time = f'{time_difference.tm_hour}h,{time_difference.tm_min}m,{time_difference.tm_sec}s'
            cmd_line = ' '.join(infos['cmdline'])
            processes_dict.update({'pid': pid, 'user name':infos['username'], 'cwd':infos['cwd'], 'cmd line':cmd_line, 'run time': run_time})
        gpus_info_dict.update({f'gpu:{i}':{'gpu info': gpu_info_dict, 'processes': processes_dict}})
    return gpus_info_dict

pprint(get_gpu_info())

网络优化主要介绍一些常用的优化算法、参数初始化方法、数据预处理方法、逐层归一化方法和超参数优化方法。

网络正则化主要介绍一些提高泛化能力的方法，包括$l_1$和$l_2$正则化、权重衰减、提前停止、丢弃法、数据增强和标签平滑。

1、网络优化

网络优化

网络优化是指寻找一个神经网络模型来使得经验（或结构）风险（损失）最小化的过程，包括模型选择以及参数学习等。深度神经网络是一个高度非线性的模型，它的损失函数是一个非凸函数，因此最小化损失是一个非凸优化问题．

鞍点（Saddle Point）与局部最小值（Local Minima）

在高维空间中，非凸优化的难点并不在于如何逃离局部最优点，而是如何逃离鞍点（鞍点示意图如下），鞍点的梯度是0，但是在一些维度上是最高点，在另一些维度上是最低点。相比鞍点，局部最小值要求在每一维度上都是最低点。

局部最小解的等价性

在非常大的神经网络中，大部分的局部最小解是等价的，它们在测试集上性能都比较相似。在训练神经网络时，我们通常没有必要找全局最小值，这反而可能导致过拟合。

神经网络优化的改善方法

目前比较有效的经验性改善方法通常分为以下几个方面：

1. 使用更有效的优化算法来提高梯度下降优化方法的效率和稳定性，比如动态学习率调整、梯度估计修正等。
2. 使用更好的参数初始化方法、数据预处理方法，来提高优化效率．
3. 修改网络结构来得到更好的优化地形（Optimization Landscape，好的优化地形即比较平滑的损失函数的曲面形状），比如使用ReLU 激活函数、残差连接、逐层归一化等。
4. 使用更好的超参数优化方法。

1.1、优化算法 - 梯度下降

目前，深度神经网络的参数学习主要是通过梯度下降法来寻找一组可以最小化结构风险的参数。在具体实现中，梯度下降法可以分为：

1. 批量梯度下降（Batch Gradient Descent，在更新参数时，使用所有的样本来进行更新。）
2. 随机梯度下降（Stochastic Gradient 是在更新参数时都使用一个样本来进行更新。）
3. 小批量梯度下降（Mini-batch Gradient Descent，是在更新参数时都使用一部分样本来进行更新。）

梯度下降公式

令$f(x;\theta)$表示一个深度神经网络，$\theta$为网络参数，在使用小批量梯度下降进行优化时，每次选取$K$个训练样本$S_t={(x(k), y(k))}^K_{k=1}$。第$t$次迭代（Iteration）时损失函数关于参数$\theta$的偏导数为

$$ G_t(\theta) = \frac{1}{K} \sum_{(x,y) \in S_t}\frac{\partial L(y, f(x;\theta))}{\partial \theta} $$

其中$L(\cdot)$为可微分的损失函数，$K$为批量大小（Batch Size）。

第$t$次更新的梯度${\rm g_t}$定义为

$$ {\rm g}t \triangleq G_t(\theta{t-1}) $$

更新参数，$\alpha(\alpha > 0)$为学习率。

$$ \theta_t \leftarrow \theta_{t-1}- \alpha {\rm g}_t $$

每次迭代时参数更新的差值$\Delta \theta_t$定义为

$$ \Delta \theta_t \triangleq \theta_t-\theta_{t-1} $$

$\Delta \theta_t$和梯度${\rm g_t}$并不需要完全一致（有时候会实际情况对梯度${\rm g_t}$进行调整）。$\Delta \theta_t$为每次迭代时参数的实际更新方向，即 $\theta_t = \theta_{t-1} + \Delta \theta_t$。在标准的小批量梯度下降中，$\Delta \theta_t = - \alpha {\rm g}_t$。

从上面公式可以看出，影响梯度下降法的主要因素有：

1. 批量大小$K$
2. 学习率$\alpha$
3. 梯度估计

1.1.1、*批量大小$K$*的选择

一般而言，批量大小不影响随机梯度的期望，但是会影响随机梯度的方差。批量大小越大，随机梯度的方差越小，引入的噪声也越小，训练也越稳定，因此可以设置较大的学习率；而批量大小较小时，需要设置较小的学习率，否则模型会不收敛。学习率通常要随着批量大小的增大而相应地增大。（可以使用线性缩放规则（Linear Scaling Rule），当批量大小增加$m$倍时，学习率也增加$m$倍。）根据GPU资源来设置批量$K$。

1.1.2、学习率$\alpha$调整

在梯度下降法中，学习率$\alpha$的取值非常关键，如果过大就不会收敛，如果过小则收敛速度太慢。

常用的学习率调整方法包括学习率衰减、学习率预热、周期性学习率调整以及一些自适应调整学习率的方法。

• 学习率衰减 常见的衰减方法有以下几种：
  1. 分段常数衰减（Piecewise Constant Decay），也称为阶梯衰减（Step Decay）
  2. 逆时衰减（Inverse Time Decay）
  3. 指数衰减（Exponential Decay）
  4. 自然指数衰减（Natural Exponential Decay）
  5. 余弦衰减（Cosine Decay）

• 学习率预热 在小批量梯度下降法中，当批量大小的设置比较大时，通常需要比较大的学习率．但在刚开始训练时，由于参数是随机初始化的，梯度往往也比较大，再加上比较大的初始学习率，会使得训练不稳定。为了提高训练稳定性，我们可以在最初几轮迭代时，采用比较小的学习率，等梯度下降到一定程度后再恢复到初始的学习率，这种方法称为学习率预热（Learning Rate Warmup）。

  常用的学习率预热方法是逐渐预热（Gradual Warmup），设定预热的迭代次数（作为分母，当前迭代次数作为分子），逐渐让学习率接近初始学习率，直到等于初始学习率。

• 周期性学习率调整

  两种常用的周期性调整学习率的方法：

  循环学习率，学习率在一个区间内周期性地增大和缩小。

  带热重启的随机梯度下降，学习率每间隔一定周期后重新初始化为某个预先设定值，然后逐渐衰减．每次重启后模型参数不是从头开始优化，而是从重启前的参数基础上继续优化。

• AdaGrad 算法

  AdaGrad 算法（Adaptive Gradient Algorithm）是借鉴 $L_2$正则化的思想，每次迭代时自适应地调整每个参数的学习率。每次迭代时，先计算每个参数梯度平方的累计值，将这个累计值开根作为分母，初始学习作为分子，从而实现学习率随着迭代次数的增加逐渐缩小。

  在AdaGrad 算法中，如果某个参数的偏导数累积比较大，其学习率相对较小；相反，如果其偏导数累积较小，其学习率相对较大．但整体是随着迭代次数的增加，学习率逐渐缩小。

  AdaGrad 算法的缺点是在经过一定次数的迭代依然没有找到最优点时，由于这时的学习率已经非常小，很难再继续找到最优点。

• RMSprop 算法

  RMSProp 算法和AdaGrad 算法的区别在于梯度平方的累计值的计算由加上了指数衰减，前面的梯度对当前的梯度影响逐渐变小，将其加起来来确定当前参数学习率。在迭代过程中，每个参数的学习率并不是呈衰减趋势，既可以变小也可以变大，这样可以在有些情况下避免AdaGrad算法中学习率不断单调下降以至于过早衰减的缺点。

• AdaDelta 算法 也是AdaGrad 算法的一个改进。使用RMSprop 算法同样的方式来调整学习率。此外，AdaDelta 算法将RMSprop 算法中的初始学习率$\alpha$改为动态计算的$\sqrt{\Delta X_{t-1}^2}$在一定程度上平抑了学习率的波动。

1.1.3、梯度估计修正

• 动量法

  动量（Momentum）是模拟物理中的概念。一个物体的动量指的是该物体在它运动方向上保持运动的趋势，是该物体的质量和速度的乘积．动量法（Momentum Method）是用之前积累动量来替代真正的梯度．每次迭代的梯度可以看作加速度。

  每个参数的实际更新差值取决于最近一段时间内梯度的加权平均值，当某个参数在最近一段时间内的梯度方向不一致时，其真实的参数更新幅度变小；相反，当在最近一段时间内的梯度方向都一致时，其真实的参数更新幅度变大，起到加速作用．一般而言，在迭代初期，梯度方向都比较一致，动量法会起到加速作用，可以更快地到达最优点．在迭代后期，梯度方向会不一致，在收敛值附近振荡，动量法会起到减速作用，增加稳定性。

  类似于RMSprop 算法，前面的梯度对当前的梯度影响逐渐变小，并将其加起来作为更新参数的梯度，而且参数更新对前一次迭代的参数有一个惯性（相当于初速度），而梯度相当于加速度。

• Nesterov 加速梯度

  Nesterov 加速梯度（Nesterov Accelerated Gradient，NAG）是一种对动量法的改进，也称为Nesterov 动量法（Nesterov Momentum）。

  Nesterov 加速梯度与动量法 思想是类似的，但是认为使用前一次迭代参数的梯度作为加速度是不太合理的，应该使用动量（惯性）移动到了的地方的加速度（偏导）来计算下一次迭代的参数（速度）。

• Adam 算法和Nadam 算法

  Adam算法（Adaptive Moment Estimation Algorithm）可以看作动量法和RMSprop 算法的结合。不但使用动量作为参数更新方向，而且可以自适应调整学习率。

  而Nadam 算法是Nesterov 加速梯度与RMSprop 算法的结合。

• 梯度截断

  为了避免梯度突然增大使得参数远离最优点，当梯度的模大于一定阈值时，就对梯度进行截断，称为梯度截断（Gradient Clipping）。

  梯度截断是一种比较简单的启发式方法，把梯度的模限定在一个区间，当梯度的模小于或大于这个区间时就进行截断．一般截断的方式有以下几种：

  *按值截断* ，给定一个区间$[a, b]$，如果一个参数的梯度小于$a$时，就将其设为$a$；如果大于$b$时，就将其设为$b$.
  
  *按模截断* ，给定的截断阈值$b$，当梯度的模小于等于$b$时，不改变梯度，当梯度的模大于$b$时，梯度等于$b$除以梯度的模再乘以梯度（将梯度的模缩放到$b$以内）。
  

  在训练循环神经网络时，按模截断是避免梯度爆炸问题的有效方法。

1.1.4、神经网络常用优化方法的汇总

不同优化方法的比较

1.2、参数初始化

当使用梯度下降法来进行优化网络参数时，参数初始值的选取十分关键，关系到网络的优化效率和泛化能力。参数初始化的方式通常有以下三种：

1. 预训练初始化：使用一个已经在大规模数据上训练过的模型提供参数初始值。
2. 随机初始化
3. 固定值初始化：对于一些特殊的参数，我们可以根据经验用一个特殊的固定值来进行初始化。

预训练初始化通常具有更好的收敛性和泛化性，但是灵活性不够，不能在目标任务上任意地调整网络结构，所以有时还是只能使用随机初始化方法来初始化参数。

1.2.1、三类常用的随机初始化方法

基于固定方差的参数初始化、基于方差缩放的参数初始化和正交初始化方法。

基于固定方差的参数初始化

随机初始化方法是从一个固定均值（通常为0）和方差$\sigma^2$的分布中采样来生成参数的初始值。基于固定方差的参数初始化方法主要有以下两种：

高斯分布初始化：使用一个高斯分布$N(0, \ \sigma^2)$对每个参数进行随机初始化。

均匀分布初始化：在一个给定的区间$[r, -r]$内采用均匀分布来初始化参数。

基于方差缩放的参数初始化

初始化一个深度网络时，为了缓解梯度消失或爆炸问题，我们尽可能保持每个神经元的输入和输出的方差一致，根据神经元的连接数量来自适应地调整初始化分布的方差，这类方法称为方差缩放（Variance Scaling）。

Xavier 初始化和He 初始化的具体设置情况，$M_{l-1}$和$M_l$分别为输入输出的神经元个数。

正交初始化

将权重矩阵初始化为正交矩阵的方法称为正交初始化（Orthogonal Initialization），正交初始化的具体实现过程可以分为两步：

1. 用均值为0、方差为1 的高斯分布初始化一个矩阵。
2. 将这个矩阵用奇异值分解得到两个正交矩阵，并使用其中之一作为权重矩阵。

1.3、数据预处理

如果一个机器学习算法在缩放全部或部分特征后不影响它的学习和预测，我们就称该算法具有尺度不变性（Scale Invariance）。尺度就是取值范围。

1.3.1、归一化

归一化（Normalization）方法泛指把数据特征转换为相同尺度的方法，比如

1. 最小最大值归一化（Min-Max Normalization）把数据特征映射到[0, 1] 或[−1, 1] 区间内。

2. 标准化（Standardization）也叫Z 值归一化（Z-Score Normalization）把数据特征映射为服从均值为0、方差为1的标准正态分布。

1.3.2、白化

白化（Whitening）是一种重要的预处理方法，用来降低输入数据特征之间的冗余性．输入数据经过白化处理后，特征之间相关性较低，并且所有特征具有相同的方差．白化的一个主要实现方式是使用**主成分分析（Principal Component Analysis，PCA）**方法去除掉各个成分之间的相关性。

标准归一化和PCA 白化的比较

1.4、逐层归一化

逐层归一化（Layer-wise Normalization）是对神经网络中隐藏层的输入进行归一化，从而使得网络更容易训练。

逐层归一化可以有效提高训练效率的原因：

1. 更好的尺度不变性，把每个神经层的输入分布都归一化为标准正态分布，可以使得每个神经层对其输入具有更好的尺度不变性。不论低层的参数如何变化，高层的输入保持相对稳定。另外，尺度不变性可以使得我们更加高效地进行参数初始化以及超参数的选择。
2. 更平滑的优化地形，逐层归一化一方面可以使得大部分神经层的输入处于不饱和区域，从而让梯度变大，避免梯度消失问题；另一方面还可以使得神经网络的优化地形（Optimization Landscape）更加平滑，以及使梯度变得更加稳定，从而允许我们使用更大的学习率，并提高收敛速度。

比较常用的逐层归一化方法：批量归一化、层归一化、权重归 一化和局部响应归一化。

1.4.1、批量归一化

批量归一化（Batch Normalization），对输出的张量（N, C, H, W），基于N x H x W个数值求均值和方差进行归一化。

1.4.2、层归一化

层归一化（Layer Normalization），对输出的张量（N, C, H, W），基于C x H x W个数值求均值和方差进行归一化。

1.4.3、实例归一化

实例归一化（Instance Normalization），对输出的张量（N, C, H, W），基于H x W个数值求均值和方差进行归一化。

1.4.4、分组归一化

分组归一化（Group Normalization），对输出的张量（N, C, H, W），基于G x H x W个数值求均值和方差进行归一化。

G是分组数，需要满足C可以整除G。

参考博客：An Overview of Normalization Methods in Deep Learning

1.4.5、权重归一化

权重归一化（Weight Normalization），是对权重或者说参数进行归一化。

1.4.5、局部响应归一化

局部响应归一化（Local Response Normalization，LRN）和层归一化都是对同层的神经元进行归一化．不同的是，局部响应归一化应用在激活函数之后，只是对邻近的神经元进行局部归一化，并且不减去均值。邻近的神经元指对应同样位置的邻近特征映射。

局部响应归一化和生物神经元中的侧抑制（lateral inhibition）现象比较类似，即活跃神经元对相邻神经元具有抑制作用。当使用ReLU 作为激活函数时，神经元的活性值是没有限制的，局部响应归一化可以起到平衡和约束作用。如果一个神经元的活性值非常大，那么和它邻近的神经元就近似地归一化为0，从而起到抑制作用，增强模型的泛化能力。最大汇聚也具有侧抑制作用．但最大汇聚是对同一个特征映射中的邻近位置中的神经元进行抑制，而局部响应归一化是对同一个位置的邻近特征映射中的神经元进行抑制．

1.5、超参数优化

常见的超参数有以下三类：

1. 网络结构，包括神经元之间的连接关系、层数、每层的神经元数量、激活函数的类型等。
2. 优化参数，包括优化方法、学习率、小批量的样本数量等。
3. 正则化系数。

超参数优化（Hyperparameter Optimization）主要存在两方面的困难：

1. 超参数优化是一个组合优化问题，无法像一般参数那样通过梯度下降方法来优化，也没有一种通用有效的优化方法；
2. 评估一组超参数配置（Configuration）的时间代价非常高，从而导致一些优化方法（比如演化算法（Evolution Algorithm））在超参数优化中难以应用。

对于超参数的配置，比较简单的方法有网格搜索、随机搜索、贝叶斯优化、动态资源分配和神经架构搜索。（都是搜索超参数的值的策略）

1.5.1、网格搜索

网格搜索（Grid Search）是一种通过尝试所有超参数的组合来寻址合适一组超参数配置的方法。假设有K个超参数，第K个超参数有可能合适的值$m_k$个。那么总共的配置组合数量为$m_1m_2 \dotsc * m_K$，每次尝试一组，最后选择最好的训练结果下对应的超参数值。

1.5.2、随机搜索

采用网格搜索会在不重要的超参数上进行不必要的尝试。一种在实践中比较有效的改进方法是对超参数进行随机组合，然后选取一个性能最好的配置，这就是随机搜索（Random Search）。

1.5.3、贝叶斯优化

贝叶斯优化（Bayesian optimization）是一种自适应的超参数优化方法。根据当前已经试验的超参数组合，来预测下一个可能带来最大收益的组合。

1.5.4、动态资源分配

在超参数优化中，每组超参数配置的评估代价比较高。如果我们可以在较早的阶段就估计出一组配置的效果会比较差，那么我们就可以中止这组配置的评估，将更多的资源留给其他配置。（相当于做一个提前停止（Early-Stopping））。

这个问题可以归结为多臂赌博机问题的一个泛化问题：最优臂问题（Best-Arm Problem），即在给定有限的机会次数下，如何玩这些赌博机并找到收益最大的臂。和多臂赌博机问题类似，最优臂问题也是在利用和探索之间找到最佳的平衡。

有一种策略是逐次减半（Successive Halving），我们可以通过$T= \lceil log_2(N) - 1 \rceil$轮逐次减半的方法来选取最优的配置，每次都选取一半最优资源，并固定住。

1.5.5、神经架构搜索

神经架构搜索，通过神经网络来自动实现网络架构的设计。利用元学习的思想，神经架构搜索利用一个控制器来生成另一个子网络的架构描述。控制器可以由一个循环神经网络来实现。控制器的训练可以通过强化学习来完成，其奖励信号为生成的子网络在开发集上的准确率。（用神经网络来自动实现网络架构）

2、网络正则化

正则化（Regularization）是一类通过限制模型复杂度，从而避免过拟合，提高泛化能力的方法。

在传统的机器学习中，提高泛化能力的方法主要是限制模型复杂度，比如采用$l1$和$l2$正则化等方式。而在训练深度神经网络时，特别是在过度参数化（Over-Parameterization）时，$l1$和$l2$正则化的效果往往不如浅层机器学习模型中显著。过度参数化是指模型参数的数量远远大于训练数据的数量。因此训练深度学习模型时，往往还会使用其他的正则化方法，比如数据增强、提前停止、丢弃法、集成法等。

2.1、$l1$和$l2$正则化

$l1$和$l2$正则化是机器学习中最常用的正则化方法，通过约束参数的$l1$和$l2$范数来减小模型在训练数据集上的过拟合现象。

同时加$l1$和$l2$正则化，称为弹性网络正则化（Elastic Net Regularization

2.2、权重衰减

权重衰减（Weight Decay），在每次参数更新时，引入一个衰减系数

$$ \theta_t \leftarrow (1 - \beta)\theta_{t-1} - \alpha {\rm g}_t $$

其中${\rm g}_t$为第$t$步更新时的梯度，$\alpha$为学习率，$\beta$为权重衰减系数，一般取值比较小，比如0.0005。

2.3、提前停止

提前停止（Early Stop），使用梯度下降法进行优化时，我们可以使用一个和训练集独立的样本集合，称为验证集（Validation Set），并用验证集上的错误来代替期望错误。当验证集上的错误率不再下降，就停止迭代。

2.4、丢弃法

当训练一个深度神经网络时， 我们可以随机丢弃一部分神经元（同时丢弃其对应的连接边）来避免过拟合，这种方法称为丢弃法（Dropout Method）

丢弃法一般是针对神经元进行随机丢弃，但是也可以扩展到对神经元之间的连接进行随机丢弃，或每一层进行随机丢弃。

在循环神经网络上的应用丢弃法，有两种方法：

1. 对非时间维度的连接（即非循环连接）进行随机丢失。
2. 对参数矩阵的每个元素进行随机丢弃，并在所有时刻都使用相同的丢弃掩码（丢弃掩码定义如下）。

掩蔽函数$mask(\cdot)$，

$$ mask(\cdot) = \begin{cases} m \odot x & 当训练阶段时 \ p x & 当测试阶段时 \end{cases} $$

$m \in {0, 1}^D$是丢弃掩码（Dropout Mask）,$p$为保留的概率。

2.5、数据增强

深度神经网络一般都需要大量的训练数据才能获得比较理想的效果．在数据量有限的情况下，可以通过数据增强（Data Augmentation）来增加数据量，提高模型鲁棒性，避免过拟合。

增强的方法主要有以下几种：

1. 旋转（Rotation）：将图像按顺时针或逆时针方向随机旋转一定角度。
2. 翻转（Flip）：将图像沿水平或垂直方法随机翻转一定角度。
3. 缩放（Zoom In/Out）：将图像放大或缩小一定比例。
4. 平移（Shift）：将图像沿水平或垂直方法平移一定步长。
5. 加噪声（Noise）：加入随机噪声。

2.6、标签平滑

在数据增强中，我们可以给样本特征加入随机噪声来避免过拟合．同样，我们也可以给样本的标签引入一定的噪声。假设训练数据集中有一些样本的标签是被错误标注的，那么最小化这些样本上的损失函数会导致过拟合。一种改善的正则化方法是标签平滑（Label Smoothing），即在输出标签中添加噪声来避免模型过拟合。

3、总结

提高深度神经网络训练效率的方法，通常分为以下3个方面：

1. 修改网络模型来得到更好的优化地形，比如使用逐层归一化、残差连接以及ReLU 激活函数等。
2. 使用更有效的优化算法，比如动态学习率以及梯度估计修 正等。
3. 使用更好的参数初始化方法。

提升深度神经网络的泛化能力，在传统机器学习模型上$l1$和$l2$正则化比较有效，而在深度神经网络中作用比较有限，而一些经验的做法（比如小的批量大小、大的学习率、提前停止、丢弃法、数据增强）会更有效。

先总结到这，开始实践了。

放弃shadowsocks的原因是：它经常更新，有时候一天一更，而我又有强迫症，它一更新我就想更新，不仅如此，共享的Apple ID也经常要换，每次更换ID之后，shadowsocks都需要重新下载，SSR订阅也需要更新添加，这个过程操作太多了，放弃了。

放弃了shadowsocks，需要一个新的替代方案，刚开始，我想的是自己编译shadowsocks，还没开始尝试，又在GitHub找到了一个提供了ipa文件的项目，Outline clients，这时问题又转移了，变成了如何安装ipa文件的问题，第一想法是使用爱思助手安装，可惜的是爱思助手还没有支持macOS Big Sur，我有需要转向其他方法，看到知乎的文章如何在手机上安装IPA? 讲四种方法！再也不怕应用下架了！，准备使用捷径来操作，而还没等操作，看到了去年玩捷径时的留下的TestFlight软件大全就执行了一下，这一执行，又发现了新大陆，其中有支持shadowsocks的app，不过人数都满了，我开始搜支持shadowsocks的app内测链接，然后搜到了这个TestFlight 邀请分享：iOS 应用 测试版收集清单，其中有十几个符合要求的应用，而且有一个potatso lite的测试人数没满，我开始了测试，很快，我就遇到了两个问题，订阅无法解析，而且还有广告，这时又有点忍不了了，开始又开始搜了起来，然后发现potatso lite是免费了，我登上了我美区的Apple ID，下载了并发现没有广告，虽然用其他方式也可以SSR连接信息，但是我还是开始研究订阅的问题。

订阅连接

通过ss和ssr链接解析，知道了shadowsocks链接是通过Base64进行编码的，尝试用Base64订阅连接返回结果，得到了许多SSR链接，中间以\n隔开，而其中SSR链接的编码方式是ss和ssr链接解析中说的方式，得到了SSR链接之后，使用potatso lite添加服务器，并不太方便，所以想着把它弄成二维码，而二维码图片太多也不好传文件，所以将它们保存到PDF中。

将SSR链接保存到二维码中

将信息存到二维码中，使用的是qrcode模块，简单易用。

import qrcode
img = qrcode.make('Some data here')

PDF将图片存到pdf文件中

通过poillow模块Convert Images to PDF using Python，简单示例如下。

from PIL import Image

image1 = Image.open(r'\Users\Ron\Desktop\Test\image1.png')
image2 = Image.open(r'\Users\Ron\Desktop\Test\image2.png')
image3 = Image.open(r'\Users\Ron\Desktop\Test\image3.png')

im1 = image1.convert('RGB')
im2 = image2.convert('RGB')
im3 = image3.convert('RGB')

imagelist = [im2, im3]

im1.save(r'\Users\Ron\Desktop\Test\myImages.pdf',save_all=True, append_images=imagelist)

其中save_all是必须等于True的

通过FPDF模块，简单示例如下。

from fpdf import FPDF

document = FPDF()
document.add_page()
document.set_font('Arial', size=12)
document.cell(w=0, txt="hello world")
document.output("hello_world.pdf")

pip安装来自Github的包

示例如下，参考链接为Using the Command Line to Install Packages from GitHub

GitHub链接：https://github.com/yourname/projectname

pip install git+git://github.com/yourname/projectname.git

完整代码

最简单的方式是解析好，放在腾讯服务器上。

import base64
import requests
from pprint import pprint
import pandas as pd
import qrcode
import os
from PIL import Image
from fpdf import FPDF

def fill_padding(base64_encode_str):

    need_padding = len(base64_encode_str) % 4 != 0
    if need_padding:
        missing_padding = 4 - need_padding
        base64_encode_str += '=' * missing_padding
    return base64_encode_str

def base64_decode(base64_encode_str):
    base64_encode_str = fill_padding(base64_encode_str)
    return base64.urlsafe_b64decode(base64_encode_str).decode('utf-8')

subscription_url = 'XXXXXXXXXXXX'

response = requests.get(subscription_url)
if response.status_code == 200:
    ssr_base64_strs = response.text
    ssr_strs = base64_decode(ssr_base64_strs)
    ssr_list = ssr_strs.split('\n')

    qrcodes_dir = 'ssr qrcodes'
    if os.path.exists(qrcodes_dir) == False:
            os.mkdir(qrcodes_dir)
    ssr_names = []
    pdf = FPDF('P', 'mm', (240, 240))
    for i, ssr in enumerate(ssr_list):
        temp_ssr = ssr.replace('ssr://', '').replace('_', '/').replace('-', '+')
        ssr_name = base64_decode(temp_ssr).split('.')[0].split('-')[0]
        ssr_names.append(ssr_name)
        pdf.add_page()
        pdf.set_font('Arial', 'B', 16)
        pdf.cell(20, 10, ssr_name)
        img = qrcode.make(ssr)
        img_name = os.path.join(qrcodes_dir, ssr_name + '.png')
        img.save(img_name)
        pdf.image(img_name, 20, 20, 200)
    pdf.output(qrcodes_dir+'.pdf', 'F')
    ssrs_dict = {'server name': ssr_names, 'ssr link': ssr_list}
    df = pd.DataFrame.from_dict(ssrs_dict)
    df.to_csv('ssr_links.txt', sep='\n', header=False, index=False)

1、torch.backends.cudnn.benchmark = True

这一项设置呢，是打开cudnn的benchmark mode，开启这个基准模式之后，cudnn将会自动的寻找适应于硬件的最佳算法来计算模型，而这个寻找的过程会花费一些时间，当输入固定时，可以选择开启，可以加速，而当输入不固定，经常变的时候，就无需开启了，开启之后反而可能会花费更多的时间。

参考：What does torch.backends.cudnn.benchmark do?

2、python内置的库copy

copy库主要有两个方法：

• copy.copy(x)，浅拷贝
• copy.deepcopy(x[, memo])，深拷贝

深拷贝与浅拷贝的区别在于对复合对象（对象中包含着对象）处理的不同：

浅拷贝，新建一个复合对象，把原来复合对象中的对象直接插入进来。浅拷贝后的复合对象，改变复合对象中的对象时，会改变之前的这个对象，如下图。

深拷贝，新建一个复合对象，把原来复合对象中的对象的副本插入进来。深拷贝后的复合对象，改变复合对象中的对象时，不会改变之前的这个对象，如下图。

参考：copy — Shallow and deep copy operations

3、 python内置的库multiprocessing与threading

这两个库分别是多进程、多线程操作的库。下面给出multiprocessing最基础的例子，threading模块这次先不展开讲。

Pool对象方便的提供了并行执行有多个输入的方法，它会将输入分发给不同的进程。

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    with Pool(5) as p:
        print(p.map(f, [1, 2, 3]))

Process类开启一个新进程。

from multiprocessing import Process

def f(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

参考：multiprocessing — Process-based parallelism

参考：threading — Thread-based parallelism

小结

还有太多的东西要学，继续加油，多学习，多总结，哈哈！

这两天呢，一直在弄数据集，为什么弄数据集呢，这个故事的开始是悲伤的，我在VS Code中连接服务器，想要删除数据集中多余的文件，先是选择了数据集文件夹，然后又直接选择了想删除的文件，接着点击了永久删除，这时就悲剧了，我尝试了去恢复数据，奈何没有管理员权限，最后选择了重新下载（下载过程真是...），顺带把几个数据集都大致了解一下，总结一下。

VOC 2012

Visual Object Classes Challenge 2012 (VOC2012)

1.1、简单介绍

数据集包含了20个分类（如下），后面的括号是按A-Z排序后的编号，也是语义分割标注的像素值（0表示背景，255表示对象的轮廓，如下图）

• Person: person(15)

• Animal: bird(3), cat(8), cow(10), dog(12), horse(13), sheep(17)

• Vehicle: aeroplane(1), bicycle(2), boat(4), bus(6), car(7), motorbike(14), train(19)

• Indoor: bottle(5), chair(9), dining table(11), potted plant(16), sofa(19), tv/monitor(20)

这个数据可以完成如下任务：

• 分类（可以区分上面的20类，还可以区分动作Action Classification，包括如下动作）
  • Jumping
  • Phoning
  • PlayingInstrument
  • Reading
  • RidingBike
  • RidingHorse
  • Running
  • TakingPhoto
  • UsingComputer
  • Walking
• 检测（不仅可以检测整个对象，还能检测人的部分Person Layout，不过只限于检测头、手、脚）
  • head
  • hands
  • feet
• 分割（包括语义分割与实例分割）
  • 总共有2913张图片，训练集1464张，验证集1449张，当然可以根据自己的想法调整训练集验证集图片的数量。

1.2、下载数据集

• 通过命令下载

  wget -c http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar
  

• 通过torchvision.datasets下载

  设置一下下载到哪个文件夹下（root参数），然后将download参数设置为True。

  我个人比较推荐这种方法，比较简单，主要是它会自动解压好。

  import torchvision
  
  root = './'
  torchvision.datasets.VOCSegmentation(root, year='2012', image_set='trainval', download=True, transform=None, target_transform=None, transforms=None)
  

1.3、加载数据集

使用torchvision.datasets加载数据集较为简单，“站在巨人的肩膀上”。

• 做分类的话，使用如下代码，pytorch文档

  torchvision.datasets.VOCDetection(root, year='2012', image_set='train', download=False, transform=None, target_transform=None, transforms=None)
  

• 做分割的话，可以使用一下代码，从pytorch，torchvision.datasets.VOCSegmentation源码中改过来的。

  官方代码只适应语义分割任务，下面的代码通过target_type参数控制返回不同的目标。（语义分割target_type='Class'，实例分割target_type='Object'）

  import os
  from torchvision.datasets.vision import VisionDataset
  from PIL import Image
  
  class VOCSegmentation(VisionDataset):
      def __init__(self,
                  root,
                  target_type='Object',
                  image_set='train',
                  transform=None,
                  target_transform=None,
                  transforms=None):
          super(VOCSegmentation, self).__init__(root, transforms, transform, target_transform)
  
          assert target_type in ['Object', 'Class'], "target_type must in ['Object', 'Class']"
  
          base_dir = 'VOCdevkit/VOC2012'
          voc_root = os.path.join(self.root, base_dir)
          image_dir = os.path.join(voc_root, 'JPEGImages')
          mask_dir = os.path.join(voc_root, 'Segmentation'+target_type)
  
          if not os.path.isdir(voc_root):
              raise RuntimeError('Dataset not found or corrupted.' +
                              ' You can use download=True to download it')
  
          splits_dir = os.path.join(voc_root, 'ImageSets/Segmentation')
  
          split_f = os.path.join(splits_dir, image_set.rstrip('\n') + '.txt')
  
          with open(os.path.join(split_f), "r") as f:
              file_names = [x.strip() for x in f.readlines()]
  
          self.images = [os.path.join(image_dir, x + ".jpg") for x in file_names]
          self.masks = [os.path.join(mask_dir, x + ".png") for x in file_names]
          assert (len(self.images) == len(self.masks))
  
      def __getitem__(self, index):
          img = Image.open(self.images[index]).convert('RGB')
          target = Image.open(self.masks[index])
  
          if self.transforms is not None:
              img, target = self.transforms(img, target)
  
          return img, target
  
      def __len__(self):
          return len(self.images)
  

1.4、提取对象的标记

获取对象对应的像素值，列表第一个值为背景值，这种方式比较简单，还有一种是通过颜色color map来判断的，这部分内容放到最后拓展来讲。

def get_target_ids(target):
    # 提取对象对应的像素值，将背景（0），轮廓（255）结合到一起
    ids = [ iid if iid != 0 else [0, 255] for iid in np.unique(target) ]
    ids = ids[0:-1]
#     print(ids)
    return ids

1.4.1、二值masks（0为背景，1为对象）

# 二值mask（0为背景，1为对象）
def get_object_masks(target, ids) -> 'np.ndarray (n, h, w)':
    target = np.array(target)

    # 提取mask列表，并堆叠到一起
    mask_list = []
    for j, iid in enumerate(ids):
        if j == 0:
            mask = np.isin(target, iid)
        else:
            mask = np.where(target == iid, 1, 0)
        mask_list.append(mask)
    masks = np.stack(mask_list, axis=0)

    return masks

1.4.2、数字标号的mask（0为背景，1...n为对象的值）

# 数字标号的mask（0为背景，1...n为对象的值）
def get_object_nums_mask(target, ids) -> 'np.ndarray (h, w)':
    target = np.array(target)

    # 将对象对应的标号加到一起（一个像素不会对应两个值）
    nums_mask = np.zeros_like(target)
    for j, iid in enumerate(ids):
        if j == 0:
            continue
        else:
            mask = np.where(target == iid, j, 0)
        nums_mask = nums_mask + mask
    return nums_mask

COCO 2017

Common Objects in Context (COCO)

2.1、简单介绍

COCO数据集也是支持多种任务：分类、检测（物体检测、关键点检测、姿态检测）、图片字幕、分割（包括全景分割、实例分割、语义分割）

COCO2017 训练集有118287张图片，验证集有5000张图片。

不多说了，直接进行下一步吧。

2.2、下载数据集

下面是用命令下载，可能下载会比较慢，可以使用迅雷下载，然后上传到服务器，也可以使用axel工具。（参考:知乎-命令行的“迅雷”，提升百倍以上下载速率）

• 下载并解压训练集

  wget -c http://images.cocodataset.org/zips/train2017.zip
  
  mkdir COCO2017
  
  mv train2017.zip ./COCO2017/train2017.zip
  
  unzip -d ./COCO2017/  ./COCO2017/train2017.zip
  

• 下载并解压验证集

  wget -c http://images.cocodataset.org/zips/val2017.zip
  
  mv val2017.zip ./COCO2017/val2017.zip
  
  unzip -d ./COCO2017/ ./COCO2017/val2017.zip
  

• 下载并解压训练集与验证的集的标注

  wget -c http://images.cocodataset.org/annotations/annotations_trainval2017.zip
  
  mv annotations_trainval2017.zip ./COCO2017/annotations_trainval2017.zip
  
  unzip -d ./COCO2017/ ./COCO2017/annotations_trainval2017.zip
  

2.3、加载数据集

2.3.1、下载COCO API

• pip

  pip3 install pycocotools
  

• conda

  conda install -c conda-forge pycocotools -y
  

2.3.2、加载数据集

加载数据集的target并不是图像，而是json字符串，包含了图片的信息，包括图片高宽、边框信息、图片ID、多边形点标注或者Run-length encoding (RLE)格式，具体格式根据任务不同，可以通过COCO官方给出的Data format介绍

• 通过torchvision.datasets

  import torchvision
  import matplotlib.pyplot as plt
  
  root = r'COCO2017/train2017'
  annFile_train = r'./COCO2017/annotations/instances_train2017.json'
  annFile_val = r'./COCO2017/annotations/instances_val2017.json'
  
  coco_dataset_train = torchvision.datasets.CocoDetection(root, annFile_train, transform=None, target_transform=None, transforms=None)
  
  coco_dataset_val = torchvision.datasets.CocoDetection(root, annFile_val, transform=None, target_transform=None, transforms=None)
  

  图像字幕可以通过torchvision.datasets.CocoCaptions(root, annFile, transform=None, target_transform=None, transforms=None)来加载。

• 通过pycocotools

  import os
  from pycocotools.coco import COCO
  from PIL import Image
  
  root = r'COCO2017/train2017'
  annFile_train = r'./COCO2017/annotations/instances_train2017.json'
  annFile_val = r'./COCO2017/annotations/instances_val2017.json'
  
  coco = COCO(annFile_train)
  ids = list(sorted(coco.imgs.keys()))
  for i, img_id in enumerate(ids):
      img_path = coco.loadImgs(img_id)[0]['file_name']
      img = Image.open(os.path.join(root, img_path)).convert('RGB') # 加载原图
  
      ann_ids = coco.getAnnIds(imgIds=img_id)
      target = coco.loadAnns(ann_ids) #加载target
  

  pycocotools github地址

  最主要的python源文件有两个：coco.py、mask.py、cocoeval.py，下面是这几个文件里API的说明。

  • coco.py

    # The following API functions are defined:
    #  COCO       - COCO api class that loads COCO annotation file and prepare data structures.
    #  decodeMask - Decode binary mask M encoded via run-length encoding.
    #  encodeMask - Encode binary mask M using run-length encoding.
    #  getAnnIds  - Get ann ids that satisfy given filter conditions.
    #  getCatIds  - Get cat ids that satisfy given filter conditions.
    #  getImgIds  - Get img ids that satisfy given filter conditions.
    #  loadAnns   - Load anns with the specified ids.
    #  loadCats   - Load cats with the specified ids.
    #  loadImgs   - Load imgs with the specified ids.
    #  annToMask  - Convert segmentation in an annotation to binary mask.
    #  showAnns   - Display the specified annotations.
    #  loadRes    - Load algorithm results and create API for accessing them.
    #  download   - Download COCO images from mscoco.org server.
    # Throughout the API "ann"=annotation, "cat"=category, and "img"=image.
    # Help on each functions can be accessed by: "help COCO>function".
    

  • mask.py

    # The following API functions are defined:
    #  encode         - Encode binary masks using RLE.
    #  decode         - Decode binary masks encoded via RLE.
    #  merge          - Compute union or intersection of encoded masks.
    #  iou            - Compute intersection over union between masks.
    #  area           - Compute area of encoded masks.
    #  toBbox         - Get bounding boxes surrounding encoded masks.
    #  frPyObjects    - Convert polygon, bbox, and uncompressed RLE to encoded RLE mask.
    

  • cocoeval.py

    # The usage for CocoEval is as follows:
    #  cocoGt=..., cocoDt=...       # load dataset and results
    #  E = CocoEval(cocoGt,cocoDt); # initialize CocoEval object
    #  E.params.recThrs = ...;      # set parameters as desired
    #  E.evaluate();                # run per image evaluation
    #  E.accumulate();              # accumulate per image results
    #  E.summarize();               # display summary metrics of results
    # For example usage see evalDemo.m and http://mscoco.org/.
    

2.4、提取对象的标签标记

这里主要以通过torchvision.datasets加载数据集方式下的target，而通过pycocotools加载数据集下的target有些不同，他包括了更多信息，可以通过下面这句代码转为通过torchvision.datasets加载数据集方式下的target。

target = target['Objects']

以下两个方法中的coco_object参数是COCO类实例化的对象，可以使用torchvision.datasets数据集对象中的coco属性调用，如：coco_dataset_train.coco，或者是pycocotools中COCO类实例化的对象。

2.4.1、二值masks（0为背景，1为对象）

def get_object_masks(coco_object, target):

    bg = 0
    mask_list = []
    for j, ann in enumerate(target):
        mask = coco_object.annToMask(ann)
        mask_list.append(mask)
        bg = bg + mask

    bg = np.where(bg == 0, 1, 0)

    mask_list.insert(0, bg)
    masks = np.stack(mask_list, axis=0)

    return masks

2.4.2、数字标号的mask（0为背景，1...n为对象的值）

COCO数据集中有对象有重叠，下面的方法有去掉重叠像素（后面的对象像素点位置在赋值的时候，如果已经有对象赋值了则不再赋值，如下图第三张），去掉重叠对象（后面的对象如果与已有对象有重叠则跳过，如下图第五张），以上方法是不够好的，可能应该直接不使用数字标号的mask（这种mask主要为softmax服务），而使用二值mask做二分类。（如下图所示，第一张图为原图，第二站图为有标注遮罩的图，第三张图为没有去重叠的图, 第四张图为去掉重叠元素的像素点的图，下面的第一段代码，第五张图为去掉重叠元素的像素点的图，下面的第二段代码）

def get_object_nums_mask_remove_overlap_pixel(coco_object, target):

    nums_mask = []
    for j, ann in enumerate(target):
        mask = coco_object.annToMask(ann)
        if j == 0:
            nums_mask = np.zeros_like(mask)
        # 去掉了后面有重叠的像素点
        nums_mask = nums_mask + np.where((mask - (nums_mask > 0))==1, j+1, 0)

    return nums_mask

def get_object_nums_mask_remove_overlap_object(coco_object, target):

    nums_mask = []
    nums_object = 1
    for j, ann in enumerate(target):
        mask = coco_object.annToMask(ann)

        if j == 0:
            nums_mask = np.zeros_like(mask)

        # 去掉了后面有重叠的像素点的对象
        if ((mask - (nums_mask == 0)) == 1).any():
            break

        nums_mask = nums_mask + np.where(mask == 1, nums_object, 0)
        nums_object = nums_object + 1

    return nums_mask

Cityscapes

3.1、简单介绍

Cityscapes数据集呢，主要是车行驶在各个城市的图像，图像比较大（1024*2048），主要用于分割，检测等任务，这里就不多说了，看下面的数据集信息吧。

md5值可以使用md5sum工具来验证参考：CSDN-Linux下使用md5sum计算和检验MD5码

gtFine_trainvaltest.zip（241MB）：主要为标的好一些的标注，包括标注训练与验证集共3475张图片，测试集1525张图片忽略了区域，这个数据集和leftImg8bit_trainvaltest.zip（11GB）相呼应

gtCoarse.zip（1.3GB）：主要为标的粗糙一些的标注，包括标注训练与验证集标注共3475张图片，标注了额外的训练数据集19998张图片，与leftImg8bit_trainextra.zip (44GB) 和leftImg8bit_trainvaltest.zip（11GB）相呼应。

3.2、下载数据集

可以通过Cityscapes官网注册登录然后下载，也可以通过命令下载参考：CSDN-Linux下载交通图片数据集CityScapes Dataset

命令如下

3.2.1、登录

注意需要先注册。

wget --keep-session-cookies --save-cookies=cookies.txt --post-data 'username=yourname&password=yourpassword&submit=Login' https://www.cityscapes-dataset.com/login/

3.2.2、下对应数据集

修改下面对应的ID值就可以下载对应的包，相关包的ID可以看上面的表格。

wget --load-cookies cookies.txt --content-disposition https://www.cityscapes-dataset.com/file-handling/?packageID=3

3.2.3 解压图片和标注

mkdir Cityscapes
mv leftImg8bit_trainvaltest.zip ./Cityscapes/leftImg8bit_trainvaltest.zip
unzip -d ./Cityscapes ./Cityscapes/leftImg8bit_trainvaltest.zip
mv ./Cityscapes/README ./Cityscapes/README_leftImg8bit
mv ./Cityscapes/license.txt ./Cityscapes/license_leftImg8bit.txt

mv gtFine_trainvaltest.zip ./Cityscapes/gtFine_trainvaltest.zip
unzip -d ./Cityscapes ./Cityscapes/gtFine_trainvaltest.zip
mv ./Cityscapes/README ./Cityscapes/README_gtFine
mv ./Cityscapes/license.txt ./Cityscapes/license_gtFine.txt

3.3、加载数据集

加载数据集之前需要下载安装cityscapesScripts

python -m pip install cityscapesscripts

依旧使用torchvision.datasets来加载数据集，简单和方便，代码如下。加载数据集的类型可分为'instance', 'semantic', 'color', 'polygon'这几种，也可以是这集中的任意组合，其中color是输出全景分割label，polygon是输出分割对象的多边形轮廓的点信息。

import torchvision
import numpy as np

root = r'./Cityscapes/'

# target_type = ['instance', 'semantic', 'color', 'polygon']
target_type = 'instance'

cityscapes_dataset = torchvision.datasets.Cityscapes(root, split='train', mode='fine', target_type=target_type, transform=None, target_transform=None)

还可以通过将Cityscapes数据集转换为COCO数据，然后通过COCO来加载，参考：https://github.com/jinfagang/cityscapestococo

3.4、提取对象的mask标记

def get_target_ids(target):
    ids = [iid for iid in np.unique(target) if iid >= 1000]
#     print(ids)
    return ids

提取对象的mask方式与VOC2012的方式基本一样（代码如上），只是获取ids的方式不同。VOC2012的实例分割标注，没有带有类别信息，只是按第一个、第二个、到第n个对象的顺序标号（从零开始）来标记的（如下图一），而Cityscapes的实例分割包括了分类标签信息（如下图三，来自labels.py），它是通过对象id*1000+第几个对象的顺序标号来标记的（如下图二）。

VOC2012中，0表示背景，255表示对象轮廓

Cityscapes中，小于1000的数字是语义分割的标号，而大于1000的是对应对象的实例分割标注（对象id*1000+第几个对象的顺序标号）。如26003是对象car的第四个对象（下标从零开始）。

拓展：颜色转换

将(0-255)的PIL.PngImagePlugin.PngImageFile转成RGB模式下的PIL.Image.Image的颜色转换，如下代码color_map_rgb可以获取获取到0-N的对应的颜色。

def bitget(number, pos):
    return (number >> pos - 1) & 1

def bitor(number1, number2):
    return number1 | number2

def bitshift(number, shift_bit_count):
    if shift_bit_count < 0:
        number = number >> abs(shift_bit_count)
    else:
        number = number << shift_bit_count
    return number

def color_map_rgb(N):
    cmap = np.zeros((N+1,3), np.uint8)
    for i in range(N+1):
        if i == 0:
            continue
        id = i
        r = g = b = 0
        for j in range(8):
            r = bitor(r, bitshift(bitget(id, 1), 7 - j))
            g = bitor(g, bitshift(bitget(id, 2), 7 - j))
            b = bitor(b, bitshift(bitget(id, 3), 7 - j))
            id = bitshift(id, -3)
        cmap[i, :]=[r, g, b]
#         print([r,g,b])
    return cmap

简单来看0-255对应的颜色值的规律：(以下面0-10所对应的RGB颜色值来看)

规律 将二进制逆序，以三位为一捆，然后每一位的数字对应乘以255*(1/2)^n(第几捆)，然后把所有捆对应位的对应的值加起来。

以10为例，10的二进制是b001010，逆序010100，分为两捆，第一捆010，第二捆100，第一捆对应乘以128（255*(1/2)^1）得到(0128, 1128, 0128)，第二捆对应乘以64（255(1/2)^2）得到(164, 064, 0*64)，最后对应相加得到RGB值(64, 128, 0)

再来个大点的数66，66的二进制b1000010，逆序0100001，第一捆010，第二捆000，第三捆100，分别对应，(0128, 1128, 0128)，(064, 064, 064)，(32*1, 0, 0)，对应相加得到(32, 128, 0)，验证结果正确（如下图所示）。

总结

小小总结一下，这次主要总结了三个数据集VOC2012、COCO2017、Cityscapes的使用方法，主要以实例分割方向上来讲解，不知道怎么总结好了，不说了，休息。

论文地址

源码地址

网络结构

我们直接来看网络结构图。

网络主要分为两个分支，上面的分支用来预测每个语义类别的种子图seed map，这个种子图呢，是一个分数图，靠近实例对象的中心点对应会有一个高的分数，而离中心点比较远的分数则比较低，下面的分支呢，输出offset map和间隙$\sigma$，offset map与坐标向量（xmap，ymap）相加构造成像素点的embedding。随后由seed map确定实例对象的中心点位置，取对应位置的$\sigma$作为间隙，通过计算embedding的距离（或者说是相似度）来确定实例分割的结果。

网络细节

seed map

查看源码发现呢，这个种子图，并不是像网络结构图中那样分了成了多张，而只是一张包含了所有语义对象的图并且用损失函数（如下）在语义对象上进行约束。

$$ L_{seed} = \frac{1}{N}\sum_{i}^{N}\mathbf{1}{{s_i \in S_k}}||s_i-\phi_k(e_i)||^2+\mathbf{1}{{s_i \in bg }}||s_i-0||^2 $$

这里的$S_k$是由ground truth确定的语义对象，$s_i$是seed map中的点，函数$1_{{s_i \in S_k}}$表示属于前景对象的值为1，属于背景的值为0，反过来，函数$1_{{s_i \in bg }}$表示属于背景为1，属于前景对象为0。 $\phi_k(e_i)$为如下公式，计算属于$i$点属于对象$k$的分数。

$$ \phi_k(e_i)=exp\left(-\frac{||e_i-C_k||^2}{2\sigma_k^2} \right) $$

那为什么要用$s_i$减去$\phi_k(e_i)$，作者认为这个分数应该等于计算由$\phi_k(e_i)$计算出来的值，即这个分数应该等于推理中属于正确语义类别中的分数，而这个属于正确语义类别中的分数由$\phi_k(e_i)$计算出来。

间隙$\sigma$

间隙$\sigma$在实际计算中，是使用的实例在seed map最大分数位置对应到$\sigma \ map$中的$\sigma$值，这里和推理中的$\sigma$是不一致，所以用损失函数（如下）来约束它。

$$ L_{smooth}=\frac{1}{|S_k|}\sum_{\sigma_i \in S_k}||\sigma_i - \sigma_k||^2 $$

其中，$\sigma_k$是推理中的间隙。

$$ \sigma_k = \frac{1}{|S_k|}\sum_{\sigma_i \in S_k} \sigma_i $$

基础网络

使用ERFNet，一种编码解码器结构来作为基础网络，将如网络结构图所示，将解码器分开用两次，分别训练不同的参数，实现不同的效果，效果中将网络输出结果叠加到一起，形成了一个4的通道的张量，第一二通道是offset，第三通道是间隙$\sigma$，第四通道是seed map。

xmap与ymap

xmap与ymap由如下代码构造而成。其中2048与1024分别为图像（Cityscas数据集）的宽与高。

xm = torch.linspace(0, 2, 2048).view(1, 1, -1).expand(1, 1024, 2048)
ym = torch.linspace(0, 1, 1024).view(1, -1, 1).expand(1, 1024, 2048)
xym = torch.cat((xm, ym), 0)

损失函数

除了上面对间隙$\sigma$和seed map的分数进行约束的损失之外，还需要优化分割效果的损失，论文中使用二分类损失Lovasz-hinge loss，公式如下，其中又一个雅卡尔指数Jaccard index的概念，其实就是交叠率。

$$ J_c(y^, \bar{y})= \frac{|y^=c \cap \bar{y}=c|}{|y^*=c \cup \bar{y}=c|} $$

转换为求最小loss

$$ \Delta_{J_c(y^, \bar{y})} = 1 - J_c(y^, \bar{y}) $$

求预测像素$i$的hinge loss，其中$F_i(x)$是像素$i$的评分函数的值，而$\bar{y}=sign(F_i(x))$，即$F_i(x)$是没有转为标签之前的分数，$sign(\cdot)$是符号函数，大于$0$，则等于$1$，等于$0$，不变，小于$0$，则等于$-1$，$y_i^*$是像素$i$的标签等于$-1$或者$1$，

$$ loss_{hinge} = max(1 - F_i(x)y_i^,\ 0) $$

再进一步拓展到Lovasz-hinge loss，$\Delta_j^-$是$\Delta_j$的Lovasz拓展。

$$ Loss_{Lovasz\ hinge} = \Delta_j^-(loss_{hinge}(F)) $$

Lovasz拓展又是什么呢，Lovasz拓展可用于求解次模最小化问题。次模函数的Lovasz拓展是一个凸函数，可高效实现最小化，这里的次模函数看了定义，还是懵的，不纠结这个了，还是继续看Lovasz拓展吧。给定一个次模函数$f$，Lovasz拓展$\hat{f}$如下:

$$ \hat{f}(x) = \sum_{i=0}^{n}\lambda_if(X_{S_i}) $$

其中，

$$ \lambda_i = x_{\pi_{(i)}} - x_{\pi_{(i + 1)}} $$

$x_{\pi_{(i)}}$是排好序之后的$x$，

$$1\ge x_{\pi_{(1)}} \ge x_{\pi_{(2)}} \ge ... \ge x_{\pi_{(n)}} \ge 0 $$

经过相关的推到和证明，得到最后得到Lovasz拓展的次梯度sub-gradients将其作为最小化的对象。

$$ g(x) = \sum_{i=1}^{n}(\Delta_{J_c(loss_{hinge}{{\pi(i)}})} - \Delta{J_c(loss_{hinge}{{\pi(i-1)}})} ) * loss{hinge}{_{\pi(i)}} $$

这里只要将$loss_{hinge}{_{\pi(i-1)}}$改成如下公式就可以将二分类Lovasz-hinge loss变成多分类lovasz-softmax loss

$$ loss = \begin{cases} 1-F_i(c) & if \ c = y^*, \ F_i(c) & otherwise. \end{cases} $$

参考

知乎的文章：Lovasz-Softmax loss

CSDN文章：lovasz-softmax loss

LovaszSoftmax源码地址

损失拓展

论文中提到了对间隔和像素点中心进行拓展。

• 将间隔由圆变成椭圆的间隔，学习二维（x，y）的间隔

  $$ \phi_k(e_i)=exp\left(-\frac{||e_{ix}-C_{kx}||^2}{2\sigma_{kx}^2}-\frac{||e_{iy}-C_{ky}||^2}{2\sigma_{ky}^2} \right) $$

• 将直接取seed map最大值对应的位置作为中心改为取属于对象的embedding的均值。

  $$ \phi_k(e_i)=exp\left(-\frac{||e_i-\frac{1}{|S_k|}\sum_{e_j\in S_k}e_j||^2}{2\sigma_k^2} \right) $$

很显然的是，第二个拓展，只能用于训练的时候，因为我们需要确定点属于哪个实例，才能通过求均值的方式求中心，论文中为了比较以上的两种拓展，将seed map采样改成了在ground truth上采样，这样直接可以确定点属于哪个实例，从而可以顺利的通过求均值的方式求中心。

训练策略

由于使用Cityscapes数据集，图片比较大h1024xw2048，作者先将图片剪切成500x500，做了100轮预训练，之后在剪切图片1024x1024大小下，进行了50轮的微调，这种方式可以借鉴一下，想起之前还有一种方式，将网络最后的分割层改成改成分类层，在ImageNet数据集上做预训练，只能改回来再在分割的数据集上做分割任务。

论文小结

从这篇论文中学到了什么呢，我觉得主要还是可学习的间隙，然后的话，算是了解一下了做分割的两个损失函数二分类的Lovasz-hinge loss和多分类的lovasz-softmax loss，之后在我们的工作中，我想我会去比较一下交叉熵和lovasz-softmax loss。

看这篇论文，之前卡了我一下的是，之前一直觉得求中心点是个死环，求不出来中心点，在论文中的推理过程中，中心点需要知道哪些点属于实例，而哪些点属于实例需要由有中心点的高斯函数求出来，最后发现作者用逐步取seed map中最大值来确定中心位置和相应位置的间隙，从而可以算哪些点属于实例（$\phi_k(e_i) > 0.5$），逐步求实例中心的这个过程其实有点类似于非最大值抑制求极大值的过程，每个极大值代表一个实例的中心。

这篇论文就大概总结到这里了。

爬取成绩

1、准备工作

在开始爬取数据前先到做一些准备工作。下载安装Chrome浏览器、chromedriver以及selenium模块。

本来是准备使用PhantomJS，奈何开发团队主要人员吵架，然后暂停了项目的开发，Selenium的新版本中，也不再支持PhantomJS，后来知道了Firefox和Chrome都是支持无头模式的，所以我决定使用Chrome试一试。

安装Chrome浏览器

$ sudo apt-get update
$ wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
$ sudo dpkg -i google-chrome-stable_current_amd64.deb

如果出现了缺少依赖的情况，可以使用如下命令解决

$ sudo apt-get -f -y install

再重新安装Chrome即可，可以通过以下命令查看是否安装正确。

$ google-chrome --version
$ which google-chrome

安装chromedriver

在这里找到与Chrome大版本一致的chromedriver，下载下来，并解压到/usr/bin或者/usr/local/bin目录中，也可以解压到当前吗目录，不过这样后续需要指定chromedriver的路径。

$ wget http://chromedriver.storage.googleapis.com/83.0.4103.39/chromedriver_linux64.zip
$ unzip chromedriver_linux64.zip -d /usr/local/bin

如果将chromedriver解压到了/usr/bin或者/usr/local/bin目录中，可以使用如下命令验证一下。

$ chromedriver --version

Seleium官方文档中给出了各个浏览器WebDriver的下载地址和加载方式

安装selenium模块

这里就不多说了，pip，conda安装都很容易。

2、开始爬取成绩

Seleium官方给的快速入门，特别不粗，看一遍，直接就能上手，这里我不具体来说爬成绩的代码，而是简单讲一讲Seleium使用WebDriver的简单上手。

设置无头加载

chrome_options = webdriver.ChromeOptions()
chrome_options.headless = True
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--no-sandbox")

加载WebDriver

以Chrome为例。其他浏览器加载方式类似，具体可见文档

#Simple assignment
from selenium.webdriver import Chrome

driver = Chrome(executable_path='/usr/bin/chromedriver', options=chrome_options)

#Or use the context manager
from selenium.webdriver import Chrome

with Chrome(executable_path='/usr/bin/chromedriver', options=chrome_options) as driver:
    #your code inside this indent

访问网站链接

driver.get("https://selenium.dev")

等待网站加载完成

• 强制等待

  time.sleep(5) # Wait for 5 seconds.
  

• 隐性等待

  设置最长等待时间，在没有达到最长时间时加载完成，则进行下一步，到最长等待时间，还没有加载完成，则也惊喜下一步。

  driver.implicitly_wait(30)  # 最长等30秒
  

• 显性等待

  程序每隔xx秒验证一下条件，如果条件成立了，则执行下一步，否则继续等待，如果超过设置的最长时间，则抛出异常TimeoutException。

  WebDriverWait(driver, timeout=3).until(some_condition)
  

  from selenium.webdriver.support.ui import WebDriverWait
  def document_initialised(driver):
      return driver.execute_script("return initialised")
  
  driver.navigate("file:///race_condition.html")
  WebDriverWait(driver).until(document_initialised)
  el = driver.find_element(By.TAG_NAME, "p")
  assert el.text == "Hello from JavaScript!"
  

  from selenium.webdriver.support.ui import WebDriverWait
  
  driver.navigate("file:///race_condition.html")
  el = WebDriverWait(driver).until(lambda d: d.find_element_by_tag_name("p"))
  assert el.text == "Hello from JavaScript!"
  

  driver = Firefox()
  driver.get("http://somedomain/url_that_delays_loading")
  wait = WebDriverWait(driver, 10, poll_frequency=1, ignored_exceptions=[ElementNotVisibleException, ElementNotSelectableException])
  element = wait.until(EC.element_to_be_clickable((By.XPATH, "//div")))
  

浏览器相关操作

```python
driver.get("https://selenium.dev")

driver.current_url

driver.back()

driver.forward()

driver.refresh()

driver.title

driver.current_window_handle

driver.switch_to.window(window_handle)

# Opens a new tab and switches to new tab
driver.switch_to.new_window('tab')
# Opens a new window and switches to new window
driver.switch_to.new_window('window')

#Close the tab or window
driver.close()
#Switch back to the old tab or window
driver.switch_to.window(original_window)

driver.quit()
```

其他窗口相关的操作请看[文档](https://www.selenium.dev/documentation/en/webdriver/browser_manipulation/)。

常用接口获取值

size #获取元素的尺寸
text #获取元素的文本
get_attribute(name) #获取属性值
location #获取元素坐标，先找到要获取的元素，再调用该方法
page_source #返回页面源码
driver.title #返回页面标题
current_url #获取当前页面的URL
is_displayed() #设置该元素是否可见
is_enabled() #判断元素是否被使用
is_selected() #判断元素是否被选中
tag_name #返回元素的tagName

定位元素

• 定位单个元素

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  driver = webdriver.Firefox()
  driver.get("http://www.google.com")
  # Get search box element from webElement 'q' using Find Element
  search_box = driver.find_element(By.NAME, "q")
  search_box.send_keys("webdriver")
  

  find_element_by_id()
  find_element_by_name()
  find_element_by_xpath()
  find_element_by_link_text()
  find_element_by_partial_link_text()
  find_element_by_tag_name()
  find_element_by_class_name()
  find_element_by_css_selector()
  

• 定位多个元素

  # Get all the elements available with tag name 'p'
  elements = driver.find_elements(By.TAG_NAME, 'p')
  

• 从元素中定位元素

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  
  driver = webdriver.Firefox()
  driver.get("http://www.google.com")
  search_form = driver.find_element(By.TAG_NAME, "form")
  search_box = search_form.find_element(By.NAME, "q")
  search_box.send_keys("webdriver")
  

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  
  driver = webdriver.Chrome()
  driver.get("https://www.example.com")
  
  # Get element with tag name 'div'
  element = driver.find_element(By.TAG_NAME, 'div')
  
  # Get all the elements available with tag name 'p'
  elements = element.find_elements(By.TAG_NAME, 'p')
  for e in elements:
      print(e.text)
  

• 定位到焦点的元素

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  
  driver = webdriver.Chrome()
  driver.get("https://www.google.com")
  driver.find_element(By.CSS_SELECTOR, '[name="q"]').send_keys("webElement")
  
  # Get attribute of current active element
  attr = driver.switch_to.active_element.get_attribute("title")
  print(attr)
  

• 获取元素属性

  element.get_attribute("title")
  

• 调用截图（需要在有浏览器显示的情况下）

  driver.save_screenshot("screenshot.png")
  

操作元素

clear()     #清除元素的内容
send_keys() #模拟按键输入
click()     #点击元素
submit()    #提交表单

键盘与鼠标操作

• 键盘操作

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  from selenium.webdriver.common.keys import Keys
  driver = webdriver.Chrome()
  
  # Navigate to url
  driver.get("http://www.google.com")
  
  # Enter "webdriver" text and perform "ENTER" keyboard action
  driver.find_element(By.NAME, "q").send_keys("webdriver" + Keys.ENTER)
  
  # Perform action ctrl + A (modifier CONTROL + Alphabet A) to select the page
  webdriver.ActionChains(driver).key_down(Keys.CONTROL).send_keys("a").perform()
  

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  from selenium.webdriver.common.keys import Keys
  driver = webdriver.Chrome()
  
  # Navigate to url
  driver.get("http://www.google.com")
  
  # Store google search box WebElement
  search = driver.find_element(By.NAME, "q")
  
  action = webdriver.ActionChains(driver)
  
  # Enters text "qwerty" with keyDown SHIFT key and after keyUp SHIFT key (QWERTYqwerty)
  action.key_down(Keys.SHIFT).send_keys_to_element(search, "qwerty").key_up(Keys.SHIFT).send_keys("qwerty").perform()
  

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  driver = webdriver.Chrome()
  
  # Navigate to url
  driver.get("http://www.google.com")
  
  # Store 'SearchInput' element
  SearchInput = driver.find_element(By.NAME, "q")
  SearchInput.send_keys("selenium")
  
  # Clears the entered text
  SearchInput.clear()
  

  send_keys(Keys.ENTER) #按下回车键
  send_keys(Keys.TAB) #按下Tab制表键
  send_keys(Keys.SPACE) #按下空格键space
  send_keys(Kyes.ESCAPE) #按下回退键Esc
  send_keys(Keys.BACK_SPACE) #按下删除键BackSpace
  send_keys(Keys.SHIFT) #按下shift键
  send_keys(Keys.CONTROL) #按下Ctrl键
  send_keys(Keys.ARROW_DOWN) #按下鼠标光标向下按键
  send_keys(Keys.CONTROL,'a') #组合键全选Ctrl+A
  send_keys(Keys.CONTROL,'c') #组合键复制Ctrl+C
  send_keys(Keys.CONTROL,'x') #组合键剪切Ctrl+X
  send_keys(Keys.CONTROL,'v') #组合键粘贴Ctrl+V
  

• 鼠标操作

  click()
  context_click(elem) #右击鼠标点击元素elem，另存为等行为
  double_click(elem) #双击鼠标点击元素elem，地图web可实现放大功能
  drag_and_drop(source,target) #拖动鼠标，源元素按下左键移动至目标元素释放
  move_to_element(elem) #鼠标移动到一个元素上
  click_and_hold(elem) #按下鼠标左键在一个元素上
  perform() #在通过调用该函数执行ActionChains中存储行为
  

Selenium小结

在实现需求的过程中，遇到了一直提醒浏览器版本过低的问题，然后使用如下语句，点击提醒框的确定按钮，进入下一步。

alert = browser.switch_to.alert
alert.accept()

Selenium处理的过程：设置无头加载，加载驱动，加载网页，等待加载完成，爬取数据。

邮件发送

1、在IIS上搭建SMTP服务器

这里主要参考CSDN中的一篇博客Windows Server 2012 r2搭建SMTP，这里放上博客中给出的图，以后好找到。

• 1、打开控制面板选择打开或关闭windows features，按照提示在features中找到SMTP，选择安装；在Windows Server中也可以在服务器管理Server Manage中的Manage中添加。

  

• 2、打开IIS6.0，这里需要注意的是IIS6.0，点击windows窗口图标，在search中输入“iis”，选择打开iis 6.0 Manager；在Windows Server中也可以在服务器管理Server Manage中Tools中打开。

  

• 3、在打开窗口，SMTP Vritual Server右键选择domain，并新建一个新的domain，按照提示输入名称和类型即可.

  

  

  

• 4、设置ip（可以不改默认的All Unassgined）以及端口（也可以不改默认的25）。

  

  

  

• 5、访问控制，选择基本的明文验证。

  

  

• 6、在windows中添加一个用户，用来做明文认证，从“Security”的配置中，将用户分配给SMTP。

  创建用户过程：在【控制面板Contorl Panel】中选择【用户账号User Accounts】，接着再次选择【用户账号User Accounts】，选择【管理另一个账号Manage another account】，选择添加一个【添加一个用户账号add a user account】，输入账户名密码创建用户。

  

2、发送邮件

大致代码如下，发出的邮箱from_addr，任意设置，只要符合正确的邮件格式就行，smtp_server.login('XXX', 'XXXX')使用上面添加的用户账号密码登录。

import smtplib
from email.mime.text import MIMEText
from email.header import Header

host = 'XXXX'
smtp_server = smtplib.SMTP()
smtp_server.connect(host, 25)
# smtp_server.set_debuglevel(1)
from_addr = 'XXX'
to_addr = 'XXX'
smtp_server.login('XXX', 'XXXX') # 添加到SMTP服务器的用户账号密码

message = MIMEText(content, 'html', 'utf-8')
message['From'] = from_addr
message['To'] = to_addr
message['Subject'] = Header('成绩单', 'utf-8').encode()

smtp_server.sendmail(from_addr, to_addr, message.as_string())
smtp_server.quit()

总结

selenium大概入了下门，SMTP基本是复制粘贴的runoob.com的代码，以后有遇到要使用SMTP再具体深入了解了。

故事的开始

服务器不知道是咋滴啦，frp客户端掉了，natapp客户端也掉了。

开启了了解这个natapp之路。

配置natapp SSH通道

以创建免费的SSH通道为例。

1、创建SSH隧道

登录到natapp网页，在【我的隧道】中，点击【购买隧道】，就可以看到一个【免费隧道】，点击它，选择隧道协议，【TCP】（这里有三种，TCP、UDP、WEB），然后设置【本地端口】（设置默认的SSH端口22吧），点击【免费购买】，创建隧道成功。

2、下载natapp

下载natapp地址

下载对应的系统的版本的natapp。

3、配置config.ini文件

创建一个config.ini文件，将下面的内容复制进去，再将authtoken复制进去，然后配置一下log，也可以不配置，在启动客户端的时候加入命令参数。如$ ./natapp -log=stdout -loglevel=ERROR

#将本文件放置于natapp同级目录 程序将读取 [default] 段
#在命令行参数模式如 natapp -authtoken=xxx 等相同参数将会覆盖掉此配置
#命令行参数 -config= 可以指定任意config.ini文件
[default]
authtoken=                      #对应一条隧道的authtoken
clienttoken=                    #对应客户端的clienttoken,将会忽略authtoken,若无请留空,
log=none                        #log 日志文件,可指定本地文件, none=不做记录,stdout=直接屏幕输出 ,默认为none
loglevel=ERROR                  #日志等级 DEBUG, INFO, WARNING, ERROR 默认为 DEBUG
http_proxy=                     #代理设置 如 http://10.123.10.10:3128 非代理上网用户请务必留空

4、启动natapp

执行如下命令，也可以参考natapp给出的教程

nohup ./natapp -config=config.ini -log=stdout -loglevel=INFO  >log.out 2>&1  &

这里指定了配置文件，是因为我后续还增加了一个免费的web通道。

5、测试SSH连接

由于免费的没有固定的域名和端口，它会在启动的时候给定，我们可以在log.out中找到对于的url，这里的图，我是用的web隧道的，因为我们使用了付费的SSH通道，又固定的域名与端口。

使用对应的的域名与端口，执行ssh命令，测试是否可以连接。

新增免费的隧道

对于每个一个注册用户，natapp提供两个免费的不同协议的隧道，下面创建免费的web通道。

1、创建Web隧道

与创建SSH隧道类似，将【隧道协议】改成【web】,其他步骤一致。

2、配置隧道

之前已经下载了natapp，这里只需要创建一个新的配置文件，例如webconfig.ini（这可以直接复制成一个新的文件cp config.ini webconfig.ini），再进行之前与SSH通道类似的的配置config.ini文件就行，将对应的authtoken换上去。

3、启动并测试

• 与之前SSH启动natapp类似，指定一下配置文件就好了，如下，

  nohup ./natapp -config=webconfig.ini -log=stdout -loglevel=INFO >weblog.out 2>&1  &
  

• 启动一个web服务，比如jupyter notebook，指定端口为之前创建隧道时设置的端口，命令如下。

  nohup jupyter notebook --port 8888 >jupyter.out 2>&1  &
  

  需要注意的是，一定要指定端口为之前创建隧道时设置的端口，jupyter notebook远程设置可以参考我上一篇博客。

• 在log文件中找到链接，看链接是否可以正常访问。

总结

总结一下，这个natapp配置起来，其实也和frp配置起来差不多，没有多复杂，natapp基于ngrok还是做了一些简化吧，不错，收费也不高，怎么说呢，说不高也不高，其实说高也高，它按单个隧道来付费。有好的带宽的外网服务器的话，我还是比较推荐开源的frp吧，没有必要花额外的钱了。

内网穿透配置

相关开源的内网穿透工具的地址如下：

• ngrok
• frp
• pagekite的python开源实现pypagekite
• localtunnel

为什么选择frp

接着上面的几个开源工具来说，其中ngrok是1.x的版本，2.x之后内，不开源了，其实也是可以理解的，他们也要吃饭（听说1.x又许多bug没解决，不过我没使用过也不知道），看文档配置不怎么简单。frp的话，简单，我基本上几分钟就看懂是怎么一回事了，pypagekite的话执行python语句来配置服务，后面跟一大串命令参数，最后一个localtunnel，是基于js开发的，还需要先搭建node.js包管理平台npm（node package manager）来弄，直接就放弃这个选项了。 由于配置简单，我选择了用frp（fast reverse proxy）玩一下

frp内网穿透过程

看上面的架构图，大概是在外网环境下运行frp服务端，而在内网环境下运行frp客户端，服务端与客服端形成通道，可以进行连接，外网下用户访问服务端，服务端在与客服端通信得到请求访问的结果，总结为一个词就是反向代理。

什么是正向代理、反向代理

先说一下正向代理，正向代理是代理了客服端，代理与服务端通信，代替客户端与服务端的直接通信。通俗理解：可以说是正向代理是代表客户（客户端）与厂商（服务端）通信，像是代购的角色。

• [客户端 <一> 代理] 一> 服务端

相反，反向代理就是代理了服务端，代理与服务端通信，代替服务端与客户端的直接通信。通俗理解：反向代理则是是代表厂商（服务端）与客户（客户端）通信，像是经销商的角色。

• 客户端 一> [代理 <一> 服务端]

正向代理隐藏真实客户端，反向代理隐藏真实服务端

配置frp

1、下载frp

在frp github库的发布的页面下载对应的对应系统的frp工具。

2、配置ssh访问

• 2.1、配置服务端

  在外网环境下的服务器（我这里是腾讯云的学生服务器），配置frps.ini文件中的bind_port，给服务器设置开通一个访问的端口。

  [common]
  bind_port = 7000
  

• 2.2、启动服务端

  ./frps -c ./frps.ini
  

• 2.3、配置客户端

  在内网环境下的服务器（我这里是学校的服务器），配置frpc.ini如下，其中server_addr对应外网下服务器的地址（域名），server_port对应上面frps配置的端口。

  [common]
  server_addr = x.x.x.x
  server_port = 7000
  
  [ssh]
  type = tcp
  local_ip = 127.0.0.1
  local_port = 22
  remote_port = 6000
  

• 2.4、启动客服端

  ./frpc -c ./frpc.ini
  

• 2.5、测试ssh链接

  ssh test@x.x.x.x -p 6000
  

  这里test需要改成对应的要登录的账户名，@后面为服务器地址（域名），-p后面是内网服务器ssh对应开通的端口。

3、配置web服务访问

• 3.1、配置服务端

  在外网环境下的服务器，配置frps.ini文件中的vhost_http_port，给服务器设置开通一个web服务访问的端口。

  [common]
  bind_port = 7000
  vhost_http_port = 8080
  

• 3.2、启动服务端

  ./frps -c ./frps.ini
  

• 3.3、配置客户端

  在内网环境下的服务器，配置frpc.ini如下，其中server_addr对应外网下服务器的地址（域名），server_port对应之前的frps配置的端口，配置本地的端口，custom_domains是外网下服务器的域名，一般使用二级域名。

  [common]
  server_addr = x.x.x.x
  server_port = 7000
  
  [web]
  type = http
  local_port = 80
  custom_domains = www.example.com
  

  也可以配置多个web服务，这里我就配置了两个web服务，一个为jupyter notebook准备的，一个为tensorboard可视化准备的。设置多个web服务，只需要在后面加数字就行。

  [common]
  server_addr = x.x.x.x
  server_port = 7000
  
  [web1]
  type = http
  local_port = 80
  custom_domains = site1.example.com
  
  [web2]
  type = http
  local_port = 81
  custom_domains = site2.example.com
  

• 3.4、启动客服端

  ./frpc -c ./frpc.ini
  

• 3.5、测试web访问

  http://site1.example.com:7000
  http://site2.example.com:7000
  

4、仪表盘

• 4.1、配置仪表盘

  设置仪表盘，可以查看，链接的状态以及使用的流量，在服务端frps.ini中设置仪表盘的端口dashboard_port，可以设置用户名和密码，不设置的话，默认都是admin。

  [common]
  dashboard_port = 7500
  dashboard_user = admin
  dashboard_pwd = admin
  

• 4.2、测试仪表盘访问

  访问http://x.x.x.x:7500。

  

5、其他内容

4.1、web服务可以设置https，要求是有域名证书，具体操作看文档

4.2、还有其他一些配置，比如P2P模式 等等其他的请看文档

jupyter notebook配置远程连接

配置jupyter远程访问，大概需要一下三个步骤，密码可以不设置，不过设置密码也会相对方便一点，在不设置密码的情况下，启动jupyter notebook会自动生成一个token，这个token作为链接的一部分，会比较难记。

1、生成notebook配置文件

执行以下命令，会在用户目录下生成的配置文件.jupyter/jupyter_notebook_config.py，之后在这个文件中再进行配置。

jupyter notebook --generate-config

2、生成密码

输入下面的命令，会在用户目录下生成一个保存有密码的哈希值的json文件，.jupyter/jupyter_notebook_config.json。

jupyter notebook password

3、修改配置文件

在用户目录下的.jupyter/jupyter_notebook_config.py中找到下面几行取消注释并修改，这几行分别对应修改可以访问的ip、启动jupyter notebook时是否开启浏览器，以及jupyter notebook服务对应的接口，其实直接将下面的几行复制到文件也可以。

c.NotebookApp.ip = '*'
c.NotebookApp.open_browser = False
c.NotebookApp.port = 8888

注意：如果用frp做内网穿透的话，这里的端口需要对应上面frp客户端web服务配置的端口号，tensorboard可视化等等其他web服务也是一样。

4、启动jupyter notebook并在后台运行

使用nohup命令后台运行jupyter notebook，并将输出的内容追加的内容输出到jupyter.out文件中，同时将错误信息也输出到文件中。

nohup jupyter notebook >>jupyter.out 2>&1 &

拓展知识

• nohup命令语法

  • nohup Command [ Arg … ] [ & ]

  nohup加上需要后台执行的命令以及命令的参数Command [ Arg … ]，以&结束

• >>表示追加，>表示覆盖。

• 2>&1：0表示键盘输入，1表示标准输出（屏幕输出），2表示错误输出。

总结

算是知道了几个内网穿透的工具，在使用的过程中，由于腾讯云服务器的带宽的限制，访问tensorboard的时候，加载图片有些慢，所以其实有这方面的真实需求，可以使用那些付费的内网穿透工具，例如natapp，有很多套餐，但是都不贵。

ssh、http、仪表盘的配置合并到一起的文件如下：

外网服务器frps.ini:

[common]
;ssh开通的端口，可以改
bind_port = 7000
;http开通的端口，可以改
vhost_http_port = 8080  
;仪表盘开通的端口，可以改
dashboard_port = 7500
;仪表盘账户名（可选），可以改
dashboard_user = admin
;仪表盘密码（可选），可以改  
dashboard_pwd = admin

内网服务器frpc.ini:

[common]
;外网服务器地址，需要改
server_addr = x.x.x.x
;外网服务器端口，可以改
server_port = 7000

[ssh]
;协议类型，不用改
type = tcp
;本地地址，不用改
local_ip = 127.0.0.1
;本地ssh的端口，不用改
local_port = 22
;远程ssh的端口，可以改
remote_port = 6000

;ssh访问方式：ssh 用户名@外网服务器地址 -p 远程ssh端口remote_port

[web1]
;协议类型，不用改
type = http
;本地地址，可以改，需要对应web服务的端口，如jupyter以及tensorboard远程访问端口需要设置为这里的端口
local_port = 80
;对应外网服务器二级域名的，需要改，而且二级域名需要添加到域名记录列表
custom_domains = site1.example.com

;web访问方式：外网服务器二级域名:外网服务器端口号，如http://site1.example.com:7000


[web2]
;协议类型，不用改
type = http
;本地地址，可以改，需要对应web服务的端口，如jupyter以及tensorboard远程访问端口需要设置为这里的端口
local_port = 81
;对应外网服务器二级域名的，需要改，而且二级域名需要添加到域名记录列表
custom_domains = site2.example.com

;web访问方式：外网服务器二级域名:外网服务器端口号，如http://site2.example.com:7000

pytorch框架选择GPU运行程序

pytorch框架选择GPU运行程序，发现os.environ["CUDA_VISIBLE_DEVICES"]="0"放置位置是有讲究的，需要放在倒入torch模块之前，才行。

经过测试，发现没有这个问题，之前我们遇到的问题是，程序没有用我自己设定的gpu跑代码，我调整了config文件（注：config文件中有语句os.environ["CUDA_VISIBLE_DEVICES"]="0"）的导入顺序之后，发现解决了问题，因此我错误的认为os.environ["CUDA_VISIBLE_DEVICES"]="0"需要在torch模块之前导入才行。

tqdm模块

tqdm.tqdm类

tqdm.__init__(iterable=None,
              desc=None,
              total=None,
              leave=True,
              file=None,
              ncols=None,
              mininterval=0.1,
              maxinterval=10.0,
              miniters=None,
              ascii=None,
              disable=False,
              unit='it',
              unit_scale=False,
              dynamic_ncols=False,
              smoothing=0.3,
              bar_format=None,
              initial=0,
              position=None,
              postfix=None,
              unit_divisor=1000,
              write_bytes=None,
              lock_args=None,
              nrows=None,
              gui=False)

所有的参数都是可选的，初始化方法返回一个已经装饰了的可迭代器。

iterable参数

需要用进度条装饰的可迭代的对象，list等等都可以。

desc参数

desc是进度条的前缀，字符串。如下图红框所示。

total参数

迭代的总次数，不设置的话，就等于可迭代对象的长度len(iterable)，具体用法如下，常用于手动设置更新迭代次数。

with tqdm(total=100) as pbar:
    for i in range(10):
        sleep(0.1)
        pbar.update(10)

pbar = tqdm(total=100)
for i in range(10):
    sleep(0.1)
    pbar.update(10)
pbar.close()

leave参数

布尔类型，默认为True，leave参数表示在迭代结束之后，是否保留进度条状态，如果设置为False或者None，则在迭代之后，不会保留最后的状态，而变成0，如下图所示。

file参数

io.TextIOWrapper或者io.StringIO，默认为sys.stderr，表示将进度条信息输出到那里。如下图所示。

ncols参数

输出信息所占的宽度，不指定，则为进度条的整个宽度，指定则为指定的宽度，如下图。

mininterval参数

进度条更新的最小时间间隔，默认为0.1秒。如下图。

更新进度条，其实就是说重新出来一个进度条。

maxinterval参数

进度条更新的最大时间间隔，默认为10秒，与mininterval类似。

miniters参数

进度条更新的最小迭代次数，当设置为0时，根据CPU性能自适应，指定了最小迭代次数，则经过了多少次迭代之后就会更新进度条。

ascii参数

bool或者str，如果不指定或者指定为False，会有滑块填充，如上面的图，有黑色的滑块，如果指定ascii参数，则不会有滑块出现，而是以#填充，并且没有进行完的地方会以数字滚动显示。

disable参数

bool，默认为False，如果指定为True则禁用了整个进度条，如果设置为None，在不是TTY（Teletypes，可以理解为在终端或者控制台上，不会禁用进度条）的情况下，禁用进度条。

经过尝试，在终端中设置为None，依然还是会显示进度条，而在jupyter notebook不会显示进度条。

unit参数

str，表示迭代次数的单位，默认是it，如下红色框框所示。

unit_scale参数

如果设定为1或者True，则会自适应数字单位，如下面的三万多变成了37.5k。

dynamic_ncols参数

默认为False，如果设置了，则会自适应输出的宽ncols和高nrows。

smoothing参数

默认为0.3，设置范围在0到1之间，表示速度估算的指数移动平均平滑因子，0为平均速度，1是当前速度/瞬时速度，表示的是在进度条变化的时候，显示的多少次迭代每秒是平均速度还是瞬时速度。（原话：Exponential moving average smoothing factor for speed estimates）

bar_format参数

进度条的格式，str，不同的进度条格式设置会影响性能，默认的格式是{l_bar}{bar}{r_bar}，其中l_bar是{desc}: {percentage:3.0f}%|，r_bar是|{n_fmt}/{total_fmt} [{elapsed}<{remaining},''{rate_fmt}{postfix}，这里可以设置很多参数，如下vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, percentage, elapsed, elapsed_s, ncols, nrows, desc, unit, rate, rate_fmt, rate_noinv, rate_noinv_fmt, rate_inv, rate_inv_fmt, postfix, unit_divisor, remaining, remaining_s。 当没有设置desc参数的时候，后面的冒号:会被自动去掉。

initial参数

默认值为0，表示初始的迭代次数，常用于新开始一个进度条。如下图，从3开始，最后变成50003次迭代。

position参数

默认为0，如果设置为其他数（记为N），它会在进度条前，先输出N个空行。

postfix参数

与desc参数相似，desc是前缀，postfix是后缀

unit_divisor参数

迭代次数的除数，也可以理解为单位，默认为1000，当unit_scale参数为True的时候，忽略这个参数。

write_bytes参数

表示写入二进制字节编码还是unicode编码，默认为写入unicode编码，当write_bytes参数为True时，写入二进制字节编码。

lock_args参数

tuple类型，刷新中间输出，通过tqdm.refresh()方法，获得中间输出.

nrows参数

与ncols参数类似，表示显示进度条的高度.

gui参数

将进度条使用matplotlib去画，进度条从字符串变成了图片。 不过不建议使用改参数，已经被tqdm.gui.tqdm(...)取代。

tqdm.update(n=1)方法

默认n=1，常用于手动更新迭代次数。

tqdm.close()方法

清除进度条，如果指定了leave=False，则进度条会被清理掉，反之还会留着。

tqdm.refresh(nolock=False, lock_args=None)方法

刷新进度条的显示。

tqdm.unpause()方法

重新开始打印时间，从上次停止的时间开始。

tqdm.reset(total=None)方法

重设total参数

tqdm.set_description(desc=None, refresh=True)方法

tqdm.set_description_str(desc=None, refresh=True)方法

重新设置desc参数，set_description_str方法，没有冒号:跟在desc参数后。

后面的一系列方法不再说明，大多数是重新设置初始化方法中的参数。

tqdm.trange()

与tqdm.tqdm()类似，tqdm.trange()代替了tqdm(range(*args), **kwargs)

tqdm.notebook.tqdm()与tqdm.notebook.trange()

在IPython和Jupyter Notebook中显示好看一些的进度条，使用方法和tqdm.tqdm()、tqdm.trange()类似。

tqdm.gui.tqdm()与tqdm.gui.trange()

用于GUI的进度条，使用方法和tqdm.tqdm()、tqdm.trange()类似。

实验性模块

好像暂时还不能用。

tqdm.contrib.tenumerate()

类似于python内建的enumerate方法

tqdm.contrib.tzip()

类似于python内建的zip方法

tqdm.contrib.tmap()

类似于python内建的tmap方法

自适应打印

from tqdm.auto import tqdm, trange

会根据环境的不同，输出不同样式的进度条。如下图所示。

小结

依旧比较啰嗦，其实主要知道tqdm, trange的用法就行。

from tqdm.auto import tqdm, trange

argparse模块

argparse模块与logging一样都是python自带的模块，这个模块让命令行解析(如下图)变得简单，也可以说是很简单的将程序构建成为一个命令行工具。

创建解析器

class argparse.ArgumentParser(prog=None, usage=None, description=None, epilog=None, parents=[], formatter_class=argparse.HelpFormatter, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True, allow_abbrev=True)

创建一个ArgumentParser对象的可设置的参数，有上面这么多，不过我都只自定义设置过一个参数description，其他参数都默认，这个description参数呢，是usage与agrument之间的一个对程序的描述，可见上面的图。ArgumentParser文档

加入参数

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

加入参数的过程是用上面创建解析器步骤的解析器对象调用add_argument方法来完成。add_argument方法文档，这块用的比较多的，我们一个一个参数看一下。

name or flags参数

name or flags表示参数的名字，可以使用多个名字，一般有下面两种用法，分别表示为可选参数和必选参数。

parser.add_argument('-f', '--foo') # 表示可选参数
parser.add_argument('bar') # 表示必须的参数

其中表示可选参数的形式，也可以通过required参数来将可选参数作为必选参数。

action参数

action参数是当解析参数时，当前参数有使用到的时候，调用action类来处理它。python提供了许多action，同时我们也可以自己实现。

• store，action参数的默认值，只存储参数值。

• store_const存储固定值，常用于可选参数。

• store_true 与 store_false，存储布尔类型的值，默认为True或者False，相当于default参数设置为了True或False。

• append存储一个列表，将值追加到列表，常用于可选参数多次指定，实例如下：

  >>> parser = argparse.ArgumentParser()
  >>> parser.add_argument('--foo', action='append')
  >>> parser.parse_args('--foo 1 --foo 2'.split())
  Namespace(foo=['1', '2'])
  

• append_const也是存储一个列表，与append类似，不过追加的是常量。

  >>> parser = argparse.ArgumentParser()
  >>> parser.add_argument('--str', dest='types', action='append_const', const=str)
  >>> parser.add_argument('--int', dest='types', action='append_const', const=int)
  >>> parser.parse_args('--str --int'.split())
  Namespace(types=[<class 'str'>, <class 'int'>])
  

• count存储参数出现的次数，未出现则为0。

  >>> parser = argparse.ArgumentParser()
  >>> parser.add_argument('--verbose', '-v', action='count', default=0)
  >>> parser.parse_args(['-vvv'])
  Namespace(verbose=3)
  

• help，输出帮助信息，如输出最上面那张图那样的内容，默认添加到解析器中，使用-h或者-help调用。

• version，输出版本信息。

  >>> import argparse
  >>> parser = argparse.ArgumentParser(prog='PROG')
  >>> parser.add_argument('--version', action='version', version='%(prog)s 2.0')
  >>> parser.parse_args(['--version'])
  PROG 2.0
  

• extend，存储一个列表将参数值加入到这个列表。

  >>> parser = argparse.ArgumentParser()
  >>> parser.add_argument("--foo", action="extend", nargs="+", type=str)
  >>> parser.parse_args(["--foo", "f1", "--foo", "f2", "f3", "f4"])
  Namespace(foo=['f1', 'f2', 'f3', 'f4'])
  

• 自定义action，没用过，这里贴上示例代码。

  >>> class FooAction(argparse.Action):
  ...     def __init__(self, option_strings, dest, nargs=None, **kwargs):
  ...         if nargs is not None:
  ...             raise ValueError("nargs not allowed")
  ...         super(FooAction, self).__init__(option_strings, dest, **kwargs)
  ...     def __call__(self, parser, namespace, values, option_string=None):
  ...         print('%r %r %r' % (namespace, values, option_string))
  ...         setattr(namespace, self.dest, values)
  ...
  >>> parser = argparse.ArgumentParser()
  >>> parser.add_argument('--foo', action=FooAction)
  >>> parser.add_argument('bar', action=FooAction)
  >>> args = parser.parse_args('1 --foo 2'.split())
  Namespace(bar=None, foo=None) '1' None
  Namespace(bar='1', foo=None) '2' '--foo'
  >>> args
  Namespace(bar='1', foo='2')
  

nargs参数

nargs参数关联不同数目的命令行参数到单一动作，也就是说nargs参数来规定命令行某个参数的个数。支持的值有N，?，*，+，argparse.REMAINDER，当nargs参数没有指定值，则参数的个数又action来决定。其中：

• N表示参数后的N个值组成为一个列表。

• ?表示的是多种情况，当参数没有出现的时候，参数的值是defalut参数的值，当参数后面没有跟着值的时候，参数的值是const参数的值，当参数出现并且后面有值的时候才参数的值才会是这个值。常用于输入输出文件，如下实例代码，没有输入输出文档，则从控制台读取以及写入。

  >>> parser = argparse.ArgumentParser()
  >>> parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
  ...                     default=sys.stdin)
  >>> parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),
  ...                     default=sys.stdout)
  >>> parser.parse_args(['input.txt', 'output.txt'])
  Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,
      outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)
  >>> parser.parse_args([])
  Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,
      outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)
  

• *表示参数后面跟的所有值，组合成为一个列表，作为这个参数的值；需要注意的是：必须参数中nargs参数中为*的情况不要出现多次，这样会引起冲突，而可选残生是没关系的。

• +与*相似，也是将参数后面跟的值，组合成一个列表，不同的是+要求参数后面跟的值至少又一个值。

• argparse.REMAINDER表示所有对不上号的参数组合成一个列表。

const参数

const参数是指定参数的常量值，当使用了store_const和 append_const动作的时候，必须指定const参数。

default参数

default参数指定参数的默认值，当default参数等于argparse.SUPPRESS，且参数没有出现时，则参数对应属性不存在。

type参数

type参数是参数对应的类型，type可以是任意可以调用的对象，而且传入字符串，返回操作后的值。

choices参数

choices参数传入一个容器，参数值只能从容器中选取一个，任何容器都可作为choices值传入，比如list 对象，set 对象以及自定义容器等。

required参数

required参数用于将可变参数变为必须参数。

help参数

help参数表示描述参数的字符串，由于帮助字符串支持%-formatting（示例如下），因此在这个帮助字符串中显示%，必须将其转义为%%。

parser.add_argument('bar', nargs='?', type=int,default=42, help='the bar to %(prog)s (default: %(default)s)')

metavar参数

使用metavar来指定一个参数的替代名称，需要注意的是，它只是替代了显示的名字，而正在调用的参数名称是由dest参数决定的。不使用metavar参数的默认情况下，对于位置参数动作，dest值将被直接使用，而对于可选参数动作，dest 值将被转为大写形式。 因此，一个位置参数dest='bar'的引用形式将为bar，一个带有单独命令行参数的可选参数--foo的引用形式将为FOO。

dest参数

设置解析参数所返回对象的属性名的，默认情况下，会接受第一个长选项字符串并去掉开头的--字符串来生成dest的值，如果没有提供长选项字符串，则dest将通过接受第一个短选项字符串并去掉开头的-字符来获得；如果名称内部有-字符都将被转换为_字符，来确保字符串是有效的属性名称。

解析参数

ArgumentParser.parse_args(args=None, namespace=None)

args是要解析的字符串列表，默认值是从sys.argv获取。 namespace用于获取属性的对象，默认值是一个新的空Namespace对象，这里的Namespace是一个具有可读字符串表示形式的对象。

解析参数，在这里不多说了，给一个示例代码。

示例代码

parser = argparse.ArgumentParser(description='train or val for our model which no embeding')

parser.add_argument("--exp", type=str, default="train_without_embeding", help="experiment")
parser.add_argument("--VOC2012_root_path", type=str, default="/home/mist/datasets/VOCdevkit/VOC2012",
                        help="the root of VOC2012 dataset")
parser.add_argument("--num_epochs", type=int, default=100, help="number of epoch")
parser.add_argument('--use_gpu', action='store_true',default=True, help='whether to use GPU')
parser.add_argument('--gpu', type=str, default="0", help='choose GPU')
parser.add_argument('--optimizer', type=str, default="Adam", choices=['SGD', 'Adam'], help='choose optimizer')

args = parser.parse_args()

小结

感觉这次还是有点在翻译官方文档的感觉，不过也算是将官方文档大概的看了一下，明天继续总结一下tqdm模块，加油，奥利给！

今天总结一下python模块，logging、argparse、tqdm，好早就想小结一下，一直没有做.（写的有点多，argparse、tqdm独立出来，下两篇） 还有《神经网络与深度学习》中的第七章的网络优化与正则化、第八章的注意力机制，看了好久了，也想总结一下，这几天都总结一下吧。

logging模块

logging是python自带的日志模块官方文档，这里主要总结一下Logger、Handler、Formatter对象以及常用的方法。

Logger对象-class logging.Logger

获取日志对象Logger

Logger类不能被直接实例化，需要用logging.getLogger(name)来获取日志对象。

常用方法

1. 设置日志对象输出信息的最低级别setLevel(level)，相应的日志级别
2. 添加处理日志的处理器对象addHandler(hdlr)
3. 输出对应级别的信息：debug(msg, *args, **kwargs)、info(msg, *args, **kwargs)、warning(msg, *args, **kwargs)、error(msg, *args, **kwargs)、critical(msg, *args, **kwargs)、log(level, msg, *args, **kwargs)、exception(msg, *args, **kwargs)，相应的日志级别。

日志级别

日志级别如下表，根日志对象默认的级别是NOTSET，而后代日志对象默认是WARNING，后代日志对象可以由getChild(suffix)方法来获取。

Handler对象-logging.Handler

Handler对象是可以直接实例化的，而且它还有很多子类，如下:

• StreamHandler：
  • StreamHandler(stream=None)
  • 输出日志到sys.stdout，sys.stderr或者是其他file-like文件对象，常用于输出到控制台
• FileHandler：
  • FileHandler(filename, mode='a', encoding=None, delay=False)
  • 输出日志到文件，继承了StreamHandler
• NullHandler：不做任何处理
• WatchedFileHandler：监测文件打开与关闭操作，输出日志
• BaseRotatingHandler：滚动处理RotatingFileHandler，TimedRotatingFileHandler的基类
• RotatingFileHandler：
  • RotatingFileHandler(filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False)
  • 这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小maxBytes之后，它会自动将当前日志文件改名，然后创建一个新的同名日志文件继续输出。比如日志文件是app.log。当app.log达到指定的大小之后，RotatingFileHandler自动把文件改名为app.log.1，如果app.log.1已经存在，会先把app.log.1重命名为app.log.2，一直到最后重新创建chat.log，继续输出日志信息，如果backupCount=5那么，最多创建备份到app.log.5。
• TimedRotatingFileHandler
  • TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None)
  • 这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。interval是时间间隔.when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：

    值	类型
    S	秒
    M	分
    H	小时
    D	天
    W0-W6	每星期（0表示星期一）
    midnight	每天凌晨

• SocketHandler：远程输出日志到TCP/IP sockets
• DatagramHandler：远程输出日志到UDP sockets
• SysLogHandler：日志输出到系统日志syslog
• NTEventLogHandler：远程输出日志到Windows NT/2000/XP的事件日志
• SMTPHandler：远程输出日志到邮件地址
• MemoryHandler：日志输出到内存中的制定buffer
• HTTPHandler：通过"GET"或"POST"远程输出到HTTP服务器
• QueueHandler：输出日志到队列中
• QueueListener：从队列中接受日志信息

以上这些logging.Handler子类，比较常用的是StreamHandler、FileHandler、RotatingFileHandler、TimedRotatingFileHandler。

常用方法

1. 设置处理器处理信息最低等级setLevel(level)
2. 设置输出日志信息格式setFormatter(fmt)，fmt为Formatter对象

Formatter对象-logging.Formatter

Formatter对象用于规定输出日志的格式，这些格式其实是来源于LogRecord对象的属性，不过可以通过字符串的方式直接创建，如实例代码中logging.Formatter。

格式就大概讲到这里，具体可以看实例代码。

实例代码

import logging
import os

class Logger():

    def __init__(self, logger_path):
        self.logger = logging.getLogger()
        self.logger.setLevel(logging.DEBUG)
        # 输出到文件
        self.logfile = logging.FileHandler(logger_path)
        self.logfile.setLevel(logging.DEBUG)
        # formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        formatter = logging.Formatter('%(asctime)s -%(filename)s:%(lineno)s - %(levelname)s - %(message)s')
        self.logfile.setFormatter(formatter)
        # 输出到控制台
        self.logdisplay = logging.StreamHandler()
        # self.logdisplay.setLevel(logging.DEBUG)
        self.logdisplay.setLevel(logging.INFO)
        self.logdisplay.setFormatter(formatter)
        self.logger.addHandler(self.logfile)
        self.logger.addHandler(self.logdisplay)

    def get_logger(self):
        return self.logger

from logger import Logger

logger = Logger('./test.log')
my_logger = logger.get_logger()

my_logger.info('hello, world')
my_logger.debug('hello, world')
## `debug(msg, *args, **kwargs)`
## `info(msg, *args, **kwargs)`
## `warning(msg, *args, **kwargs)`
## `error(msg, *args, **kwargs)`
## `critical(msg, *args, **kwargs)`
## `log(level, msg, *args, **kwargs)`
## `exception(msg, *args, **kwargs)`

小结

上面写了这么多，总结一起，主要就是上面的实例代码这部分代码，全文内容应该差不多可以满足我们大多数日常开放的使用，就总结到这了，用过滤器对象过滤输出等等其他内容就等待探索了，文档在此。

本来想logging、argparse、tqdm三个模块放一起的，发现写的有点多（啰里八嗦的），argparse、tqdm模块还是独立写出来吧。

论文简介 论文下载 源码地址

提出并解决问题

实时语义分割：希望同时做到分割速度快、分割质量高。有许多方法已经在一些benchmarks（例如：pascal voc、cityscapes、coco等等数据集）上取得好的效果。（拓展知识: 浅谈 baseline & benchmark & backbone中的理解）

提出问题

• 有些方法使用U-shape结构^u_shape（U型结构，例如下图结构），这种结构在处理高分辨率特征图时候，会消耗大量时间。（论文中这么说，我个人觉得还是跟网络深度有关系，这里没有明白为什么作者要特意的挑出U型结构。）

  • 有些工作通过限制固定的图像大小。
  • 有些工作会去掉特征图的一些“冗余”信息（比如使用Spatial Dropout，在DeepLabV3+论文中提到说不是所有的的特征都对解码模块有重要的作用）。

  一些方法通过以上两个方法来加快计算速度，但是相应的也存在一些问题。会丢失掉一些边界和小对象的空间细节

• 浅层网络（shallow network）的特征区分能力会比较弱，然而使用深层的网络（deep network）则会影响速度。

解决问题

为了解决以上问题，最大程度的利用特征，并尽可能的减少计算量，很多相应的结构产生了，如下图所示。

• 多分支（Multi-branch）结构，图中（a），使用这种多分支结构结合了空间细节和上下文信息，然而加入了额外的分支，会使得速度受到限制，并且相互独立的两个分支会限制模型的学习能力。
• 空间金字塔池化（spatial pyramid pooling）结构，图中（b），使用空间金字塔池化结构呢，加强了带有高层次上下文的特征（features with high-level context），但是这样也会显著的加大计算量，而且加强的特征是来自于单路径输出的特征图，缺乏低层次特征，而低层次特征同样保留空间细节和分割信息。
• 网络级的特征重用（feature reuse in network level）结构，图中（c），使用网络级的特征重用结构，则包括了低层次的特征。从图（c）中看，其实就是使用了单个网络结构的低层次与高层次的特征，那它为什么叫网络级的特征重用呢，其实是因为左边与右边的网络结构是一样的，只是输入的大小变小了。
• 阶段级的特征重用（feature reuse in stage level）结构，图中（d），这种结构在结合了网络级的特征重用结构的基础上，还在不同的阶段聚合特征，加强了特征表示能力，重用（reuse）高层次的特征打破了语义信息与空间结构细节的隔阂（gap）（即同时使用了低层次与高层次的特征）。

论文中提出的网络级的特征重用结构，图中（c）、阶段级的特征重用结构，图中（d），显然会消耗更多的空间以及算力，但是由于可以更好的利用特征，所以降低网络的深度，从而达到整体计算量减少的效果。

DFANet与其他语义分割模型比较

论文中方法DFANet（Deep Feature Aggregation Network）与其他语义分割模型性能与计算量比较，如下图。

横坐标单位为GFLOPs（Giga FLoating-point Operations），十亿浮点运算次数，衡量模型的复杂度（计算量），这个概念需要和全大写的FLOPS（floating point operations per second），意指每秒浮点运算次数，是一个衡量硬件性能的指标（每秒的计算速度）。 纵坐标是准确率（交叠率，mIoU），可以看出效果在性能与计算量是比较均衡的。 其中DFANet A与DFANet B是在使用不同的backbone的情况下进行比较，DFANet A使用的backbone的计算量是DFANet B的两倍（1.6GFLOPs：0.83GFLOPs），DFANet A与DFANet A‘是在不同的输入图像大小的情况下进行比较的，DFANet A的输入图片的大小为1024x1024，DFANet A‘的输入大小为512x1024。

相关的工作与概念

相关工作

实时的语义分割相关工作：

• SegNet使用比较小的架构（small architecture）和池化索引策略（pooling indices strategy）来减少网络参数。
• ENet减少下采样的次数，追求的紧致的框架，然后去掉了模型的最后一个阶段，使得感受野变小，以至于导致对大的对象分割效果不够好。
• ESPNet使用了新的空间金字塔结构。
• ICNet使用多尺度的图像作为输入，并且使用一个级联网络来提升效率。
• BiSeNet使用空间路径（spatial path）和语义路径（semantic path）来减少计算量。

相关概念

• 深度分离卷积（Depthwise Separable Convolution）：深度卷积操作由逐深度卷积（depthwise convolution）加逐点卷积（pointwise convolution）构成，可以在保持很小的性能（效果）损失的情况下，减少参数和计算量。Xception模块中的卷积就是深度分离卷积，因而兼顾了语义分割速度和准确度。相关概念可以查看这个帖子Depthwise卷积与Pointwise卷积。
• 高层次特征（High-level Features）：高层次的特征刻画了输入图片的语义信息，分割任务关键在于感受野与分类能力，PSPNet、与DeepLab系列网络使用额外的操作将山下问信息和多尺度特征表示信息合并到一起。空间金字塔池化已经广泛的应用，作为对整体场景理解（overall scene interpretation）一个好的描述。
• 上下文编码（Context Encoding）：SENet使用逐深度注意力（channel-wise attention）提升了模型特征的表示。EncNet使用上下文编码来加强对每个像素点分割结果的预测，这本篇论文中使用全连接模块作为attention，来提升backbone性能（会对性能有一点点影响）。
• 特征聚合（Feature Aggregation）：实现特征聚合有跳跃连接（skip connection），另外还有密集连接（dense connection），另外RefineNet提出在上采样解读提取多尺度特征的模块。

论文中提出的方法

模型

论文提出的模型主要分三部分轻量级权重的backbone（the lightweight backbones）, 子网络级的聚合（sub-network aggregation ）模块和子阶段级的聚合（sub-stage aggregation ）模块，而其中子网络级的聚合模块和子阶段级的聚合模块是相融在一起的，如下图。

模型图中，“C”表示串联到一起（concatenation），“xN”代表上采样N倍。“+”表示对应元素相加，‘x’表示对应元素相乘，fc attention模块是Xception中的全连接层，加上一个1x1卷积^1x1_conv在于之前的特征逐元素相乘（[B, 1000, 1, 1] 通过1x1卷积得到[B, 192, 1, 1]），其他各个模块的细节如下图， ，conv1是普通的卷积操作，enc2、enc3、enc4中的卷积都是深度分离卷积操作，Xception A与Xception B是两种不同的Bakcbone。^Xception

在模型图中decoder那部分紫色的conv都没有体现卷积的通道，我看了代码它是输出64个通道的1x1卷积，所以输出大小维持原大小。在解码阶段的卷积只是做了减少通道数量的操作。

训练细节

• 损失是用的交叉熵损失
• backbone是用的作者自己修改后的Xception模型，并在ImageNet-1k数据集^ImageNet_1k上进行训练，然后用于DFANet模型的预训练。
• fc attention^attention模块中的全连接层参数也是来自backbone中的全连接层参数。

总结与感受

DFANet: Deep Feature Aggregation for Real-Time Semantic Segmentation 这篇论文主要提出了一种特征聚合网络结构，结合了网络级的特征重用模块、阶段级的特征重用模块，达到了比较好的分割性能的情况下，同时有比较好的实时性。

这次总结大多已翻译为主了，大多是翻译了一些我认为可以拿出来讲一下的东西总结在了这里，也算是了解了一种新的特征聚合模块吧，不过还是对当前工作是有启发的，我们当前的特征是用的backbone最后的输出，没有结合低层次的特征，之前一直想使用结合多个层次的特征，而这篇论文正提供了一种方法。

暂且总结到这里，做ppt，准备下周的汇报了。

论文简介 论文下载 源码地址

效果图

先看效果图吧（图一），图c的embedding效果图确实挺好的。

下面来看论文主体内容吧。

摘要与引言

论文一开始就说结合了现在流行的两种实例分割方法：基于分割方法（先分割然后聚类）、基于建议方法（先检测然后预测mask），打到了Mask R-CNN的性能以及速度的同时，文章中的方法是one-stage方法，而Mask R-CNN是具有代表性的two-stage方法。

这里说一下我所理解的one-stage、two-stage以及end-to-end吧。^one_stage__two_stage__end_to_end

论文还提到了Mask R-CNN存在的两个问题：

• “RoIPooling/RoIAlign”（相关概念可以看一下这篇博客）步骤的结果会导致特征的丢失和长宽比变形（the distortion to the aspect ratios），“RoIPooling/RoIAlign”主要的作用是将不同大小的建议框对应的feature map映射到统一大小，方便后续的处理，由于建议框大小不是固定的，所以结果对应到建议框的区域的长宽比可能是变形的（比如建议框大小为大小为665x665，而经过“RoIPooling/RoIAlign”要固定成7*7大小的特征图，这个映射的比例是2.86:1，这个比例不成整数，固而扭曲了长宽比），从而会丢失一些细节。
• 原话：it still sustains weakness in being complex to adjust too many parameters. 我不确定这里的参数是说的模型参数还是超参数，不过我更偏向于是超参数太多。

然后论文中还提到了现在基于分割的one-stage方法，在聚类上有瓶颈，例如有很难确定簇的数量以及簇的中心，从而在性能上不如基于建议方法。

论文中方法结合基于分割方法与基于建议方法，使用两个embedding概念，像素上的嵌入（embedding for pixels），实例建议上的嵌入（embedding for instance proposals，来表示框以及分类），在簇与簇之间使用灵活的间隙（margin）来训练。

EmbedMask

模型

图中模型主体是FCOS模型^fcos（一个物体检测模型），蓝色的部分是论文中新加入的内容，加入了像素级别和建议框上的嵌入以及建议间隙（用来灵活的建议框中像素嵌入向量之间的间隙）。

生成Mask

生成Mask的方法是求像素级别的嵌入向量与建议框的嵌入向量（作为建议框中实例簇的中心）的欧式距离，距离小于margin时，则属于建议框分类的实例，反之不属于，公式如下：

$$ Mask_k(x_i) = \begin{cases} 1,\ \ ||p_i-Q_k|| \leq \sigma & \ 0,\ \ ||p_i-Q_k|| > \sigma \end{cases} $$

其中$Mask_k(x_i)$是像素点$x_i$属于实例$k$的对应的Mask值，$p_i$是像素点对应的像素级别的嵌入向量，$Q_k$是像素点所属建议框对应分类k的嵌入向量，$\sigma$则是margin。

论文中还提到这个margin是可以学习得到的（由Box Regression经过1x1的卷积后得到，可见模型图），而上面那种常用的方法到这里还并不能学习，而论文中提到参考了一篇论文中的方法，使用高斯函数，将这个margin融入到生成属于分类对象$k$的Mark的概率图中。公式如下：

$$\phi(x_i, S_k) = \phi(p_i, Q_k, \Sigma_k) = exp(-\frac{||p_i-Q_k||^2}{2{\Sigma_k}^2})$$

其中$\phi(x_i, S_k)$是指像素点$x_i$属于实例$S_k$的概率，而$\Sigma_k$是实例$k$对应的Margin。（由Box Regression经过1x1的卷积后得到。）

就这样，将Margin融入到了训练参数中，而在训练的时候$Q_k$与$\Sigma_k$与推理的时候的$Q_k$与$\Sigma_k$是有所区别的。训练的时候$Q_k$与$\Sigma_k$的计算公式如下：

$$Q_k = \frac{1}{N_k} \sum_{j\in M_k} q_j$$

$$\Sigma_k = \frac{1}{N_k} \sum_{j\in M_k} \sigma_j$$

其中$N_k$是在实例$S_k$中正采样的像素点的个数，$M_k$是实例$k$的对应的Mask。

正因为推理的时候与训练的时候的不同，在损失函数上对其进行了约束，见smooth损失。

可学习的的间隙（Margin）

论文中提到了两点使用手动设置固定的margin的问题：

• 找到一个比较好的值相对较难
• 对于多尺度对象的训练不太友好，因为像素级别的嵌入向量在大的对象往往比较发散，而在小的对象却比较集中（即距离的跨度或者说范围与对象大小成正比，当对象越大时，像素嵌入向量的距离的范围跨度会大一些，而对象笔比较小的时候，范围跨度会小一些）。

损失函数

1. 用于优化Mask的损失函数

使用二分类损失函数，公式如下，但在实践中，作者发现使用lovasz-hinge loss^lovasz_hinge_loss损失更好，这个损失暂时还么了解。

$$L_{mask}=\frac{1}{K}\sum_{k=1}^K\frac{1}{N_k}\sum_{p_i\in B_k}L(\phi(x_i,S_k), G(x_i,S_k))$$

其中$L(·)$是二分类（交叉熵）损失、$B_k$ 是实例$k$的对应的推荐框内的像素点集，$\phi(x_i, S_k)$是指像素点$x_i$属于实例$S_k$的概率，$G(x_i,S_k)$是像素点$x_i$属于实例$S_k$的真实值，属于为1，不属于为0。

2. Smooth损失

由于在训练的时候的$Q_k$与$\Sigma_k$与推理的时候的$Q_k$与$\Sigma_k$是有所区别的，所以使用Smooth损失来约束它，让$q_j$与$Q_k$以及$\sigma$与$\Sigma_k$尽量接近。公式如下：

$$ \begin{aligned} L_{smooth} & = \frac{1}{K}\sum_{k=1}^K\frac{1}{N_k}\sum_{j\in M_k}||q_j - Q_k||^2 \ & + \frac{1}{K}\sum_{k=1}^K\frac{1}{N_k}\sum_{j\in M_k}||\sigma_j - \Sigma_k||^2 \end{aligned} $$

其中$M_k$是实例$k$的对应的Mask。

3. 整体的损失

整体的损失公式如下：

$$L=L_{cls}+L_{center}+L_{box}+\lambda_1L_{mask}+\lambda_2L_{smooth}$$

其中原始分类的损失$L_{cls}$、中心损失（center-ness loss）$L_{center}$、边框回归损失（box regression loss）$L_{box}$还是沿用FCOS那篇论文中的，而加了上面提到的两个损失$L_{mask}$、$L_{smooth}$。

模型整个处理过程

EmbedMask整个过程大概是：给定一张图片，通过修改后的物体检测网络FCOS，经过NMS（non-maximum suppression，非极大值抑制），得到最终建议的实例集$S$，对应这个实例集中的实例$S_k$有它的边框值、类别分数、推荐边框的嵌入向量$q_j$、推荐边框的间隙（Margin）$\sigma_j$，计算代表实例k的嵌入向量$Q_k$和可学习的阈值$\Sigma_k$，再通过计算$\phi(x_i, S_k)$（$\phi(p_i, Q_k, \Sigma_k)$）得到$x_i$属于$S_k$的概率，设置阈值为0.5，生成最终Mask。

总结与感受

首先这个网络主体是使用的物体检测网络FCOS，加入了像素上的嵌入，实例建议上的嵌入，对这些我的感触都不大，最让我感觉学到了的是可学习的间隙（margin），我们当前的课题，是使用的固定的间隙，也确实遇到多尺度对象的训练效果不好的问题，我想之后我们得使用类似论文中的方法改进这点，算是意外收获了，还有就是结合使用中间层的特征，我们暂时还没有用起来，一直有提说要用上，看这篇论文也是这样用的。

好了，先记录到这了。

今天整理了一下博客，大概看了一下jekyll-TeXt-theme的源码，

1. 把TOC(目录)从右边移到了，加大了一下字体。
2. 在查看效果的时候，惊奇的发现，TOC没有内容的时候，依旧有会占据这块地方，然后又改了一下代码，在没有内容的时候隐藏一下TOC。
3. 看jekyll-TeXt-theme文档的时候，又发现了一些好玩的东西，jekyll 脚注(Footnote)^Footnote、还有定义(Definition)^Definition，画图[^ChartAndMermaid]等等。
4. 设置了一下图片居中，将如下css代码加入到_article-content.scss文件的img:not(.emoji)标签中，同时注释掉vertical-align项，参考链接。

    clear: both; 
    display: block; 
    margin:auto; 
    // vertical-align: middle; // 注释掉
   

5. 最后还把博客的标题命名，文件命名统一了一下。

好了，最后点下题，我又回来了。

明天算法与数据结构课、文献检索与论文写作结课结课，要考试、要汇报，溜了溜了。

[^ChartAndMermaid]: 图表Chart的文档链接 、流程图、时序图等等Mermaid图的文档链接，这里的Mermaid图，其实是一个JavaScript库的名字，用来画图的库，翻译过来为美人鱼。

Pipenv——最好用的python虚拟环境和包管理工具

粗略的总结一下使用pipenv创建虚拟环境，主要可以看上面那博客。

Installation

If you're on MacOS, you can install Pipenv easily with Homebrew:

$ brew install pipenv

Or, if you're using Debian Buster+:

$ sudo apt install pipenv

Or, if you're using Fedora 28:

$ sudo dnf install pipenv

Or, if you're using FreeBSD:

# pkg install py36-pipenv

Otherwise, refer to the documentation for instructions.

主要使用到的命令

创建虚拟环境过程

$ pipenv install

使用特定的python环境 $ pipenv —python 3.7

进入pipenv环境

$ pipenv shell

pipenv下安装包

$ pipenv install module-name

example：pipenv install tensorflow-gpu

pipenv环境下执行python

$ pipenv run python source.py

pipenv查看已安装的包和包依赖

$ pipenv graph

退出pipenv环境

$ exit 或者 ctrl+d

pipenv相关命令

☤ Usage

$ pipenv
Usage: pipenv [OPTIONS] COMMAND [ARGS]...

Options:
  --where          Output project home information.
  --venv           Output virtualenv information.
  --py             Output Python interpreter information.
  --envs           Output Environment Variable options.
  --rm             Remove the virtualenv.
  --bare           Minimal output.
  --completion     Output completion (to be eval'd).
  --man            Display manpage.
  --three / --two  Use Python 3/2 when creating virtualenv.
  --python TEXT    Specify which version of Python virtualenv should use.
  --site-packages  Enable site-packages for the virtualenv.
  --version        Show the version and exit.
  -h, --help       Show this message and exit.


Usage Examples:
   Create a new project using Python 3.7, specifically:
   $ pipenv --python 3.7

   Remove project virtualenv (inferred from current directory):
   $ pipenv --rm

   Install all dependencies for a project (including dev):
   $ pipenv install --dev

   Create a lockfile containing pre-releases:
   $ pipenv lock --pre

   Show a graph of your installed dependencies:
   $ pipenv graph

   Check your installed dependencies for security vulnerabilities:
   $ pipenv check

   Install a local setup.py into your virtual environment/Pipfile:
   $ pipenv install -e .

   Use a lower-level pip command:
   $ pipenv run pip freeze

Commands:
  check      Checks for security vulnerabilities and against PEP 508 markers
             provided in Pipfile.
  clean      Uninstalls all packages not specified in Pipfile.lock.
  graph      Displays currently–installed dependency graph information.
  install    Installs provided packages and adds them to Pipfile, or (if no
             packages are given), installs all packages from Pipfile.
  lock       Generates Pipfile.lock.
  open       View a given module in your editor.
  run        Spawns a command installed into the virtualenv.
  shell      Spawns a shell within the virtualenv.
  sync       Installs all packages specified in Pipfile.lock.
  uninstall  Un-installs a provided package and removes it from Pipfile.

根据这篇文章来， HP 筆記型電腦 -- 更新 BIOS

其中：第三步：打開硬件診斷 UEFI 功能表 选用【通過 Windows 8 訪問 UEFI】

最后更新bios这个步骤时，按【f9 设备启动方式】选择【从文件中启动】，在hpbiosupdate文件夹中找到HpBiosUpdate.efi，点击启动，再从按文章中的步骤4的第4步开始进行下一步。

利器 JupyterLab 数据分析必备IDE完全指南 - 游薪渝的文章 - 知乎 包括如何安装、有哪些特性、插件的推荐等等，其中Jupyterlab_voyager还不支持jupyter lab 1.13以上的版本

JupyterLab插件 推荐了一些插件。

如何优雅地使用 Jupyter？ - 知乎

pdfboxNet库

PDFBox是Java实现的PDF文档协作类库，提供PDF文档的创建、处理以及文档内容提取功能，也包含了一些命令行实用工具，pdfboxNet也就是pdfbox的.Net实现了。

主要特性包括：从PDF提取文本、合并PDF文档、PDF文档加密与解密、与Lucene搜索引擎的集成、填充PDF/XFDF表单数据、从文本文件创建PDF文档、从PDF页面创建图片、打印PDF文档等等。

大概参考了一下这篇文章，C#读取PDF ——PDFBox使用，其中不需要和文章中说的一样取下载库文件，在VS集成开发环境中，使用NnGet直接搜索安装就好了。

文章有点古老了，技术我也不知道是不是被淘汰了，其实我只是想验证我的想法，打开PDF提取相关信息，这里就以及验证了可以提取信息，虽然后来通过进一步的交流发现，那边又整理好的EXCEL表格，可能是检索EXCEL吧，还是步完全清楚需求，罢了罢了，继续玩一玩PDF相关的东西吧。

PDF winform控件

一想，玩一下PDF相关的Winform控件吧，随后就开始找了。

Adobe提供的ActiveX控件

Adobe提供的ActiveX控件，这里没有具体尝试，需要在安装adobe acrobat。

相关链接

【C# 基础】— 解决 "winForm 引用 Adobe PDF Reader控件不显示pdf 文件" 问题 CSDN问题：C# winform Acrobat Reader 显示pdf如何获取当前页数,提到了Free Spire.PDFViewer、devexpress pdf的控件

DevExpress的PDF控件

听说比较好用，有点跃跃欲试的感觉，但是一个license需要18k+，果断放弃了，不过网上有破解版，之后有时间再尝试一下。

相关链接

PDF Viewer文档

基于DevExpress实现对PDF、Word、Excel文档的预览及操作处理

DevExpress控件使用详细说明

DevExpress 编译成功的 dll

DevExpress 18 源代码编译方法

2014年DevExpress使用教程合集

DevExpressSources151

devexpress 使用安装、破解注册和汉化包进行汉化的步骤

DevExpress安装文件、源码、注册破解下载

没有尝试的收费的PDF控件

ComponentOne-PDF for WinForm

Free Spire.PDFViewer for .NET 收费，但是也有免费版，免费版有功能上的限制，比如只能显示10页。

开源的PDF控件

PDF Viewer Control Without Acrobat Reader Installed 很老的开源项目了，09年的。

The PDFView4NET toolkit 免费的，并且持续更新，有时间再尝试一下。相关链接

PdfiumViewer

一个免费的.NET的PDF控件库。PdfiumViewer GitHub库 PdfiumBuild GitHub库

PdfiumBuild库的下载，对应在NuGet下载PdfiumViewer.Native.x86_64.v8-xfa库和PdfiumViewer.Native.x86.v8-xfa库就好了，而PdfiumViewer库在NuGet对应的搜索下载就好了。

其中我下载了PdfiumViewer Github上的源码，跑了PdfiumViewer的Demo项目，除了页面老了点，其他是极好的。

写在最后

PDF相关的库就大概接触了一下上面这些了，不多说了，PDF相关的东西，以后有用得到再翻一翻看一看吧。

论文简介 论文下载

概述

根据上图，大概描述一下整个模型，首先给定视频的一帧，通过在DeepLabV3+架构，去掉最后一层，得到骨干特征（backbone features）并再头部（top of that）加上一个嵌入层（embedding layer）的网络，得到每一个像素点的嵌入向量（对应的得到整个嵌入向量空间），随后对应于每一个对象，通过当前嵌入空间和前一帧图片的嵌入空间计算得到全局匹配距离图（global matching distance map），通过当前嵌入空间和前一帧图片的嵌入空间计算得到本地匹配距离图（local matching distance map），随后将骨干特征（backbone features）（共享，复制N份，N为对象的个数）和对应于一个对象的全局匹配距离图、本地匹配距离图、前一帧的预测结果组合到一起，形成一个维度为[w/4, h/4, 259(256+3)]的张量，再将这个张量作为分割头网络（segmentation head）的输入，得到每一个点对于每个对象的logits值（校正值），将其堆叠在一起，通过softmax函数得到一个张量[w/4, h/4, N]，即为处理的结果，对应于每个点属于每个对象的概率。

下面分别较为详细一点的总结一下各个部分内容。

语义嵌入（semantic embedding）

对于每一个像素点，都提取一个实体嵌入向量在学习到的嵌入空间中，这里定义一下两个像素点的距离。

$$d(p,q)=1-\frac {2}{1+exp({\vert \vert e_p -e_q \vert \vert }^2)}$$

当两点距离比较远的时候，距离趋近于1，当两点距离比较近的时候距离趋近于0，关于点的距离的计算都是用像素点对应的嵌入向量。

全局匹配（global matching）

定义全局匹配公式为

$$ G_{t, o}(p) = min_{q \in P_{1, o}} d(p, q)$$

这里的t代表第几帧，o为全体对象的一个，$G_{t, o}(p)$为第t帧中像素点p与第一帧对象o的最小距离，而$P_{1, o}$对应于第一帧所属对象o的像素点集合。

假设第一帧对象o中有n个像素点，则这里的$G_{t, o}(p)$是第t帧中的一个像素点p到这n个像素点中的最短距离。

本地前一帧匹配（local previous frame matching）

$$ \hat G_{t, o}(p) = \begin{cases} min_{q \in P_{t-1, o}} d(p, q), &{ if\ P_{t-1, o}\neq \emptyset}\ 1,&{otherwise}\end{cases} $$

这里与全局匹配类似，计算上一帧与当前帧的距离，但是，当这一帧不存在对象o的时候设置距离为1。

显而易见的是，这里可以优化，在我们计算第一帧与当前帧的距离的时候，两帧可能变化比较大，不得不计算所有的点的距离，但是在计算当前帧的时候，其实两帧之间的变化是比较小的，我们可以只计算部分点，论文中提出了一种方法优化，减少计算量。

给定一个窗口大小k（作者设置k=15），以p点为中心，向上下左右延伸k个像素点，记这个像素点集合为$N(p)$，集合中存在有$(2\cdot k +1)^2$个元素，让集合$N(p)$与$P_{1, o}$去交集，再计算距离，没有交集的情况，距离直接设置1，这里的原理是只有p点周围的像素点中存在属于对象的像素点的时候，才进行计算，周围没有属于对象的像素点的时候，看作没有变化不进行计算。

$$ L_{t, o}(p) = \begin{cases} min_{q \in P_{t-1, o}^p} d(p, q), &{ if\ P_{t-1, o}^p\neq \emptyset}\ 1,&{otherwise}\end{cases} $$

其中$P_{t-1, o}^p = P_{t-1, o} \cap N(p)$

前一帧的预测结果（previous frame predications）

对应对象的预测结果图为二值图，属于该对象的像素点对应值为1，不属于该对象的像素点对应值为0，但是用在下一帧的预测时的图是只经过softmax的可能性图（soft probability map）。

除了前一帧预测的可能性图，还有全局匹配距离图和本地前一帧距离图，它们与当前帧的嵌入空间堆积到一起作为动态分割头网络的输入，下面大概说一下动态分割头网络。

动态分割头（dynamic segmentation head）

可以看到上面的模型图，动态分割头网络只前向运行一次，各个对象之间共享权重，最后对应每个对象生成一个一维的校正值（logits）特征图，将它们堆叠到一起，再对象层面的维度运用softmax函数，得到像素点属于各个对象的可能性，最后损失函数使用交叉熵损失，最后再大概说一下大概的训练过程。

训练过程（training procedure）

对于训练的每一步，首先随机选取训练集中的一个mini-batch的视频，再每一个视频中随机选取3帧，一帧做“第一帧”，另外两个临近的帧，分别作为“前一帧”和当前帧，再经过上面所说的一系列的运算并进行训练（loss为softmax情况下的交叉熵损失）。

推论或结论（inference）

FEELVOS是简单的、直接的（straightforward），对于每一帧只需要一次前向传播，这里作者又将整个测试过程大概说了一遍：给定一个测试视频和第一帧的真实值（ground truth），首先提取第一帧的嵌入向量，随后，一帧一帧的计算当前帧的嵌入向量，并于第一帧计算全局匹配（global matching）和前一帧计算本地匹配（local matching），结合前一帧的预测结果，对每一个对象运行动态分割头（dynamic segmentation head）网络，再对每个像素执行softmax（原文是argmax）生成最终的分割结果。

实现细节（implementation details）

提取特征的网络是DeepLabv3+架构（基于Xception-65架构），运用逐深度可分离卷积（depthwise separable convolutions），批标准化（batch normalization），深黑的空间金字塔池化（atrous spatial pyramid pooling），和一个步长为4的生成特征的解码模块。

这里作者的方法加了一个嵌入层（embedding layer）组合在逐深度可分离卷积层（depthwise separable convolutions），设置提取的嵌入向量维度为100。

在动态分割头，作者发现一个大的接收域（large receptive field）是很重要的（这里的接收域还没有完全理解），作者使用了4层逐深度可分离卷积层（256维）和一层核大小为7x7的逐深度的卷积层，最后加一层1x1的卷积来提取一维的校正值（logits）。

文中还提到了在全局匹配中计算所有成对的像素点的距离是很昂贵的，而且并不是所有的像素都又必要考虑的，所以提出了一种优化方法，在训练中，参考点集取随机子样本（randomly subsample），从第一帧变成每个对象最多包含1024个像素点，即本身要计算整张图片，变成每个对象最多计算1024点，极大的减小了计算量，并且作者指出对结果几乎没有影响。

对于本地匹配，窗口大小k=15，也就是对于取以点p为中心的$(2*15+1)^2$，窗口大小在这一小节提到本地前一帧匹配。

在开始训练时，使用DeepLabv3+在ImageNet和COCO训练好的参数。

训练数据，作者使用的是DAVIS 2017数据集中的60个训练视频。

作者还运用了一个白举交叉熵损失，对于计算损失，只考虑最难的15%的像素点。

在优化的时候，使用带有动量的梯度下降（$momentum = 0.9$），学习率$\alpha=0.0007$，每一捆的大小（$batch\ size = 3\ videos$）,训练200000（20万）步。

最后还运用了标准数据增强（standard data augmentation），例如翻转和缩放、随机剪切输入图像为465x465像素。

其他实验细节这里不再细说，需要实现的时候再回顾论文。

总结与感受

看了这篇论文，除了对模型的了解，还学到了两种降低计算成本的思路（对全局匹配取随机子样本进行计算，还有对于本地匹配取窗口），挺好的，虽然没有取跑一遍他的实验，但是还是学到了很多思想了，还是希望自己有一个好的改进的方法的时候，然后再好好做实验吧，加油！

嵌入模型（embedding model）

学习一个嵌入模型（维度为[h, w, d]的张量），使用logistics损失来训练它。

相似度

$$\sigma(p,q)=\frac{2}{1+exp(||e_p-e_q||)}$$

其中，$\sigma(p,q)$ 表示点p与点q的相似度，当两者在嵌入空间（$e_p$ 与 $e_q$）比较近时，$\sigma(p,q)=\frac{2}{1+e^0}=1$，两者比较远时，$\sigma(p,q)=\frac{2}{1+e^\infty}=0$。

损失函数

$$L_e=-\frac{1}{|S|}\sum_{ {p,q}\in S}w_{pq}[1_{{y_p=y_q}}log(\sigma(p,q))+1_{{y_p\neq y_q}}log(1-\sigma(p,q))]$$

其中$S$ 是"种子点"集合，这里的$\vert S \vert$表示集合中种子点的个数，$w_{pq}$是点p与点q相似度损失的权重，$w_{pq}$与点p和点q所属的实例大小成反比，添加这个权重，从而使得损失函数不会偏向于更大的样本，$$1_{{y_p=y_q}}$$表示当$$y_p=y_q$$成立的时候式子取1，不成立则取0，$$1_{{y_p\neq y_q}}$$同理。

论文中还提到了正则化权重，$\sum_{p,q}w_pq=1$ 。

在训练开始时，在每一个实例中随机取样，选取K个点来作为种子点，假设有N个实例，则种子点集合元素个数$\vert S \vert=N \cdot K$，在这里只计算在$\vert S \vert$中的点与点之间的相似度损失，选取种子点机制在分类和选种子点模型说明，以上说的点都是用嵌入空间对于点的嵌入向量来计算的。

创建遮罩（creating masks）

创建遮罩机制

对于种子点p，比较所有其他点q，当p与q的相似度大于一个阈值的时候，则记q点与p点属于同一个遮罩，反之，则不属于同一个遮罩，一般记为背景，公式如下：

$$m(p,\tau)={ q:\sigma(p,q) \geq \tau }$$

对于阈值$\tau$，论文中提到，作者实验中使用阈值的数值$$\tau \in {{ 0.25,0.5,0.75}}$$。

向量化距离公式

在计算相似度的公式中，计算两点的距离$\vert\vert e_p - e_q \vert\vert_2^2$，将其向量化，$A^2+B^2-2A \bigodot B$，其中$A$是嵌入空间张量（维度为[h, w, d]，h为高度，w为宽度，d为嵌入维度），$B$是K个种子点的嵌入向量（维度为[k, d]），这里再计算相似度，再阈值化（thresholding）处理矩阵就好了。

选取种子点机制

当p点与种子点q的相似度大于一个阈值时，则将这个点p设置为与点q同类，反之属于背景，由此可知每一个种子点都会产生一个二值遮罩，那么我们如何选种子点呢？首先选择每个类中一个“种子度”最高的点，这个点是在各个阈值$\tau$（各个分类模型下）下取属于某个类别的最大可能性中的最大值对应的点，结合一个“正则项”选点。

选择第t个种子点

$$p_t=arg\ max_{p \notin p_{1:t-1}}[log(S_p)+\alpha log(D(p,p_{1:t-1}))]$$

其中，

$$ S_p = max_{\tau \in \mathit{T}}\ max_{c=1}^C \mathit{C}_{pc}^{\tau} $$

$$ D(p,p_{1:t-1}) = min_{q \in p_{1:t-1}} ||e_p - e_q ||_2^2 $$

$S_p$表示p点的种子度（seediness），$D(p,p_{1:t-1})$表示p点与已选择的点中的最小距离，在论文中提到处理不同大小的对象分别对每一个阈值$\tau$训练一个分类模型（原文：To handle objects of different sizes, we train a different classification model for each value of $\tau$;），在实验中作者使用阈值的范围为$$\mathit{T}={{ 0.25, 0.5, 0.75, 0.9 }}$$，即$\tau \in {{ 0.25, 0.5, 0.75, 0.9}}$对应每个阈值生成一个模型，$S_p$为在每一个阈值$\tau $的分类模型下，取属于c类的可能性的最大值，随后,再取对应各个阈值下的最大可能性的最大值，$C_{pc}^{\tau}$是在阈值为$\tau$产生的模型下,点p属于c类的可能性。$arg \ max$表示后面的式子取最大值时的变量值，这里是取最大值时对应的点。

$\alpha \ log(D(p,p_{1:t-1}))$ 可以简单理解为正则项，作用是让新选的p点与已经选择了的t-1个种子点的距离大一些，这里体现为惩罚新选p点与已经选择的t-1个点的最小距离。

简单总结一下，选种子点机制，平衡p点属于c类的可能性的最大可能性和p点远离已选点，选择取最大值时的p点。

分类和种子度模型（classification and seediness model）

处理的机制

创建遮罩时，通过$m(p,\tau)$，当q点与p点的相似度大于阈值时，将p点的真实值（ground truth）复制给q点，反之将背景的标签设置给q点，整个图完成这个工作之后，将分配的标签转为one-hot形式，再对每个实例的K个种子点，使用softmax交叉熵损失来训练模型。

$$ L_{cls} = -\frac{1}{|S|}\sum_{p \in S}\sum_{c=0}^{C}y_{pc}\ log \ \mathit{C}_{pc}$$

当我们已经选择了最好的种子点集之后，我们就可以算出对应最好的阈值和在选择最好的阈值的情况下相关的置信度。

最好的阈值以及对应的标签c

$$(\tau, c_p) = arg \ max_{\tau \in \mathit{T},c \in {1:\mathit{C}}} C_{pc}^{\mathit{T}}$$

置信度

$$ S_p = \mathit{C}_{p,c_p}^{\mathit{T}_p} $$

共享全图片卷积特征

这里主要告诉我们特征提取器基于DeepLab v2模型（基于resnet-101），使用COCO进行预训练，损失函数如下：

$$L = L_c + \lambda L_{cls}$$

这里超参数$\lambda$的设置在这里不详细讲了，跑代码的时候自己再调一下，论文中说到作者最大使用0.2。

这部分请看论文原文吧。基于深度度量学习的语义实例分割（Semantic Instance Segmentation via Deep Metric Learning）

总结与感受

我个人认为论文给我们最重要的方法是自动选取种子点的方法，这样就可以实现自动化分割实体，在应用上，比如重上色，其实选点的过程下可以让用户交互，用户都只要交互一次，在训练上的话，难度也比较小，当然如何我们还是让用户去交互的话，应用面就被限制了，再回到用户交互的方式的话那就是一种退步。 回到方法，感觉还是有点难度的，可能还没有完全搞懂，可能是没有跑代码的原因吧，不过现在大概知道其中的思想了，以后有需要再好好回顾论文吧。

之前在暑假的时候，可以直接在Notebook中下载包，然后运行TensorFlow，Pytorch，百度升级了两次平台，现在已经不可以了，但是我们可以通过终端下载包，上传代码，然后运行，训练就好了。

安装包

上传package.txt,包括python包信息 打开终端，下载包，命令如下

pip3 install -r package.txt

pip不可使用，更新一下就可以使用了，命令如下

pip3 install --upgrade pip 

将数据以及代码上传到AI Studio工作空间，执行代码训练模型。

相关链接

python如何从txt文件中批量pip安装包

Ubuntu下安装Python 3.7

Centos/Linux 下升级python2.7至3.5.0

Google Colab 免费GPU服务器使用教程

在Kaggle免费使用GPU训练自己的神经网络

更新博客

今天再一次尝试了百度AI studio，kaggle，谷歌colab这三个平台。

百度的AI studio在基础版cpu的情况下，是可以上传代码进行训练，再带gpu的主机上没有权限。

kaggle上传文件这块受到限制了，自己写代码还是可以的，每个星期有30个小时的免费GPU使用时间，然后就是有丰富的数据集，可以不用下载下来，可以参加竞赛拿奖金，预装了tensorflow和pytorch等等。

谷歌的colab和百度的差不多，但是开放程度更高，稳定性更好，预装了tensorflow和pytorch，有免费的GPU，15g网盘。

翻墙工具

附上两个翻墙工具链接，不是完全免费的。

SocketPro

W加速器

命令

查看linux系统版本

cat /proc/version

查看cpu信息

cat /proc/cpuinfo

查看内存信息

cat /proc/meminfo

英伟达系统管理接口,查看cuda信息gpu信息等等。

nvidia-smi

python更新pip

python -m pip install –upgrade pip

相关说明

可以直接再jupyter lab的notebook模式直接执行shell命令

执行shell命令Shell是一种与计算机进行文本交互的方式。一般来讲，当你正在使用Python编译器，需要用到命令行工具的时候，要在shell和IDLE之间进行切换。但是，如果你用的是Jupyter，就完全不用这么麻烦了，你可以直接在命令之前放一个“!”，就能执行shell命令，完全不用切换来切换去，就能在IPython里执行任何命令行。In [1]: !ls

In [2]: !pwd
/home/Parul/Desktop/Hello World Folder
In [3]: !echo "Hello World"
Hello World

再次安装依赖包

注意将所依赖的包以及版本信息保存到txt文件中，方便之后再安装使用，colab好像不需要重新安装包（可再次考证一下），ai studio每次都需要重新安装。

pip常用命令 pip freeze,pip show等等。

下载数据集，进行训练

这一块，我们把各个平台，当作一个云主机，直接执行命令下载数据集，上传代码，然后就可以进行训练了。

突发奇想

学校的APP特别不好用，经常吐槽它，就在昨天晚上，我们突发奇想，看可不可以将一些内容迁移到小程序上，于是我说干就干了，首先我反编译了APK，随后看了一些相关代码，找了到一些接口的URL以及传递的参数名，然而不知道参数是什么样的形式，随后使用fiddler开始抓包，其中碰到了一个不能抓取https协议请求的问题，这里附上配置链接，安卓配置，iOS配置，解决了这个问题，抓到包，但是发现了参数中的token需要解决，解决不了无法提供给多人使用，所以我又看了一下代码，发现他是使用了一个单例模型，将一个类的实例转为String作为token，但是这里我不太确定只有这一种方法，因为我看到了登录的接口中，返回的参数返回了一个token，可能分不同的情况吧，到这里我开始打退堂鼓了，还得好好锻炼，一个人还是很难耐得住寂寞。

反编译APK

再这里记录一下反编译APK的步骤吧。

参考链接

第一步、解压APK

使用WINRAR解压软件解压APK包，得到.dex文件。

第二步、使用apktool反编译APK

注意需要安装java 8以及以上版本的JDK。参考链接

下载工具

下载脚本apktool.bat，下载jar包apktool.jar，注意，这里下载的包需要更名为apktool.jar

配置环境变量

将apktool.bat和apktool.jar所在文件夹添加到环境变量中，或者这两个文件放到C://Windows目录下。

执行反编译命令

命令格式为 apktool d [apk文件] [输出文件夹]

apktool d base.apk base

第三步、使用dxe2jar反编译APK

这里将解压出来的.dex转为jar包。

下载工具

下载dex2jar

执行命令

再dex2jar文件夹中执行命令，命令格式d2j-dex2jar.bat [dex文件路径]，注意将所有的.dex文件转换为jar包。

d2j-dex2jar.bat E:\classes.dex

第四步、使用jd-gui查看jar源代码

下载jd-gui，使用jd-gui打开jar包查看源码。

论文提出一种将特征空间的点分簇的损失函数，损失函数主要分为三项构成，分别为方差项（variance term），距离项（distance term），正则项（regulariztion trem），其中方差项计算的是簇内的距离，距离项计算的是簇与簇的距离，分别控制同簇点与簇中心之间的距离在δv之内，不同簇与簇的中心距离大于δd，论文下载地址

论文主要关注于损失函数，主要关注于训练出好的特征空间（如Embedding Space）。

带有歧视的损失函数

定义

$C$是真实值中的簇的总数，$N_c$簇$c$中的元素数量，$x_i$是一个元素对应的嵌入向量，$\mu_c$是$c$簇中嵌入向量的平均值（簇的中心），$\vert\vert\cdot\vert\vert$是L1距离或者L2距离，$[x]_+$是max(0,x)定义的铰链函数，$\delta_v$和$\delta_d$代表方差和距离损失的间隙。

方差项

$$L_{var} = \frac{1}{C}\sum_{c=1}^C\frac{1}{N_c}\sum_{i=1}^{N_c}[||{\mu_i-x_i}||-\delta_v]_+^2$$

距离项

$$L_{dist}=\frac{1}{C(C-1)}{\sum_{c_A=1}^{C}\sum_{c_B=1}^{C}}{c_A \neq c_B}[2\delta_d-||{\mu{c_A}-\mu_{c_B}}||]_+^2$$

正则项

$$L_{reg}=\frac{1}{C}\sum_{c=1}^{C}||\mu_c||$$

完整损失函数

$$L=\alpha\cdot{L_{var}}+\beta\cdot{L_{dist}}+\gamma\cdot{L_{reg}}$$

在实验时，作者设置$\alpha=\beta=1$，$\gamma=0.001$。

其他内容

论文还说到了后处理（post-processing），包括增强鲁棒性（increasing robustness）等等， 还有其他实验的设置和数据集，还有优缺点等等，这里最后说一下这个方法的优缺点（pros and cons）。

优缺点

论文中方法，在有重叠部分的情况下依然有好的效果，比如在合成的零散的线条中，在数据集图片中有比较相似的实例时，效果也比较好，但是，在随机多种多样的数据集中，效果不太好，在只有一个的实例对象的图片中训练效果不是太好。

MathJax数学公式

MathJax语法

MathJax语法

在线MathJax公式书写