SVM分析——svm.h

時間  2019-12-05
標籤 svm 分析 svm.h 简体版
原文   原文鏈接 
 # ifndef _LIBSVM_H
#define _LIBSVM_H
#define LIBSVM_VERSION 320
#ifdef __cplusplus
extern "C" {//支持c與c++混合編程
#endif
extern int libsvm_version;
struct svm_node     //存儲單個特徵向量
{
 int index;         //特徵的維數
 double value;     //特徵的數值
};
struct svm_problem     //存儲本次參加運算的參數
{
 int all ;       //數據的總數
 double *p;      //指向數據分類類別的指針
 svm_node **x;     //指向存儲內容爲指針的指針
};
enum { C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR }; //定義枚舉類型表示選用SVM的類別
enum { LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED }; //定義枚舉類型表示所選取的核函數類型
struct svm_parameter
{
 int svm_type;//定義svm分類類型
 int kernel_type;//定義核函數類型
 int degree;//核函數的指數
 double gamma;
 double coef0;
 /* training parameter*/
 double cache_size;//訓練所需的內存
 double eps;
 double C;//懲罰因子
 int nr_weight;//
 int *weight_lable;//權重的數目
 double* weight;//權重
 double nu;
 double p;
 int shrinking;//是否壓縮
 int probability;//是否作機率估計
}
//svm_model
struct svm_model
{
 struct svm_parameter param;//訓練參數
 int nr_class;//類別數
 int l;//支持向量數
 struct svm_node **SV;             /*保存支持向量的指針，至於支持向量的內容，若是是從文件中讀取，內容會
                                       額外保留；若是是直接訓練得來，則保留在原來的訓練集中。若是訓練完成後須要預報，原來的
                                       訓練集內存不能夠釋放。*/
 double *rho;//判別函數的alpha
 double *probA;
 double *probB;
 int *sv_indices;
 //classification use
 int *lable;
 int *nSV;
 int free_sv;
};
struct svm_model *svm_train(const struct svm_self *prob,const svm_parameter *param);//定義svm訓練函數
void svm_cross_validation(const struct svm_problem *prob, const struct svm_parameter *param, int nr_fold, double *target);//交差驗證函數 
int svm_save_model(const char *model_file_name, const struct svm_model *model);//保存訓練好的數據函數
struct svm_model *svm_load_model(const char *model_file_name);//將訓練好的模型讀取到內存中
int svm_get_svm_type(const struct svm_model *model);//獲得svm類型的函數
int svm_get_nr_class(const struct svm_model *model);//獲得數據的類別數函數
void svm_get_labels(const struct svm_model *model, int *label);//獲得數據的類別標號
void svm_get_sv_indices(const struct svm_model *model, int *sv_indices);
int svm_get_nr_sv(const struct svm_model *model);
double svm_get_svr_probability(const struct svm_model *model);
double svm_predict_values(const struct svm_model *model, const struct svm_node *x, double* dec_values);//用訓練好的模型預測數據類別，並保存到數組
double svm_predict(const struct svm_model *model, const struct svm_node *x);//預測某同樣本的函數
double svm_predict_probability(const struct svm_model *model, const struct svm_node *x, double* prob_estimates);
void svm_free_model_content(struct svm_model *model_ptr);//清除訓練模型，釋放資源
void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr);
void svm_destroy_param(struct svm_parameter *param);
const char *svm_check_parameter(const struct svm_problem *prob, const struct svm_parameter *param);
int svm_check_probability_model(const struct svm_model *model);
void svm_set_print_string_function(void (*print_func)(const char *));
#ifdef __cplusplus
}
#endif
#endif /* _LIBSVM_H */

 

 

 

 

如今開始看一看libsvm的頭文件svm.hhtml

svm.h中主要是定義了4個結構體，分別是svm_node、svm_problem、svm_parameter、svm_model，而後就是19個函數的聲明，函數的聲明我就不先講了，等到在svm.cpp中碰到後再細說。下面來看一看這幾個結構體：node

 

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. struct svm_node  
    2.  
 
  
  2. {  
    3.  
 
  
  3.     int index;  
    4.  
 
  
  4.     double value;  
    5.  
 
  
  5. };  
    6.

 

       這個結構體用於存儲單一貫量中的單個特徵。例如：向量x1={0.002，0.345，4.000，5.677}，則用svm_node來存儲就是使用一個包含5個svm_node的數組來存儲這個4維向量，內存中的表示以下：c++

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. struct svm_problem  
    2.  
 
  
  2. {  
    3.  
 
  
  3.     int l; //記錄樣本總數  
    4.  
 
  
  4.     double *y;//指向樣本所屬類別的數組  
    5.  
 
  
  5.     struct svm_node **x;//指向一個存儲內容爲指針的數組  
    6.  
 
  
  6. };  
    7.

 

