图像分割应用的最大阻碍是缺乏高质量标注的训练数据。深度分割模型的泛化能力依赖大规模和高质量的像素级标注数据。 事实上，图像分割标注是一个昂贵且耗时的过程。对于新的任务或是需要快速应用的场景，数据稀缺问题更为严重。因此，数据标注的高成本降低了模型在新任务和扩展性，从而阻碍了深度分割模型在现实中的应用。
为了缓解数据标注压力，当前已有大量的工作来进行半监督和弱监督的图像分割。例如，利用少量精确标注的数据、稀疏的标注、带噪声的标注、分类标注或者以上几种组合实现半监督图像分割模型。 然而，半监督图像分割具有其天然的难度和挑战性，需要特定的模型设计以及学习策略。

任务

任务： 训练集中只有一个子集有完全的标注。
半监督学习的几个假设：

• 平滑性假设：相近的图片应该具备相同的标注；
• 低密度分离假设（聚类假设）：决策边界应该位于数据分布密度相对较低的区域（见下图）；
• 流形假设：输入空间由多个低维流形组成，所有数据点均位于其上；位于同一流形上的数据点具有相同标签。

挑战：半监督学习场景的主要挑战在于如何高效、彻底地利用大量未标记的数据。

1. 从少量数据中学习并防止过拟合
2. 充分利用无标记数据
3. 利用先验知识获得泛化性能更好的模型

半监督分割相关方法

半监督分割的最常见方法包括：

• 通用策略：数据增强、迁移学习、先验知识学习、课程学习和小样本学习；
• 利用未标记数据：自训练、一致性正则、协同训练、自监督学习和对抗学习。

数据增强

数据增强能够降低过拟合到少量标注数据的风险。
经典的数据增强方法： 数据几何变换，例如随机仿射变换、随机裁剪、随机擦除、颜色强度变换等；
合成更多样化和更真实的标记数据的方法： 混合图像、特征空间增强和生成对抗网络 。

Mixing and Cutting: Mixup线性插值一对随机的训练图像和相应的标签。Cutout在训练数据上采用区域 dropout 策略的思想，即遮挡图像的一部分。CutMix是 Mixup 和 Cutout 结合，通过用不同图像的一部分替换图像的一部分[1]。

Auto Augment: 基于强化学习的搜索算法为目标数据集寻找最有效的数据增强策略[2]，来最小化验证集上的误差。这里选择16种图像变换来限制策略搜索空间。一个策略由5个子策略组成，每个子策略依次应用两个图像变换。每个变换包含两个参数：使用的概率和强度（例如，在70%概率下旋转30度）。为了使用离散搜索算法，作者将强度范围离散为10个值（均匀间距），同时将概率离散化为11个值（均匀间距）。模型使用控制器决定哪种数据增强策略，并通过在验证集上运行一个子模型实验来测试该策略的泛化能力。控制器以验证的准确性作为奖励信号进行更新，使用近似策略优化算法更新控制器参数。最后总体上最好的5个策略（每个包含5个子策略）被选择作为该数据集上的最佳策略。

Adversarial data augmentation: 利用对抗样本（adversarial example[3,5]，见下图）来训练鲁棒的模型。如何设计和构造更逼真的对抗扰动是核心问题。

基于梯度的对抗样本生成方法直观且强大。它旨在通过利用神经网络的学习方式，即梯度来攻击神经网络。攻击使用损失函数对输入数据的梯度，调整输入数据以最大化损失。Fast Gradient Sign Method (FGSM)[3]形式化表述为:
$$
x^{\prime}=x+\epsilon \cdot \operatorname{sign}\left(\vec{\nabla}_{x} J(\Theta, x, y)\right) .
$$

# FGSM attack code from https://pytorch.org/tutorials/beginner/fgsm_tutorial.html
def fgsm_attack(image, epsilon, data_grad):
    # Collect the element-wise sign of the data gradient
    sign_data_grad = data_grad.sign()
    # Create the perturbed image by adjusting each pixel of the input image
    perturbed_image = image + epsilon*sign_data_grad
    # Adding clipping to maintain [0,1] range
    perturbed_image = torch.clamp(perturbed_image, 0, 1)
    # Return the perturbed image
    return perturbed_image


# input image
data.requires_grad = True
# Forward pass the data through the model
output = model(data)
# Calculate the loss
loss = F.nll_loss(output, target)
# Zero all existing gradients
model.zero_grad()
# Calculate gradients of model in backward pass
loss.backward()
# Collect datagrad
data_grad = data.grad.data
# Call FGSM Attack
perturbed_data = fgsm_attack(data, epsilon, data_grad)

Generative adversarial networks: 直接合成新的带标签的数据来做数据增强。例如跨模态数据合成等。

参考文献：
[1] CutMix: Regularization Strategy to Train Strong Classifiers with Localizable Features. (ICCV 19)
[2] AutoAugment: Learning Augmentation Policies from Data. (CVPR 19)
[3] Explaining and Harnessing Adversarial Examples. (ICLR 15)
[4] AutoAugment - Learning Augmentation Policies from Data. (CVPR 19)
[5] DeepFool: a simple and accurate method to fool deep neural networks. (CVPR 16)

自监督学习

自监督学习主要是利用辅助任务（pretext）从大规模的无监督数据中挖掘自身的监督信息，通过这种构造的监督信息对网络进行训练，从而可以学习到对下游任务有价值的表征。对比学习是一种比较流行的自监督辅助任务。
少量论文研究了如何构建像素级的自监督辅助任务，如[1]中根据像素空间距离构建像素级的正负样本对来进行像素级的自监督学习。

参考文献：
[1] Propagate Yourself: Exploring Pixel-Level Consistency for Unsupervised Visual Representation Learning. (CVPR 21)
[2] Contrastive Semi-Supervised Learning for 2D Medical Image Segmentation. (MICCAI 21)

迁移学习

在许多深度学习研究中，迁移学习也狭义地指“预训练再微调”策略，如backbone训练和数据集迁移。例如，SimCLRv2自监督学习通用表征，通过fine-tune和知识蒸馏实现半监督分类。

课程学习

课程学习首先从任务的更简单的方面或更简单的子任务开始，然后逐渐增加难度级别。

• 数据(data)课程学习：重加权（reweighting）目标训练分布的数据，即对训练数据进行非均匀采样。核心在于如何确定样本的重要性，并基于重要性决定样本呈现的顺序。因此它能够很好的和先验知识结合。实验表明这种方式能避免糟糕的局部最优并取得良好的泛化能力[1]。例如，根据病例的严重程度决定训练顺序，或是multiple experts的不确定性作为困难程度。
  自步(self-paced) 学习是一种特殊的数据课程学习：它根据模型的反馈（如loss），动态地决定数据学习顺序[2]。
• 任务(task)课程学习：首先解决简单但相关的任务，为以后解决更复杂的任务提供辅助信息。类似于分割的多阶段训练。例如，对于左心室的分割，先学习目标区域的大小，再学习分割任务[3]。

参考文献：
[1] Deep active self-paced learning for accurate pulmonary nodule segmentation. (MICCAI 18)
[2] Selfpaced curriculum learning. (AAAI 15)
[3] Curriculum semi-supervised segmentation. (MICCAI 19)

小样本学习

小样本分割（Few-shot Segmentation，FSS）的目的是在基础（base）语义类别上学习一个模型，但在未见过（unseen）的类别上，只用k个带标注的样本实现语义分割，而无需重新训练模型。新类别的k个带标注的样本通常被称为支持集（support set）。FSS根据support set预测每个查询图像（query set）的分割。

现有的小样本分割方法分类：

• 基于分类的原型网络（Prototypical Networks）[1]，使用后处理来获得分割结果[2]（与弱监督语义分割类似）；
• 直接利用propotypes做像素级的度量而不用后处理[3]，也就是把分割作为逐像素的分类。

原型网络： 是一种基于度量学习的元学习方法，它将样本投影到一个度量空间，且在这个空间中同类样本距离较近，异类样本的距离较远。（上图）原型（prototypes）是指每个类别的support set样本的embedding的均值，query样本通过计算与prototypes的距离进行分类。

$N_C$ way $N_S$ shot learning的含义：$N_C$是Support set中的类别数量，$N_S$是support set中每个类别包含的样本数量。如何理解few-shot learning中的n-way k-shot? - 知乎
基于Prototypical Networks实现的few-shot训练流程：

1. 从所有类别中随机采样$N_C$个类别，类别子集记为$V$；
2. 对每个类别，选择$N_S$个样本构建support set $S_k$；
3. 选择$N_Q$个样本作为query set；
4. 利用support set的embedding计算prototypes $c_k$；
5. 计算loss $J$，也就是最小化每一个query 样本和对应的prototype之间的距离。

