目标

转换函数

定义

黄色特性：fraction可以被转换为double，按照return返回

这种就是转换函数，没有函数类型

通常要加上const

注意：这里return double转换有问题，需要改成return (double)f_up / (double)f_down;

只要认为合理，可以设置任何operator

non-explicit-one-argument ctor

可以把别的东西转化为fraction

转换函数与non-explicit-one-argument ctor

编译器发现两条路可行，所以报错

explicit-one-argument ctor

加上explict只有用在这里，在构造函数前面

告诉编译器不要自动转化为fraction

转换函数的其他用途

pointer-like classes

关于智能指针

指针所做的，智能指针应该都要做到

在这里关注* 和->

share在接受普通指针

右下角->在把sp转化为px已经消耗掉了啊？

箭头符号在作用一个以后，还能再作用下去

关于迭代器

主要遍历容器，所以要写++和–

链表：

链表迭代器node必然有一个指针

对迭代器解指针拿的是数据，所以直接return数据data

function-like classes 所谓仿函数

为什么要让class像函数？

定义

函数是接受一个()符号，所以class可以通过重载()就可以作为函数

奇特模样

上面都继承了如下：

仿函数都会继承一些奇特的base classes

标准库里都会有很多class使用仿函数

namespace经验谈

可以把函数放在namespace里，这样就不用重复的取名字了

相当于分组一样

模板

class template

function template

函数模板在使用时自动推导类型

member template

当然可以，但是反之不可以

specialization 模板特化

作为一个设计者可能面对独特的类型

画两条线，在电脑上必然是实数

第一个框框是泛化

指定特别的类型，char或者int等等，编译器就会用特定的算法

浅绿色是临时对象，蓝色就是参数

模板偏特化

个数上的偏

范围上的偏

可以把范围限制在指针

模板模板参数

typename和class只有在模板这个位置共通

用在 传一个容器，容器的指定类型，就需要模板模板参数

为什么第一个错了，因为list不只有一个参数，所以不可以这么用，要引入第二个框的两个语法

关于c++标准库

都用一遍

三个主题

variadic templates(c11) 数量不定的模板参数

print(args…)一直在递归

最后变成0个的时候调用上面的void print()

#include <iostream>#include <bitset>using namespace std;void print(){}template <typename T,typename... Types>void print(const T& firstArg, const Types&... args){    cout << firstArg << endl;    print(args...);}int main() {    print(7.5, "hello", "word", bitset<16>(377));}

sizeof...(args)可以知道args的大小

auto (c11)

编译器知道find的返回类型，就会自动补上

ranged-base for (c11)

reference

习惯*靠向int，point to int

常见用途：

声明：<类型标志符>函数名（参数表）const；

说明：

（1）const是函数类型的一部分，在实现部分也要带该关键字。

（2）const关键字可以用于对重载函数的区分。

（3）常成员函数不能更新类的成员变量，也不能调用该类中没有用const修饰的成员函数，只能调用常成员函数。

（4）非常量对象也可以调用常成员函数，但是如果有重载的非常成员函数则会调用非常成员函数。

复合&继承关系下的构造和析构

继承关系下的构造和析构

哺乳动物-猪

先创建哺乳动物再创建猪，先删除猪再删除哺乳动物

复合关系下的构造和析构

继承和复合关系下的构造和析构

对象模型

关于vptr虚指针和vtbl虚表

重要

当一个类有一个虚函数的时候，虚函数是最重要的一部分，如果只谈继承不说虚函数用途不，只要类里面有一个虚函数，对象里面就会多一个指针(一万个虚函数也是一个指针)。

继承函数是继承调用权

B改写了一个虚函数，C又改写了B的虚函数

a、b和c里面的指针指向了一个虚表，虚表中包含了数个指向虚函数的指针

不再是单纯的静态调用，而是动态调用，面向对象很重要的环节！

为了让容器放各种的形状，就要指定容器里放各类的指针，draw函数要经常改写以适应各类形状

符合以下三个条件做动态绑定

1.通过指针绑定

2.指针向上转型，up-cast

3.调用虚函数

只要符合三个条件，编译器就编译成

右下角成为多态

关于this

虚函数两个用法，一个是上一节的，一个是这节的

关于 Dynamic Binding

补充

关于const

放在成员函数后面的const是很容易被忽略的，

意图是：修饰成员函数，加const至关重要

关于new，delete

class可以重载new和delete

重载::operator new，operator delete，::operator new[],::operator delete[]

重载这些影响非常广

member operator new/delete

通常接管做内存池

重载 member operator new[]/delete[]

实例，接口

如果使用者想要绕过特性，使用::new

12×5是60，结果是64，多出来的4记录了数组大小(计数器)

重载new()，delete()

对象构造的时候要分配内存然后调用构造函数，构造函数发出异常没成功，就要把分配的内存释放掉，对应的delete就被调用起来

basic_string 使用 new(extra) 扩充申请量

标准库：

当create自己的时候，分配一个rep+extra内容空间，rep做的是计数器。

1. 三大函数：拷贝构造、赋值和析构

标准库太过于复杂，所以写一个基本功能的string

实现如下功能：

