search.xml

<?xml version="1.0" encoding="utf-8"?>
<search>
  <entry>
    <title>《E题1.0》</title>
    <url>/2022/10/06/HWB/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E9%97%AE%E9%A2%981">问题1</a></li>
<li><a href="#%E9%97%AE%E9%A2%982">问题2</a></li>
<li><a href="#%E9%97%AE%E9%A2%983">问题3</a></li>
<li><a href="#%E9%97%AE%E9%A2%984">问题4</a></li>
<li><a href="#%E9%97%AE%E9%A2%985">问题5</a></li>
<li><a href="#%E9%97%AE%E9%A2%986">问题6</a></li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="问题1">问题1</span></h1><h4><span id="从机理分析的角度建立不同放牧策略放牧方式和放牧强度对锡林郭勒草原土壤物理性质主要是土壤湿度和植被生物量影响的数学模型">从机理分析的角度，建立不同放牧策略（放牧方式和放牧强度）对锡林郭勒草原土壤物理性质（主要是土壤湿度）和植被生物量影响的数学模型</span></h4><p>筛选出放牧策略（载畜量）、降水、地表蒸发量数据，套用下方公式</p>
<p>画出植被生物量和单位时间的曲线，可求出对应的单位时间的斜率，推出该时间S和w的关系；</p>
<p>土壤含水量同理，但要将α换成w的式子；</p>
<p>画出土壤含水量和单位时间的曲线，可求出对应的单位时间的斜率，推出该时间S和w的关系；</p>
<p>E(a)直接使用蒸发量代替</p>
<p><img src="/2022/10/06/HWB/image-20221006201807430.png" alt="image-20221006201807430"></p>
<h1><span id="问题2">问题2</span></h1><p>先时间序列自回归预测浅层因子，然后用这些浅层因子做自变量做多元回归；</p>
<p>其中可以使用前十年的单一月份数据，来预测后一年单一月份数据（建12个模型）</p>
<h1><span id="问题3">问题3</span></h1><h4><span id="从机理分析的角度建立不同放牧策略放牧方式和放牧强度对锡林郭勒草原土壤化学性质影响的数学模型-并请结合附件14中数据预测锡林郭勒草原监测样地12个放牧小区在不同放牧强度下2022年土壤同期有机碳-无机碳-全n-土壤cx2fn比等值并完成下表">从机理分析的角度，建立不同放牧策略（放牧方式和放牧强度）对锡林郭勒草原土壤化学性质影响的数学模型。并请结合附件14中数据预测锡林郭勒草原监测样地(12个放牧小区)在不同放牧强度下2022年土壤同期有机碳、无机碳、全N、土壤C&#x2F;N比等值,并完成下表。</span></h4><p>时间序列自回归</p>
<h1><span id="问题4">问题4</span></h1><h4><span id="利用沙漠化程度指数预测模型和附件提供数据包括自己收集的数据确定不同放牧强度下监测点的沙漠化程度指数值">利用沙漠化程度指数预测模型和附件提供数据（包括自己收集的数据）确定不同放牧强度下监测点的沙漠化程度指数值。</span></h4><p>影响因子：风速、降水、气温（气象因素附件8）；植被盖度（附件10或6或5）、地表水资源（附件9）、地下水位（附件9）；人口数量、牲畜数量、社会经济水平（附件2）等等。</p>
<p>PCA加权累加</p>
<p><img src="/2022/10/06/HWB/image-20221006191041118.png" alt="image-20221006191041118"></p>
<h4><span id="并请尝试给出定量的土壤板结化定义">并请尝试给出定量的土壤板结化定义</span></h4><p><img src="/2022/10/06/HWB/image-20221006192120031.png" alt="image-20221006192120031"></p>
<h4><span id="在建立合理的土壤板结化模型基础上结合问题3给出放牧策略模型使得沙漠化程度指数与板结化程度最小">在建立合理的土壤板结化模型基础上结合问题3，给出放牧策略模型，使得沙漠化程度指数与板结化程度最小。</span></h4><p>带入第一题公式和板结化公式，求解S</p>
<h1><span id="问题5">问题5</span></h1><h4><span id="锡林郭勒草原近10的年降水量包含降雪通常在300-mm-~1200-mm之间请在给定的降水量300mm600mm-900-mm-和1200mm情形下在保持草原可持续发展情况下对实验草场内附件14-15放牧羊的数量进行求解找到最大阈值-注这里计算结果可以不是正整数">锡林郭勒草原近10的年降水量（包含降雪）通常在300 mm ~1200 mm之间，请在给定的降水量（300mm，600mm、900 mm 和1200mm）情形下，在保持草原可持续发展情况下对实验草场内（附件14、15）放牧羊的数量进行求解，找到最大阈值。（注：这里计算结果可以不是正整数）</span></h4><p>筛选出满足降水条件的年份对应的数据。</p>
<p><img src="/2022/10/06/HWB/image-20221006193918802.png" alt="image-20221006193918802"></p>
<h1><span id="问题6">问题6</span></h1><h4><span id="在保持附件13的示范牧户放牧策略不变和问题4中得到的放牧方案两种情况下用图示或者动态演示方式分别预测示范区2023年9月土地状态比如土壤肥力变化-土壤湿度-植被覆盖等">在保持附件13的示范牧户放牧策略不变和问题4中得到的放牧方案两种情况下，用图示或者动态演示方式分别预测示范区2023年9月土地状态（比如土壤肥力变化、土壤湿度、植被覆盖等）</span></h4><p>善男先做</p>
]]></content>
      <categories>
        <category>建模</category>
      </categories>
      <tags>
        <tag>建模</tag>
      </tags>
  </entry>
  <entry>
    <title>施磊C++初级STL笔记</title>
    <url>/2023/03/22/cpp_STL_note/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#c-stl%E5%88%86%E7%B1%BB">C++ STL分类</a><ul>
<li><a href="#%E4%B8%80-%E6%A0%87%E5%87%86%E5%AE%B9%E5%99%A8">一、标准容器</a><ul>
<li><a href="#1%E9%A1%BA%E5%BA%8F%E5%AE%B9%E5%99%A8">1.顺序容器</a></li>
<li><a href="#2%E5%AE%B9%E5%99%A8%E9%80%82%E9%85%8D%E5%99%A8">2.容器适配器</a></li>
<li><a href="#3%E5%85%B3%E8%81%94%E5%AE%B9%E5%99%A8">3.关联容器</a></li>
</ul>
</li>
<li><a href="#%E4%BA%8C-%E8%BF%91%E5%AE%B9%E5%99%A8">二、近容器</a></li>
<li><a href="#%E4%B8%89-%E8%BF%AD%E4%BB%A3%E5%99%A8">三、迭代器</a></li>
<li><a href="#%E5%9B%9B-%E5%87%BD%E6%95%B0%E5%AF%B9%E8%B1%A1">四、函数对象</a></li>
<li><a href="#%E4%BA%94-%E6%B3%9B%E5%9E%8B%E7%AE%97%E6%B3%95">五、泛型算法</a></li>
</ul>
</li>
<li><a href="#vector%E5%AE%B9%E5%99%A8">vector容器</a></li>
<li><a href="#deque%E5%AE%B9%E5%99%A8">deque容器</a></li>
<li><a href="#list%E5%AE%B9%E5%99%A8">list容器</a></li>
<li><a href="#%E5%AE%B9%E5%99%A8%E9%80%82%E9%85%8D%E5%99%A8">容器适配器</a></li>
<li><a href="#%E5%85%B3%E8%81%94%E5%AE%B9%E5%99%A8">关联容器</a></li>
<li><a href="#%E8%BF%AD%E4%BB%A3%E5%99%A8">迭代器</a></li>
<li><a href="#%E5%87%BD%E6%95%B0%E5%AF%B9%E8%B1%A1">函数对象</a></li>
<li><a href="#%E6%B3%9B%E5%9E%8B%E7%AE%97%E6%B3%95">泛型算法</a></li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="c-stl分类">C++ STL分类</span></h1><h2><span id="一-标准容器">一、标准容器</span></h2><h3><span id="1顺序容器">1.顺序容器</span></h3><p>vector    deque    list</p>
<h3><span id="2容器适配器">2.容器适配器</span></h3><p>stack    queue    priority_queue</p>
<h3><span id="3关联容器">3.关联容器</span></h3><p>无序关联容器    链式哈希表    增删查O(1)</p>
<p>unordered_set    unordered_multiset    unordered_map    unordered_multimap</p>
<p>有序关联容器</p>
<p>set    multiset    map    multimap</p>
<h2><span id="二-近容器">二、近容器</span></h2><p>数组    string    bitset</p>
<h2><span id="三-迭代器">三、迭代器</span></h2><p>iterator    const_iterator</p>
<p>reverse_iterator    const_reverse_iterator</p>
<h2><span id="四-函数对象">四、函数对象</span></h2><p>greater    less</p>
<h2><span id="五-泛型算法">五、泛型算法</span></h2><p>sort    find    find_if    binary_search    for_each</p>
<h1><span id="vector容器">vector容器</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230322224639551.png" alt="image-20230322224639551"></p>
<h1><span id="deque容器">deque容器</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230322231048003.png" alt="image-20230322231048003"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230322232359532.png" alt="image-20230322232359532"></p>
<h1><span id="list容器">list容器</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230322232440404.png" alt="image-20230322232440404"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230322232641231.png" alt="image-20230322232641231"></p>
<p><strong>vector、deque、list区别</strong></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323102712597.png" alt="image-20230323102712597"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323102855340.png" alt="image-20230323102855340"></p>
<h1><span id="容器适配器">容器适配器</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230323111005628.png" alt="image-20230323111005628"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323110945919.png" alt="image-20230323110945919"></p>
<h1><span id="关联容器">关联容器</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230323111555262.png" alt="image-20230323111555262"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323111417256.png" alt="image-20230323111417256"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323112926253.png" alt="image-20230323112926253"></p>
<h1><span id="迭代器">迭代器</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230323150210820.png" alt="image-20230323150210820"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323145614546.png" alt="image-20230323145614546"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323145734503.png" alt="image-20230323145734503"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323145949126.png" alt="image-20230323145949126"></p>
<h1><span id="函数对象">函数对象</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230323152022993.png" alt="image-20230323152022993"></p>
<p>通过函数指针调用函数，是没有办法内联的，效率很低，因为没有函数调用开销。</p>
<p><strong>所以需要函数对象来代替函数指针</strong></p>
<p> <img src="/2023/03/22/cpp_STL_note/image-20230323152258041.png" alt="image-20230323152258041"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323152325846.png" alt="image-20230323152325846"></p>
<h1><span id="泛型算法">泛型算法</span></h1><p><img src="/2023/03/22/cpp_STL_note/image-20230323194139744.png" alt="image-20230323194139744"></p>
<p><img src="/2023/03/22/cpp_STL_note/image-20230323195045590.png" alt="image-20230323195045590"></p>
]]></content>
      <categories>
        <category>C++</category>
      </categories>
      <tags>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>《游戏资源中常见的贴图类型介绍》</title>
    <url>/2023/07/12/link_1/</url>
    <content><![CDATA[<!-- toc -->



<!-- tocstop -->

<span id="more"></span>

<p><a href="https://zhuanlan.zhihu.com/p/260973533">游戏资源中常见的贴图类型 - 知乎 (zhihu.com)</a></p>
]]></content>
      <categories>
        <category>link</category>
      </categories>
      <tags>
        <tag>有用的博文</tag>
      </tags>
  </entry>
  <entry>
    <title>施磊C++初级笔记</title>
    <url>/2023/03/20/cpp_basic_note/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E6%B7%B1%E5%85%A5%E5%AD%A6%E4%B9%A0c%E8%AF%AD%E8%A8%80%E5%85%88%E8%A6%81%E7%BB%83%E5%A5%BD%E7%9A%84%E5%86%85%E5%8A%9F">1 深入学习C++语言先要练好的内功</a><ul>
<li><a href="#11-%E6%8E%8C%E6%8F%A1%E8%BF%9B%E7%A8%8B%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E7%A9%BA%E9%97%B4%E5%8C%BA%E5%9F%9F%E5%88%92%E5%88%86">1.1 掌握进程虚拟地址空间区域划分</a></li>
<li><a href="#12-%E4%BB%8E%E6%8C%87%E4%BB%A4%E8%A7%92%E5%BA%A6%E6%8E%8C%E6%8F%A1%E5%87%BD%E6%95%B0%E8%B0%83%E7%94%A8%E5%A0%86%E6%A0%88%E8%AF%A6%E7%BB%86%E8%BF%87%E7%A8%8B">1.2 从指令角度掌握函数调用堆栈详细过程</a></li>
<li><a href="#13-%E4%BB%8E%E7%BC%96%E8%AF%91%E5%99%A8%E8%A7%92%E5%BA%A6%E7%90%86%E8%A7%A3c%E4%BB%A3%E7%A0%81%E7%9A%84%E7%BC%96%E8%AF%91%E5%92%8C%E9%93%BE%E6%8E%A5%E5%8E%9F%E7%90%86">1.3 从编译器角度理解C++代码的编译和链接原理</a></li>
</ul>
</li>
<li><a href="#2-c%E5%9F%BA%E7%A1%80">2 C++基础</a><ul>
<li><a href="#21-%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3newdelete">2.1 深入理解new，delete</a></li>
<li><a href="#22-c%E7%9A%84const">2.2 C++的const</a><ul>
<li><a href="#const%E6%80%8E%E4%B9%88%E7%90%86%E8%A7%A3">const怎么理解？</a></li>
<li><a href="#c%E5%92%8Cc%E4%B8%AD%E7%9A%84%E5%8C%BA%E5%88%AB%E6%98%AF%E4%BB%80%E4%B9%88">C和C++中的区别是什么？</a></li>
</ul>
</li>
<li><a href="#23-const%E5%92%8C%E4%B8%80%E4%BA%8C%E5%A4%9A%E7%BA%A7%E6%8C%87%E9%92%88%E7%9A%84%E7%BB%93%E5%90%88%E5%BA%94%E7%94%A8">2.3 const和一二（多）级指针的结合应用</a><ul>
<li><a href="#const%E4%BF%AE%E9%A5%B0%E7%9A%84%E9%87%8F%E5%B8%B8%E5%87%BA%E7%8E%B0%E7%9A%84%E9%94%99%E8%AF%AF">const修饰的量常出现的错误</a></li>
<li><a href="#const%E5%92%8C%E4%B8%80%E7%BA%A7%E6%8C%87%E9%92%88%E7%9A%84%E7%BB%93%E5%90%88">const和一级指针的结合</a></li>
<li><a href="#const%E5%92%8C%E4%BA%8C%E7%BA%A7%E6%8C%87%E9%92%88%E7%9A%84%E7%BB%93%E5%90%88">const和二级指针的结合</a></li>
</ul>
</li>
<li><a href="#24-c%E7%9A%84%E5%BC%95%E7%94%A8">2.4 C++的引用</a></li>
<li><a href="#25-%E5%87%BD%E6%95%B0%E9%87%8D%E8%BD%BD">2.5 函数重载</a></li>
<li><a href="#26-inline%E5%87%BD%E6%95%B0">2.6 inline函数</a></li>
</ul>
</li>
<li><a href="#3-c%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1">3 C++面向对象</a><ul>
<li><a href="#31-this%E6%8C%87%E9%92%88">3.1 this指针</a></li>
<li><a href="#32-%E5%AF%B9%E8%B1%A1%E7%9A%84%E6%B7%B1%E6%8B%B7%E8%B4%9D%E5%92%8C%E6%B5%85%E6%8B%B7%E8%B4%9D">3.2 对象的深拷贝和浅拷贝</a></li>
<li><a href="#33-%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0%E7%9A%84%E5%88%9D%E5%A7%8B%E5%8C%96%E5%88%97%E8%A1%A8">3.3 构造函数的初始化列表</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<p><img src="/2023/03/20/cpp_basic_note/image-20230321143438563.png" alt="image-20230321143438563"></p>
<h1><span id="1-深入学习c语言先要练好的内功">1 深入学习C++语言先要练好的内功</span></h1><h2><span id="11-掌握进程虚拟地址空间区域划分">1.1 掌握进程虚拟地址空间区域划分</span></h2><p><img src="/2023/03/20/cpp_basic_note/image-20230320221443055.png" alt="image-20230320221443055"></p>
<p><img src="/2023/03/20/cpp_basic_note/image-20230320221901794.png" alt="image-20230320221901794"></p>
<h2><span id="12-从指令角度掌握函数调用堆栈详细过程">1.2 从指令角度掌握函数调用堆栈详细过程</span></h2><p><img src="/2023/03/20/cpp_basic_note/image-20230321111119551.png" alt="image-20230321111119551"></p>
<p><img src="/2023/03/20/cpp_basic_note/image-20230321112224556.png" alt="image-20230321112224556"></p>
<p>具体得看视频，讲述了main函数调用sum方法每步的空间变化。</p>
<h2><span id="13-从编译器角度理解c代码的编译和链接原理">1.3 从编译器角度理解C++代码的编译和链接原理</span></h2><p><img src="/2023/03/20/cpp_basic_note/image-20230321142611763.png" alt="image-20230321142611763"></p>
<p><img src="/2023/03/20/cpp_basic_note/image-20230321142632348.png" alt="image-20230321142632348"></p>
<h1><span id="2-c基础">2 C++基础</span></h1><h2><span id="21-深入理解newdelete">2.1 深入理解new，delete</span></h2><p>malloc和free称作C的库函数，new和delete称作运算符；</p>
<p>new不仅可以做内存开辟，还可以做内存初始化操作；</p>
<p>malloc开辟内存失败，是通过返回值和nullptr作比较；而new开辟内存失败，是通过抛出bad_alloc类型的异常来判断；</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// new有多少种？</span></span><br><span class="line"><span class="type">int</span> *p1 = <span class="keyword">new</span> <span class="built_in">int</span>(<span class="number">20</span>);</span><br><span class="line"><span class="type">int</span> *p2 = <span class="built_in">new</span> (nothrow) <span class="type">int</span>;</span><br><span class="line"><span class="type">const</span> <span class="type">int</span> *p3 = <span class="keyword">new</span> <span class="type">const</span> <span class="built_in">int</span>(<span class="number">40</span>);</span><br><span class="line"></span><br><span class="line"><span class="comment">// 定位new</span></span><br><span class="line"><span class="type">int</span> data = <span class="number">0</span>;</span><br><span class="line"><span class="comment">// 在一块已经定位好内存的内存块上，初始化值为50</span></span><br><span class="line"><span class="type">int</span> *p4 = <span class="built_in">new</span> (&amp;data) <span class="built_in">int</span>(<span class="number">50</span>);</span><br></pre></td></tr></table></figure>

<h2><span id="22-c的const">2.2 C++的const</span></h2><h3><span id="const怎么理解">const怎么理解？</span></h3><p>const修饰的变量不能再作为左值！！！初始化完成后值不能被修改！！！</p>
<h3><span id="c和c中的区别是什么">C和C++中的区别是什么？</span></h3><p>C中const修饰的量不叫常量，叫常变量 ；</p>
<p>C++中const必须初始化，叫常量；</p>
<p>C++中若</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">int</span> b = <span class="number">20</span>;</span><br><span class="line"><span class="type">const</span> <span class="type">int</span> a = b;</span><br></pre></td></tr></table></figure>

<p>此时a已经被修改了，就是常变量而不是常量了，因为其初始值不是一个立即数。</p>
<p>const编译方式不同，C中const当作一个变量来编译生成指令的；C++中，所有出现const常量名字的地方都会被常量的初始值替换；</p>
<h2><span id="23-const和一二多级指针的结合应用">2.3 const和一二（多）级指针的结合应用</span></h2><h3><span id="const修饰的量常出现的错误">const修饰的量常出现的错误</span></h3><p>1.常量不能再作为左值；（直接修改）</p>
<p>2.不能把常量的地址泄露给一个普通的指针或者普通的引用变量；（如下做了间接修改）</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">const</span> <span class="type">int</span> a = <span class="number">10</span>;</span><br><span class="line"></span><br><span class="line"><span class="type">int</span> *p = &amp;a;	<span class="comment">// int* &lt;= const int* xxx!!!</span></span><br></pre></td></tr></table></figure>

<h3><span id="const和一级指针的结合">const和一级指针的结合</span></h3><figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">const</span> <span class="type">int</span> *p；	<span class="comment">// p指针可以指向任意int类型的内存，但无法通过指针间接修改指向的内存的值（离const最近的类型为int）</span></span><br><span class="line"><span class="type">int</span> <span class="type">const</span>* p;	<span class="comment">// 同上</span></span><br><span class="line"><span class="type">int</span> *<span class="type">const</span> p;	<span class="comment">// 这个指针p现在是常量，不能再指向其他内存，但可以通过指针解引用修改指向的内存的值（离const最近的类型为int*）</span></span><br><span class="line"><span class="type">const</span> <span class="type">int</span> *<span class="type">const</span> p;	<span class="comment">// 指针p是常量，其指向内存的值也无法修改</span></span><br></pre></td></tr></table></figure>

<p>C++的语言规范：const修饰的使离它最近的类型</p>
<p>const和一级指针的结合有两种情况：</p>
<p><strong>一种是使指针是常量，无法再指向其他内存；一种是使指针指向的内存的值是常量，无法在被修改。</strong></p>
<p>总结，const和指针的类型转换公式：</p>
<p><em><em>int</em>    &lt;&#x3D;    const int</em>    是错误的！**</p>
<p><em><em>const int</em>    &lt;&#x3D;    int</em>    是可以的！**</p>
<p><strong>int**    &lt;&#x3D;    const int**是错误的!</strong></p>
<p><strong>const int**    &lt;&#x3D;    int**是错误的！</strong></p>
<p><strong>const如果右边没有指针*的话，const是不参与类型的。</strong></p>
<h3><span id="const和二级指针的结合">const和二级指针的结合</span></h3><figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">const</span> <span class="type">int</span> **q;	<span class="comment">// **q不能被赋值</span></span><br><span class="line"><span class="type">int</span> *<span class="type">const</span>* q;	<span class="comment">// *q不能被赋值</span></span><br><span class="line"><span class="type">int</span> **<span class="type">const</span> q;	<span class="comment">// q不能被赋值</span></span><br></pre></td></tr></table></figure>

<h2><span id="24-c的引用">2.4 C++的引用</span></h2><p><strong>引用和指针的区别？</strong></p>
<p>引用是一种更安全的指针。</p>
<p>1.引用是必须初始化的，指针可以不初始化；</p>
<p>2.引用只有一级引用，不存在多级引用；指针可以有一级指针，也可以有多级指针；</p>
<p>3.定义一个引用变量和定义一个指针变量其汇编指令是一模一样的；通过引用变量修改所引用内存的值，和通过指针解引用修改指针指向内存的值，其底层指令也是一模一样的；</p>
<p><strong>右值引用</strong></p>
<p>1.int &amp;&amp;c &#x3D; 20;    专门用来引用右值类型，指令上，可以自动产生临时量，然后直接引用临时量 c &#x3D; 40;</p>
<p>2.右值引用变量本身是一个左值，只能用左值引用来引用它；</p>
<p>3.不能用一个右值引用变量来引用一个左值；</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">int</span> array[<span class="number">5</span>] = &#123;&#125;;</span><br><span class="line"><span class="type">int</span> *p = array;</span><br><span class="line"><span class="comment">// 定义一个引用变量，来引用array数组</span></span><br><span class="line"><span class="built_in">int</span> (&amp;q)[<span class="number">5</span>] = array;</span><br><span class="line">cout &lt;&lt; <span class="built_in">sizeof</span>(array) &lt;&lt; endl;</span><br><span class="line">cout &lt;&lt; <span class="built_in">sizeof</span>(p) &lt;&lt; endl;</span><br><span class="line">cout &lt;&lt; <span class="built_in">sizeof</span>(q) &lt;&lt; endl;</span><br><span class="line"><span class="comment">// 20 4 20</span></span><br></pre></td></tr></table></figure>

<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">int</span> a = <span class="number">10</span>;	<span class="comment">// 左值，它有内存，有名字，值可以修改</span></span><br><span class="line"><span class="type">int</span> &amp;b = a;</span><br><span class="line"></span><br><span class="line"><span class="comment">// int &amp;c = 2-; // 20是右值：没内存，没名字</span></span><br><span class="line"><span class="comment">// C++提供了右值引用	一个右值引用变量本身是一个左值</span></span><br><span class="line"><span class="type">int</span> &amp;&amp;c = <span class="number">20</span>;</span><br><span class="line">c = <span class="number">30</span>;</span><br><span class="line"><span class="comment">/*</span></span><br><span class="line"><span class="comment">int tmp = 20;</span></span><br><span class="line"><span class="comment">tmp -&gt; d</span></span><br><span class="line"><span class="comment">*/</span></span><br><span class="line"><span class="type">const</span> <span class="type">int</span> &amp;d = <span class="number">20</span>;</span><br></pre></td></tr></table></figure>

<p> <strong>const、一级指针、引用的结合</strong></p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 写一句代码，在内存0x0018ff44处写一个4字节的10</span></span><br><span class="line"><span class="comment">// 引用一个int常量</span></span><br><span class="line"><span class="type">int</span> *<span class="type">const</span> &amp;p = (<span class="type">int</span>*)<span class="number">0x0018ff44</span>;</span><br><span class="line"></span><br><span class="line"><span class="type">int</span> a = <span class="number">10</span>;</span><br><span class="line"><span class="type">int</span> *p = &amp;a;</span><br><span class="line"><span class="comment">// q是a的引用变量</span></span><br><span class="line"><span class="type">int</span> *&amp;q = p;</span><br></pre></td></tr></table></figure>

<h2><span id="25-函数重载">2.5 函数重载</span></h2><p><strong>什么是函数重载</strong></p>
<p>1.一组函数，其中函数名相同，参数列表的个数或者类型不同，那么这一组函数就称作函数重载；</p>
<p>2.一组函数要称得上重载，一定先是处在同一个作用域当中的；</p>
<p>3.const或者volatile，是怎么影响形参类型的；</p>
<p>4.一组函数，函数名相同，参数列表也相同，仅仅是返回值不同不叫重载；</p>
<p><strong>请解释一下多态？</strong></p>
<p>静态（编译时期）的多态：函数重载</p>
<p>动态（运行时期）的多态：</p>
<p><strong>C++为什么支持函数重载，C语言不支持函数重载？</strong></p>
<p>C++代码产生函数符号的时候，函数名+参数列表类型组成的！</p>
<p>C代码产生函数符号，函数名来决定！</p>
<h2><span id="26-inline函数">2.6 inline函数</span></h2><p><strong>inline内联函数和普通函数的区别</strong></p>
<p>inline函数：在编译过程中，就没有函数的调用开销了，在函数的调用点直接把函数的代码进行展开处理了</p>
<p>inline函数不再生成相应的函数符号</p>
<p>inline只是建议编译器把这个函数处理成内联函数，但是不是所有的inline都会被编译器处理成内联函数——递归</p>
<p>debug版本上，inline是不起作用的；inline只有在release版本下才能出现</p>
<p>g++ -c main.cpp -02        objdump -t main.o</p>
<h1><span id="3-c面向对象">3 C++面向对象</span></h1><h2><span id="31-this指针">3.1 this指针</span></h2><p>this指针 &#x3D;&gt; 类 &#x3D;&gt; 很多对象 共享一套成员方法</p>
<p>成员方法，方法的参数都会添加一个this指针</p>
<p>构造函数：定义对象时，自动调用的；可以重载的；构造完成，对象产生了</p>
<p>析构函数：不带参数，不能重载，只有一个析构函数；析构完成，对象就不存在了</p>
<p><strong>OOP语言的四大特征是？</strong></p>
<p>抽象    封装&#x2F;隐藏    继承    多态</p>
<h2><span id="32-对象的深拷贝和浅拷贝">3.2 对象的深拷贝和浅拷贝</span></h2><p>对象默认的拷贝构造是做内存的数据拷贝</p>
<p>关键是对象<strong>如果占用外部资源</strong>，那么浅拷贝就出现问题了！（占用同一个资源析构两次就会出错！）</p>
<p>此时（对象的浅拷贝出现问题了）就需要自定义<strong>拷贝构造函数</strong>和<strong>赋值函数</strong>（运算符重载）</p>
<h2><span id="33-构造函数的初始化列表">3.3 构造函数的初始化列表</span></h2><p><strong>初始化列表做初始化和在函数体内初始化区别？</strong></p>
<p>int amount &#x3D; 0；和 int amount; amount &#x3D; 0;的区别，若数据类型为自定义类型，未指定该自定义类型的构造函数（调用默认构造函数），则无法成功构造。</p>
]]></content>
      <categories>
        <category>C++</category>
      </categories>
      <tags>
        <tag>C++</tag>
      </tags>
  </entry>
  <entry>
    <title>《Face-to-Parameter Translation for Game Character Auto-Creation》</title>
    <url>/2022/07/24/review_10_F2P/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E6%96%B9%E6%B3%95%E7%AE%80%E8%BF%B0">方法简述</a><ul>
