WingDust

WingDust 查看完整档案

填写现居城市  |  填写毕业院校  |  填写所在公司/组织填写个人主网站
编辑
_ | |__ _ _ __ _ | '_ \| | | |/ _` | | |_) | |_| | (_| | |_.__/ \__,_|\__, | |___/ 个人简介什么都没有

个人动态

WingDust 收藏了文章 · 2月28日

装饰者模式和TypeScript装饰器

导读

本文主要为三方面的内容:

  1. 装饰者模式的概念和使用
  2. Typescript装饰器的使用、执行顺序
  3. 编译后的源码分析

学习的目的是对装饰者模式模式有进一步的理解,并运用在自己的项目中;对TypeScript装饰器的理解,更好的使用装饰器,例如在 nodejs web 框架中、 vue-property-decorator 中,或者是自定义装饰器,能熟练运用并掌握其基本的实现原理。

装饰者模式介绍

装饰者模式(Decorator Pattern)也称为装饰器模式,在不改变对象自身的基础上,动态增加额外的职责。属于结构型模式的一种。

使用装饰者模式的优点:把对象核心职责和要装饰的功能分开了。非侵入式的行为修改。

举个例子来说,原本长相一般的女孩,借助美颜功能,也能拍出逆天的颜值。只要善于运用辅助的装饰功能,开启瘦脸,增大眼睛,来点磨皮后,咔嚓一拍,惊艳无比。

经过这一系列叠加的装饰,你还是你,长相不增不减,却能在镜头前增加了多重美。如果你愿意,还可以尝试不同的装饰风格,只要装饰功能做的好,你就能成为“百变星君”。

可以用代码表示,把每个功能抽象成一个类:

// 女孩子
class Girl {
  faceValue() {
    console.log('我原本的脸')
  }
}

class ThinFace  {
  constructor(girl) {
    this.girl = girl;
  }
  faceValue() {
    this.girl.faceValue();
    console.log('开启瘦脸')
  }
}

class IncreasingEyes  {
  constructor(girl) {
    this.girl = girl;
  }
  faceValue() {
    this.girl.faceValue();
    console.log('增大眼睛')
  }
}

let girl = new Girl();
girl = new ThinFace(girl);
girl = new IncreasingEyes(girl);

// 闪瞎你的眼
girl.faceValue(); // 

从代码的表现来看,将一个对象嵌入到另一个对象中,相当于通过一个对象对另一个对象进行包装,形成一条包装链。调用后,随着包装的链条传递给每一个对象,让每个对象都有处理的机会。

这种方式在增加删除装饰功能上都有极大的灵活性,假如你有勇气展示真实的脸,去掉瘦脸的包装即可,这对其他功能毫无影响;假如要增加磨皮,再来个功能类,继续装饰下去,对其他功能也无影响,可以并存运行。

javascript 中增加小功能使用类,显的有点笨重,JavaScript 的优点是灵活,可以使用对象来表示:

let girl = {
  faceValue() {
    console.log('我原本的脸')
  }
}
function thinFace() {
  console.log('开启瘦脸')
}
function IncreasingEyes() {
  console.log('增大眼睛')
}

girl.faceValue = function(){
  const originalFaveValue = girl.faceValue;  // 原来的功能
  return function() {
    originalFaveValue.call(girl);
    thinFace.call(girl);
  }
}()
girl.faceValue = function(){
  const originalFaveValue = girl.faceValue;  // 原来的功能
  return function() {
    originalFaveValue.call(girl);
    IncreasingEyes.call(girl);
  }
}()

girl.faceValue();

在不改变原来代码的基础上,通过先保留原来函数,重新改写,在重写的代码中调用原来保留的函数。

用一张图来表示装饰者模式的原理:

https://cdn.nlark.com/yuque/0/2020/jpeg/150099/1587202888193-39950b89-6763-4932-9122-c2ec93962e20.jpeg

从图中可以看出来,通过一层层的包装,增加了原先对象的功能。

TypeScript中的装饰器

TypeScript 中的装饰器使用 @expression 这种形式,expression 求值后为一个函数,它在运行时被调用,被装饰的声明信息会被做为参数传入。