int main(){  String s1();   String s2("hello");  String s3(s1); //copy，构造 *重点  cout << s3 << endl; //重载  s3 = s2; //copy,赋值  cout << s3 << endl;       cout << s2 << endl;    cout << s1 << endl;      system("PAUSE");  return 0;}

编译器会给一套构造，string用很不好，如果类带指针，就不能用默认版本，要自己写！

Big Three,三个特殊函数

拷贝构造

拷贝赋值

析构函数：当它死亡时就会被调用

这三个就是big three

ctor和dtor(构造函数和析构函数)

new分配1个字符：new char[1]

如果没有把动态分配的内存及时清理，会内存溢出！

所以需要析构函数！

new和delete之后再讲！

class with pointer members 必须有拷贝构造和拷贝赋值

使用默认的浅拷贝，很危险！

拷贝构造函数

1.创建出一个足够的空间

2.把内容拷贝过去

如果不写这个函数只拷贝指针就是浅拷贝，要避免！

拷贝赋值函数

把左边杀掉，再分配一块右边一样大的空间，再把右边的复制到左边。

如果不写检测自我赋值，1杀掉以后，a和b都找不到唯一的那个指针了！

所以要写自我赋值检测！

2.堆、栈与内存管理

output函数

写成全局函数，因为写成成员函数cout会在右边！

所谓栈(stack)，所谓堆(heap)

stack，是存在于某作用域的一块内存空间，例如你调用函数，函数本身即会形成一个stack用来放置它所接收的参数，以及返回地址。

在函数本体内声明的任何变量，其所使用的内存块都取自上述stack。

Heap,或system heap是指由操作系统提供的一块global内存空间，程序可动态分配从某个中获得的若干区块(blocks)。

class Complex { … }; ... {    Complex c1(1,2); //栈    Complex* p = new Complex(3); //堆}

上述c1其生命在作用域结束之际就会结束，这种作用域的object，又称为auto object，因为他会被自动清理。

stack local objects 的生命期

class Complex { … }; ... {    stack Complex c1(1,2); //}

上述生命在程序结束后其生命才会结束！

global objects的生命期

class Complex { … }; ... Complex c3(1,2);int main(){}

也可以视为stack，其作用域是整个程序！

class Complex { … }; ... {    Complex* p = new Complex;    ...    delete p;}

p所指的便是heap object，其生命在被deleted之际结束。

class Complex { … }; ... {    Complex* p = new Complex;}

以上出现内存泄漏，因为当作用域结束，p所指的heap仍然存在，但指针p的生命却结束了，作用域之外再也看不到p，heap就此遗失在内存海里。

new：先分配memory，再调用ctor

delete：先调用dtor，再释放memory

动态分配所得的内存块 in VC

必须是16的倍数，所以从52pad到64

在非调试下，得到的就是16

上下cookie要记录整个的大小！

64的16进制是40,41是因为最后一位是1的话为操作系统给出去的内存，0是操作系统拿到的内存，所以改成41.

16的倍倍数的16位进制最后的4位都是0所以可以借一个来用。

动态分配的array

8*3的意思是3个数字，最后+4是因为vc中要在数组的前面声明数组长度！

array new 一定要搭配 array delete

内存泄漏的是只杀掉了第一个指针，剩下的两个都没有杀掉！

指针class复习

string.h

#ifndef __String__#define __String__#include<iostream>#include<cstring>class String {public:    String(const char* cstr = 0); //拿来当初值    String(const String& str);    String& operator=(const String& str);    ~String();    char* get_c_str() const { return m_data; }private:    char* m_data;};inline String::String(const char* cstr) {    if (cstr) {        m_data = new char[std::strlen(cstr) + 1];        strcpy(m_data, cstr);    }    else {        m_data = new char[1];        *m_data = '\0';    }}inlineString::~String(){    delete[] m_data;//array new}inlineString::String(const String& str){    m_data= new char[std::strlen(str.m_data) + 1];    strcpy(m_data, str.m_data);}inlineString& String::operator=(const String& str)//&引用{    if (&str == this) {//&取地址        return *this;    }    delete[] m_data;    m_data = new char[strlen(str.m_data) + 1];    strcpy(m_data, str.m_data);    return *this;}std::ostream& //back add ostreamoperator << (std::ostream& os, const String& str) //cout will change{    os << str.get_c_str();    return os;}#endif

string_test.cpp

#include "String.h"#include <iostream>using namespace std;int main(){  String s1("hello");   String s2("world");  String s3(s2);  cout << s3 << endl;  s3 = s1;  cout << s3 << endl;       cout << s2 << endl;    cout << s1 << endl;      system("PAUSE");  return 0;}

1.头文件与类的声明

c++关于数据的函数

相较于c的特点：class和struct

以上两种形式创建了objects

本课程以complex和string为例：

正式开始之前：代码基本形式

c++代码主要由以下三部分组成：

c和c++的输出的区别

c++的优势是cout啥都可以丢！

头文件正规写法：防御声明

同一个程序第二次include就不会再次引入，否则会形成无限循环！

很重要的防卫声明。

头文件正规写法：布局

最主要的是1和2，然后写完再检讨声明0；

class的声明

每一个class都有一个head，再加上body！

实部虚部是一个double值，要设计另一个复数是整数或者float怎么办？

class的模板：解决重复性

T可以随意替换，第一行告诉编译器啥是T，下面的为实例指定double或者int。

有很多函数，不过多着墨。可以自行了解 。

2.构造函数

inline函数

inline拥有很大的优势，速度很快！但是是否inline由编译器决定！

不在本体内定义就可以加inline

访问级别

public可以被外界看到，private就要封装起来！

不必非得集中为2段。

下面的两个就是调用函数。

重要数据要放在private！

构造函数是什么？

构造函数写法很独特，函数名要和class名一样，然后括号里传入参数(默认实参)。

并且构造函数不需要有返回值，因为构造函数就是用来创建对象的。

有些人可能在大括号里赋值，但是要培养大气的写法：

complex (double r = 0, double i = 0): re (r), im (i) 

这种写法只能在构造函数里写，原理和re=r一样，但是为什么要在这里做？

简单来说一个变量数值的设定有初始化和赋值，第一阶段是: re (r), im (i)，初始化就会效率高一些。

传进来的实参要赋值给别人，不然的话传进来的实参就会消失在构造函数里面！

3.参数传递与返回值

构造函数可以有很多个-重载

比如说设计一个类，有很多种想法，所以就可以重载。

为什么可以重载？

编译器会把函数编译成如右下角的东西，所以名称并不相同。

如果函数有默认函数，则和无参数同名参数重复了，如上1和上2，complex()不知道调用哪个。

把构造函数放在private区

class complex{public:complex& operator += (const complex&);double real () const { return re; }double imag () const { return im; }private:double re, im;complex (double r = 0, double i = 0): re (r), im (i) { }friend complex& __doapl (complex*, const complex&); };

如上所示如果把构造函数放在private就不可以进行如下操作了：

{complex c1(2,1);complex c2;...}

什么情况可以放在private里？

在经典设计模式 singleton中，把构造函数放在了private里：

class A {public:static A& getInstance();setup() { ... }private:A();A(const A& rhs);...};A& A::getInstance(){static A a;return a;}

外界可以通过A::getInstance().setup();来进行调用其中的getinstance函数。

常量成员函数

即再函数的后面加const：

class complex{public:complex (double r = 0, double i = 0): re (r), im (i) { }complex& operator += (const complex&);double real () const { return re; } //在这里double imag () const { return im; }private:double re, im;friend complex& __doapl (complex*, const complex&); };

real和imag不改变数据，则马上加上const。

如果不加的话，使用者如下这么使用的话：

{const complex c1(2,1);cout << c1.real();cout << c1.imag();}

使用者：不改data，函数：可以改data

这样的话使用者就会被禁止使用const，使得使用者很生气(？

参数传递 by value or by reference

整包传过去，把整个值挪过去！

所以尽量reference。

之前c可以传指针，现在可以用引用！

如果传过去不希望对方改，加const。

返回值传递：by value or by reference

返回值也尽量传reference

什么时候不可以返回reference？

两种情况，ths加上了传进来的r，ths这个空间本来就在的，如果说在函数里构造了变量，返回了reference，等执行完毕这个引用就被销毁了，白玩！

友元

声明一个朋友，这个朋友可以自由取得friend的private成员！

相同的class的各个objects互为friends(友元)

4.操作符重载与临时对象

操作符重载-1，成员函数this

c2+=c1的理解，+=作用于c2

所有的成员函数一定带一个隐藏的参数this，谁调用函数谁就是this，此时this为c2的指针，不能在参数列写出来，但是在函数里可以用！

return by reference 语法分析

传进来的左操作数是一个指针，返回一个object，可是返回的声明是complex&，是无所谓的，传递者无需知道接收者是以reference形式接收。

如果使用者这么用：c2+=c1，inline void是可以的，但是如果使用c3+=c2+=c1,就不可以返回void了。

class body之外的各种定义

操作符重载-2，非成员函数

temp object(临时对象) typename()

上图绝不可return by reference。因为他们的返回必定是个local object！

typename生命很短，无需命名。

各种操作符重载，非成员函数

查手册发现cout为ostream参数，每一次输出都在改变，所以ostream不能加const。

因为可能涉及<<xx<<xx这么输出，所以返回类型应该设置为ostream

复习

#ifndef _COMPLEX_#define _COMPLEX_class complex;class complex& __doapl(complex*, const complex&);class complex{public:  complex(double r = 0, double i = 0)    :re(r), im(i) //只需要经过一步编译就可返回，很好用！  {};  complex& operator += (const complex&);  double real() const { return re; }  double imag() const { return im; }private:  double re, im;  friend complex& __doapl(complex*, const complex&);};inline complex&__doapl(complex* ths, const complex& r){  ths->re += r.re;  ths->im += r.im;  return *ths;}//because right could be change and can abundant, so add const inline complex& complex::operator += (const complex& r) {  return __doapl(this, r);} //only write right inline doubleimag(const complex& x){  return x.imag();}inline doublereal(const complex& x){  return x.real();}inline complexoperator + (const complex& x, const complex& y){  return complex (real (x) + real (y), imag (x) + imag (y));}//why not design  member function,because complex + true numberinline complexoperator + (const complex& x, double  y){  return complex(real(x) + y, imag(x));}//why not design  member function,because complex + true numberinline complexoperator + (double x, const complex& y){  return complex(x + real(y), imag(y));}//why not design  member function,because complex + true number#include std::ostream& //back add ostreamoperator << (std::ostream& os, const complex& x) //cout will change{  return os << '(' << real(x)  << ',' << imag(x) << ')';}#endif

注意事项与整理：

• 设计一个class构造函数：re(r)要用起来
• 函数加不加const一定要考虑
• 参数传递一定要考虑&
• return要不要&
• 数据尽可能的放在private，函数放在public

你必须把经验悬挂在头脑中的一个由许多思维模型组成的框架上。
——查理·芒格

0 随笔

作为一本世界级的名书，说实话当我看到这个名字以及副标题“查理·芒格的智慧箴言录”的时候我真的认为它是一本满满当当的充满着心里鸡汤的书，要知道世界级的心灵鸡汤并不少。
可是当我继续了解了其中的内容的时候，我就被查理芒格其个人品质与对待投资的观念所打动，这本书不仅仅讲的是投资，更多的是对待人生的态度。
整本书包含的是他过去20年来的11场演讲以及发表过的各种文章，从中提炼一下就能分析出查理他整本书都在强调的三个部分。
在解读这三个部分的时候我们先来了解一下：
谁是查理·芒格？

查理·芒格（Charlie Thomas Munger，1924年1月1日—）美国投资家，沃伦·巴菲特的黄金搭档，伯克希尔·哈撒韦公司的副主席。
查理·芒格（Charlie Thomas Munger），出生于美国内布拉斯加州的奥马哈。这位至今（2021年）已经97岁高寿的老人，在过去的46年里，他和巴菲特联手创造了有史以来最优秀的投资纪录——伯克希尔公司股票账面价值以年均20.3%的复合收益率创造投资神话，每股股票价格从19美元升至84487美元。
——百度百科

和芒格接触过的人，都会称赞他的思想以及他的那套方法论的作用与价值，其中就包括查理芒格最为人称道的“多元思维模型”。

1 多元思维模型

查理芒格的“多元思维模型”是每个了解这本书的人都会不约而同提到的一个模型，芒格提倡要集百家之所长，集合众多的知识概念去建立一个复式框架。芒格觉得，最重要的是要记住一系列原理，包括复利、排列组合、决策树、心理学等等一百多种模型，它们加在一起往往能带来很大的力量。这是很多力量共同作用于同一个方向，而得到的效果通常大于这些力量之和。
之所以构建这样一套体系，是因为芒格觉得如果对一件事不多元化的看待，那么你处理起来也是单一的偏执的。世界是一个复杂的整体，不像是学院时期1+1就是等于2，每道题都有标答。如果用单一的思维去看待身边的事物，那么就可能扭曲现实，直到其符合预期。
国外有一句谚语“当你拿起锤子的时候，你会觉得满世界都是钉子。”而中国也有乞丐许愿金碗去乞讨的笑话。这一定程度证明了思维的单一性。
其实“多元思维”不是方法论或者说不仅仅是方法论，从本质上来讲，其是一种认识世界的基本态度。
越是成熟的人就不会对一件事下定义去主张自己的观点，而是从不同的观点去解释为什么会发生；什么是擅作主张呢？就是去评价一个人是对是错、谁是好人谁是坏人……等一系列问题。成熟的人往往会去解释，面对一件事有没有不同的解释，能不能换一个角度看？
有人会认为这样做是“只空谈不实践”，其实恰恰相反，当我们关心别人的实践对其做出评价的时候，我们只是在干涉别人，对被人下定义而对我们自己毫无好处，仅仅是拿着自己过去受过的教育去乱砍一通，而不是去成长；当我们真正做到能够多方面多角度的分析对方究竟为何这么做时，我们才会将这种认知应用于自己的实践中。
还应该注意到，在主观世界里，我们受到的教育往往是一大堆原则，而客观世界里则只有“刚刚好”这么一说。
什么是刚刚好呢，在实践中，写字、绘画乃至创业来说，如果一味着遵循原则办事，往往就会成为一个死板的人没有长进的人；如同开车，在某一时某一刻是向左好还是向右好？都不对，开车讲究的是“刚刚好”，这就是客观世界的实践，客观的世界一切活动都是在“向左向右”的两个互相矛盾的原则中找到那个“刚刚好”的平衡点。
每一个受过教育的人都已经在主观世界里形成了一套规范的“原则手册”，而在社会中要做到的就是把客观世界发生的事与主观世界的认知原则找到平衡；比如说诚实，这是主观世界的金科铁律，可是在现实中我们有时候不得不去撒谎去隐瞒，好像这也没有什么道德瑕疵；比如说在法律实践中追求正义也会计算成本；认真努力的人在客观世界可能也会一事无成；“听了那么多道理，也过不好这一生。”讲的就是这个现象。
原则和“刚刚好”之间有一条很深的鸿沟，每时每刻我们都可能会跌落下去。当你弥合了这条沟，把客观世界的东西放到我们主观世界里揉碎并融入我们自身，那这便是成长。所以成长的越快，岁数越大，就越会包容很多事情。而查理芒格在书中不断强调的“多元思维模型”就是这一鸿沟的粘合剂。
作为一个局外人，挥舞着自己知道的原则去指导深陷泥潭里的人，讲他们的是非对错简直太容易了，但是对自己的成长没有任何好处。反而当自己陷入同样境地的人，自己掌握的那些原则完全就用不了了；如同现在很多人是别人世界里的“情圣”，自己世界里的“呆子”；
我们应该保持一个包容的、多元的视角，让更多的观念在自己的世界里共处，这样才会成长的更快。

2 反向思维

日常生活中，我们还需要构建自己的知识体系，查理芒格引入了另一个思维模型“反向思维”。
查理芒格有这样一个方法，在思考要去哪之前，要先想清楚不去哪。他把这叫做反向思维，很多人在做数学题或者考试的时候就能熟练的运用着类方法去排除错误选项，但在现实生活中很多人并没有这个意识运用这个方法。
查理芒格非常推崇反向思维，他认为，对于复杂的系统和人类的大脑来说，采用反向思考，往往会使问题变得更容易解决。
同样的，我们要建立好自己的知识体系，最好先想清楚坏的知识体系是什么然后避免它。
书中提到，坏的知识体系主要有三个特征，分别是缺乏纵深，单一化和松散无联系。
第一个缺乏纵深，比较好理解，一个人什么都知道，一细问又什么都不知道，这样的人就是知识面缺乏纵深的人。这样获取的知识很难打通之间的联系，这样在社会中竞争就会很弱。
第二个单一化，单一化的知识体系会造成狭隘的视野，比如一个公司研发部的人觉得是产品质量好才卖得好，而销售部的人会觉得是他们的口才好才卖得好，其实两方的视野都过于狭隘。于是有的公司会推行轮流换岗制度，每干一段时间就换一个不同的部门，这样下来员工们都互相理解对方，也成就了一个团结的员工体系。
第三个就是松散无联系，在生活中我们经常收集各种我们认为有用的知识，长此以往个人的知识库堆积如山，可是面对如山的知识，我们往往都会头痛，因为没有一个完整的体系去联系它们，它们只是一个个松散的点，就如同堆积在沙发上如山一般的衣服。不仅增加了你的知识负荷，也让你无从下手去面对它们。
以上就是差的知识体系了，知道了差的知识体系，我们就来了解一下好的知识体系，一个好的知识体系要符合一个特质：宏观上看像是一个T,微观上又像是一个Y。
为什么像T呢，其实就是一个好的知识体系，要在一方面深入扎根精通，并且能够有联系的广泛拓展知识面。
查理芒格在投资中就做到了这一点。查理芒格在投资一家公司时，不只是去看这个公司的财报，而是深入迁出的了解这个公司的整个生态系统。在这个过程中包括了历史学、心理学、数学、工程学、物理学、统计学、经济学等等。为什么需要这么多的学科呢？芒格回答：因为几乎每个系统都受多种因素的影响，所以要理解这样的系统必须熟练地掌握多元思维，这也就是所谓的T型架构。
接下来再说说为什么像Y？
比如说，你是一名厨师，也许你拥有精湛的厨艺，可以将菜做的色香味俱全，而Y型架构就是说，你不能用单一的一种知识，还要将其他领域的知识结合起来，比如你想做一道名菜，如果你美术知识精湛，你可以将菜雕的以假乱真，那么你的手艺绝对会更上一层楼。

3 投资心法

说了这么多做人做事，该聊聊怎样投资了，这一部分主要讲的就是芒格的投资心法。
在查理·芒格看来，投资可以分为三种，一种为可以投资，一种为不可以投资，一种为太难理解。而查理芒格只投自己认为可以投资的项目，其从不了解制药和高科技行业，所以他的投资也从不涉及。
那么怎么评判一个项目可否投资呢？
芒格有四个标准：
第一个标准，项目要好理解，有发展空间并且容易生存。
第二个标准，不能只看财务报表，财务报表只说明了公司现在的业绩，完全代表不了以后的价值，要多方面的考虑。
第三个标准，要看一家公司“护城河”够不够宽，什么是护城河？就是行业壁垒，如果一个行业门槛特低，那势必会引来很多竞争对手，那谁能笑到最后就不好说了。
第四个标准，就是投资股价公道的大企业，要比投资股价低的普通企业号，因为未来其他股东可能注资或者转让股权引起股权稀释，股利下降，大企业价值更高。
查理芒格认为，所有聪明的投资都是价值投资。你必须先评估一个企业的价值，再评估股票的价值，还要根据公司的竞争优势，来判断是不是应该持有这家公司的股票。
“想要得到某样东西最好的办法，就是让自己配得上它。”这是查理芒格的一句名言，单单看来这只是一句鸡汤，而关于鸡汤有一个定义：你端上来一碗热气腾腾的鸡汤，可是却没有勺子。言下之意就是道理是好道理，但是没给实现的方法。
可是芒格的理论，真的是鸡汤吗？其实不是，比如这句话配合上他的投资心法，其实是一回事，我们可以认为这句话是心法，而上面的四个标准就是招式。能不能看到这两者的共通之处，就看个人的功力了。
​

​

0.随想

其实关于理财的书这并不是我阅读的第一本，我的第一本书是小狗钱钱，与这本书相比较，小狗钱钱更多的是教导一个人如何去理财，用什么方式去理财。我通过小狗钱钱这本书，了解了人生中的三笔钱，了解了如何去规划资产，攒下了不少的钱。不过人的提升欲望总是无穷的，于是我又通过聆听，浅尝了理财观念培养的一大神书-*穷爸爸富爸爸。

其实我发现，这类神书统一都有一些特点比如简单、善于理解、循循善诱以及通篇举例。小狗钱钱通过一个小女孩攒钱的故事教导人们，而穷爸爸富爸爸则是以作者的切身经历来说明一些问题。

什么是穷爸爸富爸爸？初看标题的时候，我以为是亲子书籍就没多感冒。

其实他讲的是作者的高学历的父亲与从小玩到大的好朋友的商人父亲的对比，通过对比我发现其实身边的穷爸爸类性格的人占了绝大多数。

下面我们来了解一下什么是穷爸爸什么又是富爸爸。

1.价值观对比

罗伯特的亲生父亲总是说：“贪婪是万恶之源，人就应该懂得节制，不要浑身都是铜臭味。”，而另一个企业家爸爸总是说：“贫穷才是万恶之源，贫穷会放大人向恶的一面。”

亲生父亲遇到想买的东西总会说：“这个我可买不起，以后可别提了。”而另一个企业家父亲却不准这么想，他会让罗伯特去思考：“如果想要买这个东西，要用什么方式赚钱才买得起。”

亲生父亲一句话就逃避了这个问题，一辈子都在为攒钱努力；而企业家父亲却在积极面对问题，一生都在为提升生活品质获得幸福而努力，两种思想带来的结局相比也是轻而易举就能料到的。

亲生父亲对于交税问题总是抱怨不止，认为政府太黑心部分工资都拿去交税；而企业家父亲却觉得交税是应该的，不交税怎么创造一个公平公正的市场环境。

亲生父亲总是劝罗伯特让他好好学习，以后出人头地找到好工作来养活自己；而企业家父亲却教导罗伯特要好好学习，以后就可以自己开公司，创造更多的就业机会。

两位父亲给孩子设立的目标虽然过程一样，可带来的影响却是不一样的，一个是不好好学习就不会有好工作，一个是好好学就会帮到更多的人。

亲生父亲在饭桌上一律禁止谈钱，而企业家父亲能聊到没完。

亲生父亲在花一笔钱的时候会小心翼翼如同割肉，而企业家爸爸告诉罗伯特，只要投资在风险控制之内，就大胆去花。

这里可能会有人持着反对意见，不过先按下不表。

亲生父亲总会把欠款拖到最后才偿还，而企业家父亲总要提前偿还，绝不会出现逾期，因为逾期的罚金就是对他理财能力最大的侮辱。

亲生父亲总是把希望寄托在政府身上，把自己的老年退休金全面押在了政府上，平时最关心的就是加薪、退休政策、医疗补贴、病假和津贴这些琐事；而企业家父亲就不吃这套，他觉得一个人有了依靠，就不知不觉变得软弱，变得有依赖性，变得不思进取，他认为持续的学习才是最好的保障**。**

亲生父亲整天教别人如何写一个印象深刻的简历，而企业家父亲每天都教他写自己的商业计划书和财务计划表。

两位父亲都经历过破产，亲生父亲会说“你看，我永远不会成为富人了。”而企业家父亲会说“破产嘛，就是暂时的，我有丰富的理财知识，我依然是个富人。”

看到这里，读者似乎对于两位父亲的价值观已经有了很明晰的认识了，亲生父亲对于钱处于一种看不上又很需要的状态，看不上、不关心或者说看不起，到最后自然就得不到；而企业家父亲对待金钱始终处于一种关心，想要然后设立目标去达到的态度，长此以往，何愁不富甲天下？

似乎有很多人在身边都是如这位亲生父亲般的心态，拥有着杰出的学习能力，比别人高得多的学历，可正是因为如此他们自命清高，傲娇阻止了他们去发展；反而是学历不高，早早在社会中摸爬滚打的人，对于钱才有一种执着，不是为了挣钱去挣钱，而是为了让自己过得更好去挣钱；取之有道的财，何故鄙夷？

很多人在自己的领域深耕，世界上99.99%的人都没有其在这个领域认知的多，可是却不懂得推销自己，也不懂得赚钱，用互联网的话来说就是：只懂得做产品。

不管学历高与不高，财商在中国似乎并不是太过学校重视，人人都持有一种管理金钱似乎是金融系才去做的事这种心态。越早建立理财的意识，才会越早的实现财务自由。

2.如何提高财商

这本书似乎对于如何提高财商并不像<小狗钱钱>那般细列出一项项的具体措施，而是给了两个方针。

第一条：富人是不会为了钱去工作的

富人不会为了一点点的钱去出卖自己的时间与劳动力，富人只把精力放在自己的事业上。

穷人刚毕业找到了工作，工资仅仅够支付房租和日常开销，随着努力升职加薪，但是生活中更多的开销扑面而来，只能更努力地工作，如此循环往复，哪怕年入百万，依旧是债台高筑。像一只老鼠在木头笼子里奔跑，老鼠跑的越快，笼子转的越快，其实只不过是原地打转。

那要怎么摆脱这样的困境呢？

我认为应该直面自己的恐惧和欲望，很多人创造的价值都远远地高于自己所赚的工资，选择工作不能选择那些对自己毫无帮助的职业，如大学中很多人去兼职，家教、发传单或者去当售货员等，如是家境困难补贴学费无可厚非，可很多人只是抱着去所谓的“锻炼自己”的目的去工作，而获得的只不过是时薪10元20元的廉价劳动输出报酬而已。

在大学中自有许多人可以选择自己想要的生活方式，哪怕对自己的未来毫无帮助也是一种尝试；而在工作中就应该为了自己的未来负责，选择更能提升自己的工作。

第二条：学会区分资产和负债的区别

其实大多数人分不清何为资产又何为负债，在很多人看来买房和买车是同样的对于生活的花销，其实不然。买车数年要花费大量的金钱去保养与维修，用了几年后会面临淘汰和报废等状况，买车就是负债，它不会升值，不会使你赚到更多钱，它更多时间是在你有了钱生钱的能力时满足自己内心需求的一件物品。

也就是说，你要用资产赚来的钱去购买负债，而不是要用原本来购买资产的钱去购买负债；

而买房、股票或者基金等一系列投资就是资产，他可以帮助你的财富实现正增长。富人会把每一分钱当做自己的士卒，去攻城略地赢得每一分钱，穷人会克制不住自己的欲望“月光”有多少花多少，这就是根本区别。

所以说，区分资产和负债，克制自己的消费冲动，先把自己的钱堆积到可以钱生钱来，这才算正确的理财方法。

3.总结

以上就是本书最核心的两个部分，提炼再提炼即本书的精华所在，如果你一直不关心自己的财务情况，只一心赚钱而不管好后院，终其一生，留下的只能是银行账单和微薄的养老金。

说明：本笔记选于PDF全名：20210623影响力第五版教材版-美-罗伯特·西奥迪尼.pdf

注：本笔记所有的时间戳均为本人所采用的万能双向连接，对于我而言，它实现了笔记和PDF之间的无缝跳转，但他并不影响你对于这篇文章的理解或者感受我对这本书的喜爱之情。

简介：自 1986 年出版以来，作为获得美国心理协会、美国心理学基金会年度大奖提名的西奥迪尼经典著作，本书已经成为史上最强大、最震摄人心、最诡谲的心理学畅销书。

24 年来，被翻译成 26 种文字广为传播，全球销量超过 300 万册。时至今日，本书仍位列亚马逊总排行榜 Top400 之中，并雄踞消费者行为学和应用心理学类畅销书榜首。

也正是在这个畅销版本的基础上，西奥迪尼才衍生出后来为斯坦福大学等多所名校所采用的教材版本。

非正文

这本书的作者一改常态，直接在开篇提出了影响力的六种特质：互惠、承诺和一致、权威、社会认同、喜好、稀缺，不过似乎各个国家对于影响力有着不同的认知，中国似乎更偏向于权威，至少中国香港是这样的

书签： 20210623193940

有时候换一个角度就能得到事物最本质的特征，就如同作者一样，他不像普通的工具书一样单独的去输出乏味的知识或者外行人教导外行人的不靠谱，作者亲自去参与这个世界上靠着情商活下去的组织，去汲取营养。这也就是参与式观察(participant observation)

第一章 影响力的武器 [武装自己]

与经典版不同的是，在题首导读给出了一个个案例供人分析，我还没有看到正文，我就能从上总结的六种特质中分析出这个案例是怎么回事了。

第二次世界大战期间，小托马斯·沃森受命调查有高级将领遇难或受伤的飞机事故。有一起事故牵涉到著名的空军将领鸟扎尔・思特( Uzal Ent)。起飞之前，他的副驾驶员生病了。新分来的副驾驶员听说能和传奇将领一起飞行，感到很光荣。起飞时，思特轻声哼着歌，并随着脑海里的节奏点头打拍子。新的副驾驶员以为这是恩特要他把飞机的助跑轮收起来。尽管那时候他们的速度还非常缓慢，根本没法飞上天，副驾驶员还是把助跑轮给抬了起来。结果，飞机的腹部立刻贴在了地上。混乱中，螺旋桨叶片切入了恩特的背部，割断了他的脊椎，导致他下半身。接照沃森的描述，副驾驶员是这样解释自己的行动的副驾驶员作证的时候，

我问他：“既然你知道飞机不能起飞，为什么还要把助跑轮升起来？”

他说：“我以为是将军要我这么做的啊。”他真是个蠢货。“ 蠢吗？在这一起事件中，的确是够蠢的。但能不能理解呢？ 现代生活的迷宫需要捷径，从这个角度看，它也完全可以理解。

书签：20210623195240

在这个案例中，小兵似乎完全听信了将军，因为将军是一个传奇飞行员，所以小兵因为将军的权威听信了将军。

随后，作者列出了绿宝石翻倍卖反而比原价卖的更火的例子，作者似乎想要通过这个例子来表达稀缺，权威对于买卖的重要性。

-书签：20210623195826

往后面的阅读中，似乎并不是我理解的那样，作者举例了雌火鸡的例子说明了一个道理，动物在自然环境中会因为某些特定的原因触发自身的“磁带”，也就是所谓的固定模式.

比如：雄性知更鸟只要看到一丛红色的知更鸟胸羽，就会做出有敌人侵犯自己领地的样子，凶猛地攻击它。可只要你取掉那从红色的羽毛，哪怕是摆上一只惟妙惟肖的雄知更鸟玩具，前者也对它不理不睬。研究人员在蓝喉鸟身上也观察到了类似的结果，只不过，触发它捍卫领地行为的是一种特殊的蓝色胸羽。

-书签：20210623201343

1.1 按一下就播放

而人类也难以逃脱这种规律，根据社会心理学家艾伦的实验证明：我们在需要别人帮忙的时候，要是能给出一个理由，成功的概率会更大。 因为人就是单纯的喜欢要一个理由，哪怕不合理不成立。

据另一项研究显示，人类的行为并不是固定的磁带行为，但是有时候没啥两样。就如作者举的例子那个绿宝石，人类一看到贵的东西自动的就等价了好的东西。

所谓好货不便宜，便宜没好货等俗语阐述了人类社会的普遍心理活动。

真正想买好东西的人对价格低的东西是看不上眼的。

书签：20210623204126

自此，第一章第一小节就结束了。

总结一下：

• 在需要帮助的时候提出一个理由。
• 只要在大众普遍认为正确的或者理应发生的事情上做文章就有很大几率成功。

1.2 把赌注压在抄捷径上

因为人们疲于学习更多的知识，对于未知商品的判断大多取决于对价格的判断(如有专业的知识就可以大概的估算出价值次次的赌注，上文的绿宝石既是此道理。

世界上的事务千千万，我们需要一条捷径来了解世界，而总结出一条条简约的范式才能有足够的把握面对这个复杂的世界。

我们容忍这个简约的范式出错，它可以是不完美的，但是它是必不可缺少的。在生活中使用这些捷径也有一个专属名词启发式判断(judgmental heuristics)。

在这本书的第六章，会出现一个捷径直接产生了影响力的一大关键因素权威，即“专家说的话肯定是对的。”，而利用这种反应(可控式反应)似乎可以轻而易举的说服别人。

1.3 渔利的奸商

自然界就有许多利用这种捷径的动物-‘拟态体’，利用对方的错误行为，达到自己的目的。

书签：20210629194523

似乎自然生存斗争中，每一种生命形式都有着对应的拟态体。如细胞病毒等也不例外。

有许多人类也能自如的运用捷径这一特点，操控人心，无往不利。

就如同上面的例子：就利用了“价格贵=东西好”

1.4 以柔克刚

熟练的柔道选手可以运用杠杆重力等作用几近做到四两拨千斤的功效，为人处世更是如此。

举个例子：“对比原理”

两样东西要是第二样和第一样有着相当的不同，那么我们往往认为两者的差距比实际的更大。

如果先搬一种轻的东西，再拿一件重的东西，我们会觉得第二件东西比实际上更沉；而要是我们一开始直接就搬这件重东西，反倒不会觉得有这么沉。

书签：20210629195131

要是有一个人来到店里，应该先给他推销贵的东西，随后按照对比原则依次推销越来越便宜的东西，这样他们就会觉得超乎寻常的便宜，这样购买的东西就会越来越多了。

售楼员也会先带你去看不合适的房子，然后去到普通的房子就会大为欣赏了。

卖汽车也是同理，买完车以后一一报上备选配件，当顾客看到合同的时候就会发现已经花了比买车时预算多得多的钱。

第二章 互惠

互惠原理：要是人家给了我们什么好处，我们应当尽量回报。

这种你给我一点我给你一点的欠人情式“欠债网”是人类的独特适应机制，有了它，人类才得以实现劳动分工。

互惠原理向我们做了个保证，不管结局是好是坏，我们种下什么样的因，就得什么样的果。

2.1 原理怎样起作用

作者举了个小故事：

实验人员告诉受试者他参加的是所谓的“艺术鉴赏”实验，他要跟别人一起为几幅画作的质量打分。另一名打分的人，我们就叫他“乔”吧，他只是假装当成受试者的同伴，其实是里根教授的助手。为了达成实验目的，研究人员采用了两种不同的环境来进行。

有几回，乔主动帮了真正的受试者一个小忙。在短暂的休息时间，乔离开了房间几分钟，回来时带了两罐可口可乐，一罐给受试者，一罐给自己。

他说:“我问他（实验员）能不能弄瓶可乐喝喝，他说没问题，我就给你也带了一罐来。”

另外几回，乔没有帮受试者这个小忙，他只是到房间外休息了两分钟，然后就回来了。

除此以外的各个方面，乔的表现都是相同的。

稍后，等所有的画作都评分完毕，实验员暂时离开了房间，乔请受试者帮他一个忙。他表示，他正帮一款新车卖抽奖彩票，要是他卖掉的彩票最多，就能得到50美元的奖金。乔请受试者以每张25美分的价格买些彩票:“帮帮忙，买一张也行，可越多越好。”

实验的主要目的之一，就是研究上述两种情况下受试者从乔手里买的彩票数量。

毫无疑问，先前接受了乔好意的受试者，买起彩票来更慷慨。显然，他们觉得自己欠了乔点儿人情，所买彩票的数量比另一种情况下多了一倍。

尽管里根的研究只对互惠原理的运作做了很筒单的阐释，但它勾勒出了该原理的若干重要特点。

这里，我们不妨来仔细地分析一-下，看看互惠原理是怎样被人当成牟利的手段的。

–20210629200552

一 单目结构光编码目的

类似于双目，如果把投影仪看成一个逆相机，直到空间中的一点成像平面的位置，就可以知道空间中一点的坐标。

编码的目的：知道打在物体物体表面的光是从投影仪的那个像素发出来的，就知道在投影仪的虚拟成像位置。

二 格雷码的编码与解码

2.1 格雷码vs二进制码

格雷码是一种二进制码，最大的特点是相邻格雷码编码只有一位不同。

所以格雷码解码更稳定，相对不容易出错。

体现在

• 明暗交接处变换更少：

对于格雷码来说，明暗交接处变换更少，如图所示二进制下部有7次变换，而格雷码只有4次。黑白交接的影响主要是在解码上，解码很重要的环节就是二值化，一般情况下全黑和全亮是不容易出错的，因为在实际应用中投影交界处是渐变的，阈值很难确定(还有物体边缘的影响)。

• 最细的条纹宽度更宽

在相机对焦外，可能投影会糊掉，所以条纹越宽越不容易糊掉。

2.2 编解格雷码

如果单纯的编制一张图片的话很简单，如上一节图所示，最低一行(最后一位)变化为0110周期，第二行为0011100周期，第三行为0000111111110000周期(2的指数级增长)。

二进制码->格雷码

1.对n位二进制的码字，从右到左，以0到 n-1编号

2.如果二进制码字的第i位和i+1位相同，则对应的格雷码的第i位为0，否则为1

格雷码->二进制码

从左边第二位起，将每位与左边一位解码后的值异或，作为该位解码后的值（最左边一位依然不变）。依次异或，直到最低位。依次异或转换后的值就是格雷码转换 后的二进制值。

以十进制数6为例，格雷码->二进制码

第一位不变： 1

第二位（0）与第一位解码后的值（1）异或：1

第三位（1）与第二位解码后的值（1）异或：0

三 图片二值化方法

前提条件：每个在投影仪照射范围的点都至少需要经历一次明暗变换，即总要能找到一张图该位置为 0，另一张图该位置是1

实现方法：

方法一： 增加两张图， 一张全黑图，一张全亮图

方法二： 去除全0和全1的编码 ，让每个编码至少含有一个0和一个1(不建议，可能会破坏格雷码稳定性)

二值化方法：

对于每个像素，计算其在整个时间序列（一组）下的最大值和最小值，然后对当前图片像素二值化就 是计算出一个如上式所示的阈值，阈值大于0.5的时候则为1，小于0.5则为0。

四 其他离散型编码

在某些场景下，由于物体材质的原因，格雷码效果不好；物体受到全局光照影响特别大；

Global illumination 全局光照：

1 inter-reflection 内反射 – long range effect

2 diffusion 漫反射 – long range effect

3 sub-surface scatter 下表面散射 – short range effect

全局光照对解码影响：解码错误

解决思路：

不同的全局光，对不同频率的编码光影响不同。

1 高频光适合 （long range effect): 内反射， 漫反射

有可能第一行右边亮的地方点亮左边暗的地方，所以需要更密集的投射如下：

2 低频光适合 （short range effect): 下表面反射(影响临近的点)

低频光因为影响临近，所以最好是越低频越好，如下：

其实相对来说格雷码最稳定，而上面这种方法会生成过多的图片，会对点云帧率有所影响。

参考论文： Structured Light 3D Scanning in the Presence of Global Illumination

五 总结

格雷码编解码流程：

特殊应用场景：

接了导师的活，要求把TVloss加入到已经写好的DnCNN里，下面是tvloss代码：

class TVLoss(nn.Module):    def __init__(self, TVLoss_weight=1):        super(TVLoss, self).__init__()        self.TVLoss_weight = TVLoss_weight    def forward(self, x):        batch_size = x.size()[0]        h_x = x.size()[2]        w_x = x.size()[3]        count_h = self._tensor_size(x[:, :, 1:, :])  # 算出总共求了多少次差        count_w = self._tensor_size(x[:, :, :, 1:])        h_tv = torch.pow((x[:, :, 1:, :] - x[:, :, :h_x - 1, :]), 2).sum()        # x[:,:,1:,:]-x[:,:,:h_x-1,:]就是对原图进行错位，分成两张像素位置差1的图片，第一张图片        # 从像素点1开始（原图从0开始），到最后一个像素点，第二张图片从像素点0开始，到倒数第二个        # 像素点，这样就实现了对原图进行错位，分成两张图的操作，做差之后就是原图中每个像素点与相        # 邻的下一个像素点的差。        w_tv = torch.pow((x[:, :, :, 1:] - x[:, :, :, :w_x - 1]), 2).sum()        return self.TVLoss_weight * 2 * (h_tv / count_h + w_tv / count_w) / batch_size    def _tensor_size(self, t):        return t.size()[1] * t.size()[2] * t.size()[3]

可以看出返回的是一个数，使用方法为：

addition = TVLoss() # 初始化loss = addition(model(batch_y)) # 输入为经过模型得出的fakexloss = Variable(loss, requires_grad=True)

由实验——TV Loss解决over fitting的问题，tvloss在深度学习里不可以单独的作为loss，需要配合其他loss使用，在这里我们引入sum_squared_error 误差平方和：

criterion = sum_squared_error()loss2 = criterion(model(batch_y), batch_y - batch_x)loss = (loss * args.tvlosspr) + loss2 # args.tvlosspr为事先定义好的tvloss参数

如上，就把TVloss嵌入进程序里了(好不好用我也不知道)

如果不好用的话我会回来改一下，如果过去一个月了这篇文章还没有改那就证明这个方法成功了(至少没失败)

2021年4月21日更新

发现更为简便的加loss方法

my = model(batch_y)loss2 = criterion(my, batch_y - batch_x)tvloss = 1e-6 * (torch.sum(torch.abs(my[:, :, :, :-1] - my[:, :, :, 1:])) + torch.sum(torch.abs(my[:, :, :-1, :] - my[:, :, 1:, :]))) #1e-6为参数loss =   tvloss + loss2 

这个方法我也没试验过

等有时间再实验吧

EOF

本文是学习总结的笔记，仅供个人学习使用。

1. introduction

在这篇文章中，作者训练了一个端到端的卷积网络，以从连续无约束的图像对中计算深度和摄像机运动。该体系结构由多个堆叠的编解码器网络组成，核心部分是一个能够改进自身预测的迭代网络。该网络不仅估计深度和运动，而且还估计表面法线、图像之间的光流和匹配的置信度。该方法的一个重要组成部分是基于空间相对差异的训练损失。与传统的基于运动方法的双框结构相比，结果更准确，鲁棒性更强。与流行的Depth-from-Single-Image网络不同的是，DEMON学习了匹配的概念，因此更好地概括了训练过程中看不到的结构。

1.1 卷积网络与SfM的对比

SfM是计算机视觉研究中的一个长期课题。大多数现有的系统都是经过精心设计，包括几个连续的处理步骤。目前这个步骤的实现有一些固有的限制。例如，在通过密集对应搜索推断场景的结构之前，通常从估计摄像机运动开始。因此，对相机运动的错误估计会导致错误的深度预测。此外，通过关键点检测和描述子匹配计算稀疏对应来估计摄像机运动。这种低层次的处理很容易出现异常值，并且不能在无纹理的区域工作。最后，所有现有的SfM方法在小型摄像机转换的情况下都失败了。这是因为在这些退化的情况下很难整合能够提供合理解决方案的先验。

在本文中，作者训练了一个卷积网络，从无约束的一对图像中联合估计深度和摄像机运动。该方法与典型的SfM有很大的不同，它同时解决了运动和密集深度估计的问题。从长远来看，学习方法有很大的潜力，因为它自然地整合了X方法的所有形状:多视图、轮廓、纹理、阴影、散焦、雾霾。此外，在退化情况下，可以有效地从数据中学习到对象和结构的强先验，并对问题进行规格化;

深度学习方法明显优于传统方法。

1.2 传统卷积神经网络与本网络对比

最近，卷积网络在单个图像的深度预测方面表现出色通过学习对象及其形状的先验知识，这些网络在受限评价中，如室内或驾驶场景，达到了非常好的性能。

然而，单一图像方法在推广到以前未见过的图像类型方面存在更多问题。这是因为他们没有利用立体视觉。下图显示了一个示例，其中单个图像的深度失败，因为网络以前没有看到类似的结构。作者的网络，它学会了利用运动视差，没有这个限制，很好地概括了非常新的场景。

为了利用运动视差，网络必须将两个输入图像对应起来。作者发现一个简单的编码器-解码器网络不能使用立体图像:当训练它从两个图像计算深度时，它最终只使用其中一个。单幅图像的深度是满足训练目标的捷径，无需将两幅图像进行对应，并从对应中得到相机的运动和深度。在走捷径的同时网络忽略了三维空间对预测结果的影响。

本文解决了传统神经网络的问题，采用了一种光流估计与相机运动和深度估计交替进行的架构;为了求解光流，网络必须使用两个图像。

本文还提出了一个技术贡献是用特殊的梯度损失来处理由运动引起的结构尺度模糊。

2. Methods

整体网络架构如图2所示。DeMoN是一个编码-解码网络链，解决不同的任务。该体系结构由三个主要部分组成:bootstrap网络、迭代网络和细化网络。前两个组件是一对编码器解码器网络，其中第一个计算光流，第二个计算深度和摄像机运动;参见下图。迭代网递归地应用于连续地改进前一次迭代的估计。最后一个组件是一个单独的编码器-解码器网络，生成最终的更新采样和细化的深度映射。

2.1 训练过程

2.1.1 损失函数

该网络估计的输出性质非常不同:高维(每像素)深度地图和低维摄像机运动向量。损失必须平衡这两个目标，并在不过度适应特定场景的情况下促进这两个任务的协同作用。

• Point-wise losses.
  • 作者将点方向的损失应用到作者的输出上:反深度值ξ，表面法线n，光流w，光流置信值c。对于深度，作者直接在反深度值上使用L1损失:
  • 对于法线和光流的损失函数：
  • 作者训练网络通过预测每个光流分量的置信图来评估其自身流量预测的质量。x分量置信度：)相应的损失函数是：
• Motion losses.
  • 作者使用了摄像机运动的最小参数化，每个参数为旋转r和平移t。运动矢量的损失：
• Scale invariant gradient loss.
  • 作者定义离散不变梯度g为
  • 基于这个梯度，作者定义了一个尺度不变的损失，它惩罚了相邻像素之间的相关性:
  • 作者对光流的每个分量应用相同的尺度不变梯度损失。这增强了估计流场的平滑度和运动不连续性的锐度
• Weighting
  • 作者分别权衡损失以平衡其重要性。权重因素是根据经验确定的，并在补充资料中列出。

2.2 训练进度

网络训练是基于Caffe框架的。作者用Adam从头开始训练模型，动量为0.9，重量衰减为0.0004。整个培训过程包括三个阶段。

首先，作者在引导网和迭代网中顺序训练四个编解码器组件，每个迭代250k次，批大小为32。在训练编解码器时，作者保持前面所有组件的权重不变。对于指定光流的编解码器，在10k次迭代后应用尺度不变损耗。

其次，作者只训练迭代网络的编解码器对。在此阶段，作者将前三次训练迭代的输出附加到小批量中。在此阶段，引导网络使用大小为8的批次。将前三次网络迭代的输出添加到批次中，从而产生迭代网络的总批次大小为32。作者运行160万次培训迭代。

最后，在其他权值固定的情况下，对精化网络进行600k次迭代训练。

3. Results

3.1 数据集

SUN3D：这个数据集提供了一组不同的室内图像以及深度和相机姿势。此数据集上的深度和相机姿势并不完美。因此，作者从数据集中采样图像对，并自动丢弃具有较高照相一致性误差的图像对。作者拆分数据集，以便相同的场景不会同时出现在训练和测试集中。

MVS：包括几个室外数据集。作者使用来自的Citywall和Achteckturm数据集和Breisach数据集进行训练，并使用COLMAP提供的数据集进行测试。重建场景的深度图通常是稀疏的，并且可能包含重建误差。

Scenes11：是一个合成数据集，包含随机几何形状的虚拟场景图像，提供完美的深度和运动场景真实，但缺乏真实感。

因此，作者引入了基于blendswap.com上150个场景的Blendswap数据集。该数据集提供了大量的场景，从类似卡通的场景到逼真的场景。该数据集主要包含室内场景。作者仅将此数据集用于训练。

NYUv2：提供多种室内场景的深度地图，但缺乏相机姿态信息。作者没有在NYU上进行训练，而是使用了与Eigen等人相同的测试分割。与Eigen等人不同，作者还需要第二个输入图像，它不应该与前一个相同。因此，作者根据差分图像上的一个阈值，自动选择与第一幅图像足够不同的下一幅图像。

在所有没有表面法线的情况下，我们从深度图中生成它们。我们专门为SUN3D中使用的相机特性训练了DeMoN，并通过裁剪和缩放来适应所有其他数据集以匹配这些参数。

3.2 误差指标

单图像方法的目的是在实际物理尺度上预测深度，而双图像方法通常产生的尺度相对于相机平移向量的范数。比较这两组方法的结果需要一个尺度不变误差度量。我们采用的尺度不变误差，定义为：

其中：

为了与运动方法中的经典结构进行比较，我们采用了以下措施：

3.3 与经典结构的运动对比

两帧深度和运动估计方法的比较。对所有措施来说，越低越好。为了与基线方法进行公平比较，我们仅在两幅图像中可见的像素处评估深度。因为Base-Matlab的深度只能作为稀疏点云提供，因此不能与这里进行比较。我们没有报告NYUv2的错误，因为运动地面真相(因此深度刻度)是不可用的。右:与单帧深度估计的比较。由于尺度估计不具有可比性，我们仅报告尺度不变误差度量。

通过增加DeMoN的两个输入图像之间的基线来提高质量性能。深度图由左上角的参考图像和下面的第二个图像生成。第一个输出包含两个相同的图像输入，这是传统结构运动的退化情况。

3.4 与单个图像的深度进行比较

在各种数据集上进行定性深度预测比较，DeMoN的预测非常清晰和详尽，因为一些原因，缺少有关NYUv2的Base-Oracle预测。

3.4 对新数据的归纳

当面对与训练数据截然不同的场景时，在训练过程中学习的特定场景先验可能是无用的，甚至是有害的。相反，一对图像之间的几何关系是独立于场景内容的，应该概括为未知的场景。为了分析DeMoN的泛化特性，我们汇编了一个小数据集，其中包含一些不常见或复杂的场景，例如抽象雕塑、人物和物体的特写、旋转90度的图像。

将DeMoN的泛化能力可视化到以前看不到的配置。在这种情况下，单帧方法有严重的问题，因为在最后一个示例的深度估计的点云可视化中最清晰可见。

4. Discussion

DeMoN是第一个学习从两个不受约束的图像中估计深度和摄像机运动的深度网络。与从单一图像估算深度的网络不同，DeMoN可以利用运动视差，这是一种强大的线索，可用于新类型的场景，并允许估算自我运动。该网络在两帧上优于传统的运动技术结构，因为与那些相比，它是端到端的训练，并学习从X线索整合其他形状。当涉及到处理相机与不同的内在参数，它还没有达到传统方法的灵活性。下一个挑战是解除这个限制，并将这项工作扩展到两个以上的图像。与传统技术一样，这有望显著提高鲁棒性和准确性。

5. References

• C. Bailer, B. Taetz, and D. Stricker. Flow Fields: Dense Correspondence Fields for Highly Accurate Large Displacement Optical Flow Estimation. In IEEE International Conference on Computer Vision (ICCV), Dec. 2015.

• P . Agrawal, J. Carreira, and J. Malik. Learning to see by moving. In IEEE International Conference on Computer Vision (ICCV), Dec. 2015.

• D. Eigen and R. Fergus. Predicting Depth, Surface Normals and Semantic Labels With a Common Multi-Scale Convo- lutional Architecture. In IEEE International Conference on Computer Vision (ICCV), Dec. 2015

• F. Liu, C. Shen, G. Lin, and I. Reid. Learning Depth from Single Monocular Images Using Deep Convolutional Neural Fields. In IEEE Transactions on Pattern Analysis and Machine Intelligence, 2015.

本文是学习肖勇大神的点云课程总结的笔记，仅供个人学习使用。

肖勇

Mapping & Localization Technical Specialist @ Lucid Motors，主要从事无人车地 图和定位算法研发。先后参与 Lyft、百度无人车 项目开发。密歇根大学土木工程博士，中科院遥 感与数字地球研究所地图学硕士，武汉大学测绘 工程学士。

点云数据及获取

• 定义
  • 点云：三维点的数据集合
• 属性
  • 三维坐标
  • 强度
  • 颜色
  • 时间戳

• 分类

  • 点云组织形式：

    • organized: the point cloud is laid out as a 2D array of points that resembles an image like structure -
    • unorganized: the point cloud is a list of points.

• 点云获取方式
  • 激光扫描仪
    • 星载
    • 机载
    • 地面
    • 移动
  • 深度相机(depth Camera)
  • 双目相机(stereo Camera)
  • 光学相机多视角重建

激光扫描仪

• 工作原理：time of flight

• 

• 分类

  • 星载：卫星
  • 机载：飞机，无人机
  • 地面：三脚架上固定
  • 移动：车辆，机器人等

星载激光雷达

• 常见系统
  • GLAS星载激光雷达 系统(Geoscience Laser Altimeter System)
  • CALIOP星载激光雷 达
  • ALADIN星载多普勒 激光雷达
• 

机载激光雷达

• 机载激光雷达
  • 使用配有 GPS/IMU的飞机（无人机） 获取大范围的点云
• 特点
  • 精度高：10cm
  • 大尺度测绘
• 应用领域
  • 大尺度（城市级别）测绘
  • DEM
  • 正射影像 （高精度相机）

地面激光雷达

• 地面激光雷达
  • 激光雷达通常固定在三角架上，进行 较大范围扫描获取点云。
• 特点
  • 精度高： 可达到 mm
  • 距离远：可达到400m
  • 扫描速度快： Leica RTC360 1s 采集 ~200万点云
• 应用
  • 文物三维扫描建模
  • 地形测量

移动激光雷达

• 移动激光雷达

  • 激光雷达通常跟着移动物体（ 机器人无人车），进行较大范 围扫描获取点云

• 特点

  • 精度高： cm
  • 距离远：~240m
  • 扫描速度快： 10Hz, 200万点 云每秒

• 应用

  • 无人车，机器人

  • 街景测量

    

Point Cloud created by Velodyne Lidar’s Alpha Prime sensor

深度相机

• 深度相机
  • 通过近红外激光器把具有结构特征 的光线投影到物体上，通过红外摄 像头采集得到深度信息。
• 特点
  • 成本低，计算量小
  • 主动光源，夜晚也可用
  • 观测该范围和距离有限
• 应用
  • 室内机器人
  • AR/VR

双目相机

• 使用两个相机从不同位置获取物体的 两幅图像，通过计算对应点的位置偏 差，使用三角原理（Triangulation） 计算点的三维坐标
• 特点
  • 成本低
  • 室内室外都适用
  • 对环境光敏感
  • 基线限制了测量范围

光学相机多视角重建

• SFM 运动结构恢复(Structure from motion)

  • 给出多幅图像及其图像特征点的对应集合 ，估计3D点的位置和摄像机姿态（运动）

• 特点

  • 成本低

  • 使用高精度相机和更稳定的平台（有 GPS/IMU）可以进行高精度测量

  • 计算量大

Credit to http://gsp.humboldt.edu/OLM/Courses/GSP_216_Online/lesson8-2/SfM.html

点云数据处理

点云滤波(filtering)

• 检测和移除点云中的噪声或不感兴趣的点
• 分类
  • 基于统计信息 (statiscal-based)
  • 基于领域 (neighbor-based) 基于投影（projection-based)
  • 基于信号处理(singal processing based)
  • 基于偏微分方程(PDEs-based)
  • 其他方法：voxel grid fitlering, quadtreebased, etc.
• 常用方法
• 基于体素(voxel grid)
• 移动平均最小二乘(Moving Least Squares)

点云匹配 (point cloud registration)

• 估计两帧或者多帧点云之间的 rigid body transformation 信息，将所有帧的点云配准在同 一个坐标系。
• 分类
  • 初/粗匹配: 适用于初始位姿差别大的两帧点云
  • 精匹配：优化两帧点云之间的变换
  • 全局匹配：通常指优化序列点云匹配的误差， 如激光 SLAM，两帧之间匹配，全局匹配
• 常用方法
  • 基于 Iterative Closest Point (ICP)的方法
  • 基于特征的匹配方法
  • 深度学习匹配方法

Credit to http://geometryhub.net/en/notes/registration

• Iterative Closest Point (ICP)Registration
  • Given two scans 𝑃 and 𝑄, initial transformation between them 𝑅,𝑡
  • Iterate
    • Find some pairs of closest points (𝑝𝑖,𝑞𝑖)
    • Optimize 𝑅,𝑡 to minimize

点云分割 (segmentation)

• 根据空间、集合等特征将点划分为不同的集合。
• 常用方法
  • 基于边缘的方法：变成图像，使用边缘信息
  • 基于区域生长
  • 几何模型拟合：拟合平面，球形，圆柱等

• Segmentation using smoothness constraint
  • 

点云目标检测 (object detection)

• 从点云中检测某类物体

• 方法：

  • 传统机器学习方法
  • 深度学习方法

点云分类 (classification)/语义分割(Semantic Segmentation)

• 为每个点云分配一个语义标签

• 方法：

  • 传统机器学习
  • 深度学习

模型重建 (model reconstruction

• 从点云中获取更精简更紧凑的模型，如获取 mesh 模型。

• 常见的 3D shape representation: 深度图，点云 ，体素，网格(mesh)

• 常用方法：

  • Delaunay Mesh Generation
  • Finite Element Mesh Generation.
  • Marching cube

常用软件及开源

CloudCompare

开源，且支持多平台(Windows, Mac, Linux)

• 支持常见的点云数据格式，简单的 点云编辑
• 支持用户自己添加插件和增加新功 能 (如 Ransac， Poisson Mesh Reconstruction, Classification with CANUPO)
• 适合于点云可视化，简单编辑或者处理

Meshlab

• 处理和编辑3D三角形网格的开源系 统
• 主要是编辑，清理，修复，检查， 渲染，纹理和转换网格的工具
• 3D Acquisition: color mapping and texturing Cleaning 3D models
• 支持多平台（Win，Linux, Mac)

部分商业软件

• Microstation TerraSolid (Bentley):航测，主要适用于机载雷达，获取 DEM 和建筑建模等
• Global Mapper Lidar Moduel:主要处理机载激光雷达数据，分类，建模，生成 DEM等
• LiDAR 360 (数字绿土)：林业资源调查，地形测绘等
• 点云魔方(中国科学院遥感与数字地球研究所)：植被应用，电力巡线等
• ENVI LiDAR; ArcGIS：含有部分点云处理模块，主要用于遥感和林业
• Cyclone, Cloudworx, TruView: Leica徕卡开发，主要用于其地面激光雷达和移动（背包式）激光
  雷达数据处理
• Riscan Pro：主要用于处理 Riegl 瑞格地面激光雷达数据
• RealWorks(Trimble)
• Polyworks (Innovmetric); Geomagic (3D systems)：逆向工程，主要用于机械测量

开源库

• PCL (Point cloud library)
  • Filter
  • Segmentation
  • Registration
  • Keypoints
  • Recognition
• 特点
  • 支持多平台（Win，Linux, Mac)
  • 功能齐全，可扩展性好
  • 广泛用于机器人，很多开源算法和 系统（ROS)

