GO编程模式–错误处理

Error Check  Hell

说到 Go 语言的 if err !=nil 的代码了,这样的代码的确是能让人写到吐。那么有没有什么好的方式呢,有的。我们先看如下的一个令人崩溃的代码。

func parse(r io.Reader) (*Point, error) {

    var p Point

    if err := binary.Read(r, binary.BigEndian, &p.Longitude); err != nil {
        return nil, err
    }
    if err := binary.Read(r, binary.BigEndian, &p.Latitude); err != nil {
        return nil, err
    }
    if err := binary.Read(r, binary.BigEndian, &p.Distance); err != nil {
        return nil, err
    }
    if err := binary.Read(r, binary.BigEndian, &p.ElevationGain); err != nil {
        return nil, err
    }
    if err := binary.Read(r, binary.BigEndian, &p.ElevationLoss); err != nil {
        return nil, err
    }
}

要解决这个事,我们可以用函数式编程的方式,如下代码示例:

func parse(r io.Reader) (*Point, error) {
    var p Point
    var err error
    read := func(data interface{}) {
        if err != nil {
            return
        }
        err = binary.Read(r, binary.BigEndian, data)
    }

    read(&p.Longitude)
    read(&p.Latitude)
    read(&p.Distance)
    read(&p.ElevationGain)
    read(&p.ElevationLoss)

    if err != nil {
        return &p, err
    }
    return &p, nil
}

上面的代码我们可以看到,我们通过使用Closure 的方式把相同的代码给抽出来重新定义一个函数,这样大量的  if err!=nil 处理的很干净了。但是会带来一个问题,那就是有一个 err 变量和一个内部的函数,感觉不是很干净。

那么,我们还能不能搞得更干净一点呢,我们从Go 语言的 bufio.Scanner()中似乎可以学习到一些东西:

scanner := bufio.NewScanner(input)

for scanner.Scan() {
    token := scanner.Text()
    // process token
}

if err := scanner.Err(); err != nil {
    // process the error
}

上面的代码我们可以看到,scanner在操作底层的I/O的时候,那个for-loop中没有任何的 if err !=nil 的情况,退出循环后有一个 scanner.Err() 的检查。看来使用了结构体的方式。模仿它,我们可以把我们的代码重构成下面这样:

首先,定义一个结构体和一个成员函数

type Reader struct {
    r   io.Reader
    err error
}

func (r *Reader) read(data interface{}) {
    if r.err == nil {
        r.err = binary.Read(r.r, binary.BigEndian, data)
    }
}

然后,我们的代码就可以变成下面这样:

func parse(input io.Reader) (*Point, error) {
    var p Point
    r := Reader{r: input}

    r.read(&p.Longitude)
    r.read(&p.Latitude)
    r.read(&p.Distance)
    r.read(&p.ElevationGain)
    r.read(&p.ElevationLoss)

    if r.err != nil {
        return nil, r.err
    }

    return &p, nil
}

有了上面这个技术,我们的“流式接口 Fluent Interface”,也就很容易处理了。如下所示:

package main

import (
  "bytes"
  "encoding/binary"
  "fmt"
)

// 长度不够,少一个Weight
var b = []byte {0x48, 0x61, 0x6f, 0x20, 0x43, 0x68, 0x65, 0x6e, 0x00, 0x00, 0x2c} 
var r = bytes.NewReader(b)

type Person struct {
  Name [10]byte
  Age uint8
  Weight uint8
  err error
}
func (p *Person) read(data interface{}) {
  if p.err == nil {
    p.err = binary.Read(r, binary.BigEndian, data)
  }
}

func (p *Person) ReadName() *Person {
  p.read(&p.Name) 
  return p
}
func (p *Person) ReadAge() *Person {
  p.read(&p.Age) 
  return p
}
func (p *Person) ReadWeight() *Person {
  p.read(&p.Weight) 
  return p
}
func (p *Person) Print() *Person {
  if p.err == nil {
    fmt.Printf("Name=%s, Age=%d, Weight=%d\n",p.Name, p.Age, p.Weight)
  }
  return p
}

func main() {   
  p := Person{}
  p.ReadName().ReadAge().ReadWeight().Print()
  fmt.Println(p.err)  // EOF 错误
}

包装错误