Javascript规范里的装饰器目前处在 建议征集的第二阶段,也就意味着不能在原生代码中直接使用,浏览器暂不支持。

可以通过 babelTypeScript 工具在编译阶段,把装饰器语法转换成浏览器可执行的代码。(最后会有编译后的源码分析)

以下主要讨论 TypeScript 中装饰器的使用。

TypeScript 中的装饰器可以被附加到类声明、方法、 访问符(getter/setter)、属性和参数上。

开启对装饰器的支持,命令行 编译文件时:

tsc --target ES5 --experimentalDecorators test.ts

配置文件 tsconfig.json

{
    "compilerOptions": {
        "target": "ES5",
        "experimentalDecorators": true
    }
}

装饰器的使用

装饰器实际上就是一个函数,在使用时前面加上 @ 符号,写在要装饰的声明之前,多个装饰器同时作用在一个声明时,可以写一行或换行写:

// 换行写
@test1
@test2
declaration

//写一行
@test1 @test2 ...
declaration

定义 face.ts 文件:

function thinFace() {
  console.log('开启瘦脸')
}

@thinFace
class Girl {
}

编译成 js 代码,在运行时,会直接调用 thinFace 函数。这个装饰器作用在类上,称之为类装饰器。

如果需要附加多个功能,可以组合多个装饰器一起使用:

function thinFace() {
  console.log('开启瘦脸')
}
function IncreasingEyes() {
  console.log('增大眼睛')
}

@thinFace
@IncreasingEyes
class Girl {
}

多个装饰器组合在一起,在运行时,要注意,调用顺序是 从下至上 依次调用,正好和书写的顺序相反。例子中给出的运行结果是:

'增大眼睛'
'开启瘦脸'

如果你要在一个装饰器中给类添加属性,在其他的装饰器中使用,那就要写在最后一个装饰器中,因为最后写的装饰器最先调用。

装饰器工厂

有时需要给装饰器传递一些参数,这要借助于装饰器工厂函数。装饰器工厂函数实际上就是一个高阶函数,在调用后返回一个函数,返回的函数作为装饰器函数。

function thinFace(value: string){
  console.log('1-瘦脸工厂方法')
  return function(){
    console.log(`4-我是瘦脸的装饰器,要瘦脸${value}`)
  }
}
function IncreasingEyes(value: string) {
  console.log('2-增大眼睛工厂方法')
  return function(){
    console.log(`3-我是增大眼睛的装饰器,要${value}`)
  }
}

@thinFace('50%')
@IncreasingEyes('增大一倍')
class Girl {
}

@ 符号后为调用工厂函数,依次从上到下执行,目的是求得装饰器函数。装饰器函数的运行顺序依然是从下到上依次执行。

运行的结果为:

1-瘦脸工厂方法
2-增大眼睛工厂方法
3-我是增大眼睛的装饰器,要增大一倍
4-我是瘦脸的装饰器,要瘦脸50%

总结一下:

  1. 写了工厂函数,从上到下依次执行,求得装饰器函数。
  2. 装饰器函数的执行顺序是 从下到上 依次执行。

类装饰器

作用在类声明上的装饰器,可以给我们改变类的机会。在执行装饰器函数时,会把类构造函数传递给装饰器函数。

function classDecorator(value: string){
  return function(constructor){
    console.log('接收一个构造函数')
  }
}

function thinFace(constructor){
  constructor.prototype.thinFaceFeature = function() {
    console.log('瘦脸功能')
  }
}

@thinFace
@classDecorator('类装饰器')
class Girl {}

let g = new Girl();

g.thinFaceFeature(); // '瘦脸功能'

上面的例子中,拿到传递构造函数后,就可以给构造函数原型上增加新的方法,甚至也可以继承别的类。

方法装饰器

作用在类的方法上,有静态方法和原型方法。作用在静态方法上,装饰器函数接收的是类构造函数;作用在原型方法上,装饰器函数接收的是原型对象。
这里拿作用在原型方法上举例。


function methodDecorator(value: string, Girl){
  return function(prototype, key, descriptor){
    console.log('接收原型对象,装饰的属性名,属性描述符', Girl.prototype === prototype)
  }
}