• Open3D
  • Surface alignment
  • 3D machine learning support with PyTorch and TensorFlow
  • GPU acceleration for core 3D operation
• 特点 •
  • 支持多平台
  • python集成成熟，可和 Pytorch, Tensorflow 集成

参考文献

• Fernandes, D., Silva, A., Névoa, R., Simões, C., Gonzalez, D., Guevara, M., Novais, P., Monteiro, J. and Melo-Pinto, P., 2021. Pointcloud based 3D object detection and classification methods for self-driving applications: A survey and taxonomy. Information Fusion,68, pp.161-191.
• Florent Lafarge, Clément Mallet. Creating large-scale city models from 3D-point clouds: a robust approach with hybrid representation. International Journal of Computer Vision, Springer Verlag, 2012, 99 (1), pp.69-85. ffhal-00759265f
• Han, X.F., Jin, J.S., Wang, M.J., Jiang, W., Gao, L. and Xiao, L., 2017. A review of algorithms for filtering the 3D point cloud. Signal Processing: Image Communication, 57, pp.103-112.
• Landrieu, L., & Simonovsky, M. (2018). Large-scale point cloud semantic segmentation with superpoint graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (pp. 4558-4567).
• Lin, X. and Zhang, J., 2014. Segmentation-based filtering of airborne LiDAR point clouds by progressive densification of terrain segments. Remote Sensing,6(2), pp.1294-1326.
• Rabbani, T., Van Den Heuvel, F. and Vosselmann, G., 2006. Segmentation of point clouds using smoothness constraint. International archives of photogrammetry, remote sensing and spatial information sciences,36(5), pp.248-253.
• Schnabel, R., Wahl, R., & Klein, R. (2007, June). Efficient RANSAC for point‐cloud shape detection. In Computer graphics forum
• Seif, H.G. and Hu, X., 2016. Autonomous driving in the iCity—HD maps as a key challenge of the automotive industry. Engineering, 2(2), pp.159-162
• Vo, A. V., Truong-Hong, L., Laefer, D. F., & Bertolotto, M. (2015). Octree-based region growing for point cloud segmentation. ISPRS Journal of Photogrammetry and Remote Sensing,104, 88-100.
• Yang, B., Luo, W. and Urtasun, R., 2018. Pixor: Real-time 3d object detection from point clouds. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition (pp. 7652-7660).
• Wang, N., Zhang, Y., Li, Z., Fu, Y., Liu, W. and Jiang, Y.G., 2018. Pixel2mesh: Generating 3d mesh models from single rgb images. In Proceedings of the European Conference on Computer Vision (ECCV) (pp. 52-67).