最后,多说一句,我们需要包装一下错误,而不是干巴巴地把err给返回到上层,我们需要把一些执行的上下文加入。

通常来说,我们会使用 fmt.Errorf()来完成这个事,比如:

if err != nil {
   return fmt.Errorf("something failed: %v", err)
}

另外,在Go语言的开发者中,更为普遍的做法是将错误包装在另一个错误中,同时保留原始内容:

type authorizationError struct {
    operation string
    err error   // original error
}

func (e *authorizationError) Error() string {
    return fmt.Sprintf("authorization failed during %s: %v", e.operation, e.err)
}

当然,更好的方式是通过一种标准的访问方法,这样,我们最好使用一个接口,比如 causer接口中实现 Cause() 方法来暴露原始错误,以供进一步检查:

type causer interface {
    Cause() error
}

func (e *authorizationError) Cause() error {
    return e.err
}

这里有个好消息是,这样的代码不必再写了,有一个第三方的错误库(github.com/pkg/errors),对于这个库,我无论到哪都能看到他的存在,所以,这个基本上来说就是事实上的标准了。代码示例如下:

import "github.com/pkg/errors"

//错误包装
if err != nil {
    return errors.Wrap(err, "read failed")
}

// Cause接口
switch err := errors.Cause(err).(type) {
case *MyError:
    // handle specifically
default:
    // unknown error
}

PyQT5环境配置

1. Conda环境

建议安装conda环境,可以方便的维护和切换多个不用的Python环境

创建新的conda虚拟python环境:

conda create -n env_name python=3.x

启动conda环境:

conda activate env_name

2. PyQt5安装

pip install pyqt5

3. QtDesigner

对于开发稍微复杂一些的界面,建议安装QtDesigner

https://build-system.fman.io/qt-designer-download

4. UI资源编译

编译.ui文件

例如,ui文件为w_main.ui, 编译命令如下

pyuic5 -o w_main.py w_main.ui

编译资源文件

例如,资源文件为apprcc.qrc, 编译命令如下:

pyrcc5 -o apprcc_rc.py apprcc.qrc

人工智能中的分类算法

本质

给定一个对象X,将其划分到预定义好的某一个类别Yi中的算法

分类算法解决什么问题

人群分类,新闻分类,query分类,商品分类,网页分类,垃圾邮件过滤,网页排序

分类算法

1. Naive Bayesian Mode 朴素贝叶斯模型

最简单的监督学习分类器,这个分类器模型是建立在每一个类别的特征向量服从正态分布的基础上的(据说不满足独立分布,效果也很好),因此也被称为概率分类器。整个分布函数被假设为一个高斯分布,每一类别一组系数。当给定了训练数据,算法将会估计每一个类别的向量均值和方差矩阵,然后根据这些进行预测。

特点:如果没有很多数据,该模型会比很多复杂的模型获得更好的性能,因为复杂的模型用了太多假设,以致产生欠拟合。

2.K Nearest Neighbors(KNN) K近邻

这个算法首先贮藏所有的训练样本,然后通过分析(包括选举,计算加权和等方式)一个新样本周围K个最近邻,然后把新样本标记为在K近邻点中频率最高的类。

这种方法有时候被称作“基于样本的学习”,即为了预测,我们对于给定的输入搜索最近的已知其相应的特征向量。

特点:简单有效,但因为需要存储所有的训练集,占用很大内存,速度比较慢。使用该方法前通常训练集先聚类来降低数据大小。

3. Support Vector Machines(SVM) 支持向量机

SVM是一种基于核函数的方法,它通过某些核函数把特征向量映射到高维空间(一般情况下高维空间上比低维空间上更加线性可分),然后建立一个线性判别函数(或者说是一个高维空间中的能够区分训练数据的最优超平面)。最优解在某种意义上是两类中距离分割面最近的特征向量和分割面的距离最大化。离分割面最近的特征向量被称为”支持向量”,意即其它向量不影响分割面(决策函数)。

特点:当数据集合比较小的时候,支持向量机的效果常常最好。对于核来说,不仅仅只存在于 SVM 内,对于任意的算法,只要计算时出现了内积的,都可以用核函数替代,从而提高在高维数据上的性能

4. Decision Trees 决策树