<li><a href="#%E8%B4%A1%E7%8C%AE">贡献</a></li>
</ul>
</li>
<li><a href="#%E6%96%B9%E6%B3%95%E8%AF%A6%E8%A7%A3">方法详解</a><ul>
<li><a href="#1imitator">1.Imitator</a></li>
<li><a href="#2facial-similarity-measurement">2.Facial Similarity Measurement</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content_ICCV_2019/papers/Shi_Face-to-Parameter_Translation_for_Game_Character_Auto-Creation_ICCV_2019_paper.pdf">Face-to-Parameter Translation for Game Character Auto-Creation (thecvf.com)</a></p>
<p>code: no code</p>
<p>reference link: <a href="https://zhuanlan.zhihu.com/p/105037127">【1】伏羲AI lab：脸部照片到脸部参数的游戏角色自动生成 论文笔记 - 知乎 (zhihu.com)</a></p>
<span id="more"></span>

<h1><span id="出发点">出发点</span></h1><p>RPG游戏中捏脸的标准工作流是从配置大量<strong>面部参数</strong>开始，然后，游戏引擎将这些用户指定的参数作为输入，并生成3D人脸。也可以说游戏人脸定制是一种3DMM的特例或是一种风格迁移问题。</p>
<p>但遗憾的是，上述方法不能直接应用于游戏环境中。原因有三。首先，这些方法并不是用于生成参数化的角色，而这对于大多数游戏引擎来说是必不可少的，因为它们通常会<strong>接受游戏角色的定制参数</strong>，而不是图像或3D网格。其次，这些方法对用户交互不友好，因为大多数用户很难直接编辑Mesh。最后，给定一组用户指定参数的游戏引擎的渲染过程是不可微分的，这进一步限制了深度学习方法在游戏环境中的适用性。</p>
<h1><span id="方法简述">方法简述</span></h1><p>针对上述问题，本文提出了一种根据玩家输入的人脸照片自动生成游戏角色的方法，如图所示。</p>
<p><img src="/2022/07/24/review_10_F2P/image-20220724165007254.png" alt="image-20220724165007254"></p>
<p>与以往3DMM方法不同，我们的方法通过<strong>预测一组具有明确物理意义的面部参数，为骨骼驱动的模型创建三维轮廓</strong>。在我们的方法中，每个参数控制每个面部组件的一个单独属性，包括位置、方向和比例。更重要的是，我们的方法在创建结果的基础上支持额外的用户交互，玩家可以根据自己的需求进一步改进他们的形象。由于游戏引擎的渲染过程是不可微分的，我们设计了一个生成网络作为“模仿者”来模仿游戏引擎的物理行为，从而可以在神经风格传递框架下实现本文提出的方法，并使用梯度下降法优化面部参数。</p>
<h2><span id="贡献">贡献</span></h2><p>1)我们提出了一种端到端的人脸参数转换和游戏角色自动生成方法。据我们所知，关于这一主题的研究工作很少。</p>
<p>2)由于游戏引擎的渲染过程是不可区分的，我们引入了一个模仿者，通过构建一个深度生成网络来模仿游戏引擎的行为。这样，梯度可以平滑地反向传播到输入，从而利用梯度下降法更新人脸参数。</p>
<p>3)为跨域人脸相似度测量设计了两个损失函数。提出的目标可以在多任务学习框架中联合优化。</p>
<h1><span id="方法详解">方法详解</span></h1><p><img src="/2022/07/24/review_10_F2P/image-20220724165938954.png" alt="image-20220724165938954"></p>
<h2><span id="1imitator">1.Imitator</span></h2><p><img src="/2022/07/24/review_10_F2P/image-20220724194516986.png" alt="image-20220724194516986"></p>
<p>采用类似DCGAN的结构，包含8个反卷积层，用来模拟游戏引擎从脸部参数到脸部图像的映射。然后将真实游戏引擎的渲染结果与模拟器生成的图像算L1 loss。训练用了20000对人脸图像，游戏引擎用的是逆水寒的游戏引擎。</p>
<p><img src="/2022/07/24/review_10_F2P/image-20220724195638704.png" alt="image-20220724195638704"></p>
<p>图4显示了我们的模仿者的“渲染”结果的三个示例。这些图像的面部参数是手动创建的。由于训练样本是根据面部参数的统一分布随机生成的，所以对于大多数人物可能看起来很奇怪(请参阅我们的补充资料)。尽管如此，我们仍然可以从图4中看到，生成的人脸图像和渲染的地面真实图像有很高的相似性，即使在一些纹理复杂的区域，如头发。这表明我们的模仿者不仅将训练数据拟合在一个低维的人脸流形中，而且还学会了解耦不同人脸参数之间的相关性。</p>
<h2><span id="2facial-similarity-measurement">2.Facial Similarity Measurement</span></h2><p>alignment后的真实人脸与Imitator生成的人脸通过预训练好的识别网络算embedding间的余弦相似度。</p>
<p><img src="/2022/07/24/review_10_F2P/image-20220725143108613.png" alt="image-20220725143108613"></p>
<p>又采用了一个预训练好的分割网络对两张图像进行分割，在著名的Helen face语义分割数据集上训练该模型。为了提高人脸语义特征的位置敏感性，进一步使用分割结果(分类概率图)作为特征图的像素权值，构建位置敏感的内容丢失函数。通俗点应该就是针对每个部分对feature map做掩码算L1。</p>
<p><img src="/2022/07/24/review_10_F2P/image-20220725144042722.png" alt="image-20220725144042722"></p>
<p><img src="/2022/07/24/review_10_F2P/image-20220725143221347.png" alt="image-20220725143221347"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>Game Character Create</tag>
      </tags>
  </entry>
  <entry>
    <title>《High-Fidelity 3D Digital Human Head Creation from RGB-D Selfies》</title>
    <url>/2022/10/17/review_11_Hifi3dFace/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E5%AE%9E%E7%8E%B0%E6%95%88%E6%9E%9C">1. 实现效果</a></li>
<li><a href="#2-%E5%85%A8%E9%83%A8%E7%AE%97%E6%B3%95%E6%80%BB%E8%A7%88">2. 全部算法总览</a><ul>
<li><a href="#21-%E6%95%B0%E6%8D%AE%E9%9B%86">2.1 数据集</a></li>
<li><a href="#22-%E7%9B%AE%E6%A0%87">2.2 目标</a></li>
<li><a href="#23-%E7%94%A8%E6%88%B7%E8%BE%93%E5%85%A5%E6%95%B0%E6%8D%AE">2.3 用户输入数据</a></li>
<li><a href="#24-%E5%A4%84%E7%90%86%E7%AE%A1%E7%BA%BF">2.4 处理管线</a></li>
</ul>
</li>
<li><a href="#3-%E5%85%B7%E4%BD%93%E7%AE%97%E6%B3%95">3. 具体算法</a><ul>
<li><a href="#31-%E5%B8%A7%E9%80%89%E6%8B%A9">3.1 帧选择</a><ul>
<li><a href="#311-%E7%B2%97%E7%AD%9B%E5%92%8C%E9%A2%84%E5%A4%84%E7%90%86">3.1.1 粗筛和预处理</a></li>
<li><a href="#312-%E5%B8%A7%E9%80%89%E6%8B%A9">3.1.2 帧选择</a></li>
</ul>
</li>
<li><a href="#32-%E5%87%A0%E4%BD%95%E7%94%9F%E6%88%90">3.2 几何生成</a><ul>
<li><a href="#321-%E5%88%9D%E5%A7%8B%E6%A8%A1%E5%9E%8B%E5%AE%9A%E4%B9%89">3.2.1 初始模型定义</a></li>
<li><a href="#322-%E4%BC%98%E5%8C%96%E6%A1%86%E6%9E%B6">3.2.2 优化框架</a></li>
<li><a href="#323-%E5%8F%AF%E5%BD%A2%E5%8F%98%E6%A8%A1%E5%9E%8B%E7%9A%84%E5%A2%9E%E5%BC%BA%E6%89%A9%E5%85%853d%E6%95%B0%E6%8D%AE%E7%9A%84%E6%96%B9%E6%B3%95">3.2.3 可形变模型的增强（扩充3D数据的方法）</a></li>
</ul>
</li>
<li><a href="#33-%E8%B4%B4%E5%9B%BE%E7%94%9F%E6%88%90">3.3 贴图生成</a><ul>
<li><a href="#331-%E5%9F%BA%E4%BA%8E%E5%8C%BA%E5%9F%9F%E9%87%91%E5%AD%97%E5%A1%94%E7%9A%84%E5%8F%82%E6%95%B0%E8%A1%A8%E7%A4%BA%E6%9E%84%E9%80%A0%E8%AF%A6%E8%A7%A3regional-pyramid-bases">3.3.1 基于区域金字塔的参数表示构造详解（Regional Pyramid bases）</a></li>
<li><a href="#332-%E5%8C%BA%E5%9F%9F%E6%8B%9F%E5%90%88regional-fitting">3.3.2 区域拟合（Regional Fitting）</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content_ICCV_2019/papers/Shi_Face-to-Parameter_Translation_for_Game_Character_Auto-Creation_ICCV_2019_paper.pdf">https://arxiv.org/abs/2010.05562</a></p>
<p>code: <a href="https://github.com/tencent-ailab/hifi3dface">tencent-ailab&#x2F;hifi3dface: Code and data for our paper “High-Fidelity 3D Digital Human Creation from RGB-D Selfies”. (github.com)</a></p>
<p>ref link:<a href="https://blog.csdn.net/jiafeier_555/article/details/125428388">https://blog.csdn.net/jiafeier_555/article/details/125428388</a></p>
<span id="more"></span>

<h1><span id="1-实现效果">1. 实现效果</span></h1><p>将用户的RGB-D自拍作为输入，自动生成高保真、可装配的头部模型，以及高分辨率的纹理图和法线图。</p>
<h1><span id="2-全部算法总览">2. 全部算法总览</span></h1><h2><span id="21-数据集">2.1 数据集</span></h2><p>包含各100名男女性的3D人脸，20481个顶点和40832个面片，每个模型对应2K分辨率的纹理图和法线图。</p>
<h2><span id="22-目标">2.2 目标</span></h2><p>用RGB-D自拍数据捕捉高保真用户的面部几何形状和反射率，该数据进一步用于创建和渲染全头、逼真的数字人类。<strong>对于几何建模，我们使用3DMM参数来表示一个面，因为它对低级别的输入数据更鲁棒，并且与基于变形的表示形式相比，网格质量更可控</strong>。对于纹理建模，我们合成了2K分辨率的反照率图和法线图，而不考虑输入的RGB-D分辨率。 </p>
<h2><span id="23-用户输入数据">2.3 用户输入数据</span></h2><p>需要通过带深度相机的手机设备采集RGB-D数据，腾讯其有个采集软件，拍摄界面将引导用户连续向左、向右、向上和向后中间旋转头部。整个采集过程不到10秒，总共采集了200-300帧RGB-D图像，分辨率为640×480。用于计算的面部区域被裁剪（并调整大小）为300×300。相机的固有参数直接从设备读取。 </p>
<h2><span id="24-处理管线">2.4 处理管线</span></h2><p>我们首先使用自动帧选择算法来选择覆盖用户所有侧面的几个高质量帧（第4节）。然后，使用所选帧中检测到的面部标志计算初始3DMM模型拟合（第5.1节）。从初始拟合开始，应用基于可差分渲染器的多视图RGB-D约束优化（第5.2节）来求解3DMM参数以及照明参数和姿势。根据估计的参数，合成高分辨率反照率法向图（第6节）。最后，可以创建和渲染高质量、逼真的全头像（第7节）。</p>
<h1><span id="3-具体算法">3. 具体算法</span></h1><h2><span id="31-帧选择">3.1 帧选择</span></h2><p>通常从用户获取200-300帧。为了提高效率和健壮性，我们开发了一个健壮的帧选择程序，以选择几个高质量的帧进行进一步处理，该程序同时考虑了视图覆盖和数据质量。如图2所示，该过程包括如下所述的两个阶段。 </p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221023165135058.png" alt="image-20221023165135058"></p>
<h3><span id="311-粗筛和预处理">3.1.1 粗筛和预处理</span></h3><p>首先用了个face landmark的检测（在300W-LP数据集上训练的MobileNet）来检测2D landmark；</p>
<p>然后，可以使用PnP算法利用模板3D面部模型上的2D地标和3D关键点之间的对应关系有效地计算每个帧的粗略头部姿势；</p>
<p>使用2D地标和粗略的头部姿势可以很容易地识别和筛选出具有极端无效姿势或闭眼张开嘴表情的帧。我们根据姿势将其余帧分类为组：前、左、右和上；</p>
<h3><span id="312-帧选择">3.1.2 帧选择</span></h3><p>对于每组，我们进一步根据两个标准选择一个帧：图像质量和刚性。为了测量帧的图像质量，我们计算拉普拉斯高斯（LoG）滤波器响应，并将方差用作运动模糊分数（分数越大的图像越清晰）。首先基于前面组中的运动模糊分数来选择前面帧。然后，我们利用深度数据计算其他组中的每个帧与正面之间的刚度。具体而言，使用深度数据将每个帧的检测到的2D地标从2D提升到3D。请注意，遮挡的界标会根据帧所属的组自动移除，例如，对于左侧组中的帧，面部右侧的界标将被移除。 </p>
<h2><span id="32-几何生成">3.2 几何生成</span></h2><h3><span id="321-初始模型定义">3.2.1 初始模型定义</span></h3><p>使用基于 PCA 的线性 3DMM 进行参数建模。 人脸模型的形状和反照率纹理表示为：</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025151737274.png" alt="image-20221025151737274"></p>
<p>其中 s¯ 是平均 3D 人脸形状模型的向量格式，𝑆 是形状身份基础，x𝑠ℎ𝑝 是要估计的相应身份参数向量，a¯ 是平均反照率图的向量格式，𝐴 是反照率图基础颜色，x𝑎𝑙𝑏是要估计的相关反照率参数向量。</p>
<p>使用岭回归 ，可以通过将形状模型投影到每个输入图像上来提取部分纹理图。 使用从每个视图的地标派生的预定义蒙版（见图 3），然后使用拉普拉斯金字塔混合将部分纹理贴图混合成完整的纹理贴图。（<strong>unwarp操作</strong>） 初始反照率参数可以通过另一个岭回归来获得，以拟合混合纹理图。</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025153015905.png" alt="image-20221025153015905"></p>
<h3><span id="322-优化框架">3.2.2 优化框架</span></h3><p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025153218398.png" alt="image-20221025153218398"></p>
<p>优化框架： 要解决的参数包括：用户的 3DMM 参数 x𝑠ℎ𝑝 和 x𝑎𝑙𝑏，每个视图的照明参数 x𝑙𝑖𝑔ℎ𝑡 和姿势 x𝑝𝑜𝑠𝑒。 约束包括：关键点损失𝐿𝑙𝑎𝑛、RGB 照片损失𝐿𝑟𝑔𝑏、深度损失𝐿𝑑𝑒𝑝和身份感知损失𝐿𝑖𝑑。</p>
<p>优化目标：<img src="/2022/10/17/review_11_Hifi3dFace/image-20221025155915049.png" alt="image-20221025155915049"></p>
<p>对于每个用户的两个3DMM系数是不同的，而光照系数和姿态系数对每个用户都通用。</p>
<p>目标Loss：</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025160858227.png" alt="image-20221025160858227"></p>
<p>具体Loss：</p>
<p><strong>RGB Photo Loss</strong>：L2，输入的RGB图像和渲染的RGB图像做L2</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025160959267.png" alt="image-20221025160959267"></p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025161500643.png" alt="image-20221025161500643"></p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025161600812.png" alt="image-20221025161600812"></p>
<p>（下图是真实RGB，上图是mesh和贴图在原图上做渲染后的图像）</p>
<p><strong>Depth Loss</strong>：L2，ρ是个截断函数，用来限定L2的范围；</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025162833565.png" alt="image-20221025162833565"></p>
<p><strong>Identity Perceptual Loss</strong>：L2，过VGGFace的fc7后的特征做感知loss；</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025163251941.png" alt="image-20221025163251941"></p>
<p><strong>Landmark Loss</strong>：每个lankmark做L2（不同位置权重不一样）</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221025163440791.png" alt="image-20221025163440791"></p>
<p>Regularization：为了确保重建的合理性，对形状和纹理参数应用正则化</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221026111116994.png" alt="image-20221026111116994"></p>
<h3><span id="323-可形变模型的增强扩充3d数据的方法">3.2.3 可形变模型的增强（扩充3D数据的方法）</span></h3><p>优化中的约束十分丰富（loss很多），如果使用传统的线性3DMM的表达能力十分有限，为此提出了一种增强方法。</p>
<p>motivation：人脸大多不对称，会在对齐人脸模型时造成歧义， 原因是在两个模型的对齐过程中，它们之间的相对旋转和平移是通过最小化模型上某些参考点的误差来确定的。 不同的参考点可能导致不同的对齐结果。 由于人脸的不对称结构，没有完美的参考点。</p>
<p>这提醒我们可以扰乱两个对齐模型之间的相对姿势以获得“代替”的对齐。通过这种方式既可以获得额外的PCA样本，因为新的对齐方式引入了新的变形目标。此外，我们可以使用一组扰动操作，包括姿态扰动、镜像、区域替换等，来增强对齐的模型。 基于生成的大量数据，我们提出了一种随机迭代算法来构建一个 3DMM，将更多的容量压缩到基的更低维度。</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221026151445577.png" alt="image-20221026151445577"></p>
<p><strong>数据生成和扰动具体增强步骤</strong>（从200个对齐后的面部模型开始）</p>
<p>从 200 个对齐的面部形状模型开始，我们的数据生成和扰动过程包括以下步骤： </p>
<p>1.使用扰动进行区域替换</p>
<p>我们首先用其他模型替换每个模型的鼻子区域，沿俯仰角旋转扰动（在±1度内均匀采样）。 嘴部区域也以相同的方式处理。对于眼睛区域，我们在没有扰动的情况下应用替换。通过在处理过程中最小化引入的视觉缺陷来根据经验设计不同的扰动。 <strong>此步骤中使用的面部区域如图 5 所示</strong></p>
<p>2.刚性变换扰动。 </p>
<p>然后，我们对每个人脸模型应用刚性变换扰动，其中统一采样范围设置为：沿yam&#x2F;pitch&#x2F;roll的 ±1 度用于旋转，沿三个轴中的每一个轴的 ±1% 用于平移 , ±1% 刻度。</p>
<p>3.镜像。 </p>
<p>最后，我们沿模型局部坐标系对所有生成的人脸模型应用镜像。 通过这种方式，我们总共得到了超过 100,000 个人脸模型。</p>
<p>最后效果表示，拥有大量数据生成和增强所训练出的模型不出意外有更强大的表达能力，拟合得更好。</p>
<p>迭代增强3DMM构造算法流程：</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221026155015588.png" alt="image-20221026155015588"></p>
<h2><span id="33-贴图生成">3.3 贴图生成</span></h2><p><strong>这一部分参考博客里讲得很好，建议先看参考博客</strong></p>
<p>提出了一种合成高分辨率反照率和法线贴图的混合方法。</p>
<p>我们注意到基于超分辨率的方法无法产生高质量的眉毛细节。 另一方面，直接合成高分辨率纹理图可能会导致压倒性的细节，这也使得渲染不真实。 我们的方法在基于金字塔的参数表示的帮助下解决了这些问题。 图 9 显示了我们方法的流程。</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221026163814008.png" alt="image-20221026163814008"></p>
<p>第一步提取纹理（extract）</p>
<p>第二步通过光照参数调整纹理亮度（delight）</p>
<p>第三步将3D人脸展开到2D贴图（unwrap），512*512</p>
<p>unwrap详情见代码，最终效果就是blender里面的展UV</p>
<p>第四步使用<strong>区域拟合方法</strong>获得2048*2048的反射率贴图和法线贴图（regional fitting）</p>
<p>第五步通过CNN（具体模型为<strong>pix2pix</strong>）对两个贴图进行细化（refinement）</p>
<h3><span id="331-基于区域金字塔的参数表示构造详解regional-pyramid-bases">3.3.1 基于区域金字塔的参数表示构造详解（Regional Pyramid bases）</span></h3><p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221026214551913.png" alt="image-20221026214551913"></p>
<p>1.先将unwrap后的贴图resize成512和2048大小的图像，最终要得到上图左边的素材；</p>
<p>2.使用Mask将脸部分为8个区域，具体规则如下表示</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221027111816307.png" alt="image-20221027111816307"></p>
<p>3.每个样本有三种贴图（512-a，2048-a，2048-g），构成如下三元组</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221027150644329.png" alt="image-20221027150644329"></p>
<p>4.concat到一维，计算PCA，得到主成分</p>
<p>5.将得到的主成分根据索引，scatter back回图像</p>
<p>scatter back的操作是tensorflow的scatter_nd()函数实现的。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">scatter_nd(indices,updates,shape,name=None)</span><br></pre></td></tr></table></figure>

<p>根据indices将updates散布到新的（初始为零）张量。</p>
<h3><span id="332-区域拟合regional-fitting">3.3.2 区域拟合（Regional Fitting）</span></h3><p>由于构造了regional pyramid base，不同区域的不同类型皮肤&#x2F;头发细节可以通过高分辨率基分别保存，而低分辨率的拟合过程使算法专注于主要的面部结构，例如，形状眉毛和嘴唇。（<strong>多尺度</strong>）</p>
<p>区域拟合分为两部分：<strong>参数拟合和高分辨率贴图合成</strong></p>
<p><strong>参数拟合</strong></p>
<p><strong>参数拟合部分，就是将生成头模的时候生成的粗略化的Xalb，通过最小化loss，迭代训练得到较优的Xalb。</strong></p>
<p>参数拟合部分只使用了512的贴图</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221027153638981.png" alt="image-20221027153638981"></p>
<p>变量解释：</p>
<p><strong>Loss 1</strong></p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221027155829303.png" alt="image-20221027155829303">为unwrap后的图像；</p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221027155908838.png" alt="image-20221027155908838">表示将生成头模过程中生成的粗略的颜色贴图参数，与region pyramid bases逐区域相乘拟合再叠加成一张总的颜色贴图；</p>
<p>然后计算这两张图像之间的L2，记作loss1；</p>
<p><strong>Loss 2</strong></p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221027160544519.png" alt="image-20221027160544519"></p>
<p>主要消除8个区域边界中的伪影。做法是：通过uv_mask将整个颜色贴图分割成边界mask和非边界mask，然后分别计算颜色贴图中的边界距离和非边界距离,将这两种距离相加。记做loss2；</p>
<p><strong>Loss 3</strong></p>
<p>对于<img src="/2022/10/17/review_11_Hifi3dFace/image-20221027160823904.png" alt="image-20221027160823904">这个颜色贴图参数做L2正则，记作loss3；</p>
<p>三个Loss相加 使其最小化，迭代更新颜色贴图参数Xalb，直到得到训练好的Xalb。</p>
<p><strong>高分辨率贴图生成</strong></p>
<p><img src="/2022/10/17/review_11_Hifi3dFace/image-20221027161429672.png" alt="image-20221027161429672"></p>
<p>将上部分得到的较优的Xalb，分别与区域金字塔生成的A2048（2048* 2048分辨率的颜色贴图基）逐区域相乘拟合再叠加成一张总的颜色贴图，这便是区域拟合部分得到的最终的颜色贴图。<br>将上部分得到的较优的Xalb，分别与区域金字塔生成的G2048（2048* 2048分辨率的法线贴图基）逐区域相乘拟合再叠加成一张总的法线贴图，这便是区域拟合部分得到的最终的法线贴图。</p>
<p><strong>细节生成</strong></p>
<p>基于pix2pix模型，进出模型的分辨率是相同的，但细节上会细化；</p>
<p>在训练过程中，首先使用面部区域替换和肤色转移将200幅高质量反照率&#x2F;法线图（来自构建3DMM的数据集）放大为4000幅图，作为训练两个网络的GT。</p>
<p>然后，对4000幅图执行区域拟合（Regional Fitting），以获得拟合的反照率&#x2F;法线地图，这些图在训练期间用作网络的输入。只使用整个UV贴图中的面部区域来计算训练损失。</p>
<p>类似于pix2pix，保持𝐿1损耗和GAN损耗。对于反照率细化，我们还应用总变化损失（total variation loss）来减少伪影并改善皮肤平滑度。对于法线图细化，还使用预测和GT图之间的逐像素余弦距离，以提高正常方向的精度。使用Adam优化器对网络进行75000次迭代。</p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3DMM</tag>
      </tags>
  </entry>
  <entry>
    <title>《REALY:Rethinking the Evaluation of 3D Face Reconstruction》</title>
    <url>/2023/06/01/review_12_REALY/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E8%B4%A1%E7%8C%AE">1. 贡献</a></li>
<li><a href="#2-%E5%8A%A8%E6%9C%BA">2. 动机</a></li>
<li><a href="#3-%E7%AE%80%E4%BB%8B">3. 简介</a></li>
<li><a href="#4-%E9%A2%84%E5%A4%87%E7%9F%A5%E8%AF%86">4. 预备知识</a><ul>
<li><a href="#%E7%AC%A6%E5%8F%B7%E5%AE%9A%E4%B9%89"><strong>符号定义</strong></a></li>
<li><a href="#3dmm%E8%A1%A5%E5%85%85">3DMM补充</a></li>
<li><a href="#%E4%B8%80%E4%BA%9B%E6%A0%87%E5%87%86%E7%9A%84evaluation-pipeline">一些标准的evaluation pipeline</a></li>
<li><a href="#motivation">motivation</a></li>
</ul>
</li>
<li><a href="#5-realya-new-3d-face-benchmark">5. REALY：A New 3D Face Benchmark</a><ul>
<li><a href="#%E9%80%89%E6%8B%A9hifi3d%E5%9F%BA%E5%BA%95%E4%BD%9C%E4%B8%BA%E7%9B%AE%E6%A0%87%E6%8B%93%E6%89%91%E7%9A%84%E5%8E%9F%E5%9B%A0">选择HIFI3D基底作为目标拓扑的原因</a></li>
<li><a href="#%E6%95%B0%E6%8D%AE%E9%9B%86%E6%9E%84%E5%BB%BA%E6%AD%A5%E9%AA%A4">数据集构建步骤</a></li>
<li><a href="#%E6%8C%91%E6%88%98%E4%B8%8E%E8%A7%A3%E5%86%B3%E6%96%B9%E6%A1%88">挑战与解决方案</a><ul>
<li><a href="#%E6%8C%91%E6%88%98%E4%B8%80%E5%8E%9F%E5%A7%8B%E6%89%AB%E6%8F%8F%E5%85%B7%E6%9C%89%E4%B8%8D%E5%90%8C%E7%9A%84%E6%AF%94%E4%BE%8B%E5%92%8C%E5%A7%BF%E5%8A%BF%E5%85%B7%E6%9C%89%E4%B8%8D%E5%87%86%E7%A1%AE%E7%9A%84%E7%A8%80%E7%96%8Fkeypoints%E8%BF%99%E4%BD%BF%E5%BE%97%E5%AE%83%E4%BB%AC%E9%9A%BE%E4%BB%A5%E4%B8%80%E8%87%B4%E5%9C%B0%E5%AF%B9%E9%BD%90">挑战一：原始扫描具有不同的比例和姿势，具有不准确的稀疏keypoints，这使得它们难以一致地对齐。</a></li>
<li><a href="#%E6%8C%91%E6%88%98%E4%BA%8C%E5%BE%97%E5%88%B0%E9%87%8D%E6%96%B0%E6%8B%93%E6%89%91%E7%9A%84-sl-%E4%B9%8B%E5%90%8E%E5%A6%82%E4%BD%95%E5%87%86%E7%A1%AE%E5%9C%B0%E5%B0%86region-masks%E4%BB%8E-sl%E7%BB%A7%E6%89%BF%E8%87%AA-stemp%E8%BD%AC%E7%A7%BB%E5%88%B0sh">挑战二：得到重新拓扑的 SL 之后，如何准确地将region masks从 SL（继承自 Stemp）转移到SH</a></li>
</ul>
</li>
<li><a href="#hifi3d">HIFI3D++</a></li>
</ul>
</li>
<li><a href="#6-%E5%88%9B%E6%96%B0%E7%9A%84evaluation-pipeline">6 创新的Evaluation pipeline</a></li>
<li><a href="#7-%E5%AE%9E%E9%AA%8C">7. 实验</a><ul>
<li><a href="#%E6%B6%88%E8%9E%8D%E5%AE%9E%E9%AA%8Cbicp-vs-gicp">消融实验：bICP VS gICP</a></li>
<li><a href="#%E4%B8%8D%E5%90%8C%E6%96%B9%E6%B3%95%E5%9C%A8realy-benchmark%E4%B8%8A%E7%9A%84%E8%A1%A8%E7%8E%B0">不同方法在REALY benchmark上的表现</a></li>
<li><a href="#%E4%B8%8D%E5%90%8C3dmm%E5%9C%A8realy%E4%B8%8A%E7%9A%84%E8%A1%A8%E7%8E%B0">不同3DMM在REALY上的表现</a></li>
</ul>
</li>
<li><a href="#8-%E6%80%BB%E7%BB%93">8. 总结</a></li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://realy3dface.com/">REALY (realy3dface.com)</a></p>
<p>code: <a href="https://github.com/tencent-ailab/hifi3dface"><a href="https://github.com/czh-98/REALY">czh-98&#x2F;REALY: REALY: Rethinking the Evaluation of 3D Face Reconstruction (ECCV 2022) (github.com)</a></a></p>
<p>ref link:<a href="https://blog.csdn.net/jiafeier_555/article/details/125428388">https://blog.csdn.net/jiafeier_555/article/details/125428388</a></p>
<span id="more"></span>