本模型是基于DnCNN-keras进行的微小调整，主要是将其模型单输入无监督学习(输入纯净图片进行噪声添加并学习去噪)，修改成输入纯净图片与真实的噪声图片进行监督学习，使其去噪能力更为专一与准确。

main.py

首先对迭代函数进行修改：

原代码：

def train_datagen(y_, batch_size=8):    indices = list(range(y_.shape[0]))    while(True):        np.random.shuffle(indices)            for i in range(0, len(indices), batch_size):            ge_batch_y = y_[indices[i:i+batch_size]]            noise =  np.random.normal(0, args.sigma/255.0, ge_batch_y.shape)              ge_batch_x = ge_batch_y + noise             yield ge_batch_x, ge_batch_y

修改后：

def train_datagen(x_, y_, batch_size=8):#添加x_形参    indices = list(range(y_.shape[0]))    while (True):        np.random.shuffle(indices)        for i in range(0, len(indices), batch_size):            ge_batch_x = x_[indices[i:i + batch_size]] # 添加对x的batch处理            ge_batch_y = y_[indices[i:i + batch_size]]            # noise =  np.random.normal(0, args.sigma/255.0, ge_batch_y.shape)    # noise            # #noise =  K.random_normal(ge_batch_y.shape, mean=0, stddev=args.sigma/255.0)            # ge_batch_x = ge_batch_y + noise  # input image = clean image + noise            #将加噪声部分部分注释掉            yield ge_batch_x, ge_batch_y 