這個結構體用於存儲本次參加運算的全部樣本及其所屬類別，一個示意圖以下（其中最右邊的4個長方格如同上圖中的表格）：web

 struct svm_parameter
{
 int svm_type;//定義svm分類類型
 int kernel_type;//定義核函數類型
 int degree;//核函數的指數
 double gamma;
 double coef0;
 /* training parameter*/
 double cache_size;//訓練所需的內存
 double eps;
 double C;//懲罰因子
 int nr_weight;//
 int *weight_lable;//權重的數目
 double* weight;//權重
 double nu;
 double p;
 int shrinking;//是否壓縮
 int probability;//是否作機率估計
}

這個結構體用於存儲svm的各個參數，知道就行。面試

 struct svm_model
{
 struct svm_parameter param;//訓練參數
 int nr_class;//類別數
 int l;//支持向量數
 struct svm_node **SV;             /*保存支持向量的指針，至於支持向量的內容，若是是從文件中讀取，內容會
                                       額外保留；若是是直接訓練得來，則保留在原來的訓練集中。若是訓練完成後須要預報，原來的
                                       訓練集內存不能夠釋放。*/
 double *rho;//判別函數的alpha
 double *probA;
 double *probB;
 int *sv_indices;
 //classification use
 int *lable;
 int *nSV;
 int free_sv;
};

 

這個函數體用於保存訓練後的訓練模型model，在predict中要用到。
=======================================編程

關於extern 「C」的解析數組