<h1><span id="1-贡献">1. 贡献</span></h1><p>提出一个3D face reconstruction的benchmark REALY（Region-aware benchmark based on the LYHM Benchmark）</p>
<p>REALY，HIFI3D++（3DMM），本文的新evaluation pipeline以开源。</p>
<h1><span id="2-动机">2. 动机</span></h1><p>人脸重建任务中，不同的数据集，会制约重建方法、评估方法、3DMM基底的发展。</p>
<p>现有的开源 3D 人脸数据集存在一些不可忽视的缺陷。 例如，面部扫描具有不同的比例和随机姿势，并且提供的关键点不够准确或辨别力不够，这使得将输入形状与预测面部对齐以进行评估变得极其困难。 此外，由于原始面部扫描中缺乏真实标注，标准评估管道依赖于最近邻对应来衡量扫描与估计面部形状之间的相似性，这完全忽略了实体特征并丢弃了人体的几何形状面孔。</p>
<h1><span id="3-简介">3. 简介</span></h1><p>为了填补这一空白，提出了一个名为 REALY 的新基准，用于评估 3D 人脸重建方法。  REALY 包含来自 <strong>LYHM 数据集</strong>的 100 个人的 3D 人脸扫描，其中人脸扫描被一致地<strong>重新缩放、全局对齐，并展开成拓扑结构一致的mesh</strong>。 更重要的是，由于本文已经<strong>预定义了重新拓扑网格模板的面部关键点keypoints和掩码masks</strong>，因此<strong>可以将keypoints和masks转移到原始面部扫描结构</strong>中。 在这种情况下，本文即获得了原始原始面部扫描的高质量面部关键点和蒙版，这使我们能够对估计的 3D 面部形状执行更准确的对齐和细粒度的区域评估。</p>
<p>我们的基准包含来自不同种族、年龄和性别群体的个体。 利用为 REALY 构建的<strong>重新拓扑步骤（已开源）</strong>，我们通过对齐和重新拓扑多个 3D 人脸数据集，进一步提供了一个名为 HIFI3D++ 的 3DMM 基底。 我们进行了广泛的实验来评估最先进的 3D 人脸重建方法和 3DMM 基底。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601193651526.png" alt="image-20230601193651526"></p>
<h1><span id="4-预备知识">4. 预备知识</span></h1><h2><span id="符号定义"><strong>符号定义</strong></span></h2><p><img src="/2023/06/01/review_12_REALY/image-20230601201029200.png" alt="image-20230601201029200"></p>
<p>三个特殊的face shape，以及在不同face shape上的keypoints和regions</p>
<p><img src="/review_12_REALY/image-20230601201913382.png" alt="image-20230601201913382"></p>
<p><img src="/review_12_REALY/image-20230601201923089.png" alt="image-20230601201923089"></p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601202527762.png" alt="image-20230601202527762"></p>
<p><strong>NMSE用于度量两个surfaces之间的距离</strong></p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601202606377.png" alt="image-20230601202606377"></p>
<p><strong>ICP可用于通过迭代求解刚性变换和最近邻映射来对齐两个shape，以最小化NMSE</strong></p>
<h2><span id="3dmm补充">3DMM补充</span></h2><p>一些开源的3DMM数据：</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601202856040.png" alt="image-20230601202856040"></p>
<h2><span id="一些标准的evaluation-pipeline">一些标准的evaluation pipeline</span></h2><p>一些数据集还提供ground truth scan数据</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601203122686.png" alt="image-20230601203122686"></p>
<h2><span id="motivation">motivation</span></h2><h4><span id="传统standard-evaluation-pipeline的缺陷">传统standard evaluation pipeline的缺陷</span></h4><p><img src="/2023/06/01/review_12_REALY/image-20230601204718654.png" alt="image-20230601204718654"></p>
<p>如上图，使用standard evalution pipeline，高分辨的shape和gt shape的差异反而要比低分辨率的shape的高。所以<strong>考虑regions的对齐</strong>比较合理。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601210609441.png" alt="image-20230601210609441"></p>
<p>如上图，x对应的最近邻点是y1，而根据语义x应该与语义y2计算NMSE。</p>
<p><strong>结论</strong></p>
<p><strong>需要考虑基于region和双向对齐</strong></p>
<p>&#x3D;》提出真实语义区域的region masks的shape进行度量&#x3D;》现存数据集都未设定这样的规则&#x3D;》本文方法</p>
<h1><span id="5-realya-new-3d-face-benchmark">5. REALY：A New 3D Face Benchmark</span></h1><p>100个个体</p>
<p>每个个体包含高分辨率shape（来自LYHN的aligned 3D scan）和低分辨率shape（使用HIFI3D基底拓扑进行重新拓扑化）</p>
<p>所有shape始终等比例缩放对齐，</p>
<p>同时每个shape都有68个keypoints和4个region masks</p>
<p>对于每个个体，使用精心设计的照明条件和gt相机参数渲染出5张高质量的多视图图像（包括1张正面图像）</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601212010004.png" alt="image-20230601212010004"></p>
<h2><span id="选择hifi3d基底作为目标拓扑的原因">选择HIFI3D基底作为目标拓扑的原因</span></h2><p>LYHM 在眼睛和嘴巴的边界处有过密的采样；</p>
<p>LSFM 没有边缘循环来定义眼睛和嘴巴的轮廓；</p>
<p>FLAME的三角剖分不自然，无法模拟一些逼真的肌肉动作，比如抬眉毛。 作为比较，HIFI3D 具有更好的三角剖分和平衡采样，可以做出逼真和细腻的表达。 </p>
<p>此外，HIFI3D还有眼球、嘴巴内部结构、肩部区域等，这些都将有利于下游应用。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601220745894.png" alt="image-20230601220745894"></p>
<h2><span id="数据集构建步骤">数据集构建步骤</span></h2><p>第一，从 LYHM 收集 1235 个scans数据，并在 HIFI3D 拓扑中准备<strong>模板形状 Stemp</strong>，其中<strong>预定义了 68 个关键点 Ktemp 和 4 个区域掩码 Rtemp</strong>（包括鼻子、嘴巴、前额和脸颊区域）。</p>
<p>第二，将输入扫描重新缩放并严格对齐到模板形状 Stemp，从而生成我们的真实高分辨率网格 SH（即<strong>对齐扫描</strong>）。 </p>
<p>第三，定义一个评估区域（有相关论文），该区域是一个以鼻尖为中心的圆盘。</p>
<p>第四，将 Stemp“包装”（即<strong>执行非刚性配准</strong>）到每个 SH 以获得重新拓扑化的 SL，使得 SL 具有与 Stemp 相同的拓扑但反映 SH 的形状。（<strong>高分配准低分</strong>） 请注意，我们有关键点 KL &#x3D; Ktemp 和区域 RL &#x3D; Rtemp，因为 <strong>SL 和 Stemp 共享相同的 HIFI3D 拓扑</strong></p>
<p>第五，将每个人的 KL 和 RL 从 SL 转移到 SH。（<strong>低分的region和mask转移到高分</strong>） 我们还设置了一个渲染管道，用于为带纹理的高分辨率网格 SH 合成多视图图像。 这种受控环境使REALY能够专注于反映不同方法的重建能力。<br>第六，过滤掉wrapping error（这里不理解）大于 0.2mm 的样本，并请具有 3 年建模经验的专家艺术家从所有处理过的扫描中选择 100 个具有最高模型质量的个体，跨越不同的性别、种族和年龄，以获得我们的真正的基准（<strong>最终人工筛选高质量模型</strong>）。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601220904606.png" alt="image-20230601220904606"></p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601212947987.png" alt="image-20230601212947987"></p>
<h2><span id="挑战与解决方案">挑战与解决方案</span></h2><h3><span id="挑战一原始扫描具有不同的比例和姿势具有不准确的稀疏keypoints这使得它们难以一致地对齐">挑战一：原始扫描具有不同的比例和姿势，具有不准确的稀疏keypoints，这使得它们难以一致地对齐。</span></h3><p>为了解决这个问题，我们迭代以下步骤直到收敛：</p>
<p>第一，渲染一张高分shape的前脸、带纹理的图像（使用initial&#x2F;estimated transformation）来对齐SH到Stemp（注意正面姿势需要alignment transformation，因为对于给定的scan数据，正面姿势是未知的需要进行统一对齐）；</p>
<p>第二，使用sota的landmark detector来检测这张渲染图像的2D 面部keypoints；</p>
<p>第三，使用渲染相机视角将 2D 关键点投影到 3D； </p>
<p>第四，使用 SH 上的投影 3D 关键点与 Stemp 上已知的 3D 关键点之间的对应关系，更新从 SH 到 Stemp 的对齐变换。</p>
<h3><span id="挑战二得到重新拓扑的-sl-之后如何准确地将region-masks从-sl继承自-stemp转移到sh">挑战二：得到重新拓扑的 SL 之后，如何准确地将region masks从 SL（继承自 Stemp）转移到SH</span></h3><p> 一种天真的解决方案是使用从 SL 到 SH 的最近邻映射来传输区域掩码。 然而，由于 SH 的分辨率可以比 SL 的分辨率大 50 倍，这种天真的解决方案将引入断开连接和嘈杂的区域掩码。 为避免此类缺陷，我们从两个方向使用顶点到点映射来查找 SH 上的候选区域。<br>由于在从 SH 到 SL 的映射过程中可以建立更多的对应关系，因此可以获得更高质量、更平滑的区域掩码。 最后，我们过滤掉噪声区域（例如，鼻孔、眼球）并返回最大的连接区域。</p>
<h2><span id="hifi3d">HIFI3D++</span></h2><p>通过以上过程，我们可以通过对更多的3D人脸模型进行重新拓扑来进一步构建新的3DMM基底。</p>
<p>具体来说，基于来自 HIFI3D 的 200 个个体，我们另外处理和重新拓扑来自 FaceScape 数据集的 846 个个体的 3D 人脸模型到 HIFI3D 拓扑中。 连同上述来自 LYHM 的 1235 个个体的处理模型，我们收集并选择了 1957 个最具代表性的mesh数据。 </p>
<p>然后，我们应用 PCA 获得我们的新基底，包含 526 个 PC（具有 99.9% 的累积解释方差），我们将其命名为 HIFI3D++。</p>
<p>下图显示了 HIFI3D++ 与其他 3DMM 的比较。 请注意，以前的 3DMM 或多或少存在种族偏见。 例如，BFM  主要由欧洲人构建，FLAME 由美国和欧洲的扫描构建，而 HIFI3D 和 FS 由亚洲人的扫描构建。<br>LSFM 和 FLAME 分别包含 50 : 1 和 12 : 1 的白种人和亚洲人。 相比之下，HIFI3D++ 由跨越更平衡的种族群体的高质量模型构建，确保白种人和亚洲人（加上来自其他种族的一些受试者）之间的比例为 1：1。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601222014228.png" alt="image-20230601222014228"></p>
<h1><span id="6-创新的evaluation-pipeline">6 创新的Evaluation pipeline</span></h1><p><strong>本文提出的pipeline就是采用rICP+bICP取代standard pipeline的直接gICP</strong></p>
<p>在REALY的基础上，我们提出一个新的评价流程避免先前评价流程的问题，具体而言，我们的评价流程包含如下两个步骤：</p>
<p><strong>（该两步分别对应上文的motivation）</strong></p>
<p><strong>第一，局部区域的对齐 region-aware ICP（对齐region）</strong></p>
<p>考虑到不同区域的重建质量会影响全局的对齐结果，由于我们的benchmark得到了不同脸部区域的mask，因此我们可以借助这个信息将predicted mesh对齐到ground-truth scan的特定区域，在error计算时只计算ground-truth scan上的特定区域与predicted mesh之间的误差，而不考虑脸部其他区域对于对齐结果以及误差计算的影响。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601223856306.png" alt="image-20230601223856306"></p>
<p><strong>第二，对应关系的建立 non-rigid and bidirectional ICP（构建点对）</strong></p>
<p>在局部对齐的基础上，我们需要建立ground-truth scan某一区域上的每一个点与predicted mesh之间的对应点并计算两者的误差。考虑到先前基于最近点的方式存在的问题，我们提出一个新的对应关系的建立方法，提高了关键点语义信息的一致性。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601223904991.png" alt="image-20230601223904991"></p>
<p>具体而言，我们<strong>首先通过最近点建立初步的对应关系（region-aware ICP）</strong>；随后<strong>借助non-rigid ICP将ground-truth scan某一区域变形到predicted mesh</strong>上，由于变形后的区域与predicted mesh已经贴合，因为在变形过程中考虑了具备语义信息的关键点损失，所以这时的对应关系相比于原始的最近点的对应关系具有更好的语义关系的一致性（如，图3中脸部关键点的一致性），从而我们<strong>对初始的对应关系进行更新</strong>；最后，由于变形前后的拓扑形状的一致性，我们能够<strong>借助更新后的对应关系计算原始的ground-truth scan区域与局部对齐的mesh之间的最终误差</strong>。</p>
<p><strong>下图为三种ICP后gt和predicted的关联度</strong></p>
<p><img src="/2023/06/01/review_12_REALY/image-20230601223102196.png" alt="image-20230601223102196"></p>
<h1><span id="7-实验">7. 实验</span></h1><h2><span id="消融实验bicp-vs-gicp">消融实验：bICP VS gICP</span></h2><p><img src="/2023/06/01/review_12_REALY/image-20230604150316983.png" alt="image-20230604150316983"></p>
<p>从图4来看，全局的对齐策略由于局部区域的改变容易导致全局误差的变化，而我们的对齐策略则只聚焦于特定区域，其中对角线的error map表明误差较大的区域，而非对角线的error map的误差较小，对应没有发生变化的区域。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230604150534367.png" alt="image-20230604150534367"></p>
<p>从表2来看，我们的对齐结果通过ground-truth的对应点计算得到的误差与真实的误差更为接近，而全局的对齐策略则导致误差与真实误差不匹配。</p>
<p>从表3来看，我们的对应点计算策略带来的误差要显著小于全局对齐后最近点获得的对应点。实验结果表明，我们的评价流程不仅能够聚焦到脸部区域有差异的部分(图4和表2的对角线)，并且我们的对应关系建立更加准确(表3)。</p>
<h2><span id="不同方法在realy-benchmark上的表现">不同方法在REALY benchmark上的表现</span></h2><p>具体可见REALY官网列表</p>
<p>我们对比了先前的评价流程与我们提出的评价流程在REALY benchmark上的表现。对于先前的评价方法，我们从两个方向(即ground-truth scan的每个点与predicted mesh建立对应关系，以及predicted mesh每个点与ground-truth scan建立对应关系)作为对比，定量与定性的比较如表4和图5所示。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230604151228612.png" alt="image-20230604151228612"></p>
<p><img src="/2023/06/01/review_12_REALY/image-20230604151250890.png" alt="image-20230604151250890"></p>
<p>我们通过user study投票选出各组最好(*)&#x2F;次好(†)的人脸，通过比较不同评价流程选出的最好的人脸(橙、蓝、紫框)可以发现，我们的评价流程（橙框）选出的最好的人脸与user study的投票结果匹配程度更高。并且，我们的评价流程给出了细粒度的评测结果，即：对不同的人脸区域都能进行定量的评价和比较。</p>
<h2><span id="不同3dmm在realy上的表现">不同3DMM在REALY上的表现</span></h2><p>借助REALY benchmark，本文采用RGB(-D) Fitting的方式对不同3DMM的表达能力进行了评价，定量与定性的比较如表5和图8所示</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230604151640859.png" alt="image-20230604151640859"></p>
<p><img src="/2023/06/01/review_12_REALY/image-20230604151657772.png" alt="image-20230604151657772"></p>
<p>定量和定性的结果表明，我们的3DMM在REALY上取得了更优的重建效果，并且，通过不同方法的比较表明，RGB-D Fitting的结果要显著优于目前最好的重建算法，3D人脸重建任务仍有很大的提升空间。</p>
<p>为了进一步证明HIFI3D++的表达能力，我们只用顶点损失，根据最小二乘的方式拟合一组mesh，对HIFI3D&#x2F;HIFI3D(A)&#x2F;HIFI3D++进行比较，如图9所示。</p>
<p><img src="/2023/06/01/review_12_REALY/image-20230604151756157.png" alt="image-20230604151756157"></p>
<h1><span id="8-总结">8. 总结</span></h1><p>本文是我们对3D人脸重建评价的重新思考和探索。针对先前的评价指标无法准确衡量重建mesh与ground-truth相似性的问题，我们构建了一个新的数据集——REALY，包含更加丰富以及高质量的脸部区域信息，并借助新的评价流程对先前的数十个重建算法、3DMM进行了评价。</p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3D Face Reconstruction</tag>
      </tags>
  </entry>
  <entry>
    <title>《Towards Realistic Generative 3D Face Models》</title>
    <url>/2023/06/07/review_13_AlbedoGAN/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E8%B4%A1%E7%8C%AE">1. 贡献</a></li>
</ul>
<!-- tocstop -->

<p>paper: [<a href="https://arxiv.org/abs/2304.12483">2304.12483] Towards Realistic Generative 3D Face Models (arxiv.org)</a></p>
<p>code: <a href="https://github.com/aashishrai3799/Towards-Realistic-Generative-3D-Face-Models/">aashishrai3799&#x2F;Towards-Realistic-Generative-3D-Face-Models: 3D face model that can generate high-quality mesh and texture (github.com)</a></p>
<span id="more"></span>

<h1><span id="1-贡献">1. 贡献</span></h1>]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3D Face Reconstruction</tag>
      </tags>
  </entry>
  <entry>
    <title>《FFHQ-UV:Normalized Facial UV-Texture Dataset for 3D Face Reconstruction》</title>
    <url>/2023/06/07/review_14_FFHQ-UV/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E8%B4%A1%E7%8C%AE">1. 贡献</a></li>
<li><a href="#2-ffhq-uv%E6%95%B0%E6%8D%AE%E9%9B%86%E5%88%9B%E5%BB%BA%E7%AE%A1%E9%81%93">2. FFHQ-UV数据集创建管道</a><ul>
<li><a href="#21-%E5%9F%BA%E4%BA%8Estylegan%E7%9A%84%E9%9D%A2%E9%83%A8%E5%9B%BE%E5%83%8F%E7%BC%96%E8%BE%91">2.1 基于StyleGAN的面部图像编辑</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: [<a href="https://arxiv.org/abs/2211.13874">2211.13874] FFHQ-UV: Normalized Facial UV-Texture Dataset for 3D Face Reconstruction (arxiv.org)</a></p>
<p>code: <a href="https://github.com/aashishrai3799/Towards-Realistic-Generative-3D-Face-Models/"><a href="https://github.com/csbhr/FFHQ-UV">csbhr&#x2F;FFHQ-UV: The official repository of our CVPR2023 paper “FFHQ-UV: Normalized Facial UV-Texture Dataset for 3D Face Reconstruction”. (github.com)</a></a></p>
<span id="more"></span>

<h1><span id="1-贡献">1. 贡献</span></h1><p>设计了一个从真实人脸图像生成高质量 UV 纹理图的全自动管道，涉及人脸编辑、UV 纹理的提取、矫正和补全；</p>
<p>基于 FFHQ，创建并开源了一个具有均匀光照、中立表情和干净面部区域的大规模 UV 纹理数据集 FFHQ-UV；</p>
<p>基于 FFHQ-UV，提出了一个 3D 人脸重建算法，在高保真度和高质量上超越现有方法。</p>
<h1><span id="2-ffhq-uv数据集创建管道">2. FFHQ-UV数据集创建管道</span></h1><p><img src="/2023/06/07/review_14_FFHQ-UV/image-20230608092241715.png" alt="image-20230608092241715"></p>
<p>分为三步：</p>
<p>1、基于StyleGAN的面部图像编辑</p>
<p>2、面部UV纹理提取</p>
<p>3、UV纹理校正和补全</p>
<h2><span id="21-基于stylegan的面部图像编辑">2.1 基于StyleGAN的面部图像编辑</span></h2><p>首先从单视图野外图像中提取出多视图、归一化后的人脸图像，由此产生的图像具有均匀的光照、中性的表情、无遮挡（眼镜头发等等）。</p>
<p><strong>具体来说，首先使用GAN inversion方法e4e获取W+潜在空间中的w参数，后使用人脸编辑方法 StyleFlow 和 InterFaceGAN 自动编辑 StyleGAN2 的 W+ 潜在空间中的图像属性</strong>。</p>
<p>GAN inversion可以将一张图像映射到一个GAN生成器的隐空间中，从而利用StyleGAN强大的能力对图片进行编辑。</p>
<p>源码阅读：</p>
<p>run_ffhq_uv_dataset.sh</p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3D Face Reconstruction</tag>
      </tags>
  </entry>
  <entry>
    <title>《Facial Geometric Detail Recovery via Implicit Representation》</title>
    <url>/2023/07/05/review_15_PBIDR/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E7%9B%AE%E6%A0%87">1、目标</a></li>
<li><a href="#2-%E8%B4%A1%E7%8C%AE">2、贡献</a></li>
<li><a href="#3-%E7%AE%80%E4%BB%8B">3、简介</a></li>
<li><a href="#4-%E7%9B%B8%E5%85%B3%E5%B7%A5%E4%BD%9C">4、相关工作</a></li>
<li><a href="#5-%E5%85%B7%E4%BD%93%E6%96%B9%E6%B3%95">5、具体方法</a><ul>
<li><a href="#51-%E9%81%AE%E6%8C%A1%E9%B2%81%E6%A3%92%E7%BA%B9%E7%90%86%E8%A1%A5%E5%85%A8">5.1 遮挡鲁棒纹理补全</a></li>
<li><a href="#52-%E7%BA%B9%E7%90%86%E5%BC%95%E5%AF%BC%E7%9A%84%E9%9D%A2%E9%83%A8%E5%87%A0%E4%BD%95%E7%BB%86%E8%8A%82%E6%81%A2%E5%A4%8D">5.2 纹理引导的面部几何细节恢复</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://arxiv.org/pdf/2203.09692v1.pdf">2203.09692v1.pdf (arxiv.org)</a></p>
<p>code: <a href="https://github.com/deepinsight/insightface/tree/master/reconstruction/PBIDR">insightface&#x2F;reconstruction&#x2F;PBIDR at master · deepinsight&#x2F;insightface · GitHub</a></p>
<span id="more"></span>