对训练函数进行修改：

原函数：

ef train():    data = load_train_data()    data = data.reshape((data.shape[0],data.shape[1],data.shape[2],1))    data = data.astype('float32')/255.0    if args.pretrain:   model = load_model(args.pretrain, compile=False)    else:           if args.model == 'DnCNN': model = models.DnCNN()    model.compile(optimizer=Adam(), loss=['mse'])    ckpt = ModelCheckpoint(save_dir+'/model_{epoch:02d}.h5', monitor='val_loss',                     verbose=0, period=args.save_every)    csv_logger = CSVLogger(save_dir+'/log.csv', append=True, separator=',')    lr = LearningRateScheduler(step_decay)    history = model.fit_generator(train_datagen(data, batch_size=args.batch_size),                    steps_per_epoch=len(data)//args.batch_size, epochs=args.epoch, verbose=1,                     callbacks=[ckpt, csv_logger, lr])    return model

修改后：

def train():    datax = load_train_data(args.train_datax)    datax = datax.reshape((datax.shape[0], datax.shape[1], datax.shape[2], 1))    datax = datax.astype('float32') / 255.0    # 复制粘贴给标签腾地方    datay = load_train_data(args.train_datay)    datay = datay.reshape((datay.shape[0], datay.shape[1], datay.shape[2], 1))    datay = datay.astype('float32') / 255.0    if args.pretrain:        model = load_model(args.pretrain, compile=False)    else:        if args.model == 'DnCNN': model = models.DnCNN()    model.compile(optimizer=Adam(), loss=['mse'])    ckpt = ModelCheckpoint(save_dir + '/model_{epoch:02d}.h5', monitor='val_loss',                           verbose=0, period=args.save_every)    csv_logger = CSVLogger(save_dir + '/log.csv', append=True, separator=',')    lr = LearningRateScheduler(step_decay)    history = model.fit_generator(train_datagen(datax, datay, batch_size=args.batch_size),                                  steps_per_epoch=len(datax) // args.batch_size, epochs=args.epoch, verbose=1,                                  callbacks=[ckpt, csv_logger, lr]) # 添加输入对应形参    return model

修改测试函数：

原函数：

def test(model):  # 略    file_list = glob.glob('{}/*.png'.format(args.test_dir))    for file in file_list:        # read image        img_clean = np.array(Image.open(file), dtype='float32') / 255.0        img_test = img_clean + np.random.normal(0, args.sigma/255.0, img_clean.shape)        img_test = img_test.astype('float32')        # predict  # 略    pd.DataFrame({'name':np.array(name), 'psnr':np.array(psnr), 'ssim':np.array(ssim)}).to_csv(out_dir+'/metrics.csv', index=True)

修改后：

def test(model):  # 略    file_list = glob.glob('{}/*.png'.format(args.test_dir))    for file in file_list:        # read image        img_clean = np.array(Image.open(file), dtype='float32') / 255.0        # img_test = img_clean + np.random.normal(0, args.sigma / 255.0, img_clean.shape)        # 将噪声注释掉        img_test = img_clean.astype('float32')        # predict  # 略    pd.DataFrame({'name':np.array(name), 'psnr':np.array(psnr), 'ssim':np.array(ssim)}).to_csv(out_dir+'/metrics.csv', index=True)

对应train函数，添加预设dir：

parser.add_argument('--train_datax', default='./data/npy_data/x.npy', type=str, help='path of train data')parser.add_argument('--train_datay', default='./data/npy_data/y.npy', type=str, help='path of train data')

data.py

分别打包噪声图片和标签就好了。

还没有跑这个模型，如果失败了会过来继续修改文章。

如果成功了，那就当做一篇记录自己修改(学长帮助)模型的经验记录吧。

一张好的照片明暗合适，画面清晰，色彩合理，下面就这三个点来分别讲解一张好的照片是如何创作出来的。

明暗？曝光！

曝光及曝光三要素

曝光：光线进入相机的过程

控制照片明暗参数-曝光三要素：光圈，快门，感光度ISO

光圈

由一组叶片组成，叶片中间会形成通光孔。

可以想象光圈就是水龙头，光线就是水流。

光圈的表示形式为F*，F后面的数字越小，代表光圈越大。

对拍照的影响：

• 光圈越大，虚化越好。

快门

类似于卷帘门，通过控制叶片的打开时间来控制相机进光量。

长快门可以拉丝。如图：

感光度

感光度，顾名思义，感光度越高对于光线越敏感。

光圈与快门一定的情况下，进入相机的光线总量是一样的，所以感光元件对于光线的敏感程度最后决定了照片的明暗程度也就是曝光度。

对照片影响：ISO越高，噪点越明显。

ISO越低越好

那么何时使用高ISO呢？

• 夜间手持拍摄，因为长时快门对于相机抖动十分敏感，所以应该小快门，大ISO。
• 抓拍运动物体，因为长快门对于物体的瞬间姿态无法捕捉，所以拍摄运动物体应该短快门，如果此时光线不足并且光圈最大，应该最后调节ISO达到合适明暗程度。
• 使用长焦镜头拍摄的时候，相机的轻微抖动很容易模糊，所以应该调节ISO。

三者之间的关系

在ISO尽量小的情况下(100-200)，应该优先考虑快门和光圈的调节。

用水龙头表示就是：

• 阀门打开的大小-光圈大小
• 水流的时间-快门时间
• 水流出的总量-进光量

刚刚好接满一杯水，就是一张好的照片。

光圈和快门是此消彼长的。

• 光圈越大，快门越短，背景虚化越好。

• 光圈越小，快门越大，背景越没有虚化。

曝光模式

日常常用的几种曝光模式：

• A+全自动模式：傻瓜模式，没有任何发挥的空间，与手机摄影无异。有时因为手机先进的软件功能，可能相机的自动模式不如手机。
• P程序自动模式：加强版傻瓜模式，适合新手使用。可以适用于突发状况。
• TV快门优先模式：抓拍或者长快门可使用此模式。
• Av光圈优先模式：可以手动设置光圈和ISO，相机会自动匹配快门时间。利用虚化效果的时候或者风景的时候应该采用此模式。
• M全手动模式：相机中应该会有曝光指示表，一般是-2–2,0为曝光正确，需要拥有丰富的拍摄经验，新手基本上用不到，用到了也没A模式好……
• SCN场景自动模式：相机自己设定的，比如人像，风景，运动模式，不太建议使用。

测光模式

相机对于周围光线的侦测“

• 评价测光(矩阵测光，多重测光)
• 局部测光
• 点测光
• 中央重点平均测光

评价测光

相机会把整个取景画面分成若干个区域，分别测光，对各个区域的亮度值取平均数以此值为基准。

点测光

对一个点进行测光，拍摄逆光环境，如果均衡测光会出现大黑脸状况，所以需要具体针对脸进行测光。

曝光补偿

对画面亮度进行补偿，在半自动模式下可以手动调节曝光补偿表。

应用场景：比如拍摄较黑的物体时，相机会自动调亮场景，此时曝光是不正确的，拍出来的物体是偏灰的，所以需要手动调节曝光补偿表。

白加黑减

• 拍摄小清新的照片的时候可以适当增加曝光补偿。

• 拍摄剪影照片的时候可以适当减少曝光补偿。

灵活

清晰？对焦！

手机对焦：点那儿对那儿

相机对焦：支持触屏，绝大多数情况是半按快门对焦

对焦区域

• 单点自动对焦：适合拍人，手动选择一个点对焦，精确度最高。
• 45点自动对焦：相机自动选择，对焦精确度会有所下降。
• 区域自动对焦/大区域自动对焦：将所有对焦点分成不同区域，相机会自动选择区域中的点自动对焦。精度介于上面两个之间，适合拍摄运动物体。

对焦模式

对焦模式分为自动对焦(AF)和手动对焦(MF)。

自动对焦

半按快门自动拍摄。

对焦模式：

• 单次自动对焦:拍人，只对焦一次
• 人工智能自动对焦(连续伺服AF)：拍运动物体，保持运动物体自动跟随对焦
• 人工智能伺服自动对焦(自动AF)：前两种的结合，拍摄小宝宝，物体运动不规则，此时应该选择这个模式，会在1,2模式无缝切换

手动对焦

镜头前端会有一个对焦环，缓慢的旋转使被摄物体最清晰，即可按下快门拍摄。

一般会按下放大镜进行放大拍摄对焦。

应用于：

• 光线暗
• 大逆光
• 拍摄光斑

色彩？白平衡！

白平衡基本意义：不管在什么环境下，都能将白色还原成白色。

在自然光下，拍摄物体是原本的颜色，但在暖光下可能物体会发黄，所以需要调整白平衡。

在什么光源下选择什么白平衡即可。

大部分设置为自动白平衡即可，在特殊情况下，可以手动设置来调节相片的色调。

import from Numpy

>>> a=np.array([2,3.3])>>> torch.from_numpy(a)tensor([2.0000, 3.3000], dtype=torch.float64)>>> a=np.ones([2,3])>>> torch.from_numpy(a)tensor([[1., 1., 1.],        [1., 1., 1.]], dtype=torch.float64)

import from List

>>> torch.tensor([2,3.2])#torch.tensor接受现有数据，Tensor和FloatTensor接受一个shape(数据的维度)tensor([2.0000, 3.2000])>>> torch.FloatTensor([2.,3.2])#尽量不要使用tensor([2.0000, 3.2000])>>> torch.tensor([2,3.2])tensor([2.0000, 3.2000])>>> torch.tensor([[2,3.2],[3.2,1.]])tensor([[2.0000, 3.2000],        [3.2000, 1.0000]])

uninitialized

• Torch.empty()
• Torch.FloatTensor(d1,d2,d3)
  • Not torch.FloatTensor([1,2])=torch.tensor([1,2])
• Torch.IntTensor(d1,d2,d3)

>>> torch.empty(1)tensor([nan])>>> torch.Tensor(2,3)tensor([[0., 0., 0.],        [0., 0., 0.]])>>> torch.IntTensor(2,3)tensor([[1064135033, 1056173720, 1064928610],        [1038606400, 1060693140, 1040603820]], dtype=torch.int32)>>> torch.FloatTensor(2,3)tensor([[0., 0., 0.],        [0., 0., 0.]])

• 后续要使用其他数据覆盖掉未初始化数据

set default type

>>> torch.tensor([1.2,3]).type()'torch.FloatTensor'>>> torch.set_default_tensor_type(torch.DoubleTensor)>>> torch.tensor([1.2,3]).type()'torch.DoubleTensor'

rand/rand_like,randint

• rand产生不包括1

  >>> a=torch.rand(3,3)>>> atensor([[0.4744, 0.7030, 0.8309],        [0.7480, 0.0447, 0.8336],        [0.7141, 0.0262, 0.5663]])>>> torch.rand_like(a)tensor([[0.4703, 0.5290, 0.2008],        [0.7135, 0.9063, 0.4426],        [0.0830, 0.7966, 0.8128]])>>> torch.randint(1,10,[3,3])tensor([[8, 2, 4],        [2, 5, 1],        [3, 5, 2]])

randn

>>> torch.randn(3,3)#均值为0，方差为1tensor([[ 0.4364,  0.0172,  1.0050],        [ 0.2373, -2.0858, -0.9249],        [ 0.8681,  1.2555, -1.0074]])

full

>>> torch.full([2,3],7)tensor([[7, 7, 7],        [7, 7, 7]])>>> torch.full([],7)tensor(7)>>> torch.full([1],7)tensor([7])

arange/range

>>> torch.arange(0,10)tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])>>> torch.arange(0,10,2)tensor([0, 2, 4, 6, 8])