function thinFace(prototype, key, descriptor){
  // 保留原来的方法逻辑
  let originalMethod = descriptor.value;
  // 改写,增加逻辑,并执行原有逻辑
  descriptor.value = function(){
    originalMethod.call(this);  // 注意修改this的指向
    console.log('开启瘦脸模式')
  }
}

class Girl {

  @thinFace
  @methodDecorator('方式装饰器', Girl)
  faceValue(){
    console.log('我是原本的面目')
  }
}

let g = new Girl();

g.faceValue();

从代码中可以看出,装饰器函数接收三个参数,原型对象、方法名、描述对象。对描述对象陌生的,可以参考 这里;

要增强功能,可以先保留原来的函数,改写描述对象的 value 为另一函数。

当使用 g.faceValue() 访问方法时,访问的就是描述对象 value 对应的值。

在改写的函数中增加逻辑,并执行原来保留的原函数。注意原函数要用 callapplythis 指向原型对象。

属性装饰器

作用在类中定义的属性上,这些属性不是原型上的属性,而是通过类实例化得到的实例对象上的属性。

装饰器同样会接受两个参数,原型对象,和属性名。而没有属性描述对象,为什么呢?这与TypeScript是如何初始化属性装饰器的有关。 目前没有办法在定义一个原型对象的成员时描述一个实例属性。

function propertyDecorator(value: string, Girl){
  return function(prototype, key){
    console.log('接收原型对象,装饰的属性名,属性描述符', Girl.prototype === prototype)
  }
}

function thinFace(prototype, key){
  console.log(prototype, key)
}

class Girl {
  @thinFace
  @propertyDecorator('属性装饰器', Girl)
  public age: number = 18;
}

let g = new Girl();

console.log(g.age); // 18

其他装饰器的写法

下面组合多个装饰器写在一起,出了上面提到的三种,还有 访问符装饰器、参数装饰器。这些装饰器在一起时,会有执行顺序。


function classDecorator(value: string){
  console.log(value)
  return function(){}
}
function propertyDecorator(value: string) {
  console.log(value)
  return function(){
    console.log('propertyDecorator')
  }
}
function methodDecorator(value: string) {
  console.log(value)
  return function(){
    console.log('methodDecorator')
  }
}
function paramDecorator(value: string) {
  console.log(value)
  return function(){
    console.log('paramDecorator')
  }
}
function AccessDecorator(value: string) {
  console.log(value)
  return function(){
    console.log('AccessDecorator')
  }
}
function thinFace(){
  console.log('瘦脸')
}
function IncreasingEyes() {
  console.log('增大眼睛')
}


@thinFace
@classDecorator('类装饰器')
class Girl {
  @propertyDecorator('属性装饰器')
  age: number = 18;
  
  @AccessDecorator('访问符装饰器')
  get city(){}

  @methodDecorator('方法装饰器')
  @IncreasingEyes
  faceValue(){
    console.log('原本的脸')
  }

  getAge(@paramDecorator('参数装饰器') name: string){}
}

运行了这段编译后的代码,会发现这些访问器的顺序是,属性装饰器 -> 访问符装饰器 -> 方法装饰器 -> 参数装饰器 -> 类装饰器。

更详细的用法可以参考官网文档:https://www.tslang.cn/docs/handbook/decorators.html#decorator-factories

装饰器运行时代码分析

装饰器在浏览器中不支持,没办法直接使用,需要经过工具编译成浏览器可执行的代码。

分析一下通过工具编译后的代码。

生成 face.js 文件:

tsc --target ES5 --experimentalDecorators  face.ts

打开 face.js 文件,会看到一段被压缩后的代码,可以格式化一下。

先看这段代码:

__decorate([
    propertyDecorator('属性装饰器')
], Girl.prototype, "age", void 0);
__decorate([
    AccessDecorator('访问符装饰器')
], Girl.prototype, "city", null);
__decorate([
    methodDecorator('方法装饰器'),
    IncreasingEyes
], Girl.prototype, "faceValue", null);
__decorate([
    __param(0, paramDecorator('参数装饰器'))
], Girl.prototype, "getAge", null);
Girl = __decorate([
    thinFace,
    classDecorator('类装饰器')
], Girl);