<h1><span id="1-目标">1、目标</span></h1><p>单图三维人脸重建</p>
<p>有限的低维3DMM统计模型会导致重建效果平滑，缺乏细节</p>
<p>直接预测三维模型结构的方法成本高昂，需要大量匹配的三维扫描数据</p>
<p>参数化的纹理空间表达力有限（一般都是较低维的）</p>
<p>输入的野外图像容易受遮挡和阴影等环境因素的影响</p>
<h1><span id="2-贡献">2、贡献</span></h1><p>设计了一种单张图像获取高保真纹理和几何形状的方法；</p>
<p>设计了遮挡鲁棒的面部纹理补全方法，仅使用预训练的StyleGAN-v2生成器；</p>
<p>设计了一种详细的形状优化方法，一种基于物理的深度网络，解耦出镜面法线以更好地恢复几何细节；</p>
<h1><span id="3-简介">3、简介</span></h1><p>提出一种<strong>人脸几何细节恢复方法</strong>，包括了<strong>纹理增强</strong>和<strong>几何增强</strong></p>
<p><strong>纹理增强部分</strong></p>
<p>首先人脸解析生成蒙版，后输入StyleGAN Encoder来修复被遮挡的图像，然后使用无遮挡的图像修复蒙版图像</p>
<p><strong>几何增强部分</strong></p>
<p>先使用完整面部纹理图像和3DMM得出的粗糙几何形状渲染出多视角的图像；输入这些渲染图像，后经过深度网络分离，漫反射法线（diffuse normal）和镜面法线（specular normal）</p>
<p><img src="/2023/07/05/review_15_PBIDR/image-20230705211531697.png" alt="image-20230705211531697"></p>
<h1><span id="4-相关工作">4、相关工作</span></h1><p><strong>纹理修复相关工作</strong></p>
<p>利用面部对称性训练image to image网络，需要匹配训练数据</p>
<p>将纹理修复视为补全问题，使用StyleGAN-v2修复遮挡部分，但存在外部遮挡时会失效</p>
<p><strong>几何增强相关工作</strong></p>
<p>基于优化——拟合3DMM获得粗略形状，后使用shape from shading生成细节——遮挡敏感</p>
<p>基于回归——拟合3DMM获得粗略形状，回归高分扫描数据；回归displacement map；回归bump map；利用多视图图像数据回归；利用light-stage数据来学习漫反射和镜面反射率；直接学习可动画化的displacement map；</p>
<p>无3DMM模型——直接重建密集网格或推断表面法线 image to mesh</p>
<p><strong>隐式表面重建</strong></p>
<p>SDF理论介绍：</p>
<p><a href="https://zhuanlan.zhihu.com/p/536530019">SDF(signed distance field)基础理论和计算 - 知乎 (zhihu.com)</a></p>
<p>SDF的本质就是存储每个点到图形的最近距离，即将模型划出一个表面，在模型表面外侧的点数值大于0，在模型表面内侧的点数值小于0。</p>
<h1><span id="5-具体方法">5、具体方法</span></h1><h2><span id="51-遮挡鲁棒纹理补全">5.1 遮挡鲁棒纹理补全</span></h2><p><strong>去除外部遮挡</strong></p>
<p>给定输入图像与通过现成人脸分割网络得到的人脸图像蒙版，和使用StyleGAN-v2对latent space采样进行复原</p>
<p><img src="/2023/07/05/review_15_PBIDR/image-20230706213722366.png" alt="image-20230706213722366"></p>
<p>遵循与OSTeC相同的方式来初始化潜在参数，这加速了收敛并帮助优化器避免局部极小值。 然后，使用学习率为 0.25 的 Adam优化器对潜在参数（方程 1）进行优化。 请注意，我们的过程（例如拼接、掩模预测）是全自动的，不需要针对不同图像进行参数调整。</p>
<p><strong>纹理补全</strong></p>
<p>这部分基本是基于OSTeC的工作上做的；与OSTeC所用的3DMM估计粗略形状；获取可视部分，再以不同的姿势重新渲染修复混合</p>
<p><strong>多视角面部的再渲染</strong></p>
<p>选择各种预设相机姿势下使用纹理图渲染网格结构，收集多视角的渲染图以便之后使用</p>
<h2><span id="52-纹理引导的面部几何细节恢复">5.2 纹理引导的面部几何细节恢复</span></h2><p>给定一连串渲染图和他们对应的几何结构，定义一个SDF和一个可微分渲染器PBIDR，使用PBIDR优化SDF，获得精确的镜面法线和隐式的面部表面，最后传回3DMM拓扑。</p>
<p><strong>SDF的形状表示</strong></p>
<p><img src="/2023/07/05/review_15_PBIDR/image-20230706221922642.png" alt="image-20230706221922642"></p>
<p>预测一个点到面的映射</p>
<p><strong>基于物理的隐式可微分渲染器PBIDR</strong></p>
<p>传统上，面部重建方法使用简单的 Lambertian 着色模型来渲染具有单个反照率纹理的面部网格。 相反，逼真的面部渲染需要额外的材质属性和昂贵的着色模型。  Blinn-Phong 着色模型分别对漫反射和镜面着色进行建模，并且可以以较低的计算成本近似人体皮肤渲染。 此外，分离漫反射法线和镜面法线还可以近似皮肤的漫反射次表面散射，它受镜面法线中存在的高频细节的影响较小。 相反，镜面法线代表一些细观表面细节的外观，例如细皱纹和皮肤毛孔，这些细节通常很难提取，但它们在渲染中的效果很显着。</p>
<p>将镜面法线近似为SDF的梯度，光滑的漫反射法线近似为再原始粗糙网格上进行重心采样获得的法线，这样只有SDF法线负责渲染图像的高频细节，从而指导SDF更准确地捕获它们。因此，可将该顶点的外观分解为：</p>
<p><img src="/2023/07/05/review_15_PBIDR/image-20230706223609630.png" alt="image-20230706223609630"></p>
<p><strong>形状细节优化</strong></p>
<p>定义了一个优化框架，并使用光度损失、掩蔽损失、eikonal 损失、配准损失和法线损失来训练 SDF MLP 结构。</p>
<p><img src="/2023/07/05/review_15_PBIDR/image-20230706223750017.png" alt="image-20230706223750017"></p>
<p><img src="/2023/07/05/review_15_PBIDR/image-20230706223802170.png" alt="image-20230706223802170"></p>
<p><strong>将细化的SDF转换到模板网格</strong></p>
<p>优化 Fθ 后，我们可以估计任意点的梯度和 SDF 值，并将它们“拉”到隐式曲面。 因此，我们计算粗 3D 网格中顶点的 SDF 值，然后近似其法线。 然后，我们保留原始网格面，并通过其法线和 SDF 值给每个顶点一个位移，得到细粒度网格 Gf 如下：</p>
<p><img src="/2023/07/05/review_15_PBIDR/image-20230706224023313.png" alt="image-20230706224023313"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3D Face Reconstruction</tag>
      </tags>
  </entry>
  <entry>
    <title>《Multiview Neural Surface Reconstruction by Disentangling Geometry and Appearance》</title>
    <url>/2023/07/07/review_16_IDR/</url>
    <content><![CDATA[<!-- toc -->



<!-- tocstop -->

<p>ref link: <a href="https://blog.csdn.net/pylittlebrat/article/details/127883937">(99条消息) IDR 学习笔记_multiview neural surface reconstruction by disenta_ACxz的博客-CSDN博客</a></p>
<span id="more"></span>





]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3D Face Reconstruction</tag>
      </tags>
  </entry>
  <entry>
    <title>《Sider:Singleimage neural optimization for facial geometric detail recovery》</title>
    <url>/2023/07/07/review_17_SIDER/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E7%9B%AE%E6%A0%87">1、目标</a></li>
<li><a href="#2-%E8%B4%A1%E7%8C%AE">2、贡献</a></li>
<li><a href="#3-%E6%96%B9%E6%B3%95">3、方法</a><ul>
<li><a href="#31-%E6%9E%B6%E6%9E%84">3.1 架构</a></li>
<li><a href="#32-%E5%AD%A6%E4%B9%A0%E7%B2%97%E7%B3%99%E5%87%A0%E4%BD%95%E7%BB%93%E6%9E%84">3.2 学习粗糙几何结构</a></li>
<li><a href="#33-%E6%81%A2%E5%A4%8D%E9%9D%A2%E9%83%A8%E5%87%A0%E4%BD%95%E7%BB%86%E8%8A%82">3.3 恢复面部几何细节</a></li>
</ul>
</li>
<li><a href="#4-%E5%AE%9E%E9%AA%8C">4、实验</a><ul>
<li><a href="#41-%E5%AE%9E%E6%96%BD%E7%BB%86%E8%8A%82">4.1 实施细节</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://arxiv.org/pdf/2108.05465.pdf">2108.05465.pdf (arxiv.org)</a></p>
<p>code: none</p>
<span id="more"></span>

<h1><span id="1-目标">1、目标</span></h1><p>单图人脸几何细节重建</p>
<p>结合3DMM和SDF的隐式几何表达用神经网络做优化</p>
<h1><span id="2-贡献">2、贡献</span></h1><p>提出了SIDER，一种无监督从单图重建人脸几何细节的方法；</p>
<p>提出了一种新颖的从粗到精的优化方案，该方案利用经典的3DMM模型表示作为先验来防止 SDF 的退化解决方案，并使用无监督的光度损失进行优化；</p>
<h1><span id="3-方法">3、方法</span></h1><p>给定单个图像，SIDER 旨在从中提取面部几何细节，例如皱纹和皮肤褶皱。<br>SIDER 使用两阶段神经优化方法来提取这些细节。 在第一阶段，我们先利用 FLAME 可变形模型 ，以学习面部的粗略几何形状，其表示为 SDF。<br>接下来，我们根据所提供图像 I 的光度损失来优化此 SDF，以学习面部几何细节。 下面我们详细阐述SIDER的运作和训练过程。</p>
<h2><span id="31-架构">3.1 架构</span></h2><p><img src="/2023/07/07/review_17_SIDER/image-20230708162612823.png" alt="image-20230708162612823"></p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710141317269.png" alt="image-20230710141317269"></p>
<p>几何网络预测两种数据：</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710143021110.png" alt="image-20230710143021110"></p>
<p>前者为对应一个点x上经过位置编码所预测的SDF值；后者为在x处预测的特征向量用于输入渲染网络。</p>
<p>渲染网络输入输出如下：</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710145857267.png" alt="image-20230710145857267"></p>
<p>输入经过编码后的x，x处的法线，经过编码后的视角，在几何网络种预测的x处的特征向量。</p>
<h2><span id="32-学习粗糙几何结构">3.2 学习粗糙几何结构</span></h2><p>基于FLAME（与全身的SMPL类似）</p>
<p><a href="https://aitechtogether.com/article/17540.html">3D人脸模型Flame —-《Learning a model of facial shape and expression from 4D scans》论文讲解及代码注释 | AI技术聚合 (aitechtogether.com)</a></p>
<p><a href="https://zhuanlan.zhihu.com/p/591136896">基于FLAME的三维人脸重建技术总结 - 知乎 (zhihu.com)</a></p>
<p>基于LBS（linear blend skinning）并结合blendshape（并非arkits规则）作为表示</p>
<p>给定一张图像I，FLAME使用standard landmark来拟合：</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710163331427.png" alt="image-20230710163331427"></p>
<p>前一个L是FLAME模型的第i个landmark的位置，后一个使用3DDFA预测得到的landmark作为GT值，优化的参数为FLAME模型的shape，exp，pose参数以及相机参数。训练一个MLP来进行拟合。</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710163941399.png" alt="image-20230710163941399"></p>
<p>其中P是FLAME模型<strong>附近空间中</strong>随机选取的一组点；x是此空间中一个点；φ 是位置编码；SDFGT (·) 是针对粗糙网格的SDF的GT值；由于 FLAME 网格是一个开放且单一的表面层，因此无法直接在其上定义 SDF（不存在距离为负的区域，因为没有“内部”）。 因此，为了定义SDF，将网格视为一个有“厚度”的体积物体。 这使我们能够将真实 SDF 定义如下：</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710164824672.png" alt="image-20230710164824672"></p>
<p>其中 Point2Mesh 是点到网格的距离函数，是一个表示网格厚度的小数字。</p>
<p>此外，几何网络使用 eikonal 损失进行正则化：</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710165139092.png" alt="image-20230710165139092"></p>
<h2><span id="33-恢复面部几何细节">3.3 恢复面部几何细节</span></h2><p>使用输入的原始图像I来fine-tune几何网络以恢复几何细节。</p>
<p>为渲染SDF，使用sphere-tracing结合渲染网络。光线从相机中心o射入场景，并使用球体追踪和隐式微分来估计这些光线与面部网格的交点，更通俗地说，使用渲染网络预测相交点的RGB值。</p>
<p>具体使用Multiview Neural Surface Reconstruction by Disentangling Geometry and Appearance这篇文章中的方法。</p>
<p>更通俗地说，考虑一条射线，r &#x3D; o + vt，其观察方向为 v，表面交点为 xˆ。xˆ 处的 RGB 颜色计算如下：</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710155252181.png" alt="image-20230710155252181"></p>
<p>就是上面的公式</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710155704886.png" alt="image-20230710155704886"></p>
<p>总体的几何细节生成loss</p>
<p><img src="/2023/07/07/review_17_SIDER/image-20230710155711482.png" alt="image-20230710155711482"></p>
<h1><span id="4-实验">4、实验</span></h1><h2><span id="41-实施细节">4.1 实施细节</span></h2><p><strong>数据集</strong></p>
<p>FFHQ    ALFW2000    NoW</p>
<p>resize到256</p>
<p><strong>几何网络</strong></p>
<p>8层全连接 一个残差连接（从input到第四层）与Multiview Neural Surface Reconstruction by Disentangling Geometry and Appearance文中结构相似</p>
<p><strong>渲染网络</strong></p>
<p>四层全连接，其输入被非线性映射以学习高频。两个MLP的每一层都包括512个隐藏单元。</p>
<p>首先对几何网络进行1000个epoch的训练，以学习粗略几何形状。然后，通过优化对其进行微调，并联合训练渲染网络约200-300个epoch。使用Adam优化器，学习率为10-4。</p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3D Face Reconstruction</tag>
      </tags>
  </entry>
  <entry>
    <title>《A Hierarchical Representation Network for Accurate and Detailed Face Reconstruction from In-The-Wild Images》</title>
    <url>/2023/07/12/review_18_HRN/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#1-%E7%9B%AE%E6%A0%87">1、目标</a></li>
<li><a href="#2-%E4%BB%8B%E7%BB%8D">2、介绍</a></li>
<li><a href="#3-%E6%96%B9%E6%B3%95">3、方法</a><ul>
<li><a href="#31-%E6%96%B9%E6%B3%95%E6%A6%82%E8%BF%B0">3.1 方法概述</a></li>
<li><a href="#32-%E5%88%86%E5%B1%82%E5%BB%BA%E6%A8%A1">3.2 分层建模</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: [<a href="https://arxiv.org/abs/2302.14434">2302.14434] A Hierarchical Representation Network for Accurate and Detailed Face Reconstruction from In-The-Wild Images (arxiv.org)</a></p>
<p>code: [youngLBW&#x2F;HRN: <a href="https://github.com/youngLBW/HRN">CVPR2023] A Hierarchical Representation Network for Accurate and Detailed Face Reconstruction from In-The-Wild Images. (github.com)</a></p>
<span id="more"></span>

<h1><span id="1-目标">1、目标</span></h1><p><img src="/review_18_HRN/image-20230712065221103.png" alt="image-20230712065221103"></p>
<p>在三个层面上解耦出不同的资产，以达到良好的重建效果</p>
<p>三个层面：3DMM粗网格结构；deformation map；displacement map</p>
<p>可拓展到muti view工况</p>
<p>介绍了阿里自己做的一个数据集（还未公开）</p>
<h1><span id="2-介绍">2、介绍</span></h1><p>现有的方法要么使用低维的3DMM实现低频细节，要么再考虑displacement map实现高频细节，往往忽略了中频细节。</p>
<p>本方法将人脸几何结构解耦为低中高三频细节，后针对这三者分别建模为face-wise blendshape coefficients、vertex-wise deformation map、pixel-wise displacement map。</p>
<p><strong>贡献</strong></p>
<p>1、分三层建模</p>
<p>2、GT创建流程，以及设计de-reouching模块</p>
<p>3、可拓展至muti-view重建</p>
<p>4、引入FaceHD-100数据集</p>
<h1><span id="3-方法">3、方法</span></h1><p><img src="/review_18_HRN/image-20230712070647960.png" alt="image-20230712070647960"></p>
<h2><span id="31-方法概述">3.1 方法概述</span></h2><p>我们首先使用3DMM来预测coarse mesh和albedo map（蓝色区域）。然后，我们开发了一种分层建模策略，以从粗到细的方式处理复杂的面部细节（绿色和紫色区域）。为了便于对层次细节进行准确和忠实的建模，结合3D先验进行对抗和半监督学习。<br>此外，我们提出了一个de-rectouching module，以实现几何结构和外观的更好解耦，缓解各种皮肤纹理和照明之间的模糊性。此外，我们将我们的框架扩展到多视图方式，并引入了高质量的3D人脸数据集，以促进稀疏视图人脸重建的研究。为了简化，我们在每一节中指定了相关的损失函数和训练策略。</p>
<h2><span id="32-分层建模">3.2 分层建模</span></h2><p>图1解释了模型在不同层次上所体现的细节变化。</p>
<p>低频部分，其提供与输入面大致对准的粗略形状；</p>
<p>中频细节，其描述相对于低频部分的轮廓和局部形状的细节；</p>
<p>高频细节，如褶皱、微凸起等。</p>
<p><strong>具体设计如下</strong></p>
<p>低频部分，选择BFM作为基础模型，并输出低维系数来实现粗略重建；</p>
<p>中频细节，三通道的deformation map，关联position map，在uv空间上可定位到三维结构上的某一顶点，在三通道上表示相对偏移；64x64x3；</p>
<p>高频细节，采用DECA中的displacement map，表示沿法线方向的几何变形，256x256x1；displacement map以像素方式转换为渲染过程中使用的详细法线，以显示所有微小的细节，打破了基础模型顶点密度的限制。因此，我们能够用这些表示来描述任意复杂的面。</p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3D Face Reconstruction</tag>
      </tags>
  </entry>
  <entry>
    <title>《Sparse Local Patch Transformer for Robust Face Alignment and Landmarks Inherent Relation Learning》</title>
    <url>/2022/03/25/review_1_Sparse%20Local%20Patch%20Transformer%20for%20Robust%20Face%20Alignment%20and%20Landmarks/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a></li>
</ul>
<!-- tocstop -->

<p>paper: [<a href="https://arxiv.org/abs/2203.06541">2203.06541] Sparse Local Patch Transformer for Robust Face Alignment and Landmarks Inherent Relation Learning (arxiv.org)</a></p>
<p>code: <a href="https://github.com/Jiahao-UTS/SLPT-master">Jiahao-UTS&#x2F;SLPT-master (github.com)</a></p>
<span id="more"></span>

<h1><span id="出发点">出发点</span></h1><p>landmark之间的内在联系对于人脸对齐的性能有很大影响，本文重点考虑其内在联系。</p>
<p>之前的方法有heatmap regression，Coordinate regression，有着不同方面的劣势。</p>
<h1><span id="创新点">创新点</span></h1><p>提出了SLPT（<em>sparse local patch transformer</em>）来学习<em>query-query</em>和<em>representation-query</em>关系（自适应内在关系）；为了进一步提高SLPT的性能，提出了一种从粗到精的框架，使局部补丁进化为<strong>金字塔形补丁</strong>。</p>
<h1><span id="做法">做法</span></h1><p>本文的SLPT并非同DETR从完整的feature map中预测坐标，而是首先从局部patch中生成每个landmark的表示特征。</p>
<p>然后，使用一系列可学习的queries（称为<em>landmark queries</em>）来聚合表示。</p>
<p>基于Transformer的交叉注意机制，SPLT在每一层学习一个<strong>自适应邻接矩阵</strong>。最后，通过MLP独立预测每个landmark在其对应patch中的subpixel坐标。由于使用了稀疏的局部补丁，与其他ViT相比，输入token的数量显著减少。 </p>
<p>为了进一步提高性能，引入了从粗到精的框架，以与SLPT结合。下图为所提出的从粗到精的框架利用稀疏的局部面片实现鲁棒的人脸对齐。根据前一阶段的landmarks裁剪稀疏的局部补丁，并将其输入到同一SLPT中以预测面部landmarks。此外，patch大小随着阶段的增加而缩小，以使局部特征演变成金字塔形式。</p>
<p><img src="/2022/03/25/review_1_Sparse%20Local%20Patch%20Transformer%20for%20Robust%20Face%20Alignment%20and%20Landmarks/1.png" alt="1"></p>
<p>整体框架图：</p>
<p><img src="/2022/03/25/review_1_Sparse%20Local%20Patch%20Transformer%20for%20Robust%20Face%20Alignment%20and%20Landmarks/2.png" alt="2"></p>
<p>分为三部分：</p>
<p><strong>the patch embedding &amp; structure encoding</strong></p>
<p>不同于ViT，SLPT先根据landmark裁剪patch，再通过线性插值将patch大小调整为K*K，又使用了结构编码（可学习的参数）来补充表示。每种编码都与相邻地标（如左眼和右眼）的编码有很高的相似性。</p>
<p>Muti-head Cross-attention（在Vision Transformer基础上的改进）：通过landmark在CNN提取出的feature map上划取局部patch，将这些feature map上的patch排成一个patch embedding，将其视为landmark的表示；紧接着对其进行结构编码（Structure Encodeing）,以获取人脸中的相对位置和patch embedding做concat。输入 landmarks queries ，通过这些MLP，独立预测每个landmark的位置。</p>
<p><strong>inherent relation layers</strong></p>
<p>受Transformer启发，每一层由三个块组成，即多头自注意（MSA）块、多头交叉注意（MCA）块和多层感知器（MLP）块，并且在每个块之前应用一个layer norm（LN）。 </p>
<p><strong>prediction heads</strong></p>
<p>预测头由一个用于规范化输入的分层模板和一个用于预测结果的MLP层组成。</p>
<p>最右边的图像显示了不同样本的自适应固有关系。其将每个点连接到第一个内在关系层中交叉注意权重最高的点显示。</p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>Patch-based Transformer</tag>
      </tags>
  </entry>
  <entry>
    <title>《Pose-guided Feature Disentangling for Occluded Person Re-identification Based on Transformer》</title>
    <url>/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a><ul>
<li><a href="#visual-context-transformer-encoder">Visual Context Transformer Encoder</a></li>
<li><a href="#pose-guided-feature-aggregation">Pose-guided Feature Aggregation</a></li>
<li><a href="#part-view-based-transformer-decoder">Part View Based Transformer Decoder</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content/CVPR2021/papers/Jing_Cross-Modal_Center_Loss_for_3D_Cross-Modal_Retrieval_CVPR_2021_paper.pdf">https://arxiv.org/pdf/2112.02466v2.pdf</a></p>
<p>code: <a href="https://github.com/WangTaoAs/PFD_Net">WangTaoAs&#x2F;PFD_Net: This is Official implementation for “Pose-guided Feature Disentangling for Occluded Person Re-Identification Based on Transformer” in AAAI2022 (github.com)</a></p>
<span id="more"></span>

<h1><span id="出发点">出发点</span></h1><p>存在遮挡的行人重识别（<em>Occluded Person Re-identification</em>），由于遮挡的存在，各种噪声被引入，导致特征不匹配；遮挡可能具有与人体部位相似的特征，导致特征学习失败。</p>
<p>前人的方法有：使用姿势信息指导特征空间将全局特征划分为局部特征（缺点是需要严格的特征空间对齐）；使用基于图的方法建模拓扑信息（缺点是容易陷入上述的第二种问题）。</p>
<h1><span id="创新点">创新点</span></h1><p>本文探索了在没有空间对齐的情况下，将附加姿势信息与Transformer相结合的可能性。其使用姿势信息对语义成分（如人体的关节部位）进行分解，并对非遮挡的部位进行选择性匹配；设计了一种<em>Pose-guided Push Loss</em>。</p>
<h1><span id="做法">做法</span></h1><p>整体框架图：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329103047158.png" alt="image-20220329103047158"></p>
<h2><span id="visual-context-transformer-encoder">Visual Context Transformer Encoder</span></h2><p>首先需要对输入图像划分为固定大小的N块patch，步距大小定义为S，每块patch的尺度定义为P，patch个数N为：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329103958451.png" alt="image-20220329103958451"></p>
<p>当S等于P时，划分出来的patch就不重叠；当S&lt;P时，patch重叠，可以减少空间领域信息的丢失。</p>
<p>将这些patch通过线形层生成一个序列输入transformer encoder，concat一组可训练的<em>Position Encoding</em>，以及<em>Camera Information Embedding</em>（表示该图像所属的摄像头视角信息，标签给定的，相同视角图像有一样的值），最终的输入序列定义为：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329104849953.png" alt="image-20220329104849953"></p>
<p>最后通过Transformer Encoder输出分为两部分的特征，一部分为global feature，一部分为part feature。为进一步区分人体各个部位的特征，part feature又分为K组，每一组都与global feature做cancat送入shared transformer layer学习这些K组融合特征。</p>
<p><strong>Encoder Supervision Loss</strong></p>
<p>选用交叉熵损失作为identity loss以及triplet loss来作为这部分的loss：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329110809342.png" alt="image-20220329110809342"></p>
<h2><span id="pose-guided-feature-aggregation">Pose-guided Feature Aggregation</span></h2><p>被遮挡的人体图像的身体信息较少，而非身体部位的信息可能不明确。本文使用<em>pose estimator</em> 从图像中提取landmark信息。</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329112105052.png" alt="image-20220329112105052"></p>
<p><strong>Pose Estimation</strong></p>
<p>给定一张图像，估计器从中提取M个landmark，然后利用这些landmark生成一组heatmap <strong>H</strong>，每张heatmap都被下采样到（H&#x2F;4）*（W&#x2F;4），其中最大的response point对应一个joint point，设置了一个阈值γ来滤除高置信度和低置信度的landmark。滤除出的剩余landmark的heatmap并不是将其设为0，而是赋值0&#x2F;1，热图标签可以形式化为：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329112535277.png" alt="image-20220329112535277"></p>
<p>ci定义为第i个landmark的置信度分数。</p>
<p><strong>Pose-guided Feature Aggregation</strong></p>
<p>将之前的分组数设为K&#x3D;M，使其等于landmark的数量。将生成的一组heatmap <strong>H</strong>后接一层FC，使其尺寸与group part local feature（fgp）相同，得到<strong>H‘</strong>。将<strong>H‘</strong>与<strong>fgp</strong> mutiply element-wisely（向量对应元素相乘，将heatmap的注意力附加在fgp上）获得<strong>P</strong>，其目的是为了从fgp中找到对身体某个部位贡献最大的信息部分。</p>
<p>为此，本文开发了一种匹配和分布机制，将part local feature和pose-guided feature视为一组相似性度量问题，最终获取一个pose-guided feature集合<strong>S</strong>。</p>
<p>对于每个<strong>Pi</strong>,在fgp中找到最相似的特征，即<strong>找寻融合了heatmap注意力的序列和原始局部特征的最近距离的局部特征</strong>，以选出优质的局部特征，用余弦距离，形式化定义为：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329115119956.png" alt="image-20220329115119956"></p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329115132888.png" alt="image-20220329115132888"></p>
<h2><span id="part-view-based-transformer-decoder">Part View Based Transformer Decoder</span></h2><p>将heatmap和fen做点乘送入Decoder学习一系列learnable semantic views以学习有区别的身体部分。其实整个框架的大体思路为一张图片走两路，一路分patch进transformer encoder，一路特征点检测生成heatmap走transformer decoder，再将这两部分的输出进行match，可以得到view feature，取高置信度的view feature采样成与fgb，fgp相同尺寸算triplet loss，再将所有的view feature采样做<em>Pose Guided Push Loss</em>。</p>
<p><strong>Pose-View Matching Module</strong></p>
<p>此部分计算patch view和通过Pose-guided Feature Aggregation得到的Set之间的相似度，来获得最终的view feature，用余弦距离，形式化定义为：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329151559098.png" alt="image-20220329151559098"></p>
<p>之前的heatmap通过阈值打好了0&#x2F;1标签，最终的view feature即可通过heatmap标签分为两类。在上述距离置信度较高的view feature中取heatmap label为1的；在置信度较低的view feature中取heatmap label为0的。这样的操作会产生可变长度，需要固定长度补0操作。</p>
<p><strong>Decoder Supervision Loss</strong></p>
<p>提出的Pose-guided Push Loss：</p>
<p>余弦距离：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329152506162.png" alt="image-20220329152506162"></p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329152517889.png" alt="image-20220329152517889"></p>
<p>整体的loss定义：</p>
<p><img src="/2022/03/30/review_2_Pose-guided%20Feature%20Disentangling%20for%20Occluded%20Person%20Re-identification%20Based%20on%20Transformer/image-20220329153030797.png" alt="image-20220329153030797"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>ReID</tag>
        <tag>Transformer</tag>
        <tag>Landmark</tag>
      </tags>
  </entry>
  <entry>
    <title>《DVG-Face:Dual Variational Generation for Heterogeneous Face Recognition》</title>
    <url>/2022/04/09/review_3_DVG-Face/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#%E4%B8%8E%E5%89%8D%E4%BD%9Cdvg%E7%9A%84%E4%B8%8D%E5%90%8C">与前作DVG的不同</a></li>
<li><a href="#%E5%89%8D%E5%A4%87%E7%9F%A5%E8%AF%86">前备知识</a></li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a><ul>
<li><a href="#dual-generation">Dual Generation</a><ul>
<li><a href="#training-with-paired-heterogeneous-data">Training with Paired Heterogeneous Data</a></li>
<li><a href="#training-with-unpaired-vis-data">Training with Unpaired VIS Data</a></li>
</ul>
</li>
<li><a href="#heterogeneous-face-recognition">Heterogeneous Face Recognition</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://arxiv.org/pdf/2009.09399.pdf">2009.09399.pdf (arxiv.org)</a></p>
<p>code: <a href="https://github.com/WangTaoAs/PFD_Net"><a href="https://github.com/BradyFU/DVG-Face">BradyFU&#x2F;DVG-Face: DVG-Face: Dual Variational Generation for Heterogeneous Face Recognition, TPAMI 2021 (github.com)</a></a></p>
<span id="more"></span>

<h1><span id="出发点">出发点</span></h1><p>为解决异构人脸识别（Heterogeneous Face Recognition）问题中成对异构数据匮乏的问题。</p>
<h1><span id="创新点">创新点</span></h1><p>将异构人脸识别视为一个双生成（dual generation）问题，<strong>从噪声中采样大规模的成对</strong>异构人脸数据；</p>
<p>将丰富的<strong>身份信息集成到联合分布</strong>中，以丰富生成数据的身份多样性。同时，对生成的成对图像施加一个保持成对身份的损失（<strong>pairwise identity preserving loss</strong>），以确保它们的身份一致性。这两个特性使得能够更好地利用生成的未标记数据来训练异构人脸识别网络；</p>
<p>通过将生成的成对图像视为正对，将从不同样本获取的图像视为负对，通过<strong>对比学习</strong>对异构人脸识别网络进行优化，以学习domain-invariant和区分性的embedding feature。</p>
<h1><span id="与前作dvg的不同">与前作DVG的不同</span></h1><p><strong>生成图像的身份更丰富：</strong></p>
<p>对于前作，生成器只能使用小规模的成对异构数据进行训练，从而限制生成图像的身份多样性。在当前版本中，重新设计了生成器的体系结构和训练方式，允许使用成对异构数据和<strong>大规模未配对VIS数据</strong>（单模态的非成对真实人脸数据）对其进行训练。后者的引入极大地丰富了生成图像的身份多样性。 </p>
<p><strong>生成的图像被更有效地利用：</strong></p>
<p>前作借助身份一致性属性，通过成对距离损失（pairwise distance loss）使用生成的成对数据对异构人脸识别网络进行训练。在此基础上，得益于上述身份多样性特性，当前版本进一步将从不同样本中获得的图像视为负对，形成了一种<strong>对比学习</strong>机制。 先前版本只能利用生成的图像来减少域差异，而当前版本则利用生成的图像来学习域不变和区分性嵌入特征（可学习）。 </p>
<p><strong>增加了更深入的分析和更多的实验：</strong></p>
<p>增加不同模态对图像的实验。</p>
<h1><span id="前备知识">前备知识</span></h1><p><strong>VAE</strong></p>
<p><a href="https://zhuanlan.zhihu.com/p/364917826">变分自编码器（VAE）原理 - 知乎 (zhihu.com)</a></p>
<h1><span id="做法">做法</span></h1><p><img src="/2022/04/09/review_3_DVG-Face/image-20220409140033446.png" alt="image-20220409140033446"></p>
<p>待解决问题：</p>
<p>（1）如何生成不同的配对异构数据</p>
<p>（2）如何有效利用这些生成的数据</p>
<h2><span id="dual-generation">Dual Generation</span></h2><p><strong>核心：结合域属性和身份特征</strong></p>
<p>通过一个双变分生成器实现。生成器包含两个特定域的encoder（图中的橙色和灰色Ev，En），一个decoder（浅蓝色G），一个预训练好的人脸识别网络（F）以及一个身份采样器（Fs）。</p>
<p>两个<em>Domain-specific attribute encoders</em>用于学习NIR和VIS数据的领域特定属性分布，人脸识别网络用于提取身份特征，身份采样器可以灵活地从噪声中采样丰富的身份表示（？）。成对异构数据的联合分布由身份表示和属性分布组成（具体的fusion文中并未指出，代码中是concat），decoder将联合分布映射到像素空间。</p>
<h3><span id="training-with-paired-heterogeneous-data">Training with Paired Heterogeneous Data</span></h3><p>输入成对同身份的异构图像，生成器学习潜在空间中的解耦联合分布。具体而言，采用在MS-Celeb-1M上预训练的人脸识别模型（本文采用的是LightCNN）作为特征提取器，由F提取出的特征被认为仅仅是identity related。考虑到F是从VIS模态预训练得到的，在另一个模态的表现不好，那么只需要提取VIS模态的身份特征作为两个模态共同的身份表示。</p>
<p>两个encoder提取出Domain-specific attribute分布，为确保其仅仅是属性相关的，在属性和身份表示之间施加了角度正交损失。最后解耦后的两种分布构成成对NIR-VIS数据的联合分布，然后被送到decoder作为输入。</p>
<p>该过程中涉及到了四个损失函数：包括角正交损失、分布学习损失、成对身份保持损失和对抗性损失。</p>
<p><strong>Angular Orthogonal Loss</strong></p>
<p>角正交损失施加在Zv和f，Zn和f之间，计算它们之间的余弦相似度，最小化他们的绝对值的和。</p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409153226995.png" alt="image-20220409153226995"></p>
<p><strong>Distribution Learning Loss</strong></p>
<p>分布学习损失启发自VAEs，首先用KL散度计算两个分布的差异，再结合L1正则化重构decoder的输入。</p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409162532051.png" alt="image-20220409162532051"></p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409162539110.png" alt="image-20220409162539110"></p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409162548220.png" alt="image-20220409162548220"></p>
<p><strong>Pairwise Identity Preserving Loss</strong></p>
<p>为了保留生成数据的身份，以前基于条件生成的方法通常采用身份保留损失。利用预训练好的人脸识别网络分别提取生成数据和真实目标数据的嵌入特征，然后迫使这两个特征尽可能接近。然而，由于既不存在类内约束，也不存在类间约束，因此很难保证生成的图像属于与目标一致的特定类。</p>
<p>本文关注生成的成对图像的身份一致性，而不是生成的图像属于谁。因此提出了一种成对的身份保持损失，以限制特征之间的距离</p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409172316619.png" alt="image-20220409172316619"></p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409172325881.png" alt="image-20220409172325881"></p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409172332593.png" alt="image-20220409172332593"></p>
<p><strong>Adversarial Loss</strong></p>
<p>引入对抗损失来提高生成图像的清晰度。</p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409184040111.png" alt="image-20220409184040111"></p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409184047202.png" alt="image-20220409184047202"></p>
<p><strong>Overall Loss</strong></p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409184118573.png" alt="image-20220409184118573"></p>
<h3><span id="training-with-unpaired-vis-data">Training with Unpaired VIS Data</span></h3><p>身份信息获取的一种简单的方法是使用预训练的人脸识别网络从大规模VIS数据中提取身份。然而，如果希望在测试阶段生成大规模的新配对数据，必须拥有相同数量的具有不同身份的VIS数据（如b图右下角）。</p>
<p>为避免此情况，引入了身份采样器（identity sampler）。具体实现为，首先采用识别网络提取MS-Celeb-1M数据集上的embedding特征，利用这些特征来训练VAE模型。训练后的VAE的decoder被用作身份采样器，它可以将标准高斯噪声中的点映射到身份表示。</p>
<p>由于这些采样的身份表示没有对应的ground true异构图像，本文建议以不成对的方式训练生成器。 </p>
<p><strong>整体流程：</strong></p>
<p>首先，通过身份采样器Fs对身份特征f~（经过识别网络提取）进行采样。</p>
<p>然后，将两种属性分布特征Zn和Zv以及f~分别concat输入decoder G。</p>
<p>最后，生成一对不属于异构数据库的新异构图像。 </p>
<p>其中的loss和train with paired的情况类似，只不过没有了对抗损失（具体可见train_generator.py代码中的loss部分）。</p>
<h2><span id="heterogeneous-face-recognition">Heterogeneous Face Recognition</span></h2><p>与训练好的LightCNN作为backbone，使用有限的数据对进行训练，再使用大规模生成后的数据进行训练对比。loss选择softmax loss。backbone在训练生成器时是权重更新的，在此处HRN中固定。</p>
<p>对于生成的数据，由于没有特定的类别标签，上述softmax loss不适用。引入<strong>对比学习</strong>机制来利用这些数据。</p>
<p>对比学习机制流程：</p>
<p>首先从生成数据中采样两对异构数据，基于生成的都是身份一致的，这两对都是正例，再将其做交叉，构造出了两对负例，要注意的是要保证交叉后的模态还是跨模态的。对比损失如下：</p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409191600670.png" alt="image-20220409191600670"></p>
<p>其中m是一个margin值。</p>
<p>整体的HFR网络损失为：</p>
<p><img src="/2022/04/09/review_3_DVG-Face/image-20220409191702568.png" alt="image-20220409191702568"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>HFR</tag>
        <tag>generation</tag>
      </tags>
  </entry>
  <entry>
    <title>《CariMe:Unpaired Caricature Generation with Multiple Exaggerations》</title>
    <url>/2022/04/13/review_4_CariMe/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E4%BB%BB%E5%8A%A1">任务</a></li>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a><ul>
<li><a href="#multi-exaggeration-warper">Multi-exaggeration Warper</a><ul>
<li><a href="#warp-reconstruction-loss">Warp Reconstruction Loss</a></li>
<li><a href="#photo-reconstruction-loss">Photo Reconstruction Loss</a></li>
<li><a href="#total-variation-loss">Total Variation Loss</a></li>
<li><a href="#wrapper-total-loss">Wrapper Total Loss</a></li>
</ul>
</li>
<li><a href="#styler">Styler</a><ul>
<li><a href="#adversarial-loss">Adversarial Loss</a></li>
<li><a href="#image-reconstruction-loss">Image Reconstruction Loss</a></li>
<li><a href="#cycle-consistency-loss">Cycle Consistency Loss</a></li>
<li><a href="#style-total-loss">Style Total Loss</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content/CVPR2021/papers/Jing_Cross-Modal_Center_Loss_for_3D_Cross-Modal_Retrieval_CVPR_2021_paper.pdf">https://ieeexplore.ieee.org/abstract/document/9454341/</a></p>
<p>code: <a href="https://github.com/edward3862/CariMe-pytorch">edward3862&#x2F;CariMe-pytorch: Unpaired Caricature Generation with Multiple Exaggerations (TMM 2021) (github.com)</a></p>
<span id="more"></span>

<h1><span id="任务">任务</span></h1><p>漫画生成、图像到图像的翻译、图像扭曲、风格转换</p>
<h1><span id="出发点">出发点</span></h1><p>与一般的image-to-image translation不同，由于各种空间变形的存在，自动绘制漫画是一项更具挑战性的任务。原先的漫画生成方式都是instance-level，本文拓展到distribution-level。</p>
<h1><span id="创新点">创新点</span></h1><p>CariMe可生成具有<strong>多重</strong>夸张和<strong>多种</strong>风格的漫画</p>
<p>提出了一种基于变形场（deformation fields）的非成对漫画生成方法，可以有效地学习真实照片到漫画的空间变换分布。还引入了一个辅助内容编码（auxiliary content code），以帮助产生有意义的、特定于照片的夸张。</p>
<h1><span id="做法">做法</span></h1><p>一个wrapper，一个styler</p>
<h2><span id="multi-exaggeration-warper">Multi-exaggeration Warper</span></h2><p>分别输入一张漫画脸和真实脸，首先计算所有漫画的平均landmark（代码中的main_cal_wrap_degree.py），<img src="/2022/04/13/review_4_CariMe/image-20220414090134868.png" alt="image-20220414090134868">从每个漫画中得到，表达了该张漫画所表示的特定的夸张模式，然后该特征经过encoder获得低维向量Zw（wrap code)，与此同时引入了对应的真实人脸过另一个encoder提取Zp（auxiliary photo-specific content code)，Zp与Zw都是满足标准正态分布的向量，在测试阶段Zw是从正态分布中随机采样获取，以获得不同的变形编码。down scale和up scale操作文中的解释是给变形场去噪。</p>
<p><img src="/2022/04/13/review_4_CariMe/image-20220414083337682.png" alt="image-20220414083337682"></p>
<h3><span id="warp-reconstruction-loss">Warp Reconstruction Loss</span></h3><p><img src="/2022/04/13/review_4_CariMe/image-20220414092823399.png" alt="image-20220414092823399"></p>
<p>L1正则，旨在拉近reconstruction后的变形场与原变形场的差异。</p>
<h3><span id="photo-reconstruction-loss">Photo Reconstruction Loss</span></h3><p><img src="/2022/04/13/review_4_CariMe/image-20220414093327113.png" alt="image-20220414093327113"></p>
<p>L1正则，旨在拉近reconstruction后的真实人脸与输入真实人脸的差异，来鼓励Zp保持对原真是人脸的内容和空间信息。</p>
<h3><span id="total-variation-loss">Total Variation Loss</span></h3><p><img src="/2022/04/13/review_4_CariMe/image-20220414094156859.png" alt="image-20220414094156859"></p>
<p>用来给生成的图像去噪。</p>
<p><a href="https://blog.csdn.net/qq_38406029/article/details/118996415">(54条消息) TV Loss详解_鬼道2022的博客-CSDN博客_tvloss公式</a></p>
<h3><span id="wrapper-total-loss">Wrapper Total Loss</span></h3><p><img src="/2022/04/13/review_4_CariMe/image-20220414094730445.png" alt="image-20220414094730445"></p>
<h2><span id="styler">Styler</span></h2><p>旨在做风格迁移，将图像分界为content representation和style code。</p>
<p>一个style encoder，一个context encoder，一个style decoder（AdaLIN:<a href="https://blog.csdn.net/weixin_43823140/article/details/107840916">(54条消息) 【飞桨】论文解读：U-GAT-IT: Unsupervised Generative Attentional Networks with Adaptive Layer-Instance_目楽 Leo mu的博客-CSDN博客</a>），style输出一个正态分布的style code，context输出feature map。</p>
<p>将context输出的feature map分别进行instance normalization（styler中常用的一种像素normalization）和layer normalization，combine方式需要到代码中查看，送到AdaLIN中，其范式为：</p>
<p><img src="/2022/04/13/review_4_CariMe/image-20220414101725797.png" alt="image-20220414101725797"></p>
<p><img src="/2022/04/13/review_4_CariMe/image-20220414083358409.png"></p>
<h3><span id="adversarial-loss">Adversarial Loss</span></h3><p><img src="/2022/04/13/review_4_CariMe/image-20220414101755992.png" alt="image-20220414101755992"></p>
<p>AdaLIN是基于GAN的方法，所以有adversarial loss。</p>
<h3><span id="image-reconstruction-loss">Image Reconstruction Loss</span></h3><p><img src="/2022/04/13/review_4_CariMe/image-20220414101914719.png" alt="image-20220414101914719"></p>
<p>L1正则，旨在拉近reconstruction后的图像与原图像的距离。</p>
<h3><span id="cycle-consistency-loss">Cycle Consistency Loss</span></h3><p>对生成后的图像再次进入encoder，输出特征与之前encoder输出做L1正则，这里的cycle是循环，不是cycle loss！</p>
<p><img src="/2022/04/13/review_4_CariMe/image-20220414103236545.png" alt="image-20220414103236545"></p>
<h3><span id="style-total-loss">Style Total Loss</span></h3><p><img src="/2022/04/13/review_4_CariMe/image-20220414103409597.png" alt="image-20220414103409597"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>generation</tag>
        <tag>caricature</tag>
      </tags>
  </entry>
  <entry>
    <title>《Clothes-Changing Person Re-identification with RGB Modality Only》</title>
    <url>/2022/05/02/review_5_Simple-CCReID/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E4%BB%BB%E5%8A%A1">任务</a></li>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a><ul>
