开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 查看源码
SVM.h
资源名称：TextClassify.rar　[点击查看]
上传用户：sanxfzhen
上传日期：2014-12-28
资源大小：2324k
文件大小：14k
源码类别：

多国语言处理

开发平台：

Visual C++

SVM.h：源码内容
  1. // SVM.h: interface for the CSVM class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #if !defined(AFX_SVM_H__169833C2_5291_4CDB_BE81_22DBD80908F0__INCLUDED_)
  6. #define AFX_SVM_H__169833C2_5291_4CDB_BE81_22DBD80908F0__INCLUDED_
  8. #if _MSC_VER > 1000
  9. #pragma once
  10. #endif // _MSC_VER > 1000
  12. #include "Compute_Param.h"
  13. #include "Compute_Prompt.h"
  14. #include "Compute_Result.h"
  16. # define CFLOAT  float       /* the type of float to use for caching */
  17. /* kernel evaluations. Using float saves */
  18. /* us some memory, but you can use double, too */
  19. # define FNUM    long        /* the type used for storing feature ids */
  20. # define FVAL    float       /* the type used for storing feature values */
  22. # define LINEAR  0           /* linear kernel type */
  23. # define POLY    1           /* polynoial kernel type */
  24. # define RBF     2           /* rbf kernel type */
  25. # define SIGMOID 3           /* sigmoid kernel type */
  26. # define CUSTOM  4
  28. typedef struct word
  29. {
  30. FNUM    wnum;
  31. FVAL    weight;
  32. } SVM_WORD;
  34. typedef struct doc
  35. {
  36. long    docnum;
  37. double  twonorm_sq;
  38. SVM_WORD    *words;
  39. } DOC;
  41. typedef struct learn_parm 
  42. {
  43. double svm_c;                /* upper bound C on alphas */
  44. double svm_costratio;        /* factor to multiply C for positive examples */
  45. double transduction_posratio;/* fraction of unlabeled examples to be */ /* classified as positives */
  46. long   biased_hyperplane;    /* if nonzero, use hyperplane w*x+b=0  otherwise w*x=0 */
  47. long   svm_maxqpsize;        /* size q of working set */
  48. long   svm_newvarsinqp;      /* new variables to enter the working set in each iteration */
  49. double epsilon_crit;         /* tolerable error for distances used in stopping criterion */
  50. double epsilon_shrink;       /* how much a multiplier should be above  zero for shrinking */
  51. long   svm_iter_to_shrink;   /* iterations h after which an example can be removed by shrinking */
  52. long   remove_inconsistent;  /* exclude examples with alpha at C and  retrain */
  54.  
  55. long   skip_final_opt_check; 
  56.  /* do not check KT-Conditions at the end of optimization for examples removed by  
  57.  shrinking. WARNING: This might lead to sub-optimal solutions! */
  59. long   compute_loo;          /* if nonzero, computes leave-one-out  estimates */
  60. double rho;                  /* parameter in xi/alpha-estimates and for pruning leave-one-out range [1..2] */
  61. long   xa_depth;             /* parameter in xi/alpha-estimates upper  bounding the number of SV the current alpha_t is distributed over */
  62. char predfile[200];          /* file for predicitions on unlabeled examples  in transduction */
  63. char alphafile[200];         
  64. /* file to store optimal alphas in. use
  65. empty string if alphas should not be   output */
  68. /* you probably do not want to touch the following */
  69. double epsilon_const;        /* tolerable error on eq-constraint */
  70. double epsilon_a;            /* tolerable error on alphas at bounds */
  71. double opt_precision;        /* precision of solver, set to e.g. 1e-21   if you get convergence problems */
  74. /* the following are only for internal use */
  75. long   svm_c_steps;          /* do so many steps for finding optimal C */
  76. double svm_c_factor;         /* increase C by this factor every step */
  77. double svm_costratio_unlab;
  78. double svm_unlabbound;
  79. double *svm_cost;            /* individual upper bounds for each var */
  80. long   totwords;             /* number of features */
  81. } LEARN_PARM;
  83. typedef struct kernel_parm 
  84. {
  85. long    kernel_type;   
  86. long    poly_degree;
  87. double  rbf_gamma;
  88. double  coef_lin;
  89. double  coef_const;
  90. char    custom[50];    /* for user supplied kernel */
  91. } KERNEL_PARM;
  93. typedef struct model 
  94. {
  95. long    sv_num;
  96. long    at_upper_bound;
  97. double  b;
  98. DOC     **supvec;
  99. double  *alpha;
  100. long    *index;       /* index from docnum to position in model */
  101. long    totwords;     /* number of features */
  102. long    totdoc;       /* number of training documents */
  103. KERNEL_PARM kernel_parm; /* kernel */
  105. /* the following values are not written to file */
  106. double  loo_error,loo_recall,loo_precision; /* leave-one-out estimates */
  107. double  xa_error,xa_recall,xa_precision;    /* xi/alpha estimates */
  108. double  *lin_weights;   /* weights for linear case using folding */
  109. } MODEL;
  111. typedef struct quadratic_program 
  112. {
  113. long   opt_n;            /* number of variables */
  114. long   opt_m;            /* number of linear equality constraints */
  115. double *opt_ce,*opt_ce0; /* linear equality constraints */
  116. double *opt_g;           /* hessian of objective */
  117. double *opt_g0;          /* linear part of objective */
  118. double *opt_xinit;       /* initial value for variables */
  119. double *opt_low,*opt_up; /* box constraints */
  120. } QP;
  122. typedef struct kernel_cache 
  123. {
  124. long   *index;  /* cache some kernel evalutations */
  125. CFLOAT *buffer; /* to improve speed */
  126. long   *invindex;
  127. long   *active2totdoc;
  128. long   *totdoc2active;
  129. long   *lru;
  130. long   *occu;
  131. long   elems;
  132. long   max_elems;
  133. long   time;
  134. long   activenum;
  135. long   buffsize;
  136. } KERNEL_CACHE;
  138.  
  139. typedef struct timing_profile 
  140. {
  141. long   time_kernel;
  142. long   time_opti;
  143. long   time_shrink;
  144. long   time_update;
  145. long   time_model;
  146. long   time_check;
  147. long   time_select;
  148. } TIMING;
  149.  
  150. typedef struct shrink_state 
  151. {
  152. long   *active;
  153. long   *inactive_since;
  154. long   deactnum;
  155. double **a_history;
  156. } SHRINK_STATE;
  158. typedef struct cache_parm_s {
  159.   KERNEL_CACHE *kernel_cache;
  160.   CFLOAT *cache;
  161.   DOC *docs; 
  162.   long m;
  163.   KERNEL_PARM *kernel_parm;
  164.   long offset,stepsize;
  165. } cache_parm_t;
  167. class CSVM  
  168. {
  169. public: 
  170. CSVM();
  171. virtual ~CSVM();
  172. int svm_learn_main (int);
  173. int svm_classify (int, double*);
  174. double svm_classify(DOC &doc);
  175. private:
  176. void set_learn_parameters(LEARN_PARM* learn_parm,KERNEL_PARM* kernel_parm);
  177. private:   //svm_common.h
  178. double classify_example(MODEL *, DOC *);
  179. double classify_example_linear(MODEL *, DOC *);
  180. CFLOAT kernel(KERNEL_PARM *, DOC *, DOC *); 
  181. double custom_kernel(KERNEL_PARM *, DOC *, DOC *); 
  182. double sprod_ss(SVM_WORD *, SVM_WORD *);
  183. double model_length_s(MODEL *, KERNEL_PARM *);
  184. void   clear_vector_n(double *, long);
  185. void   add_vector_ns(double *, SVM_WORD *, double);
  186. double sprod_ns(double *, SVM_WORD *);
  187. double sprod_ss1(SVM_WORD *a,SVM_WORD*b,int offset);
  188. double sprod_ss2(SVM_WORD *a,SVM_WORD*b,int offset);
  189. void   add_weight_vector_to_linear_model(MODEL *);
  190. int    read_model(char *, MODEL *, long, long);
  191. int    read_documents(char *, DOC *, long *, long, long, long *, long *, int);
  192. int    parse_document(char *, DOC *, long *, long *, long);
  193. int    nol_ll(char *, long *, long *, long *);
  194. double ktt(int ta,int tb,double pa[],double pb[]);
  195. double kt(int t,double ta[],double tb[]);
  196. double fi(double* tt);
  197. double fs(double ta[]);
  198. double sumofword(DOC* a);
  199. long   minl(long, long);
  200. long   maxl(long, long);
  201. long   get_runtime();
  202. void   *my_malloc(long); 
  203. void   copyright_notice();
  204. //void  SetInitParam();         ?????????
  205. int isnan(double);
  206. private:    //svm_common.h
  207. void printm(char*);
  208. void    printe(char*);
  209. private:    //svm_learn.h
  210. void   svm_learn(DOC *, long *, long, long, LEARN_PARM *, KERNEL_PARM *, 
  211.  KERNEL_CACHE *, MODEL *);
  212. long   optimize_to_convergence(DOC *, long *, long, long, LEARN_PARM *,
  213.        KERNEL_PARM *, KERNEL_CACHE *, SHRINK_STATE *,
  214.        MODEL *, long *, long *, double *, double *, 
  215.        TIMING *, double *, long, long);
  216. double compute_objective_function(double *, double *, long *, long *);
  217. void   clear_index(long *);
  218. void   add_to_index(long *, long);
  219. long   compute_index(long *,long, long *);
  220. void   optimize_svm(DOC *, long *, long *, long *, long *, MODEL *, long, 
  221.     long *, long, double *, double *, LEARN_PARM *, CFLOAT *, 
  222.     KERNEL_PARM *, QP *, double *);
  223. void   compute_matrices_for_optimization(DOC *, long *, long *, long *, 
  224.  long *, long *, MODEL *, double *, 
  225.  double *, long, long, LEARN_PARM *, 
  226.  CFLOAT *, KERNEL_PARM *, QP *);
  227. long   calculate_svm_model(DOC *, long *, long *, double *, double *, 
  228.    double *, LEARN_PARM *, long *, MODEL *);
  229. long   check_optimality(MODEL *, long *, long *, double *, double *,long, 
  230. LEARN_PARM *,double *, double, long *, long *, long *,
  231. long *, long, KERNEL_PARM *);
  232. long   identify_inconsistent(double *, long *, long *, long, LEARN_PARM *, 
  233.      long *, long *);
  234. long   identify_misclassified(double *, long *, long *, long,
  235.       MODEL *, long *, long *);
  236. long   identify_one_misclassified(double *, long *, long *, long,
  237.   MODEL *, long *, long *);
  238. long   incorporate_unlabeled_examples(MODEL *, long *,long *, long *,
  239.       double *, double *, long, double *,
  240.       long *, long *, long, KERNEL_PARM *,
  241.       LEARN_PARM *);
  242. void   update_linear_component(DOC *, long *, long *, double *, double *, 
  243.        long *, long, long, KERNEL_PARM *, 
  244.        KERNEL_CACHE *, double *,
  245.        CFLOAT *, double *);
  246. long   select_next_qp_subproblem_grad(long *, long *, double *, double *, long,
  247.       long, LEARN_PARM *, long *, long *, 
  248.       long *, double *, long *, KERNEL_CACHE *,
  249.       long *, long *);
  250. long   select_next_qp_subproblem_grad_cache(long *, long *, double *, double *,
  251.     long, long, LEARN_PARM *, long *, 
  252.     long *, long *, double *, long *,
  253.     KERNEL_CACHE *, long *, long *);
  254. void   select_top_n(double *, long, long *, long);
  255. void   init_shrink_state(SHRINK_STATE *, long, long);
  256. void   shrink_state_cleanup(SHRINK_STATE *);
  257. long shrink_problem(
  258. /* shrink some variables away */
  259. /* do the shrinking only if at least minshrink variables can be removed */
  260. LEARN_PARM *learn_parm,
  261. SHRINK_STATE *shrink_state,
  262. long *active2dnum,long iteration,long* last_suboptimal_at,
  263. long totdoc,long minshrink,
  264. double *a,
  265. long *inconsistent);
  266. void   reactivate_inactive_examples(long *, long *, double *, SHRINK_STATE *,
  267.     double *, long, long, long, LEARN_PARM *, 
  268.     long *, DOC *, KERNEL_PARM *,
  269.     KERNEL_CACHE *, MODEL *, CFLOAT *, 
  270.     double *, double *);
  271. /* cache kernel evalutations to improve speed */
  272. void   get_kernel_row(KERNEL_CACHE *,DOC *, long, long, long *, CFLOAT *, 
  273.       KERNEL_PARM *);
  274. void   cache_kernel_row(KERNEL_CACHE *,DOC *, long, KERNEL_PARM *);
  275. void   cache_multiple_kernel_rows(KERNEL_CACHE *,DOC *, long *, long, 
  276.   KERNEL_PARM *);
  277. void   kernel_cache_shrink(KERNEL_CACHE *,long, long, long *);
  278. void   kernel_cache_init(KERNEL_CACHE *,long, long);
  279. void   kernel_cache_reset_lru(KERNEL_CACHE *);
  280. void   kernel_cache_cleanup(KERNEL_CACHE *);
  281. long   kernel_cache_malloc(KERNEL_CACHE *);
  282. void   kernel_cache_free(KERNEL_CACHE *,long);
  283. long   kernel_cache_free_lru(KERNEL_CACHE *);
  284. CFLOAT *kernel_cache_clean_and_malloc(KERNEL_CACHE *,long);
  285. long   kernel_cache_touch(KERNEL_CACHE *,long);
  286. long   kernel_cache_check(KERNEL_CACHE *,long);
  287. void compute_xa_estimates(
  288. MODEL *model,                           /* xa-estimate of error rate, */
  289. long *label,long *unlabeled,long totdoc,          /* recall, and precision      */
  290. DOC *docs,       
  291. double *lin,double *a,                      
  292. KERNEL_PARM *kernel_parm,
  293. LEARN_PARM *learn_parm,
  294. double *error,double *recall,double *precision);
  295. double xa_estimate_error(MODEL *, long *, long *, long, DOC *, 
  296.  double *, double *, KERNEL_PARM *, 
  297.  LEARN_PARM *);
  298. double xa_estimate_recall(MODEL *, long *, long *, long, DOC *, 
  299.   double *, double *, KERNEL_PARM *, 
  300.   LEARN_PARM *);
  301. double xa_estimate_precision(MODEL *, long *, long *, long, DOC *, 
  302.      double *, double *, KERNEL_PARM *, 
  303.      LEARN_PARM *);
  304. void avg_similarity_of_sv_of_one_class(MODEL *, DOC *, double *, long *, KERNEL_PARM *, double *, double *);
  305. double most_similar_sv_of_same_class(MODEL *, DOC *, double *, long, long *, KERNEL_PARM *, LEARN_PARM *);
  306. double distribute_alpha_t_greedily(long *, long, DOC *, double *, long, long *, KERNEL_PARM *, LEARN_PARM *, double);
  307. double distribute_alpha_t_greedily_noindex(MODEL *, DOC *, double *, long, long *, KERNEL_PARM *, LEARN_PARM *, double); 
  308. void estimate_transduction_quality(MODEL *, long *, long *, long, DOC *, double *);
  309. double estimate_margin_vcdim(MODEL *, double, double, KERNEL_PARM *);
  310. double estimate_sphere(MODEL *, KERNEL_PARM *);
  311. double estimate_r_delta_average(DOC *, long, KERNEL_PARM *); 
  312. double estimate_r_delta(DOC *, long, KERNEL_PARM *); 
  313. double length_of_longest_document_vector(DOC *, long, KERNEL_PARM *); 
  314. void   write_model(char *, MODEL *);
  315. void   write_prediction(char *, MODEL *, double *, double *, long *, long *,
  316. long, LEARN_PARM *);
  317. void   write_alphas(char *, double *, long *, long);
  318. private:    //svm_hideo.h
  319. double *optimize_qp(QP *, double *, long, double *, LEARN_PARM *);
  320. int optimize_hildreth_despo(long,long,double,double,double,long,long,long,double,double *,
  321.     double *,double *,double *,double *,double *,
  322.     double *,double *,double *,long *,double *);
  323. int solve_dual(long,long,double,double,long,double *,double *,double *,
  324.        double *,double *,double *,double *,double *,double *,
  325.        double *,double *,double *,double *,long);
  326. void linvert_matrix(double *, long, double *, double, long *);
  327. void lprint_matrix(double *, long);
  328. void ladd_matrix(double *, long, double);
  329. void lcopy_matrix(double *, long, double *);
  330. void lswitch_rows_matrix(double *, long, long, long);
  331. void lswitchrk_matrix(double *, long, long, long);
  332. double calculate_qp_objective(long, double *, double *, double *);
  333. public:
  334. CCompute_Prompt com_pro;
  335. CCompute_Param com_param;
  336. CCompute_Result com_result;
  337. private:    //svm_hideo.h
  338. double *primal,*dual;
  339. long   precision_violations;
  340. double opt_precision;
  341. long   maxiter;
  342. double lindep_sensitivity;
  343. double *buffer;
  344. long   *nonoptimal;
  345. long  smallroundcount;
  346. private:
  347. char temstr[MAX_PATH*10];
  348. };
  350. #endif // !defined(AFX_SVM_H__169833C2_5291_4CDB_BE81_22DBD80908F0__INCLUDED_)