org.numenta.nupic.network.Inference Java Examples

protected void processInput(Network network, IN record, long timestamp) throws Exception {

        if(userFunction.reset(record)) {
            network.reset();
            LOG.debug("network reset");
        }

        Object input = convertToInput(record, timestamp);
        Inference inference = network.computeImmediate(input);

        if(inference != null) {
            NetworkInference outputInference = NetworkInference.fromInference(inference);
            StreamRecord<Tuple2<IN,NetworkInference>> streamRecord = new StreamRecord<>(
                    new Tuple2<>(record, outputInference),
                    timestamp);
            output.collect(streamRecord);
        }
    }
 

/**
 * {@inheritDoc}
 */
@Override
public void listenToNetwork(Network network) {
    if(network == null) {
        throw new IllegalArgumentException("Cannot listen to null Network.");
    }
    
    this.htmNetwork = network;
    
    network.observe().subscribe(new Subscriber<Inference>() {
        @Override public void onCompleted() {}
        @Override public void onError(Throwable e) {}
        @Override public void onNext(Inference t) {
            currentPrediction = subsample(
                SDR.cellsAsColumnIndices(t.getPredictiveCells(), cellsPerColumn));
            semaphore.release();
        }
    });
    
    this.cellsPerColumn = htmNetwork.getHead().getTail().getConnections().getCellsPerColumn();
   
}
 

public static NetworkInference fromInference(Inference i) {
    Map<String, Classification<Object>> classifications = new HashMap<>();
    for (String field : i.getClassifiers().keys()) {
        classifications.put(field, i.getClassification(field));
    }
    return new NetworkInference(i.getAnomalyScore(), classifications);
}
 

/**
 * Primitive file appender for collecting output. This just demonstrates how to use
 * {@link Subscriber#onNext(Object)} to accomplish some work.
 *
 * @param infer             The {@link Inference} object produced by the Network
 * @param classifierField   The field we use in this demo for anomaly computing.
 */
private void writeToFile(Inference infer, String classifierField) {
    try {
        double newPrediction;
        if(null != infer.getClassification(classifierField).getMostProbableValue(1)) {
            newPrediction = (Double)infer.getClassification(classifierField).getMostProbableValue(1);
        } else {
            newPrediction = predictedValue;
        }
        if(infer.getRecordNum() > 0) {
            double actual = (Double)infer.getClassifierInput()
                    .get(classifierField).get("inputValue");
            double error = Math.abs(predictedValue - actual);
            StringBuilder sb = new StringBuilder()
                    .append(infer.getRecordNum()).append(", ")
                            //.append("classifier input=")
                    .append(String.format("%3.2f", actual)).append(", ")
                            //.append("prediction= ")
                    .append(String.format("%3.2f", predictedValue)).append(", ")
                    .append(String.format("%3.2f", error)).append(", ")
                            //.append("anomaly score=")
                    .append(infer.getAnomalyScore());
            pw.println(sb.toString());
            pw.flush();
            System.out.println(sb.toString());
        } else {

        }
        predictedValue = newPrediction;
    }catch(Exception e) {
        e.printStackTrace();
        pw.flush();
    }

}
 

@Test
public void testSerializeDeSerialize() {
    final List<Inference> callVerify = new ArrayList<>();
    
    SerializerCore serializer = Persistence.get().serializer();
    
    Inference inf = new ManualInput() {
        @SuppressWarnings("unchecked")
        @Override
        public <T> T postDeSerialize(T i) {
            Inference retVal = (Inference)super.postDeSerialize(i);
            assertNotNull(retVal);
            assertTrue(retVal != i); // Ensure Objects not same
            assertTrue(retVal.equals(i)); // However they are still equal!
            callVerify.add(retVal);
            assertTrue(callVerify.size() == 1);
            
            return (T)retVal;
        }
    };
    
    byte[] bytes = serializer.serialize(inf);
    assertNotNull(bytes);
    
    Inference serializedInf = serializer.deSerialize(bytes);
    assertNotNull(serializedInf);
}
 

@Test
public void testGetSubscriber() {
    NetworkAPIDemo demo = new NetworkAPIDemo(Mode.MULTIREGION);
    Subscriber<Inference> s = demo.getSubscriber();
    assertNotNull(s);
}