参考文献：
[1] Prototypical Networks for Few-shot Learning. (NeurIPS 17)
[2] CANet: Class-Agnostic Segmentation Networks with Iterative Refinement and Attentive Few-Shot Learning. (CVPR 19)
[3] PANet: Few-Shot Image Semantic Segmentation with Prototype Alignment. (ICCV 19)

自训练

自训练是指模型最初只在小规模的标记数据上进行训练，然后同时用带标记数据和伪标记数据进行训练。

自训练的挑战主要是： 1)提高伪标签质量和2)减少噪声伪标签的负面影响。

为了降低噪声伪标签的负面影响，使用多种不确定性或置信度估计方法，整体上不确定性估计可以分为：

• 数据不确定性（aleatoric uncertainty）
• 模型不确定性（epistemic uncertainty）

在深度网络中生成伪标签和量化不确定性的流行方法包括贝叶斯神经网络、Monte Carlo Dropout、Monte Carlo BatchNorm，以及深度集成（Deep ensemble）。贝叶斯神经网络通过学习参数的后验分布来捕捉模型的不确定性，通常难以实现且训练计算速度缓慢 。

非贝叶斯策略，包括 Monte Carlo Dropout 和深度集成更有吸引力：

• Monte Carlo Dropout：随机Dropout的情况下，利用深度网络的多个前向的结果来估计不确定性。
• Deep Ensemble：分别训练不同训练子集 或不同初始化的多个网络，然后将预测结合起来进行不确定性估计。

医疗影像分割中，[1,2,3]使用Monte Carlo Dropout作为Uncertainty来指导未标注/弱标注数据的自训练。[4] 使用多模型Ensemble估计置信度，使用不同的初始化和训练顺序。

参考文献：
[1] A Macro-Micro Weakly-supervised Framework for AS-OCT Tissue Segmentation. (MICCAI 20)
[2] Uncertainty guided semi-supervised segmentation of retinal layers in OCT images. (MICCAI 19)
[3] Uncertainty-aware self-ensembling model for semi-supervised 3d left atrium segmentation. (MICCAI 19)
[4] Confidence Calibration and Predictive Uncertainty Estimation for Deep Medical Image Segmentation. (TMI 20)

协同训练

协同训练 Co-training[1]可以视作自训练/伪标签训练的一个扩展：将单网络自训练扩展至多个模型。在半监督分割中，通常使用不同训练子集 或不同初始化的多个网络，彼此互相提供伪标签（或是估计不确定性）来实现协同训练。

参考文献：
[1] Deep Co-Training for Semi-Supervised Image Recognition. (ECCV 18)
[2] Deep Co-Training for Semi-Supervised Image Segmentation. (PR 20)

一致性正则

一致性正则基于模型应该对类似的输入产生一致的预测的假设：模型对同一个样本不同扰动或变换的版本，应输出相同的预测。也就是最小化不同版本的预测之间的差异，以获得一个具有更好泛化能力的模型。一致性正则是半监督，弱监督以及噪声标签学习中使用最广泛的正则方法。

分割任务中常见的扰动/变换：

• 输入图像颜色变换[1]
• 图像几何变换（对于几何/空间变换，分割强调等变性，而分类要求不变性）
• 中间特征扰动（如Dropout）[2]
• 网络参数扰动（两个网络不同的初始化），类似于co-training

输出一致性损失形式：

• 最小化预测概率/中间特征的距离(MSE，JS，KL divergence)[2]
• 生成伪标签监督（Cross Entropy）[1,3]

参考文献：
[1] PseudoSeg: Designing Pseudo Labels for Semantic Segmentation. (ICLR 21)
[2] Semi-Supervised Semantic Segmentation with Cross-Consistency Training. (CVPR 20)

对抗训练

生成对抗网络（GAN）训练两个子网络，一个作为鉴别器，旨在识别样本是来自真实数据还是由生成器生成，另一个作为生成器，旨在生成鉴别器无法区分的样本。GAN已经被广泛用于半监督分割[1,2]和域适应分割中。例如，一种直接的想法是：鉴别器输出的置信度可以被当作质量评估，用于选择最好的预测结果用于后续的self-training[1]。

参考文献：
[1]Semi-Supervised Semantic Segmentation with High- and Low-level Consistency. (TPAMI 21)
[2]Semi Supervised Semantic Segmentation Using Generative Adversarial Network. (ICCV 17)

总结

上文总结了深度半监督语义分割的任务设定、主要挑战和主流的技术手段。总结起来，数据增强、迁移学习和课程学习等方法能够缓解过拟合到少量带标注样本的问题，自监督学习、自训练、一致性正则、协同训练和对抗训练则提供了利用无监督样本的方法。

Valine Admin 是 Valine 评论系统的后端功能补充和增强，主要实现评论邮件通知、评论管理、垃圾评论过滤等功能。支持完全自定义的邮件通知模板，基于Akismet API实现准确的垃圾评论过滤。

教程使用LeanCloud国际版做演示。

云引擎一键部署

进入评论系统数据库所在的LeanCloud应用。进入「云引擎-设置」，设置环境变量以及云引擎域名。**以下参数需要正确设置。云引擎域名（ADMIN_URL参数）用于评论后台管理，如 。

切换到「云引擎-部署」，部署模式选择「部署项目-Git部署」，分支「master」，手动部署目标环境为「生产环境」在Leancloud云引擎设置界面，填写代码库并保存：https://github.com/DesertsP/Valine-Admin.git，即可一键部署。

评论管理

首先需要设置管理员信息。访问管理员注册页面https://云引擎域名/sign-up，注册管理员登录信息，如：https://deserts-io.avosapps.us/sign-up

• 注：使用原版Valine如果遇到注册页面不显示直接跳转至登录页的情况，请手动删除_User表中的全部数据。

定时任务设置

关于自动休眠的官方说法：点击查看。目前实现了两种云函数定时任务来解决云引擎休眠的问题：

• 自动唤醒，定时访问Web APP二级域名防止云引擎休眠；
• 每天定时检查过去24小时内漏发的邮件通知。

进入「云引擎-定时任务」，创建两个定时任务。

选择self-wake云函数，Cron表达式为0 */30 0-16 * * ?，表示每天早0点到晚16点每隔30分钟访问云引擎。

选择resend-mails云函数，Cron表达式为0 0 0 * * ?，表示每天0点检查过去24小时内漏发的通知邮件并补发。

• 关于国际版时区的问题：国际版使用UTC-0时间，注意与国内时间对应。

至此，Valine Admin 已经可以正常工作，以下是可选配置。

更多设置

邮件通知模板

邮件通知模板在云引擎环境变量中设定，可自定义通知邮件标题及内容模板。

邮件通知包含两种，分别是被@通知和博主通知，这两种模板都可以完全自定义。默认使用经典的蓝色风格模板（样式来源未知）。

默认被@通知邮件内容模板如下：

<div style="border-top:2px solid #12ADDB;box-shadow:0 1px 3px #AAAAAA;line-height:180%;padding:0 15px 12px;margin:50px auto;font-size:12px;"><h2 style="border-bottom:1px solid #DDD;font-size:14px;font-weight:normal;padding:13px 0 10px 8px;">您在<a style="text-decoration:none;color: #12ADDB;" href="${SITE_URL}" target="_blank">            ${SITE_NAME}</a>上的评论有了新的回复</h2> ${PARENT_NICK} 同学，您曾发表评论：<div style="padding:0 12px 0 12px;margin-top:18px"><div style="background-color: #f5f5f5;padding: 10px 15px;margin:18px 0;word-wrap:break-word;">            ${PARENT_COMMENT}</div><p><strong>${NICK}</strong>回复说：</p><div style="background-color: #f5f5f5;padding: 10px 15px;margin:18px 0;word-wrap:break-word;"> ${COMMENT}</div><p>您可以点击<a style="text-decoration:none; color:#12addb" href="${POST_URL}" target="_blank">查看回复的完整內容</a>，欢迎再次光临<a style="text-decoration:none; color:#12addb" href="${SITE_URL}" target="_blank">${SITE_NAME}</a>。<br></p></div></div>

效果如下图：

@通知模板中的可用变量如下（注，这是邮件模板变量，是指嵌入到HTML邮件模板中的变量，请勿与云引擎环境变量混淆）：

默认博主通知邮件内容模板如下：

<div style="border-top:2px solid #12ADDB;box-shadow:0 1px 3px #AAAAAA;line-height:180%;padding:0 15px 12px;margin:50px auto;font-size:12px;"><h2 style="border-bottom:1px solid #DDD;font-size:14px;font-weight:normal;padding:13px 0 10px 8px;">您在<a style="text-decoration:none;color: #12ADDB;" href="${SITE_URL}" target="_blank">${SITE_NAME}</a>上的文章有了新的评论</h2><p><strong>${NICK}</strong>回复说：</p><div style="background-color: #f5f5f5;padding: 10px 15px;margin:18px 0;word-wrap:break-word;"> ${COMMENT}</div><p>您可以点击<a style="text-decoration:none; color:#12addb" href="${POST_URL}" target="_blank">查看回复的完整內容</a><br></p></div></div>