linspace/logspace

>>> torch.linspace(0,10,steps=4)tensor([ 0.0000,  3.3333,  6.6667, 10.0000])>>> torch.linspace(0,10,steps=10)tensor([ 0.0000,  1.1111,  2.2222,  3.3333,  4.4444,  5.5556,  6.6667,  7.7778,         8.8889, 10.0000])>>> torch.linspace(0,10,steps=11)tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])>>> torch.linspace(0,-1,steps=10)tensor([ 0.0000, -0.1111, -0.2222, -0.3333, -0.4444, -0.5556, -0.6667, -0.7778,        -0.8889, -1.0000])>>> #生成10的0次方为起始值，10的-1次方为终止值的8个数构成的等比数列... c = torch.logspace(0,-1,steps=8)>>> print(c)tensor([1.0000, 0.7197, 0.5179, 0.3728, 0.2683, 0.1931, 0.1389, 0.1000])

Ones/zeros/eye

>>> torch.ones(3,3)tensor([[1., 1., 1.],        [1., 1., 1.],        [1., 1., 1.]])>>> torch.zeros(3,3)tensor([[0., 0., 0.],        [0., 0., 0.],        [0., 0., 0.]])>>> torch.eye(3,3)#对角矩阵tensor([[1., 0., 0.],        [0., 1., 0.],        [0., 0., 1.]])

randperm

• random.shuffle nmpuy

>>> a=torch.rand(2,3)>>> b=torch.rand(2,2)>>> idx=torch.randperm(2)>>> idxtensor([0, 1])>>> idxtensor([0, 1])>>> a[idx]tensor([[0.9459, 0.4927, 0.4129],        [0.3428, 0.3058, 0.5658]])>>> b[idx]tensor([[0.1292, 0.6434],        [0.9975, 0.4396]])>>> a,b(tensor([[0.9459, 0.4927, 0.4129],        [0.3428, 0.3058, 0.5658]]), tensor([[0.1292, 0.6434],        [0.9975, 0.4396]]))

python与pytorch对应转换

怎样表达string

• One-hot
  • [0,1,0,0，…]
  • 缺点：单词之间的相关性并没有体现出来，并且是极度稀疏矩阵。
• Embedding：数字表达语言
  • word2vec
  • glove

数据类型

Type check

in:a = torch.randn(2,3)in:a.type()out:'torch.floatTensor'in: type(a)out:torch.Tensorin:isinstance(a,torch.FloatTensor)out:True

isinstance(data,torch.cude,DoubleTensor)#falsedata=data.cude()isinstance(data,torch.FloatTensor)#True

Dimension 0 /rank 0

torch.tensor(1.)#tensor(1.)torch.tensor(1.3)#tensor(1.300)

Dim 0

>>> a=torch.tensor(2.2)>>> a.shapetorch.Size([])>>> len(a.shape)0>>> a.size()torch.Size([])

• 通常用在loss

dim 1 /rank 1

>>> torch.tensor([1.1])tensor([1.1000])>>> torch.tensor([1.1,2.2])tensor([1.1000, 2.2000])>>> torch.FloatTensor(1)tensor([3.0100e+32])>>> torch.FloatTensor(2)tensor([0.0000, 1.8750])>>> data = np.ones(2)>>> dataarray([1., 1.])>>> torch.from_numpy(data)tensor([1., 1.], dtype=torch.float64)

• 通常用在Bias
• 或者用在Linear Input

>>> a = torch.ones(2)>>> a.shapetorch.Size([2])

Dim 2

>>> a = torch.randn(2,3)>>> atensor([[ 2.8500, -1.0306,  0.4257],        [-0.9918,  0.3094,  0.3869]])>>> a.shapetorch.Size([2, 3])>>> a.size(0)2>>> a.size(1)3>>> a.shape[1]3

• 通常用在带有batch的linear input

>>> import torch>>> a=torch.rand(1,2,3)>>> atensor([[[0.2698, 0.2206, 0.2297],         [0.6471, 0.9053, 0.2742]]])>>> a.shapetorch.Size([1, 2, 3])>>> a[0]tensor([[0.2698, 0.2206, 0.2297],        [0.6471, 0.9053, 0.2742]])>>> list(a.shape)[1, 2, 3]

• RNN input Batch
  • [10个单词，20句话，100维表示]

Dim4

>>> a=torch.rand(2,3,28,28)#张数，通道数，28*28尺寸>>> atensor([[[[0.6408, 0.0313, 0.0700,  ..., 0.1324, 0.7475, 0.1444],          [0.8315, 0.7339, 0.0126,  ..., 0.5260, 0.4896, 0.7950],          [0.5399, 0.6679, 0.6118,  ..., 0.1571, 0.0436, 0.6759],         [[0.6578, 0.7380, 0.5285,  ..., 0.0970, 0.8109, 0.2364],          [0.4398, 0.4145, 0.6420,  ..., 0.7736, 0.1780, 0.4816],          [0.5297, 0.0386, 0.2156,  ..., 0.3286, 0.7100, 0.1554],          ...,          [0.4681, 0.1787, 0.7982,  ..., 0.5238, 0.5333, 0.7992],          [0.5267, 0.1461, 0.7075,  ..., 0.0974, 0.9872, 0.8482],          [0.9274, 0.4764, 0.9747,  ..., 0.1132, 0.7222, 0.1312]]]])>>> a.shapetorch.Size([2, 3, 28, 28])

Mixd

>>> a.shapetorch.Size([2, 3, 28, 28])>>> a.numel()4704>>> a.dim()4>>> a=torch.tensor(1)>>> a.dim()0

想要获取完整代码，请访问面包多进行支持哦，仅需一口奶茶的钱！

一、实验目的

实现基于蒙特卡洛法的21点问题的最优解，了解强化学习的基本原理，理解蒙特卡洛法并编写相应的代码。

二、实验内容

赌场上流行的21点纸牌游戏的目的是获得其数值之和尽可能大而不超过21的牌。所有的人形牌面都算作10，而A可以算作1或11。我们的实验仅考虑每个玩家独立与庄家竞争的版本。游戏开始时，庄家和玩家都有两张牌。庄家的一张牌面朝上，另一张牌面朝下。如果玩家有21张牌（一张A和一张10牌），则称为自然牌。他就赢了，除非庄家也有自然牌，在这种情况下，游戏是平局。如果玩家没有自然牌，那么他可以要求额外的牌，单张发牌(hits)，直到他停止（sticks）或超过21（goes bust）。如果他破产，那么他输了，如果他坚持，那么就轮到庄家的回合。庄家hits或sticks或者goes bust；在牌数字和为17或更多的时候，庄家就停止发牌。赢、输、或平局由谁的最终和值更接近21决定。

三、实验过程

本次实验需要导入如下包：

import gymimport numpy as npfrom collections import defaultdictimport matplotlibimport matplotlib.pyplot as plt

运用gym自带的21点游戏进行接下来的编程：

env = gym.make('Blackjack-v0')observation = env.reset()print(env.action_space, env.observation_space, sep='\n')

这段代码返回了玩家的当前点数之和 ∈{0,1,…,31} ，庄家朝上的牌点数之和 ∈{1,…,10} ，及玩家是否有能使用的ace（no =0 、yes =1 ），和智能体可以执行两个潜在动作：STICK = 0，HIT = 1。

本次实验采用On-policy first-visit MC control，On-policy方法在一定程度上解决了exploring starts这个假设，让策略既greedy又exploratory，最后得到的策略也一定程度上达到最优。如下图所示：

我们定义一个嵌套函数：

def make_epsilon_greedy_policy(Q_table, nA, epsilon):    def generate_policy(observation):        prob_A = np.ones(nA) * epsilon / nA        optimal_a = np.argmax(Q_table[observation])        prob_A[optimal_a] += (1.0 - epsilon)        return prob_A    return generate_policy

MC算法是逐幕进行的，所以我们要根据策略来生成一幕数据。

这里要注意：generate_policy是一个函数即make_epsilon_greedy_policy的返回值。generate_policy的返回值是 π \piπ 。这里循环了1000次只是为了确保能获得完整的一幕。

接下来是MC控制的主体部分，我们要循环足够多的次数使得价值函数收敛，每次循环都首先根据策略生成一幕样本序列，然后遍历每个“状态—价值”二元组，并用所有首次访问的回报的平均值作为估计.

这里要注意：Return和Count是字典，每个“状态—价值”二元组是一个key，该二元组每一幕的回报是它的value，随着越来越多的迭代，根据大数定律，它的平均值会收敛到它的期望值。并且在下一轮迭代生成另外一幕样本序列的时候，generate_policy函数会根据Q_table更新。

def MC_control(env, iteration_times=500000, epsilon=0.1, discount_factor=1.0):    Return, Count, Q_table = defaultdict(float), defaultdict(float), defaultdict(lambda: np.zeros(env.action_space.n))    policy = make_epsilon_greedy_policy(Q_table, env.action_space.n, epsilon)    for i in range(iteration_times):        if i % 1000 == 0:            print(str(i) + "次")        trajectory = generate_one_episode(env, policy)        s_a_pairs = set([(x[0], x[1]) for x in trajectory])        for state, action in s_a_pairs:            s_a = (state, action)            first_visit_id = next(i for i, x in enumerate(trajectory) if x[0] == state and x[1] == action)            G = sum([x[2] * (discount_factor ** i) for i, x in enumerate(trajectory[first_visit_id:])])            Return[s_a] += G            Count[s_a] += 1.            Q_table[state][action] = Return[s_a] / Count[s_a]    return policy, Q_table

接下来是将价值函数可视化：

def plot_value_function(Q_table):    x = np.arange(12, 21)    y = np.arange(1, 10)    X, Y = np.meshgrid(x, y)    Z_noace = np.apply_along_axis(lambda x: Q_table[(x[0], x[1], False)], 2, np.dstack([X, Y]))    Z_ace = np.apply_along_axis(lambda x: Q_table[(x[0], x[1], True)], 2, np.dstack([X, Y]))        def plot_surface(X, Y, Z, title):            代码过长略

实验结束。想要获取完整代码，请访问面包多进行购买

四、实验结果

运行如上代码，在代码文件RL中，输出图所示：

本实验全部源码以及数据集以上架面包多(超便宜)，点击购买，关注公众号[全都是码农]免费获得更多超值内容！

实验内容

某地区的多个罗非鱼池塘水样数据，包含水产专家按水色判断水质分类的数据，以及用数码相机按照标准进行水色采集的数据，如表1和图1所示。每个水质图片命名规则是“类别-编号.jpg”，如“1_1.jpg”是第一类样本的图片。请根据这些样本，利用数字图像处理技术，通过水色图像实现水质的自动评价。

实验过程

观察样本图片，发现其几乎每张图片都有背景噪声，所以需要先对图像进行预处理，如下代码：

输入fromdir为图片文件夹，todir为输出文件夹。

对处理过的图片进行HSV颜色矩提取并打上标签：

接下来编写神经网络相关代码：

分析csv数据：

读取颜色矩：

定义网络变量：

class NNetConfig():    num_classes = 5  # 多分类的种类    num_epochs = 500  # 训练总批次    print_per_epoch = 100  # 每训练多少批次时打印训练损失函数值和预测准确率值    # layersls = [9, 20, 30,60,120,60,30, 20, 5]  # 极其不稳定    # layersls = [9, 20, 30, 60, 120, 60, 30, 20, 5]  # 【输入，隐藏各层节点数，输出】 500轮90%一般,2000轮100%完全拟合    layersls = [9, 20, 60, 20, 5]  # 【输入，隐藏各层节点数，输出】 500轮 90%稳定 2000轮过拟合    learning_rate = 0.01  # 网络学习率    train_filename = './clour/xunshu.csv'  # 训练数据    test_filename = './clour/ceshu.csv'  # 测试数据    best_model_savepath = "./dnn/"  # 最好模型的存放文件夹

