示例#1
2
void CRF::New(const FunctionCallbackInfo<Value>& args) {
    Isolate* isolate = args.GetIsolate();
    
    if (args.IsConstructCall()) {
        // Invoked as constructor: `new CRF(...)`
        
        CRF* obj = new CRF();
        
        CRFPP::Tagger* tag = CRFPP::createTagger(get(args[0]));
        if(!tag){
            
            isolate->ThrowException(Exception::TypeError(
                                                       String::NewFromUtf8(isolate, (const char *) CRFPP::getTaggerError())));
            return;
            
        }
        
        v8::Local<v8::External> handle = v8::External::New(isolate, tag);
        v8::Persistent<v8::External, v8::CopyablePersistentTraits<v8::External> > tagger(isolate, handle);
        
        obj -> tagger = tagger;
        
        obj->Wrap(args.This());
        args.GetReturnValue().Set(args.This());
    } else {
        const int argc = 1;
        Local<Value> argv[argc] = { args[0] };
        Local<Function> cons = Local<Function>::New(isolate, constructor);
        args.GetReturnValue().Set(cons->NewInstance(argc, argv));
    }
}
VectorFactorsExtractor::VectorFactorsExtractor(const CRF& i_crf, vector<double>* o_parameters)
{
    o_parameters->clear();

    const Factors& factors = i_crf.GetParameters();
    const vector<double>& initialWeights = factors.GetInitialWeights();
    const vector<double>& finalWeights = factors.GetFinalWeights();
    const vector<double>& defaultWeights = factors.GetDefaultWeights();

    numberOfLabels = i_crf.GetOutputAlphabet().Size();
    numberOfFeatures = i_crf.GetInputAlphabet().Size();
    numberOfCliques = i_crf.GetWeightsAlphabet().Size();

    // Insert intial, final and default weights
    dimension = 2 * numberOfLabels + numberOfCliques;
    o_parameters->resize(dimension);
    std::copy(initialWeights.begin(), initialWeights.end(),
        o_parameters->begin());
    std::copy(finalWeights.begin(), finalWeights.end(),
        o_parameters->begin() + numberOfLabels);
    std::copy(defaultWeights.begin(), defaultWeights.end(),
        o_parameters->begin() + 2 * numberOfLabels);

    cliqueFeatureConverter.resize(numberOfCliques);
    const vector<unordered_map<int, double> >& cliquesData = factors.GetWeights();
    // Iterate over cliques
    for (size_t cliqueIndex = 0; cliqueIndex < cliquesData.size();
        ++cliqueIndex)
    {
        unordered_map<int, int> featureToPositionInVector;
        const unordered_map<int, double>& currentCliquesData = cliquesData[cliqueIndex];
        for (auto iter = currentCliquesData.begin(); iter != currentCliquesData.end(); ++iter)
        {
            o_parameters->push_back(iter->second);
            featureToPositionInVector[iter->first] = dimension;
            ++dimension;
        }
        cliqueFeatureConverter[cliqueIndex] = std::move(featureToPositionInVector);
        printf("\rVectorFactorsExtractor evaluated %zu cliques", cliqueIndex);
    }
}
示例#3
0
Handle<Value> CRF::New(const Arguments& args) {
    HandleScope scope;

    if (!args.IsConstructCall()) {
        return ThrowException(Exception::TypeError(
            String::New("Use the new operator to create instances of this object."))
        );
    }

    if (args.Length() < 1) {
        return ThrowException(Exception::TypeError(
            String::New("First argument must be the path to the model")));
    }

    // Creates a new instance object of this type and wraps it.
    CRF* obj = new CRF();

    CRFPP::Tagger* tag = CRFPP::createTagger(get(args[0]));
    if(!tag){
       return ThrowException(Exception::TypeError(
            String::New(CRFPP::getTaggerError())));
    }

    obj -> tagger = Persistent<CRFPP::Tagger>(tag);

    obj->Wrap(args.This());

    return args.This();
}
示例#4
0
void CRFBinaryWriter::Write(const CRF& crf) const
{
	std::ofstream out(file, std::ios::binary);
	Tools::SetLocale(out);
    if (!out)
    {
        std::wcout << L"Can't write to "
                   << Tools::ConvertStringToWstring(file)
                   << L"    " << file.size()
                   << std::endl;
        exit(1);
    }
	// Printing alphabets;
	crf.GetInputAlphabet().Print(out);
	crf.GetOutputAlphabet().Print(out);
	crf.GetWeightsAlphabet().Print(out);
	// Printing States;
	int stateSize = crf.GetNumStates();
	out.write((char*)&stateSize, sizeof(int));
	for (int stateIndex = 0; stateIndex < stateSize; stateIndex++)
	{
		const State& state = crf.GetStates()[stateIndex];
		double initialWeight = crf.GetInitialWeights()[stateIndex];
		out.write((char*)&initialWeight, sizeof(double));
		double finalWeight = crf.GetFinalWeights()[stateIndex];
		out.write((char*)&finalWeight, sizeof(double));
		int numDestinations = state.GetNumDestinations();
		out.write((char*)&numDestinations, sizeof(int));
		for (int destIndex = 0; destIndex < numDestinations; ++destIndex)
		{
			out.write((char*)&state.GetDestinations()[destIndex], sizeof(int));
			int weightIndexesLength = state.GetWeightsIndexes()[destIndex].size();
			out.write((char*)&weightIndexesLength, sizeof(int));
			for (int weightIndex = 0; weightIndex < weightIndexesLength; ++weightIndex)
			{
				out.write((char*)&state.GetWeightsIndexes()[destIndex][weightIndex], 
					sizeof(int));
			}
		}
	}
	// Printing weights;
	const Factors& parameters = crf.GetParameters();
	for (int widx = 0; widx < parameters.GetWeightAlphabet().Size(); ++widx)
	{
		double defaultWeight = parameters.GetDefaultWeights()[widx];
		out.write((char*)&defaultWeight, sizeof(double));
        const unordered_map<int, double>& transitionWeights = parameters.GetWeights()[widx];
        int size = transitionWeights.size();
        out.write((char*)&size, sizeof(int));
        for (auto item : transitionWeights)
        {
            int index = item.first;
            double value = item.second;
            out.write((char*)&index, sizeof(int));
            out.write((char*)&value, sizeof(double));
        }
	}
	out.close();
}