【JVM故事】了解JVM的結構,好在面試時吹牛


class文件格式

參考上一篇文章《【JVM故事】一個Java字節碼文件的誕生記》,後續還會專門講解class文件的內部結構。

數據類型

jvm包括兩種數據類型,基本類型和引用類型。

基本類型包括,數值類型,boolean類型,和returnAddress類型。

數值類型包括,整型,浮點型,和char類型。

boolean類型同樣只有true和false。

returnAddress類型是一個指針,指向jvm指令的操作碼,在Java中沒有與之對應的類型。

boolean類型的操作會被轉化為int類型的操作進行,boolean數組會當成byte數組去操作。1表示true,0表示false。

引用類型包括三種,類類型,數組類型,和接口類型。

它們的值是動態創建的類實例,數組,或實現接口的類實例。

數組有component類型和element類型,component類型就是數組去掉最外層維度后剩下的類型,可能還是一個數組類型(對於多維數組)。

element類型就是數組裡面存儲的最小數據的類型,它必須是一個基本類型,類類型,或接口類型。

對於一維數組的話,component類型和element類型是相同的。

引用類型還有一個特殊值,就是null,表示沒有引用任何對象。

運行時公有數據區

堆

jvm有一個堆,在所有jvm線程間共享,堆是一個運行時數據區域,所有為類實例和數組分配的內存都來自於它。

堆在jvm啟動時創建,堆中對象不用顯式釋放,gc會幫我們釋放並回收內存。

方法區

jvm有一個方法區,在所有jvm線程間共享,它存儲每一個類的結構。

像運行時常量池,字段和方法數據,方法和構造函數的代碼,還有特殊的方法用於類和實例的初始化,以及接口的初始化。

方法區在jvm啟動時創建,雖然方法區在邏輯上是堆的一部分。

但簡單實現時可以選擇不進行gc和壓縮,本規範沒有強制要求方法區的位置,也沒有要求管理已編譯代碼的策略。

運行時常量池

運行時常量池就是類或接口的字節碼文件里的常量池的運行時表示形式,它包含幾種常量。

如在編譯時就已經知道的数字字面量值,和必須在運行時解析的方法和字段的引用,運行時常量池的功能類似於傳統語言的符號表,不過它包含的數據會更加寬泛。

運行時常量池分配在jvm的方法區,類或接口的運行時常量池在類或接口被jvm創建時才會構建。

運行時私有數據區

pc寄存器

jvm支持一次運行多個線程,每個線程都有自己的pc寄存器,任何時候一個線程只能運行一個方法的代碼。

如果方法不是native的,pc寄存器包含當前正在被執行的jvm指令地址,如果方法是native的,pc寄存器的值是未定義的。

jvm棧

每一個jvm線程都有一個私有的jvm棧,隨着線程的創建而創建,棧中存儲的是幀。

jvm棧和傳統語言如C的棧相似,保存局部變量和部分計算結果,參与方法的調用和返回。jvm棧主要用於幀的出棧和入棧,除此之外沒有其它操作,

幀可能是在堆上分配的,所以jvm棧使用的內存不必是連續的。

native方法棧

native方法不是用Java語言寫的,為了支持它需要使用傳統棧,如C語言棧。不過jvm不能加載native方法,所以也不需要提供native方法需要的棧。

幀

每次當一個方法被調用時一個新的幀會被創建。當方法調用完成時,與之對應的幀會被銷毀,無論是正常完成還是拋異常結束。

所以幀是方法調用的具體體現形式,或稱方法調用是以幀的形式進行的。幀用來存儲數據和部分計算結果,和執行動態鏈接,方法返回值,分發異常。

幀分配在創建幀的線程的jvm棧上,每一個幀都有自己的本地變量數組,自己的操作數據棧,和一個對當前方法所在類的運行時常量池的引用。

本地變量數組和操作數棧的大小在編譯時就確定了,它們隨着和幀關聯的方法編譯后的代碼一起被提供,因此幀這種數據結構的大小隻依賴於jvm的實現,這些結構所需的內存可以在方法調用時同時被分配。

在一個線程執行的任何時刻,都只會有一個幀是處於激活的。這個幀被稱為當前幀,與之對應的方法被稱為當前方法,方法所在的類被稱為當前類,此時用到的本地變量數組和操作數棧也都是當前幀的。

一個幀將不在繼續是當前幀,如果它的方法調用了另一個方法,或者它的方法結束了。

當一個方法被調用,一個新的幀被創建,當執行控制由原來的方法傳遞到新的方法時,這個新的幀變為當前幀。

當方法返回時,當前幀把方法執行的結果傳回到上一幀,當上一幀被激活的同時當前幀會被丟棄。

本地變量數組

每一幀都包含一個變量數組,就是都熟知的本地變量存儲的地方。這個本地變量數組的長度在編譯時確定,隨着編譯后的方法代碼一起提供。

通常一個本地變量(的位置)能夠存儲一個類型的值,但是long和double類型卻需要兩個本地變量(的位置)才能存一個值。

本地變量按索引尋址,第一個本地變量的索引是0。long和double需要消耗兩個連續的索引,但卻是按照較小的這個索引尋址的。不能按照較大的那個索引去讀數據,但是可以寫入,當然這樣將使本地變量內容錯亂。

在方法被調用時,jvm使用本地變量來接收傳遞進來的參數值。在類(靜態)方法調用時,所有參數被傳入從索引0開始的連貫的本地變量數組裡。

在實例(非靜態)方法調用時,索引0處總是傳入正在其上執行方法調用的那個對象的引用,(就是Java中的this了),所有參數被傳入從1開始的連貫的本地變量數組裡。

操作數棧

每個幀包含一個後進先出的棧,用於存儲正在執行的jvm指令的操作數,就是都熟知的操作數棧,這個棧的最大深度在編譯時就已確定,隨着編譯后的方法代碼一起提供。

當幀被創建時,操作數棧是空的,jvm提供一些指令用於加載常量值,本地變量值,字段值到操作數棧上,另一些jvm指令採用操作數棧上的操作數進行操作,並把結果放回到操作數棧上。

操作數棧也用於準備將要傳遞給方法調用的參數和接收方法調用返回的結果。

long和double類型的值佔用兩個單位的棧深度,其它類型的值佔用一個單位的棧深度。

動態鏈接

每一個幀都包含了對當前方法所屬類型的運行時常量池的引用。目的是為了支持方法代碼的動態鏈接。class文件中描述一個方法引用被調用的方法和被訪問的變量的代碼,是採用符號引用的形式實現的。

符號引用的形式可以粗略的認為是字符串的形式,就是用字符串標明需要調用哪個類的哪個方法或訪問哪個字段或變量。就像符號引用這個名字一樣,這些僅僅是符號,是拿不到具體值的,所以必須要進行轉換。

動態鏈接就是把這些符號方法引用轉換為具體的方法引用,在必要時加載類來解析尚未明確的符號,把符號變量的訪問轉換為這些變量運行時所在存儲結構的適合的偏移量(索引)。這樣的方式又稱為後期綁定。

方法調用

一個方法調用正常完成(即沒有拋異常)時,會根據所返回的值的類型執行一個適合的return指令,當前幀會去恢復調用者的狀態,包括它的本地變量和操作數棧,使調用者的程序計數器適合的遞增來跳過剛剛的那個方法調用指令。

返回值會被放到調用者幀的操作數棧上,然後繼續執行調用者方法的幀。

一個方法在調用時拋出了異常,且這個異常沒有在這個方法內被捕獲處理,將會導致這個方法調用的突然結束,這種情況下永遠不會向方法的調用者返回一個值。

特殊方法

站在jvm的級別,每一個用Java寫的構造函數都以一個實例初始化方法出現,且都是特殊的名字,就是<init>,這個名字是編譯器提供的。

實例初始化方法只能在jvm內部使用invokespecial這個指令調用,且只能在尚未初始化的類實例上調用。

一個類或接口最多可以有一個類或接口初始化方法,通過調用這個方法被初始化。類或接口的初始化方法也有特殊的名字,就是<clinit>,該方法沒有參數,且返回值是void。

方法名稱也是由編譯器提供的,從Java7開始,在字節碼中這個方法必須被標記為靜態的才行。

這個初始化方法是被jvm隱式調用的,它們絕對不會直接被用任何jvm指令調用,僅作為類初始化進程的一部分被間接的調用。

Java類庫

jvm必須為Java類庫的實現提供足夠的支持。一些類庫中的類如果沒有jvm協助是無法實現的。

反射,就是在運行時獲取某個類的類型相關信息,如它的字段信息,方法信息,構造函數信息,父類信息,實現的接口信息。

這些信息都必須是把一個類加載完之後才可以知道的,只有jvm才可以加載類。如java.lang.reflect這個包下的類和Class這個類。

在Java中加載一個類或接口用類加載器,即ClassLoader,背後還是委託給jvm來實現的。

鏈接和初始化一個類或接口。

安全,如java.security包下的類,還有其它類像SecurityManager。

多線程,如線程這個類Thread。

弱引用,像java.lang.ref包下的類。

公有設計,私有實現

以上內容只是jvm的一個“相對寬泛”的規範,它並不是實現方案,也不是實現細節。

實現者可以根據自身的需要來實現jvm,如運行在後端服務器上的jvm和運行在移動設備上的jvm肯定側重點有所不同。

從事Java的人都知道,事實上jvm是有較多的實現版本。

由於jvm是處在Java語言和操作系統之間的,所以它要向上提供對Java的支持,向下與操作系統良好交互。

寫在最後