<li><a href="#clothes-based-adversarial-loss">Clothes-based Adversarial Loss</a><ul>
<li><a href="#training-clothes-classifier">Training clothes classifier</a></li>
<li><a href="#learning-clothes-irrelevant-features">Learning clothes-irrelevant features</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content/CVPR2021/papers/Jing_Cross-Modal_Center_Loss_for_3D_Cross-Modal_Retrieval_CVPR_2021_paper.pdf">https://arxiv.org/pdf/2204.06890v1.pdf</a></p>
<p>code: <a href="https://github.com/guxinqian/simple-ccreid">guxinqian&#x2F;Simple-CCReID: Pytorch implementation of ‘Clothes-Changing Person Re-identification with RGB Modality Only. In CVPR, 2022.’ (github.com)</a></p>
<span id="more"></span>

<h1><span id="任务">任务</span></h1><p>换装人员重识别</p>
<h1><span id="出发点">出发点</span></h1><p><strong>提取与衣服无关的特征</strong>，如脸型、发型、体形和步态。目前大多数工作主要集中在从多模态信息（如剪影和草图）中建模身体形状，但没有充分利用原始 RGB 图像中与衣服无关的信息。</p>
<h1><span id="创新点">创新点</span></h1><p>文章提出一种基于衣服的<strong>对抗</strong>性损失（CAL），通过惩罚 re-id 模型对衣服的预测能力（其实就是个分类器），从原始 RGB 图像中<strong>挖掘与衣服无关的特征</strong>。</p>
<h1><span id="做法">做法</span></h1><p>首先通过最小化Lc来优化衣服分类器。然后固定衣服分类器的参数，最小化Lid和Lca，迫使backbone学习与衣服无关的特征。（每张图片对应一个一个身份标签和服装标签，将衣服类定义为细粒度标识类——所有同一身份的样本都根据他们的衣服被划分为属于该身份的不同类别，不同的人即使穿着相同的衣服也不会共享相同的衣服标签）</p>
<p><img src="/2022/05/02/review_5_Simple-CCReID/image-20220504092335366.png" alt="image-20220504092335366"></p>
<h2><span id="clothes-based-adversarial-loss">Clothes-based Adversarial Loss</span></h2><h3><span id="training-clothes-classifier">Training clothes classifier</span></h3><p>Lc采用交叉熵损失</p>
<h3><span id="learning-clothes-irrelevant-features">Learning clothes-irrelevant features</span></h3><p>固定衣服分类器的参数，并强制主干学习与衣服无关的特征。为此，应该<strong>惩罚re-id模型对于衣服的预测能力</strong>。</p>
<p>然而，由于衣服类被定义为细粒度类，因此惩罚re-id模型对于所有衣服类别的预测能力，也会降低其预测身份的能力，这对re-id是有害的。</p>
<p>那么最终的目的是使经过训练的<strong>服装分类器无法区分相同身份和不同服装的样本</strong>。</p>
<p>所以，Lca是一个<em>multi-positive-class classification loss</em>，属于同一个身份的不同服装类互为正类。（把不同衣服的只要是属于同一个id身份的衣服类都视为衣服正类）</p>
<p><img src="/2022/05/02/review_5_Simple-CCReID/image-20220504101750986.png" alt="image-20220504101750986"></p>
<p>Si+（Si-)是一个有相同身份的衣服标签fi的集合，K是S中的衣服类别数量，q(c)是第c个衣服类别的交叉熵损失的权重，同一件衣服同一个身份的正例，和不同衣服同一个身份的正例有相同的权重1&#x2F;K。</p>
<p>同时，为了在不严重降低衣服一致性识别精度的情况下提高模型的换衣识别能力，等式（4）可替换为：</p>
<p><img src="/2022/05/02/review_5_Simple-CCReID/image-20220504105337953.png" alt="image-20220504105337953"></p>
<p><img src="/2022/05/02/review_5_Simple-CCReID/image-20220504105427890.png" alt="image-20220504105427890"></p>
<p>另外，穿着相同衣服的正例比穿着不同衣服的正例有更大的权重。</p>
<p>在优化CAL的同时，对身份分类器进行了优化。因此，第二步的优化过程是：</p>
<p><img src="/2022/05/02/review_5_Simple-CCReID/image-20220504105540307.png" alt="image-20220504105540307"></p>
<p>当仅使用Lid进行训练时，该模型在优化的早期阶段倾向于学习简单样本（具有相同的衣服），然后逐渐学习区分困难样本（具有相同的身份和不同的衣服）。类似课程学习方式，但尽管如此（6）中并未抛弃Lid。其原因是，在优化的早期阶段，只有最小化Lca并迫使模型区分硬样本，才可能导致局部最优。相反，在我们的实验中，在第一次降低学习率后，增加了Lca用于训练。</p>
<p>&#96;&#96;</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">class ClothesBasedAdversarialLoss(nn.Module):</span><br><span class="line">    &quot;&quot;&quot; Clothes-based Adversarial Loss.</span><br><span class="line"></span><br><span class="line">    Reference:</span><br><span class="line">        Gu et al. Clothes-Changing Person Re-identification with RGB Modality Only. In CVPR, 2022.</span><br><span class="line"></span><br><span class="line">    Args:</span><br><span class="line">        scale (float): scaling factor.</span><br><span class="line">        epsilon (float): a trade-off hyper-parameter.</span><br><span class="line">    &quot;&quot;&quot;</span><br><span class="line">    def __init__(self, scale=16, epsilon=0.1):</span><br><span class="line">        super().__init__()</span><br><span class="line">        self.scale = scale</span><br><span class="line">        self.epsilon = epsilon</span><br><span class="line"></span><br><span class="line">    def forward(self, inputs, targets, positive_mask):</span><br><span class="line">        &quot;&quot;&quot;</span><br><span class="line">        Args:</span><br><span class="line">            inputs: prediction matrix (before softmax) with shape (batch_size, num_classes)</span><br><span class="line">            targets: ground truth labels with shape (batch_size)</span><br><span class="line">            positive_mask: positive mask matrix with shape (batch_size, num_classes). The clothes classes with </span><br><span class="line">                the same identity as the anchor sample are defined as positive clothes classes and their mask </span><br><span class="line">                values are 1. The clothes classes with different identities from the anchor sample are defined </span><br><span class="line">                as negative clothes classes and their mask values in positive_mask are 0.</span><br><span class="line">        &quot;&quot;&quot;</span><br><span class="line">        inputs = self.scale * inputs</span><br><span class="line">        negtive_mask = 1 - positive_mask</span><br><span class="line">        identity_mask = torch.zeros(inputs.size()).scatter_(1, targets.unsqueeze(1).data.cpu(), 1).cuda()</span><br><span class="line"></span><br><span class="line">        exp_logits = torch.exp(inputs)</span><br><span class="line">        log_sum_exp_pos_and_all_neg = torch.log((exp_logits * negtive_mask).sum(1, keepdim=True) + exp_logits)</span><br><span class="line">        log_prob = inputs - log_sum_exp_pos_and_all_neg</span><br><span class="line"></span><br><span class="line">        mask = (1 - self.epsilon) * identity_mask + self.epsilon / positive_mask.sum(1, keepdim=True) * positive_mask</span><br><span class="line">        loss = (- mask * log_prob).sum(1).mean()</span><br><span class="line"></span><br><span class="line">        return loss</span><br></pre></td></tr></table></figure>





]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>ReID</tag>
        <tag>decouple</tag>
        <tag>adversarial</tag>
      </tags>
  </entry>
  <entry>
    <title>《IACycleGAN》</title>
    <url>/2022/06/08/review_6_IACycleGAN/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E4%BB%BB%E5%8A%A1">任务</a></li>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a><ul>
<li><a href="#%E7%94%9F%E6%88%90%E6%A8%A1%E5%9E%8B">生成模型</a><ul>
<li><a href="#%E7%94%9F%E6%88%90%E7%BD%91%E7%BB%9C%E6%95%B4%E4%BD%93loss%E5%9B%BE%E7%A4%BA">生成网络整体loss图示</a></li>
</ul>
</li>
<li><a href="#%E8%AF%86%E5%88%AB%E7%BD%91%E7%BB%9C%E4%B8%8E%E7%94%9F%E6%88%90%E7%BD%91%E7%BB%9C%E7%9A%84%E4%BA%92%E7%9B%B8%E4%BC%98%E5%8C%96">识别网络与生成网络的互相优化</a></li>
</ul>
</li>
<li><a href="#%E5%AE%9E%E9%AA%8C">实验</a><ul>
<li><a href="#%E6%95%B0%E6%8D%AE%E9%9B%86">数据集</a><ul>
<li><a href="#%E7%94%9F%E6%88%90%E6%A8%A1%E5%9E%8B%E5%AE%9E%E6%96%BD%E7%BB%86%E8%8A%82">生成模型实施细节</a></li>
<li><a href="#%E8%AF%86%E5%88%AB%E6%A8%A1%E5%9E%8B%E5%AE%9E%E6%96%BD%E7%BB%86%E8%8A%82">识别模型实施细节</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content/CVPR2021/papers/Jing_Cross-Modal_Center_Loss_for_3D_Cross-Modal_Retrieval_CVPR_2021_paper.pdf"><a href="https://arxiv.org/pdf/2103.16019.pdf">Identity-Aware CycleGAN for Face Photo-Sketch Synthesis and Recognition (arxiv.org)</a></a></p>
<p>code: none</p>
<span id="more"></span>

<h1><span id="任务">任务</span></h1><p>真人素描生成与识别</p>
<h1><span id="出发点">出发点</span></h1><p>生成促进识别 识别促进生成；</p>
<p>大部分生成方法使得合成图像与原始图像在纹理上保持一致，会导致信息丢失；</p>
<p>大多数生成框架都只能学习两个域之间的关系，其鉴别器只关注照片和草图之间的差异，而不考虑任何特定的识别优化（身份信息）；</p>
<h1><span id="创新点">创新点</span></h1><p>在CycleGAN上加入了感知损失（perceptual loss）,能更好的关注面部的语义信息（眼睛、鼻子）;</p>
<p>使生成模型和识别模型相互优化，生成模型迭代生成更好的图像，Triplet Loss训识别模型；</p>
<h1><span id="做法">做法</span></h1><h2><span id="生成模型">生成模型</span></h2><p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608102426736.png" alt="image-20220608102426736"></p>
<p>分别给出两个domain的照片（这里输入的是paired数据，这里的paired应该身份paired），其训练目的是获得Gx，Gy两个生成器。</p>
<p>两个识别网络，其目的是使用pretrain好的vggface提取feature做Identity perception loss；</p>
<p>生成器用了《Perceptual losses for real-time style transfer and super-resolution》中的结构；</p>
<p>判别器用了PatchGAN的结构；</p>
<h3><span id="生成网络整体loss图示">生成网络整体loss图示</span></h3><p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608105545461.png" alt="image-20220608105545461"></p>
<h4><span id="对抗损失adversarial-loss">对抗损失（adversarial loss）</span></h4><p>输入图像与生成图像进入判别器进行计算，最小化下式</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608110633855.png" alt="image-20220608110633855"></p>
<h4><span id="循环一致性损失cycle-consistency-loss">循环一致性损失（cycle consistency loss）</span></h4><p>Gx生成的图像再进入Gy恢复原本domain与最初的输入x计算L1，<strong>此loss为pix级</strong>，最小化下式</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608110959225.png" alt="image-20220608110959225"></p>
<h4><span id="身份保持损失identity-perception-loss">身份保持损失（identity perception loss）</span></h4><p>仅使用对抗损失会导致伪影和训练不稳定，需要加更强大的监督；</p>
<p>通过一个pretrain的识别网络（文中选择vggface）分别提取两对（原图与合成图）的feature计算L2，<strong>此loss区别于pix级监督，是feature级</strong>，文中对于此处的解释是：绘制的草图会有夸张成分以扭曲面部纹理信息，夸大面部特征，完全基于pix重建图像效果不会好；CycleGAN的训练需要进行数据增强操作（resize，flip等）难以实施pix级的监督。</p>
<p>最小化下式</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608111456554.png" alt="image-20220608111456554"></p>
<h4><span id="身份映射损失identity-mapping-loss">身份映射损失（identity mapping loss）</span></h4><p>常规的pix级的约束，最小化下式</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608112212476.png" alt="image-20220608112212476"></p>
<h4><span id="整体loss">整体loss</span></h4><p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608112236780.png" alt="image-20220608112236780"></p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608112252105.png" alt="image-20220608112252105"></p>
<p>最小化生成器的loss最大化判别器的loss</p>
<p>其中超参数lamda分别设为10，30000000，5</p>
<h2><span id="识别网络与生成网络的互相优化">识别网络与生成网络的互相优化</span></h2><p>许多主做生成的工作都是fix相应的识别网络作为一个特征提取器来附加身份保持损失；</p>
<p>本文的做法估计是：</p>
<p>step1：先fix识别网络参数训练生成网络，获得一定量的生成的图片；</p>
<p>step2：使用生成的图片fine-tune识别网络（单走一个人脸识别模型的流程），用了triplet loss，更新识别网络参数，其中两个模态分别有两个识别网络，要分开训练；</p>
<p>step3：重复上述操作以获得更好的生成模型和识别模型。</p>
<p>（有问题的点：若第一次生成的质量得不到保证，那低质量的生成图像真的能提升识别模型的acc吗？<strong>互相优化的模型很依赖第一次生成的图像质量</strong>）</p>
<p>我认为的做法：先简单训练一个识别网络达到一个还行的acc，更新其backbone参数作为生成网络的特征提取器，然后再进行生成网络的训练。</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608135047478.png" alt="image-20220608135047478"></p>
<h1><span id="实验">实验</span></h1><p>CycleGAN生成—》一阶段vgg fine-tune—》IACycleGAN生成（加入fine-tune的vgg提取的特征做身份保持损失）—》二阶段vgg fine-tune</p>
<h2><span id="数据集">数据集</span></h2><p>CUFS和CUFSF</p>
<h3><span id="生成模型实施细节">生成模型实施细节</span></h3><p>对于生成网络的训练，都是从头开始训练，使用instance normalization来实现更好的稳定性和更低的噪声；</p>
<p>使用Adam优化器，horizontal filp prob&#x3D;0.5用于数据增强；</p>
<p>前100个epoch设置0.0002的学习率，并在后100个epoch线性下降至0；</p>
<p>在titian xp上训练了10小时；</p>
<p>为减小网络震荡，采用存储多个生成图像的图像缓冲区来更新鉴别器，而不是使用最后生成的图像。</p>
<p>生成使用了SSIM FSIM两个指标</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608152343197.png" alt="image-20220608152343197"></p>
<h3><span id="识别模型实施细节">识别模型实施细节</span></h3><p>文中用的vggface，caffe上跑的（估计是官方代码）</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608153331083.png" alt="image-20220608153331083"></p>
<p>在做检索任务时，先做风格模态的迁移，再计算相似度。</p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608155946505.png" alt="image-20220608155946505"></p>
<p><img src="/2022/06/08/review_6_IACycleGAN/image-20220608160958943.png" alt="image-20220608160958943"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>sketch</tag>
        <tag>synthesis</tag>
        <tag>GAN</tag>
        <tag>face recognition</tag>
      </tags>
  </entry>
  <entry>
    <title>《Learning to Warp for Style Transfer》</title>
    <url>/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E4%BB%BB%E5%8A%A1">任务</a></li>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#%E7%9B%B8%E5%85%B3%E5%B7%A5%E4%BD%9C">相关工作</a><ul>
<li><a href="#texture-nst">Texture NST</a><ul>
<li><a href="#%E5%9C%A8%E7%BA%BF%E4%BC%98%E5%8C%96%E7%9A%84%E5%BD%A2%E5%BC%8F">在线优化的形式</a></li>
<li><a href="#%E7%A6%BB%E7%BA%BF%E4%BC%98%E5%8C%96%E7%9A%84%E5%BD%A2%E5%BC%8F">离线优化的形式</a></li>
<li><a href="#%E5%85%B6%E4%BB%96%E5%8F%98%E5%BC%8F">其他变式</a></li>
</ul>
</li>
<li><a href="#geometric-nst">Geometric NST</a></li>
</ul>
</li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a><ul>
<li><a href="#geometric-stylewarper">Geometric Style（Warper）</a><ul>
<li><a href="#feature-extraction">Feature Extraction</a></li>
<li><a href="#feature-correlation">Feature Correlation</a></li>
<li><a href="#warp-network-training-and-using">Warp Network: Training and Using</a></li>
</ul>
</li>
<li><a href="#texture-stylestyler">Texture Style（Styler）</a></li>
<li><a href="#%E5%AE%9E%E7%8E%B0%E7%BB%86%E8%8A%82">实现细节</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content/CVPR2021/papers/Jing_Cross-Modal_Center_Loss_for_3D_Cross-Modal_Retrieval_CVPR_2021_paper.pdf"><a href="https://openaccess.thecvf.com/content/CVPR2021/papers/Liu_Learning_To_Warp_for_Style_Transfer_CVPR_2021_paper.pdf">Learning To Warp for Style Transfer (thecvf.com)</a></a></p>
<p>code: <a href="https://github.com/xch-liu/learning-warp-st">https://github.com/xch-liu/learning-warp-st</a></p>
<span id="more"></span>

