मैं जावा से विज्ञान-सीखने वाले क्लासिफायर को कैसे कॉल कर सकता हूं?

Question

मेरे पास एक वर्गीकरण है जिसे मैंने पायथन के विज्ञान-सीखने का उपयोग करके प्रशिक्षित किया है। जावा प्रोग्राम से क्लासिफायर का उपयोग कैसे कर सकता हूं? क्या मैं ज्योथन का उपयोग कर सकता हूं? क्या Python में क्लासिफायरफायर को सहेजने और जावा में लोड करने का कोई तरीका है? क्या इसका उपयोग करने का कोई और तरीका है?

Answer 1

आप ज्योथन का उपयोग scikit के रूप में नहीं कर सकते हैं-सीखने में भारी मात्रा में निर्भर करता है और बहुत सी संकलित सी और फोरट्रान एक्सटेंशन इसलिए ज्योथन में काम नहीं कर सकते हैं।

सबसे आसान एक जावा वातावरण में सीखने scikit का उपयोग करने के तरीके होगा:

• एक microframework का उपयोग कर, एक HTTP/Json सेवा के रूप में वर्गीकारक बेनकाब उदाहरण के लिए इस तरह के रूप flask या bottle या cornice और यह जावा से फोन एक HTTP क्लाइंट लाइब्रेरी

• अजगर में एक कमांडलाइन आवरण आवेदन लिखने कि इस तरह के सीएसवी या JSON (या कुछ निचले स्तर द्विआधारी प्रतिनिधित्व) के रूप में कुछ प्रारूप का उपयोग कर stdout पर stdin और आउटपुट भविष्यवाणियों पर डेटा पढ़ता है का उपयोग करते हुए और कॉल पायथन कार्यक्रम एफ उदाहरण के लिए रोम जावा Apache Commons Exec का उपयोग कर।

• पाइथन प्रोग्राम फिट समय (आमतौर पर फ्लोटिंग पॉइंट मानों की एक सरणी के रूप में) के कच्चे संख्यात्मक पैरामीटर को आउटपुट करता है और जावा में पूर्वानुमान फ़ंक्शन को पुन: कार्यान्वित करता है (यह आम तौर पर पूर्वानुमानित रैखिक मॉडल के लिए आसान है जहां भविष्यवाणी अक्सर होती है एक थ्रेसहोल्ड डॉट उत्पाद)।

यदि आपको जावा में सुविधा निष्कर्षण को फिर से कार्यान्वित करने की आवश्यकता है तो अंतिम दृष्टिकोण बहुत अधिक काम करेगा।

अंत में आप जावा लाइब्रेरी जैसे वेका या महाउट का उपयोग कर सकते हैं जो जावा से विज्ञान-सीखने का प्रयास करने की बजाय आपको आवश्यक एल्गोरिदम लागू करता है।

Answer 2

इस उद्देश्य के लिए JPMML प्रोजेक्ट है।

सबसे पहले, आप को क्रमानुसार PMML (जो आंतरिक रूप से एक्सएमएल है) करने के लिए मॉडल scikit सीखने अजगर से सीधे sklearn2pmml लाइब्रेरी का उपयोग कर या अजगर में यह पहली बार डंप और जावा में या इस लाइब्रेरी द्वारा प्रदान की एक कमांड लाइन से jpmml-sklearn का उपयोग कर बदल सकते हैं। इसके बाद, आप अपने जावा कोड में jpmml-evaluator का उपयोग करके लोड मॉडल को deserialize और निष्पादित कर सकते हैं।

इस तरह से सभी scikit-learn मॉडल के साथ काम नहीं करता है, लेकिन उनमें से many के साथ काम करता है।

Answer 3

यहाँ JPMML समाधान के लिए कुछ कोड है:

--PYTHON PART--

# helper function to determine the string columns which have to be one-hot-encoded in order to apply an estimator. 
def determine_categorical_columns(df): 
    categorical_columns = [] 
    x = 0 
    for col in df.dtypes: 
     if col == 'object': 
      val = df[df.columns[x]].iloc[0] 
      if not isinstance(val,Decimal): 
       categorical_columns.append(df.columns[x]) 
     x += 1 
    return categorical_columns 

categorical_columns = determine_categorical_columns(df) 
other_columns = list(set(df.columns).difference(categorical_columns)) 


