view release on metacpan or  search on metacpan

lib/Algorithm/AdaGrad.xs  view on Meta::CPAN

    ofs.close();
}

static void _load(pTHX_ AdaGradPtr self, SV* sv) {
    if(SvTYPE(sv) != SVt_PV && SvTYPE(sv) != SVt_PVMG){
        croak("Invalid parameter: the parameter must be string.");
    }
    STRLEN len;
    const char* filename = SvPV(sv, len);
    
    std::ifstream ifs(filename);
    
    ifs.read(reinterpret_cast<char*>(&(self->eta)), sizeof(double));
    
    size_t featNum = 0;
    ifs.read(reinterpret_cast<char*>(&featNum), sizeof(size_t));
    
    std::unordered_map<std::string, AdaGrad*>& classifers = *(self->classifers);
    classifers.clear();
    
    for(size_t i = 0; i < featNum; ++i){
        size_t size = 0;
        ifs.read(reinterpret_cast<char*>(&size), sizeof(size_t));
        char* feature = new char[size];
        ifs.read(feature, sizeof(char) * size);
        std::string featStr(feature, size);
        delete[] feature;
        AdaGrad* newObj = new AdaGrad();
        newObj->load(ifs);
        classifers.insert(std::make_pair(featStr, newObj));
    }
    
    if(ifs.fail()) {
        croak("Failed to load file: %s", filename);
    }
    
    ifs.close();
}


MODULE = Algorithm::AdaGrad PACKAGE = Algorithm::AdaGrad

PROTOTYPES: DISABLE

AdaGradPtr
new(const char *klass, ...)
PREINIT:
    double eta = 0.0;
CODE:
{
    if(items > 1){
        SV* arg_sv = ST(1);
        eta = getDoubleValue(arg_sv, "Parameter must be a number.");
    }
    AdaGradPtr obj = NULL;
    New(__LINE__, obj, 1, struct AdaGradS);
    obj->classifers = new classifers_type();
    obj->eta = eta;
    RETVAL = obj;
}
OUTPUT:
    RETVAL

int
update(AdaGradPtr self, SV* sv)
CODE:
{   
    SvGETMAGIC (sv);
    if(!SvROK(sv) || SvTYPE(SvRV(sv)) !=  SVt_PVAV) {
        croak("Parameter must be ARRAY-reference");
    }

    AV* av = (AV*)SvRV(sv);
    size_t arraySize = av_len(av);
    for(size_t i = 0; i <= arraySize; ++i){
        SV** elm = av_fetch(av, i, 0);
        if(elm != NULL){
            handleUpdate(self, *elm);       
        }
    }
    RETVAL = 0;
}
OUTPUT:
    RETVAL

int
classify(AdaGradPtr self, SV* sv)
CODE:
{
    if(!SvROK(sv) || SvTYPE(SvRV(sv)) != SVt_PVHV) {
        croak("Invalid parameter: Parameter must be HASH-reference.");
    }
    
    HV* features = (HV*)SvRV(sv);

    hv_iterinit(features);
    HE* he = NULL;
    STRLEN len;
    std::unordered_map<std::string, AdaGrad*>& classifers = *(self->classifers);
    double margin = 0.0;
    while ((he = hv_iternext(features))){
        char* key = HePV(he, len);
        std::string featStr = std::string(key, len);
        classifers_type::const_iterator iter = classifers.find(featStr);
        if(iter == classifers.end()){
            continue;
        }
        AdaGrad* ag = iter->second;
        
        SV* val = HeVAL(he);
        double gradient = getDoubleValue(val, "Invalid parameter: type of parameter must be number.");
        margin += ag->classify(gradient);
    }

    RETVAL = margin >= 0 ? POSITIVE_LABEL : NEGATIVE_LABEL;
}
OUTPUT:
    RETVAL


void save(AdaGradPtr self, SV* sv)
CODE:
{
    _save(self, sv);
}

void
load(AdaGradPtr self, SV* sv)
CODE:
{
    _load(self, sv);
}
    
void
DESTROY(AdaGradPtr self)
CODE:
{
    std::unordered_map<std::string, AdaGrad*>& classifers = *(self->classifers);
    std::unordered_map<std::string, AdaGrad*>::iterator iter = classifers.begin();
    std::unordered_map<std::string, AdaGrad*>::iterator iter_end = classifers.end();   
    for(;iter != iter_end; ++iter){
        Safefree(iter->second);
    }
    Safefree (self->classifers);
    Safefree (self);
}