博主通知邮件模板中的可用变量与@通知中的基本一致，PARENT_NICK 和 PARENT_COMMENT 变量不再可用。

这里还提供一个彩虹风格的@通知邮件模板代码：

<div style="border-radius: 10px 10px 10px 10px;font-size:13px;    color: #555555;width: 666px;font-family:'Century Gothic','Trebuchet MS','Hiragino Sans GB',微软雅黑,'Microsoft Yahei',Tahoma,Helvetica,Arial,'SimSun',sans-serif;margin:50px auto;border:1px solid #eee;max-width:100%;background: #ffffff repeating-linear-gradient(-45deg,#fff,#fff 1.125rem,transparent 1.125rem,transparent 2.25rem);box-shadow: 0 1px 5px rgba(0, 0, 0, 0.15);"><div style="width:100%;background:#49BDAD;color:#ffffff;border-radius: 10px 10px 0 0;background-image: -moz-linear-gradient(0deg, rgb(67, 198, 184), rgb(255, 209, 244));background-image: -webkit-linear-gradient(0deg, rgb(67, 198, 184), rgb(255, 209, 244));height: 66px;"><p style="font-size:15px;word-break:break-all;padding: 23px 32px;margin:0;background-color: hsla(0,0%,100%,.4);border-radius: 10px 10px 0 0;">您在<a style="text-decoration:none;color: #ffffff;" href="${SITE_URL}"> ${SITE_NAME}</a>上的留言有新回复啦！</p></div><div style="margin:40px auto;width:90%"><p>${PARENT_NICK} 同学，您曾在文章上发表评论：</p><div style="background: #fafafa repeating-linear-gradient(-45deg,#fff,#fff 1.125rem,transparent 1.125rem,transparent 2.25rem);box-shadow: 0 2px 5px rgba(0, 0, 0, 0.15);margin:20px 0px;padding:15px;border-radius:5px;font-size:14px;color:#555555;">${PARENT_COMMENT}</div><p>${NICK} 给您的回复如下：</p><div style="background: #fafafa repeating-linear-gradient(-45deg,#fff,#fff 1.125rem,transparent 1.125rem,transparent 2.25rem);box-shadow: 0 2px 5px rgba(0, 0, 0, 0.15);margin:20px 0px;padding:15px;border-radius:5px;font-size:14px;color:#555555;">${COMMENT}</div><p>您可以点击<a style="text-decoration:none; color:#12addb" href="${POST_URL}#comments">查看回复的完整內容</a>，欢迎再次光临<a style="text-decoration:none; color:#12addb"                href="${SITE_URL}"> ${SITE_NAME}</a>。</p><style type="text/css">a:link{text-decoration:none}a:visited{text-decoration:none}a:hover{text-decoration:none}a:active{text-decoration:none}</style></div></div>

效果如图：

垃圾评论检测

Akismet (Automattic Kismet)是应用广泛的一个垃圾留言过滤系统，其作者是大名鼎鼎的WordPress 创始人 Matt Mullenweg，Akismet也是WordPress默认安装的插件，其使用非常广泛，设计目标便是帮助博客网站来过滤留言Spam。有了Akismet之后，基本上不用担心垃圾留言的烦恼了。
启用Akismet后，当博客再收到留言会自动将其提交到Akismet并与Akismet上的黑名单进行比对，如果名列该黑名单中，则该条留言会被标记为垃圾评论且不会发布。

如果还没有Akismet Key，你可以去 AKISMET FOR DEVELOPERS 免费申请一个；
当AKISMET_KEY设为MANUAL_REVIEW时，开启人工审核模式；
如果你不需要反垃圾评论，Akismet Key 环境变量可以忽略。

为了实现较为精准的垃圾评论识别，采集的判据除了评论内容、邮件地址和网站地址外，还包括评论者的IP地址、浏览器信息等，但仅在云引擎后台使用这些数据，确保隐私和安全。

如果使用了本站最新的Valine和Valine Admin，并设置了Akismet Key，可以有效地拦截垃圾评论。被标为垃圾的评论可以在管理页面取消标注。

手动配置邮件服务器

• 自定义邮件服务器地址和端口信息，删除SMTP_SERVICE环境变量，新增以下变量：

Troubleshooting

• 部署失败，请在评论中附图，或去Github发起Issue
• 邮件发送失败，确保环境变量都没问题后，重启云引擎
  
• 博主通知模板中不要出现PARENT*相关参数，注意区分MAIL_TEMPLATE和MAIL_TEMPLATE_ADMIN
• 点击邮件中的链接跳转至相应评论，这一细节实现需要在Web前端添加一点额外的代码：

<script>
    if(window.location.hash){
        var checkExist = setInterval(function() {
           if ($(window.location.hash).length) {
              $('html, body').animate({scrollTop: $(window.location.hash).offset().top-90}, 1000);
              clearInterval(checkExist);
           }
        }, 100);
    }
</script>

• 建议参考的其他教程：Valine Admin食用指南，解决valine-admin云引擎唤醒失败 等，特别感谢track13，Spoience，以及在Github和评论区讨论的各位同学。

macOS和iOS间的接力功能非常好用，最近发现它时常失效，每次都得关闭蓝牙重新开启，短暂的正常后还是会失效，同时蓝牙鼠标也会在休眠唤醒后失效。尝试过各种方案后，发现真正有效的还是解决蓝牙问题。

• 在菜单栏中显示蓝牙图标
• 按住option+shift同时点击蓝牙图标-调试-移除所有设备，还原蓝牙模块
• 重新连接蓝牙设备后正常（无需单独连接iPhone和 Watch等通过iCloud共享的蓝牙设备）

此外，在设置-安全和隐私中，取消勾选“使用您的 Watch解锁App和Mac”，再次勾选，就会发现Apple Watch解锁功能也复活了。

实验室有数十台GPU服务器以及近30人的使用这些机器，而且有些机器的IP会经常变化。一个简单的需求是：如何快速地获知机器的IP地址以及GPU的运行状态？

通常我们会在shell中执行nvidia-smi来查看机器的GPU使用状态，当机器数量太多时变得异常麻烦。笔者利用LeanCloud数据库简单实现了一套工具，将所有机器的信息汇聚在Web页面来显示。

利用LeanCloud做数据库，设计了一个简单的GPU运行状态信息的Hub。每台机器定时将GPU信息发送到LeanCloud数据库，然后用一个前端页面将GPU信息展示出来。

服务器信息同步

在所有服务器上定时运行该Python脚本，即可将信息同步到LeanCloud数据库。

GPU Hub

访问https://nvidia-smi.github.io/signin.html获取 GPU信息，使用你的LeanCloud的AppID和AppKey作为认证信息。如下图

多人共享的GPU服务器最大的痛点在于，每个人都希望拥有root权限并且过度自信。

笔者接手实验室的服务器管理以来，尝试LXD容器作为虚拟化方案至今已有一年多。机器多为4卡TitanXP或4卡2080Ti，近30个人共享使用。总体上，LXD虚拟化方案运行稳定，使用方便，配合一系列脚本，能够极大的解放管理员，降低工作量。

Google搜索LXD+GPU能够找到大量的中英文资料，因此本文只会简述安装和配置过程，着重分享不同环境下的挑战和解决方案。

笔者也将说明文档共享出来，供大家参考使用：https://deserts.gitbook.io/gpu/manual

安装配置

宿主机驱动配置

笔者习惯使用Ubuntu服务器版系统。首先安装英伟达显卡驱动，CUDA在宿主机上并非必要。

apt install git gcc g++ make cmake build-essential curl -y
apt-get remove --purge nvidia* -y

#把 nouveau 驱动加入黑名单并禁用用 nouveau 内核模块
# 在文件 blacklist-nouveau.conf 中加入如下内容
echo "blacklist nouveau" >> /etc/modprobe.d/blacklist-nouveau.conf
echo "options nouveau modeset=0" >> /etc/modprobe.d/blacklist-nouveau.conf

# 保存退出，执行
update-initramfs -u

#给驱动run文件赋予执行权限：
sudo chmod +x NVIDIA-Linux-x86_64-<版本>.run
#后面的参数非常重要，不可省略：
sudo ./NVIDIA-Linux-x86_64-<版本>.run --no-opengl-files

安装nvidia-container-runtime，这样在容器中可以直接调用宿主机的显卡驱动。

# Add the package repositories
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | apt-key add -

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | tee /etc/apt/sources.list.d/nvidia-docker.list
apt-get update

apt install libnvidia-container-dev libnvidia-container-tools nvidia-container-runtime -y

宿主机LXD配置

安装ZFS并配置，使用ZFS作为LXD的存储管理工具。ZFS文件系统开启去重。

apt install zfsutils-linux

zpool create tank /dev/sda
zfs create tank/lxd
zfs set dedup=on tank/lxd