<h1><span id="任务">任务</span></h1><p>NST（neural style transfer）</p>
<h1><span id="出发点">出发点</span></h1><p>大多数风格迁移只考虑了迁移纹理信息，而为关注在艺术层面的几何扭曲。</p>
<p>本文考虑使用深度神经网络进行图像样式化的问题，特别关注<strong>艺术扭曲</strong>。</p>
<h1><span id="创新点">创新点</span></h1><p>在CycleGAN上加入了感知损失（perceptual loss）,能更好的关注面部的语义信息（眼睛、鼻子）;</p>
<p>使生成模型和识别模型相互优化，生成模型迭代生成更好的图像，Triplet Loss训识别模型；</p>
<p>与其他扭曲迁移模型的区别：</p>
<p>不同于The face of art: Landmark detection and geometric style in portraits和WarpGAN，其<strong>不限于单个语义类别</strong>；</p>
<p>不同于Deformable style transfer依赖前向和后向优化，其专门设计了前馈网络，以<strong>输出给定内容和几何图像的扭曲字段</strong>；</p>
<p>比Deformable style transfer快；</p>
<p>与Geometric style transfer仅限于参数化扭曲字段不同，其生成的是<strong>非参数化扭曲</strong>；</p>
<p>与Geometric style transfer以外的其他NST算法不同，其<strong>支持使用两幅图像来指定样式</strong>，这为图像创建增加了其他NST算法所没有的多功能性。</p>
<h1><span id="相关工作">相关工作</span></h1><h2><span id="texture-nst">Texture NST</span></h2><p>纹理NST一直是NST的主要形式（默认NST都是纹理NST）</p>
<h3><span id="在线优化的形式">在线优化的形式</span></h3><p>通过迭代优化图像来传递样式。</p>
<h3><span id="离线优化的形式">离线优化的形式</span></h3><p>离线优化生成模型，并在测试阶段通过一次向前传递生成样式化图像。</p>
<p>训好的模型一般只能迁移特定样式，有些模型将多种风格融合到一个模型中，或者使用一个模型来传递任意的艺术风格。</p>
<h3><span id="其他变式">其他变式</span></h3><p>肖像画风格转移、视觉属性转移、语义风格转移、视频风格转移、3D风格转移和照片级真实感风格转移</p>
<h2><span id="geometric-nst">Geometric NST</span></h2><p>几何形变的艺术风格的迁移越来越重要。</p>
<p>一些方法仅限于特定的内容域，如面部《The face of art: Landmark detection and geometric style in portraits》和文本。这些方法产生了极好的结果。</p>
<p>《Deformable style transfer》和《Geometric Style Transfer》描述了在多个类上操作的更通用的方法，增加的灵活性在质量方面似乎成本不高。</p>
<p>DST速度慢 支持任意形变</p>
<p>GST速度快 不支持任意形变</p>
<p>本文方法快且支持任意形变</p>
<h1><span id="做法">做法</span></h1><p>输入要求：</p>
<p>1）一张要被迁移的content图像Ic</p>
<p>2）一张指导几何迁移的图像Ig</p>
<p>3）一张指导纹理迁移的图像It</p>
<p>Ig和It可以是同一张</p>
<p>total pipeline如下（一个warper 一个styler）</p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220609205913858.png" alt="image-20220609205913858"></p>
<h2><span id="geometric-stylewarper">Geometric Style（Warper）</span></h2><p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220609210756668.png" alt="image-20220609210756668"></p>
<p>其关键思想是训练一个能够推断<strong>二维扭曲场w</strong>的神经网络，并创建一个衡量特征相似性的四维标量函数<strong>M</strong>。</p>
<p>有三个主要组成部分：</p>
<p>1）特征提取：分别获取 Fg 和 Fc</p>
<p>2）特征融合：来衡量特征相似度 M(Fc,Fg)</p>
<p>3）训练warp网络输出函数 f 使得 w &#x3D; f(M)，<strong>一旦训完，网络 f 可以在新输入上使用，无需修改</strong>，（即得到了一个通用的Warp Field Estimation用来估计warp degree）本文所有输出都是单个warper生成的。</p>
<p>定义warp field的w是非参数化的，不对分布做假设，就是一些统计量，不用网络进行分布的约束。</p>
<h3><span id="feature-extraction">Feature Extraction</span></h3><p>使用VGG，提取pool4出来的特征，接一个L2 normalization。输出的 F 是 W * H 的特征图，本文中是16 * 16，文中说是平衡了计算效率和扭曲质量得出的结果。</p>
<h3><span id="feature-correlation">Feature Correlation</span></h3><p>此模块计算feature map在每个pixel上的特征关联分数，结果存储在四维标量函数 M 中,M∈R W×H×W×H，其中的每个元素的计算规则如下：</p>
<p>Fc 是content图像提取的feature；</p>
<p>Fg是geometric图像提取的feature；</p>
<p>i，j 对应Fc中的pix坐标</p>
<p>k，l 对应Fg中pix的坐标</p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220610101853238.png" alt="image-20220610101853238"></p>
<p>分母为遍历Fg上的每个pix与Fc( i , j ) 做内积求平方开根；</p>
<p>分子为Fc（i，j）与Fg（k，l）做内积。</p>
<p>个人理解：这个统计量表示了每个两个feature间的关联性特征量。</p>
<h3><span id="warp-network-training-and-using">Warp Network: Training and Using</span></h3><p>本文在技术上的贡献为其训练了一个 f 来输出非参数化的warp field（w）。</p>
<p>输入feature correlation（M），该步骤可以表示为 w &#x3D; f (M)，形式化定义这层mapping：</p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220610191607879.png" alt="image-20220610191607879"></p>
<p>W1 , H1是图像尺寸，最终warp module输出根据Ig的几何形变warp后的Ic。</p>
<p>原则上不需要进行训练，因为如下的优化问题对于任何的图像对的数据都足够解决：</p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220610192737703.png" alt="image-20220610192737703"></p>
<p>h是一个度量函数。</p>
<p>此基于优化的方式来自于DST，但与直接从经过训练的网络计算扭曲场相比，单实例优化速度较慢。（本文没采用基于优化的方式，而是单独训练了一个网络）</p>
<p>本文网络使用<strong>一组语义相关或具有几何相似部分的图像对</strong>进行训练。图像对涵盖了广泛的语义内容：人脸、动物等。为了提高模型在艺术领域的泛化能力，我们使用艺术增强来创建每个训练图像的纹理增强副本。<strong>经过训练后，变形网络可以应用于任何图像，无论其语义内容如何</strong>。</p>
<p><strong>其基本思想是局部移动内容图像中的像素，并重新计算新扭曲图像中的特征，直到loss收敛</strong></p>
<p>定义Fm来表示受像素m影响的</p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220610200411017.png" alt="image-20220610200411017"></p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220610200701085.png" alt="image-20220610200701085"></p>
<p><strong>这个最终的softmax归一化输出代表每个content图像的pixel在每个扭曲图像中的search window中的关联程度</strong></p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220610213521698.png" alt="image-20220610213521698"></p>
<p>个人最终理解：</p>
<p><strong>输入扭曲图像和内容图像（待扭曲图像），使用VGG提取feature map，warp field矩阵扭曲Fc矩阵，与Fg矩阵进行feature matching计算一个关联度四维统计量，输入warp field estimator（神经网络），最小化每个pixel和其扭曲图像相应search window的关联度统计量来使得内容图像尽可能扭曲成目标扭曲样式；神经网络更新参数，输出更好的warp field，循环优化网络，直至达到良好的扭曲效果。</strong></p>
<p>前半部分机器学习，后半部分深度学习，这样warp field可以直接通过网络inference出来，速度提升。</p>
<h2><span id="texture-stylestyler">Texture Style（Styler）</span></h2><p>最小化content loss 和 texture loss，二者依赖于用于目标检测而训练的模型，本文唯一不同在于采取多尺度策略，<strong>优先将纹理随着细节的增加转移到输出图像的不同区域</strong>。几十年来，这种策略一直用于规定性纹理合成，最近用于仅纹理的NST，有助于改善风格转换结果。在本文工作中，利用它来解决<strong>由于几何扭曲而产生的模糊和其他瑕疵</strong>。</p>
<p>此部分不做详解</p>
<h2><span id="实现细节">实现细节</span></h2><p>warper在PF-PASCAL和MS COCO数据集上训练，可训练网络结构不大，单卡训了2小时</p>
<p><img src="/2022/06/09/review_7_Learing%20to%20Warp%20for%20Style%20Transfer/image-20220611151019063.png" alt="image-20220611151019063"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>style transfer</tag>
        <tag>warp</tag>
      </tags>
  </entry>
  <entry>
    <title>《Geometric and Textural Augmentation for Domain Gap Reduction》</title>
    <url>/2022/06/12/review_8_geom%20tex%20dg/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E4%BB%BB%E5%8A%A1">任务</a></li>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E5%88%9B%E6%96%B0%E7%82%B9">创新点</a></li>
<li><a href="#idea%E6%A6%82%E8%A7%88">idea概览</a></li>
<li><a href="#%E5%81%9A%E6%B3%95">做法</a><ul>
<li><a href="#%E5%87%A0%E4%BD%95%E5%A2%9E%E5%BC%BA">几何增强</a></li>
<li><a href="#%E7%BA%B9%E7%90%86%E5%A2%9E%E5%BC%BA">纹理增强</a></li>
<li><a href="#%E7%BB%93%E5%90%88%E5%87%A0%E4%BD%95%E5%92%8C%E7%BA%B9%E7%90%86%E5%A2%9E%E5%BC%BA">结合几何和纹理增强</a></li>
</ul>
</li>
<li><a href="#%E5%AE%9E%E9%AA%8C">实验</a></li>
<li><a href="#%E7%BB%93%E8%AE%BA">结论</a></li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content/CVPR2022/papers/Liu_Geometric_and_Textural_Augmentation_for_Domain_Gap_Reduction_CVPR_2022_paper.pdf">Geometric and Textural Augmentation for Domain Gap Reduction (thecvf.com)</a></p>
<p>code: <a href="https://github.com/xch-liu/geom-tex-dg">xch-liu&#x2F;geom-tex-dg: Geometric and Textural Augmentation for Domain Gap Reduction (github.com)</a></p>
<span id="more"></span>

<h1><span id="任务">任务</span></h1><p>通过纹理和风格分布采样增强训练数据提升不同风格不同形变物体识别效果。</p>
<h1><span id="出发点">出发点</span></h1><p>对于艺术品这种具有风格形变的目标识别性能不好；</p>
<p>有工作人为这是个域泛化的问题，但已被证明的是：<strong>同一个类别但不同样式</strong>的数据往往比<strong>不同类别但相同样式</strong>的数据的差别更大，从而阻碍常规的DG方法；</p>
<p>此外，照片和艺术品的数量也不尽相同。因此，从几乎完全由照片组成的训练数据转移到包含艺术品的测试集是一个重大挑战。</p>
<p>最近的工作集中于通过style transfer应用于训练示例来提高模型鲁棒性，减轻过拟合；</p>
<p><strong>理由为：通过输入不同风格纹理的图像数据，从而使得识别网络被迫关注于物体本身语义特征的学习，如形状等</strong></p>
<p>但大多数仅关注于纹理的迁移，而忽略了几何形变的迁移；</p>
<h1><span id="创新点">创新点</span></h1><p>在几何和纹理风格方面弥补了domain的差距，而不仅仅是纹理；</p>
<p>本文的增强过程不同于现有技术，当前的文献通过使用一组（纹理）风格的样本将照片处理成不同风格艺术品来扩充数据集，相反，本文构建<strong>纹理和几何描述符的独立分布</strong>，并<strong>从中采样</strong>以增加训练数据。我们的实验表明，几何和纹理增强提高了几种常见跨域基准的分类泛化能力。</p>
<h1><span id="idea概览">idea概览</span></h1><p>本文假设纹理style和对象身份是独立的；（类似 content 和 style 的概念）</p>
<p>同一身份类别中的图像的扭曲场一般是相似的，而跨身份类别图像的扭曲场存在显著差异；</p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220612171213941.png" alt="image-20220612171213941"></p>
<p>手写数字和马的扭曲场明显是不一样的，</p>
<p>样式包括纹理和几何。纹理样式与对象类无关：知道图片是水彩或剪贴画并不能预测其对象类（身份类别）。不过，几何样式取决于对象类。使用<strong>learning to warp</strong>（箭头上方的颜色编码扭曲字段和下面相应的变形结果），可以扭曲显示相同对象类但纹理样式不同的源图像。可以看到，对象类中的扭曲场是相似的，但在对象类之间差异很大，马和文字的扭曲场（可视化表示为图中的热力图）明显不一致。</p>
<h1><span id="做法">做法</span></h1><p>增强通过处理训练输入x来扩展训练数据，以生成新的训练输入A（x）。分为两个步骤：几何增强扭曲图像；纹理增强变更纹理。</p>
<p>这两步通过独立采样两个分布来执行，<strong>分布构建是采用预先训练好的特征提取器</strong>。</p>
<p>图示训练集S包含3种风格3个类别</p>
<p><strong>本文目标为学习一个预测模型，能够很好地泛化到一个unseen style domain，也就是说，使用训练集S构建一个分类器，当图像的style是unseen的时候也能表现得很好。</strong></p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220612212437877.png" alt="image-20220612212437877"></p>
<p><strong>本文默认同一个身份类别的图像有着相近的扭曲场；</strong></p>
<p><strong>左：一个简化的训练集，包括三个风格（艺术、照片和素描）中的三个对象（狗、长颈鹿、吉他）。</strong></p>
<p><strong>中：输入同一身份不同风格的图像进行排列组合构成图像对，图中是三种就构建了三种排列组合；然后送入扭曲模块，生成warp field W*；</strong></p>
<p><em><em>扭曲分布NW</em> 就由每个身份类别的扭曲场 W</em> 构建，并从这些分布中采样扭曲原本的图像，以达到增强效果；**</p>
<p><strong>右：纹理分布的构造。将训练集输入纹理样式预测网络F以生成纹理表示集V。纹理分布NV是基于V构造的。为了更好地显示，扭曲字段采用颜色编码，NW∗和NV在低维空间中可视化。</strong></p>
<h2><span id="几何增强">几何增强</span></h2><p>几何增强是通过对训练数据进行随机形变来实现的。每个随机形变都要有以下的几个要求：</p>
<p>（1）形变速度要足够快，以便再训练期间在线执行；</p>
<p>（2）形变程度要可控，以避免过度形变；</p>
<p>（3）最重要的是，形变的类型应该足够丰富，来确保可变性并且足够合理，以避免无意义和误导性的形变（应符合特定的身份类别——比如马不能按照狗形变）</p>
<p>本文使用了《Learning to Warp》（见上个markdown）的warper来实现上述效果；</p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220616212625252.png" alt="image-20220616212625252"></p>
<p>具体操作：</p>
<p>例如一个类别 k 中有N张图像，那这<strong>N张图像排列组合成所有的图像对</strong>，<strong>每种图像对都对应了一个的扭曲场，每个类别的扭曲场又构成一组扭曲场</strong>；</p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220616212720503.png" alt="image-20220616212720503"></p>
<p>如何将这些扭曲场施加到训练图像上呢？</p>
<p>如果直接从Wk（一组扭曲场）中采样，那么扭曲的样式数量就由K的大小限制住了，为了使本文的方法能够支持尽可能广泛的几何样式，<strong>基于Wk构造了一个几何分布，并直接从中采样新的扭曲场</strong>。</p>
<p>使用多元正态分布对扭曲分布进行建模，计算均值和协方差矩阵：</p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220616212437320.png" alt="image-20220616212437320"></p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220616212447197.png" alt="image-20220616212447197"></p>
<p>Wk表示为一个二维的矩阵，每一列代表一个 “矢量化” 的扭曲场。</p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220616212739581.png" alt="image-20220616212739581"></p>
<p>为减少计算均值和协方差矩阵的计算量，对Wk做了一步下采样操作。</p>
<h2><span id="纹理增强">纹理增强</span></h2><p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220617102147930.png" alt="image-20220617102147930"></p>
<p>采用Ghiasi的《Exploring the structure of a real-time, arbitrary neural artistic stylization network》，模型代码位置Dassl\dassl\modeling\backbone\styleaugment\styleaug\ghiasi.py</p>
<p>具体细节：</p>
<p>模型具体的两个模块：</p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220617104416760.png" alt="image-20220617104416760"></p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220617104423963.png" alt="image-20220617104423963"></p>
<p>通过一个纹理样式预测网络，从一个style图像预测一个100维的向量v，（trained on PBN数据集）；</p>
<p>这些向量组成一个矩阵；</p>
<p>使用多元正态分布对扭曲分布进行建模，计算均值和协方差矩阵（<strong>同扭曲分布的构建</strong>），不同之处在于，由于纹理央视和对象类的假设是独立的，可以将类别和域标签融合在一起（不细分类别，所有训练数据一起构建）；</p>
<p>在做纹理增强时，在Nv分布中随机采样v，并通过样式预测网络传输v，再再content图像Ic上来应用这个采样出的纹理v得到Io；</p>
<p>为了控制风格增强的程度，做了个线性插值：</p>
<p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220617105954463.png" alt="image-20220617105954463"></p>
<p>除了增强纹理样式表示之外，上述方法的另一个好处是计算效率。通过对图像进行批处理来构造纹理分布（一个batch先构造好？），然后进行直接表示采样，可以大大减少训练过程中的时间开销。</p>
<h2><span id="结合几何和纹理增强">结合几何和纹理增强</span></h2><p><img src="/2022/06/12/review_8_geom%20tex%20dg/image-20220617110427313.png" alt="image-20220617110427313"></p>
<p>在训练过程中使用几何和纹理分布。在训练过程中，每个图像都可能被从特定类的扭曲分布中采样的扭曲场变形，然后可能使用来自与类无关的纹理分布的样本重新纹理。下面的虚线框中显示了混合几何和纹理样式的一些潜在增强。</p>
<h1><span id="实验">实验</span></h1><p>在本节中，我们将评估我们的方法在几个基准上的性能，并将其与最新的最先进的方法进行比较。我们还进行了烧蚀研究，以验证我们的识别方法中每个成分的重要性，无论描述风格如何。在每一种情况下，被测试的假设都是，增强通过扩大视觉对象类（VOC）以包括看不见的示例来增强对象分类性能。因此，我们不对任何测试图像应用任何类型的增强：我们的假设是VOC足够宽，可以包含新图像。</p>
<p>具体数据见代码文件组织结构。</p>
<p>做了<strong>多源和单源</strong>的域泛化效果对比。</p>
<h1><span id="结论">结论</span></h1><p><strong>结论1：</strong></p>
<p>从实验效果可知纹理和几何变换都有效，纹理影响更大；</p>
<p>证明了：纹理偏移大于几何偏移。根据我们的实验结果和之前一些研究的发现，这种现象可能有一些原因：</p>
<p>这与CNN对非形状特征的敏感性有关。CNN对范围广泛的图像处理非常敏感，对人类判断几乎没有影响。</p>
<p>具有纹理偏好的CNN可能表示归纳纹理偏差，这使得模型很难在小数据区域中学习几何相关特征，也很难将其推广到不同的分布，而不是它们所训练的分布。</p>
<p><strong>结论2：</strong></p>
<p>我们的实验结果还表明，几何和纹理增强的效果因数据集而异。最大的原因之一是数据集之间的对象和样式差异。</p>
<p>一些对象类本身具有几何形状差异，例如PACS中的动物和数字DG中的手写数字。相比之下，Office Home中的静态对象具有较少的类内形状变化。这意味着它们对几何样式的依赖不同。</p>
<p>（几何扭曲越多的数据集，几何增强影响越大）</p>
<p><strong>局限：</strong></p>
<p>由于我们的几何和纹理分布是基于源图像的相应特征表示构建的，因此它们强烈<strong>依赖于图像质量</strong>。如果特征表示远远不够好，则扩充空间将是次优的。</p>
<p><strong>补充：</strong></p>
<p>此外，对于不同的任务，如场景级分类、多对象图像，我们的纹理增强是适用的，但几何增强不能直接使用，因为它可能会在不考虑场景内容的情况下引入扭曲。一种潜在的改进方法是增加场景中的单个对象，这反过来需要对象检测，这是一个与分类不同的研究领域。这超出了本文的范围，但却是一个很好的未来探索方向。</p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>style transfer</tag>
        <tag>argument</tag>
      </tags>
  </entry>
  <entry>
    <title>《MeInGame:Create a Game Character Face from a Single Portrait》</title>
    <url>/2022/06/29/review_9_MeInGame/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E4%BB%BB%E5%8A%A1">任务</a></li>
<li><a href="#%E5%87%BA%E5%8F%91%E7%82%B9">出发点</a></li>
<li><a href="#%E8%B4%A1%E7%8C%AE">贡献</a></li>
<li><a href="#%E6%96%B9%E6%B3%95">方法</a><ul>
<li><a href="#3d%E4%BA%BA%E8%84%B8%E6%95%B0%E6%8D%AE%E9%9B%86%E6%9E%84%E5%BB%BA%E6%96%B9%E6%B3%95">3D人脸数据集构建方法</a></li>
<li><a href="#%E4%BA%BA%E8%84%B8%E5%BD%A2%E7%8A%B6%E9%87%8D%E5%BB%BA-face-shape-reconstruction">人脸形状重建 （Face Shape Reconstruction）</a></li>
<li><a href="#%E5%BD%A2%E7%8A%B6%E8%BD%AC%E6%8D%A2shape-transfer">形状转换（Shape Transfer）</a></li>
<li><a href="#%E6%8D%9F%E5%A4%B1%E5%87%BD%E6%95%B0">损失函数</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<p>paper: <a href="https://openaccess.thecvf.com/content/CVPR2022/papers/Liu_Geometric_and_Textural_Augmentation_for_Domain_Gap_Reduction_CVPR_2022_paper.pdf"><a href="https://arxiv.org/pdf/2102.02371.pdf">2102.02371.pdf (arxiv.org)</a></a></p>
<p>code: <a href="https://github.com/xch-liu/geom-tex-dg"><a href="https://github.com/FuxiCV/MeInGame">FuxiCV&#x2F;MeInGame: MeInGame: Create a Game Character Face from a Single Portrait, AAAI 2021 (github.com)</a></a></p>
<span id="more"></span>

<h1><span id="任务">任务</span></h1><p>从单张真实2D肖像生成武侠风格的3D可形变模型。</p>
<h1><span id="出发点">出发点</span></h1><p>近年来，人们提出了许多基于深度学习的三维人脸重建方法，但在游戏中应用较少。当前的游戏角色定制系统要么要求玩家手动调整相当多的面部属性以获得所需的面部，要么限制面部形状和纹理的自由度。</p>
<h1><span id="贡献">贡献</span></h1><p>我们提出了一种低成本的三维人脸数据集创建方法。我们创建的数据集在种族和性别上是平衡的，面部形状和纹理都是从原始图像中创建的。我们将在论文被接受后将其公开。 提出了一种低成本的面部纹理获取方法</p>
<p>我们提出了一种将重建的3DMM人脸形状转换为游戏网格的方法，可以直接在游戏环境中使用。该方法与网格连通性无关，在实际应用中计算效率较高。 </p>
<p>为了消除光照和遮挡的影响，我们在对抗性训练范式下训练神经网络，从野外人脸图像中的单个图像预测一个完整的漫反射贴图。 </p>
<h1><span id="方法">方法</span></h1><p><img src="/2022/06/29/review_9_MeInGame/image-20220629143637063.png" alt="image-20220629143637063"></p>
<p>Shape Reconstructor pretrain好，获取3DMM系数和姿势系数，通过3DMM网络构成3DMM mesh（只有正面3D人脸），Shape Transfer将3DMM mesh转换成Game mesh（整个3D人头）；</p>
<p>根据Game mesh将原图uv展开创建一个粗糙纹理贴图，通过encoder decoder进一步细化至细化纹理；</p>
<p>还引入了一个光照predictor，预测光照系数；</p>
<p>最后，将预测的形状、纹理和照明系数一起提供给可微分渲染器，并强制渲染输出与输入照片类似。为了进一步改进结果，引入了两个鉴别器。</p>
<h2><span id="3d人脸数据集构建方法">3D人脸数据集构建方法</span></h2><p>1）给定一张人脸图像，通过预训练好的人脸分割网络检测皮肤区域</p>
<p>2）计算输入面部皮肤的平均颜色，并将平均皮肤颜色传输到模板纹理贴图（由游戏开发人员提供，是标准3D模型模板对应的标准UV模板） </p>
<p>3）根据变形的game mesh，将输入人脸图像展开到UV空间</p>
<p>4）使用Poisson blending（图像融合操作）将展开的贴图与UV模板混合，移除头发和眼镜等非皮肤区域，并尽可能使用对称性修补遮挡区域</p>
<h2><span id="人脸形状重建-face-shape-reconstruction">人脸形状重建 （Face Shape Reconstruction）</span></h2><p>第一步从输入图像预测3DMM形状和姿势系数。采用了<a href="https://openaccess.thecvf.com/content_CVPRW_2019/papers/AMFG/Deng_Accurate_3D_Face_Reconstruction_With_Weakly-Supervised_Learning_From_Single_Image_CVPRW_2019_paper.pdf">Accurate 3D Face Reconstruction With Weakly-Supervised Learning: From Single Image to Image Set (thecvf.com)</a>的方法，其他3DMM的方法同样适用。</p>
<h2><span id="形状转换shape-transfer">形状转换（Shape Transfer）</span></h2><p>形状传递模块的目的是将重建的3DMM网格传递到游戏网格。我们设计了基于Radial Basis Function（RBF）插值的形状传递模块。</p>
<h2><span id="损失函数">损失函数</span></h2><p>我们设计了损失函数来最小化渲染人脸图像和输入人脸照片之间的距离，以及精细纹理贴图和地面真实纹理贴图之间的距离。在渲染循环中，我们设计了四种类型的损失函数，即像素损失、感知损失、皮肤正则化损失和对抗性损失，以从全局外观和局部细节来衡量面部相似性。 </p>
<p><strong>像素损失（Pixel Loss）</strong></p>
<p>渲染后的图像R和输入图像I，做pixel loss：</p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629153338519.png" alt="image-20220629153338519"></p>
<p>GT的UV贴图G和细化的纹理贴图F，做pixel loss：</p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629154446786.png" alt="image-20220629154446786"></p>
<p><strong>感知损失（Perceptual Loss）</strong></p>
<p>在感知层面减小重建图像的差异，做法遵循[Structure Guided Img Inpaint using Edge Prediction - 知乎 (zhihu.com)](<a href="https://zhuanlan.zhihu.com/p/147654092#:~:text=%E3%80%8AEdgeConnect%3A">https://zhuanlan.zhihu.com/p/147654092#:~:text=《EdgeConnect%3A</a> Structure Guided Image Inpainting using Edge Prediction》,结构信息 中的 边缘信息 来实现图像的修复（类似Free-form的素描信息） 适用于： rectangular masks、irregular masks。)</p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629160619803.png" alt="image-20220629160619803"></p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629160626723.png" alt="image-20220629160626723"></p>
<p><strong>皮肤正则化损失 （Skin Regularization Loss）</strong></p>
<p>为了在整个面部产生恒定的肤色并去除高光和阴影，我们进行了两次损失来调整面部皮肤，即“对称损失”和“标准偏差损失”。与之前将皮肤正则化直接应用于顶点颜色的工作不同，我们对高斯模糊纹理贴图施加惩罚。这是基于一个事实，即一些个性化的细节（例如痣）并不总是对称的，并且与肤色无关。我们将对称损耗定义如下： </p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629160919834.png" alt="image-20220629160919834"></p>
<p>我们将表皮标准偏差损失定义如下： </p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629161001203.png" alt="image-20220629161001203"></p>
<p><strong>对抗损失（Adversarial Loss）</strong></p>
<p>为了进一步提高重建的逼真度，我们还在训练期间使用对抗性损失。我们引入了两个鉴别器，一个用于渲染人脸，另一个用于生成的UV纹理贴图。我们训练鉴别器来判断生成的输出是真是假，同时，我们训练网络的其他部分来愚弄鉴别器。对抗训练的目标功能定义如下： </p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629161825452.png" alt="image-20220629161825452"></p>
<p><strong>总损失定义</strong></p>
<p>**<img src="/2022/06/29/review_9_MeInGame/image-20220629161847549.png" alt="image-20220629161847549">    **        </p>
<p><img src="/2022/06/29/review_9_MeInGame/image-20220629161920596.png" alt="image-20220629161920596"></p>
]]></content>
      <categories>
        <category>paper review</category>
      </categories>
      <tags>
        <tag>3DMM</tag>
      </tags>
  </entry>
  <entry>
    <title>RTTO WEEK1</title>
    <url>/2022/09/19/rtto_1/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#week-1"><strong>WEEK 1</strong></a><ul>