编写网络：

class NNet(object):    def __init__(self, config):        self.config = config        self.layersls = config.layersls        self.NNet()    def NNet(self):  # 根据给出的输入输出及每层网络的节点数搭建深度学习网络        """        根据给出的输入输出及每层网络的节点数搭建深度学习网络        :param layersls: 【输入，隐藏各层节点数，输出】        :return:        """        model = tf.keras.Sequential()        for i in range(len(config.layersls)):            if (i == 0):  # 确定网络的输入和网络的第一层节点数                model.add(tf.keras.layers.Dense(config.layersls[1],                                                activation="relu",                                                input_shape=(config.layersls[0],)))                i += 1            elif (i == len(config.layersls) - 1):  # 确定网络的输出                model.add(tf.keras.layers.Dense(config.layersls[i]))            else:  # 网络的各隐藏层节点数                model.add(tf.keras.layers.Dense(config.layersls[i],                                                activation="relu"))        return model

剩下详细代码自行下载阅读

实验结果

运行zero_slip.py输出如下：

\1.  filename **is** :2_6.jpg \2.  the fulll name of the file **is** :.\xun\2_6.jpg \3.  parent **is** :.\xun \4.  filename **is** :2_7.jpg \5.  the fulll name of the file **is** :.\xun\2_7.jpg \6.  parent **is** :.\xun \7.  <......> \8.  the fulll name of the file **is** :.\xun\5_5.jpg \9.  parent **is** :.\xun \10. filename **is** :5_6.jpg \11. the fulll name of the file **is** :.\xun\5_6.jpg \12. 训练集集切割完毕 

切割图像部分如下：

如图所示切割完整，效果良好。

运行first_feature.py进行特征提取：

1.    以输出颜色矩到./clour/ceshu.csv  2.    以输出颜色矩到./clour/xunshu.csv  

输出完整。

运行second_train.py：

输出loss值和准确率值：

\1.  <DatasetV1Adapter shapes: (), types: tf.string> \2.  当前最高准确率：0.455: \3.  Epoch 000: Loss: 6.768, Accuracy: 45.455%， isBest:* \4.  当前最高准确率：0.591: \5.  Epoch 100: Loss: 1.072, Accuracy: 59.091%， isBest:* \6.  当前最高准确率：0.636: \7.  Epoch 200: Loss: 0.787, Accuracy: 63.636%， isBest:* \8.  当前最高准确率：0.727: \9.  Epoch 300: Loss: 0.613, Accuracy: 72.727%， isBest:* \10. Epoch 400: Loss: 0.723, Accuracy: 68.182%， isBest: \11. 开始对已训练网络进行测试： \12. <DatasetV1Adapter shapes: (), types: tf.string> \13. 测试数据的测试结果为: 72.727% \14. tf.Tensor(0.7272727272727273, shape=(), dtype=float64) \15. 预测下面1个水质颜色矩的类别(正确答案为：三)： \16. [[29.5469, 146.3947, 123.1732, 0.864407537, 5.590716583, 1.752484454, 1.029934609, 6.391303213, 2.040322913]] \17. ['三'] 

最后输出正确的验证结果。

运行th_app.py并输入图片地址 ./cep/1_50.jpg ：

1.    输入图片地址:./cep/1_50.jpg  2.    此图片为：['一']  

结果正确。

本实验全部源码以及数据集以上架面包多(超便宜)，点击购买，关注公众号[全都是码农]免费获得更多超值内容！

本实验代码已上传面包多，请点击购买，或者关注[全都是码农]公众号，回复[最近邻]，限时免费获取！

实验概述

本实验皆在运用OpenCV、Python等工具采用适当的算法对手写体数字进行识别与检测，可以提供训练集与测试集进行训练，并可以输入手写字体进行测试检验。

通过独立的完成本实验，可以极大地提高本人对于Python、OpenCV的理解，掌握手写数字的特征提取技术和最近邻模板匹配法。

环境说明

系统：window 10

软件：PyCharm Community Edition 2020.2.2 x64

语言：python 3.6

环境：cv2，numpy，matplotlib.pyplot，time

数据集

本数据集为100张图片，分别为数字0-9，每个数字10张图片，8张训练集，2张测试集。如下：

图 1 数字零	图 2 数字一
图 3 数字二	图 4 数字三

术语定义

训练集：可以训练模型参数，使模型拟合于正确的预测函数。

测试集：通过训练过的模型进行检验，评估最终模型泛化能力。

验证集：用于调超参数，监控模型是否发生过拟合。

需求说明

实验内容

\1. 学习利用行列扫描的方法获取手写数字的上、下、左、右位置的子程序。

\2. 设计手写数字的特征提取算法，并编写对应特征提取程序。

\3. 编写基于最近邻模板匹配的手写数字识别程序。

实验结果与分析

记录输入数字0-9各10个，程序运行后相应的识别结果，并对结果进行深入分析。

\1. 记录每个样品的特征提取效果图。

\2. 记录该样品对应的归一化后的特征值。

\3. 统计每个数字正确识别率。并对错误识别的情况进行深入分析。

软件设计

一、体系设计图

函数清单

代码介绍

（一）Mainapp.py代码

mainapp.py为主程序，表1函数清单中的函数均包含于其中。

运行程序后，程序先行运用ImgToNp()函数将img文件夹中0-9文件夹里的80个样本图片转化为矩阵保存于变量中并将其返回。

四、实验结果

运行mainapp.py后，输出框如下所示：

\1.   图片地址以导入矩阵...... \2.   准备提取特征...... \3.   特征以存储于feature矩阵...... \4.   准备贴标签...... \5.   标签以贴完...... \6.   是否输出特征图与特征值？y/n: 

输入y时，程序将输出80张样本的特征值与特征图，分别存储于”./fandimg/{0-9}”，以及”./fandimg/featureArray/{0-9}”中。如下图：

)

程序继续运行，输出框输出：1.    3-9.bmp 这张图判断错误了，系统判断为：1 最接近的三个结果为：[[3. 7. 1.]]但是正确结果为：3  2.    4-9.bmp 这张图判断错误了，系统判断为：1 最接近的三个结果为：[[1. 1. 1.]]但是正确结果为：4  3.    5-10.bmp 这张图判断错误了，系统判断为：1 最接近的三个结果为：[[5. 1. 1.]]但是正确结果为：5  4.    6-10.bmp 这张图判断错误了，系统判断为：1 最接近的三个结果为：[[1. 1. 1.]]但是正确结果为：6  5.    7-9.bmp 这张图判断错误了，系统判断为：1 最接近的三个结果为：[[1. 1. 1.]]但是正确结果为：7  6.    8-9.bmp 这张图判断错误了，系统判断为：3 最接近的三个结果为：[[8. 9. 3.]]但是正确结果为：8  7.    8-10.bmp 这张图判断错误了，系统判断为：9 最接近的三个结果为：[[8. 9. 9.]]但是正确结果为：8  8.    9-9.bmp 这张图判断错误了，系统判断为：1 最接近的三个结果为：[[9. 7. 1.]]但是正确结果为：9  

f

本实验代码可以通过面包多购买或者关注公众号免费获取。扫码关注回复“模糊汽车”即可获取全部内容！

一、实验目的

理解模糊逻辑推理的原理及特点，熟练应用模糊推理，了解可能性理论。

模糊推理所处理的事物自身是模糊的，概念本身没有明确的外延，一个对象是否符合这个概念难以明确地确定，模糊推理是对这种不确定性,即模糊性的表示与处理。模糊逻辑推理是基于模糊性知识(模糊规则的一种近似推理，一般采用Zadeh 提出的语言变量、语言值、模糊集和模糊关系合成的方法进行推理。

二、实验内容

假设两汽车均为理想状态，即，Y为速度，U为油门控制输入。

（1）设计模糊控制器控制汽车由静止启动，追赶200m外时速90km的汽车并与其保持30m的距离。

（2）在25时刻前车速度改为时速110km时，仍与其保持30m距离。

（3）在35时刻前车速度改为时速70km时，仍与其保持30m距离。

要求：

（1）设计两输入一输出的模糊控制器，给出输入、输出语言变量的隶属函数图，模糊控制规则表，推论结果立体图。

（2）用SIMULINK仿真两车追赶的模糊控制系统，给出目标车的速度曲线图、油门踩放图、追赶车速度图、与前车相对距离图。

三、实验结果

以误差量(两车距离〉及误差对时间的变化量作为输入进行模糊规则设计。本例采用位置型模糊控制器，即控制规则的条件为:

if v为A and th为B then y为C

按一般方法，可得一套控制规律[]如表1所示。

所示规则库有空缺，为了防止失控，可以将(e,△e)按如下公式转换为极坐标(r,θ)

将规则库填满，从而得到表2所示极坐标形式的模糊控制规则：

由上表可知，将θ分为PB PM ZE NM NB,将r分为NB ZE PB，y分为PB PM ZE NM NB。

因此可以根据此表一一写出对应规则如：

等15条规则。

由MATLAB命令行输入fuzzy，配置模糊系统，设置输入r、th(θ)、输出y的论域分别为[0,1]、[-3,3]和[-1,1]，并设置隶属函数(均取三角形)如下：

将建立好的FLS模糊推理系统car5.fis放入工作区，并导入设计好的SIMULINK仿真追赶模型如下：

运行程序输出如下：

四、实验总结

由本次实验可知，隶属度，模糊关系，模糊规则的关系如下：

模糊规则，本质是定义在X x Y的二元模糊关系R。模糊规则的形式为：if x is A then y is B。

模糊关系R是X×Y中的模糊子集。若用μR(u，v)表示其隶属函数，则μR(u，v)反映了u与v有关系R的程度。

本实验达成了要求，并使我学到了很多知识，包括FIS模糊程序的建立，SIMULINK模型的搭建。更主要的是通过这次实验使我更加深刻地理解了这门课程的重要性。

使我学到了很多知识，包括FIS模糊程序的建立，SIMULINK模型的搭建。更主要的是通过这次实验使我更加深刻地理解了这门课程的重要性。

本实验代码可以通过面包多购买或者关注公众号免费获取。扫码关注回复“模糊汽车”即可获取全部内容！

浅析机器视觉在医疗影像处理中的应用

以人工智能，大数据和云计算为代表的新型电子信息产业的快速发展，极大地改善了人们的生活，促进了技术的不断进步。技术创新和智能产品以井喷的形式呈现。在人工智能风潮的影响下，现有的电子信息产业链条正逐步转变为网络信息产业智能网，电子信息产业的新增长点和边界也越来越大。

随着科学技术的飞速发展，单一目标的低精度识别已不能满足社会生产的需求，基于人工智能的图像识别技术已经成为时代的要求。识别图片的目的是将存储的信息与实际信息（当时的感官输入信息）进行比较，以实现图片识别。图像描述是使用字符表现图像中每个特征，甚至对象之间的关联。最后，获得了目标特征及其关系的抽象表达。可以在图像识别过程中使用匹配的模板。在某些特定应用中，图形识别不仅需要识别目标，还需要目标的位置和姿态以指导初始计算。

（一）深度学习在医学图像研究现状

在医学中，医生通常会对感染细胞进行人工诊断，了解患者的细胞感染情况以及病理研究，通过人眼进行判断，十分的耗费人工。当前医学中十分普及的方式就是通过仪器采集部分细胞样本，转化成图片，运用人工进行识别。这种仪器减轻了研究人员的精力消耗，促进了治疗水平的提升，但是依旧存在一些准确率低下的问题。

针对这些不足，决策树算法、Mean-Shift 聚类、FCM 聚类算法、朴素贝叶斯分类器等传统方法在早些年大放异彩，虽然在对医学影像处理的过程中存在着速度快，容易部署等特点，但总体来说传统的方法对于图像的细节辨析存在不足的现象。所以业界逐渐将深度学习引用到了医学领域的图像处理上。

目前，深度学习在医学分类学习和表征学习方面取得了显著进展，有不少研究人员

获得了不错的成果。

2013年，Plis采用DBN来识别脑成像Huntington病变。实验结果表明，深度学习能够学习重要的生理表征，在神经影像学应用中具有很大的潜力[[1]]。同年，Chakdar和Potetz[[2]]使用DBN来提取低级别麟状上皮内病变（Low Grade Squamous Intraepithelial Lesion，LGSIL）的特征，并将这些特征输入SVM进行分类，其分类准确率达到100%。Cruz-Roa等人通过自编码神经网络从常规组织病理学图像中自动识别基底细胞癌，相比传统方法，识别精度提高了7%[[3]]。2014年，Roth[[4]]等人采用卷积神经网络方法用于临床淋巴结病变识别，证明CNN可以推广到二维、三维医学图像分析任务，且对数据集进行随机旋转采样可以提高 CNN的分类性能。

2015年，在CNN基础之上，Ypsilantis[[5]]提出3S-CNN模型对107例食道癌患者的PET图像进行检测，在该数据集上敏感性和特异性分别达到80.7%、81.6%，识别效果远超其它模型。Gao[[6]]为了对核性白内障的严重程度进行分级评估，先将图片输入卷积神经网络，再利用递归神经网络进一步提取特征，最后使用SVM进行分类，结果验证了该模型优于临床白内障分级方面的最新进展。Li等人[20在对阿尔茨海默病进行研究时，将RBM作为基本单元并利用 Dropout技术构建深度学习模型。与经典深度学习方法相比，平均精度提高了5.9%。

2017年初，斯坦福大学研究人员Esteva等人在《Nature》上发表了一篇关于皮肤癌检测的论文[[7]]，其模型的检测正确率及敏感度均超过了专业医师。随着计算机技术的快速发展，利用深度学习技术进行医学图像辅助诊断将会越来越成熟。

（二）医学图像识别的挑战

1. 数据集获取困难

深度学习有如此强大的识别能力基于它庞大的数据集，而在医学领域，病例相同的数据集获取难度颇高，因为CNN的参数多，必须依靠大规模的训练数据才能防止过度拟合。在数据量少的情况下，有两种解决方案：一个叫Data Augmentation。就是依赖现有的图像，通过旋转，平移，变形等变化，产生更多的图像。二是使用转移学习。其思想是通过在另一种大规模的数据集上面训练，得到CNN的参数作为初始值，再在目标数据集上训练对参数进行调优。

2. 医学影像清晰度

医学影像对于不同患者以及不同仪器来说都有显著的差异，包括灰度的变化以及模糊情况。而图像增强作为图像处理中十分重要的一个环节,决定着处理后图像的整体视觉效果与目标图像是否清晰,因此,对医学图像增强算法的研究显得十分重要。

3. 医学影像的维度

随着医学的发展，二维图像已经无法满足医生的要求，例如在肺部高分辨率CT影像的研究中，真正得到的模型其实大多是三维模型，而深度学习主要是基于二维模型的训练，这也是研究人员面临的巨大挑战。

（三）总结与展望

在近几年，逐渐的很多科学家将人工智能思想应用到了医学辅助诊断中，提出了很多将人工智能的思想应用到了医学辅助诊断当中的方法，并开发了许多基于较小样本量的数据集训练出的准确率很理想的模型。

将人工智能识别与人工识别相对比发现，人工智能的效率与准确率要显著高于人类，例如深度学习对于脑肿瘤细胞的检测与识别对于人工的辅助有着很强的实际应用作用，此外，人工智能技术还可以广泛用于设计自动化系统，该系统可以直接检测病人的肿瘤细胞，这将大大降低人的操作难度，节省了医疗人员宝贵的时间。所以人工智能对于医学的发展的帮助是可观的也是乐观的。

从众多的医学影像处理的应用来看,处理方法的来源除了依赖于常见的其它图像处理理论之外,还必须或者最好是从医学影像本身的成像原理出发，设计出适当的医学影像处理法,从而在很大程度上满足实际工作的需要,所以医疗器材的发展也刻不容缓。

参考文献

[[1]] Plis S M, Hjelm D R, Salakhutdinov R, et al. Deep learning for neuroimaging: a validation study[J]. Frontiers in neuroscience, 2014, 8: 229.

[[2]] Chakdar K, Potetz B. Deep learning for the semiautomated analysis of Pap smears[J]. Medical Applications of Artificial Intelligence, 2013: 193-214.

[[3]] Cruz-Roa A A, Ovalle J E A, Madabhushi A, et al. A deep learning architecture for image representation, visual interpretability and automated basal-cell carcinoma cancer detection[C]//International Conference on Medical Image Computing and Computer-Assisted Intervention. Springer, Berlin, Heidelberg, 2013: 403-410.

[[4]] Roth H R, Lu L, Seff A, et al. A new 2.5 D representation for lymph node detection using random sets of deep convolutional neural network observations[C]//International conference on medical image computing and computer-assisted intervention. Springer, Cham, 2014: 520-527.

[[5]] Ypsilantis P P, Siddique M, Sohn H M, et al. Predicting response to neoadjuvant chemotherapy with PET imaging using convolutional neural networks[J]. PloS one, 2015, 10(9): e0137036.

[[6]] Gao X, Lin S, Wong T Y. Automatic feature learning to grade nuclear cataracts based on deep learning[J]. IEEE Transactions on Biomedical Engineering, 2015, 62(11): 2693-2701.

[[7]] Esteva A, Kuprel B, Novoa R A, et al. Dermatologist-level classification of skin cancer with deep neural networks[J]. nature, 2017, 542(7639): 115-118.

已知输入变量与输出变量均为连续变量的预测问题被称为回归问题；

输出变量为有限个离散变量的预测问题称为分类问题。

决策树是一种常见的分类与回归方法，因其呈树状结构而得名。决策树算法的思路简单易懂，但也包含丰富的内容：随机森林、GBDT、Xgboost等流行算法都是在其模型上的延伸。

Q1 简要介绍决策树是什么

决策树是一种描述对实例进行分类的结构。

严格来说，决策树由结点与有向边共同构成树形结构；其中结点又分为内部结点、叶节点，他们分别表示特征、类别。决策树要解决的问题本质上就是从训练数据找到一组“最佳“的分类规则，这个树可能有多个，也可能没有。“最佳”则用损失函数来靠近。

决策树的核心思想就是，找到一个最优特征，对该特征进行最好的划分，并且重复上述步骤，不断丰富内部节点，直到满足指定条件。

决策树的实施包括什么？

决策树的实施包括特征选择，决策树的生成与树的修剪。

1. 特征选择

由于通常实际项目中的特征变量数都会远远大于两个。此时对多个特征进行先后顺序不同的决策时会有不同的结果与准确率，所以就需要“特征选择”来决定当前应选用哪个特征来划分。

直观来讲，当下特征中对分类“最有效”的特征应该优化选择；比如判断是否爱吃四川火锅，“是否爱吃辣”比“是否有洁癖”更有代表性，所以应当排在前面。

从定量的角度，信息增益与信息增益比就是可以表示特征“有效性”的指标。

(1)熵

香农曾说过，信息是用来消除随机不确定性的东西。回到分类问题本身，对于用决策树分类前的数据，因为没有其类别的任何信息，此时数据的不确定性是最大的，熵也是最大的；对于决策树分类后的数据，理论上，特征信息被最有效地利用了，数据的随机不确定性也得到最大程度的消除，数据最后被安排在几种类别中，此时数据的不确定性是最小的，即熵是最小的；而过程中每用一个特征进行一次决策，就能降低一次数据的熵。自然地，当下最优的特征就是使熵降低最多的特征。这就是信息增益的主要思想。

(2)信息增益

那么如何理解信息增益呢？根据定义，信息增益可以视作某一特征对数据集混乱程度降低的贡献程度:即当某个特征确定下来后，数据集熵的降低得越明显，说明该特征对数据集提供了更多的信息，贡献度越大。

一般地，这个差值也称为互信息。

2.那么如何理解信息增益呢？根据定义，信息增益可以视作某一特征对数据集混乱程度降低的贡献程度:即当某个特征确定下来后，数据集熵的降低得越明显，说明该特征对数据集提供了更多的信息，贡献度越大。
一般地，这个差值也称为互信息。

2.决策树的生成

在确定了特征选择的方法后，树就可以一层一层生成了。本节介绍的ID3算法与C4.5算法是由Quinlan分别在1986年与1993年提出的。

(1)ID3 算法

ID3算法在特征选择的过程，用上文所述的信息增益原则进行；在树的生成过程，对所选取的特征的不同取值进行划分；最后建立一棵决策树。值得注意的是在决策树生成前要先设定好一个阈值，当余下所有特征的信息增益小于这个阈值时，树的生长就完成了。

(2)C4.5 算法

C4.5算法是ID3算法的延伸，在特征选择的过程中，用信息增益比的原则进行，这是与ID3算法不同的地方；在树的生成过程，对所选的特征的不同取值进行划分；最后建立一颗决策树。

3.决策树的修剪
根据上述算法生成的决策树，由于考虑到每个特征的每种可能取值，容易出现过拟合，即对训练数据的分类准确率很高，对测试数据分类的准确率比较低。这是决策树的算法特征所决定的，所以对决策树的修剪就显得非常重要。
本文介绍的是用极小化损失函数进行剪枝的方法。损失函数如下所示：

其中T表示确定的一棵决策树，该数共有｜T｜个叶子结点，每个结点下包含训练样本N_t个，H_t（T)表示训练样本N_t的经验熵。

可以看到损失函数包括两部分:决策树分类结果的熵与决策树的叶子结点数量。

极小化损失函数时，既需要使得决策树分类后的数据熵很小，同时也需要满足决策树的叶子结点不能太多，即决策树不能太大。其中系数α表示对两者的平衡，α越大，就越倾向于牺牲一定的模型准确率以减少树的叶子结点数量；反之相反。

剪枝的具体步骤如下:

1)计算每个结点的经验熵。

2)计算损失函数：记当前树的某个叶子结点剪掉前后的树的损失函数，记为C_α（T_前)与C_α（T_后)，若C_α（T_前)≥C_α（T_前)，则剪掉该叶子结点，其父结点成为新的叶子结点，得到一颗新的决策树。