__decorate 的作用就是执行装饰器函数,从这段代码中能够看出很多信息,印证上面得到的结论。

通过__decorate调用顺序,可以看出来,多个类型的装饰器一起使用时,顺序是,属性装饰器 -> 访问符装饰器 -> 方法装饰器 -> 参数装饰器 -> 类装饰器。

调用了 __decorate 函数,根据使用的装饰器类型不同,传入的参数也不相同。

第一个参数传入的都一样,为数组,这样确保和我们书写的顺序一致,每一项是求值后的装饰器函数,如果写的是 @propertyDecorator() 则一上来就执行,得到装饰器函数,这跟上面分析的一致。

类装饰器会把类作为第二个参数,其他的装饰器,把原型对象作为第二个参数,属性名作为第三个,第四个是 nullvoid 0void 0的值为undefined,也就等于没传参数

要记住传给 __decorate 函数参数的个数和值,在深入到 __decorate 源码中, 会根据这些值来决定执行装饰器函数时,传入参数的多少。

好,来看 __decorate 函数实现:

// 已存在此函数,直接使用,否则自己定义
var __decorate = (this && this.__decorate) ||
// 接收四个参数: 
//decorators存放装饰器函数的数组、target原型对象|类,
//key属性名、desc描述(undefined或null)
function(decorators, target, key, desc) {
  var c = arguments.length,
  // 拿到参数的个数
  r = c < 3 // 参数小于三个,说明是类装饰器,直接拿到类
    ? target
    : desc === null // 第四个参数为 null,则需要描述对象;属性装饰器传入是  void 0,没有描述对象。
        ? desc = Object.getOwnPropertyDescriptor(target, key) 
        : desc,
  d;
  // 如果提供了Reflect.decorate方法,直接调用;否则自己实现
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") 
    r = Reflect.decorate(decorators, target, key, desc);
  else 
    // 装饰器函数执行顺序和书写的顺序相反,从下至上 执行
    for (var i = decorators.length - 1; i >= 0; i--) 
      if (d = decorators[i]) // 拿到装饰器函数
          r = (c < 3 // 参数小于3个,说明是类装饰器,执行装饰器函数,直接传入类
            ? d(r) 
            : c > 3 // 参数大于三个,是方法装饰器、访问符装饰器、参数装饰器,则执行传入描述对象
              ? d(target, key, r) 
              : d(target, key) // 为属性装饰器,不传入描述对象
            ) || r;

  // 给被装饰的属性,设置得到的描述对象,主要是针对,方法、属性来说的
  /*** 
     * r 的值分两种情况,
     *  一种是通过上面的 Object.getOwnPropertyDescriptor 得到的值
     *  另一种,是装饰器函数执行后的返回值,作为描述对象。
     *      一般不给装饰器函数返回值。
    */
  return c > 3 && r && Object.defineProperty(target, key, r),r;
};

上面的参数装饰器,调用了一个函数为 __params

var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};

目的是,要给装饰器函数传入参数的位置 paramIndex

看了编译后的源码,相信会对装饰器的理解更深刻。

以上如有偏差欢迎指正学习,谢谢。~~~~

github博客地址:https://github.com/WYseven/blog,欢迎star。

如果对你有帮助,请关注【前端技能解锁】:
qrcode_for_gh_d0af9f92df46_258.jpg

查看原文

WingDust 发布了文章 · 2月27日

VSCode Feature Request 第一次打开TypeScript文件自动折叠 tsdoc 注释

本人在 VSCode 提了一个
第一次打开TypeScript文件自动折叠 tsdoc 注释 的 Feature Request

如果喜欢这个 Feature 的

请到 ↪open TypeScript file , the Doc comment default be folder去点个赞

随便去了解一下大型开源项目的 Issues Triaging
也是不错的

查看原文

赞 0 收藏 0 评论 0

WingDust 发布了文章 · 2月23日

依VSCode Class源码 实例化时参数 写法 既当参数又当属性

在 VSCode 源码中会有这样的代码