#construction of transformators for our example 
labelBinarizers = [(d, LabelBinarizer()) for d in categorical_columns] 
nones = [(d, None) for d in other_columns] 
transformators = labelBinarizers+nones 

mapper = DataFrameMapper(transformators,df_out=True) 
gbc = GradientBoostingClassifier() 

#construction of the pipeline 
lm = PMMLPipeline([ 
    ("mapper", mapper), 
    ("estimator", gbc) 
]) 

--JAVA भाग -

//Initialisation. 
String pmmlFile = "ScikitLearnNew.pmml"; 
PMML pmml = org.jpmml.model.PMMLUtil.unmarshal(new FileInputStream(pmmlFile)); 
ModelEvaluatorFactory modelEvaluatorFactory = ModelEvaluatorFactory.newInstance(); 
MiningModelEvaluator evaluator = (MiningModelEvaluator) modelEvaluatorFactory.newModelEvaluator(pmml); 

//Determine which features are required as input 
HashMap<String, Field>() inputFieldMap = new HashMap<String, Field>(); 
for (int i = 0; i < evaluator.getInputFields().size();i++) { 
    InputField curInputField = evaluator.getInputFields().get(i); 
    String fieldName = curInputField.getName().getValue(); 
    inputFieldMap.put(fieldName.toLowerCase(),curInputField.getField()); 
} 


//prediction 

HashMap<String,String> argsMap = new HashMap<String,String>(); 
//... fill argsMap with input 

Map<FieldName, ?> res; 
// here we keep only features that are required by the model 
Map<FieldName,String> args = new HashMap<FieldName, String>(); 
Iterator<String> iter = argsMap.keySet().iterator(); 
while (iter.hasNext()) { 
    String key = iter.next(); 
    Field f = inputFieldMap.get(key); 
    if (f != null) { 
    FieldName name =f.getName(); 
    String value = argsMap.get(key); 
    args.put(name, value); 
    } 
} 
//the model is applied to input, a probability distribution is obtained 
res = evaluator.evaluate(args); 
SegmentResult segmentResult = (SegmentResult) res; 
Object targetValue = segmentResult.getTargetValue(); 
ProbabilityDistribution probabilityDistribution = (ProbabilityDistribution) targetValue; 

Answer 4

आप एक कुली उपयोग कर सकते हैं, मैंने sklearn-पोर्टर (https://github.com/nok/sklearn-porter) का परीक्षण किया है, और यह जावा के लिए अच्छा काम करता है।एक DecisionTreeClassifier

import pandas as pd 
from sklearn import tree 
from sklearn_porter import Porter 

train_dataset = pd.read_csv('./result2.csv').as_matrix() 

X_train = train_dataset[:90, :8] 
Y_train = train_dataset[:90, 8:] 

X_test = train_dataset[90:, :8] 
Y_test = train_dataset[90:, 8:] 

print X_train.shape 
print Y_train.shape 


clf = tree.DecisionTreeClassifier() 
clf = clf.fit(X_train, Y_train) 

porter = Porter(clf, language='java') 
output = porter.export(embed_data=True) 
print(output) 

मेरे मामले में, मैं उपयोग कर रहा हूँ, और की

प्रिंट निर्गम (आउटपुट)

है:

मेरे कोड पीछा कर रहा है कंसोल में पाठ के रूप में निम्नलिखित कोड:

class DecisionTreeClassifier { 

    private static int findMax(int[] nums) { 
    int index = 0; 
    for (int i = 0; i < nums.length; i++) { 
     index = nums[i] > nums[index] ? i : index; 
    } 
    return index; 
    } 


    public static int predict(double[] features) { 
    int[] classes = new int[2]; 

    if (features[5] <= 51.5) { 
     if (features[6] <= 21.0) { 

      // HUGE amount of ifs.......... 

     } 
    } 

    return findMax(classes); 
    } 

    public static void main(String[] args) { 
    if (args.length == 8) { 

     // Features: 
     double[] features = new double[args.length]; 
     for (int i = 0, l = args.length; i < l; i++) { 
      features[i] = Double.parseDouble(args[i]); 
     } 

     // Prediction: 
     int prediction = DecisionTreeClassifier.predict(features); 
     System.out.println(prediction); 

    } 
    } 
}