Here, we present what classes do we need to add and what interfaces do we need to implement. We provide the source code for all of the classes and interfaces.

Task Loss

First we define out measure of performance. Every task has defines its own function. In out package, in order to create new loss function one should implement the ITaskLoss interface. In our problem settings we use the following loss function:

\begin{equation} \label{eq:loss} \ell ((t_{s}, t_{e}),(\hat{t_{s}}, \hat{t_{e}})) = max{\{|(\hat{t_{s}}-\hat{t_{e}}) - (t_{s} - t_{e})| - \epsilon ,0\}} \end{equation}

In words, the loss will be the max between zero to the difference between the predicted signals length to its actual length and we minus epsilon. This means that we allow the classifier to be mistaken by at most epsilon.

For this we create new Java class inside that implements the ITaskLoss interface. The code for the implementation of this class is attached to this tutorial.

Inference

Now we turn to define our inference functions. Every inference class should implement the IInference interface.
In our problem settings the inference will be a brute force. We assume that at the beginning and at the end there is a gap of three frames, which means the beginning of the of the signal can not be in the first 3 frames and the end of the signal can not be at the last three frames, this can be redefined otherwise if needed.
Out inference will go over all the possible time pairs for the start and end times, starting from minimum gap to maximum gap.

In general we need the Inference class to implement the following:

\begin{equation} \label{eq:decoding} \hat{y}_{w}(x) = argmax_{\mathcal{y} \in \mathcal{Y}} ~ w^\top \phi(x, y) \end{equation}

and,

\begin{equation} \label{eq:augmented-loss} \hat{y}_{w}(x) = argmax_{\mathcal{y} \in \mathcal{Y}} ~ w^\top \phi(x, y) + \ell (y,\hat{y}) \end{equation}

For this we create new Java class inside the com.structed.models.inference package, this class should implement the IInference interface. The code for the implementation of this class is attached to this tutorial or can be found at the tutorial folder.

Feature Functions

We now add the feature functions. Every feature function class should implement the IFeatureFunctions interface. Since we want to recognize the pick of the start of the signal and the decrease of the end signal we implemented the following feature functions:

1. Difference between the element at the start index to the element at index start - 1
2. Difference between the element at the start index to the element at index start - 2
3. Difference between the element at the end index to the element at index end + 1
4. Difference between the element at the end index to the element at index end + 2
5. Difference between the mean of the signal from start to end to the mean of the signal from start to start - 3
6. Difference between the mean of the signal from start to end to the mean of the signal from end to end + 3

We expect that the value of the above feature functions will be high when we reach the true start time and end time, and low otherwise.

For this we create new Java class inside the com.structed.data.featureFunctions package, this class should implement the IFeatureFunctions interface. The code for the implementation of this class is attached to this tutorial or can be found at the tutorial folder.

Storing the train/test examples

                
        Logger.info("Dummy data example.");
        int readerType = 0;
        int epochNum = 3;
        int isAvg = 1;
        int numExamples2Display = 3;
        // <the path to the train dummy data>
        String trainPath = "data/train.txt"; 
        // <the path to the test dummy data>
        String testPath = "data/test.txt"; 

        // load the data
        Reader reader = getReader(readerType);
        InstancesContainer dummyTrainInstances = reader.readData(trainPath, Consts.SPACE, 
              Consts.COLON_SPLITTER);
        InstancesContainer dummyTestInstances = reader.readData(testPath, 
              Consts.SPACE, Consts.COLON_SPLITTER);
        if ( dummyTrainInstances.getSize() == 0 ) return;

        // ======= PASSIVE AGGRESSIVE ====== //
        // init the first weight vector
        Vector W = new Vector() {{put(0, 0.0);}}; 
        // model parameters
        ArrayList<Double> arguments = new ArrayList<Double>(){{add(3.0);}}; 
        // task loss parameters
        ArrayList<Double> task_loss_params = new ArrayList<Double>(){{add(1.0);}}; 

        // create the model
        StructEDModel dummy_model = new StructEDModel(W, new PassiveAggressive(), new TaskLossDummyData(),
                new InferenceDummyData(), null, new FeatureFunctionsDummy(), arguments); 
        // train
        dummy_model.train(dummyTrainInstances, task_loss_params, null, epochNum, isAvg); 
        // predict
        ArrayList<PredictedLabels> labels = dummy_model.predict(dummyTestInstances, task_loss_params, 
                numExamples2Display); 

        // print the prediction
        for(int i=0 ; i<dummyTestInstances.getSize() ; i++)
            Logger.info("Y = "+dummyTestInstances.getInstance(i).getLabel()+", Y_HAT = "+
                labels.get(i).firstKey());
        Logger.info("");       

                    

                
        // ======= CRF ====== //
        // init the first weight vector
        W = new Vector() {{put(0, 0.0);}}; 
        // model parameters
        arguments = new ArrayList<Double>(){{add(0.1);add(0.1);}}; 

        // create the model
        StructEDModel dummy_model_crf = new StructEDModel(W, new CRF(), new TaskLossDummyData(),
                new InferenceDummyData(), null, new FeatureFunctionsDummy(), arguments); 
        // train
        dummy_model_crf.train(dummyTrainInstances, task_loss_params, null, epochNum, isAvg); 
        // predict
        labels = dummy_model_crf.predict(dummyTestInstances, task_loss_params, numExamples2Display); 

        // print the prediction
        for(int i=0 ; i<dummyTestInstances.getSize() ; i++)
            Logger.info("Y = "+dummyTestInstances.getInstance(i).getLabel()+", Y_HAT = "+
                  labels.get(i).firstKey());
        Logger.info("");