bordeaux/service/src/android/bordeaux/services/Predictor.java

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.bordeaux.services;

import android.os.IBinder;
import android.util.Log;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashSet;
import java.util.Iterator;
import java.io.Serializable;
import java.io.*;
import java.lang.Boolean;
import android.bordeaux.services.FeatureAssembly;
import android.bordeaux.learning.predictorHist;

/**
 * This is interface to implement Prediction based on histogram that
 * uses predictor_histogram from learnerning section
 */
public class Predictor extends IPredictor.Stub
        implements IBordeauxLearner {
    private ModelChangeCallback modelChangeCallback = null;
    private final String TAG = "Predictor";
    private final String SET_EXPIRE_TIME = "SetExpireTime";
    private final String USE_HISTORY = "Use History";
    private final String SET_FEATURE = "Set Feature";
    private long mExpireTime = 3 * 60;
    private long mLastSampleTime = 0;
    private boolean mUseHistoryFlag = false;
    private final String NEW_START = "New Start";

    static public class Model implements Serializable {
        public HashMap<String, Integer> countHistogram = new HashMap<String, Integer>();
        public HashSet<String> usedFeatures = new HashSet<String>();
        public int sampleCounts;
        public boolean useHistoryFlag;
        public long expireTime;
        public long lastSampleTime;
    }

    private predictorHist mPredictorHist = new predictorHist();
    private String mLastSample = NEW_START;
    public FeatureAssembly mFeatureAssembly = new FeatureAssembly();

    /**
     * Reset the Predictor
     */
    public void ResetPredictor(){
        printModel(getPredictionModel());
        mPredictorHist.ResetPredictorHist();
        mUseHistoryFlag = false;
        mLastSampleTime = 0;
        mLastSample = NEW_START;
        mFeatureAssembly = new FeatureAssembly();
        printModel(getPredictionModel());
        if (modelChangeCallback != null) {
            modelChangeCallback.modelChanged(this);
        }
    }

    /**
     * Augment input string with buildin features such as time, location
     */
    private String buildDataPoint(String sampleName) {
        String fs = mFeatureAssembly.augmentFeatureInputString(sampleName);
        if (mUseHistoryFlag) {
             if (((System.currentTimeMillis()- mLastSampleTime)/1000) > mExpireTime) {
                 mLastSample  = NEW_START;
             }
             fs = fs + "+" + mLastSample;
        }
        return fs;
    }

    /**
     * Input is a sampleName e.g.action name. This input is then augmented with requested build-in
     * features such as time and location to create sampleFeatures. The sampleFeatures is then
     * pushed to the histogram
     */
    public void pushNewSample(String sampleName) {
        String sampleFeatures = buildDataPoint(sampleName);
        mLastSample = sampleName;
        mLastSampleTime = System.currentTimeMillis();
        mPredictorHist.pushSample(sampleFeatures);
        if (modelChangeCallback != null) {
            modelChangeCallback.modelChanged(this);
        }
        //printModel(getPredictionModel());
    }

    /**
     * return probabilty of an exmple using the histogram
     */
    public float getSampleProbability(String sampleName) {
        String sampleFeatures = buildDataPoint(sampleName);
        return mPredictorHist.getProbability(sampleFeatures);
    }

    /**
     * Set parameters for 1) using History in probability estimations e.g. consider the last event
     * and 2) featureAssembly e.g. time and location.
     */
    public boolean setPredictorParameter(String s, String f) {
        boolean res = false;
        if (s.equals(USE_HISTORY)) {
            if (f.equals("true")){
                mUseHistoryFlag = true;
                res = true;
            }
            else if (f.equals("false")) {
                mUseHistoryFlag = false;
                res = true;
            }
        } else if (s.equals(SET_EXPIRE_TIME)) {
            mExpireTime = Long.valueOf(f);
            res = true;
        } else if (s.equals(SET_FEATURE)) {
            res = mFeatureAssembly.registerFeature(f);
        }
        if (!res)
            Log.e(TAG,"Setting parameter " + s + " with " + f + " is not valid");
        return res;
    }

    public Model getPredictionModel() {
        Model m = new Model();
        m.countHistogram.putAll(mPredictorHist.getHist());
        m.sampleCounts = mPredictorHist.getHistCounts();
        m.expireTime = mExpireTime;
        m.usedFeatures = (HashSet) mFeatureAssembly.getUsedFeatures();
        m.useHistoryFlag = mUseHistoryFlag;
        m.lastSampleTime = mLastSampleTime;
        return m;
    }

    public boolean loadModel(Model m) {
        //Log.i(TAG,"on loadModel");
        //printModel(m);
        mPredictorHist = new predictorHist();
        mPredictorHist.set(m.countHistogram);
        mExpireTime = m.expireTime;
        mUseHistoryFlag = m.useHistoryFlag;
        mLastSampleTime = m.lastSampleTime;
        mFeatureAssembly = new FeatureAssembly();
        boolean res = false;
        Iterator itr = m.usedFeatures.iterator();
        while(itr.hasNext()) {
            res = res & mFeatureAssembly.registerFeature((String) itr.next());
        }
        return res;
    }

    public void printModel(Model m) {
        Log.i(TAG,"histogram is : " + m.countHistogram.toString());
        Log.i(TAG,"number of counts in histogram is : " + m.sampleCounts);
        Log.i(TAG,"ExpireTime time is : " + m.expireTime);
        Log.i(TAG,"useHistoryFlag is : " + m.useHistoryFlag);
        Log.i(TAG,"used features are : " + m.usedFeatures.toString());
    }

    // Beginning of the IBordeauxLearner Interface implementation
    public byte [] getModel() {
        Model model = getPredictionModel();
        //Log.i(TAG,"on getModel");
        printModel(model);
        try {
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            ObjectOutputStream objStream = new ObjectOutputStream(byteStream);
            objStream.writeObject(model);
            byte[] bytes = byteStream.toByteArray();
            //Log.i(TAG, "getModel: " + bytes);
            return bytes;
        } catch (IOException e) {
            throw new RuntimeException("Can't get model");
        }
    }

    public boolean setModel(final byte [] modelData) {
        //Log.i(TAG,"on setModel");
        try {
            ByteArrayInputStream input = new ByteArrayInputStream(modelData);
            ObjectInputStream objStream = new ObjectInputStream(input);
            Model model = (Model) objStream.readObject();
            boolean res = loadModel(model);
            //Log.i(TAG, "LoadModel: " + modelData);
            return res;
        } catch (IOException e) {
            throw new RuntimeException("Can't load model");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException("Learning class not found");
        }
    }

    public IBinder getBinder() {
        return this;
    }

    public void setModelChangeCallback(ModelChangeCallback callback) {
        modelChangeCallback = callback;
    }
    // End of IBordeauxLearner Interface implemenation
}