export class ChannelServer<TContext = string> implements IChannelServer<TContext>, IDisposable {
// ...
    private protocolListener: IDisposable | null;
// ...
    constructor(private protocol: IMessagePassingProtocol) {
        this.protocolListener = this.protocol.onMessage(msg => this.onRawMessage(msg));
        // ...
    }

其中在 Class 实例化方法中参数是这样写的 private protocol: IMessagePassingProtocol
内部又对这个变量以 this.protocol 来使用的
做了一个小测试

class Name {
#n:number
c :number =123
p:number
constructor(private sp:number) {
this.#n = 0
this.p = this.sp
// this.c = 0
}
get k():Function{
return (e: any)=>{console.log(e);
}
}
}
let name1 = new Name(4)
console.log(name1);

使用 Deno 运行 $ deno run test.ts

Name { sp: 4, c: 123, p: 4 }
// 可以看到 sp 既当了实例方法的参数又当实例化后属性
  1. 要写成这样好像需要属性的修饰符 即 private 、readonly
  2. 应该要对这个参数定义类型,不然它会被默认认为 any
查看原文

赞 0 收藏 0 评论 0

WingDust 回答了问题 · 2月23日

解决TypeScript vscode 源码 参数类型 不解

补充:
由于 function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map: (...args: any[]) => T = id => id): Event<T> 参数 map 定义了默认类型,所以它将会同是可选的
image.png
也造成了 可以写成先传发射器与事件名并给一个变量,就达成一个

  • 新命名
  • 被包装
  • 可放入函数参数
const onHello = Event.fromNodeEventEmitter<Electron.WebContents>(ipcMain, 'ipc:hello');
// 此时就注册了监听:'ipc:hello'事件的一个回调函数。
const remove = onHello(() => console.log('注册了一个关于`ipc:hello`事件的回调'));

关注 1 回答 2

WingDust 提出了问题 · 2月22日

解决TypeScript vscode 源码 参数类型 不解

 export function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map: (...args: any[]) => T = id => id): Event<T> {
     const fn = (...args: any[]) => result.fire(map(...args));
     const onFirstListenerAdd = () => emitter.on(eventName, fn);
     const onLastListenerRemove = () => emitter.removeListener(eventName, fn);
     const result = new Emitter<T>({ onFirstListenerAdd, onLastListenerRemove });

     return result.event;
 }

map: (...args: any[]) => T = id => id) id是什么意思,怎么是这样写的 = id => id

关注 1 回答 2

WingDust 提出了问题 · 2月22日

解决TypeScript class 私有字段 写法区别请教?

class Name {
  #n:number
  private c :number
  constructor() {
    this.#n = 0
    this.c = 0
  }
  get k():Function{
    return (e: any)=>{console.log(e);
    }
  }
}

let name1 = new Name()
name1.k('asdasd')
name1.c
name1.#n

其中 #nc 两个写法是同样作用吗

关注 2 回答 2

WingDust 回答了问题 · 2月18日

解决想问图片中的英文使用是什么字体

Operator Mono

关注 1 回答 1

WingDust 回答了问题 · 2月18日

解决 python 有多行注释运行报错

好像是在注释中的路径会有这个问题

关注 3 回答 2

WingDust 回答了问题 · 2月18日

解决rollup 的多个 input 的配置文件 怎么写