3)对决策树的叶子结点重复2)的过程，直至不能再剪裁为止。

Q2 决策树算法的优点和缺点是什么？

优点：

1)思路简明，计算速度快。

2)决策树的分类规则非常清晰，能够看到那些特征比较重要，具有较强的可解释性。能够同时处理数据型和常规型属性。很多算法要求数据属性是统一的。

3)对缺失值不敏感，可以处理不相关特征数据。

4)不需要任何参数假设。

缺点：

1)对连续的特征变量处理效果不好，因为算法模型中主要都是对分类变量的特征讨论的，例如树的生成时将某一特征的所有属性都生成子叶。

2)在树的生成过程中，对某一特征进行划分时会将该特征每一可能的取值分为一类，就会使得树对取值较多的连续变量过于敏感；例如，如果某特征的每一取值的样本都是唯一的，即是同一类的，用该特征进行划分就会有明显的信息增益。但实际中这并不是最有意义的特征。

3)非常容易过拟合。

Q3 试着简要介绍随机森林

由于决策树分类器的缺点和分类方法自身较为单薄， Leo Breiman和 Adele Cutler于2001年提出了随机森林算法，随机森林，顾名思义，就是指利用多棵决策树对样本进行训练并预测的一种方法。

随机森林的思想可以用一个简单例子来解释。

假设多位评委为饭店评定星级，每位评委都应独立地对餐品做出“五级”或“四级”的评价，最终该饭店的星级，则由所有评委的评价结果决定，最多评委评价的级别就是该饭店的星级。

这里，整个评委团队就像是随机森林的算法模型，饭店则是待测对象，饭店的最终星级由评委团队中每一位评委的投票结果决定。

随森林包含多个决策树，就算每棵树的分类能力比较弱，或者存在误差，但依靠大量决策树的投票结果，误差会相对抵消，从而使得效果较好的“决策树”的分类结果表现出来。这就是随机森林算法的思想。

同样是决策树，随机森林模型既可以处理回归问题，也可以处理分类问题。原因是在随机森林的实施过程中，使用的是不同于上述简单分类决策树的CART决策树。

简要介绍随机森林实施步骤与特点。

1.CART决策树

在介绍随机森林的实验步骤之前，需要先简要介绍一下CART决策树。CART模型的全称是分类与回归树模型，是在1984年由Breiman由出。不同于简单分类决策树，CART决策树是二叉树，即要求对每次某个特征划分时只能分为两类，但会对该特征的不同取值进行多次划分，以保证信息得到充分使用。

下面分别介绍回归树与分类树是如何进行特征选择与树的生成的。

(1)回归树

已知决策树本质上是建立一种划分特征空间的规则，一个特征空间对应着一个输出值。

则回归树模型可写为:

其中R_k表示一划分好的特征空间域，一共有K个这样的划分，每一个划分的特征空间的输出值为c_k，c_k的取值为属于特征空间R_k的样本点的输出值的平均水平，I_(x∈Rk)则为示性函数。
特征选择和树的生成其实就是对特征空间建立划分规则的过程。不同于简单分类决策树，回归树始终满足如下损失函数，并以此为原则进行特征空间的划分:

那怎么认识这个损失函数呢？

首先，由于CART决策树是二叉树，所以每次划分会把特征空间划分为两部分，损失函数就是两部分数据的误差的和，这两部分特征空间分别记为R₁（j，s)与R₂（j，s)。为什么划分好的特征空间会与（j，s)有关呢？假设在一结点选择特征x以及其某一取值s，划分时则将特征空间分为｛x≥s｝与｛x＜s｝两部分。所以特征空间是由（j，s)共同确定的。最小化损失函数是要使得两部分的误差都很小。

然后以第一个部分的误差为例，来看怎么定义一个特征空间内的样本点的误差。根据回归决策树的性质，一个特征范围内的取值是一样的，所以误差才有：

而最合理的c₁取值应该是使得改组内方差最小的值(均值)。这也和回归树模型中C_k的取值方法是统一的。

(2)分类树

分类树（classification tree)简单地说，就是根据训练数据集构造一个类似树形的分类决策模型，然后用这个模型来辅助决策。

例如下图是一个简单的是否举行某个活动的决策树(分类树)：

我们可以通过上面的决策树进行预测，当天气晴朗，交通畅通时，我们预测该活动很可能要举办；当天下小雨交通拥挤时，我们预测活动很可能被取消。

这只是一个简单的小例子，真实中的决策树方法包括以下几个步骤：

(1)收集数据：可以使用任何方法。

(2)准备数据：树构造算法只适用于标称型数据，因此数值型数据必须离散化。

(3)选取划分算法：根据数据的特点，选取合适的划分算法

(4)构造决策树：使用选取的划分算法构造树形的决策模型

(5)测试算法：使用经验树计算错误率

(6)使用算法：使用决策树模型预测决策

2.随机森林的实施步骤

1）随机有放回地从N个训练样本中抽取N个样本，作为生成树的训练集。

2）对K个特征随机选k个作为特征子集在对树做特征选择时，从特征子集中选择最优的特征。

3）让树做最大程度的生长，不做树的修剪。

4）重复1）～3）的步骤T次，建立T棵决策树；若是分类问题，则某样本T棵决策树的投票结果即为最终类别；若是回归问题，则T棵决策树的回归结果的算术平均值即为最终结果。

3.随机森林的几个特点

1）采用Bootstrap抽样法。原因在于:若不如此，会使得每棵树的分类结果一样；这样失去了树之间的独立性，随机森林的“投票”思想也就失去了意义。

2）每次随机从特征中选取k≤K个作为特征子集建立决策树。一方面，可以降低复杂度，加快算法的实施过程；另一方面，可以保证树与树之间有更好的独立性。实际上当k-K时，这里的决策树就等价于普通的CART决策树；k≤K亦可增强模型的泛化能力。

3）不需要对树进行剪裁。已知剪裁是为了避免决策树的过拟合；但由于随机森林的实施过程对样本和特征都进行了随机选择，再加上最终投票的形式，不剪枝也不会出现过拟合，所以就不必剪裁了。

Q4如何做随机森林参数的选择

在实施步骤中包含两个参数:特征子集的数量和需建立的决策树数量T

对于后者，由投票的思想，理论上T应该越大越好；但由于会影响算法的复杂度，应选择适当的T使得准确率与复杂度达到平衡。

对于前者，已知当k较大时，树与树相关性比较强，会影响模型的准确率；k较小时，单棵树的分类能力太差，也会影响模型的准确率。经验上一般把特征数量的对数作为特征子集的数量。

为了更好地取得合适的k，通常会用袋外错误率最低的方法。

实际上，使用 Bootstrap法确定每棵树的训练集时，对于第i棵树，约有三分之一的样本没有参与树的生成；这些样本被称为这棵树的袋外样本(oob样本)由此，袋外错误率(out-of–bag error)的定义如下:

其中N1表示对于某个样本，它作为oob样本的树它的分类错误的棵数，N表示对于某个样本，计算它作为oob样本的树的数量。可证明 oob error是随机森林泛化误差的一个无偏估计。

Q5试简要介绍随机森林的优缺点

优点:

1）在当前所有算法中，有较好的准确率。

2）可高度并行化，对于大数据大样本很有优势。

3）实现过程相对简单。

4）模型较稳健，对部分的特征缺失不敏感。

5）随机森林算法能够降低方差。为什么能降低方差呢？因为随机森林的预测输出值是多课决策树的均值，如果有n个独立同分布的随机变量x_i,它们的方差都为γ²，则它们的均值的方差为：

缺点：

1）对于噪音比较大的样本集，容易过拟合。

2）取值划分较多的特征容易对模型产生更大的影响，从而影响模型的效果

常见面试笔试题:随机森林的“随机性”表现在哪里？比决策树好在哪里？

分析:“随机性”表现在两方面:一方面，每棵决策树的样本是经过 Bootstrap随机选取的；另一方，每棵决策树生成所用到的特征是从所有特征集中随机选取的。

相较于决策树，正因为随机森林的“随机性”，其在过拟合问题上有所改善，极大地提高了分类模型的准确率。

Q6决策树中C4.5算法优化了ID3算法的什么缺点

ID3算法使用信息增益来选择用于分组的变量，但是这样可能会出现偏向于取值比较多的变量的情况，并使得模型预测的准确率下降。而C4.5利用信息增益率能够有效地解决上述ID3使用信息增益时出现的问题。

C4.5算法在构造决策树的过程中可以进行相应的剪枝，但是ID3算法没有。并且C4.5算法在对数据预处理的时候还会对连续型的变量进行离散化处理。