在閱讀svm.h時發現了以下一段代碼：app

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. #ifndef _LIBSVM_H  
    2.  
 
  
  2. #define _LIBSVM_H  
    3.  
 
  
  3. #define LIBSVM_VERSION 317  
    4.  
 
  
  4.   
    5.  
 
  
  5. #ifdef __cplusplus  
    6.  
 
  
  6. extern "C" {  
    7.  
 
  
  7. #endif  
    8.

 

顯然，前3行代碼是爲了防止頭文件被重複引用，那麼5-6行是什麼意思呢？函數


某企業曾經給出以下的一道面試題：爲何標準頭文件都有相似如下的結構？oop

 
   
   
   
   

   

   

    
    
    
    
    
    

   
     
 
    
  1. #ifndef __INCvxWorksh  
    2.  
 
    
  2. #define __INCvxWorksh   
    3.  
 
    
  3. #ifdef __cplusplus  
    4.  
 
    
  4. extern "C" {  
    5.  
 
    
  5. #endif   
    6.  
 
    
  6. /*...*/   
    7.  
 
    
  7. #ifdef __cplusplus  
    8.  
 
    
  8. }  
    9.  
 
    
  9. #endif   
    10.  
 
    
  10. #endif /* __INCvxWorksh */  
    11.

 

分析
顯然，頭文件中的編譯宏「#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif」 的做用是防止該頭文件被重複引用。

那麼

 
   
   
   
   

   

   

    
    
    
    
    
    

   
     
 
    
  1. #ifdef __cplusplus  
    2.  
 
    
  2. extern "C" {  
    3.  
 
    
  3. #endif   
    4.  
 
    
  4. #ifdef __cplusplus  
    5.  
 
    
  5. }  
    6.  
 
    
  6. #endif  
    7.

 

的做用又是什麼呢？

extern "C" 包含雙重含義，從字面上便可獲得：首先，被它修飾的目標是「extern」的；其次，被它修飾的目標是「C」的。讓咱們來詳細解讀這兩重含義。

被extern "C"限定的函數或變量是extern類型的；extern是C/C++語言中代表函數和全局變量做用範圍（可見性）的關鍵字，該關鍵字告訴編譯器，其聲明的函數和變量能夠在本模塊或其它模塊中使用。記住，下列語句：extern int a;僅僅是一個變量的聲明，其並非在定義變量a，並未爲a分配內存空間。變量a在全部模塊中做爲一種全局變量只能被定義一次，不然會出現鏈接錯誤。一般，在模塊的頭文件中對本模塊提供給其它模塊引用的函數和全局變量以關鍵字extern聲明。例如，若是模塊B欲引用該模塊A中定義的全局變量和函數時只需包含模塊A的頭文件便可。這樣，模塊B中調用模塊A中的函數時，在編譯階段，模塊B雖然找不到該函數，可是並不會報錯；它會在鏈接階段中從模塊A編譯生成的目標代碼中找到此函數。

與extern對應的關鍵字是static，被它修飾的全局變量和函數只能在本模塊中使用。所以，一個函數或變量只可能被本模塊使用時，其不可能被extern 「C」修飾。

被extern "C"修飾的變量和函數是按照C語言方式編譯和鏈接的；

未加extern 「C」聲明時的編譯方式

首先看看C++中對相似C的函數是怎樣編譯的。做爲一種面向對象的語言，C++支持函數重載，而過程式語言C則不支持。函數被C++編譯後在符號庫中的名字與C語言的不一樣。例如，假設某個函數的原型爲：

[cpp]   view plain copy 在CODE上查看代碼片 派生到個人代碼片
<EMBED id=ZeroClipboardMovie_8 height=18 name=ZeroClipboardMovie_8 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=8&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">
  1. void foo( int x, int y );  

該函數被C編譯器編譯後在符號庫中的名字爲_foo，而C++編譯器則會產生像_foo_int_int之類的名字（不一樣的編譯器可能生成的名字不一樣，可是都採用了相同的機制，生成的新名字稱爲「mangled name」）。_foo_int_int這樣的名字包含了函數名、函數參數數量及類型信息，C++就是靠這種機制來實現函數重載的。例如，在C++中，函數void foo( int x, int y )與void foo( int x, float y )編譯生成的符號是不相同的，後者爲_foo_int_float。一樣地，C++中的變量除支持局部變量外，還支持類成員變量和全局變量。用戶所編寫程序的類成員變量可能與全局變量同名，咱們以"."來區分。而本質上，編譯器在進行編譯時，與函數的處理類似，也爲類中的變量取了一個獨一無二的名字，這個名字與用戶程序中同名的全局變量名字不一樣。

未加extern "C"聲明時的鏈接方式

假設在C++中，模塊A的頭文件以下：

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. // 模塊A頭文件　moduleA.h  
    2.  
 
  
  2. #ifndef MODULE_A_H  
    3.  
 
  
  3. #define MODULE_A_H  
    4.  
 
  
  4. int foo( int x, int y );  
    5.  
 
  
  5. #endif  
    6.

 

在模塊B中引用該函數：

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. // 模塊B實現文件　moduleB.cpp  
    2.  
 
  
  2. #include "moduleA.h"  
    3.  
 
  
  3. foo(2,3);  
    4.

 

實際上，在鏈接階段，鏈接器會從模塊A生成的目標文件moduleA.obj中尋找_foo_int_int這樣的符號！

加extern "C"聲明後的編譯和鏈接方式

加extern "C"聲明後，模塊A的頭文件變爲：

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. // 模塊A頭文件　moduleA.h  
    2.  
 
  
  2. #ifndef MODULE_A_H  
    3.  
 
  
  3. #define MODULE_A_H  
    4.  
 
  
  4. extern "C" int foo( int x, int y );  
    5.  
 
  
  5. #endif 
    6.

 

 

 

在模塊B的實現文件中仍然調用foo( 2,3 )，其結果是：

（1）模塊A編譯生成foo的目標代碼時，沒有對其名字進行特殊處理，採用了C語言的方式；

（2）鏈接器在爲模塊B的目標代碼尋找foo(2,3)調用時，尋找的是未經修改的符號名_foo。

因此，能夠用一句話歸納extern 「C」這個聲明的真實目的：實現C++與C及其它語言的混合編程。
　　
extern "C"的慣用法

（1）在C++中引用C語言中的函數和變量，在包含C語言頭文件（假設爲cExample.h）時，需進行下列處理：

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. extern "C"  
    2.  
 
  
  2. {  
    3.  
 
  
  3. #include "cExample.h"  
    4.  
 
  
  4. }  
    5.

 

 

 

而在C語言的頭文件中，對其外部函數只能指定爲extern類型，C語言中不支持extern "C"聲明，在.c文件中包含了extern "C"時會出現編譯語法錯誤。筆者編寫的C++引用C函數例子工程中包含的三個文件的源代碼以下：

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. /* c語言頭文件：cExample.h */  
    2.  
 
  
  2. #ifndef C_EXAMPLE_H  
    3.  
 
  
  3. #define C_EXAMPLE_H  
    4.  
 
  
  4. extern int add(int x,int y);  
    5.  
 
  
  5. #endif  
    6.  
 
  
  6. /* c語言實現文件：cExample.c */  
    7.  
 
  
  7. #include "cExample.h"  
    8.  
 
  
  8. int add( int x, int y )  
    9.  
 
  
  9. {  
    10.  
 
  
  10.   return x + y;  
    11.  
 
  
  11. }  
    12.  
 
  
  12. // c++實現文件，調用add：cppFile.cpp  
    13.  
 
  
  13. extern "C"   
    14.  
 
  
  14. {  
    15.  
 
  
  15. #include "cExample.h"  
    16.  
 
  
  16. }  
    17.  
 
  
  17. int main(int argc, char* argv[])  
    18.  
 
  
  18. {  
    19.  
 
  
  19.   add(2,3);   
    20.  
 
  
  20.   return 0;  
    21.  
 
  
  21. }  
    22.

 

若是C++調用一個C語言編寫的.DLL時，當包括.DLL的頭文件或聲明接口函數時，應加extern "C" {　}。

（2）在C中引用C++語言中的函數和變量時，C++的頭文件需添加extern "C"，可是在C語言中不能直接引用聲明瞭extern "C"的該頭文件，應該僅將C文件中將C++中定義的extern "C"函數聲明爲extern類型。
筆者編寫的C引用C++函數例子工程中包含的三個文件的源代碼以下：

 

 
 
 
 
 

 

 

  
  
  
  
  
  

 
     
 
  
  1. //C++頭文件 cppExample.h  
    2.  
 
  
  2. #ifndef CPP_EXAMPLE_H  
    3.  
 
  
  3. #define CPP_EXAMPLE_H  
    4.  
 
  
  4. extern "C" int add( int x, int y );  
    5.  
 
  
  5. #endif  
    6.  
 
  
  6. //C++實現文件 cppExample.cpp  
    7.  
 
  
  7. #include "cppExample.h"  
    8.  
 
  
  8. int add( int x, int y )  
    9.  
 
  
  9. {  
    10.  
 
  
  10.    return x + y;  
    11.  
 
  
  11. }  
    12.  
 
  
  12. /* C實現文件 cFile.c 
    13.  
 
  
  13. /* 這樣會編譯出錯：#include "cExample.h" */  
    14.  
 
  
  14. extern int add( int x, int y );  
    15.  
 
  
  15. int main( int argc, char* argv[] )  
    16.  
 
  
  16. {  
    17.  
 
  
  17.   add( 2, 3 );   
    18.  
 
  
  18.   return 0;  
    19.  
 
  
  19. }  
    20.

 

 

上面關於extern C的解析轉載自：C++中extern 「C」含義深層探索

其餘關於extern C 的知識可參見博文：

C++項目中的extern "C" {}

面試之C++：extern及extern 「C」用法

 

 

 

‍

  1. #ifndef _HELLO_H_
  2. #define _HELLO_H_

  4. #ifdef __cplusplus
  5. #define extern "C" {
  6. #endif


  9. //Your code


  12. #ifdef __cplusplus
  13. #define }
  14. #endif

  16. #endif /*_HELLO_H*/

  • 外層的「#ifndef _HELLO_H_」是爲了防止本文件被重複include。
  • 內層的「#ifdef __cplusplus」是爲了解決c 和c的名字匹配問題。

C 支持函數重載，c語言不支持函數重載。函數被c 編譯後在庫裏面的名字與c語言不一樣。

假設某個函數的原型爲：

void foo( int x, int y );

　　該函數被C編譯器編譯後在符號庫中的名字爲_foo，而C 編譯器則會產生像_foo_int_int之類的名字（不一樣的編譯器可能生成的名字不一樣，可是都採用了相同的機制，生成的新名字稱爲「mangled name」）。

　　_foo_int_int這樣的名字包含了函數名、函數參數數量及類型信息，C 就是靠這種機制來實現函數重載的。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程