高級語言(Java,C#)中的很多操作如文件操作,網絡操作,內存操作,線程操作,I/O操作等,都不是高級語言自身能夠實現的。

也不是它們的虛擬機(JVM,CLR)能夠實現的,實際最終是由操作系統實現的,因為這些都是系統資源,只有操作系統才有權限訪問。

如果你用Java或C#代碼創建了一個文件,千萬不要以為是Java或C#創建了這個文件,它們只是層層向下調用了操作系統的API,然後到文件系統API,最後可能到磁盤驅動程序。

由此可以看出,要想設計一門語言,不單單是關鍵字、語法、編譯器,類庫,虛擬機這些,還要深度了解操作系統,甚至是硬件,如CPU架構和CPU指令集等。

所以,和語言相關的事情,每一項都是異常的繁瑣複雜,都需要投入大量的人力、財力、時間去研究,最後即使研究成功了,可能沒有生態,沒人使用,自然也無法賺錢。

因此,國人現在還沒有一門屬於自己的真正語言。

>>> 熱門文章集錦 <<<

 

畢業10年,我有話說

【面試】我是如何面試別人List相關知識的,深度有點長文

我是如何在畢業不久只用1年就升為開發組長的

爸爸又給Spring MVC生了個弟弟叫Spring WebFlux

【面試】我是如何在面試別人Spring事務時“套路”對方的

【面試】Spring事務面試考點吐血整理(建議珍藏)

【面試】我是如何在面試別人Redis相關知識時“軟懟”他的

【面試】吃透了這些Redis知識點,面試官一定覺得你很NB(乾貨 | 建議珍藏)

【面試】如果你這樣回答“什麼是線程安全”,面試官都會對你刮目相看(建議珍藏)

【面試】迄今為止把同步/異步/阻塞/非阻塞/BIO/NIO/AIO講的這麼清楚的好文章(快快珍藏)

【面試】一篇文章幫你徹底搞清楚“I/O多路復用”和“異步I/O”的前世今生(深度好文,建議珍藏)

【面試】如果把線程當作一個人來對待,所有問題都瞬間明白了

Java多線程通關———基礎知識挑戰

品Spring:帝國的基石

 

作者是工作超過10年的碼農,現在任架構師。喜歡研究技術,崇尚簡單快樂。追求以通俗易懂的語言解說技術,希望所有的讀者都能看懂並記住。下面是公眾號的二維碼,歡迎關注!

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※台北網頁設計公司全省服務真心推薦

※想知道最厲害的網頁設計公司"嚨底家"!

※推薦評價好的iphone維修中心

※網頁設計最專業,超強功能平台可客製化

※別再煩惱如何寫文案,掌握八大原則!

循序漸進VUE+Element 前端應用開發(8)— 樹列表組件的使用,循序漸進VUE+Element 前端應用開發(5)— 表格列表頁面的查詢,列表展示和字段轉義處理,

在我前面隨筆《循序漸進VUE+Element 前端應用開發(6)— 常規Element 界面組件的使用》裏面曾經介紹過一些常規的界面組件的處理,主要介紹到單文本輸入框、多文本框、下拉列表,以及按鈕、圖片展示、彈出對話框、表單處理,本篇隨筆補充這一個主題,介紹樹列表組件和下拉列表樹組件在項目中的使用,以及一個SplitPanel的組件。

1、常規樹列表控件的使用

眾所周知,一般界面很多情況涉及到樹列表的處理,如類型展示,如果是一層的,可以用下拉列表代替,如果是多個層級的,採用樹控件展示會更加直觀。

在Element裏面也有一個el-tree的控件,如下所示,這裏主要對它的各種屬性和方法進行介紹。

 簡單的代碼如下所示

<el-tree :data="data"  @node-click="handleNodeClick"></el-tree>

主要在script部分裏面指定它的data數據,以及單擊節點的事件處理,結合卡片控件的展示,我們可以把樹放在其中進行展示

 界面代碼如下所示,通過 default-expand-all 可以設置全部展開,icon-class 指定節點圖標(也可以默認不指定)

        <el-card class="box-card">
          <div slot="header" class="clearfix">
            <span>樹列表</span>
            <el-button style="float: right; padding: 3px 0" type="text">操作按鈕</el-button>
          </div>
          <div>
            <el-tree
              style="padding-top:10px"
              :data="treedata"
              node-key="id"
              default-expand-all
              icon-class="el-icon-price-tag"
              highlight-current
              @node-click="handleNodeClick"
            >
              <span slot-scope="{ node, data }" class="custom-tree-node">
                <span>
                  <i :class="node.icon ? node.icon : 'el-icon-price-tag'" />
                  {{ node.label }}
               &nbsp;&nbsp;
                </span>
              </span>
            </el-tree>
          </div>
        </el-card>

其中界面裏面,我們通過 class=”custom-tree-node”,來指定樹列表的展現內容,可以加入圖標等信息

而在script裏面,定義了一個treedata的屬性

      // 初始化樹列表
      treedata: [
        {
          label: '一級 1',
          id: '1',
          children: [{
            id: '1-1',
            label: '二級 1-1',
            children: [{
              label: '三級 1-1-1',
              id: '1-1-1'
            }, {
              label: '三級 1-1-2',
              id: '1-1-2'
            }, {
              label: '三級 1-1-3',
              id: '1-1-3'
            }]
          }]
        }
      ]

如果設置有選擇框,得到界面如下所示。

 主要設置  show-checkbox 和 @check-change=”handleCheckChange” 即可。

界面代碼如下所示

<el-tree
  style="padding-top:10px"
  :data="treedata"
  node-key="id"
  default-expand-all
  highlight-current
  show-checkbox
  :default-checked-keys="['1-1-1']"
  @node-click="handleNodeClick" @check-change="handleCheckChange"
>
  <span slot-scope="{ node, data }" class="custom-tree-node">
    <span>
      <i :class="node.icon ? node.icon : 'el-icon-price-tag'" />
      {{ node.label }}
   &nbsp;&nbsp;
    </span>
  </span>
</el-tree>

而對於樹列表,可以進行一個過濾處理操作,如下界面所示。

 在內容區增加一個input的文本框進行過濾處理,並綁定對應的屬性變量

<el-input
  v-model="filterText"
  placeholder="輸入關鍵字進行過濾"
  clearable
  prefix-icon="el-icon-search"
/>

樹列表控件需要增加過濾函數綁定 :filter-node-method=”filterNode”,如下代碼所示。

<el-tree
  ref="tree"
  class="filter-tree"
  style="padding-top:10px"
  :data="treedata"
  node-key="id"
  default-expand-all
  highlight-current
  show-checkbox
  :filter-node-method="filterNode"
  @check-change="handleCheckChange"
  @node-click="handleNodeClick"
>
  <span slot-scope="{ node, data }" class="custom-tree-node">
    <span>
      <i :class="node.icon ? node.icon : 'el-icon-price-tag'" />
      {{ node.label }}
   &nbsp;&nbsp;
    </span>
  </span>
</el-tree>

script的處理代碼如下所示,需要watch過濾的綁定值,變化就進行過濾處理。

 為了在列表結合中進行快速的過濾,我們可以在上次介紹的列表界面裏面增加一個樹列表的快速查詢處理。如下界面所示。

 這裏列表裡面增加了一個第三方組件 splitpanes,用來劃分區塊展示,而且可以拖動,非常不錯,地址是:https://github.com/antoniandre/splitpanes

這個組件的Demo展示地址如下所示:https://antoniandre.github.io/splitpanes

效果大概如下所示

  npm 安裝如下所示

npm i --S splitpanes

安裝成功后,然後在vue文件的script部分裏面引入即可

import { Splitpanes, Pane } from 'splitpanes'
import 'splitpanes/dist/splitpanes.css'

它的使用代碼也很簡單

<splitpanes style="height: 400px">
  <pane min-size="20">1</pane>
  <pane>
    <splitpanes horizontal>
      <pane>2</pane>
      <pane>3</pane>
      <pane>4<pane>
    </splitpanes>
  </pane>
  <pane>5</pane>
</splitpanes>

我的列表界面使用了兩個Panel即可實現左側樹的展示,和右側常規列表查詢的處理。

  

2、下拉框樹列表的處理

除了常規的樹列表展示內容外,我們也需要一個在下拉列表中展示樹內容的界面組件。

這裏又得引入一個第三方的界面組件,因此Element的Select組件不支持樹列表。

GitHub地址:https://github.com/riophae/vue-treeselect

官網地址:https://vue-treeselect.js.org/

NPM安裝:

npm install --save @riophae/vue-treeselect

界面代碼如下所示。

<template>
  <div id="app">
    <treeselect v-model="value" :multiple="true" :options="options" />
  </div>
</template>

這裏的value就是選中的集合,options則是樹列表的節點數據。

<script>
  // import the component
  import Treeselect from '@riophae/vue-treeselect'
  // import the styles
  import '@riophae/vue-treeselect/dist/vue-treeselect.css'

  export default {
    // register the component
    components: { Treeselect },
    data() {
      return {
        // define the default value
        value: null,
        // define options
        options: [ {
          id: 'a',
          label: 'a',
          children: [ {
            id: 'aa',
            label: 'aa',
          }, {
            id: 'ab',
            label: 'ab',
          } ],
        }, {
          id: 'b',
          label: 'b',
        }, {
          id: 'c',
          label: 'c',
        } ],
      }
    },
  }
</script>

我的測試界面代碼如下所示

          <div style="height:180px">
            <!--
                v-model 綁定選中的集合
                options 樹節點數據
                 defaultExpandLevel 展開層次,Infinity為所有
                 flat 為子節點不影響父節點,不關聯
             -->
            <treeselect
              v-model="value"
              :options="treedata"
              :multiple="true"
              :flat="true"
              :default-expand-level="Infinity"
              :open-on-click="true"
              :open-on-focus="true"
              clearable
              :max-height="200"
            />
          </div>
<script>
// import vue-treeselect component
import Treeselect from '@riophae/vue-treeselect'
// import the styles
import '@riophae/vue-treeselect/dist/vue-treeselect.css'

export default {
  name: 'Tree',
  components: { Treeselect },
  data() {
    return {
      // 過濾條件
      filterText: '',
      // 初始化樹列表
      treedata: [
        {
          label: '一級 1',
          id: '1',
          children: [{
            id: '1-1',
            label: '二級 1-1',
            children: [{
              label: '三級 1-1-1',
              id: '1-1-1'
            }, {
              label: '三級 1-1-2',
              id: '1-1-2'
            }, {
              label: '三級 1-1-3',
              id: '1-1-3'
            }]
          }]
        }
      ],
      value: ['1-1-2']
    }
  },
................
}
</script>

來一張幾個樹列表一起的對比展示界面。

 以上就是普通樹列表和下拉列表樹展示的界面效果,往往我們一些特殊的界面處理,就需要多利用一些封裝良好的第三方界面組件實現,可以豐富我們的界面展示效果。

 

列出以下前面幾篇隨筆的連接,供參考:

循序漸進VUE+Element 前端應用開發(1)— 開發環境的準備工作

循序漸進VUE+Element 前端應用開發(2)— Vuex中的API、Store和View的使用

循序漸進VUE+Element 前端應用開發(3)— 動態菜單和路由的關聯處理

循序漸進VUE+Element 前端應用開發(4)— 獲取後端數據及產品信息頁面的處理

循序漸進VUE+Element 前端應用開發(5)— 表格列表頁面的查詢,列表展示和字段轉義處理

循序漸進VUE+Element 前端應用開發(6)— 常規Element 界面組件的使用

循序漸進VUE+Element 前端應用開發(7)— 介紹一些常規的JS處理函數

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨,RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

※網頁設計最專業,超強功能平台可客製化

※別再煩惱如何寫文案,掌握八大原則!

終於我用JOL打破了你對java對象的所有想象

目錄

  • 簡介
  • JOL簡介
  • 使用JOL分析VM信息
  • 使用JOL分析String
  • 使用JOL分析數組
  • 使用JOL分析自動裝箱
  • 使用JOL分析引用關係
  • 總結

簡介

使用面向對象的編程語言的好處就是,雖然沒有女朋友,但是仍然可以new對象出來。Java是面向對象的編程語言,我們天天都在使用java來new對象,但估計很少有人知道new出來的對象到底長的什麼樣子,是美是丑到底符不符合我們的要去?

對於普通的java程序員來說,可能從來沒有考慮過java中對象的問題,不懂這些也可以寫好代碼。

但是對於一個有鑽研精神的極客來說,肯定會想多一些,再多一些,java中的對象到底是什麼樣的。

今天,小F給大家介紹一款工具JOL,可以滿足大家對java對象的所有想象。

更多精彩內容且看:

  • 區塊鏈從入門到放棄系列教程-涵蓋密碼學,超級賬本,以太坊,Libra,比特幣等持續更新
  • Spring Boot 2.X系列教程:七天從無到有掌握Spring Boot-持續更新
  • Spring 5.X系列教程:滿足你對Spring5的一切想象-持續更新
  • java程序員從小工到專家成神之路(2020版)-持續更新中,附詳細文章教程

更多內容請訪問www.flydean.com

JOL簡介

JOL的全稱是Java Object Layout。是一個用來分析JVM中Object布局的小工具。包括Object在內存中的佔用情況,實例對象的引用情況等等。

JOL可以在代碼中使用,也可以獨立的以命令行中運行。命令行的我這裏就不具體介紹了,今天主要講解怎麼在代碼中使用JOL。

使用JOL需要添加maven依賴:

<dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.10</version>
</dependency>

添加完依賴,我們就可以使用了。

使用JOL分析VM信息

首先我們看下怎麼使用JOL來分析JVM的信息,代碼非常非常簡單:

log.info("{}", VM.current().details());

輸出結果:

# Running 64-bit HotSpot VM.
# Using compressed oop with 3-bit shift.
# Using compressed klass with 3-bit shift.
# WARNING | Compressed references base/shifts are guessed by the experiment!
# WARNING | Therefore, computed addresses are just guesses, and ARE NOT RELIABLE.
# WARNING | Make sure to attach Serviceability Agent to get the reliable addresses.
# Objects are 8 bytes aligned.
# Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]
# Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]

上面的輸出中,我們可以看到:Objects are 8 bytes aligned,這意味着所有的對象分配的字節都是8的整數倍。

使用JOL分析String

上面的都不是重點,重點是怎麼使用JOL來分成class和Instance信息。

其實java中的對象,除了數組,其他對象的大小應該都是固定的。我們先舉一個最最常用的字符串來看一下:

log.info("{}",ClassLayout.parseClass(String.class).toPrintable());

上面的例子中,我們使用ClassLayout來解析一個String類,先看下輸出:

[main] INFO com.flydean.JolUsage - java.lang.String object internals:
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0    12           (object header)                           N/A
     12     4    byte[] String.value                              N/A
     16     4       int String.hash                               N/A
     20     1      byte String.coder                              N/A
     21     1   boolean String.hashIsZero                         N/A
     22     2           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 2 bytes external = 2 bytes total

先解釋下各個字段的含義,OFFSET是偏移量,也就是到這個字段位置所佔用的byte數,SIZE是後面類型的大小,TYPE是Class中定義的類型,DESCRIPTION是類型的描述,VALUE是TYPE在內存中的值。

分析下上面的輸出,我們可以得出,String類中佔用空間的有5部分,第一部分是對象頭,佔12個字節,第二部分是byte數組,佔用4個字節,第三部分是int表示的hash值,佔4個字節,第四部分是byte表示的coder,佔1個字節,最後一個是boolean表示的hashIsZero,佔1個字節,總共22個字節。但是JVM中對象內存的分配必須是8字節的整數倍,所以要補全2字節,最後String類的總大小是24字節。

有人可能要問小F了,如果字符串裏面存了很多很多數據,那麼對象的大小還是24字節嗎?

這個問題問得非常有水平,下面我們就來看看怎麼使用JOL來解析String對象的信息:

log.info("{}",ClassLayout.parseInstance("www.flydean.com").toPrintable());

上面的例子,我們使用了parseInstance而不是parseClass來解析String實例的信息。

輸出結果:

[main] INFO com.flydean.JolUsage - java.lang.String object internals:
 OFFSET  SIZE      TYPE DESCRIPTION                               VALUE
      0     4           (object header)                           01 c2 63 a2 (00000001 11000010 01100011 10100010) (-1570520575)
      4     4           (object header)                           0c 00 00 00 (00001100 00000000 00000000 00000000) (12)
      8     4           (object header)                           77 1a 06 00 (01110111 00011010 00000110 00000000) (399991)
     12     4    byte[] String.value                              [119, 119, 119, 46, 102, 108, 121, 100, 101, 97, 110, 46, 99, 111, 109]
     16     4       int String.hash                               0
     20     1      byte String.coder                              0
     21     1   boolean String.hashIsZero                         false
     22     2           (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 2 bytes external = 2 bytes total

先看結論,和String Class一樣,這個String對象確實只佔24字節。

實例的解析和Class解析的結果差不多,因為是實例對象,所以多了VALUE的值。

我們知道在JDK9之後,String的底層存儲從Char[] 變成了Byte[]用於節約String的存儲空間。上面的輸出中,我們可以看到String.value值確實很長,但是保存在String中的只是Byte數組的引用地址,所以4字節就夠了。

使用JOL分析數組

雖然String的大小是不變的,但是其底層數組的大小是可變的。我們再舉個例子:

log.info("{}",ClassLayout.parseClass(byte[].class).toPrintable());

輸出結果:

[main] INFO com.flydean.JolUsage - [B object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0    16        (object header)                           N/A
     16     0   byte [B.<elements>                             N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

類的解析結果,可以看到Byte數組佔16個字節。

再看實例的情況:

log.info("{}",ClassLayout.parseInstance("www.flydean.com".getBytes()).toPrintable());

輸出結果:

[main] INFO com.flydean.JolUsage - [B object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           22 13 07 00 (00100010 00010011 00000111 00000000) (463650)
     12     4        (object header)                           0f 00 00 00 (00001111 00000000 00000000 00000000) (15)
     16    15   byte [B.<elements>                             N/A
     31     1        (loss due to the next object alignment)
Instance size: 32 bytes
Space losses: 0 bytes internal + 1 bytes external = 1 bytes total

可以看到數組的大小真的變化了,這次變成了32字節。

使用JOL分析自動裝箱

我們知道,java中的基本類型都有一個和它對於的Object類型,比如long和Long,下面我們來分析下他們兩個在JVM中的內存區別:

log.info("{}",ClassLayout.parseClass(Long.class).toPrintable());

輸出結果:

[main] INFO com.flydean.JolUsage - java.lang.Long object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0    12        (object header)                           N/A
     12     4        (alignment/padding gap)                  
     16     8   long Long.value                                N/A
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

可以看到1個Long對象是佔24個字節的,但是其中真正存儲long的value只佔8個字節。

看一個實例:

log.info("{}",ClassLayout.parseInstance(1234567890111112L).toPrintable());

輸出結果:

[main] INFO com.flydean.JolUsage - java.lang.Long object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)
      4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)                           9a 15 00 00 (10011010 00010101 00000000 00000000) (5530)
     12     4        (alignment/padding gap)                  
     16     8   long Long.value                                1234567890111112
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total

使用JOL分析引用關係

上面我們使用JOL分析的是class內部的空間使用情況,那麼如果有外部引用可不可以分析呢?

HashMap hashMap= new HashMap();
hashMap.put("flydean","www.flydean.com");
log.info("{}", GraphLayout.parseInstance(hashMap).toPrintable());

上面我們使用一個不同的layout:GraphLayout,它可以用來分析外部引用情況。

輸出結果:

[main] INFO com.flydean.JolUsage - java.util.HashMap@57d5872cd object externals:
          ADDRESS       SIZE TYPE                      PATH                           VALUE
        7875f9028         48 java.util.HashMap                                        (object)
        7875f9058         24 java.lang.String          .table[14].key                 (object)
        7875f9070         24 [B                        .table[14].key.value           [102, 108, 121, 100, 101, 97, 110]
        7875f9088         24 java.lang.String          .table[14].value               (object)
        7875f90a0         32 [B                        .table[14].value.value         [119, 119, 119, 46, 102, 108, 121, 100, 101, 97, 110, 46, 99, 111, 109]
        7875f90c0         80 [Ljava.util.HashMap$Node; .table                         [null, null, null, null, null, null, null, null, null, null, null, null, null, null, (object), null]
        7875f9110         32 java.util.HashMap$Node    .table[14]                     (object)

從結果我們可以看到HashMap本身是佔用48字節的,它裏面又引用了佔用24字節的key和value。

總結

使用JOL可以分析java類和對象,這個對於我們對JVM和java源代碼的理解和實現都是非常有幫助的。

本文的例子https://github.com/ddean2009/
learn-java-base-9-to-20

本文作者:flydean程序那些事

本文鏈接:http://www.flydean.com/java-object-layout-jol/

本文來源:flydean的博客

歡迎關注我的公眾號:程序那些事,更多精彩等着您!

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格,搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

※回頭車貨運收費標準

基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇(四)

系列文章

  1. 基於 abp vNext 和 .NET Core 開發博客項目 – 使用 abp cli 搭建項目
  2. 基於 abp vNext 和 .NET Core 開發博客項目 – 給項目瘦身,讓它跑起來
  3. 基於 abp vNext 和 .NET Core 開發博客項目 – 完善與美化,Swagger登場
  4. 基於 abp vNext 和 .NET Core 開發博客項目 – 數據訪問和代碼優先
  5. 基於 abp vNext 和 .NET Core 開發博客項目 – 自定義倉儲之增刪改查
  6. 基於 abp vNext 和 .NET Core 開發博客項目 – 統一規範API,包裝返回模型
  7. 基於 abp vNext 和 .NET Core 開發博客項目 – 再說Swagger,分組、描述、小綠鎖
  8. 基於 abp vNext 和 .NET Core 開發博客項目 – 接入GitHub,用JWT保護你的API
  9. 基於 abp vNext 和 .NET Core 開發博客項目 – 異常處理和日誌記錄
  10. 基於 abp vNext 和 .NET Core 開發博客項目 – 使用Redis緩存數據
  11. 基於 abp vNext 和 .NET Core 開發博客項目 – 集成Hangfire實現定時任務處理
  12. 基於 abp vNext 和 .NET Core 開發博客項目 – 用AutoMapper搞定對象映射
  13. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰(一)
  14. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰(二)
  15. 基於 abp vNext 和 .NET Core 開發博客項目 – 定時任務最佳實戰(三)
  16. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇(一)
  17. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇(二)
  18. 基於 abp vNext 和 .NET Core 開發博客項目 – 博客接口實戰篇(三)

上篇文章完成了文章增刪改的接口和友情鏈接列表的接口,本篇繼續。

善於思考的同學肯定發現,在執行增刪改操作后,Redis緩存中的數據還是存在的,也就意味着查詢接口返回的數據還是舊的,所以在寫接口之前,先完成一下清緩存的操作。

移除緩存

移除緩存我這裏找了一個新的包:Caching.CSRedis,選他是因為微軟的包Microsoft.Extensions.Caching.StackExchangeRedis沒有給我們實現批量刪除的功能。

Caching.CSRedis開源地址,https://github.com/2881099/csredis 在這不做過多介紹,感興趣的自己去看。

在.Application.Caching層添加包Caching.CSRedis,Install-Package Caching.CSRedis,然後在模塊類MeowvBlogApplicationCachingModule中進行配置。

//MeowvBlogApplicationCachingModule.cs
...
public override void ConfigureServices(ServiceConfigurationContext context)
{
    ...

    var csredis = new CSRedis.CSRedisClient(AppSettings.Caching.RedisConnectionString);
    RedisHelper.Initialization(csredis);

    context.Services.AddSingleton<IDistributedCache>(new CSRedisCache(RedisHelper.Instance));
}
...

直接新建一個移除緩存的接口:ICacheRemoveService,添加移除緩存的方法RemoveAsync()。代碼較少,可以直接寫在緩存基類CachingServiceBase中。

public interface ICacheRemoveService
{
    /// <summary>
    /// 移除緩存
    /// </summary>
    /// <param name="key"></param>
    /// <param name="cursor"></param>
    /// <returns></returns>
    Task RemoveAsync(string key, int cursor = 0);
}

然後可以在基類中實現這個接口。

public async Task RemoveAsync(string key, int cursor = 0)
{
    var scan = await RedisHelper.ScanAsync(cursor);
    var keys = scan.Items;

    if (keys.Any() && key.IsNotNullOrEmpty())
    {
        keys = keys.Where(x => x.StartsWith(key)).ToArray();

        await RedisHelper.DelAsync(keys);
    }
}

簡單說一下這個操作過程,使用ScanAsync()獲取到所有的Redis key值,返回的是一個string數組,然後根據參數找到符合此前綴的所有key,最後調用DelAsync(keys)刪除緩存。

在需要有移除緩存功能的接口上繼承ICacheRemoveService,這裏就是IBlogCacheService。

//IBlogCacheService.cs
namespace Meowv.Blog.Application.Caching.Blog
{
    public partial interface IBlogCacheService : ICacheRemoveService
    {
    }
}

在基類中已經實現了這個接口,所以現在所有繼承基類的緩存實現類都可以調用移除緩存方法了。

在MeowvBlogConsts中添加緩存前綴的常量。

//MeowvBlogConsts.cs
/// <summary>
/// 緩存前綴
/// </summary>
public static class CachePrefix
{
    public const string Authorize = "Authorize";

    public const string Blog = "Blog";

    public const string Blog_Post = Blog + ":Post";

    public const string Blog_Tag = Blog + ":Tag";

    public const string Blog_Category = Blog + ":Category";

    public const string Blog_FriendLink = Blog + ":FriendLink";
}

然後在BlogService.Admin.cs服務執行增刪改后調用移除緩存的方法。

//BlogService.Admin.cs

// 執行清除緩存操作
await _blogCacheService.RemoveAsync(CachePrefix.Blog_Post);

因為是小項目,採用這種策略直接刪除緩存,這樣就搞定了當在執行增刪改操作后,前台接口可以實時查詢出最後的結果。

文章詳情

當我們修改文章數據的時候,是需要把當前數據庫中的數據帶出來显示在界面上的,因為有可能只是個別地方需要修改,所以這還需要一個查詢文章詳情的接口,當然這裏的詳情和前端的是不一樣的,這裡是需要根據Id主鍵去查詢。

添加模型類PostForAdminDto.cs,直接繼承PostDto,然後添加一個Tags列表就行,==,好像和上一篇文章中的EditPostInput字段是一模一樣的。順手將EditPostInput改一下吧,具體代碼如下:

//PostForAdminDto.cs
using System.Collections.Generic;

namespace Meowv.Blog.Application.Contracts.Blog
{
    public class PostForAdminDto : PostDto
    {
        /// <summary>
        /// 標籤列表
        /// </summary>
        public IEnumerable<string> Tags { get; set; }
    }
}

//EditPostInput.cs
namespace Meowv.Blog.Application.Contracts.Blog.Params
{
    public class EditPostInput : PostForAdminDto
    {
    }
}

在IBlogService.Admin.cs中添加接口。

/// <summary>
/// 獲取文章詳情
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task<ServiceResult<PostForAdminDto>> GetPostForAdminAsync(int id);

實現這個接口。

/// <summary>
/// 獲取文章詳情
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task<ServiceResult<PostForAdminDto>> GetPostForAdminAsync(int id)
{
    var result = new ServiceResult<PostForAdminDto>();

    var post = await _postRepository.GetAsync(id);

    var tags = from post_tags in await _postTagRepository.GetListAsync()
               join tag in await _tagRepository.GetListAsync()
               on post_tags.TagId equals tag.Id
               where post_tags.PostId.Equals(post.Id)
               select tag.TagName;

    var detail = ObjectMapper.Map<Post, PostForAdminDto>(post);
    detail.Tags = tags;
    detail.Url = post.Url.Split("/").Where(x => !string.IsNullOrEmpty(x)).Last();

    result.IsSuccess(detail);
    return result;
}

先根據Id查出文章數據,再通過聯合查詢找出標籤數據。

CreateMap<Post, PostForAdminDto>().ForMember(x => x.Tags, opt => opt.Ignore());

新建一條AutoMapper配置,將Post轉換成PostForAdminDto,忽略Tags。

然後將查出來的標籤、Url賦值給DTO,輸出即可。在BlogController.Admin中添加API。

/// <summary>
/// 獲取文章詳情
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpGet]
[Authorize]
[Route("admin/post")]
[ApiExplorerSettings(GroupName = Grouping.GroupName_v2)]
public async Task<ServiceResult<PostForAdminDto>> GetPostForAdminAsync([Required] int id)
{
    return await _blogService.GetPostForAdminAsync(id);
}

至此,完成了關於文章的所有接口。

接下來按照以上方式依次完成分類、標籤、友鏈的增刪改查接口,我覺得如果你有跟着我一起做,剩下的可以自己完成。

開源地址:https://github.com/Meowv/Blog/tree/blog_tutorial

搭配下方課程學習更佳 ↓ ↓ ↓

http://gk.link/a/10iQ7

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格,搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上,台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

※回頭車貨運收費標準

Java併發編程實戰總結 (一)

前提

首先該場景是一個酒店開房的業務。為了朋友們閱讀簡單,我把業務都簡化了。
業務:開房後會添加一條賬單,添加一條房間排期記錄,房間排期主要是為了房間使用的時間不衝突。如:賬單A,使用房間1,使用時間段為2020-06-01 12:00 – 2020-06-02 12:00 ,那麼還需要使用房間1開房的時間段則不能與賬單A的時間段衝突。

業務類

為了簡單起見,我把幾個實體類都簡化了。

賬單類

public class Bill {
    // 賬單號
    private String serial;

    // 房間排期id
    private Integer room_schedule_id;
    // ...get set
}

房間類

// 房間類
public class Room {
    private Integer id;

    // 房間名
    private String name;
    // get set...
}

房間排期類

import java.sql.Timestamp;

public class RoomSchedule {
    private Integer id;
    
    // 房間id
    private Integer roomId;

    // 開始時間
    private Timestamp startTime;

    // 結束時間
    private Timestamp endTime;
    // ...get set
}

實戰

併發實戰當然少不了Jmeter壓測工具,傳送門: https://jmeter.apache.org/download_jmeter.cgi
為了避免有些小夥伴訪問不到官網,我上傳到了百度雲:鏈接:https://pan.baidu.com/s/1c9l3Ri0KzkdIkef8qtKZeA
提取碼:kjh6

初次實戰(sychronized)

第一次進行併發實戰,我是首先想到sychronized關鍵字的。沒辦法,基礎差。代碼如下:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;

import java.sql.Timestamp;

/**
 * 開房業務類
 */
@Service
public class OpenRoomService {
    @Autowired
    DataSourceTransactionManager dataSourceTransactionManager;
    @Autowired
    TransactionDefinition transactionDefinition;

    public void openRoom(Integer roomId, Timestamp startTime, Timestamp endTime) {
        // 開啟事務
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(transactionDefinition);
        try {
            synchronized (RoomSchedule.class) {
                if (isConflict(roomId, startTime, endTime)) {
                    // throw exception
                }
                // 添加房間排期...
                // 添加賬單

                // 提交事務
                dataSourceTransactionManager.commit(transaction);
            }
        } catch (Exception e) {
            // 回滾事務
            dataSourceTransactionManager.rollback(transaction);
            throw e;
        }
    }

    public boolean isConflict(Integer roomId, Timestamp startTime, Timestamp endTime) {
        // 判斷房間排期是否有衝突...
    }
}
  1. sychronized(RoomSchedule.class),相當於的開房業務都是串行的。不管開房間1還是房間2。都需要等待上一個線程執行完開房業務,後續才能執行。這並不好哦。
  2. 事務必須在同步代碼塊sychronized中提交,這是必須的。否則當線程A使用房間1開房,同步代碼塊執行完,事務還未提交,線程B發現房間1的房間排期沒有衝突,那麼此時是有問題的。

錯誤點: 有些朋友可能會想到都是串行執行了,為什麼不把synchronized關鍵字寫到方法上?
首先openRoom方法是非靜態方法,那麼synchronized鎖定的就是this對象。而Spring中的@Service註解類是多例的,所以並不能把synchronized關鍵字添加到方法上。

二次改進(等待-通知機制)

因為上面的例子當中,開房操作都是串行的。而實際情況使用房間1開房和房間2開房應該是可以并行才對。如果我們使用synchronized(Room實例)可以嗎?答案是不行的。
在第三章 解決原子性問題當中,我講到了使用鎖必須是不可變對象,若把可變對象作為鎖,當可變對象被修改時相當於換鎖,這裏的鎖講的就是synchronized鎖定的對象,也就是Room實例。因為Room實例是可變對象(set方法修改實例的屬性值,說明為可變對象),所以不能使用synchronized(Room實例)。
在這次改進當中,我使用了第五章 等待-通知機制,我添加了RoomAllocator房間資源分配器,當開房的時候需要在RoomAllocator當中獲取鎖資源,獲取失敗則線程進入wait()等待狀態。當線程釋放鎖資源則notiryAll()喚醒所有等待中的線程。
RoomAllocator房間資源分配器代碼如下:

import java.util.ArrayList;
import java.util.List;

/**
 * 房間資源分配器(單例類)
 */
public class RoomAllocator {
    private final static RoomAllocator instance = new RoomAllocator();

    private final List<Integer> lock = new ArrayList<>();

    private RoomAllocator() {}

    /**
     * 獲取鎖資源
     */
    public synchronized void lock(Integer roomId) throws InterruptedException {
        // 是否有線程已佔用該房間資源
        while (lock.contains(roomId)) {
            // 線程等待
            wait();
        }

        lock.add(roomId);
    }

    /**
     * 釋放鎖資源
     */
    public synchronized void unlock(Integer roomId) {
        lock.remove(roomId);
        // 喚醒所有線程
        notifyAll();
    }

    public static RoomAllocator getInstance() {
        return instance;
    }
}

開房業務只需要修改openRoom的方法,修改如下:

    public void openRoom(Integer roomId, Timestamp startTime, Timestamp endTime) throws InterruptedException {
        RoomAllocator roomAllocator = RoomAllocator.getInstance();
        // 開啟事務
        TransactionStatus transaction = dataSourceTransactionManager.getTransaction(transactionDefinition);
        try {
            roomAllocator.lock(roomId);
            if (isConflict(roomId, startTime, endTime)) {
                // throw exception
            }
            // 添加房間排期...
            // 添加賬單

            // 提交事務
            dataSourceTransactionManager.commit(transaction);
        } catch (Exception e) {
            // 回滾事務
            dataSourceTransactionManager.rollback(transaction);
            throw e;
        } finally {
            roomAllocator.unlock(roomId);
        }
    }

那麼此次修改后,使用房間1開房和房間2開房就可以并行執行了。

總結

上面的例子可能會有其他更好的方法去解決,但是我的實力不允許我這麼做….。這個例子也是我自己在項目中搞事情搞出來的。畢竟沒有實戰經驗,只有理論,不足以學好併發。希望大家也可以在項目中搞事情[壞笑],當然不能瞎搞。
後續如果在其他場景用到了併發,也會繼續寫併發實戰的文章哦~

個人博客網址: https://colablog.cn/

如果我的文章幫助到您,可以關注我的微信公眾號,第一時間分享文章給您

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格,搶佔消費者視覺第一線

※廣告預算用在刀口上,台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角,別等搬了再說!

※教你寫出一流的銷售文案?

※回頭車貨運收費標準

※別再煩惱如何寫文案,掌握八大原則!

Python機器學習筆記:SVM(2)——SVM核函數,Python機器學習筆記:SVM(1)——SVM概述,Python機器學習筆記:SVM(2)——SVM核函數,Python機器學習筆記:SVM(3)——證明SVM,Python機器學習筆記:SVM(4)——sklearn實現

  上一節我學習了完整的SVM過程,下面繼續對核函數進行詳細學習,具體的參考鏈接都在上一篇文章中,SVM四篇筆記鏈接為:

Python機器學習筆記:SVM(1)——SVM概述

Python機器學習筆記:SVM(2)——SVM核函數

Python機器學習筆記:SVM(3)——證明SVM

Python機器學習筆記:SVM(4)——sklearn實現

  熱身實例

  我在上一節有完整的學習了SVM算法,為了不讓自己這麼快就忘了,這裏先學習一個實例,回顧一下,並引出核函數的概念。

  數據是這樣的:有三個點,其中正例 x1(3,  3),x2(4,3),負例 x3(1,1)

   求解:

   約束條件為:

  這個約束條件是通過這個得到的(為什麼這裏強調一下呢,因為我們這個例子本身說的就是SVM的求解過程):

   我們可以知道  y1 = +1, y2 = +1 , y3 = -1,同時,代入 α ,則得到:

  α1 +  α2 – α3=0

  下面通過SVM求解實例。

  我們將數據代入原式中:

   由於 α1 + α2 = α3 化簡可得:

   然後分別對  α1 和 α2 求偏導,偏導等於 0 可得: α1 = 1.5   α2 = -1 ,但是我們發現這兩個解並不滿足約束條件  αi >= 0,i=1,2,3,所以解應該在邊界上(正常情況下,我們需要對上式求偏導,進而算出 w,b)。

  首先令  α1 = 0,得出 α2 = -2/13  ,α3 = -2/13   (不滿足約束)

  再令 α2 = 0,得出 α1 = 0.25  ,α3 = 0.25  (滿足約束)

  所以最小值在(0.25, 0,0.25)處取得。

  我們將 α 的結果代入求解:

   所以我們代入 w  b ,求得最終的平面方程為:

  熱身完畢,下面學習核函數,為了方便理解我們下面要說的核函數,我在知乎找了一個簡單易懂的故事,讓我們了解支持向量機,更是明白支持向量機的核函數是個什麼鬼,下面看故事。

1,故事分析:支持向量機(SVM)是什麼?

  下面故事來源於此(這是源作者鏈接):點擊我即可

  在很久以前的情人節,有一個大俠要去救他的愛人,但是魔鬼和他玩了一個遊戲。

  魔鬼在桌面上似乎有規律放了兩種顏色的球,說:“你用一根棍分開他們?要求:盡量在放更多球之後,仍然使用”

  於是大俠這樣做,幹得不錯吧:

  然後魔鬼又在桌上放了更多的球,似乎有一個球站錯了陣營。

  SVM就是試圖把棍放在最佳位置,好讓在棍的兩邊有盡可能大的間隙。

  現在即使魔鬼放了更多的球,棍仍然是一個好的分界線。

  然後,在SVM工具箱中有另一個更加重要的trick 。魔鬼看到大俠已經學會了一個trick,於是魔鬼給了大俠一個新的挑戰。

  現在,大俠沒有棍可以很好地幫他分開這兩種球了,現在怎麼辦,當然像所有武俠片中一樣大俠桌子一拍,球飛到空中。然後憑藉著大俠的輕功,大俠抓起一張紙,插到了兩種球的中間。

  現在,從魔鬼的角度看這些球,這些球好像是被一條曲線分開了。

  在之後,無聊的大人們,把這些球叫做 「data」,把棍子 叫做 「classifier」, 最大間隙trick 叫做「optimization」, 拍桌子叫做「kernelling」, 那張紙叫做「hyperplane」。

  所以說,Support Vector Machine,一個普通的SVM就是一條直線罷了,用來完美劃分linearly separable的兩類。但是這又不是一條普通的直線,這是無數條可以分類的直線當中最完美的,因為它恰好在兩個類的中間,距離兩個類的點都一樣遠。而所謂的Support vector就是這些離分界線最近的點,如果去掉這些點,直線多半是要改變位置的。如果是高維的點,SVM的分界線就是平面或者超平面。其實沒有差,都是一刀切兩塊,我們這裏統一叫做直線。

  再理解一下,當一個分類問題,數據是線性可分的,也就是用一根棍就可以將兩種小球分開的時候,我們只要將棍的位置放在讓小球距離棍的距離最大化的位置即可。尋找這個最大間隔的過程,就叫做最優化。但是,显示往往是殘酷的,一般的數據是線性不可分的。也就是找不到一個棍將兩種小球很好的分類,這時候我們就需要像大俠一樣,將小球排起,用一張紙代替小棍將兩種小球進行分類,想讓數據飛起,我們需要的東西就是核函數(kernel),用於切分小球的紙,就是超平面。

2,核函數的概念

  上面故事說明了SVM可以處理線性可分的情況,也可以處理非線性可分的情況。而處理非線性可分的情況是選擇了核函數(kernel),通過將數據映射到高位空間,來解決在原始空間中線性不可分的問題。

  我們希望樣本在特徵空間中線性可分,因此特徵空間的好壞對支持向量機的性能至關重要,但是在不知道特徵映射的情況下,我們是不知道什麼樣的核函數是適合的,而核函數也只是隱式的定義了特徵空間,所以,核函數的選擇對於一個支持向量機而言就顯得至關重要,若選擇了一個不合適的核函數,則數據將映射到不合適的樣本空間,從而支持向量機的性能將大大折扣。

  所以構造出一個具有良好性能的SVM,核函數的選擇是關鍵。而核函數的選擇包含兩部分工作:一是核函數類型的選擇,二是確定核函數類型后相關參數的選擇。

  我們知道,核函數的精妙之處在於不用真的對特徵向量做核映射,而是直接對特徵向量的內積進行變換,而這種變換卻等價於先對特徵向量做核映射然後做內積。

  SVM主要是在用對偶理論求解一個二次凸優化問題,其中對偶問題如下:

   求得最終結果:

  當然這是線性可分的情況,那麼如果問題本身是線性不可分的情況呢?那就是先擴維后再計算。具體來說,在線性不可分的情況下,支持向量機首先在低維空間中完成計算,然後通過核函數將輸入空間映射到高維特徵空間,最終在高維特徵空間中構造出最優分離超平面,從而把平面上本身不好分的非線性數據分開。如下圖所示,一堆數據在二維空間中無法劃分,從而映射到三維空間中劃分:

   而在我們遇到核函數之前,如果用原始的方法,那麼在用線性學習器學習一個非線性關係,需要選擇一個非線性特徵集,並且將數據寫成新的表達形式,這等價於應用一個固定的非線性映射,將數據映射到特徵空間,在特徵空間中使用線性學習器。因此,考慮的假設集是這種類型的函數:

   這裏 Φ :X -> F 是從輸入空間到某個特徵空間的映射,這意味着建立非線性學習器分為兩步:

  • 1,使用一個非線性映射將數據變換到一個特徵空間 F
  • 2,在特徵空間使用線性學習器分類

  而由於對偶形式就是線性學習器的一個重要性質,這意味着假設可以表達為訓練點的線性組合,因此決策規則可以用測試點和訓練點的內積來表示:

  為向量加上核映射后,要求解的最優化問題變為:

  根據核函數滿足的等式條件,它等價於下面的問題:

  其線性不可分情況的對偶形式如下:

   其中 Φ(xi) 表示原來的樣本擴維后的坐標。

  最後得到的分類判別函數為:

   和不用核映射相比,只是求解的目標函數,最後的判定函數對特徵向量的內積做了核函數變換。如果K是一個非線性函數,上面的決策函數則是非線性函數,此時SVM是非線性模型。當訓練樣本很多,支持向量的個數很大的時候,預測時的速度是一個問題,因此很多時候我們會使用線性支持向量機。

3,舉例說明核函數的巧妙之處

  下面先從一個小例子來闡述問題。假設我們有兩個數據, x = (x1,  x2,  x3)  y = (y1,  y2,  y3)。此時在3D空間已經不能對其進行線性劃分了,那麼我們通過一個函數將數據映射到更高維的空間,比如9維的話,那麼 f(x) = (x1x1, x1x2, x1x3, x2x1, x2x2, x2x3, x3x1, x3x2, x3x3),由於需要計算內積,所以在新的數據在 9 維空間,需要計算  <f(x),  f(y)> 的內積,需要花費 O(n^2)。

  再具體點,令 x = (1, 2, 3), y = (4, 5, 6),那麼 f(x)  = (1, 2, 3, 2, 4, 6, 3, 6, 9),f(y) = (16, 20, 24, 20, 25, 36, 24, 30, 36)

  此時: <f(x),  f(y)>  = 16 + 40 + 72 +40 +100 + 180 + 72 +180 +324 = 1024

  對於3D空間這兩個數據,似乎還能計算,但是如果將維數擴大到一個非常大數的時候,計算起來可就不是這麼一點點問題了。

  然而,我們發現  K(x, y) = (<x, y>)^2   ,代入上式: K(x, y) = (4 + 10 + 18)^2 = 32^2 = 1024

  也就是說 : K(x, y) = (<x, y>)^2  = <f(x),  f(y)> 。

  但是 K(x, y) 計算起來卻比 <f(x), f(y)> 簡單的多,也就是說只要用 K(x, y)來計算,效果與 <f(x), f(y)> 是一樣的,但是計算效率卻大幅度提高了,如  K(x, y) 是 O(n),而  <f(x), f(y)> 是 O(n^2),所以使用核函數的好處就是,可以在一個低維空間去完成一個高緯度(或者無限維度)樣本內積的計算,比如上面例子中 K(x, y)的3D空間對比 <f(x), f(y)> 的9D空間。

  下面再舉個例子來證明一下上面的問題,為了簡單起見,假設所有樣本點都是二維點,其值分別為(x,  y),分類函數為:

   它對應的映射方式為:

   可以驗證:任意兩個擴維后的樣本點在3維空間的內積等於原樣本點在二維空間的函數輸出:

   有了這個核函數,以後的高維內積都可以轉換為低維的函數運算了,這裏也就是說只需要計算低維的內積,然後再平方。明顯問題得到解決且複雜度降低極大。總而言之:核函數它本質上隱含了從低維到高維的映射,從而避免直接計算高維的內積。

  當然上述例子是多項式核函數的一個特例,其實核函數的種類還有很多,後文會一一介紹。

4,核函數的計算原理

  通過上面的例子,我們大概可以知道核函數的巧妙應用了,下面學習一下核函數的計算原理。

  如果有一種方法可以在特徵空間中直接計算內積  <Φ(xi , Φ(x)> ,就像在原始輸入點的函數中一樣,就有可能將兩個步驟融合到一起建立一個非線性的學習器,這樣直接計算的方法稱為核函數方法。

  設 x 是輸入空間(歐式空間或者離散集合),H為特徵空間(希爾伯特空間),如果存在一個從 x 到 H 的映射:

  核是一個函數 K,對於所有 x, z ∈ χ, 則滿足:

   則稱Κ(x,z)為核函數,φ(x)為映射函數,φ(x)∙φ(z)為x,z映射到特徵空間上的內積。

  參考網友的理解:任意兩個樣本點在擴維后的空間的內積,如果等於這兩個樣本點在原來空間經過一個函數后的輸出,那麼這個函數就叫核函數。

  由於映射函數十分複雜難以計算,在實際中,通常都是使用核函數來求解內積,計算複雜度並沒有增加,映射函數僅僅作為一種邏輯映射,表徵着輸入空間到特徵空間的映射關係。至於為什麼需要映射后的特徵而不是最初的特徵來參与計算,為了更好地擬合是其中一個原因,另外的一個重要原因是樣例可能存在線性不可分的情況,而將特徵映射到高維空間后,往往就可分了。

  下面將核函數形式化定義。如果原始特徵內積是 <X ,  Z>,映射 <Φ(xi • Φ(x)>,那麼定義核函數(Kernel)為:

  到這裏,我們可以得出結論,如果要實現該節開頭的效果,只需要計算 Φ(x) ,然後計算 Φ(x)TΦ(x)即可,然而這種計算方式是非常低效的。比如最初的特徵是n維的,我們將其映射到 n2 維,然後再計算,這樣需要O(n2 ) 的時間,那麼我們能不能想辦法減少計算時間呢?

  先說結論,當然是可以的,畢竟我們上面例子,活生生的說明了一個將需要 O(n2 ) 的時間 轉換為 需要O(n ) 的時間。

  先看一個例子,假設x和z都是n維度的,

  展開后,得到:

  這個時候發現我們可以只計算原始特徵 x 和 z 內積的平方(時間複雜度為O(n)),就等價於計算映射后特徵的內積。也就是說我們不需要花O(n2 ) 的時間了。

  現在看一下映射函數(n = 3),根據上面的公式,得到:

  也就是說核函數  Κ(x,z) = (xTz)2  只能選擇這樣的 φ 作為映射函數時才能夠等價於映射后特徵的內積。

  再看另外一個核函數,高斯核函數:

  這時,如果 x 和 z 很相近 (||x – z || 約等於 0),那麼核函數值為1,如果 x 和 z 相差很大(||x – z ||  >> 0),那麼核函數值約等於0.由於這個函數類似於高斯分佈,因此稱為高斯核函數,也叫做徑向基函數(Radial Basis Function 簡稱為RBF)。它能夠把原始特徵映射到無窮維。

  下面有張圖說明在低維線性不可分時,映射到高維后就可分了,使用高斯核函數。

  注意,使用核函數后,怎麼分類新來的樣本呢?線性的時候我們使用SVM學習出w和b,新來樣本x的話,我們使用 wTx + b 來判斷,如果值大於等於1,那麼是正類,小於等於是負類。在兩者之間,認為無法確定。如果使用了核函數后,wTx + b 就變成了 wTΦ(x) + b,是否先要找到 Φ(x) ,然後再預測?答案肯定不是了,找 Φ(x) 很麻煩,回想我們之前說過的。

  只需將 <(x(i) , x> 替換成  (x(i) , x),然後值的判斷同上。

4.1  核函數有效性的判定

  問題:給定一個函數K,我們能否使用K來替代計算 Φ(x)TΦ(x),也就說,是否能夠找出一個 Φ,使得對於所有的x和z,都有 K(x, z) = Φ(x)TΦ(x),即比如給出了 K(x, z) = (xTz)2,是否能夠認為K是一個有效的核函數。

  下面來解決這個問題,給定m個訓練樣本(x(1),x(2), ….,x(m)),每一個x(i) 對應一個特徵向量。那麼,我們可以將任意兩個 x(i) 和 x(j) 帶入K中,計算得到Kij = K(x(i), x(j))。i 可以從1到m,j 可以從1到m,這樣可以計算出m*m的核函數矩陣(Kernel Matrix)。為了方便,我們將核函數矩陣和 K(x, z) 都使用 K 來表示。如果假設 K 是有效地核函數,那麼根據核函數定義:

  可見,矩陣K應該是個對稱陣。讓我們得出一個更強的結論,首先使用符號ΦK(x)來表示映射函數 Φ(x) 的第 k 維屬性值。那麼對於任意向量 z,得:

  最後一步和前面計算 K(x, z) = (xTz)2 時類似。從這個公式我們可以看出,如果K是個有效的核函數(即 K(x, z)  和 Φ(x)TΦ(z)等價),那麼,在訓練集上得到的核函數矩陣K應該是半正定的(K>=0)。這樣我們得到一個核函數的必要條件:K是有效的核函數 ==> 核函數矩陣K是對稱半正定的。

  Mercer定理表明為了證明K是有效的核函數,那麼我們不用去尋找 Φ ,而只需要在訓練集上求出各個 Kij,然後判斷矩陣K是否是半正定(使用左上角主子式大於等於零等方法)即可。

 

5,核函數:如何處理非線性數據

  來看個核函數的例子。如下圖所示的兩類數據,分別分佈為兩個圓圈的形狀,這樣的數據本身就是線性不可分的,此時我們該如何把這兩類數據分開呢?

   事實上,上圖所示的這個數據集,是用兩個半徑不同的圓圈加上了少量的噪音生成得到的,所以,一個理想的分界應該是“圓圈” 而不是“一條線”(超平面)。如果用 X1 和 X2 來表示這個二維平面的兩個坐標的話,我們知道一條二次曲線(圓圈是二次曲線的一種特殊情況)的方程可以寫作這樣的形式:

   注意上面的形式,如果我們構造另外一個五維的空間,其中五個坐標的值分別為:

   那麼顯然,上面的方程在新的坐標系下可以寫做:

   關於新的坐標 Z,這正是一個 hyper plane 的方程!也就是說,如果我們做一個映射:

   將X按照上面的規則映射為 Z,那麼在新的空間中原來的數據將變成線性可分的,從而使用之前我們推導的線性分類算法就可以進行處理了。這正是Kernel方法處理非線性問題的基本思想。

  再進一步描述 Kernel 的細節之前,不妨再來看看上述例子在映射過後的直觀形態。當然,我們無法將五維空間畫出來,不過由於我這裏生成數據的時候用了特殊的情形,所以這裏的超平面實際的方程是這個樣子的(圓心在X2軸上的一 個正圓):

   因此我只需要把它映射到下面這樣一個三維空間中即可:

   下圖即是映射之後的結果,將坐標軸經過適當的旋轉,就可以很明顯的看出,數據是可以通過一個平面來分開的

  核函數相當於把原來的分類函數:

   映射成:

   而其中的 α 可以通過求解如下 dual 問題而得到的:

   這樣一來問題就解決了嗎?似乎是的:拿到非線性數據,就找一個映射(Φ(•),然後一股腦把原來的數據映射到新空間中,再做線性SVM即可。不過事實上問題好像沒有這麼簡單)。

  細想一下,剛才的方法是不是有問題:

  在最初的例子里,我們對一個二維空間做映射,選擇的新空間是原始空間的所有一階和二階的組合,得到了五個維度;

  如果原始空間是三維(一階,二階和三階的組合),那麼我們會得到:3(一次)+3(二次交叉)+3(平方)+3(立方)+1(x1 * x2 * x3) + 2*3(交叉,一個一次一個二次,類似 x1*x2^2)=19 維的新空間,這個數目是呈指數級爆炸性增長的,從而勢必這給 Φ(•) 的計算帶來非常大的困難,而且如果遇到無窮維的情況,就根本無從計算了。

  這個時候,可能就需要Kernel出馬了。

  不妨還是從最開始的簡單例子觸發,設兩個向量為:

   而 Φ(•) 即是前面說的五維空間的映射,因此映射過後的內積為:

   (公式說明:上面的這兩個推導過程中,所說的前面的五維空間的映射,這裏說的便是前面的映射方式,回顧下之前的映射規則,再看看那個長的推導式,其實就是計算x1,x2各自的內積,然後相乘相加即可,第二個推導則是直接平方,去掉括號,也很容易推出來)

  另外,我們又注意到:

   二者有很多相似的地方,實際上,我們只要把某幾個維度線性縮放一下,然後再加上一個常數維度,具體來說,上面這個式子的計算結果實際上和映射

   之後的內積  <Φ(xi • Φ(x)>  的結果是相等的,那麼區別在什麼地方呢?

  • 1,一個是映射到高維空間中,然後再根據內積的公式進行計算
  • 2,另一個則直接在原來的低維空間中進行計算,而不需要顯式地寫出映射后的結果

  (公式說明:上面之中,最後的兩個式子,第一個算式,是帶內積的完全平方式,可以拆開,然後,再通過湊一個得到,第二個算式,也是根據第一個算式湊出來的)

  回想剛才提到的映射的維度爆炸,在前一種方法已經無法計算的情況下,后一種方法卻依舊能從容處理,甚至是無窮維度的情況也沒有問題。

  我們把這裏的計算兩個向量在隱式映射過後的空間中的內積的函數叫做核函數(kernel Function),例如,在剛才的例子中,我們的核函數為:

   核函數能簡化映射空間中的內積運算——剛好“碰巧”的是,在我們的SVM里需要計算的地方數據向量總是以內積的形式出現的。對比剛才我們上面寫出來的式子,現在我們的分類函數為:

   其中 α 由如下 dual 問題計算而得:

  這樣一來計算的問題就算解決了,避免了直接在高維空間中進行計算,而結果卻是等價的!當然,因為我們這裏的例子非常簡單,所以可以手工構造出對應於 Φ(•) 的核函數出來,如果對於任意一個映射,想要構造出對應的核函數就非常困難了。

6,核函數的本質

  下面概況一下核函數的意思:

  • 1,實際上,我們會經常遇到線性不可分的樣例,此時,我們的常用做法是把樣例特徵映射到高位空間中去(比如之前有個例子,映射到高維空間后,相關特徵便被分開了,也就達到了分類的目的)
  • 2,進一步,如果凡是遇到線性不可分的樣例,一律映射到高維空間,那麼這個維度大小是會高到可怕的(甚至是無窮維),所以核函數就隆重出場了,核函數的價值在於它雖然也是將特徵進行從低維到高維的轉換,但核函數絕就絕在它事先在低維上進行計算,而將實質上的分類效果表現在了高維上,也就是上文所說的避免了直接在高維空間中的複雜計算。

  下面引用這個例子距離下核函數解決非線性問題的直觀效果。

  假設現在你是一個農場主,圈養了一批羊群,但為了預防狼群襲擊羊群,你需要搭建一個籬笆來把羊群圈起來。但是籬笆應該建在哪裡呢?你很可能需要依據羊群和狼群的位置搭建一個“分類器”,比如下圖這幾種不同的分類器,我們可以看到SVM完成了一個很完美的解決方案。

   這個例子側面簡單說明了SVM使用非線性分類器的優勢,而邏輯模式以及決策樹模式都是使用了直線方法。

7,幾種常見的核函數

  核函數有嚴格的數學要求,所以設計一個核函數是非常困難的,科學家們經過很多很多嘗試也就只嘗試出來幾個核函數,所以我們就不要在這方面下無用功了,直接拿這常見的幾個核函數使用就OK。

  下面來分別學習一下這幾個常見的核函數。

7.1  線性核(Linear Kernel )

  基本原理:實際上就是原始空間中的內積

   這個核存在的主要目的是使得“映射后空間中的問題” 和 “映射前空間中的問題” 兩者在形式上統一起來了(意思是說:我們有的時候,寫代碼或者寫公式的時候,只要寫個模板或者通用表達式,然後再代入不同的核,便可以了。於此,便在形式上統一了起來,不用再找一個線性的和一個非線性的)

     線性核,主要用於線性可分的情況,我們可以看到特徵空間到輸入空間的維度是一樣的。在原始空間中尋找最優線性分類器,具有參數少速度快的優勢。對於線性可分數據,其分類效果很理想。因此我們通常首先嘗試用線性核函數來做分類,看看效果如何,如果不行再換別的。

優點:

  • 方案首選,奧多姆剃刀定理
  • 簡單,可以快速解決一個QP問題
  • 可解釋性強:可以輕易知道哪些feature是重要的

限制:

  • 只能解決線性可分問題

7.2 多項式核(Polynomial Kernel)

  基本原理:依靠升維使得原本線性不可分的數據線性可分。

  多項式核函數可以實現將低維的輸入空間映射到高維的特徵空間。多項式核適合於正交歸一化(向量正交且模為1)數據,屬於全局核函數,允許相距很遠的數據點對核函數的值有影響。參數d越大,映射的維度越高,計算量就會越大。

優點:

  • 可解決非線性問題
  • 可通過主觀設置Q來實現總結的預判

缺點:

  • 多項式核函數的參數多,當多項式的階數d比較高的是,由於學習複雜性也會過高,易出現“過擬合”現象,核矩陣的元素值將趨於無窮大或者無窮小,計算複雜度會大道無法計算。

 

7.3  高斯核(Gaussian Kernel)/ 徑向基核函數(Radial Basis Function)

  徑向基核函數是SVM中常用的一個核函數。徑向基函數是一個採用向量作為自變量的函數,能夠基於向量距離運算輸出一個標量。

   也可以寫成如下格式:

  徑向基函數是指取值僅僅依賴於特定點距離的實值函數,也就是:

  任意一個滿足上式特性的函數 Φ 都叫徑向量函數,標準的一般使用歐氏距離,儘管其他距離函數也是可以的。所以另外兩個比較常用的核函數,冪指數核,拉普拉斯核也屬於徑向基核函數。此外不太常用的徑向基核還有ANOVA核,二次有理核,多元二次核,逆多元二次核。

  高斯徑向基函數是一種局部性強的核函數,其可以將一個樣本映射到一個更高維的空間內,該核函數是應用最廣的一個,無論大樣本還是小樣本都有比較好的性能,而且其相對於多項式核函數參數要少,因此大多數情況下在不知道用什麼樣的核函數的時候優先使用高斯核函數。

  徑向基核函數屬於局部核函數,當數據點距離中心點變遠時,取值會變小。高斯徑向基核對數據中存在的噪聲有着較好的抗干擾能力,由於其很強的局部性,其參數決定了函數作用範圍,隨着參數 σ 的增大而減弱。

優點:

  • 可以映射到無線維
  • 決策邊界更為多樣
  • 只有一個參數,相比多項式核容易選擇

缺點:

  • 可解釋性差(無限多維的轉換,無法算出W)
  • 計算速度比較慢(當解決一個對偶問題)
  • 容易過擬合(參數選不好時容易overfitting)

上述所講的徑向核函數表達式:

  冪指數核(Exponential Kernel)

  拉普拉斯核(LaplacIan Kernel)

 

   ANOVA 核(ANOVA Kernel)

  二次有理核(Rational Quadratic Kernel)

  多元二次核(Multiquadric Kernel)

  逆多元二次核(Inverse Multiquadric Kernel)

7.4  Sigmoid核

   Sigmoid核函數來源於神經網絡,被廣泛用於深度學習和機器學習中

  採用Sigmoid函數作為核函數時,支持向量機實現的就是一種多層感知器神經網絡,應用SVM方法,隱含層節點數目(它確定神經網絡的結構),隱含層節點對輸入節點的權重都是在設計(訓練)的過程中自動確定的。而且支持向量機的理論基礎決定了它最終求得的是全局最優值而不是局部最優值,也保證了它對未知樣本的良好泛化能力而不會出現過學習線性。

8,核函數的選擇

8.1,先驗知識

  利用專家的先驗知識預先選定核函數

8.2,交叉驗證

  採取Cross-Validation方法,即在進行核函數選取時,分別試用不同的核函數,歸納誤差最小的核函數就是最好的核函數。如針對傅里恭弘=叶 恭弘核,RBF核,結合信號處理問題中的函數回歸問題,通過仿真實驗,對比分析了在相同數據條件下,採用傅里恭弘=叶 恭弘核的SVM要比採用RBF核的SVM誤差小很多。

8.3,混合核函數

  採用由Smits等人提出的混合核函數方法,該方法較之前兩者是目前選取核函數的主流方法,也是關於如何構建核函數的又一開創性的工作,將不同的核函數結合起來後有更好的特性,這是混合核函數方法的基本思想。

8.4,經驗

  當樣本特徵很多時,特徵的維度很高,這是往往樣本線性可分,可考慮用線性核函數的SVM或者LR(如何不考慮核函數,LR和SVM都是線性分類算法,也就是說他們的分類決策面都是線性的)

  當樣本的數量很多,但特徵較少時,可以手動添加一些特徵,使樣本線性可分,再考慮用線性核函數的SVM或者LR

  當樣本特徵維度不高時,樣本數量也不多時,考慮使用高斯核函數(RBF核函數的一種,指數核函數和拉普拉斯核函數也屬於RBF核函數)

8.5,吳恩達給出的選擇核函數的方法

   如果特徵的數量大道和樣本數量差不多,則選用LR或者線性核的SVM

  如果特徵的數量小,樣本的數量正常,則選用SVM+ 高斯核函數

  如果特徵的數量小,而樣本的數量很大,則需要手工添加一些特徵從而變成第一種情況

8.6  核函數選擇的例子

  這裏簡單說一下核函數與其他參數的作用(後面會詳細學習關於使用Sklearn學習SVM):

  • kernel=’linear’ 時,C越大分類效果越好,但有可能會過擬合(default C=1)
  • kernel=’rbf’時,為高斯核,gamma值越小,分類界面越連續;gamma值越大,分類界面越“散”,分類效果越好,但有可能會過擬合。

  我們來看一個簡單的例子,數據為[-5.0 , 9.0] 的隨機數組,函數如下 :

  下面分別使用三種核SVR:兩種乘法係數高斯核rbf和一種多項式核poly。代碼如下:

from sklearn import svm
import numpy as np
from matplotlib import pyplot as plt
import warnings

warnings.filterwarnings('ignore')

X = np.arange(-5.0 , 9.0 , 0.1)
# print(X)
X = np.random.permutation(X)
# print('1X:',X)
X_ = [[i] for i in X]
b = 0.5
y = 0.5 * X ** 2.0 + 3.0 * X + b + np.random.random(X.shape) * 10.0
y_ = [i for i in y]

# degree = 2 , gamma=, coef0 =
rbf1 = svm.SVR(kernel='rbf',C=1,)
rbf2 = svm.SVR(kernel='rbf',C=20,)
poly = svm.SVR(kernel='poly',C=1,degree=2)

rbf1.fit(X_ , y_)
rbf2.fit(X_ , y_)
poly.fit(X_ , y_)


result1 = rbf1.predict(X_)
result2 = rbf2.predict(X_)
result3 = poly.predict(X_)


plt.plot(X,y,'bo',fillstyle='none')
plt.plot(X,result1,'r.')
plt.plot(X,result2,'g.')
plt.plot(X,result3,'b.')
plt.show()

  結構圖如下:

  藍色是poly,紅色是c=1的rbf,綠色c=20的rbf。其中效果最好的是C=20的rbf。如果我們知道函數的表達式,線性規劃的效果更好,但是大部分情況下我們不知道數據的函數表達式,因此只能慢慢實驗,SVM的作用就在這裏了。

9,總結

  支持向量機是一種分類器。之所以稱為“機”是因為它會產生一個二值決策結果,即它是一種決策“機”。支持向量機的泛化錯誤率較低,也就是說它具有良好的學習能力,且學到的結果具有很好的推廣性。這些優點使得支持向量機十分流行,有些人認為它是監督學習中最好的定式算法。

  支持向量機視圖通過求解一個二次優化問題來最大化分類間隔。在過去,訓練支持向量機常採用非常複雜並且低效的二次規劃求解方法。John Platt 引入了SMO算法,此算法可以通過每次只優化2個 α 值來加快SVM的訓練速度。

  核方法或者說核技巧會將數據(有時候是非線性數據)從一個低維空間映射到一個高維空間,可以將一個在低維空間中的非線性問題轉化為高維空間下的線性問題來求解。核方法不止在SVM中適用,還可以用於其他算法。而其中的徑向基函數是一個常用的度量兩個向量距離的核函數。

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※回頭車貨運收費標準

※台中搬家公司費用怎麼算?

美研究早預言武漢肺炎 點名「野味市場」風險最高

摘錄自2020年4月8日自由時報報導

根據《CNN》報導,美國加州大學(University of California)與澳洲墨爾本大學(University of Melbourne)研究人員數年前進行的研究中發現,在人類持續開發破壞自然棲地時,原宿主是動植物的病毒一旦得以傳染人類,將構成相當高程度的風險。

研究作者,美國加州大學流行病學教授強森博士(Dr. Christine Kreuder Johnson)當時便曾警告,未來很可能出現具有威脅人類生存能力的動物傳人傳染病。

強森博士表示,當人類把野生哺乳類動物從自然環境捕捉並運送至市場上出售時,對這些活體野生動物造成極大的壓力,導致更多潛在存於動物體內的病毒有更高的潛力散播至人群中。她說,與野外接觸相比,處於被捕獲狀態下的野生動物具有更高的排泄、噴沫等衝動,將導致病毒被大量排出,暴露在大量人群密集分布的環境,如中國惡名昭彰的野味市場。

生活環境
國際新聞
美國
野味
武漢肺炎
蝙蝠與新興傳染病
食品安全

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※廣告預算用在刀口上,台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※教你寫出一流的銷售文案?

※超省錢租車方案

※廣告預算用在刀口上,台北網頁設計公司幫您達到更多曝光效益

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※回頭車貨運收費標準

研究:人類接觸野生動物恐招致病毒入侵 三種類別動物風險尤高

環境資訊中心綜合外電;姜唯 編譯;林大利 審校

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

※網頁設計最專業,超強功能平台可客製化

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※台中搬家遵守搬運三大原則,讓您的家具不再被破壞!

疫情之後還有氣候戰役 歐盟十國環境部長公開信:復甦方案要綠色政綱

環境資訊中心綜合外電;黃鈺婷、鄒敏惠 編譯;趙家緯 審校

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※超省錢租車方案

※別再煩惱如何寫文案,掌握八大原則!

※回頭車貨運收費標準

※教你寫出一流的銷售文案?

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※廣告預算用在刀口上,台北網頁設計公司幫您達到更多曝光效益

※網頁設計最專業,超強功能平台可客製化

趁疫情偷抓瀕危鱘魚 野生動物犯罪急升 WWF警告:中東歐保育類猛禽陷危機

環境資訊中心綜合外電;姜唯 編譯;林大利 審校

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※回頭車貨運收費標準

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※推薦評價好的iphone維修中心

※教你寫出一流的銷售文案?

※台中搬家公司教你幾個打包小技巧,輕鬆整理裝箱!

※台中搬家遵守搬運三大原則,讓您的家具不再被破壞!