决策树是一个二叉树。当每个叶节点用类别标识(多个叶子可能有相同的标识)时,它可以表示分类树;当每个叶节点被分配了一个常量(所以回归函数是分段常量)时,决策树就成了回归树。决策树是从根结点递归构造的。用所有的训练数据(特征向量和对应的响应)来在根结点处进行分裂。在每个结点处,优化准则(比如最优分裂)是基于一些基本原则来确定的(比如ML中的“纯度purity”原则被用来进行分类,方差之和用来进行回归)。所有的数据根据初始和替代分裂点来划分给左右子结点(就像在预测算法里做的一样)。然后算法回归的继续分裂左右子结点。

a) 树的深度达到了指定的最大值

b) 在该结点训练样本的数目少于指定值,比如,没有统计意义上的集合来进一步进行结点分裂了。

c) 在该结点所有的样本属于同一类(或者,如果是回归的话,变化已经非常小了)

d) 跟随机选择相比,能选择到的最好的分裂已经基本没有什么有意义的改进了。

决策树自身的优点:

) 计算简单,易于理解;

b) 适应不同的数据类型(包括类别数据,数值数据,未归一化的和混合的数据);

c) 比较适合处理有缺失属性的样本;

d) 通过分裂的顺序给数据特征赋不同的重要性;

e) 能够处理不相关的特征;

f) 在相对短的时间内能够对大型数据源做出可行且结果良好的结果;

g) 决策树构成了其他算法的基础(如boosting和随机数)。

决策树的缺点

a) 容易发生过拟合(随即森林可以很大程度上减少过拟合);

b) 忽略了数据之间的相关性;

c) 对于那些,各类别样本数量不一致的数据,在决策树中,信息增益的结果偏向于那些具有更多数值的特征(只要使用了信息增益,都有这个特点,如RF)

5. Boosting

Boosting 是个非常强大的学习方法, 它也是一个监督的分类学习方法。它组合许多“弱”分类器来产生一个强大的分类器组。一个弱分类器的性能只是比随机选择好一点,因此它可以被设计的非常简单并且不会有太大的计算花费。将很多弱分类器结合起来组成一个集成的强分类器。boosting分类器和随机森林在内部使用了决策树,所以继承了决策树的很多有用的性质(能够处理混合数据模型、没有归一化的数据、特征丢失)。

AdaBoost算法如下:

1. 给定N样本 (xi,yi) 其中

2. 初始化权值

3. 重复 for m = 1,2,…,M:

a) 根据每个训练数据的wi计算。

b) 计算

c) 更新权值并归一化使 Σiwi= 1.

4. 输出分类器

特点:简单,不容易发生过拟合,不用做特征筛选。Boosting算法是一个两类分类器(不像决策树和随机森林)

6. Random Trees 随机森林

随机森林既可以解决回归问题,也可以解决分类问题。随机森林可以通过收集很多树的子节点对各个类别投票,然后选择获得最多投票的类别作为判断结果。通过计算”森林“的所有子节点的值的平均值来解决回归问题。

随机森林建立时的基本子系统也是决策树。在建立决策树时会一直继续下去直到数据纯净。因此,尽管每个树都很好的学习了训练数据,但各个树之间仍有很大不同。我们把这些树放到一起求平均以消除这些不同(因此叫随机森林)。当然,如果所有的树都相同,随机森林也没有很大作用。为了克服这点,随机森林通过在树的建立过程中,随机选择特征子集来使各个树不同。例如,一个目标识别树可以有很多可能的特征:颜色,质地,倾斜度等。树的每个节点可以从这些特征中随机的选择子集,来决定怎样更好地分裂数据。每个后来的节点都获得新的、随机选择的特征子集。

特点:与boosting和决策树相比,随机森林可以使用更少的重要变量,获得最好的预测性能。即我们可以收缩特征集的大小,在不损失性能的前提下减少计算量和内存使用随机森林。

7. Neural Networks 神经网络

神经网络是对非线性可分数据的分类方法。与输入直接相连的称为隐藏层( hidden layer),与输出直接相连的称为输出层(output layer)。

特点:不知道隐藏层计算的东西的意义;有比较多的局部最优值,可以通过多次随机设定初始值然后运行梯度下降算法获得最优值。

Arduino 中断

各种型号Arduino外部中断引脚

型号Int.0Int.1Int.2Int.3Int.4Int.5备注
UNO23
Mega25602321201918
Leonardo3201
Due所以IO都可

中断函数

