def predict(self, x, batch_per_thread=1, distributed=True, mini_batch=False): """ Use a model to do prediction. """ if isinstance(x, ImageSet): results = callZooFunc(self.bigdl_type, "zooPredict", self.value, x, batch_per_thread) return ImageSet(results) if isinstance(x, TFImageDataset): results = callZooFunc(self.bigdl_type, "zooPredict", self.value, x.get_prediction_data(), x.batch_per_thread) return ImageSet(results) if isinstance(x, MapDataset): raise ValueError("MapDataset is not supported in TFNet") if isinstance(x, TFDataset): results = callZooFunc(self.bigdl_type, "zooPredict", self.value, x.get_prediction_data()) return results.map(lambda result: Layer.convert_output(result)) if mini_batch: results = callZooFunc(self.bigdl_type, "zooPredict", self.value, x) return results.map(lambda result: Layer.convert_output(result)) if distributed: if isinstance(x, np.ndarray): data_rdd = to_sample_rdd(x, np.zeros([x.shape[0]]), getOrCreateSparkContext()) elif isinstance(x, RDD): data_rdd = x else: raise TypeError("Unsupported prediction data type: %s" % type(x)) results = callZooFunc(self.bigdl_type, "zooPredict", self.value, data_rdd, batch_per_thread) return results.map(lambda result: Layer.convert_output(result)) else: start_idx = 0 results = [] while start_idx < len(x): end_idx = min(start_idx + batch_per_thread, len(x)) results.append(self.forward(x[start_idx:end_idx])) start_idx += batch_per_thread return np.concatenate(results, axis=0)
def predict(self, x, batch_per_thread=1, distributed=True): """ Use a model to do prediction. """ if isinstance(x, ImageSet): results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, x, batch_per_thread) return ImageSet(results) if distributed: if isinstance(x, np.ndarray): data_rdd = to_sample_rdd(x, np.zeros([x.shape[0]]), getOrCreateSparkContext()) elif isinstance(x, RDD): data_rdd = x else: raise TypeError("Unsupported prediction data type: %s" % type(x)) results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, data_rdd, batch_per_thread) return results.map(lambda result: Layer.convert_output(result)) else: if isinstance(x, np.ndarray) or isinstance(x, list): results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, self._to_jtensors(x), batch_per_thread) return [Layer.convert_output(result) for result in results] else: raise TypeError("Unsupported prediction data type: %s" % type(x))
def __call__(self, input, bigdl_type="float"): """ transform ImageSet """ # move the import here to break circular import if "zoo.feature.image.imageset.ImageSet" not in sys.modules: from zoo.feature.image import ImageSet if type(input) is ImageSet: jset = callBigDlFunc(bigdl_type, "transformImageSet", self.value, input) return ImageSet(jvalue=jset)
def get_raw_image_set(self, with_label): resource_path = os.path.join( os.path.split(__file__)[0], "../../resources") if with_label: image_folder = os.path.join(resource_path, "cat_dog") else: image_folder = os.path.join(resource_path, "cat_dog/*") image_set = ImageSet.read(image_folder, with_label=with_label, sc=get_spark_context(), one_based_label=False) return image_set
def __call__(self, input): """ Transform ImageSet or TextSet. """ # move the import here to break circular import if "zoo.feature.image.imageset.ImageSet" not in sys.modules: from zoo.feature.image import ImageSet if "zoo.feature.text.text_set.TextSet" not in sys.modules: from zoo.feature.text import TextSet # if type(input) is ImageSet: if isinstance(input, ImageSet): jset = callBigDlFunc(self.bigdl_type, "transformImageSet", self.value, input) return ImageSet(jvalue=jset) elif isinstance(input, TextSet): jset = callBigDlFunc(self.bigdl_type, "transformTextSet", self.value, input) return TextSet(jvalue=jset)
def predict(self, x, batch_per_thread=4, distributed=True): """ Use a model to do prediction. # Arguments x: Prediction data. A Numpy array or RDD of Sample or ImageSet. batch_per_thread: The default value is 4. When distributed is True,the total batch size is batch_per_thread * rdd.getNumPartitions. When distributed is False the total batch size is batch_per_thread * numOfCores. distributed: Boolean. Whether to do prediction in distributed mode or local mode. Default is True. In local mode, x must be a Numpy array. """ if isinstance(x, ImageSet) or isinstance(x, TextSet): results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, x, batch_per_thread) return ImageSet(results) if isinstance(x, ImageSet) else TextSet(results) if distributed: if isinstance(x, np.ndarray): data_rdd = to_sample_rdd(x, np.zeros([x.shape[0]])) elif isinstance(x, RDD): data_rdd = x else: raise TypeError("Unsupported prediction data type: %s" % type(x)) results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, data_rdd, batch_per_thread) return results.map(lambda result: Layer.convert_output(result)) else: if isinstance(x, np.ndarray) or isinstance(x, list): results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, self._to_jtensors(x), batch_per_thread) return [Layer.convert_output(result) for result in results] else: raise TypeError("Unsupported prediction data type: %s" % type(x))
def predict(self, x, batch_size=-1, distributed=True): """ Use a model to do prediction. # Arguments x: Prediction data. A Numpy array or RDD of Sample or ImageSet. batch_size: When distributed is True, the default value is 4 * rdd.getNumPartitions. When distributed is False the default value is 4 * numOfCores. If you want to tune the batch_size, you should make sure its value can be divisible by rdd.getNumPartitions(distributed=True) or numOfCores(distributed=False) distributed: Boolean. Whether to do prediction in distributed mode or local mode. Default is True. In local mode, x must be a Numpy array. """ if isinstance(x, ImageSet): results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, x, batch_size) return ImageSet(results) if distributed: if isinstance(x, np.ndarray): data_rdd = to_sample_rdd(x, np.zeros([x.shape[0]])) elif isinstance(x, RDD): data_rdd = x else: raise TypeError("Unsupported prediction data type: %s" % type(x)) results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, data_rdd, batch_size) return results.map(lambda result: Layer.convert_output(result)) else: if isinstance(x, np.ndarray) or isinstance(x, list): results = callBigDlFunc(self.bigdl_type, "zooPredict", self.value, self._to_jtensors(x), batch_size) return [Layer.convert_output(result) for result in results] else: raise TypeError("Unsupported prediction data type: %s" % type(x))
def predict(model_path, image_path, top_n): sc = init_nncontext( "Image classification inference example using int8 quantized model") images = ImageSet.read(image_path, sc, image_codec=1) model = ImageClassifier.load_model(model_path) output = model.predict_image_set(images) label_map = model.get_config().label_map() # list of images composing uri and results in tuple format predicts = output.get_predict().collect() sequential = Sequential() sequential.add(Activation("softmax", input_shape=predicts[0][1][0].shape)) for pre in predicts: (uri, probs) = pre out = sequential.forward(probs[0]) sortedProbs = [(prob, index) for index, prob in enumerate(out)] sortedProbs.sort() print("Image : %s, top %d prediction result" % (uri, top_n)) for i in range(top_n): print( "\t%s, %f" % (label_map[sortedProbs[999 - i][1]], sortedProbs[999 - i][0]))
if __name__ == "__main__": parser = OptionParser() parser.add_option("--image", type=str, dest="img_path", help="The path where the images are stored, " "can be either a folder or an image path") parser.add_option("--model", type=str, dest="model_path", help="Path to the TensorFlow model file") (options, args) = parser.parse_args(sys.argv) sc = init_nncontext("OpenVINO Object Detection Inference Example") images = ImageSet.read(options.img_path, sc, resize_height=600, resize_width=600).get_image().collect() input_data = np.concatenate( [image.reshape((1, 1) + image.shape) for image in images], axis=0) model_path = options.model_path model = InferenceModel() model.load_openvino(model_path, weight_path=model_path[:model_path.rindex(".")] + ".bin") predictions = model.predict(input_data) # Print the detection result of the first image. print(predictions[0])