<li><a href="#209%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84m">209.长度最小的子数组（m）</a></li>
<li><a href="#904%E6%B0%B4%E6%9E%9C%E6%88%90%E7%AF%AEm">904.水果成篮（m）</a></li>
<li><a href="#76%E6%9C%80%E5%B0%8F%E8%A6%86%E7%9B%96%E5%AD%90%E4%B8%B2h">76.最小覆盖子串（h）</a></li>
<li><a href="#59%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5m">59.螺旋矩阵（m）</a></li>
<li><a href="#203%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0e">203.移除链表元素（e）</a></li>
<li><a href="#707%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8m">707.设计链表（m）</a></li>
<li><a href="#206%E5%8F%8D%E8%BD%AC%E9%93%BE%E8%A1%A8e">206.反转链表（e）</a></li>
<li><a href="#24%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9m">24.两两交换链表中的节点（m）</a></li>
<li><a href="#19%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACn%E5%90%84%E7%BB%93%E7%82%B9m">19.删除链表的倒数第N各结点（m）</a></li>
<li><a href="#%E9%9D%A2%E8%AF%95%E9%A2%98-0207-%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4e">面试题 02.07. 链表相交（e）</a></li>
<li><a href="#142%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8iim">142.环形链表Ⅱ（m）</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="week-1"><strong>WEEK 1</strong></span></h1><h2><span id="209长度最小的子数组m">209.长度最小的子数组（m）</span></h2><p>用滑动窗口，动态调整窗口的起始位置，不断比较子序列是否符合条件（sum&gt;&#x3D;s）,取当前子序列的长度，取相对较小的。</p>
<h2><span id="904水果成篮m">904.水果成篮（m）</span></h2><p>本题的目标是：得到一个最大子串，其中最多含有两种元素；</p>
<p>用一个hashmap表示fruits[i]类型的水果对应摘了几个；</p>
<p>用滑动窗口先遍历右边界，记录更新过程中的type值的变化；</p>
<p>当hashmap中相应类型水果数量为0时，则type++；</p>
<p>若type&gt;2，则更新左边界，把hashmap中fruits[left]水果的数量–，若该水果在hashmap中的数量为0，则type–；</p>
<p>判断每次窗口的长度取历次满足条件的窗口的最大值，即为最终结果；</p>
<h2><span id="76最小覆盖子串h">76.最小覆盖子串（h）</span></h2><p>用滑动窗口，两个hashmap比较各类字符串出现的频率？不会做</p>
<h2><span id="59螺旋矩阵m">59.螺旋矩阵（m）</span></h2><p>先确定遍历的圈数——n&#x2F;2；</p>
<p>上右下左分别进行左闭右开的遍历，进行四个for循环，改变i和j；</p>
<p>如果n是奇数最里面是一个数而不是一个圈，需要单独赋值count；</p>
<h2><span id="203移除链表元素e">203.移除链表元素（e）</span></h2><p>简单链表数据结构；</p>
<p>头节点被删除的情况：直接tmp保存原head，head &#x3D; head -&gt; next，然后删除tmp；</p>
<p>子节点被删除的情况：开辟一个cur节点，遍历链表元素，若cur -&gt;next 为空则停止遍历（尾节点），删除操作同上；</p>
<h2><span id="707设计链表m">707.设计链表（m）</span></h2><p>简单链表数据结构；</p>
<p>需要注意的点是选择index位置的元素的while终止条件；</p>
<p>判断_size异常输入的条件；</p>
<h2><span id="206反转链表e">206.反转链表（e）</span></h2><p>快慢指针；</p>
<p>一个在前一个在后，使用一个tmp来记录cur节点的后一个节点，以便循环推进，每次使得快指针指向的节点重新指向慢指针指向的节点；</p>
<h2><span id="24两两交换链表中的节点m">24.两两交换链表中的节点（m）</span></h2><p>画图！</p>
<p>三个步骤，要注意先暂存两个值，以及每一步骤都会改变当前链表结构，需要画图一步步看当前链表状态；</p>
<h2><span id="19删除链表的倒数第n各结点m">19.删除链表的倒数第N各结点（m）</span></h2><p>双指针；</p>
<p>让fast移动n步；</p>
<p>然后让fast和slow同时移动，直到fast指向链表末尾；</p>
<p>删掉slow所指向的节点；</p>
<h2><span id="面试题-0207-链表相交e">面试题 02.07. 链表相交（e）</span></h2><p>分别求两链表的长度，计算长度差，先把长链表遍历一段长度差，控制两个链表一样长，然后同时开始遍历两个链表，若遍历到了相同节点则找到了交点。</p>
<h2><span id="142环形链表iim">142.环形链表Ⅱ（m）</span></h2><p>分两步：判断是否有环；若有环判断环的出口；</p>
<p>是否有环：快慢指针，快指针一次移动两个，慢指针一次移动一个，若有环快慢指针会在不空的节点上相遇；</p>
<p>环的出口：从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是环形入口的节点（这步有点绕）</p>
]]></content>
      <categories>
        <category>RTTO</category>
      </categories>
      <tags>
        <tag>RTTO</tag>
      </tags>
  </entry>
  <entry>
    <title>RTTO WEEK2</title>
    <url>/2022/09/30/rtto_2/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#week-2"><strong>WEEK 2</strong></a><ul>
<li><a href="#242%E6%9C%89%E6%95%88%E7%9A%84%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8De">242.有效的字母异位词（e）</a></li>
<li><a href="#383%E8%B5%8E%E9%87%91%E4%BF%A1e">383.赎金信（e）</a></li>
<li><a href="#49%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D%E5%88%86%E7%BB%84m">49.字母异位词分组（m）</a></li>
<li><a href="#438%E6%89%BE%E5%88%B0%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E6%89%80%E6%9C%89%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8Dm">438.找到字符串中所有字母异位词（m）</a></li>
<li><a href="#349%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86e">349.两个数组的交集（e）</a></li>
<li><a href="#350%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86iie">350.两个数组的交集Ⅱ（e）</a></li>
<li><a href="#202%E5%BF%AB%E4%B9%90%E6%95%B0e">202.快乐数（e）</a></li>
<li><a href="#1%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8Ce">1.两数之和（e）</a></li>
<li><a href="#454%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0iim">454.四数相加Ⅱ（m）</a></li>
<li><a href="#15%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8Cm">15.三数之和（m）</a></li>
<li><a href="#18%E5%9B%9B%E6%95%B0%E4%B9%8B%E5%92%8Cm">18.四数之和（m）</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="week-2"><strong>WEEK 2</strong></span></h1><h2><span id="242有效的字母异位词e">242.有效的字母异位词（e）</span></h2><p>开辟一个record数组size为26；</p>
<p>首先遍历s，把字母在相应位置进行累加计数；</p>
<p>其次遍历t，把字母在相应位置进行累减计数；</p>
<p>最后遍历record数组，若有元素不为0，则返回false；否则返回true；</p>
<h2><span id="383赎金信e">383.赎金信（e）</span></h2><p>同上，最后判断record数组中是否有-1；</p>
<h2><span id="49字母异位词分组m">49.字母异位词分组（m）</span></h2><p>该题目标为，给定一个字符串的list，需要把由相同字母构成的字符串自行分组。</p>
<p>首先遍历整个字符串列表，再将每个字符串自行排序；</p>
<p>将经过排序后的字符串放入一个哈希表，key为排序后的字符串，value为排序前的原字符串；</p>
<p>这样拥有相同字符的字符串会共享同一个key，只需取出相同key的vector；</p>
<p><code>vector&lt;vector&lt;string&gt;&gt;</code>二维string数组</p>
<p><code>unordered_map&lt;string,vector&lt;string&gt;&gt; map</code>一个无序hashmap，key是string，用于存放正序的素材字符串；value是string list，用于存放key字母构成的字符串</p>
<h2><span id="438找到字符串中所有字母异位词m">438.找到字符串中所有字母异位词（m）</span></h2><p>构造sCount和pCount两个哈希表（size&#x3D;26）用于存储每个字母分别在s和t中出现的次数；</p>
<p>保证pLen长度的窗口进行滑动，判断sCount和pCount是否相等；</p>
<p>两个string先遍历pLen的长度，更新sCount和pCount，若此时sCount &#x3D;&#x3D; pCount，则push_back(0)；</p>
<p>再从pLen+1个元素开始遍历s，减少滑动窗口第一个元素的出现次数，增加滑动窗口最后一个元素（新遍历的元素）的出现次数，若遍历过程中sCount &#x3D;&#x3D; pCount，则push_back(i+1)；</p>
<h2><span id="349两个数组的交集e">349.两个数组的交集（e）</span></h2><p>unordered_set 底层哈希表实现；</p>
<p><code>unordered_set&lt;int&gt; nums_set(nums1.begin(),nums1.end());</code>复制nums1</p>
<p>unordered_map常用操作详解：<a href="https://blog.csdn.net/weixin_45847364/article/details/121654719">(70条消息) unordered_set中end()与find()的使用_bulangman277的博客-CSDN博客</a></p>
<p>需要注意的是，使用了一个result_set用于最后结果的去重，最后再从set中取元素到vector中返回；</p>
<h2><span id="350两个数组的交集iie">350.两个数组的交集Ⅱ（e）</span></h2><p>数据范围合理的情况下可使用hash；</p>
<p>先构建两个hashmap来存放每种元素的出现次数；</p>
<p>最后检索两个构建好的hashmap，取同一元素出现次数的最小值m，添加m次该元素到最后的结果上；</p>
<h2><span id="202快乐数e">202.快乐数（e）</span></h2><p>由于该过程中求和的过程会重复出现，可单独封装一个getSum()方法；</p>
<p>使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止；</p>
<p>设置一个sum_set来记录出现过的sum值；</p>
<p>每次getSum进行判断，如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false；</p>
<h2><span id="1两数之和e">1.两数之和（e）</span></h2><p>使用unordered_map数据结构，key为nums[i]，value为i；</p>
<p>遍历一遍数组，寻找target-num[i]是否在map中；若有返回该map的索引和当前i，若没有，则在map中更新对应的key value；</p>
<h2><span id="454四数相加iim">454.四数相加Ⅱ（m）</span></h2><p>首先定义 一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数；</p>
<p>遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中；</p>
<p>定义int变量count，用来统计 a+b+c+d &#x3D; 0 出现的次数；</p>
<p>在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来；</p>
<p>最后返回统计值 count 就可以了；</p>
<h2><span id="15三数之和m">15.三数之和（m）</span></h2><p>本题如果使用哈希会有许多去重的操作，不好写。</p>
<p>使用双指针法：</p>
<p>先将数组进行排序；</p>
<p>从头遍历一个数组选择第一个数i；left指针指向i后一位的数，right指针指向数组最后一位的数；</p>
<p>若i+left+right&gt;0，则需要将三数之和缩小，此时需要将right向左移动一位；</p>
<p>若i+left+right&lt;0，则需要将三数之和放大，此时需要将left向右移动一位；</p>
<p>直到三数之和等于0，然后对所有的组合进行去重；</p>
<p>最关键的是最后的去重！</p>
<p>i，left，right三种重复的情况</p>
<p>i重复的话判断相邻两位是否相等，若等于直接continue循环，进行i++；</p>
<p>left重复的话，比较left和left+1，直接left++；</p>
<p>right重复的话，比较right和right-1，直接right–；</p>
<h2><span id="18四数之和m">18.四数之和（m）</span></h2><p>核心思想和三数之和一样，都是双指针遍历；难的是去重和剪枝；</p>
]]></content>
      <categories>
        <category>RTTO</category>
      </categories>
      <tags>
        <tag>RTTO</tag>
      </tags>
  </entry>
  <entry>
    <title>RTTO WEEK3</title>
    <url>/2022/09/30/rtto_3/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#week-3"><strong>WEEK 3</strong></a><ul>
<li><a href="#344%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2e">344.反转字符串（e）</a></li>
<li><a href="#541%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2iie">541.反转字符串Ⅱ（e）</a></li>
<li><a href="#%E5%89%91%E6%8C%87offer-05%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BCe">剑指Offer 05.替换空格（e）</a></li>
<li><a href="#151%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E7%9A%84%E5%8D%95%E8%AF%8Dm">151.反转字符串中的单词（m）</a></li>
<li><a href="#%E5%89%91%E6%8C%87offer-58-ii%E5%B7%A6%E6%97%8B%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2e">剑指Offer 58 - Ⅱ.左旋转字符串（e）</a></li>
<li><a href="#28%E6%89%BE%E5%87%BA%E5%AD%97%E7%AC%A6%E4%B8%B2%E4%B8%AD%E7%AC%AC%E4%B8%80%E4%B8%AA%E5%8C%B9%E9%85%8D%E9%A1%B9%E7%9A%84%E4%B8%8B%E6%A0%87m">28.找出字符串中第一个匹配项的下标（m）</a></li>
<li><a href="#459%E9%87%8D%E5%A4%8D%E7%9A%84%E5%AD%90%E5%AD%97%E7%AC%A6%E4%B8%B2e">459.重复的子字符串（e）</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="week-3"><strong>WEEK 3</strong></span></h1><h2><span id="344反转字符串e">344.反转字符串（e）</span></h2><p> 前一半后一半做个swap，没啥好说的。</p>
<h2><span id="541反转字符串iie">541.反转字符串Ⅱ（e）</span></h2><p>每次遍历2k的距离，如果有k个字符（size能容纳当前遍历的k个字符），则reverse前k个，否则，反转全部字符。</p>
<h2><span id="剑指offer-05替换空格e">剑指Offer 05.替换空格（e）</span></h2><p>简单遍历改字符需要进行字符串空间上的扩容；</p>
<p>1.首先遍历一遍原字符串计算出所含空格的个数；</p>
<p>2.resize原字符串，+2*count；</p>
<p>3.使用双指针法，j指向原字符串最后一位，i指向扩充后字符串最后一位，同时向前遍历新字符串；若碰到非空位置，则更新非空字符在新字符串中的位置；若碰到空位置，此时的i即对应新字符串中0的位置，前一位为2，前前位为%；</p>
<h2><span id="151反转字符串中的单词m">151.反转字符串中的单词（m）</span></h2><p>两个关键操作：字符串逆置reverse；去除多余空格，保证两个单词之间仅存在一个空格；</p>
<p>1.将原字符串去除多余空格；</p>
<p>2.将去重后的原字符串整个逆置；</p>
<p>3.遍历逆置后的字符串，碰到空格则将空格前的字符逆置；</p>
<h2><span id="剑指offer-58-ii左旋转字符串e">剑指Offer 58 - Ⅱ.左旋转字符串（e）</span></h2><p>默认不开辟额外空间；</p>
<p>reverse前n个；</p>
<p>reverse剩下的；</p>
<p>reverse全部的；</p>
<h2><span id="28找出字符串中第一个匹配项的下标m">28.找出字符串中第一个匹配项的下标（m）</span></h2><p>KMP算法</p>
<p><a href="https://programmercarl.com/0028.%E5%AE%9E%E7%8E%B0strStr.html">代码随想录 (programmercarl.com)</a></p>
<h2><span id="459重复的子字符串e">459.重复的子字符串（e）</span></h2><p>解法一：移动匹配</p>
<p>任何一个重复子字符串构成的字符串，其前半部分和后半部分都是相等的；</p>
<p>那么s+s中就一定存在一个新s；</p>
<p>掐头去尾（erase去首尾字母），这样才能找到拼接而成的新s，而不是原本头尾的老s；</p>
<p>若存在新s，则返回true，否则false；</p>
<p>解法二：KMP法</p>
<p>核心：最长相等前后缀不包含的子串就是最小重复子串</p>
]]></content>
      <categories>
        <category>RTTO</category>
      </categories>
      <tags>
        <tag>RTTO</tag>
      </tags>
  </entry>
  <entry>
    <title>RTTO WEEK4</title>
    <url>/2022/10/19/rtto_4/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#week-4"><strong>WEEK 4</strong></a><ul>
<li><a href="#27%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0e">27.移除元素（e）</a></li>
<li><a href="#344%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2e">344.反转字符串（e）</a></li>
<li><a href="#236%E6%BB%91%E5%8A%A8%E7%AA%97%E5%8F%A3%E6%9C%80%E5%A4%A7%E5%80%BCh">236.滑动窗口最大值（h）</a></li>
<li><a href="#347%E5%89%8Dk%E4%B8%AA%E9%AB%98%E9%A2%91%E5%85%83%E7%B4%A0m">347.前k个高频元素（m）</a></li>
<li><a href="#71%E7%AE%80%E5%8C%96%E8%B7%AF%E5%BE%84m">71.简化路径（m）</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="week-4"><strong>WEEK 4</strong></span></h1><h2><span id="27移除元素e">27.移除元素（e）</span></h2><p>slow用于赋值符合条件的fast位置数据，fast碰到不与val相等的则赋值，碰到与val相等的则++</p>
<h2><span id="344反转字符串e">344.反转字符串（e）</span></h2><p>上周做过了</p>
<h2><span id="236滑动窗口最大值h">236.滑动窗口最大值（h）</span></h2><p>需要重写单调队列（由于是求max，入队元素必须遵从单调递减）</p>
<p>三个功能 由STL中deque双端队列容器构造</p>
<p>front()    查询当前单调队列中最大值，由于构造的是单调递减，所以最大值为队首元素 直接front</p>
<p>pop()    查询当前单调队列中需要弹出的值是否是队首的值，若是则pop_front</p>
<p>push()    将不满足单调递减要求的数 pop_back出；若满足单调递减要求，循环push_back直至不满足要求————即要保持单调队列中元素始终单调</p>
<p>使用单调队列时</p>
<p>首先将前k个元素放进队列，res中记录前k个最大值；</p>
<p>后遍历k个后的元素，单调队列pop出首部元素，push入新元素，后进行front计算最大值push_back入res vector直至循环结束；</p>
<h2><span id="347前k个高频元素m">347.前k个高频元素（m）</span></h2><p>涉及到STL库优先队列</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">priority_queue&lt;Type, Container, Functional&gt;</span><br></pre></td></tr></table></figure>

<p>Type 是数据类型，Container 是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 是比较的方式。</p>
<p>当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，<strong>默认是大顶堆</strong>。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">//升序队列，小顶堆</span><br><span class="line">priority_queue &lt;int,vector&lt;int&gt;,greater&lt;int&gt; &gt; q;</span><br><span class="line">//降序队列，大顶堆</span><br><span class="line">priority_queue &lt;int,vector&lt;int&gt;,less&lt;int&gt; &gt;q;</span><br><span class="line"></span><br><span class="line">//greater和less是std实现的两个仿函数（就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了）</span><br></pre></td></tr></table></figure>

<h2><span id="71简化路径m">71.简化路径（m）</span></h2><p>使用栈</p>
<p><img src="/2022/10/19/rtto_4/image-20230222104900412.png" alt="image-20230222104900412"></p>
]]></content>
      <categories>
        <category>RTTO</category>
      </categories>
      <tags>
        <tag>RTTO</tag>
      </tags>
  </entry>
  <entry>
    <title>RTTO WEEK5</title>
    <url>/2023/02/22/rtto_5/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#week-5"><strong>WEEK 5</strong></a><ul>
<li><a href="#144%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%89%8D%E5%BA%8F%E9%81%8D%E5%8E%86e">144.二叉树的前序遍历（e）</a></li>
<li><a href="#94%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E4%B8%AD%E5%BA%8F%E9%81%8D%E5%8E%86e">94.二叉树的中序遍历（e）</a></li>
<li><a href="#145%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86e">145.二叉树的后序遍历（e）</a></li>
<li><a href="#%E9%9D%9E%E9%80%92%E5%BD%92%E9%81%8D%E5%8E%86%E7%9A%84%E7%BB%9F%E4%B8%80%E5%86%99%E6%B3%95">非递归遍历的统一写法</a></li>
<li><a href="#102%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86m">102.二叉树的层序遍历（m）</a></li>
<li><a href="#226%E5%8F%8D%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91e">226.反转二叉树（e）</a></li>
<li><a href="#101%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91e">101.对称二叉树（e）</a></li>
<li><a href="#559n%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6e">559.N叉树的最大深度（e）</a></li>
<li><a href="#111%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E6%B7%B1%E5%BA%A6e">111.二叉树的最小深度（e）</a></li>
<li><a href="#222%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%8A%82%E7%82%B9%E4%B8%AA%E6%95%B0m">222.完全二叉树的节点个数（m）</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="week-5"><strong>WEEK 5</strong></span></h1><h2><span id="144二叉树的前序遍历e">144.二叉树的前序遍历（e）</span></h2><p>递归法：中左右</p>
<p>非递归法：</p>
<p>1、使用栈结构</p>
<p>先pop根节点，push右节点，push左节点</p>
<h2><span id="94二叉树的中序遍历e">94.二叉树的中序遍历（e）</span></h2><p>递归法：左中右</p>
<p>非递归法：</p>
<p>1、使用栈结构和指针</p>
<p>指针动态记录需要最先出栈的左节点位置，先找到最下层的左节点，并将途径的节点入栈，找到该左节点后存入res，并pop，此时栈中的top元素为该左节点的根节点，pop根节点后去寻找是否右节点直至栈空。</p>
<h2><span id="145二叉树的后序遍历e">145.二叉树的后序遍历（e）</span></h2><p>递归法：左右中</p>
<p>非递归法：</p>
<p>1、类似前序遍历</p>
<p>先pop根节点，push<strong>左</strong>节点，push<strong>右</strong>节点，最后<strong>reverse结果</strong></p>
<h2><span id="非递归遍历的统一写法">非递归遍历的统一写法</span></h2><p>中序为例</p>
<p><img src="/rtto_5/image-20230222211656892.png" alt="image-20230222211656892"></p>
<p>如何理解？</p>
<p>目的是使在res数组中进行push_back最终值的时候，必须碰到栈中的NULL，才加入到结果集；</p>
<p>无论什么遍历顺序都是以根节点访问状态为关键，<strong>那些访问到但还没处理的根节点就加入空节点作为标记</strong>，代表着下次栈中top遇到标记时可以加入到结果集。</p>
<p>前序 后序只需改变push 中节点和NULL节点的位置就行。</p>
<h2><span id="102二叉树的层序遍历m">102.二叉树的层序遍历（m）</span></h2><p>递归法：</p>
<p><img src="/rtto_5/image-20230222215418586.png" alt="image-20230222215418586"></p>
<p><img src="/rtto_5/image-20230222215501764.png" alt="image-20230222215501764"></p>
<p>第二行是res容器的扩容，注意输出的数据形式！</p>
<p>非递归法：</p>
<p>用队列实现</p>
<p>中左右（若有）入队 ，出队入结果集。</p>
<h2><span id="226反转二叉树e">226.反转二叉树（e）</span></h2><p>递归法：</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">swap(root-&gt;left, root-&gt;right);</span><br></pre></td></tr></table></figure>

<p>非递归法：使用栈结构</p>
<p>在非递归遍历的基础上修改；存结果数组改为交换左右子树。</p>
<h2><span id="101对称二叉树e">101.对称二叉树（e）</span></h2><p>递归法：</p>
<p>1.确定递归函数的参数和返回值。</p>
<p>需要比较两个子树是否对称，故参数为左子树和右子树的节点；参数为bool。</p>
<p>2.确定终止条件。</p>
<p>首先排除空指针的情况：</p>
<p>左右空 true</p>
<p>左右一空 false</p>
<p>左右值不等 false</p>
<p>3.确定单层递归的逻辑。</p>
<p><img src="/rtto_5/image-20230228110738488.png" alt="image-20230228110738488"></p>
<p>如图对称二叉树为最后一层3-3 4-4相等</p>
<p><img src="/rtto_5/image-20230228110838781.png" alt="image-20230228110838781"></p>
<p>非递归方法：</p>
<p>使用队列（此时的规则非前中后遍历了）</p>
<p>需要按题目规则两两入队比较是否相等；false的判断条件和递归法的一样，左右有空或者左右值不相等；保证每次成对push的节点是需要进行比较的节点。（用栈也行）</p>
<h2><span id="559n叉树的最大深度e">559.N叉树的最大深度（e）</span></h2><p>和上题一样，只不过Node数据结构变了，加个遍历儿子节点就行。</p>
<h2><span id="111二叉树的最小深度e">111.二叉树的最小深度（e）</span></h2><p>递归法：</p>
<p>1.递归参数和返回值：参数为node 返回值为int</p>
<p>2.终止条件：node为空终止</p>
<p>3.单层逻辑：左存在 右不存在 说明需要更新左边的深度 +1；右存在 左不存在 说明需要更新右边的深度 +1</p>
<p>非递归法：</p>
<p>使用层序遍历，若左右都无节点就说明到了最低点，若有左右其中一个节点则不是最低点；</p>
<h2><span id="222完全二叉树的节点个数m">222.完全二叉树的节点个数（m）</span></h2><p>递归法：</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span> &#123;</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line">  <span class="function"><span class="type">int</span> <span class="title">getNodesNum</span><span class="params">(TreeNode* node)</span></span>&#123;</span><br><span class="line">	<span class="keyword">if</span>(node == <span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">	<span class="type">int</span> leftNum = <span class="built_in">getNodesNum</span>(node-&gt;left);</span><br><span class="line">	<span class="type">int</span> rightNum = <span class="built_in">getNodesNum</span>(node-&gt;right);</span><br><span class="line">	<span class="type">int</span> treeNum = leftNum + rightNum + <span class="number">1</span>;</span><br><span class="line">	<span class="keyword">return</span> treeNum;</span><br><span class="line">  &#125;</span><br><span class="line"></span><br><span class="line">  <span class="function"><span class="type">int</span> <span class="title">countNodes</span><span class="params">(TreeNode* root)</span> </span>&#123;</span><br><span class="line">      <span class="keyword">return</span> <span class="built_in">getNodesNum</span>(root);</span><br><span class="line">  &#125;</span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure>

<p>非递归法：</p>
<p>层序遍历</p>
]]></content>
      <categories>
        <category>RTTO</category>
      </categories>
      <tags>
        <tag>RTTO</tag>
      </tags>
  </entry>
  <entry>
    <title>RTTO HOT 100</title>
    <url>/2023/03/16/rtto_hot100/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#hot-100">HOT 100</a><ul>
