Java Session类代码示例

import org.tensorflow.Session; //导入依赖的package包/类
public Inception(String graphPath, String labelsPath) throws IOException{
    graphDef = Files.readAllBytes(Paths.get(graphPath));
    labels = Files.readAllLines(Paths.get(labelsPath));

    Graph g = new Graph();
    s = new Session(g);
    GraphBuilder b = new GraphBuilder(g);
    // - The model was trained with images scaled to 224x224 pixels.
    // - The colors, represented as R, G, B in 1-byte each were converted to
    //   float using (value - Mean)/Scale.
    final int H = 224;
    final int W = 224;
    final float mean = 117f;
    final float scale = 1f;
    output = b.div(
                b.sub(
                    b.resizeBilinear(
                            b.expandDims(
                                    b.cast(b.decodeJpeg(b.placeholder("input", DataType.STRING), 3), DataType.FLOAT),
                                    b.constant("make_batch", 0)),
                            b.constant("size", new int[] {H, W})),
                    b.constant("mean", mean)),
                b.constant("scale", scale));
}
 

import org.tensorflow.Session; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    try (Graph g = new Graph()) {
        final String value = "Hello from " + TensorFlow.version();

        // Construct the computation graph with a single operation, a constant
        // named "MyConst" with a value "value".
        try (Tensor t = Tensor.create(value.getBytes("UTF-8"))) {
            // The Java API doesn't yet include convenience functions for adding operations.
            g.opBuilder("Const", "MyConst").setAttr("dtype", t.dataType()).setAttr("value", t).build();
        }

        // Execute the "MyConst" operation in a Session.
        try (Session s = new Session(g);
             Tensor output = s.runner().fetch("MyConst").run().get(0)) {
            System.out.println(new String(output.bytesValue(), "UTF-8"));
        }
    }
}
 

import org.tensorflow.Session; //导入依赖的package包/类
private static float[] executeInceptionGraph(byte[] graphDef, Tensor image) {
    try (Graph g = new Graph()) {
        g.importGraphDef(graphDef);
        try (Session s = new Session(g);
                Tensor result = s.runner().feed("DecodeJpeg/contents", image).fetch("softmax").run().get(0)) {
            final long[] rshape = result.shape();
            if (result.numDimensions() != 2 || rshape[0] != 1) {
                throw new RuntimeException(
                        String.format(
                                "Expected model to produce a [1 N] shaped tensor where N is the number of labels, instead it produced one with shape %s",
                                Arrays.toString(rshape)));
            }
            int nlabels = (int) rshape[1];
            return result.copyTo(new float[1][nlabels])[0];
        }
    }
}
 

import org.tensorflow.Session; //导入依赖的package包/类
private static TfContext createContext(ReactContext reactContext, String model) throws IOException {
    byte[] b = new ResourceManager(reactContext.getAssets()).loadResource(model);

    Graph graph = new Graph();
    graph.importGraphDef(b);
    Session session = new Session(graph);
    Session.Runner runner = session.runner();

    return new TfContext(session, runner, graph);
}
 

import org.tensorflow.Session; //导入依赖的package包/类
private Tensor constructAndExecuteGraphToNormalizeImage(byte[] imageBytes) {
	try (Graph g = new Graph()) {
		GraphBuilder b = new GraphBuilder(g);
		// Some constants specific to the pre-trained model at:
		// https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip
		//
		// - The model was trained with images scaled to 224x224 pixels.
		// - The colors, represented as R, G, B in 1-byte each were
		// converted to
		// float using (value - Mean)/Scale.
		final int H = 224;
		final int W = 224;
		final float mean = 117f;
		final float scale = 1f;

		// Since the graph is being constructed once per execution here, we
		// can use a constant for the
		// input image. If the graph were to be re-used for multiple input
		// images, a placeholder would
		// have been more appropriate.
		final Output input = b.constant("input", imageBytes);
		final Output output = b
				.div(b.sub(
						b.resizeBilinear(b.expandDims(b.cast(b.decodeJpeg(input, 3), DataType.FLOAT),
								b.constant("make_batch", 0)), b.constant("size", new int[] { H, W })),
						b.constant("mean", mean)), b.constant("scale", scale));
		try (Session s = new Session(g)) {
			return s.runner().fetch(output.op().name()).run().get(0);
		}
	}
}
 

import org.tensorflow.Session; //导入依赖的package包/类
private float[] executeInceptionGraph(byte[] graphDef, Tensor image) {
	try (Graph g = new Graph()) {
		g.importGraphDef(graphDef);
		try (Session s = new Session(g);
				Tensor result = s.runner().feed("input", image).fetch("output").run().get(0)) {
			final long[] rshape = result.shape();
			if (result.numDimensions() != 2 || rshape[0] != 1) {
				throw new RuntimeException(String.format(
						"Expected model to produce a [1 N] shaped tensor where N is the number of labels, instead it produced one with shape %s",
						Arrays.toString(rshape)));
			}
			int nlabels = (int) rshape[1];
			return result.copyTo(new float[1][nlabels])[0];
		}
	}
}
 