module.exports = (env = 'production') => {
  return [{
    input: path.join(__dirname, '../src/main/index.ts'),
    output: {
      file: path.join(__dirname, '../src/main/_.js'),
      format: 'cjs',
      name: 'ElectronMainBundle',
      sourcemap: true,
    }, 
    plugins: [
      nodeResolve({ jsnext: true, preferBuiltins: true, browser: true }), // 消除碰到 node.js 模块时⚠警告
      commonjs(),
      typescript(),
    ],
    external: [
      'fs',
      'path',
      'http',
      'https',
      'child_process',
      'os',
      'electron',
    ],
  },
  {
    input:path.join(__dirname, '../src/render/nested-first/server/main.ts'),
    output:{
      file: path.join(__dirname, '../src/render/nested-first/server/main.js'),
      format: 'cjs',
      name: 'ElectronServer',
      sourcemap: true,
    },
    plugins: [
      nodeResolve({ jsnext: true, preferBuiltins: true, browser: true }), // 消除碰到 node.js 模块时⚠警告
      commonjs(),
      typescript(),
    ],
    external: [
      'fs',
      'path',
      'http',
      'https',
      'child_process',
      'os',
      'electron',
    ],
  },
  {
    input:path.join(__dirname, '../src/render/nested-second/server/main.ts'),
    output:{
      file: path.join(__dirname, '../src/render/nested-second/server/main.js'),
      format: 'cjs',
      name: 'ElectronServer',
      sourcemap: true,
    },
    plugins: [
      nodeResolve({ jsnext: true, preferBuiltins: true, browser: true }), // 消除碰到 node.js 模块时⚠警告
      commonjs(),
      typescript(),
    ],
    external: [
      'fs',
      'path',
      'http',
      'https',
      'child_process',
      'os',
      'electron',
    ],
  }
]
};

关注 1 回答 1

WingDust 收藏了文章 · 2月17日

机器学习(四):通俗理解支持向量机SVM及代码实践

上一篇文章我们介绍了使用逻辑回归来处理分类问题,本文我们讲一个更强大的分类模型。本文依旧侧重代码实践,你会发现我们解决问题的手段越来越丰富,问题处理起来越来越简单。

支持向量机(Support Vector Machine, SVM)是最受欢迎的机器学习模型之一。它特别适合处理中小型复杂数据集的分类任务。

一、什么是支持向量机

SMV在众多实例中寻找一个最优的决策边界,这个边界上的实例叫做支持向量,它们“支持”(支撑)分离开超平面,所以它叫支持向量机。

那么我们如何保证我们得到的决策边界是最优的呢?

image

如上图,三条黑色直线都可以完美分割数据集。由此可知,我们仅用单一直线可以得到无数个解。那么,其中怎样的直线是最优的呢?

image

如上图,我们计算直线到分割实例的距离,使得我们的直线与数据集的距离尽可能的远,那么我们就可以得到唯一的解。最大化上图虚线之间的距离就是我们的目标。而上图中重点圈出的实例就叫做支持向量。

这就是支持向量机。

二、从代码中映射理论

2.1 导入数据集

添加引用:

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

导入数据集(大家不用在意这个域名):

df = pd.read_csv('https://blog.caiyongji.com/assets/mouse_viral_study.csv')
df.head()
Med_1_mLMed_2_mLVirus Present
06.508238.582530
14.126123.073461
26.427876.369760
33.672954.905221
41.580322.440561

该数据集模拟了一项医学研究,对感染病毒的小白鼠使用不同剂量的两种药物,观察两周后小白鼠是否感染病毒。

  • 特征: 1. 药物Med_1_mL 药物Med_2_mL
  • 标签:是否感染病毒(1感染/0不感染)

2.2 观察数据

sns.scatterplot(x='Med_1_mL',y='Med_2_mL',hue='Virus Present',data=df)

我们用seaborn绘制两种药物在不同剂量特征对应感染结果的散点图。

image

sns.pairplot(df,hue='Virus Present')

我们通过pairplot方法绘制特征两两之间的对应关系。

image

我们可以做出大概的判断,当加大药物剂量可使小白鼠避免被感染。

2.3 使用SVM训练数据集

#SVC: Supprt Vector Classifier支持向量分类器
from sklearn.svm import SVC

#准备数据
y = df['Virus Present']
X = df.drop('Virus Present',axis=1) 

#定义模型
model = SVC(kernel='linear', C=1000)

#训练模型
model.fit(X, y)

# 绘制图像
# 定义绘制SVM边界方法
def plot_svm_boundary(model,X,y):
    
    X = X.values
    y = y.values
    
    # Scatter Plot
    plt.scatter(X[:, 0], X[:, 1], c=y, s=30,cmap='coolwarm')

    
    # plot the decision function
    ax = plt.gca()
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()

    # create grid to evaluate model
    xx = np.linspace(xlim[0], xlim[1], 30)
    yy = np.linspace(ylim[0], ylim[1], 30)
    YY, XX = np.meshgrid(yy, xx)
    xy = np.vstack([XX.ravel(), YY.ravel()]).T
    Z = model.decision_function(xy).reshape(XX.shape)

    # plot decision boundary and margins
    ax.contour(XX, YY, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
               linestyles=['--', '-', '--'])
    # plot support vectors
    ax.scatter(model.support_vectors_[:, 0], model.support_vectors_[:, 1], s=100,
               linewidth=1, facecolors='none', edgecolors='k')
    plt.show()