安装LXD

snap install lxd

换源和拉取镜像

lxc remote add tuna-images https://mirrors.tuna.tsinghua.edu.cn/lxc-images/ --protocol=simplestreams --public
lxc image copy tuna-images:ubuntu/18.04 local: --alias ubuntu/18.04 --copy-aliases --public

初始化LXD，注意ZFS pool使用上面创建的，是否使用网桥视情况而定。

lxd init

Would you like to use LXD clustering? (yes/no) [default=no]:
Do you want to configure a new storage pool? (yes/no) [default=yes]:
Name of the new storage pool [default=default]: 
Name of the storage backend to use (btrfs, ceph, dir, lvm, zfs) [default=zfs]:
Create a new ZFS pool? (yes/no) [default=yes]:
Would you like to use an existing block device? (yes/no) [default=no]:
Size in GB of the new loop device (1GB minimum) [default=100GB]: 
Would you like to connect to a MAAS server? (yes/no) [default=no]:
Would you like to create a new local network bridge? (yes/no) [default=yes]: no
Would you like to configure LXD to use an existing bridge or host interface? (yes/no) [default=no]: yes
Name of the existing bridge or host interface: br0
Would you like LXD to be available over the network? (yes/no) [default=no]:
Would you like stale cached images to be updated automatically? (yes/no) [default=yes]
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]:

lxc profile set default nvidia.runtime true
lxc profile device add default gpu gpu

创建模板容器

lxc init ubuntu/18.04 template -p default
lxc start template

进入模板容器内安装必要的软件，如conda等

lxc exec template bash

完成后，发布将模板容器发布为模板镜像，删除模板容器

sudo lxc stop template
sudo lxc publish template --alias template --public
sudo lxc rm template

自动化脚本

利用笔者提供的shell脚本，即可实现用户创建时自动创建容器。使用add_user.sh新建用户及容器，用户登录宿主机后执行login.sh。

新建用户：

ssh addu@172.26.xxx.xxx
# 密码
addu@172.26.xxx.xxx's password:
=====Welcome!
We need to get sudo permission first. Enter the password for `addu`.
# 输入addu的密码，获取sudo权限
[sudo] password for addu:
=====Let's setup a new account and create a container now.
# 输入用户名，接下来自动创建用户并新建虚拟机
Enter your username: test
Creating user...
Allocating container for test...
Creating test
Allocating ssh port... 10020
Device sshproxy added to test
# 设置用户密码
set password for test now (host only).
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
Login this host via `ssh <username>@<host-ip>` to manage your container.
Done!

用户登录：

# 使用新建的用户登陆并管理虚拟机
ssh test@172.26.xxx.xxx
test@172.26.xxx.xxx's password:
Welcome to Ubuntu 18.04.2 LTS (GNU/Linux 4.15.0-54-generic x86_64)
……
 Hi, test
 You're using the GPU Server in Vision Group.

==========About your container:
Your container is not running.
Transfer data to your container using scp or sftp;
File sharing is encouraged, access datasets at shared/datasets, access download files at shared/downloads, etc

See GPU load: nvidia-smi.
    memory usage: free -h.
    disk usage: df -h.

===== main menu  =====
[1] start your container  # 开机
[2] enter your container  # 切换至虚拟机
[3] stop your container   # 关机（也可以直接在虚拟机中执行shutdown now）
[4] change your password  # 更改密码（如果需要改虚拟机密码，进入虚拟机后执行passwd）
[5] allocate ports        # 进行端口映射
[6] release ports         # 释放申请的端口
[0] show info             # 显示虚拟机运行状态
[x] exit                  # 退出管理
# 启动虚拟机
Enter your choice: 1
========== Starting your container...

Press any key to continue...

Generative Adversarial Networks (GANs, 生成对抗网络) 是一种由两个网络构成的通过对抗学习训练的生成模型，由 Ian Goodfellow 等人（包括 Yoshua Bengio）在 2014 年提出，并得到了 Yann LeCun 的盛赞，称其为『机器学习界10年来最有趣的点子』。

本文将从新手的角度介绍GAN的思想和实现方法，前置知识仅需要神经网络基础。

监督 vs. 非监督

几乎所有人学习神经网络都是从分类器学起的，也就是『喂给』神经网络的数据集包括两部分：原始数据（x）和标注（y），我们希望构造一个复杂的非线性函数来表示 $f:x \rightarrow y$ 的映射，这是监督学习，如分类、回归、目标检测、语义分割等。

对于非监督学习，训练数据仅有原始的数据而没有标记，我们希望算法学习数据中隐含的模式或结构，如聚类，降维，特征学习等。

本文所述的 GAN，也是最简单最原始的GAN，是非监督学习，我知道对于大部分新手来说用神经网络做非监督学习是不太好接受的。

生成算法 vs. 分类算法

GAN 作为一种生成算法，其目标是能够『模仿』给定数据集中的数据，生成新的符合数据集特征的数据。

我们先来回忆简单的二分类算法。例如，对于一个垃圾邮件分类（鉴别）算法，给定邮件内容中的所有文本，分类器能够预测出该文本是否是垃圾。用一个简单的数学表达式表示即为 $P(y|x)$，其中$x$为输入分类器的特征，$y$为标签，分类器能够预测给定的$x$类别为$y$的概率。也就是分类器是从高维特征向低维标签的映射。

生成算法的目标与分类算法的目标正好相反，生成器试图从给定的低维标签生成高维的特征，即试图得到 $P(x|y)$。

也就是说，将简单的分类网络前后翻转，就是一个生成网络了。问题在于，如何训练这个生成网络，使其能够模仿训练集来生成数据，或者说学习到训练集中的数据分布。

GAN 的结构

GAN 是由两个神经网络，即生成器（Generator）和鉴别器（Discriminator）构成的。

所谓鉴别器，就是一个简单的二分类神经网络，或者叫分类器，用于判定输入的图片是来自于真实的数据集还是由生成器生成的。以下代码用Keras实现一个二分类的全连接网络，即为鉴别器。

# Disctiminator
D = Sequential([
    Flatten(input_shape=img_shape, name='flatten'),
    Dense(512, activation='relu', name='fully_connected1'),
    Dense(256, activation='relu', name='fully_connected2'),
    Dense(1, activation='sigmoid', name='classifier')
])

生成器网络将输入的低维度向量（这里用长度100的向量）映射到一个高维度向量后reshape到图片尺寸。Keras 实现如下。

# Generator
G = Sequential([
    Dense(256, activation='relu', input_dim=latent_dim, name='fully_connected1'),
    Dense(512, activation='relu', name='fully_connected2'),
    Dense(1024, activation='relu', name='fully_connected3'),
    Dense(np.prod(img_shape), activation='tanh', name='output_generated'),
    Reshape(img_shape)
])

当我们用训练好的神经网络生成数据时，鉴别器D就没有用了，只需要一行代码即可让生成器G生成一张图片 img = G.predict(noise_vector)。也就是说，鉴别器D对于GAN来说只是用来『帮助』训练生成器G的参数的。

虽然网络结构很简单，但如何让生成器生成满意的图像，或者说让生成器学习到训练集的数据分布才是GAN的核心。

对抗训练

我们有了生成器G和鉴别器D，需要将其组合在一起训练，即为对抗训练（Adversarial Training）。所谓对抗训练，就是在参数学习过程中鉴别器D和生成器G朝着对立的方向学习：D试图不断提高分别图片真假的能力，G试图不断生成更逼真的图片来糊弄D。

GAN 训练的过程如下：

• 训练D：G接收一个随机向量作为输入，输出一张图像，用生成的图像作为负样本（label为假），训练集中的图像作为正样本训练D（label为真）
• 训练G：G再生成一张图像作为正样本（label为真）输入D，经由D的代价函数后反向传播，更新G的参数（此时D的参数锁定）

我将这个过程总结为：分别训练，共同进步。在每一步中，D和G的参数分别更新；在整个训练过程中，D和G同步提高。

用Keras实现的对抗训练代码如下。

# 编译D
D.compile(loss='binary_crossentropy', optimizer=d_optimizer, metrics=['accuracy'])
# 将D和G"串联"，得到模型C
z = Input(shape=(latent_dim,))
generated_img = G(z)
D.trainable = False       # 模型C中D的参数锁定
validity = D(generated_img)
# Combined model
C = Model(z, validity)
C.compile(loss='binary_crossentropy', optimizer=g_optimizer)
C.summary()

# load data
(x_train, _), (_, _) = mnist.load_data()
x_train = x_train / 127.5 - 1
# (60000, 28, 28) -> (60000, 28, 28, 1)
x_train = np.expand_dims(x_train, axis=3)
valid = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))