import org.tensorflow.Session; //导入依赖的package包/类
public List<Entry<Float, String>> getInception(byte[] imageBytes, String modelDir) {
	logger.info(String.format("getInception: %d bytes %s", new Object[] { imageBytes.length, Paths.get(modelDir, "graph.pb") }));
	Graph g = getOrCreate(Paths.get(modelDir, "graph.pb"));
	try (Session s = new Session(g)) {
		List<String> labels = getOrCreateLabels(Paths.get(modelDir, "label.txt"));
		Tensor image = constructAndExecuteGraphToNormalizeImage(imageBytes);
		Tensor result = s.runner().feed("input", image).fetch("output").run().get(0);
		logger.debug("found results");

		final long[] rshape = result.shape();
		if (result.numDimensions() != 2 || rshape[0] != 1) {
			throw new RuntimeException(String.format(
					"Expected model to produce a [1 N] shaped tensor where N is the number of labels, instead it produced one with shape %s",
					Arrays.toString(rshape)));
		}
		int nlabels = (int) rshape[1];

		logger.debug(String.format("number of labels %d, %d", new Object[] { labels.size(), nlabels }));
		int mLabeled = Math.min(labels.size(), nlabels);

		float[] labelProbabilities = result.copyTo(new float[1][nlabels])[0];

		HashMap<Float, String> results = new HashMap<Float, String>();
		for (int i = 0; i < mLabeled; i++) {
			results.put(labelProbabilities[i], labels.get(i));
		}

		return Collections.synchronizedList(
				results.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByKey())).limit(10)
						.collect(Collectors.toList()));
	} catch (Exception e) {
		logger.error("Failed in tensorflow", e);
		throw(e);
	}
}
 

import org.tensorflow.Session; //导入依赖的package包/类
private static Tensor constructAndExecuteGraphToNormalizeImage(byte[] imageBytes) {
	try (Graph g = new Graph()) {
		GraphBuilder b = new GraphBuilder(g);
		// Some constants specific to the pre-trained model at:
		// https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip
		//
		// - The model was trained with images scaled to 224x224 pixels.
		// - The colors, represented as R, G, B in 1-byte each were converted to
		// float using (value - Mean)/Scale.
		final int H = 224;
		final int W = 224;
		final float mean = 117f;
		final float scale = 1f;

		// Since the graph is being constructed once per execution here, we can use a
		// constant for the
		// input image. If the graph were to be re-used for multiple input images, a
		// placeholder would
		// have been more appropriate.
		final Output input = b.constant("input", imageBytes);
		final Output output = b
				.div(b.sub(
						b.resizeBilinear(b.expandDims(b.cast(b.decodeJpeg(input, 3), DataType.FLOAT),
								b.constant("make_batch", 0)), b.constant("size", new int[] { H, W })),
						b.constant("mean", mean)), b.constant("scale", scale));
		try (Session s = new Session(g)) {
			return s.runner().fetch(output.op().name()).run().get(0);
		}
	}
}
 

import org.tensorflow.Session; //导入依赖的package包/类
@Test
public void testTf() throws UnsupportedEncodingException {
    try (Graph g = new Graph()) {
        final String value = "Hello from " + TensorFlow.version();

        // Construct the computation graph with a single operation, a constant
        // named "MyConst" with a value "value".
        try (Tensor t = Tensor.create(value.getBytes("UTF-8"))) {
            // The Java API doesn't yet include convenience functions for adding operations.
            g.opBuilder("Const", "MyConst").setAttr("dtype", t.dataType()).setAttr("value", t).build();
        }

        // Execute the "MyConst" operation in a Session.
        try (Session s = new Session(g); Tensor output = s.runner().fetch("MyConst").run().get(0)) {
            logger.info(new String(output.bytesValue(), "UTF-8"));
            logger.info(output.toString());
        }
    }
}
 

import org.tensorflow.Session; //导入依赖的package包/类
private static float[] executeInceptionGraph(final Graph g,
	final Tensor image)
{
	try (
		final Session s = new Session(g);
		final Tensor result = s.runner().feed("input", image)//
			.fetch("output").run().get(0)
	)
	{
		final long[] rshape = result.shape();
		if (result.numDimensions() != 2 || rshape[0] != 1) {
			throw new RuntimeException(String.format(
				"Expected model to produce a [1 N] shaped tensor where N is " +
					"the number of labels, instead it produced one with shape %s",
				Arrays.toString(rshape)));
		}
		final int nlabels = (int) rshape[1];
		return result.copyTo(new float[1][nlabels])[0];
	}
}
 