plot_svm_boundary(model,X,y)

image

我们导入sklearn下的SVC(Supprt Vector Classifier)分类器,它是SVM的一种实现。

2.4 SVC参数C

SVC方法参数C代表L2正则化参数,正则化的强度与C的值城反比,即C值越大正则化强度越弱,其必须严格为正。

model = SVC(kernel='linear', C=0.05)
model.fit(X, y)
plot_svm_boundary(model,X,y)

我们减少C的值,可以看到模型拟合数据的程度减弱。

image

2.5 核技巧

SVC方法的kernel参数可取值{'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'}。像前文中所使用的那样,我们可以使kernel='linear'进行线性分类。那么如果我们像进行非线性分类呢?

2.5.1 多项式内核

多项式内核kernel='poly'的原理简单来说就是,用单一特征生成多特征来拟合曲线。比如我们拓展X到y的对应关系如下:

XX^2X^3y
06.508236.50823**26.50823**30
14.126124.12612**24.12612**31
26.427876.42787**26.42787**30
33.672953.67295**23.67295**31
41.580321.58032**21.58032**31

这样我们就可以用曲线来拟合数据集。

model = SVC(kernel='poly', C=0.05,degree=5)
model.fit(X, y)
plot_svm_boundary(model,X,y)

我们使用多项式内核,并通过degree=5设置多项式的最高次数为5。我们可以看出分割出现了一定的弧度。

image

2.5.2 高斯RBF内核

SVC方法默认内核为高斯RBF,即Radial Basis Function(径向基函数)。这时我们需要引入gamma参数来控制钟形函数的形状。增加gamma值会使钟形曲线变得更窄,因此每个实例影响的范围变小,决策边界更不规则。减小gamma值会使钟形曲线变得更宽,因此每个实例的影响范围变大,决策边界更平坦。

model = SVC(kernel='rbf', C=1,gamma=0.01)
model.fit(X, y)
plot_svm_boundary(model,X,y)

image

2.6 调参技巧:网格搜索

from sklearn.model_selection import GridSearchCV
svm = SVC()
param_grid = {'C':[0.01,0.1,1],'kernel':['rbf','poly','linear','sigmoid'],'gamma':[0.01,0.1,1]}
grid = GridSearchCV(svm,param_grid)
grid.fit(X,y)
print("grid.best_params_ = ",grid.best_params_,", grid.best_score_ =" ,grid.best_score_)

我们可以通过GridSearchCV方法来遍历超参数的各种可能性来寻求最优超参数。这是通过算力碾压的方式暴力调参的手段。当然,在分析问题阶段,我们必须限定了各参数的可选范围才能应用此方法。

因为数据集太简单,我们在遍历第一种可能性时就已经得到100%的准确率了,输出如下:

grid.best_params_ =  {'C': 0.01, 'gamma': 0.01, 'kernel': 'rbf'} , grid.best_score_ = 1.0

总结

当我们处理线性可分的数据集时,可以使用SVC(kernel='linear')方法来训练数据,当然我们也可以使用更快的方法LinearSVC来训练数据,特别是当训练集特别大或特征非常多的时候。
当我们处理非线性SVM分类时,可以使用高斯RBF内核,多项式内核,sigmoid内核来进行非线性模型的的拟合。当然我们也可以通过GridSearchCV寻找最优参数。

往期文章:

查看原文

认证与成就

  • 获得 1 次点赞
  • 获得 4 枚徽章 获得 0 枚金徽章, 获得 1 枚银徽章, 获得 3 枚铜徽章

擅长技能
编辑

(゚∀゚ )
暂时没有

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2019-12-07
个人主页被 1.2k 人浏览