Ignore:
Timestamp:
08/22/13 20:23:29 (8 months ago)
Author:
Björn Esser <bjoern.esser@…>
Branch:
default
committer:
426ac3b6726e204573736572203c626a6f65726e2e657373657240676d61696c2e636f6d3e2031333737323834343333202d37323030
Message:

Updated the included LIBLINEAR to version 1.93.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • source/orange/liblinear/linear.cpp

    r8978 r11670  
    44#include <string.h> 
    55#include <stdarg.h> 
     6#include <locale.h> 
    67#include "linear.h" 
    78#include "tron.h" 
     
    1516#endif 
    1617template <class S, class T> static inline void clone(T*& dst, S* src, int n) 
    17 {    
     18{ 
    1819    dst = new T[n]; 
    1920    memcpy((void *)dst,(void *)src,sizeof(T)*n); 
     
    4445#endif 
    4546 
    46 class l2r_lr_fun : public function 
     47class l2r_lr_fun: public function 
    4748{ 
    4849public: 
    49     l2r_lr_fun(const problem *prob, double Cp, double Cn); 
     50    l2r_lr_fun(const problem *prob, double *C); 
    5051    ~l2r_lr_fun(); 
    5152 
     
    6667}; 
    6768 
    68 l2r_lr_fun::l2r_lr_fun(const problem *prob, double Cp, double Cn) 
    69 { 
    70     int i; 
     69l2r_lr_fun::l2r_lr_fun(const problem *prob, double *C) 
     70{ 
    7171    int l=prob->l; 
    72     int *y=prob->y; 
    7372 
    7473    this->prob = prob; 
     
    7675    z = new double[l]; 
    7776    D = new double[l]; 
    78     C = new double[l]; 
    79  
    80     for (i=0; i<l; i++) 
    81     { 
    82         if (y[i] == 1) 
    83             C[i] = Cp; 
    84         else 
    85             C[i] = Cn; 
    86     } 
     77    this->C = C; 
    8778} 
    8879 
     
    9182    delete[] z; 
    9283    delete[] D; 
    93     delete[] C; 
    9484} 
    9585 
     
    9989    int i; 
    10090    double f=0; 
    101     int *y=prob->y; 
     91    double *y=prob->y; 
    10292    int l=prob->l; 
    10393    int w_size=get_nr_variable(); 
    10494 
    10595    Xv(w, z); 
     96 
     97    for(i=0;i<w_size;i++) 
     98        f += w[i]*w[i]; 
     99    f /= 2.0; 
    106100    for(i=0;i<l;i++) 
    107101    { 
     
    112106            f += C[i]*(-yz+log(1 + exp(yz))); 
    113107    } 
    114     f = 2*f; 
    115     for(i=0;i<w_size;i++) 
    116         f += w[i]*w[i]; 
    117     f /= 2.0; 
    118108 
    119109    return(f); 
     
    123113{ 
    124114    int i; 
    125     int *y=prob->y; 
     115    double *y=prob->y; 
    126116    int l=prob->l; 
    127117    int w_size=get_nr_variable(); 
     
    199189} 
    200190 
    201 class l2r_l2_svc_fun : public function 
     191class l2r_l2_svc_fun: public function 
    202192{ 
    203193public: 
    204     l2r_l2_svc_fun(const problem *prob, double Cp, double Cn); 
     194    l2r_l2_svc_fun(const problem *prob, double *C); 
    205195    ~l2r_l2_svc_fun(); 
    206196 
     
    211201    int get_nr_variable(void); 
    212202 
    213 private: 
     203protected: 
    214204    void Xv(double *v, double *Xv); 
    215205    void subXv(double *v, double *Xv); 
     
    224214}; 
    225215 
    226 l2r_l2_svc_fun::l2r_l2_svc_fun(const problem *prob, double Cp, double Cn) 
    227 { 
    228     int i; 
     216l2r_l2_svc_fun::l2r_l2_svc_fun(const problem *prob, double *C) 
     217{ 
    229218    int l=prob->l; 
    230     int *y=prob->y; 
    231219 
    232220    this->prob = prob; 
     
    234222    z = new double[l]; 
    235223    D = new double[l]; 
    236     C = new double[l]; 
    237224    I = new int[l]; 
    238  
    239     for (i=0; i<l; i++) 
    240     { 
    241         if (y[i] == 1) 
    242             C[i] = Cp; 
    243         else 
    244             C[i] = Cn; 
    245     } 
     225    this->C = C; 
    246226} 
    247227 
     
    250230    delete[] z; 
    251231    delete[] D; 
    252     delete[] C; 
    253232    delete[] I; 
    254233} 
     
    258237    int i; 
    259238    double f=0; 
    260     int *y=prob->y; 
     239    double *y=prob->y; 
    261240    int l=prob->l; 
    262241    int w_size=get_nr_variable(); 
    263242 
    264243    Xv(w, z); 
     244 
     245    for(i=0;i<w_size;i++) 
     246        f += w[i]*w[i]; 
     247    f /= 2.0; 
    265248    for(i=0;i<l;i++) 
    266249    { 
     
    270253            f += C[i]*d*d; 
    271254    } 
    272     f = 2*f; 
    273     for(i=0;i<w_size;i++) 
    274         f += w[i]*w[i]; 
    275     f /= 2.0; 
    276255 
    277256    return(f); 
     
    281260{ 
    282261    int i; 
    283     int *y=prob->y; 
     262    double *y=prob->y; 
    284263    int l=prob->l; 
    285264    int w_size=get_nr_variable(); 
     
    307286{ 
    308287    int i; 
    309     int l=prob->l; 
    310288    int w_size=get_nr_variable(); 
    311     double *wa = new double[l]; 
     289    double *wa = new double[sizeI]; 
    312290 
    313291    subXv(s, wa); 
     
    373351        } 
    374352    } 
     353} 
     354 
     355class l2r_l2_svr_fun: public l2r_l2_svc_fun 
     356{ 
     357public: 
     358    l2r_l2_svr_fun(const problem *prob, double *C, double p); 
     359 
     360    double fun(double *w); 
     361    void grad(double *w, double *g); 
     362 
     363private: 
     364    double p; 
     365}; 
     366 
     367l2r_l2_svr_fun::l2r_l2_svr_fun(const problem *prob, double *C, double p): 
     368    l2r_l2_svc_fun(prob, C) 
     369{ 
     370    this->p = p; 
     371} 
     372 
     373double l2r_l2_svr_fun::fun(double *w) 
     374{ 
     375    int i; 
     376    double f=0; 
     377    double *y=prob->y; 
     378    int l=prob->l; 
     379    int w_size=get_nr_variable(); 
     380    double d; 
     381 
     382    Xv(w, z); 
     383 
     384    for(i=0;i<w_size;i++) 
     385        f += w[i]*w[i]; 
     386    f /= 2; 
     387    for(i=0;i<l;i++) 
     388    { 
     389        d = z[i] - y[i]; 
     390        if(d < -p) 
     391            f += C[i]*(d+p)*(d+p); 
     392        else if(d > p) 
     393            f += C[i]*(d-p)*(d-p); 
     394    } 
     395 
     396    return(f); 
     397} 
     398 
     399void l2r_l2_svr_fun::grad(double *w, double *g) 
     400{ 
     401    int i; 
     402    double *y=prob->y; 
     403    int l=prob->l; 
     404    int w_size=get_nr_variable(); 
     405    double d; 
     406 
     407    sizeI = 0; 
     408    for(i=0;i<l;i++) 
     409    { 
     410        d = z[i] - y[i]; 
     411 
     412        // generate index set I 
     413        if(d < -p) 
     414        { 
     415            z[sizeI] = C[i]*(d+p); 
     416            I[sizeI] = i; 
     417            sizeI++; 
     418        } 
     419        else if(d > p) 
     420        { 
     421            z[sizeI] = C[i]*(d-p); 
     422            I[sizeI] = i; 
     423            sizeI++; 
     424        } 
     425 
     426    } 
     427    subXTv(z, g); 
     428 
     429    for(i=0;i<w_size;i++) 
     430        g[i] = w[i] + 2*g[i]; 
    375431} 
    376432 
     
    395451// See Appendix of LIBLINEAR paper, Fan et al. (2008) 
    396452 
    397 #define GETI(i) (prob->y[i]) 
     453#define GETI(i) ((int) prob->y[i]) 
    398454// To support weights for instances, use GETI(i) (i) 
    399455 
     
    456512    for(r=1;r<active_i && beta<r*D[r];r++) 
    457513        beta += D[r]; 
    458  
    459514    beta /= r; 
     515 
    460516    for(r=0;r<active_i;r++) 
    461517    { 
     
    494550    double eps_shrink = max(10.0*eps, 1.0); // stopping tolerance for shrinking 
    495551    bool start_from_all = true; 
    496     // initial 
     552 
     553    // Initial alpha can be set here. Note that  
     554    // sum_m alpha[i*nr_class+m] = 0, for all i=1,...,l-1 
     555    // alpha[i*nr_class+m] <= C[GETI(i)] if prob->y[i] == m 
     556    // alpha[i*nr_class+m] <= 0 if prob->y[i] != m 
     557    // If initial alpha isn't zero, uncomment the for loop below to initialize w 
    497558    for(i=0;i<l*nr_class;i++) 
    498559        alpha[i] = 0; 
     560 
    499561    for(i=0;i<w_size*nr_class;i++) 
    500         w[i] = 0;  
     562        w[i] = 0; 
    501563    for(i=0;i<l;i++) 
    502564    { 
     
    507569        while(xi->index != -1) 
    508570        { 
    509             QD[i] += (xi->value)*(xi->value); 
     571            double val = xi->value; 
     572            QD[i] += val*val; 
     573 
     574            // Uncomment the for loop if initial alpha isn't zero 
     575            // for(m=0; m<nr_class; m++) 
     576            //  w[(xi->index-1)*nr_class+m] += alpha[i*nr_class+m]*val; 
    510577            xi++; 
    511578        } 
    512579        active_size_i[i] = nr_class; 
    513         y_index[i] = prob->y[i]; 
     580        y_index[i] = (int)prob->y[i]; 
    514581        index[i] = i; 
    515582    } 
    516583 
    517     while(iter < max_iter)  
     584    while(iter < max_iter) 
    518585    { 
    519586        double stopping = -INF; 
     
    556623                } 
    557624                if(y_index[i] < active_size_i[i]) 
    558                     if(alpha_i[prob->y[i]] < C[GETI(i)] && G[y_index[i]] < minG) 
     625                    if(alpha_i[(int) prob->y[i]] < C[GETI(i)] && G[y_index[i]] < minG) 
    559626                        minG = G[y_index[i]]; 
    560627 
     
    566633                        while(active_size_i[i]>m) 
    567634                        { 
    568                             if(!be_shrunk(i, active_size_i[i], y_index[i],  
     635                            if(!be_shrunk(i, active_size_i[i], y_index[i], 
    569636                                            alpha_i[alpha_index_i[active_size_i[i]]], minG)) 
    570637                            { 
     
    573640                                if(y_index[i] == active_size_i[i]) 
    574641                                    y_index[i] = m; 
    575                                 else if(y_index[i] == m)  
     642                                else if(y_index[i] == m) 
    576643                                    y_index[i] = active_size_i[i]; 
    577644                                break; 
     
    586653                    active_size--; 
    587654                    swap(index[s], index[active_size]); 
    588                     s--;     
     655                    s--; 
    589656                    continue; 
    590657                } 
     
    664731    } 
    665732    for(i=0;i<l;i++) 
    666         v -= alpha[i*nr_class+prob->y[i]]; 
     733        v -= alpha[i*nr_class+(int)prob->y[i]]; 
    667734    info("Objective value = %lf\n",v); 
    668735    info("nSV = %d\n",nSV); 
     
    683750// 
    684751//  min_\alpha  0.5(\alpha^T (Q + D)\alpha) - e^T \alpha, 
    685 //    s.t.      0 <= alpha_i <= upper_bound_i, 
     752//    s.t.      0 <= \alpha_i <= upper_bound_i, 
    686753//  
    687754//  where Qij = yi yj xi^T xj and 
     
    710777 
    711778static void solve_l2r_l1l2_svc( 
    712     const problem *prob, double *w, double eps,  
     779    const problem *prob, double *w, double eps, 
    713780    double Cp, double Cn, int solver_type) 
    714781{ 
     
    741808    } 
    742809 
     810    for(i=0; i<l; i++) 
     811    { 
     812        if(prob->y[i] > 0) 
     813        { 
     814            y[i] = +1; 
     815        } 
     816        else 
     817        { 
     818            y[i] = -1; 
     819        } 
     820    } 
     821 
     822    // Initial alpha can be set here. Note that 
     823    // 0 <= alpha[i] <= upper_bound[GETI(i)] 
     824    for(i=0; i<l; i++) 
     825        alpha[i] = 0; 
     826 
    743827    for(i=0; i<w_size; i++) 
    744828        w[i] = 0; 
    745829    for(i=0; i<l; i++) 
    746830    { 
    747         alpha[i] = 0; 
    748         if(prob->y[i] > 0) 
    749         { 
    750             y[i] = +1;  
    751         } 
    752         else 
    753         { 
    754             y[i] = -1; 
    755         } 
    756831        QD[i] = diag[GETI(i)]; 
    757832 
     
    759834        while (xi->index != -1) 
    760835        { 
    761             QD[i] += (xi->value)*(xi->value); 
     836            double val = xi->value; 
     837            QD[i] += val*val; 
     838            w[xi->index-1] += y[i]*alpha[i]*val; 
    762839            xi++; 
    763840        } 
     
    888965} 
    889966 
     967 
     968// A coordinate descent algorithm for  
     969// L1-loss and L2-loss epsilon-SVR dual problem 
     970// 
     971//  min_\beta  0.5\beta^T (Q + diag(lambda)) \beta - p \sum_{i=1}^l|\beta_i| + \sum_{i=1}^l yi\beta_i, 
     972//    s.t.      -upper_bound_i <= \beta_i <= upper_bound_i, 
     973//  
     974//  where Qij = xi^T xj and 
     975//  D is a diagonal matrix  
     976// 
     977// In L1-SVM case: 
     978//      upper_bound_i = C 
     979//      lambda_i = 0 
     980// In L2-SVM case: 
     981//      upper_bound_i = INF 
     982//      lambda_i = 1/(2*C) 
     983// 
     984// Given:  
     985// x, y, p, C 
     986// eps is the stopping tolerance 
     987// 
     988// solution will be put in w 
     989// 
     990// See Algorithm 4 of Ho and Lin, 2012    
     991 
     992#undef GETI 
     993#define GETI(i) (0) 
     994// To support weights for instances, use GETI(i) (i) 
     995 
     996static void solve_l2r_l1l2_svr( 
     997    const problem *prob, double *w, const parameter *param, 
     998    int solver_type) 
     999{ 
     1000    int l = prob->l; 
     1001    double C = param->C; 
     1002    double p = param->p; 
     1003    int w_size = prob->n; 
     1004    double eps = param->eps; 
     1005    int i, s, iter = 0; 
     1006    int max_iter = 1000; 
     1007    int active_size = l; 
     1008    int *index = new int[l]; 
     1009 
     1010    double d, G, H; 
     1011    double Gmax_old = INF; 
     1012    double Gmax_new, Gnorm1_new; 
     1013    double Gnorm1_init; 
     1014    double *beta = new double[l]; 
     1015    double *QD = new double[l]; 
     1016    double *y = prob->y; 
     1017 
     1018    // L2R_L2LOSS_SVR_DUAL 
     1019    double lambda[1], upper_bound[1]; 
     1020    lambda[0] = 0.5/C; 
     1021    upper_bound[0] = INF; 
     1022 
     1023    if(solver_type == L2R_L1LOSS_SVR_DUAL) 
     1024    { 
     1025        lambda[0] = 0; 
     1026        upper_bound[0] = C; 
     1027    } 
     1028 
     1029    // Initial beta can be set here. Note that 
     1030    // -upper_bound <= beta[i] <= upper_bound 
     1031    for(i=0; i<l; i++) 
     1032        beta[i] = 0; 
     1033 
     1034    for(i=0; i<w_size; i++) 
     1035        w[i] = 0; 
     1036    for(i=0; i<l; i++) 
     1037    { 
     1038        QD[i] = 0; 
     1039        feature_node *xi = prob->x[i]; 
     1040        while(xi->index != -1) 
     1041        { 
     1042            double val = xi->value; 
     1043            QD[i] += val*val; 
     1044            w[xi->index-1] += beta[i]*val; 
     1045            xi++; 
     1046        } 
     1047 
     1048        index[i] = i; 
     1049    } 
     1050 
     1051 
     1052    while(iter < max_iter) 
     1053    { 
     1054        Gmax_new = 0; 
     1055        Gnorm1_new = 0; 
     1056 
     1057        for(i=0; i<active_size; i++) 
     1058        { 
     1059            int j = i+rand()%(active_size-i); 
     1060            swap(index[i], index[j]); 
     1061        } 
     1062 
     1063        for(s=0; s<active_size; s++) 
     1064        { 
     1065            i = index[s]; 
     1066            G = -y[i] + lambda[GETI(i)]*beta[i]; 
     1067            H = QD[i] + lambda[GETI(i)]; 
     1068 
     1069            feature_node *xi = prob->x[i]; 
     1070            while(xi->index != -1) 
     1071            { 
     1072                int ind = xi->index-1; 
     1073                double val = xi->value; 
     1074                G += val*w[ind]; 
     1075                xi++; 
     1076            } 
     1077 
     1078            double Gp = G+p; 
     1079            double Gn = G-p; 
     1080            double violation = 0; 
     1081            if(beta[i] == 0) 
     1082            { 
     1083                if(Gp < 0) 
     1084                    violation = -Gp; 
     1085                else if(Gn > 0) 
     1086                    violation = Gn; 
     1087                else if(Gp>Gmax_old && Gn<-Gmax_old) 
     1088                { 
     1089                    active_size--; 
     1090                    swap(index[s], index[active_size]); 
     1091                    s--; 
     1092                    continue; 
     1093                } 
     1094            } 
     1095            else if(beta[i] >= upper_bound[GETI(i)]) 
     1096            { 
     1097                if(Gp > 0) 
     1098                    violation = Gp; 
     1099                else if(Gp < -Gmax_old) 
     1100                { 
     1101                    active_size--; 
     1102                    swap(index[s], index[active_size]); 
     1103                    s--; 
     1104                    continue; 
     1105                } 
     1106            } 
     1107            else if(beta[i] <= -upper_bound[GETI(i)]) 
     1108            { 
     1109                if(Gn < 0) 
     1110                    violation = -Gn; 
     1111                else if(Gn > Gmax_old) 
     1112                { 
     1113                    active_size--; 
     1114                    swap(index[s], index[active_size]); 
     1115                    s--; 
     1116                    continue; 
     1117                } 
     1118            } 
     1119            else if(beta[i] > 0) 
     1120                violation = fabs(Gp); 
     1121            else 
     1122                violation = fabs(Gn); 
     1123 
     1124            Gmax_new = max(Gmax_new, violation); 
     1125            Gnorm1_new += violation; 
     1126 
     1127            // obtain Newton direction d 
     1128            if(Gp < H*beta[i]) 
     1129                d = -Gp/H; 
     1130            else if(Gn > H*beta[i]) 
     1131                d = -Gn/H; 
     1132            else 
     1133                d = -beta[i]; 
     1134 
     1135            if(fabs(d) < 1.0e-12) 
     1136                continue; 
     1137 
     1138            double beta_old = beta[i]; 
     1139            beta[i] = min(max(beta[i]+d, -upper_bound[GETI(i)]), upper_bound[GETI(i)]); 
     1140            d = beta[i]-beta_old; 
     1141 
     1142            if(d != 0) 
     1143            { 
     1144                xi = prob->x[i]; 
     1145                while(xi->index != -1) 
     1146                { 
     1147                    w[xi->index-1] += d*xi->value; 
     1148                    xi++; 
     1149                } 
     1150            } 
     1151        } 
     1152 
     1153        if(iter == 0) 
     1154            Gnorm1_init = Gnorm1_new; 
     1155        iter++; 
     1156        if(iter % 10 == 0) 
     1157            info("."); 
     1158 
     1159        if(Gnorm1_new <= eps*Gnorm1_init) 
     1160        { 
     1161            if(active_size == l) 
     1162                break; 
     1163            else 
     1164            { 
     1165                active_size = l; 
     1166                info("*"); 
     1167                Gmax_old = INF; 
     1168                continue; 
     1169            } 
     1170        } 
     1171 
     1172        Gmax_old = Gmax_new; 
     1173    } 
     1174 
     1175    info("\noptimization finished, #iter = %d\n", iter); 
     1176    if(iter >= max_iter) 
     1177        info("\nWARNING: reaching max number of iterations\nUsing -s 11 may be faster\n\n"); 
     1178 
     1179    // calculate objective value 
     1180    double v = 0; 
     1181    int nSV = 0; 
     1182    for(i=0; i<w_size; i++) 
     1183        v += w[i]*w[i]; 
     1184    v = 0.5*v; 
     1185    for(i=0; i<l; i++) 
     1186    { 
     1187        v += p*fabs(beta[i]) - y[i]*beta[i] + 0.5*lambda[GETI(i)]*beta[i]*beta[i]; 
     1188        if(beta[i] != 0) 
     1189            nSV++; 
     1190    } 
     1191 
     1192    info("Objective value = %lf\n", v); 
     1193    info("nSV = %d\n",nSV); 
     1194 
     1195    delete [] beta; 
     1196    delete [] QD; 
     1197    delete [] index; 
     1198} 
     1199 
     1200 
    8901201// A coordinate descent algorithm for  
    8911202// the dual of L2-regularized logistic regression problems 
    8921203// 
    893 //  min_\alpha  0.5(\alpha^T Q \alpha) + \sum \alpha_i log (\alpha_i) + (upper_bound_i - alpha_i) log (upper_bound_i - alpha_i) , 
    894 //    s.t.      0 <= alpha_i <= upper_bound_i, 
     1204//  min_\alpha  0.5(\alpha^T Q \alpha) + \sum \alpha_i log (\alpha_i) + (upper_bound_i - \alpha_i) log (upper_bound_i - \alpha_i), 
     1205//    s.t.      0 <= \alpha_i <= upper_bound_i, 
    8951206//  
    8961207//  where Qij = yi yj xi^T xj and  
     
    9171228    double *xTx = new double[l]; 
    9181229    int max_iter = 1000; 
    919     int *index = new int[l];         
     1230    int *index = new int[l];     
    9201231    double *alpha = new double[2*l]; // store alpha and C - alpha 
    921     schar *y = new schar[l];     
     1232    schar *y = new schar[l]; 
    9221233    int max_inner_iter = 100; // for inner Newton 
    923     double innereps = 1e-2;  
     1234    double innereps = 1e-2; 
    9241235    double innereps_min = min(1e-8, eps); 
    9251236    double upper_bound[3] = {Cn, 0, Cp}; 
     1237 
     1238    for(i=0; i<l; i++) 
     1239    { 
     1240        if(prob->y[i] > 0) 
     1241        { 
     1242            y[i] = +1; 
     1243        } 
     1244        else 
     1245        { 
     1246            y[i] = -1; 
     1247        } 
     1248    } 
     1249     
     1250    // Initial alpha can be set here. Note that 
     1251    // 0 < alpha[i] < upper_bound[GETI(i)] 
     1252    // alpha[2*i] + alpha[2*i+1] = upper_bound[GETI(i)] 
     1253    for(i=0; i<l; i++) 
     1254    { 
     1255        alpha[2*i] = min(0.001*upper_bound[GETI(i)], 1e-8); 
     1256        alpha[2*i+1] = upper_bound[GETI(i)] - alpha[2*i]; 
     1257    } 
    9261258 
    9271259    for(i=0; i<w_size; i++) 
     
    9291261    for(i=0; i<l; i++) 
    9301262    { 
    931         if(prob->y[i] > 0) 
    932         { 
    933             y[i] = +1;  
    934         } 
    935         else 
    936         { 
    937             y[i] = -1; 
    938         } 
    939         alpha[2*i] = min(0.001*upper_bound[GETI(i)], 1e-8); 
    940         alpha[2*i+1] = upper_bound[GETI(i)] - alpha[2*i]; 
    941  
    9421263        xTx[i] = 0; 
    9431264        feature_node *xi = prob->x[i]; 
    9441265        while (xi->index != -1) 
    9451266        { 
    946             xTx[i] += (xi->value)*(xi->value); 
    947             w[xi->index-1] += y[i]*alpha[2*i]*xi->value; 
     1267            double val = xi->value; 
     1268            xTx[i] += val*val; 
     1269            w[xi->index-1] += y[i]*alpha[2*i]*val; 
    9481270            xi++; 
    9491271        } 
     
    9771299            // Decide to minimize g_1(z) or g_2(z) 
    9781300            int ind1 = 2*i, ind2 = 2*i+1, sign = 1; 
    979             if(0.5*a*(alpha[ind2]-alpha[ind1])+b < 0)  
     1301            if(0.5*a*(alpha[ind2]-alpha[ind1])+b < 0) 
    9801302            { 
    9811303                ind1 = 2*i+1; 
     
    9871309            double alpha_old = alpha[ind1]; 
    9881310            double z = alpha_old; 
    989             if(C - z < 0.5 * C)  
     1311            if(C - z < 0.5 * C) 
    9901312                z = 0.1*z; 
    9911313            double gp = a*(z-alpha_old)+sign*b+log(z/(C-z)); 
     
    9951317            const double eta = 0.1; // xi in the paper 
    9961318            int inner_iter = 0; 
    997             while (inner_iter <= max_inner_iter)  
     1319            while (inner_iter <= max_inner_iter) 
    9981320            { 
    9991321                if(fabs(gp) < innereps) 
     
    10011323                double gpp = a + C/(C-z)/z; 
    10021324                double tmpz = z - gp/gpp; 
    1003                 if(tmpz <= 0)  
     1325                if(tmpz <= 0) 
    10041326                    z *= eta; 
    10051327                else // tmpz in (0, C) 
     
    10191341                    w[xi->index-1] += sign*(z-alpha_old)*yi*xi->value; 
    10201342                    xi++; 
    1021                 }   
     1343                } 
    10221344            } 
    10231345        } 
     
    10271349            info("."); 
    10281350 
    1029         if(Gmax < eps)  
     1351        if(Gmax < eps) 
    10301352            break; 
    10311353 
    1032         if(newton_iter <= l/10)  
     1354        if(newton_iter <= l/10) 
    10331355            innereps = max(innereps_min, 0.1*innereps); 
    10341356 
     
    10401362 
    10411363    // calculate objective value 
    1042      
     1364 
    10431365    double v = 0; 
    10441366    for(i=0; i<w_size; i++) 
     
    10461368    v *= 0.5; 
    10471369    for(i=0; i<l; i++) 
    1048         v += alpha[2*i] * log(alpha[2*i]) + alpha[2*i+1] * log(alpha[2*i+1])  
     1370        v += alpha[2*i] * log(alpha[2*i]) + alpha[2*i+1] * log(alpha[2*i+1]) 
    10491371            - upper_bound[GETI(i)] * log(upper_bound[GETI(i)]); 
    10501372    info("Objective value = %lf\n", v); 
     
    10741396 
    10751397static void solve_l1r_l2_svc( 
    1076     problem *prob_col, double *w, double eps,  
     1398    problem *prob_col, double *w, double eps, 
    10771399    double Cp, double Cn) 
    10781400{ 
     
    11011423    double C[3] = {Cn,0,Cp}; 
    11021424 
     1425    // Initial w can be set here. 
     1426    for(j=0; j<w_size; j++) 
     1427        w[j] = 0; 
     1428 
    11031429    for(j=0; j<l; j++) 
    11041430    { 
     
    11111437    for(j=0; j<w_size; j++) 
    11121438    { 
    1113         w[j] = 0; 
    11141439        index[j] = j; 
    11151440        xj_sq[j] = 0; 
     
    11181443        { 
    11191444            int ind = x->index-1; 
     1445            x->value *= y[ind]; // x->value stores yi*xij 
    11201446            double val = x->value; 
    1121             x->value *= y[ind]; // x->value stores yi*xij 
     1447            b[ind] -= w[j]*val; 
    11221448            xj_sq[j] += C[GETI(ind)]*val*val; 
    11231449            x++; 
     
    11871513 
    11881514            // obtain Newton direction d 
    1189             if(Gp <= H*w[j]) 
     1515            if(Gp < H*w[j]) 
    11901516                d = -Gp/H; 
    1191             else if(Gn >= H*w[j]) 
     1517            else if(Gn > H*w[j]) 
    11921518                d = -Gn/H; 
    11931519            else 
     
    13571683 
    13581684static void solve_l1r_lr( 
    1359     const problem *prob_col, double *w, double eps,  
     1685    const problem *prob_col, double *w, double eps, 
    13601686    double Cp, double Cn) 
    13611687{ 
     
    13721698    double inner_eps = 1; 
    13731699    double sigma = 0.01; 
    1374     double w_norm=0, w_norm_new; 
     1700    double w_norm, w_norm_new; 
    13751701    double z, G, H; 
    13761702    double Gnorm1_init; 
     
    13961722    double C[3] = {Cn,0,Cp}; 
    13971723 
     1724    // Initial w can be set here. 
     1725    for(j=0; j<w_size; j++) 
     1726        w[j] = 0; 
     1727 
    13981728    for(j=0; j<l; j++) 
    13991729    { 
     
    14031733            y[j] = -1; 
    14041734 
    1405         // assume initial w is 0 
    1406         exp_wTx[j] = 1; 
    1407         tau[j] = C[GETI(j)]*0.5; 
    1408         D[j] = C[GETI(j)]*0.25; 
    1409     } 
     1735        exp_wTx[j] = 0; 
     1736    } 
     1737 
     1738    w_norm = 0; 
    14101739    for(j=0; j<w_size; j++) 
    14111740    { 
    1412         w[j] = 0; 
     1741        w_norm += fabs(w[j]); 
    14131742        wpd[j] = w[j]; 
    14141743        index[j] = j; 
     
    14181747        { 
    14191748            int ind = x->index-1; 
     1749            double val = x->value; 
     1750            exp_wTx[ind] += w[j]*val; 
    14201751            if(y[ind] == -1) 
    1421                 xjneg_sum[j] += C[GETI(ind)]*x->value; 
     1752                xjneg_sum[j] += C[GETI(ind)]*val; 
    14221753            x++; 
    14231754        } 
     1755    } 
     1756    for(j=0; j<l; j++) 
     1757    { 
     1758        exp_wTx[j] = exp(exp_wTx[j]); 
     1759        double tau_tmp = 1/(1+exp_wTx[j]); 
     1760        tau[j] = C[GETI(j)]*tau_tmp; 
     1761        D[j] = C[GETI(j)]*exp_wTx[j]*tau_tmp*tau_tmp; 
    14241762    } 
    14251763 
     
    15401878 
    15411879                // obtain solution of one-variable problem 
    1542                 if(Gp <= H*wpd[j]) 
     1880                if(Gp < H*wpd[j]) 
    15431881                    z = -Gp/H; 
    1544                 else if(Gn >= H*wpd[j]) 
     1882                else if(Gn > H*wpd[j]) 
    15451883                    z = -Gn/H; 
    15461884                else 
     
    16772015 
    16782016    // calculate objective value 
    1679      
     2017 
    16802018    double v = 0; 
    16812019    int nnz = 0; 
     
    17192057    prob_col->l = l; 
    17202058    prob_col->n = n; 
    1721     prob_col->y = new int[l]; 
     2059    prob_col->y = new double[l]; 
    17222060    prob_col->x = new feature_node*[n]; 
    17232061 
     
    17782116    for(i=0;i<l;i++) 
    17792117    { 
    1780         int this_label = prob->y[i]; 
     2118        int this_label = (int)prob->y[i]; 
    17812119        int j; 
    17822120        for(j=0;j<nr_class;j++) 
     
    18292167    int neg = 0; 
    18302168    for(int i=0;i<prob->l;i++) 
    1831         if(prob->y[i]==+1) 
     2169        if(prob->y[i] > 0) 
    18322170            pos++; 
    18332171    neg = prob->l - pos; 
    18342172 
     2173    double primal_solver_tol = eps*max(min(pos,neg), 1)/prob->l; 
     2174 
    18352175    function *fun_obj=NULL; 
    18362176    switch(param->solver_type) 
     
    18382178        case L2R_LR: 
    18392179        { 
    1840             fun_obj=new l2r_lr_fun(prob, Cp, Cn); 
    1841             TRON tron_obj(fun_obj, eps*min(pos,neg)/prob->l); 
     2180            double *C = new double[prob->l]; 
     2181            for(int i = 0; i < prob->l; i++) 
     2182            { 
     2183                if(prob->y[i] > 0) 
     2184                    C[i] = Cp; 
     2185                else 
     2186                    C[i] = Cn; 
     2187            } 
     2188            fun_obj=new l2r_lr_fun(prob, C); 
     2189            TRON tron_obj(fun_obj, primal_solver_tol); 
    18422190            tron_obj.set_print_string(liblinear_print_string); 
    18432191            tron_obj.tron(w); 
    18442192            delete fun_obj; 
     2193            delete C; 
    18452194            break; 
    18462195        } 
    18472196        case L2R_L2LOSS_SVC: 
    18482197        { 
    1849             fun_obj=new l2r_l2_svc_fun(prob, Cp, Cn); 
    1850             TRON tron_obj(fun_obj, eps*min(pos,neg)/prob->l); 
     2198            double *C = new double[prob->l]; 
     2199            for(int i = 0; i < prob->l; i++) 
     2200            { 
     2201                if(prob->y[i] > 0) 
     2202                    C[i] = Cp; 
     2203                else 
     2204                    C[i] = Cn; 
     2205            } 
     2206            fun_obj=new l2r_l2_svc_fun(prob, C); 
     2207            TRON tron_obj(fun_obj, primal_solver_tol); 
    18512208            tron_obj.set_print_string(liblinear_print_string); 
    18522209            tron_obj.tron(w); 
    18532210            delete fun_obj; 
     2211            delete C; 
    18542212            break; 
    18552213        } 
     
    18652223            feature_node *x_space = NULL; 
    18662224            transpose(prob, &x_space ,&prob_col); 
    1867             solve_l1r_l2_svc(&prob_col, w, eps*min(pos,neg)/prob->l, Cp, Cn); 
     2225            solve_l1r_l2_svc(&prob_col, w, primal_solver_tol, Cp, Cn); 
    18682226            delete [] prob_col.y; 
    18692227            delete [] prob_col.x; 
     
    18762234            feature_node *x_space = NULL; 
    18772235            transpose(prob, &x_space ,&prob_col); 
    1878             solve_l1r_lr(&prob_col, w, eps*min(pos,neg)/prob->l, Cp, Cn); 
     2236            solve_l1r_lr(&prob_col, w, primal_solver_tol, Cp, Cn); 
    18792237            delete [] prob_col.y; 
    18802238            delete [] prob_col.x; 
     
    18852243            solve_l2r_lr_dual(prob, w, eps, Cp, Cn); 
    18862244            break; 
     2245        case L2R_L2LOSS_SVR: 
     2246        { 
     2247            double *C = new double[prob->l]; 
     2248            for(int i = 0; i < prob->l; i++) 
     2249                C[i] = param->C; 
     2250 
     2251            fun_obj=new l2r_l2_svr_fun(prob, C, param->p); 
     2252            TRON tron_obj(fun_obj, param->eps); 
     2253            tron_obj.set_print_string(liblinear_print_string); 
     2254            tron_obj.tron(w); 
     2255            delete fun_obj; 
     2256            delete C; 
     2257            break; 
     2258 
     2259        } 
     2260        case L2R_L1LOSS_SVR_DUAL: 
     2261            solve_l2r_l1l2_svr(prob, w, param, L2R_L1LOSS_SVR_DUAL); 
     2262            break; 
     2263        case L2R_L2LOSS_SVR_DUAL: 
     2264            solve_l2r_l1l2_svr(prob, w, param, L2R_L2LOSS_SVR_DUAL); 
     2265            break; 
    18872266        default: 
    1888             fprintf(stderr, "Error: unknown solver_type\n"); 
     2267            fprintf(stderr, "ERROR: unknown solver_type\n"); 
    18892268            break; 
    18902269    } 
     
    19092288    model_->bias = prob->bias; 
    19102289 
    1911     int nr_class; 
    1912     int *label = NULL; 
    1913     int *start = NULL; 
    1914     int *count = NULL; 
    1915     int *perm = Malloc(int,l); 
    1916  
    1917     // group training data of the same class 
    1918     group_classes(prob,&nr_class,&label,&start,&count,perm); 
    1919  
    1920     model_->nr_class=nr_class; 
    1921     model_->label = Malloc(int,nr_class); 
    1922     for(i=0;i<nr_class;i++) 
    1923         model_->label[i] = label[i]; 
    1924  
    1925     // calculate weighted C 
    1926     double *weighted_C = Malloc(double, nr_class); 
    1927     for(i=0;i<nr_class;i++) 
    1928         weighted_C[i] = param->C; 
    1929     for(i=0;i<param->nr_weight;i++) 
    1930     { 
    1931         for(j=0;j<nr_class;j++) 
    1932             if(param->weight_label[i] == label[j]) 
    1933                 break; 
    1934         if(j == nr_class) 
    1935             fprintf(stderr,"WARNING: class label %d specified in weight is not found\n", param->weight_label[i]); 
     2290    if(param->solver_type == L2R_L2LOSS_SVR || 
     2291       param->solver_type == L2R_L1LOSS_SVR_DUAL || 
     2292       param->solver_type == L2R_L2LOSS_SVR_DUAL) 
     2293    { 
     2294        model_->w = Malloc(double, w_size); 
     2295        model_->nr_class = 2; 
     2296        model_->label = NULL; 
     2297        train_one(prob, param, &model_->w[0], 0, 0); 
     2298    } 
     2299    else 
     2300    { 
     2301        int nr_class; 
     2302        int *label = NULL; 
     2303        int *start = NULL; 
     2304        int *count = NULL; 
     2305        int *perm = Malloc(int,l); 
     2306 
     2307        // group training data of the same class 
     2308        group_classes(prob,&nr_class,&label,&start,&count,perm); 
     2309 
     2310        model_->nr_class=nr_class; 
     2311        model_->label = Malloc(int,nr_class); 
     2312        for(i=0;i<nr_class;i++) 
     2313            model_->label[i] = label[i]; 
     2314 
     2315        // calculate weighted C 
     2316        double *weighted_C = Malloc(double, nr_class); 
     2317        for(i=0;i<nr_class;i++) 
     2318            weighted_C[i] = param->C; 
     2319        for(i=0;i<param->nr_weight;i++) 
     2320        { 
     2321            for(j=0;j<nr_class;j++) 
     2322                if(param->weight_label[i] == label[j]) 
     2323                    break; 
     2324            if(j == nr_class) 
     2325                fprintf(stderr,"WARNING: class label %d specified in weight is not found\n", param->weight_label[i]); 
     2326            else 
     2327                weighted_C[j] *= param->weight[i]; 
     2328        } 
     2329 
     2330        // constructing the subproblem 
     2331        feature_node **x = Malloc(feature_node *,l); 
     2332        for(i=0;i<l;i++) 
     2333            x[i] = prob->x[perm[i]]; 
     2334 
     2335        int k; 
     2336        problem sub_prob; 
     2337        sub_prob.l = l; 
     2338        sub_prob.n = n; 
     2339        sub_prob.x = Malloc(feature_node *,sub_prob.l); 
     2340        sub_prob.y = Malloc(double,sub_prob.l); 
     2341 
     2342        for(k=0; k<sub_prob.l; k++) 
     2343            sub_prob.x[k] = x[k]; 
     2344 
     2345        // multi-class svm by Crammer and Singer 
     2346        if(param->solver_type == MCSVM_CS) 
     2347        { 
     2348            model_->w=Malloc(double, n*nr_class); 
     2349            for(i=0;i<nr_class;i++) 
     2350                for(j=start[i];j<start[i]+count[i];j++) 
     2351                    sub_prob.y[j] = i; 
     2352            Solver_MCSVM_CS Solver(&sub_prob, nr_class, weighted_C, param->eps); 
     2353            Solver.Solve(model_->w); 
     2354        } 
    19362355        else 
    1937             weighted_C[j] *= param->weight[i]; 
    1938     } 
    1939  
    1940     // constructing the subproblem 
    1941     feature_node **x = Malloc(feature_node *,l); 
    1942     for(i=0;i<l;i++) 
    1943         x[i] = prob->x[perm[i]]; 
    1944  
    1945     int k; 
    1946     problem sub_prob; 
    1947     sub_prob.l = l; 
    1948     sub_prob.n = n; 
    1949     sub_prob.x = Malloc(feature_node *,sub_prob.l); 
    1950     sub_prob.y = Malloc(int,sub_prob.l); 
    1951  
    1952     for(k=0; k<sub_prob.l; k++) 
    1953         sub_prob.x[k] = x[k]; 
    1954  
    1955     // multi-class svm by Crammer and Singer 
    1956     if(param->solver_type == MCSVM_CS) 
    1957     { 
    1958         model_->w=Malloc(double, n*nr_class); 
    1959         for(i=0;i<nr_class;i++) 
    1960             for(j=start[i];j<start[i]+count[i];j++) 
    1961                 sub_prob.y[j] = i; 
    1962         Solver_MCSVM_CS Solver(&sub_prob, nr_class, weighted_C, param->eps); 
    1963         Solver.Solve(model_->w); 
    1964     } 
    1965     else 
    1966     { 
    1967         if(nr_class == 2) 
    1968         { 
    1969             model_->w=Malloc(double, w_size); 
    1970  
    1971             int e0 = start[0]+count[0]; 
    1972             k=0; 
    1973             for(; k<e0; k++) 
    1974                 sub_prob.y[k] = +1; 
    1975             for(; k<sub_prob.l; k++) 
    1976                 sub_prob.y[k] = -1; 
    1977  
    1978             train_one(&sub_prob, param, &model_->w[0], weighted_C[0], weighted_C[1]); 
    1979         } 
    1980         else 
    1981         { 
    1982             model_->w=Malloc(double, w_size*nr_class); 
    1983             double *w=Malloc(double, w_size); 
    1984             for(i=0;i<nr_class;i++) 
    1985             { 
    1986                 int si = start[i]; 
    1987                 int ei = si+count[i]; 
    1988  
     2356        { 
     2357            if(nr_class == 2) 
     2358            { 
     2359                model_->w=Malloc(double, w_size); 
     2360 
     2361                int e0 = start[0]+count[0]; 
    19892362                k=0; 
    1990                 for(; k<si; k++) 
    1991                     sub_prob.y[k] = -1; 
    1992                 for(; k<ei; k++) 
     2363                for(; k<e0; k++) 
    19932364                    sub_prob.y[k] = +1; 
    19942365                for(; k<sub_prob.l; k++) 
    19952366                    sub_prob.y[k] = -1; 
    19962367 
    1997                 train_one(&sub_prob, param, w, weighted_C[i], param->C); 
    1998  
    1999                 for(int j=0;j<w_size;j++) 
    2000                     model_->w[j*nr_class+i] = w[j]; 
    2001             } 
    2002             free(w); 
    2003         } 
    2004  
    2005     } 
    2006  
    2007     free(x); 
    2008     free(label); 
    2009     free(start); 
    2010     free(count); 
    2011     free(perm); 
    2012     free(sub_prob.x); 
    2013     free(sub_prob.y); 
    2014     free(weighted_C); 
     2368                train_one(&sub_prob, param, &model_->w[0], weighted_C[0], weighted_C[1]); 
     2369            } 
     2370            else 
     2371            { 
     2372                model_->w=Malloc(double, w_size*nr_class); 
     2373                double *w=Malloc(double, w_size); 
     2374                for(i=0;i<nr_class;i++) 
     2375                { 
     2376                    int si = start[i]; 
     2377                    int ei = si+count[i]; 
     2378 
     2379                    k=0; 
     2380                    for(; k<si; k++) 
     2381                        sub_prob.y[k] = -1; 
     2382                    for(; k<ei; k++) 
     2383                        sub_prob.y[k] = +1; 
     2384                    for(; k<sub_prob.l; k++) 
     2385                        sub_prob.y[k] = -1; 
     2386 
     2387                    train_one(&sub_prob, param, w, weighted_C[i], param->C); 
     2388 
     2389                    for(int j=0;j<w_size;j++) 
     2390                        model_->w[j*nr_class+i] = w[j]; 
     2391                } 
     2392                free(w); 
     2393            } 
     2394 
     2395        } 
     2396 
     2397        free(x); 
     2398        free(label); 
     2399        free(start); 
     2400        free(count); 
     2401        free(perm); 
     2402        free(sub_prob.x); 
     2403        free(sub_prob.y); 
     2404        free(weighted_C); 
     2405    } 
    20152406    return model_; 
    20162407} 
    20172408 
    2018 void cross_validation(const problem *prob, const parameter *param, int nr_fold, int *target) 
     2409void cross_validation(const problem *prob, const parameter *param, int nr_fold, double *target) 
    20192410{ 
    20202411    int i; 
     
    20432434        subprob.l = l-(end-begin); 
    20442435        subprob.x = Malloc(struct feature_node*,subprob.l); 
    2045         subprob.y = Malloc(int,subprob.l); 
     2436        subprob.y = Malloc(double,subprob.l); 
    20462437 
    20472438        k=0; 
     
    20692460} 
    20702461 
    2071 int predict_values(const struct model *model_, const struct feature_node *x, double *dec_values) 
     2462double predict_values(const struct model *model_, const struct feature_node *x, double *dec_values) 
    20722463{ 
    20732464    int idx; 
     
    20982489 
    20992490    if(nr_class==2) 
    2100         return (dec_values[0]>0)?model_->label[0]:model_->label[1]; 
     2491    { 
     2492        if(model_->param.solver_type == L2R_L2LOSS_SVR || 
     2493           model_->param.solver_type == L2R_L1LOSS_SVR_DUAL || 
     2494           model_->param.solver_type == L2R_L2LOSS_SVR_DUAL) 
     2495            return dec_values[0]; 
     2496        else 
     2497            return (dec_values[0]>0)?model_->label[0]:model_->label[1]; 
     2498    } 
    21012499    else 
    21022500    { 
     
    21112509} 
    21122510 
    2113 int predict(const model *model_, const feature_node *x) 
     2511double predict(const model *model_, const feature_node *x) 
    21142512{ 
    21152513    double *dec_values = Malloc(double, model_->nr_class); 
    2116     int label=predict_values(model_, x, dec_values); 
     2514    double label=predict_values(model_, x, dec_values); 
    21172515    free(dec_values); 
    21182516    return label; 
    21192517} 
    21202518 
    2121 int predict_probability(const struct model *model_, const struct feature_node *x, double* prob_estimates) 
     2519double predict_probability(const struct model *model_, const struct feature_node *x, double* prob_estimates) 
    21222520{ 
    21232521    if(check_probability_model(model_)) 
     
    21312529            nr_w = nr_class; 
    21322530 
    2133         int label=predict_values(model_, x, prob_estimates); 
     2531        double label=predict_values(model_, x, prob_estimates); 
    21342532        for(i=0;i<nr_w;i++) 
    21352533            prob_estimates[i]=1/(1+exp(-prob_estimates[i])); 
     
    21472545        } 
    21482546 
    2149         return label;        
     2547        return label; 
    21502548    } 
    21512549    else 
     
    21562554{ 
    21572555    "L2R_LR", "L2R_L2LOSS_SVC_DUAL", "L2R_L2LOSS_SVC", "L2R_L1LOSS_SVC_DUAL", "MCSVM_CS", 
    2158     "L1R_L2LOSS_SVC", "L1R_LR", "L2R_LR_DUAL", NULL 
     2556    "L1R_L2LOSS_SVC", "L1R_LR", "L2R_LR_DUAL", 
     2557    "", "", "", 
     2558    "L2R_L2LOSS_SVR", "L2R_L2LOSS_SVR_DUAL", "L2R_L1LOSS_SVR_DUAL", NULL 
    21592559}; 
    21602560 
     
    21742574    if(fp==NULL) return -1; 
    21752575 
     2576    char *old_locale = strdup(setlocale(LC_ALL, NULL)); 
     2577    setlocale(LC_ALL, "C"); 
     2578 
    21762579    int nr_w; 
    21772580    if(model_->nr_class==2 && model_->param.solver_type != MCSVM_CS) 
     
    21822585    fprintf(fp, "solver_type %s\n", solver_type_table[param.solver_type]); 
    21832586    fprintf(fp, "nr_class %d\n", model_->nr_class); 
    2184     fprintf(fp, "label"); 
    2185     for(i=0; i<model_->nr_class; i++) 
    2186         fprintf(fp, " %d", model_->label[i]); 
    2187     fprintf(fp, "\n"); 
     2587 
     2588    if(model_->label) 
     2589    { 
     2590        fprintf(fp, "label"); 
     2591        for(i=0; i<model_->nr_class; i++) 
     2592            fprintf(fp, " %d", model_->label[i]); 
     2593        fprintf(fp, "\n"); 
     2594    } 
    21882595 
    21892596    fprintf(fp, "nr_feature %d\n", nr_feature); 
     
    21992606        fprintf(fp, "\n"); 
    22002607    } 
     2608 
     2609    setlocale(LC_ALL, old_locale); 
     2610    free(old_locale); 
    22012611 
    22022612    if (ferror(fp) != 0 || fclose(fp) != 0) return -1; 
     
    22192629    model_->label = NULL; 
    22202630 
     2631    char *old_locale = strdup(setlocale(LC_ALL, NULL)); 
     2632    setlocale(LC_ALL, "C"); 
     2633 
    22212634    char cmd[81]; 
    22222635    while(1) 
     
    22382651            { 
    22392652                fprintf(stderr,"unknown solver type.\n"); 
     2653 
     2654                setlocale(LC_ALL, old_locale); 
    22402655                free(model_->label); 
    22412656                free(model_); 
     2657                free(old_locale); 
    22422658                return NULL; 
    22432659            } 
     
    22722688        { 
    22732689            fprintf(stderr,"unknown text in model file: [%s]\n",cmd); 
     2690            setlocale(LC_ALL, old_locale); 
     2691            free(model_->label); 
    22742692            free(model_); 
     2693            free(old_locale); 
    22752694            return NULL; 
    22762695        } 
     
    22972716        fscanf(fp, "\n"); 
    22982717    } 
     2718 
     2719    setlocale(LC_ALL, old_locale); 
     2720    free(old_locale); 
     2721 
    22992722    if (ferror(fp) != 0 || fclose(fp) != 0) return NULL; 
    23002723 
     
    23522775    if(param->C <= 0) 
    23532776        return "C <= 0"; 
     2777 
     2778    if(param->p < 0) 
     2779        return "p < 0"; 
    23542780 
    23552781    if(param->solver_type != L2R_LR 
     
    23602786        && param->solver_type != L1R_L2LOSS_SVC 
    23612787        && param->solver_type != L1R_LR 
    2362         && param->solver_type != L2R_LR_DUAL) 
     2788        && param->solver_type != L2R_LR_DUAL 
     2789        && param->solver_type != L2R_L2LOSS_SVR 
     2790        && param->solver_type != L2R_L2LOSS_SVR_DUAL 
     2791        && param->solver_type != L2R_L1LOSS_SVR_DUAL) 
    23632792        return "unknown solver type"; 
    23642793 
     
    23752804void set_print_string_function(void (*print_func)(const char*)) 
    23762805{ 
    2377     if (print_func == NULL)  
     2806    if (print_func == NULL) 
    23782807        liblinear_print_string = &print_string_stdout; 
    23792808    else 
Note: See TracChangeset for help on using the changeset viewer.