import org.tensorflow.Session; //导入依赖的package包/类
public static Tensor<Float> constructAndExecuteGraphToNormalizeRGBImage(byte[] imageBytes, int W, int H, float mean, float scale) {
        try (Graph g = new Graph()) {
            GraphBuilder b = new GraphBuilder(g);
            // Some constants specific to the pre-trained model at:
            // https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip
            //
            // - The model was trained with images scaled to 224x224 pixels.
            // - The colors, represented as R, G, B in 1-byte each were converted to
            //   float using (value - Mean)/Scale.
//            final int H = 224;
//            final int W = 224;
//            final float mean = 117f;
//            final float scale = 1f;

            // Since the graph is being constructed once per execution here, we can use a constant for the
            // input image. If the graph were to be re-used for multiple input images, a placeholder would
            // have been more appropriate.
            final Output<String> input = b.constant("input", imageBytes);
            final Output<Float> output
                    = b.div(
                            b.sub(
                                    b.resizeBilinear(
                                            b.expandDims(
                                                    b.cast(b.decodeJpeg(input, 3), Float.class),
                                                    b.constant("make_batch", 0)),
                                            b.constant("size", new int[]{H, W})),
                                    b.constant("mean", mean)),
                            b.constant("scale", scale));
            try (Session s = new Session(g)) {
                return s.runner().fetch(output.op().name()).run().get(0).expect(Float.class);
            }
        }
    }
 

import org.tensorflow.Session; //导入依赖的package包/类
public static float[] executeGraph(Graph graph, Tensor<Float> image, String inputLayerName, String outputLayerName) {
//        try (Graph g=graph) {
            try (Session s = new Session(graph);
                    Tensor<Float> result = s.runner().feed(inputLayerName, image).fetch(outputLayerName).run().get(0).expect(Float.class)
                    ) { 
                final long[] rshape = result.shape();
                if (result.numDimensions() != 2 || rshape[0] != 1) {
                    throw new RuntimeException(
                            String.format(
                                    "Expected model to produce a [1 N] shaped tensor where N is the number of labels, instead it produced one with shape %s",
                                    Arrays.toString(rshape)));
                }
                int nlabels = (int) rshape[1];
                return result.copyTo(new float[1][nlabels])[0];
            }
//        }
    }
 

import org.tensorflow.Session; //导入依赖的package包/类
private static Tensor<Float> constructAndExecuteGraphToNormalizeImage(byte[] imageBytes) {
    try (Graph g = new Graph()) {
        GraphBuilder b = new GraphBuilder(g);
        // Some constants specific to the pre-trained model at:
        // https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip
        //
        // - The model was trained with images scaled to 224x224 pixels.
        // - The colors, represented as R, G, B in 1-byte each were converted to
        //   float using (value - Mean)/Scale.
        final int H = 224;
        final int W = 224;
        final float mean = 117f;
        final float scale = 1f;

        // Since the graph is being constructed once per execution here, we can use a constant for the
        // input image. If the graph were to be re-used for multiple input images, a placeholder would
        // have been more appropriate.
        final Output<String> input = b.constant("input", imageBytes);
        final Output<Float> output
                = b.div(
                        b.sub(
                                b.resizeBilinear(
                                        b.expandDims(
                                                b.cast(b.decodeJpeg(input, 3), Float.class),
                                                b.constant("make_batch", 0)),
                                        b.constant("size", new int[]{H, W})),
                                b.constant("mean", mean)),
                        b.constant("scale", scale));
        try (Session s = new Session(g)) {
            return s.runner().fetch(output.op().name()).run().get(0).expect(Float.class);
        }
    }
}
 

import org.tensorflow.Session; //导入依赖的package包/类
private static float[] executeInceptionGraph(byte[] graphDef, Tensor<Float> image) {
    try (Graph g = new Graph()) {
        g.importGraphDef(graphDef);
        try (Session s = new Session(g);
                Tensor<Float> result
                = s.runner().feed("input", image).fetch("output").run().get(0).expect(Float.class)) {
            final long[] rshape = result.shape();
            if (result.numDimensions() != 2 || rshape[0] != 1) {
                throw new RuntimeException(
                        String.format(
                                "Expected model to produce a [1 N] shaped tensor where N is the number of labels, instead it produced one with shape %s",
                                Arrays.toString(rshape)));
            }
            int nlabels = (int) rshape[1];
            return result.copyTo(new float[1][nlabels])[0];
        }
    }
}
 

import org.tensorflow.Session; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    try (Graph g = new Graph()) {
        final String value = "Hello from " + TensorFlow.version();

        // Construct the computation graph with a single operation, a constant
        // named "MyConst" with a value "value".
        try (Tensor t = Tensor.create(value.getBytes("UTF-8"))) {
            // The Java API doesn't yet include convenience functions for adding operations.
            g.opBuilder("Const", "MyConst").setAttr("dtype", t.dataType()).setAttr("value", t).build();
        }

        // Execute the "MyConst" operation in a Session.
        try (Session s = new Session(g);
                Tensor output = s.runner().fetch("MyConst").run().get(0)) {
            System.out.println(new String(output.bytesValue(), "UTF-8"));
        }
    }
}