for epoch in range(epochs):
    for _ in range(x_train.shape[0] // batch_size):
        # train D
        idx = np.random.randint(low=0, high=x_train.shape[0], size=batch_size)
        imgs = x_train[idx]
        noise = np.random.normal(0, 1, (batch_size, latent_dim))
        gen_imgs = G.predict(noise)
        D.train_on_batch(imgs, valid)
        D.train_on_batch(gen_imgs, fake)
        # train G
        noise = np.random.normal(0, 1, (batch_size, latent_dim))
        C.train_on_batch(noise, valid)

看完代码，相信你心中的诸多疑惑已经解开。

小结

本文试图抛开公式和理论，以直观的方式来介绍GAN的结构与对抗训练过程，并强调在实现过程中理解和掌握GAN。GAN 首先是一种无监督学习和生成算法，其核心思想在于对抗训练。至于公式和理论分析，我相信这时候去阅读原论文会是个不错的选择。

Several threads from STACK OVERFLOW:

We have a simple client server architecture between our mobile device and our server both written in Java. An extremely simple ServerSocket and Socket implementation. However one problem is that when the client terminates abruptly (without closing the socket properly) the server does not know that it is disconnected. Furthermore, the server can continue to write to this socket without getting any exceptions. Why?According to documentation Java sockets should throw exceptions if you try to write to a socket that is not reachable on the other end!

Another,

If I put a nonsense url no exception is thrown and none of the rest of my code is executed not even the rest of the asynctask that called the method that connects.

Typically:

    try {
        socket.connect(new InetSocketAddress(address, port), 2000);
    } catch (Exception e) {
        //will never reach this block
    }

I am facing the same problem. I have tried every means below these questions, but it still did not work. I found that some apps downloaded from Google Play has the same problem that it could connect and send data to a invalid address.

There is no doubt that there is a bug of Android SDK, could found in this thread: no IOException on socket read/write after remote close as well.

My solution is to switch the minSdkVersion to a newer version such as 21 and to use the latest build tools.

Android 开发过程中，遇到一个比较诡异的问题：Socket.connect 即使连接失败也不会抛出任何异常，这个问题在 STACK OVERFLOW 上已经有非常多的讨论，但我翻了无数答案没有找到合适的解决方法。最后可以确认这是Android历史遗留的一个臭虫，至于在哪个版本SDK中被修复了还不得而知，我最后将 minSdkVersion 从15换到21解决了这个问题，代价就是APP只能在 Android 5.0 以后的版本上运行。

强迫症这个病，得治。

东拼西凑出一个Ghost主题。主要参考了 Cho 的Bitcron自用主题样式，加入了移动端菜单、底栏以及 Ghost 的一些特色功能。前端技术栈弱鸡，只会复制粘贴加调试，小毛病是永远都不可能改完的。

Graphic design is the paradise of individuality, eccentricity, heresy, abnormality, hobbies, and humors. — George Santayana

图骗示例：

代码示例：

import torch
import torch.nn as nn

class DiceLoss(nn.Module):
    def __init__(self, eps=1e-5):
        super().__init__()
        self.eps = eps

    def forward(self, prediction, ground_truth):
        batch_size = prediction.size(0)
        classes = prediction.size(1)
        prediction = prediction.float()
        ground_truth = ground_truth.float()
        intersection = prediction * ground_truth
        dice_numerator = 2.0 * intersection.view(batch_size, classes, -1).sum(-1)
        dice_denominator = prediction.view(batch_size, classes, -1).sum(-1) + \
                           ground_truth.view(batch_size, classes, -1).sum(-1) + self.eps
        dice = dice_numerator / dice_denominator
        return 1 - dice.mean()

视频示例：

滚去学习！

快速配置深度学习主机环境的下篇。上篇已经配置好底层驱动和CUDA，可以实现SSH远程登录，使用SAMBA进行文件共享。这篇将完成TensorFlow，Jupyter，PyCharm的安装配置。

Python & TensorFlow

1. 安装Conda到/usr/local/cellers/conda3，默认的python和pip已经替换为Anaconda的版本

   NOTE：如果你不知道当前运行的Python或pip到底是哪一个什么版本，你可以使用which python查看。

2. 创建虚拟环境：conda create -n tf_env，进入：source activate tf_env，安装pip：conda install pip

3. 安装Tensorflow 1.6：pip install --ignore-installed --upgrade tfBinaryURL

   where tfBinaryURL is the URL of the TensorFlow Python package. For example, the following command installs the GPU version of TensorFlow for Python 3.6:

   pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow_gpu-1.6.0-cp36-cp36m-linux_x86_64.whl

   也可以使用：pip install tensorflow-gpu

Jupyter

1. conda install jupyter安装 Jupyter， jupyter notebook --generate-config，编辑生成的文件vi ~/.jupyter/jupyter_notebook_config.py，

   c.NotebookApp.ip = '0.0.0.0'
   c.NotebookApp.port = 8080
   c.NotebookApp.password = u'sha1:c3182135f429:0b593978f9f157b26871b7d2e9c478e4cbb6c556'
   c.NotebookApp.notebook_dir = u'/home/deserts/Projects'

上面的密码这么来的：

   >>> from IPython.lib import passwd
   >>> passwd()
   Enter password:
   Verify password:
   'sha1:7d95d331a799:305429d9f9d799dce42cb8635b770a63d254c419'

2. 设置systemd随开机启动，sudo vi /etc/systemd/system/jupyter.service，这里使用Environment指定PATH和LD_LIBRARY_PATH环境变量，因为systemd不能使用.bashrc中的环境变量。具体参数视情况而定。

   [Unit]
   Description=Jupyter Notebook
   After=network.target
   [Service]
   Type=simple
   Environment=PATH=/usr/local/cuda-9.0/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin LD_LIBRARY_PATH=/usr/local/cuda-9.0/lib64
   ExecStart=/usr/local/cellers/miniconda3/bin/jupyter notebook  --config=/home/deserts/.jupyter/jupyter_notebook_config.py --no-browser
   User=deserts
   Group=deserts
   WorkingDirectory=/home/deserts/Projects/
   Restart=always
   RestartSec=10
   [Install]
   WantedBy=multi-user.target

多人独立的Jupyter环境只需要用不同的配置文件和Python内核即可。
更好的保证安全参阅：https://bitmingw.com/2017/07/09/run-jupyter-notebook-server/

PyCharm

1. Interpreter设定：preference -> project -> project interpreter，点击小扳手，add remote，如下图进行配置：

2. 文件同步：Tools -> deployment -> configuration，按照下图配置：

设置路径映射，注意部署路径基于上图的ROOT路径设定。

3. 勾选 Tools -> deployment -> Automatic upload，即可自动同步文件。

PyCharm按照以上流程设置好以后，可以在右侧边栏打开远程文件浏览，手工进行文件操作。如果需要更丰富的远程文件管理，可以借助上篇提及的Samba映射网络驱动器。或者使用其他SFTP工具。

至于更复杂的网络拓扑，可以使用路由器的端口映射功能实现广域网（或校内网）访问。

至此，可以优雅的使用远程机器进行深度学习开发。

写两篇日志记录下配置深度学习环境的流程和心得。目标是快速搭建出深度学习环境，实现局域网内多人共享访问。分成两部分来写，上篇主要讲快速的配置操作系统和底层环境，包括Ubuntu，CUDA，cuDNN的安装，下篇主要讲软件环境的配置和使用。

注：TensorFlow 1.6 预编译版不支持 CUDA 9.1，只支持9.0。请注意下面的路径和安装文件大部分都是9.1。

快速安装过程

1. 安装最新版Ubuntu 16.04 Desktop 桌面版

2. 准备工作：
   下载CUDA 9.1安装文件，
   其他依赖环境如gcc，Ubuntu最新版已经自带，
   卸载已有的NVIDIA驱动（可选）：sudo apt-get remove --purge nvidia*
   一些开发需要的包（可选）：

sudo apt-get install build-essential
sudo apt-get install vim cmake git
sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libboost-all-dev libhdf5-serial-dev

3. 屏蔽nouveau，sudo nano /etc/modprobe.d/blacklist-nouveau.conf，加入

blacklist nouveau
blacklist lbm-nouveau
options nouveau modeset=0
alias nouveau off
alias lbm-nouveau off

禁用 nouveau 内核模块

echo options nouveau modeset=0 | sudo tee -a /etc/modprobe.d/nouveau-kms.conf
sudo update-initramfs -u

重启计算机 sudo reboot

4. （建议）永久关闭图形界面：更改运行级别runlevel为3，sudo systemctl set-default multi-user.target，修改启动界面为纯文本，sudo vi /etc/default/grub，修改GRUB_CMDLINE_LINUX_DEFAULT="text"，保存，sudo update-grub，重启后即为text mode。
   临时关闭图形界面：
   切换至文本模式（ctrl+alt+F1），登录并切换至cuda安装文件所在目录，关闭GUI服务。

sudo service lightdm stop

5. 执行安装（注意参数，不安装opengl-lib）

sudo sh cuda_<version>_linux.run --override --no-opengl-lib

Do you accept the previously read EULA? (accept/decline/quit): accept
Install NVIDIA Accelerated Graphics Driver for Linux-x86_64? ((y)es/(n)o/(q)uit): y
Install the CUDA  Toolkit? ((y)es/(n)o/(q)uit): y
Enter Toolkit Location [ default is /usr/local/cuda-9.1 ]:
Do you want to install a symbolic link at /usr/local/cuda? ((y)es/(n)o/(q)uit): y
Install the CUDA Samples? ((y)es/(n)o/(q)uit): y
Enter CUDA Samples Location [ default is /home/user ]:

如果安装没有报错，重启使驱动生效。检查驱动状态： nvidia-smi。

6.修改环境变量: （可编辑 .bashrc 或 /etc/profile 文件）

$ export PATH=/usr/local/cuda-9.1/bin${PATH:+:${PATH}}
$ export LD_LIBRARY_PATH=/usr/local/cuda-9.1/lib64 ${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

编译运行CUDA测试用例（自行查看官方说明）。

7. 注册下载 NVIDIA cuDNN （加速神经网络计算），安装只需要解压复制到对应位置即可

Unzip the cuDNN package.

$ tar -xzvf cudnn-<>.tgz

Copy the following files into the CUDA Toolkit directory.（注意路径）

$ sudo cp cuda/include/cudnn.h /usr/local/cuda/include
$ sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64
$ sudo chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*

编译运行CUDA测试用例（自行查看官方说明）。

解决问题的思路

主要问题：NVIDIA驱动装不上（或者装完图形界面出现问题）、驱动装上了但和CUDA要求的版本不匹配

1. 谨慎使用最新版NVIDIA驱动和Ubuntu自带的附加驱动
2. 建议使用CUDA自带的GPU驱动程序，不建议单独安装驱动程序
3. 建议参考官方教程进行安装
4. 旧版教程参考意义不大
5. 建议关掉图形界面进行安装

Troubleshooting

1. 安装过程出现 "The driver installation is unable to locate the kernel source. "，使用uname -r查看内核版本，如果高于4.10，如4.13.0，CUDA 9.1自带驱动不支持最新Linux内核，请降级内核：

   sudo apt-get purge linux-image-4.13.0-26-generic
   sudo apt-get purge linux-headers-4.13.0-26-generic
   

   Update initramfs image:

   sudo update-initramfs -u
   

   重启，使用 uname -r 命令确保内核版本正确

2. 如果确认内核版本没问题了，还出现（1）的问题，再尝试安装以下包：

   apt-get install linux-source
   apt-get source linux-image-$(uname -r)
   apt-get install linux-headers-$(uname -r)
   

3. 其他你可能遇到的问题，可以参考：

   官方教程：http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#runfile-nouveau

   各种问题解决方法和解释：https://www.linkedin.com/pulse/installing-nvidia-cuda-80-ubuntu-1604-linux-gpu-new-victor/

多人环境配置

1. 安装ssh服务器：sudo apt-get install openssh-server
2. 安装samba服务：sudo apt-get install samba
3. 创建多个用户：用到的命令：useradd，usermod等

最近重新拾起 Sedgewick 的《算法（第4版）》，对之前学的不扎实的算法和数据结构做个回顾。红黑树的实现和删除比较复杂，这里对书中一些描述不够清晰甚至有疏漏的地方进行注解。术语的表述基本与《算法》一致，避免使用乱七八糟的『亲戚称呼』。

红黑树的难点在于『写操作』，即put和delete方法的实现。这里以put方法的实现和简单分析作为热身，着重讨论书中描述不够清晰的delete方法的实现。全面的讲解请看原著和普林斯顿大学的授课PPT，此外有完整代码和完整论文。

2-3树和红黑树

由于红黑树（LLRB Tree）可以看做是用二叉搜索树（BST）实现的2-3树，所以从2-3树入手，讨论过程中随时回到2-3树进行比对分析。

2-3树为什么能保持完美平衡？

直观的说，插入时，总是通过『膨胀』使得原键的『度』增加，再做『适当调整』使得树保持平衡并满足2-3树的基本性质（左倾、只有2-结点和3-结点）；当出现4-结点时，『调整操作』会使得树长高，因为总是『提出』4-结点中的『中间键』，所以能保持完美平衡。

对于红黑树，我们可以这么理解，

红链接沿着『中间结点』向上传递。

插入操作

第一轮热身： 红黑树插入操作的实现，基于BST的插入操作，关键在于实现上述的『膨胀』、『适当调整』和『提出中间键』，即『新插入结点染为红色』、用『左旋』保证左倾、『右旋』和『反色』保证中间结点上移。

以上状态转移图描述了所有需要考虑的情形，可以得出三种调整的先后顺序。插入操作代码如下，注释部分为红黑树有别于BST的代码：

    public void put(Key key, Value value) {
        root = put(root, key, value);
        //根节点链接为黑色
        root.color = BLACK;
    }

    private Node put(Node node, Key key, Value value) {
        if (node == null)   // 新建结点为红色
            return new Node(key, value, 1, RED);

        int cmp = key.compareTo(node.key);
        if (cmp < 0)       node.left = put(node.left, key, value);
        else if (cmp > 0)  node.right = put(node.right, key, value);
        else               node.value = value;

        //『左旋』保证左倾
        if (!isRed(node.left) && isRed(node.right)) node = rotateLeft(node);
        //『右旋』和『反色』保证中间结点上移
        if (isRed(node.left) && isRed(node.left.left)) node = rotateRight(node);
        if (isRed(node.left) && isRed(node.right)) flipColors(node);

        node.N = size(node.left) + size(node.right) + 1;
        return node;
    }

上述插入代码在递归向下过程中不断搜索直到找到『合适位置』将新结点插入，回溯过程中对树进行『修正操作』。

如果我们将上述代码中的if (isRed(node.left) && isRed(node.right)) flipColors(node);这句提前到递归前（比较操作之前），即把递归向上时的最后一步『反色』操作，『延迟』到下次插入操作之前，这样插入完成后树中将存在4-结点，生成的是2-3-4树。

删除最大最小键

第二轮热身： 删除最小键和最大键。在2-3树中，删除底部的2-结点会影响树的完美平衡，而删除3-结点或4-结点中的键则没有问题。

删除操作可以视为插入操作的『逆操作』。如删除最小键操作中，沿着左链接向下变换使得红链接向左下移动，确保当前结点不是2-结点。

以删除最小键为例展开说明：

• 如果当前结点的左子结点不是2-结点，不处理；
• 如果当前结点的左子结点是2-结点，且左子结点的『亲兄弟』结点也是2-结点，将当前结点的最小键、左子结点和其『亲兄弟』结点三个键合并成一个4-结点；
• 如果当前结点的左子结点是2-结点，且左子的『亲兄弟』结点是3-结点，向其『亲兄弟』结点『借』一个键，使得左子结点成为3-结点；

下图是《算法》书上2-3树删除最小键过程中所进行的变换。

这张图有点问题： 我们在向下变换过程中，只允许当前结点及『所过结点』出现临时的4-结点（绿色矩形标识），当前结点的右子结点是不可能出现4-结点的（紫色矩形标识），这些临时4-结点或被接下来的变换拆散，或在向上回溯过程中被修复。我在上述第三点说明时将原书的『不是2-结点』改为了『3-结点』也是出于此。

对于根节点需要留意下，在实际红黑树操作中如果根节点的左右结点都是黑链接，我们把指向根节点的链接『假装』成红色，也就是假装根节点的键在3-结点中。

回到红黑树似乎看起来更清晰，current.right.left的颜色决定了是否要向兄弟结点借：

上述第二种情形，仅需要进行颜色反转操作：

上述第三种情形，向兄弟结点借：

代码也很简洁：

    public void deleteMin() {
        if (!isRed(root.left) && !isRed(root.right))
            root.color = RED;
        root = deleteMin(root);
        if (!isEmpty())
            root.color = BLACK;
    }

    private Node deleteMin(Node node) {
        if (node.left == null)
            return null;
        if (!isRed(node.left) && !isRed(node.right))
            node = moveRedLeft(node);
        node = deleteMin(node);
        return fixUp(node);
    }

    private Node moveRedLeft(Node node) {
        flipColors(node);
        if (isRed(node.right.left)){
            node.right = rotateRight(node.right);
            node = rotateLeft(node);
            flipColors(node);
        }
        return node;
    }
    
    private Node fixUp(Node node) {
        if (isRed(node.right)) node = rotateLeft(node);
        if (isRed(node.left) && isRed(node.left.left)) node = rotateRight(node);
        if (isRed(node.left) && isRed(node.right)) flipColors(node);
        return node;
    }

这里的fixUp即向上回溯过程中的『修复』操作，与插入操作中回溯时的代码几乎一样。第一个判断改成了if (isRed(node.right))而不是if (!isRed(node.left) && isRed(node.right))（Why？）。

对于删除最大键，由于树是左倾的，稍有不同，直接看代码画图分析即可：

    private Node deleteMax(Node node) {
        if (isRed(node.left))
            node = rotateRight(node);
        if (node.right == null)
            return null;
        if (!isRed(node.right) && !isRed(node.right.left))
            node = moveRedRight(node);
        return fixUp(node);
    }

    private Node moveRedRight(Node node) {
        flipColors(node);
        if (isRed(node.left.left)) {
            node = rotateRight(node);
            flipColors(node);
        }
        return node;
    }

删除任意键

总是删除最底部的键。当遇到待删除的结点时，使用右子树中的最小结点替换待删除结点。向左搜索时，使用moveRedLeft，向右搜索时使用moveRedRight。

代码结合了deleteMin和deleteMax，其中①处表示待删除的结点正好在底部，可以直接删除，②处使用了小技巧，使用右子树的最小结点的key和val更新待删除结点的属性。和之前一样，需要在回溯过程中修复红黑树。

    private Node delete(Node node, Key key) {
        int cmp = key.compareTo(node.key);
        if (cmp < 0){
            if (!isRed(node.left) && isRed(node.left.left))
                node = moveRedLeft(node);
            node.left = delete(node.left, key);
        } else {
            if (isRed(node.left))
                node = rotateRight(node);
            if (cmp == 0 && node.right == null) // ①
                return null;
            if (!isRed(node.right) && !isRed(node.right.left))
                node = moveRedRight(node);
            if (cmp == 0) {                     // ②
                node.value = get(node.right, min(node.right).key);
                node.key = min(node.right).key;
                node.right = deleteMin(node.right);
            }
            else node.right = delete(node.right, key);
        }
        return fixUp(node);
    }

小结： 红黑树的删除操作实现起来确实很难也很繁琐，结合2-3树并使用LLRB能够降低一部分难度。然而还是有些细节值得推敲琢磨。

@云淡风轻 开发了Valine一款极简的评论系统 。我冒昧做了二次修改给自己的博客用上；强迫症使然，这两天又熬夜写了个后台管理，对 Valine 做了轻度改造，让其更合我的胃口。Valine 可以说是当前最好的独立博客评论解决方案了。

最新版Valine Admin配置手册

Valine 的特点：

• 无后端实现
• 高速，使用国内后端云服务提供商 LeanCloud 提供的存储服务
• 开源，自定义程度高
• 支持邮件通知
• 支持验证码
• 支持 Markdown

我完善实现了以下内容：

• 头像显示、样式美化和细节优化
• 完善的邮件通知，自定义 SMTP 发件频率和内容不再受限
• 基于 Akismet 的垃圾评论自动标注和过滤
• 评论管理，避免直接操作数据库
• 通知邮件补发（未发送或发送失败的通知邮件可以进入后台补发）
• Disqus 数据迁移
• 清理不必要的数据库字段，提高效率

更新日志：

• [2020/10/07] 移除对av-min.js和jQuery的依赖，新增暗黑模式（需要主题配合），新增评论计数显示
• [2019/03/03] 已支持PJAX主题
• [2019/02/24] 已修复Markdown语法支持不完整问题
• [2018/09/16] 自定义表情包（参考下文配置emoticon_url及emoticon_list两个参数），另一套高清表情包下载: 点击下载 ；全新的评论样式；去除点赞功能
• [2018/09/14] 评论表情，表情包下载: 点击下载 解压后自行托管静态文件，需更新配置参数
• [2018/08/10] Disqus 数据迁移代码开源（Python），点击下载
• [2017/08/16] 隐私保护：敏感字段限制读取，如 E-mail（用于头像显示和评论通知）、User-Agent、IP（用于垃圾评论判别）
• [2017/08/16] 更新云引擎休眠解决方案 关于自动休眠问题的说明

在线预览

评论安装

安装过程非常简单，这里引用 Valine 原作者 @云淡风轻 的安装教程，稍作修改。

1. 获取 APP ID 和 APP KEY

点击这里登录或注册Leancloud
点这里创建应用，应用名看个人喜好。
选择刚刚创建的应用>设置>选择应用 Key，然后你就能看到你的APP ID和APP KEY了，参考下图：

为了您的数据安全，请填写应用>设置>安全设置中的Web 安全域名，如下图：

2. 修改主题模板

在主题模板的文章页中引入相应的 js 即可，几乎所有博客程序适用。以 Ghost 博客的默认主题为例，只需要在 「post.hbs」 文件中 </body> 前插入下方的代码即可。

使用PJAX主题的请见文末的代码。

<div id="comment"></div>
<span id="comment-count"></span>

<script>
    comment_el = '#comment';
    comment_count_el = 'span.comment-count';
    new Valine({
        el: comment_el,				// 评论区元素（要求div）
        count_el: comment_count_el,    // 评论计数元素（要求span）
        lang: 'zh-cn',							   // 语言（zh-cn或en）
        emoticon_url: 'https://cloud.panjunwen.com/alu', // 表情包根目录（自行解决文件托管）
        emoticon_list: ["吐.png", "狂汗.png", "不说话.png"], // 表情包文件列表
        app_id: '你的App ID',			    										   	
        app_key: '你的App Key',    										      
        placeholder: 'Write a comment',  // 提示符
        admin_email_hash: 'f32fc1c3f6674bfb5621a60901b5f96c', // 可选，管理员邮箱md5，用于显示管理员标志👮‍
        max_nest: 3,					// 嵌套评论深度，太大会影响加载速度
        page_size: 5					// 分页大小
    });
</script>

Valine.min.js 你可以使用别人的或者上传到自己的服务器或主机：Valine Ex

需要修改的只有：el、app_id 和 app_key。如果之前有用原版Valine，请将邮件通知和验证码关掉：notify: false, verify: false，避免重复发通知。算术验证码反人类，强烈建议停用。
至此，你的评论系统已经可以工作了！是不是很简单?

特别提醒，为确保数据安全，请合理设置数据库权限。此外，请务必设置 Web 安全域名。

3. 暗黑模式切换

为了实现主题和评论的同步切换，且符合主题的配色，新版本中去掉了Valine的颜色定义，改用CSS变量控制前景和背景色。使用如下5个变量控制评论区色彩。如果你的主题色彩定义与如下不同，或者不支持暗黑模式切换，需要添加如下CSS来提供色彩变量。

:root {
  /* light theme color */
  --background: #fff;
  --background-secondary: #eaeaea;
  --color: #222;
  --color-secondary: #999;
  --border-color: #dcdcdc;
}

/* dark theme colors 如果不需要自动切换可以把这里去掉 */
@media (prefers-color-scheme: dark) {
  :root {
    --background: #292a2d;
    --background-secondary: #3b3d42;
    --color: #a9a9b3;
    --color-secondary: #73747b;
    --border-color: #4a4b50;
  }
}

云引擎一键部署

请参考 {{<link "valine-admin-document">}}

数据迁移

请参考DisqusLeanCloud

效果

前端效果：

后台演示

后台截图：

邮件通知：

小结

Valine 『无后端』已经可以很好的运行，但反垃圾评论和邮件通知还得靠后台来做，正好 LeanCloud 提供免费的云引擎和云 Hook，得以实现上述功能。LeanCloud 实在太好用了，借助官方的示例程序，连 JavaScript 语法都不懂就硬着头皮用 Nodejs 了，代码虽然很丑还是放出来，Github：Valine-Admin。另外数据迁移是用 Flask 写的，也是第一次用，所以就不放源码献丑了。

PJAX支持（实验性）

对于使用pjax的主题，可以采用下面的代码加到前端jQuery加载之后的位置，确保这些js代码只加载一次，不要加到<div class="comment"></div>内部或附近。

<!--确保jQuery已经在此之前加载-->
<script src="//cdn1.lncld.net/static/js/3.0.4/av-min.js"></script>
<script src="你托管的Valine路径./dist/Valine.min.js"></script>
<script>
    <!--.comment要与评论区元素一致-->
    comment_el = '.comment';
    load_valine = function () {
      if ($(comment_el).length) {
        new Valine({ 
          av: AV,
          el: comment_el,
          emoticon_url: 'https://cloud.panjunwen.com/alu',
          emoticon_list: ["喷血.png","狂汗.png","不说话.png","汗.png","坐等.png","献花.png","不高兴.png","中刀.png","害羞.png"],
          app_id: '你的id',
          app_key: '你的key',
          placeholder: 'Write a Comment'
          });
      }
    };
    $(document).ready(load_valine);
    $(document).on('pjax:complete', function() {
      load_valine();
    });
</script>

多说离开也不是一天两天的事情了。怀念 WordPress 自带的评论系统。我一开始就用 Disqus 社会化评论?，现在也彻底富强民主文明了。从 Hexo 换回了 Ghost ，数据库有了可评论系统还是不存在。也有如 isso 这样的纯粹的评论系统，就是喜欢不起来。考虑造个轮子。

造轮子

学习 Android 时顺便用了下 LeanCloud 的存储服务，有免费的开发者版提供，用起来很顺手。

开发者版的主要资源指标：10 GB 免费空间，3,0000 API请求/天。普通博客足够了。

昨天下午去看 JavaScript 的文档，准备干活；晚上到宿舍顺手搜了下『LeanCloud 评论』，几小时前一个轮子已经诞生了——Valine 一款极简的评论系统。不知道是该高兴呢还是该高兴呢。总有人阻止我学 JavaScript！?

欲求总是无法填满的：数据迁移是个问题。熬夜用 Python 写了个 Disqus2LeanCloud，考虑到不是谁都有 Python 环境，做成 Web 服务可以方便大家（骗点流量）。翻了翻 Flask 的文档就上手做了，放到了自己的主机上 Disqus2LeanCloud。第一次用 Flask，Python 放开也有段时间了（学校天天逼着用 Java，我的信仰快动摇了）。

数据迁移说明

1. 导出数据：去 Disqus 把数据导出，系统会发压缩包到邮箱，解压出.xml文件备用；
2. 安装好Valine 评论系统，暂时不要设置 Web 安全域名（不然人家怎么进去）；
3. 备好你的 APP ID 和 APP KEY，再次强调不要设置 Web 安全域名先；打开Disqus2LeanCloud，填写 APP ID 和 APP KEY，选择 .xml数据文件，点击开始即可；
4. 没了。去设置你的 Web 安全域名。

效果

导入完成效果如下，由于 Valine 采用 LeanCloud 默认生成的时间作为评论时间，而这个时间有只读属性，所以没能把 Disqus 中的时间迁移过来。若以后有时间会继续完善。

小结

Valine 的样式简洁清新，比起 isso 等更令人有食欲。更重要的是，借助LeanCloud部署极其方便快捷。

当然，现阶段也有很多需要完善的地方 @云淡风轻，比如邮件通知功能。既然褥 LeanCloud 的羊毛，就物尽其用。虽然 LeanCloud 没有提供邮件系统，但有完善的用户系统，包括注册邮箱验证和重置密码邮箱验证（看起来没有单独规定调用次数限制），而且邮件模板可以随便修改。虽然不设置注册和登录，但可以把用户功能用起来，使用邮箱作为用户唯一标识，收到 @ 请求时对相应用户发送密码重置邮件即可，这样也顺便解决了 Comment 表数据冗余的问题。

用户Gavatar头像也比较容易，可以使用LeanCloud的文件存储进行头像缓存。

现阶段看来，用 Valine 是个不错的评论系统解决方案。希望 LeanCloud 挺住。

AsyncTaskLoader is a better choice for Activity-bound thread management, because it handles lifecycle changes correctly, delivering the result to the current active activity, preventing duplication of background threads, and helping to eliminate duplication of zombie activities.

Leveraging Loaders

Steps:

1. Create a Loader ID
2. Fill-in Loader Callbacks
3. Init Loader with LoaderManager

Detail:

1. Create a constant int to uniquely identify the loader;

Implement tne LoaderManager.LoaderCallbacks<> on Activity and override 3 methods(step 2):

public class MainActivity extends AppCompatActivity implements
    LoaderManager.LoaderCallbacks<String> 

2. Override methods and fill-in Loader Callbacks:

@Override
public Loader<String> onCreateLoader(int id, Bundle args) {
	return new AsyncTaskLoader<String>(this) {
	    @Override
	    protected void onStartLoading() {
	    }
	    @Override
	    public String loadInBackground() {
	    }
	};
}

@Override
public void onLoadFinished(Loader<String> loader, String data) {

}

@Override
public void onLoaderReset(Loader<String> loader) {

}

3. Get LoaderManager by calling getSupportLoaderManager;

Get Loader by calling getLoader and passing the ID; Pass data to loader by bundle：

Bundle bundle = new Bundle();
bundle.putString("KEY", "VALUE");
LoaderManager loadManager = getSupportLoaderManager();
Loader<String> loader = loadManager.getLoader(LOADER_ID);
if (loader == null)
    loadManager.initLoader(LOADER_ID, bundle, this);
else
    loadManager.restartLoader(LOADER_ID, bundle, this);

Caching With Loaders

1. Create a cache member variable in your AsyncTaskLoader implementation.

Override deliverResult() so that save the fetched data in your cache first, before you call the superclass's implementation of deliverResult().

String cache;
@Override
public void deliverResult(String data) {
    this.cache = data;
    super.deliverResult(data);
}

2. In onStartLoading() check if there's cached data, and if so, let your AsyncTaskLoader just deliver that. Otherwise, start loading.

@Override
protected void onStartLoading() {
    /*do something here*/
    //If mGithubJson is not null, deliver that result.
    //Otherwise, force a load. 
    if (mGithubJson != null) {
      	/** I think we could call onLoadFinished directly,
            and it works for me well!**/
        //onLoadFinished(this, cache);
        deliverResult(cache);
    }else {
        forceLoad();
    }
}

Need more ? see here

Activity and Intent

An activity is a single, focused thing that the user can do. Almost all activities interact with the user, so the Activity class takes care of creating a window for you in which you can place your UI with setContentView(View).

While activities are often presented to the user as full-screen windows, they can also be used in other ways: as floating windows (via a theme with windowIsFloating set) or embedded inside of another activity (using ActivityGroup). There are two methods almost all subclasses of Activity will implement:

• An intent is an abstract description of an operation to be performed. It can be used with startActivity to launch an Activity, broadcastIntentto send it to any interested BroadcastReceiver components, and startService(Intent) or bindService(Intent, ServiceConnection, int) to communicate with a background Service.

• An Intent provides a facility for performing late runtime binding between the code in different applications. Its most significant use is in the launching of activities, where it can be thought of as the glue between activities. It is basically a passive data structure holding an abstract description of an action to be performed.

Start Activity

Class destinationClass = ChildActivity.class;
Intent intent = new Intent(context, destinationActivityClass);
startActivity(intent);

Same as startActivity(Intent, Bundle) with no options specified.

Pass Data

putExtra

intent.putExtra(Intent.EXTRA_TEXT, textToSend);

getIntent

Intent intent = getIntent();
if (intent.hasExtra(Intent.EXTRA_TEXT)) {
    String textEntered = intent.getStringExtra(Intent.EXTRA_TEXT);
}

Show "Back" Button

<activity
    android:name=".DetailActivity"
    android:parentActivityName=".MainActivity">
    <meta-data
        android:name="android.support.PARENT_ACTIVITY"
        android:value=".MainActivity" />
</activity>

Note:

If you want to "back" to the previous activity, use below code in your onCreate method and onOptionsItemSelected:

this.getSupportActionBar().setDisplayHomeAsUpEnabled(true);

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();
    if (id == android.R.id.home) {
        onBackPressed();
    }
    return super.onOptionsItemSelected(item);
}

Implicit Intent

Common Intents on Google developer.

URI syntax:
scheme:[//[user[:password]@]host[:port]][/path][?query][#fragment]

MIME(Multipurpose Internet Mail Extensions):
Content-Type: [type]/[subtype]; parameter

Call Browser to show a web page:

private void openWebPage(String url) {
	Uri webpage = Uri.parse(url);
  // Here, we create the Intent with the action of ACTION_VIEW. 
  // This action allows the user to view particular content.
    Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
  // This is a check we perform with every implicit Intent that we launch.
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivity(intent);
    }
}

Maps URI

String address = "Yanshan University";
        Uri.Builder builder = new Uri.Builder();
        Uri uri = builder.scheme("geo").path("0,0")
                .appendQueryParameter("q", address)
                .appendQueryParameter("z", "10").build();

Share Intent

ShareCompat.IntentBuilderIntentBuilder is a helper for constructing ACTION_SEND and ACTION_SEND_MULTIPLE sharing intents and starting activities to share content.

ShareCompat.IntentReaderIntentReader is a helper for reading the data contained within a sharing (ACTION_SEND) Intent.

private void shareText (String text) {
    String mimeType = "text/plain";
    String title = "Learn how to share";
    Intent intent = ShareCompat.IntentBuilder.from(this)
            .setChooserTitle(title)
            .setType(mimeType)
            .setText(text)
            .getIntent();
    startActivity(intent);
}

Lifecycle

Persist Data with onSaveInstanceState

@Override
protected void onCreate(Bundle savedInstanceState) {
	/*other things*/
    if (savedInstanceState != null) {
        String queryUrl = savedInstanceState.getString(SEARCH_QUERY_URL_EXTRA);
        mUrlDisplayTextView.setText(queryUrl);
    }
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
  
    String queryUrl = mUrlDisplayTextView.getText().toString();
    outState.putString(SEARCH_QUERY_URL_EXTRA, queryUrl);
}