中断函数不能带任何参数,且没有返回类型

例如:

void hello()
{
  Serial.println("hello");
}

中断模式

在大多数arduino上有以下四种触发方式:

LOW低电平触发
CHANGE            电平变化,高电平变低电平、低电平变高电平
RISING              上升沿触发
FALLING            下降沿触发
HIGH                 高电平触发(该中断模式仅适用于Arduino Due)

设置中断

配置函数如下:
attachInterrupt(interrupt, function, mode);

interrupt为你中断通道编号,function为中断函数,mode为中断触发模式

需要注意的是在Arduino Due中,中断设置有点不同:
attachInterrupt(pin, function, mode); 

due 的每个IO均可以进行外部中断,所以这里第一个参数为pin,即你使用的引脚编号。

例子

int pin = 13;
volatile int state = LOW;

void setup()
{
  pinMode(pin, OUTPUT);
  attachInterrupt(0, blink, CHANGE);//当int.0电平改变时,触发中断函数blink
}

void loop()
{
  digitalWrite(pin, state);
}

void blink()//中断函数
{
  state = !state;
}

ESP32

const byte interruptPin = 25;
volatile int interruptCounter = 0;
int numberOfInterrupts = 0;
portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;


void handleInterrupt() {
  portENTER_CRITICAL_ISR(&mux);
  interruptCounter++;
  portEXIT_CRITICAL_ISR(&mux);
}

void setup() {
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), handleInterrupt, FALLING);
}

void loop() {
  if(interruptCounter>0){
    portENTER_CRITICAL(&mux);
    interruptCounter--;
    portEXIT_CRITICAL(&mux);
    numberOfInterrupts++;
    Serial.print("An interrupt has occurred. Total: ");
    Serial.println(numberOfInterrupts);
  }

  delay(1000);
}

Arduino ESP32 AD7176数据采集

新完成了一个AD7176数据采集项目:

这个板卡的质量很好,高速采集下仍然很稳定

  // --------A: ADc和接口模式配置 -------------
  // A.1:  ADC模式寄存器
  setupAdcModeReg();    // 0x01
  delay(1);

  // GPIO配置寄存器
  setupGPIOReg();      // 0x06

  //-------- B: ADC设置 ---------------------
  // B.1: 设置配置寄存器
  setupConfigReg();   // 0x20
  // B.2: 滤波器配置寄存器
  setupFilterReg();  // 0x28
  // B.3: 失调寄存器
  setupOffsetReg();  // 0x30
  // B.4: 增益寄存器
  setupGainReg();    // 0x38

  // ------C: 通道映射设置 -----------------
  // C.1: 通道映射
  setupChMap();     // 0x10

  // A.2: 接口模式寄存器
  setupIfModeReg();    // 0x02

理解了上面这个配置流程,开发起来也就很容易了。

C语言-Tips

指针数组

#include <stdio.h>
int main(){
    int a = 16, b = 932, c = 100;
    //定义一个指针数组
    int *arr[3] = {&a, &b, &c};//也可以不指定长度,直接写作 int *arr[]
    //定义一个指向指针数组的指针
    int **parr = arr;
    printf("%d, %d, %d\n", *arr[0], *arr[1], *arr[2]);
    printf("%d, %d, %d\n", **(parr+0), **(parr+1), **(parr+2));
    return 0;
}

运行结果:
16, 932, 100
16, 932, 100

arr 是一个指针数组,它包含了 3 个元素,每个元素都是一个指针,在定义 arr 的同时,我们使用变量 a、b、c 的地址对它进行了初始化,和普通数组类似

parr 是指向数组 arr 的指针,确切地说是指向 arr 第 0 个元素的指针,它的定义形式应该理解为int *(*parr),括号中的*表示 parr 是一个指针,括号外面的int *表示 parr 指向的数据的类型。arr 第 0 个元素的类型为 int *,所以在定义 parr 时要加两个 *。

第一个 printf() 语句中,arr[i] 表示获取第 i 个元素的值,该元素是一个指针,还需要在前面增加一个 * 才能取得它指向的数据,也即 *arr[i] 的形式。

第二个 printf() 语句中,parr+i 表示第 i 个元素的地址,*(parr+i) 表示获取第 i 个元素的值(该元素是一个指针),**(parr+i) 表示获取第 i 个元素指向的数据。