Java Output类代码示例

import org.tensorflow.Output; //导入依赖的package包/类
public LabelImageTensorflowInputConverter() {
	graph = new Graph();
	GraphBuilder b = new GraphBuilder(graph);
	// 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;

	final Output input = b.placeholder("input", DataType.STRING);
	graphOutput =
			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));

}
 

import org.tensorflow.Output; //导入依赖的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.Output; //导入依赖的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.Output; //导入依赖的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.Output; //导入依赖的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.Output; //导入依赖的package包/类
private Graph constructGraphToNormalizeImage() {
  Graph graph = new Graph();
  GraphBuilder b = new GraphBuilder(graph);
  // - The model was trained with images scaled to 150x150 pixels.
  // - The colors, represented as R, G, B in 1-byte each were converted to
  //   float using value/Scale.
  final int H = 150;
  final int W = 150;
  final float scale = 255f;

  final Output input = b.placeholder("input", DataType.STRING);
  final Output output =
      b.div(
          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("scale", scale));
  normalizationOutputOperationName = output.op().name();
  return graph;
}
 

import org.tensorflow.Output; //导入依赖的package包/类
static
public OpType getOpType(Output output){
	org.tensorflow.DataType dataType = output.dataType();

	switch(dataType){
		case FLOAT:
		case DOUBLE:
		case INT32:
		case INT64:
			return OpType.CONTINUOUS;
		case STRING:
		case BOOL:
			return OpType.CATEGORICAL;
		default:
			throw new IllegalArgumentException();
	}
}
 

import org.tensorflow.Output; //导入依赖的package包/类
private static Tensor constructAndExecuteGraphToNormalizeImage(byte[] imageBytes) {
	//Graph construction: using the OperationBuilder class to construct a graph to decode, resize and normalize a JPEG image.
	
	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.Output; //导入依赖的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.Output; //导入依赖的package包/类
Output decodeJpeg(Output contents, long channels) {
	return g.opBuilder("DecodeJpeg", "DecodeJpeg")
			.addInput(contents)
			.setAttr("channels", channels)
			.build()
			.output(0);
}
 

import org.tensorflow.Output; //导入依赖的package包/类
Output decodeJpeg(Output contents, long channels) {
    return g.opBuilder("DecodeJpeg", "DecodeJpeg")
            .addInput(contents)
            .setAttr("channels", channels)
            .build()
            .output(0);
}
 

import org.tensorflow.Output; //导入依赖的package包/类
Output constant(String name, Object value) {
    try (Tensor t = Tensor.create(value)) {
        return g.opBuilder("Const", name)
                .setAttr("dtype", t.dataType())
                .setAttr("value", t)
                .build()
                .output(0);
    }
}
 

import org.tensorflow.Output; //导入依赖的package包/类
public static WritableMap convert(Output output) {
    WritableNativeMap shapeMap = new WritableNativeMap();
    shapeMap.putInt("numDimensions", output.shape().numDimensions());

    WritableNativeMap map = new WritableNativeMap();
    map.putInt("index", output.index());
    map.putString("dataType", output.dataType().name());
    map.putMap("shape", shapeMap);

    return map;
}
 

import org.tensorflow.Output; //导入依赖的package包/类
@ReactMethod
public void outputList(String id, String opName, int index, int length, Promise promise) {
    try {
        Operation graphOperation = getGraphOperation(id, opName);
        Output[] outputs = graphOperation.outputList(index, length);
        WritableArray outputsConverted = new WritableNativeArray();
        for (Output output : outputs) {
            outputsConverted.pushMap(OutputConverter.convert(output));
        }
        promise.resolve(outputsConverted);
    } catch (Exception e) {
        promise.reject(e);
    }
}
 

import org.tensorflow.Output; //导入依赖的package包/类
<T> Output<T> constant(String name, Object value, Class<T> type) {
  try (Tensor<T> t = Tensor.<T>create(value, type)) {
    return g.opBuilder("Const", name)
        .setAttr("dtype", DataType.fromClass(type))
        .setAttr("value", t)
        .build()
        .<T>output(0);
  }
}