<li><a href="#1%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8Ce">1.两数之和（e）</a></li>
<li><a href="#2%E4%B8%A4%E6%95%B0%E7%9B%B8%E5%8A%A0m">2.两数相加（m）</a></li>
<li><a href="#3%E6%97%A0%E9%87%8D%E5%A4%8D%E5%AD%97%E7%AC%A6%E7%9A%84%E6%9C%80%E9%95%BF%E5%AD%90%E4%B8%B2m">3.无重复字符的最长子串（m）</a></li>
<li><a href="#4%E5%AF%BB%E6%89%BE%E4%B8%A4%E4%B8%AA%E6%AD%A3%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E4%B8%AD%E4%BD%8D%E6%95%B0h">4.寻找两个正序数组的中位数（h）</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="hot-100">HOT 100</span></h1><h2><span id="1两数之和e">1.两数之和（e）</span></h2><p>使用map&lt;int,int&gt;构造哈希表；使用map的count方法寻找target-nums[i]是否存在，存在的话就存入res相关index，否则存入nums[i]的索引位置。</p>
<h2><span id="2两数相加m">2.两数相加（m）</span></h2><p>遍历l1，l2计算sum和进位，尾插法更新tail，注意此时的tail是逆序的，需要一开始使用head指向初始节点作为结果返回。</p>
<h2><span id="3无重复字符的最长子串m">3.无重复字符的最长子串（m）</span></h2><p>滑动窗口法，使用start，end，使用end进行遍历整个字符串，记录每次end的所指向的字符记为tmp，子循环从start遍历到end，若发现有与tmp相等的符号，则发生子串重复，更新start位置到当前index下一位，计算当前子串length，并退出子循环。动态更新res和length的最大值作为当前结果。</p>
<h2><span id="4寻找两个正序数组的中位数h">4.寻找两个正序数组的中位数（h）</span></h2><p>二分法</p>
<figure class="highlight cpp"><table><tr><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Solution</span> &#123;</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line">    <span class="function"><span class="type">double</span> <span class="title">findMedianSortedArrays</span><span class="params">(vector&lt;<span class="type">int</span>&gt;&amp; nums1, vector&lt;<span class="type">int</span>&gt;&amp; nums2)</span> </span>&#123;</span><br><span class="line">        <span class="type">int</span> n = nums1.<span class="built_in">size</span>();</span><br><span class="line">        <span class="type">int</span> m = nums2.<span class="built_in">size</span>();</span><br><span class="line">        <span class="type">int</span> left = (n + m + <span class="number">1</span>) / <span class="number">2</span>;</span><br><span class="line">        <span class="type">int</span> right = (n + m + <span class="number">2</span>) / <span class="number">2</span>;</span><br><span class="line">        <span class="keyword">return</span> (<span class="built_in">getKth</span>(nums1, <span class="number">0</span>, n - <span class="number">1</span>, nums2, <span class="number">0</span>, m - <span class="number">1</span>, left) + <span class="built_in">getKth</span>(nums1, <span class="number">0</span>, n - <span class="number">1</span>, nums2, <span class="number">0</span>, m - <span class="number">1</span>, right)) * <span class="number">0.5</span>; </span><br><span class="line">    &#125;</span><br><span class="line"></span><br><span class="line">    <span class="function"><span class="type">int</span> <span class="title">getKth</span><span class="params">(vector&lt;<span class="type">int</span>&gt;&amp; nums1, <span class="type">int</span> start1, <span class="type">int</span> end1, vector&lt;<span class="type">int</span>&gt;&amp; nums2, <span class="type">int</span> start2, <span class="type">int</span> end2, <span class="type">int</span> k)</span></span>&#123;</span><br><span class="line">        <span class="type">int</span> len1 = end1 - start1 + <span class="number">1</span>;</span><br><span class="line">        <span class="type">int</span> len2 = end2 - start2 + <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line">        <span class="keyword">if</span>(len1 &gt; len2) <span class="keyword">return</span>  <span class="built_in">getKth</span>(nums2, start2, end2, nums1, start1, end1, k);</span><br><span class="line">        <span class="keyword">if</span> (len1 == <span class="number">0</span>)  <span class="keyword">return</span> nums2[start2 + k - <span class="number">1</span>];</span><br><span class="line">        </span><br><span class="line">        <span class="keyword">if</span>(k == <span class="number">1</span>) <span class="keyword">return</span> <span class="built_in">min</span>(nums1[start1], nums2[start2]);</span><br><span class="line"></span><br><span class="line">        <span class="type">int</span> i = start1 + <span class="built_in">min</span>(len1, k / <span class="number">2</span>) - <span class="number">1</span>;</span><br><span class="line">        <span class="type">int</span> j = start2 + <span class="built_in">min</span>(len2, k / <span class="number">2</span>) - <span class="number">1</span>;</span><br><span class="line"></span><br><span class="line">        <span class="keyword">if</span>(nums1[i] &gt; nums2[j])&#123;</span><br><span class="line">            <span class="keyword">return</span> <span class="built_in">getKth</span>(nums1, start1, end1, nums2, j + <span class="number">1</span>, end2, k - (j - start2 + <span class="number">1</span>));</span><br><span class="line">        &#125;</span><br><span class="line">        <span class="keyword">else</span>&#123;</span><br><span class="line">            <span class="keyword">return</span> <span class="built_in">getKth</span>(nums1, i + <span class="number">1</span>, end1, nums2, start2, end2, k - (i - start1 + <span class="number">1</span>));</span><br><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure>
]]></content>
      <categories>
        <category>RTTO</category>
      </categories>
      <tags>
        <tag>RTTO</tag>
      </tags>
  </entry>
  <entry>
    <title>Hexo建站相关</title>
    <url>/2022/03/25/tools_1_start/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#%E6%90%AD%E5%BB%BAhexo%E6%9C%8D%E5%8A%A1%E5%99%A8%E9%80%9A%E8%BF%87git%E8%87%AA%E5%8A%A8%E9%83%A8%E7%BD%B2%E5%9C%A8%E9%98%BF%E9%87%8C%E4%BA%91%E6%9C%8D%E5%8A%A1%E5%99%A8">搭建Hexo服务器，通过Git自动部署在阿里云服务器</a><ul>
<li><a href="#%E6%90%AD%E5%BB%BA%E5%8F%8A%E9%83%A8%E7%BD%B2">搭建及部署</a></li>
<li><a href="#%E5%8D%9A%E6%96%87%E5%8F%91%E5%B8%83">博文发布</a></li>
</ul>
</li>
<li><a href="#%E4%B8%BB%E9%A2%98%E5%8F%8A%E5%85%B6%E7%BE%8E%E5%8C%96">主题及其美化</a><ul>
<li><a href="#butterfly">Butterfly</a></li>
<li><a href="#next">Next</a><ul>
<li><a href="#%E7%BE%8E%E5%8C%96">美化</a></li>
<li><a href="#%E6%96%87%E7%AB%A0%E5%90%AF%E7%94%A8tags%E5%92%8Ccategories">文章启用tags和categories</a></li>
<li><a href="#%E8%AE%BE%E7%BD%AE%E9%98%85%E8%AF%BB%E5%85%A8%E6%96%87">设置阅读全文</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#%E7%9B%B8%E5%85%B3%E9%97%AE%E9%A2%98updating">相关问题（Updating…）</a><ul>
<li><a href="#%E6%97%A0%E6%B3%95%E6%AD%A3%E7%A1%AE%E6%B8%B2%E6%9F%93markdown%E6%96%87%E4%BB%B6%E9%97%AE%E9%A2%98">无法正确渲染markdown文件问题</a></li>
<li><a href="#%E6%8F%92%E5%85%A5%E5%9B%BE%E7%89%87%E9%97%AE%E9%A2%98">插入图片问题</a></li>
<li><a href="#%E7%9B%AE%E5%BD%95%E7%94%9F%E6%88%90%E9%97%AE%E9%A2%98">目录生成问题</a></li>
<li><a href="#%E6%B7%BB%E5%8A%A0%E6%9C%AC%E5%9C%B0%E6%90%9C%E7%B4%A2%E5%8A%9F%E8%83%BD">添加本地搜索功能</a></li>
</ul>
</li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="搭建hexo服务器通过git自动部署在阿里云服务器">搭建Hexo服务器，通过Git自动部署在阿里云服务器</span></h1><h2><span id="搭建及部署">搭建及部署</span></h2><p>参考博文链接：<a href="https://mp.weixin.qq.com/s/JTTUYJTvtdT6X2fvLUBFZg">Win10下Hexo博客搭建教程，及阿里云服务器部署实战 (qq.com)</a></p>
<h2><span id="博文发布">博文发布</span></h2><p>在本地机器上部署Hexo相关MyHexoBlogs文件夹下，进入MyHexoBlogs&#x2F;myblogs&#x2F;source&#x2F;_posts目录；</p>
<p>在当前页进入git bash，输入hexo clean 清除缓存，hexo g 解析静态文件，hexo d 刷新部署新的资源。</p>
<p>hexo cl &amp;&amp; hexo g &amp;&amp; hexo d</p>
<h1><span id="主题及其美化">主题及其美化</span></h1><h2><span id="butterfly">Butterfly</span></h2><p>Butterfly主题部署参考博文链接：<a href="https://www.jianshu.com/p/50a565adaf15?ivk_sa=1024320u">hexo框架|butterfly主题配置 - 简书 (jianshu.com)</a></p>
<p>Butterfly主题官方文档：<a href="https://www.butterfly1.cn/">Hexo-Butterfly主题(🦋 A Hexo Theme: Butterfly-Official website) (butterfly1.cn)</a></p>
<p>Hexo默认美化项：<a href="https://zhuanlan.zhihu.com/p/369951111">Hexo个性化设置 - 知乎 (zhihu.com)</a></p>
<h2><span id="next">Next</span></h2><h3><span id="美化">美化</span></h3><p><a href="https://blog.csdn.net/qq_34003239/article/details/100883213">(54条消息) Next主题美化_蜗牛非牛的博客-CSDN博客_next主题美化</a></p>
<h3><span id="文章启用tags和categories">文章启用tags和categories</span></h3><p><a href="https://blog.csdn.net/Lancis/article/details/118788205">(54条消息) hexo next主题简单美化_Lancis的博客-CSDN博客_next主题美化</a></p>
<h3><span id="设置阅读全文">设置阅读全文</span></h3><p><a href="https://blog.csdn.net/CHENGXUYUAN09/article/details/103408380">(54条消息) next7.6版本关于设置阅读全文_LIYUANWAISPRING的博客-CSDN博客</a></p>
<h1><span id="相关问题updating">相关问题（Updating…）</span></h1><h2><span id="无法正确渲染markdown文件问题">无法正确渲染markdown文件问题</span></h2><p>hexo对于md文件的解析规则不是标准规则，有时候在复制论文标题时会有换行符无法正确解析；</p>
<p>重新手动输入检查标题格式解决问题</p>
<h2><span id="插入图片问题">插入图片问题</span></h2><p>选择采用hexo官网的解决方式：<a href="https://hexo.io/zh-cn/docs/asset-folders">资源文件夹 | Hexo</a></p>
<h2><span id="目录生成问题">目录生成问题</span></h2><p>安装插件</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">cnpm install hexo-toc --save</span><br></pre></td></tr></table></figure>

<p>hexo的配置文件中设置格式，添加配置代码</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">toc:</span><br><span class="line">  maxdepth: 3</span><br></pre></td></tr></table></figure>

<p>在md中使用时</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">&lt;!-- toc --&gt;</span><br></pre></td></tr></table></figure>

<h2><span id="添加本地搜索功能">添加本地搜索功能</span></h2><p>与Next官方配置文件中的链接步骤不同的是，还需要修改</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">preload: true</span><br></pre></td></tr></table></figure>



]]></content>
      <categories>
        <category>Hexo</category>
      </categories>
      <tags>
        <tag>Hexo</tag>
      </tags>
  </entry>
  <entry>
    <title>Docker学习笔记</title>
    <url>/2022/09/29/tech_1_docker/</url>
    <content><![CDATA[<!-- toc -->

<ul>
<li><a href="#docker-hello-world">Docker Hello World</a><ul>
<li><a href="#%E8%BF%90%E8%A1%8C%E4%BA%A4%E4%BA%92%E5%BC%8F%E7%9A%84%E5%AE%B9%E5%99%A8">运行交互式的容器</a></li>
<li><a href="#%E5%90%AF%E5%8A%A8%E5%AE%B9%E5%99%A8%E5%90%8E%E5%8F%B0%E6%A8%A1%E5%BC%8F">启动容器（后台模式）</a></li>
</ul>
</li>
<li><a href="#docker%E5%AE%B9%E5%99%A8%E4%BD%BF%E7%94%A8">Docker容器使用</a><ul>
<li><a href="#docker%E5%AE%A2%E6%88%B7%E7%AB%AF">Docker客户端</a></li>
<li><a href="#%E5%AE%B9%E5%99%A8%E4%BD%BF%E7%94%A8">容器使用</a><ul>
<li><a href="#%E6%8D%A2%E9%BB%98%E8%AE%A4%E6%BA%90">换默认源</a></li>
<li><a href="#%E8%8E%B7%E5%8F%96%E9%95%9C%E5%83%8F">获取镜像</a></li>
<li><a href="#%E5%90%AF%E5%8A%A8%E5%AE%B9%E5%99%A8">启动容器</a></li>
<li><a href="#%E5%90%AF%E5%8A%A8%E5%B7%B2%E5%81%9C%E6%AD%A2%E8%BF%90%E8%A1%8C%E7%9A%84%E5%AE%B9%E5%99%A8">启动已停止运行的容器</a></li>
<li><a href="#%E5%90%8E%E5%8F%B0%E8%BF%90%E8%A1%8C">后台运行</a></li>
<li><a href="#%E8%BF%9B%E5%85%A5%E5%AE%B9%E5%99%A8">进入容器</a></li>
<li><a href="#%E5%AF%BC%E5%87%BA%E5%92%8C%E5%AF%BC%E5%85%A5%E5%AE%B9%E5%99%A8">导出和导入容器</a></li>
<li><a href="#%E5%88%A0%E9%99%A4%E5%AE%B9%E5%99%A8">删除容器</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#docker%E9%95%9C%E5%83%8F%E4%BD%BF%E7%94%A8">Docker镜像使用</a><ul>
<li><a href="#%E5%88%97%E5%87%BA%E9%95%9C%E5%83%8F%E5%88%97%E8%A1%A8">列出镜像列表</a></li>
<li><a href="#%E8%8E%B7%E5%8F%96%E4%B8%80%E4%B8%AA%E6%96%B0%E7%9A%84%E9%95%9C%E5%83%8F">获取一个新的镜像</a></li>
<li><a href="#%E6%9F%A5%E6%89%BE%E9%95%9C%E5%83%8F">查找镜像</a></li>
<li><a href="#%E6%8B%96%E5%8F%96%E9%95%9C%E5%83%8F">拖取镜像</a></li>
<li><a href="#%E5%88%A0%E9%99%A4%E9%95%9C%E5%83%8F">删除镜像</a></li>
<li><a href="#%E5%88%9B%E5%BB%BA%E9%95%9C%E5%83%8F">创建镜像</a><ul>
<li><a href="#%E6%9B%B4%E6%96%B0%E9%95%9C%E5%83%8F">更新镜像</a></li>
<li><a href="#%E6%9E%84%E5%BB%BA%E9%95%9C%E5%83%8F">构建镜像</a></li>
<li><a href="#%E8%AE%BE%E7%BD%AE%E9%95%9C%E5%83%8F%E6%A0%87%E7%AD%BE">设置镜像标签</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#docker%E4%BB%93%E5%BA%93%E7%AE%A1%E7%90%86%E4%BB%A5docker-hub%E4%B8%BA%E4%BE%8B">Docker仓库管理（以Docker Hub为例）</a><ul>
<li><a href="#docker-hub">Docker Hub</a><ul>
<li><a href="#%E6%B3%A8%E5%86%8C">注册</a></li>
<li><a href="#%E7%99%BB%E5%BD%95%E5%92%8C%E9%80%80%E5%87%BA">登录和退出</a></li>
<li><a href="#%E9%80%80%E5%87%BA"><strong>退出</strong></a></li>
<li><a href="#%E6%8B%89%E5%8F%96%E9%95%9C%E5%83%8F">拉取镜像</a></li>
<li><a href="#%E6%8E%A8%E9%80%81%E9%95%9C%E5%83%8F">推送镜像</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#dockerfile">Dockerfile</a></li>
</ul>
<!-- tocstop -->

<span id="more"></span>

<h1><span id="docker-hello-world">Docker Hello World</span></h1><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker run ubuntu:20.03 /bin/echo &quot;Hello world&quot;</span><br></pre></td></tr></table></figure>

<p>Docker 以 ubuntu15.10 镜像创建一个新容器，然后在容器里执行 bin&#x2F;echo “Hello world”，然后输出结果。</p>
<p>（需要sudo权限）</p>
<h2><span id="运行交互式的容器">运行交互式的容器</span></h2><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker run -i -t ubuntu:15.10 /bin/bash</span><br></pre></td></tr></table></figure>

<p>通过 docker 的两个参数 -i -t，让 docker 运行的容器实现**”对话”**的能力（进入容器的终端）</p>
<p><img src="/2022/09/29/tech_1_docker/image-20220929141727968.png" alt="image-20220929141727968"></p>
<p>如需退出容器：输入exit或者使用CTRL+D</p>
<h2><span id="启动容器后台模式">启动容器（后台模式）</span></h2><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker run -d ubuntu:20.03 /bin/sh -c &quot;while true; do echo hello world; sleep 1; done&quot;</span><br></pre></td></tr></table></figure>

<p><img src="/2022/09/29/tech_1_docker/image-20220929143428371.png" alt="image-20220929143428371"></p>
<p>会出现一个长字符串，该字符串为容器的id</p>
<p>查看当前容器</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker ps</span><br></pre></td></tr></table></figure>

<p>查看容器内的标准输出</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker logs </span><br></pre></td></tr></table></figure>

<p><img src="/2022/09/29/tech_1_docker/image-20220929144110987.png" alt="image-20220929144110987"></p>
<p>停止容器</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker stop</span><br></pre></td></tr></table></figure>

<p><img src="/2022/09/29/tech_1_docker/image-20220929144204323.png" alt="image-20220929144204323"></p>
<h1><span id="docker容器使用">Docker容器使用</span></h1><h2><span id="docker客户端">Docker客户端</span></h2><p>查看docker客户端所有命令选项</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker</span><br></pre></td></tr></table></figure>

<h2><span id="容器使用">容器使用</span></h2><h3><span id="换默认源">换默认源</span></h3><p><a href="https://huaweicloud.csdn.net/63311a8dd3efff3090b52222.html">解决docker拉取镜像慢的方法（亲测有效）_docker_阿正的梦工坊-DevPress官方社区 (csdn.net)</a></p>
<h3><span id="获取镜像">获取镜像</span></h3><p>如果我们本地没有 ubuntu 镜像，我们可以使用 docker pull 命令来载入 ubuntu 镜像</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker pull ubuntu</span><br></pre></td></tr></table></figure>

<h3><span id="启动容器">启动容器</span></h3><p>以命令行模式启动一个容器</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker run -it ubuntu /bin/bash</span><br></pre></td></tr></table></figure>

<p>参数说明：</p>
<ul>
<li><strong>-i</strong>: 交互式操作。</li>
<li><strong>-t</strong>: 终端。</li>
<li><strong>ubuntu</strong>: ubuntu 镜像。</li>
<li><strong>&#x2F;bin&#x2F;bash</strong>：放在镜像名后的是命令，这里希望有个交互式 Shell，因此用的是 &#x2F;bin&#x2F;bash。</li>
</ul>
<h3><span id="启动已停止运行的容器">启动已停止运行的容器</span></h3><p>查看所有的容器命令如下：</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker ps -a</span><br></pre></td></tr></table></figure>

<p>启动一个容器</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker start &lt;容器 ID&gt;</span><br></pre></td></tr></table></figure>

<h3><span id="后台运行">后台运行</span></h3><p>在大部分的场景下，我们希望 docker 的服务是在后台运行的，我们可以过 <strong>-d</strong> 指定容器的运行模式。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker run -itd --name ubuntu-test ubuntu /bin/bash</span><br></pre></td></tr></table></figure>

<p><strong>-d</strong>只是指定容器的运行模式，而不会默认进入容器</p>
<p><strong>–name</strong>给容器命名（此处为ubuntu-test）</p>
<p>停止的容器可以通过 docker restart 重启：</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker restart &lt;容器 ID&gt;</span><br></pre></td></tr></table></figure>

<h3><span id="进入容器">进入容器</span></h3><p>在使用 <strong>-d</strong> 参数时，容器启动后会进入后台。此时想要进入容器，可以通过以下指令进入：</p>
<ul>
<li><strong>docker attach</strong></li>
<li><strong>docker exec</strong>：推荐大家使用 docker exec 命令，因为此命令会退出容器终端，但不会导致容器的停止。</li>
</ul>
<h4><span id="attach命令">attach命令</span></h4><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker attach &lt;容器 ID&gt;</span><br></pre></td></tr></table></figure>

<h4><span id="exec命令">exec命令</span></h4><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker exec -it &lt;容器 ID&gt; /bin/bash</span><br></pre></td></tr></table></figure>

<p>区别在于attach命令如果退出容器，容器会停止；exec不会；</p>
<p><img src="/2022/09/29/tech_1_docker/image-20220929155456079.png" alt="image-20220929155456079"></p>
<h3><span id="导出和导入容器">导出和导入容器</span></h3><p><strong>导出容器</strong></p>
<p>导出本地某个容器</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker export &lt;容器 ID&gt; &gt; ubuntu.tar</span><br></pre></td></tr></table></figure>

<p><strong>导入容器快照</strong></p>
<p>使用 docker import 从容器快照文件中再导入为镜像，以下实例将快照文件 ubuntu.tar 导入到镜像 test&#x2F;ubuntu:v1:</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">cat docker/ubuntu.tar | docker import - test/ubuntu:v1</span><br></pre></td></tr></table></figure>

<p>此外，也可以通过指定 URL 或者某个目录来导入，例如：</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker import http://example.com/exampleimage.tgz example/imagerepo</span><br></pre></td></tr></table></figure>

<h3><span id="删除容器">删除容器</span></h3><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker rm -f &lt;容器 ID&gt;</span><br></pre></td></tr></table></figure>

<h1><span id="docker镜像使用">Docker镜像使用</span></h1><p>当运行容器时，使用的镜像如果在本地中不存在，docker 就会自动从 docker 镜像仓库中下载，默认是从 Docker Hub 公共镜像源下载。</p>
<h2><span id="列出镜像列表">列出镜像列表</span></h2><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker images</span><br></pre></td></tr></table></figure>

<p><img src="/2022/09/29/tech_1_docker/image-20220929162540821.png" alt="image-20220929162540821"></p>
<p>各个选项说明:</p>
<ul>
<li><strong>REPOSITORY：</strong>表示镜像的仓库源</li>
<li><strong>TAG：</strong>镜像的标签</li>
<li><strong>IMAGE ID：</strong>镜像ID</li>
<li><strong>CREATED：</strong>镜像创建时间</li>
<li><strong>SIZE：</strong>镜像大小</li>
</ul>
<p>如果你不指定一个镜像的版本标签，例如你只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像。</p>
<h2><span id="获取一个新的镜像">获取一个新的镜像</span></h2><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker pull ubuntu:18.04</span><br></pre></td></tr></table></figure>

<h2><span id="查找镜像">查找镜像</span></h2><p>可以从 Docker Hub 网站来搜索镜像，Docker Hub 网址为： **<a href="https://hub.docker.com/**%EF%BC%9B%E6%88%91%E4%BB%AC%E4%B9%9F%E5%8F%AF%E4%BB%A5%E4%BD%BF%E7%94%A8">https://hub.docker.com/**；我们也可以使用</a> docker search 命令来搜索镜像。比如我们需要一个 httpd 的镜像来作为我们的 web 服务。我们可以通过 docker search 命令搜索 httpd 来寻找适合我们的镜像。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker search httpd</span><br></pre></td></tr></table></figure>

<p><img src="/2022/09/29/tech_1_docker/image-20220929162948690.png" alt="image-20220929162948690"></p>
<h2><span id="拖取镜像">拖取镜像</span></h2><p>我们决定使用上图中的 httpd 官方版本的镜像，使用命令 docker pull 来下载镜像。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker pull httpd</span><br></pre></td></tr></table></figure>

<h2><span id="删除镜像">删除镜像</span></h2><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker rmi hello-world</span><br></pre></td></tr></table></figure>

<p>首先需要先把相关依赖的容器删除，才能进而删除镜像</p>
<h2><span id="创建镜像">创建镜像</span></h2><p>当我们从 docker 镜像仓库中下载的镜像不能满足我们的需求时，我们可以通过以下两种方式对镜像进行更改。</p>
<ul>
<li>1、从已经创建的容器中更新镜像，并且提交这个镜像</li>
<li>2、使用 Dockerfile 指令来创建一个新的镜像</li>
</ul>
<h3><span id="更新镜像">更新镜像</span></h3><p>更新镜像之前，我们需要使用镜像来创建一个容器。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker run -t -i ubuntu:15.10 /bin/bash</span><br></pre></td></tr></table></figure>

<p>在容器内进行更新</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">apt-get update</span><br></pre></td></tr></table></figure>

<p>退出容器后</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker commit -m=&quot;has update&quot; -a=&quot;runoob&quot; &lt;容器 ID&gt; runoob/ubuntu:v2</span><br></pre></td></tr></table></figure>

<p>各个参数说明：</p>
<ul>
<li><strong>-m:</strong> 提交的描述信息</li>
<li><strong>-a:</strong> 指定镜像作者</li>
<li><strong>runoob&#x2F;ubuntu:v2:</strong> 指定要创建的目标镜像名</li>
</ul>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker images</span><br></pre></td></tr></table></figure>

<p><img src="/2022/09/29/tech_1_docker/image-20220929164503769.png" alt="image-20220929164503769"></p>
<h3><span id="构建镜像">构建镜像</span></h3><p>我们使用命令 <strong>docker build</strong> ， 从零开始来创建一个新的镜像。为此，我们需要创建一个 Dockerfile 文件，其中包含一组指令来告诉 Docker 如何构建我们的镜像。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">cat Dockerfile </span><br><span class="line"></span><br><span class="line">FROM    centos:6.7</span><br><span class="line">MAINTAINER      Fisher &quot;fisher@sudops.com&quot;</span><br><span class="line"></span><br><span class="line">RUN     /bin/echo &#x27;root:123456&#x27; |chpasswd</span><br><span class="line">RUN     useradd runoob</span><br><span class="line">RUN     /bin/echo &#x27;runoob:123456&#x27; |chpasswd</span><br><span class="line">RUN     /bin/echo -e &quot;LANG=\&quot;en_US.UTF-8\&quot;&quot; &gt;/etc/default/local</span><br><span class="line">EXPOSE  22</span><br><span class="line">EXPOSE  80</span><br><span class="line">CMD     /usr/sbin/sshd -D</span><br></pre></td></tr></table></figure>

<p>每一个指令都会在镜像上创建一个新的层，每一个指令的前缀都必须是大写的。</p>
<p>第一条FROM，指定使用哪个镜像源</p>
<p>RUN 指令告诉docker 在镜像内执行命令，安装了什么。。。</p>
<p>然后，我们使用 Dockerfile 文件，通过 docker build 命令来构建一个镜像。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker build -t runoob/centos:6.7 .</span><br></pre></td></tr></table></figure>

<p>参数说明：</p>
<ul>
<li><strong>-t</strong> ：指定要创建的目标镜像名</li>
<li><strong>.</strong> ：Dockerfile 文件所在目录，可以指定Dockerfile 的绝对路径</li>
</ul>
<p>我们可以使用新的镜像来创建容器</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker run -t -i runoob/centos:6.7  /bin/bash</span><br></pre></td></tr></table></figure>

<h3><span id="设置镜像标签">设置镜像标签</span></h3><figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker tag 860c279d2fec runoob/centos:dev</span><br></pre></td></tr></table></figure>

<h1><span id="docker仓库管理以docker-hub为例">Docker仓库管理（以Docker Hub为例）</span></h1><h2><span id="docker-hub">Docker Hub</span></h2><h3><span id="注册">注册</span></h3><p>在 <a href="https://hub.docker.com/">https://hub.docker.com</a> 免费注册一个 Docker 账号。</p>
<h3><span id="登录和退出">登录和退出</span></h3><p>登录需要输入用户名和密码，登录成功后，我们就可以从 docker hub 上拉取自己账号下的全部镜像。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker login</span><br></pre></td></tr></table></figure>

<h3><span id="退出"><strong>退出</strong></span></h3><p>退出 docker hub 可以使用以下命令：</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker logout</span><br></pre></td></tr></table></figure>

<h3><span id="拉取镜像">拉取镜像</span></h3><p>通过docker search查找官方仓库的镜像，docker pull来拉取</p>
<h3><span id="推送镜像">推送镜像</span></h3><p>用户登录后，可以通过 docker push 命令将自己的镜像推送到 Docker Hub。</p>
<p>以下命令中的 username 请替换为你的 Docker 账号用户名。</p>
<figure class="highlight plaintext"><table><tr><td class="code"><pre><span class="line">docker tag ubuntu:18.04 username/ubuntu:18.04</span><br></pre></td></tr></table></figure>

<h1><span id="dockerfile">Dockerfile</span></h1><ul>
<li>FROM</li>
</ul>
<p>构建镜像基于哪个镜像</p>
<ul>
<li>MAINTAINER</li>
</ul>
<p>镜像维护者姓名或邮箱地址</p>
<ul>
<li>RUN</li>
</ul>
<p>构建镜像时运行的指令</p>
<ul>
<li>CMD</li>
</ul>
<p>运行容器时执行的shell环境</p>
<ul>
<li>VOLUME</li>
</ul>
<p>指定容器挂载点到宿主机自动生成的目录或其他容器</p>
<ul>
<li>USER</li>
</ul>
<p>为RUN、CMD、和 ENTRYPOINT 执行命令指定运行用户</p>
<ul>
<li>WORKDIR</li>
</ul>
<p>为 RUN、CMD、ENTRYPOINT、COPY 和 ADD 设置工作目录，就是切换目录</p>
<ul>
<li>HEALTHCHECH</li>
</ul>
<p>健康检查</p>
<ul>
<li>ARG</li>
</ul>
<p>构建时指定的一些参数</p>
<ul>
<li>EXPOSE</li>
</ul>
<p>声明容器的服务端口（仅仅是声明）</p>
<ul>
<li>ENV</li>
</ul>
<p>设置容器环境变量</p>
<ul>
<li>ADD</li>
</ul>
<p>拷贝文件或目录到容器中，如果是URL或压缩包便会自动下载或自动解压</p>
<ul>
<li>COPY</li>
</ul>
<p>拷贝文件或目录到容器中，跟ADD类似，但不具备自动下载或解压的功能</p>
<ul>
<li>ENTRYPOINT</li>
</ul>
<p>运行容器时执行的shell命令</p>
]]></content>
      <categories>
        <category>Docker</category>
      </categories>
      <tags>
        <tag>Docker</tag>
      </tags>
  </entry>
</search>