def convert(input_ops, output_ops, byte_order, bigdl_type):
"""
Convert tensorflow model to bigdl model
:param input_ops: operation list used for input, should be placeholders
:param output_ops: operations list used for output
:return: bigdl model
"""
input_names = map(lambda x: x.name.split(":")[0], input_ops)
output_names = map(lambda x: x.name.split(":")[0], output_ops)
temp = tempfile.mkdtemp()
dump_model(path=temp)
model_path = temp + '/model.pb'
bin_path = temp + '/model.bin'
model = Model.load_tensorflow(model_path, input_names, output_names,
byte_order, bin_path, bigdl_type)
try:
shutil.rmtree(temp)
except OSError as e:
if e.errno != errno.ENOENT:
raise
return model
def inference(image_path, model_path, batch_size, sc):
imageDF = NNImageReader.readImages(image_path,
sc,
resizeH=300,
resizeW=300,
image_codec=1)
getName = udf(lambda row: row[0], StringType())
transformer = ChainedPreprocessing([
RowToImageFeature(),
ImageResize(256, 256),
ImageCenterCrop(224, 224),
ImageChannelNormalize(123.0, 117.0, 104.0),
ImageMatToTensor(),
ImageFeatureToTensor()
])
model = Model.loadModel(model_path)
est = Estimator.from_bigdl(model=model, feature_preprocessing=transformer)
predictionDF = est.predict(data=imageDF,
batch_size=batch_size,
feature_cols="image").withColumn(
"name", getName(col("image")))
return predictionDF
def load_graph(self, graph_proto):
if not graph_proto:
raise ValueError("Graph proto is required")
input_nodes = list()
output_nodes = list()
tensor_map = dict()
initialized_tensors = set()
module_map = dict()
root_nodes = list()
dummy_root = Identity()()
for tensor in graph_proto.initializer:
if not tensor.name.strip():
raise ValueError("Tensor's name is required")
initialized_tensors.add(tensor.name)
tensor_data = parse_tensor_data(tensor)
tensor_map[tensor.name] = (tensor_data, tensor_data.shape)
for gin in graph_proto.input:
if gin.name not in initialized_tensors:
input_nodes.append(gin.name)
shape = tuple(
[dim.dim_value for dim in gin.type.tensor_type.shape.dim])
module_map[gin.name] = Identity()(dummy_root)
tensor_map[gin.name] = (None, shape)
for gout in graph_proto.output:
if gout.name not in initialized_tensors:
output_nodes.append(gout.name)
for node in graph_proto.node:
name = node.name.strip()
op_type = node.op_type
inputs = [tensor_map[n] for n in node.input]
outputs = node.output
prev_modules = [
module_map[n] for n in node.input
if n not in initialized_tensors
]
attrs = parse_node_attr(node)
if len(prev_modules) == 0:
root_nodes.append((name, op_type))
prev_modules = [dummy_root]
bigdl_module, outputs_shape = self._make_module_from_onnx_node(
op_type, inputs, prev_modules, attrs, outputs)
assert len(outputs) == len(outputs_shape)
for out, out_shape in zip(outputs, outputs_shape):
module_map[out] = bigdl_module
tensor_map[out] = (None, out_shape)
in_modules = [module_map[m] for m in input_nodes]
out_modules = [module_map[m] for m in output_nodes]
model = Model([dummy_root], out_modules)
return model
def load_keras(json_path=None, hdf5_path=None, by_name=False):
"""
Load a pre-trained Keras model.
:param json_path: The json path containing the keras model definition. Default is None.
:param hdf5_path: The HDF5 path containing the pre-trained keras model weights
with or without the model architecture. Default is None.
:param by_name: by default the architecture should be unchanged.
If set as True, only layers with the same name will be loaded.
:return: A BigDL model.
"""
return BModel.load_keras(json_path, hdf5_path, by_name)
def load_orca_checkpoint(self, path, version=None, prefix=None):
"""
Load existing checkpoint. To load a specific checkpoint, please provide both `version`
and `perfix`. If `version` is None, then the latest checkpoint under the specified
directory will be loaded.
:param path: Path to the existing checkpoint (or directory containing Orca checkpoint
files).
:param version: checkpoint version, which is the suffix of model.* file, i.e., for
modle.4 file, the version is 4. If it is None, then load the latest checkpoint.
:param prefix: optimMethod prefix, for example 'optimMethod-Sequentialf53bddcc'
:return:
"""
from bigdl.dllib.nn.layer import Model, Container
from bigdl.dllib.optim.optimizer import OptimMethod
from bigdl.orca.learn.utils import find_latest_checkpoint
import os
if version is None:
path, prefix, version = find_latest_checkpoint(path,
model_type="bigdl")
if path is None:
raise ValueError(
"Cannot find BigDL checkpoint, please check your checkpoint"
" path.")
else:
assert prefix is not None, "You should provide optimMethod prefix, " \
"for example 'optimMethod-TorchModelf53bddcc'"
try:
self.model = Model.load(
os.path.join(path, "model.{}".format(version)))
assert isinstance(self.model, Container), \
"The loaded model should be a Container, please check your checkpoint type."
self.optimizer = OptimMethod.load(
os.path.join(path, "{}.{}".format(prefix, version)))
except Exception:
raise ValueError(
"Cannot load BigDL checkpoint, please check your checkpoint path "
"and checkpoint type.")
self.estimator = SparkEstimator(self.model, self.optimizer,
self.model_dir)
self.nn_estimator = NNEstimator(self.model, self.loss,
self.feature_preprocessing,
self.label_preprocessing)
if self.optimizer is not None:
self.nn_estimator.setOptimMethod(self.optimizer)
self.nn_model = NNModel(
self.model, feature_preprocessing=self.feature_preprocessing)
def load_orca_checkpoint(self, path, version=None, prefix=None):
"""
Load existing checkpoint. To load a specific checkpoint, please provide both `version` and
`perfix`. If `version` is None, then the latest checkpoint will be loaded.
:param path: Path to the existing checkpoint (or directory containing Orca checkpoint
files).
:param version: checkpoint version, which is the suffix of model.* file, i.e., for
modle.4 file, the version is 4. If it is None, then load the latest checkpoint.
:param prefix: optimMethod prefix, for example 'optimMethod-TorchModelf53bddcc'.
:return:
"""
import os
from bigdl.dllib.nn.layer import Model
from bigdl.dllib.optim.optimizer import OptimMethod
from bigdl.orca.learn.utils import find_latest_checkpoint
from bigdl.orca.torch import TorchModel
if version is None:
path, prefix, version = find_latest_checkpoint(
path, model_type="pytorch")
if path is None:
raise ValueError(
"Cannot find PyTorch checkpoint, please check your checkpoint"
" path.")
else:
assert prefix is not None, "You should provide optimMethod prefix, " \
"for example 'optimMethod-TorchModelf53bddcc'"
try:
loaded_model = Model.load(
os.path.join(path, "model.{}".format(version)))
self.model = TorchModel.from_value(loaded_model.value)
self.optimizer = OptimMethod.load(
os.path.join(path, "{}.{}".format(prefix, version)))
except Exception as e:
raise ValueError(
"Cannot load PyTorch checkpoint, please check your checkpoint path "
"and checkpoint type." + str(e))
self.estimator = SparkEstimator(self.model, self.optimizer,
self.model_dir)
def inference(image_path, model_path, batch_size, sc):
imageDF = NNImageReader.readImages(image_path,
sc,
resizeH=300,
resizeW=300,
image_codec=1)
getName = udf(lambda row: row[0], StringType())
transformer = ChainedPreprocessing([
RowToImageFeature(),
ImageResize(256, 256),
ImageCenterCrop(224, 224),
ImageChannelNormalize(123.0, 117.0, 104.0),
ImageMatToTensor(),
ImageFeatureToTensor()
])
model = Model.loadModel(model_path)
classifier_model = NNClassifierModel(model, transformer)\
.setFeaturesCol("image").setBatchSize(batch_size)
predictionDF = classifier_model.transform(imageDF).withColumn(
"name", getName(col("image")))
return predictionDF
def test_model_save_and_load(self):
class SimpleTorchModel(nn.Module):
def __init__(self):
super(SimpleTorchModel, self).__init__()
self.dense1 = nn.Linear(2, 4)
self.dense2 = nn.Linear(4, 1)
def forward(self, x):
x = self.dense1(x)
x = torch.sigmoid(self.dense2(x))
return x
torch_model = SimpleTorchModel()
az_model = TorchModel.from_pytorch(torch_model)
with tempfile.TemporaryDirectory() as tmp_dir_name:
path = tmp_dir_name + "/model.obj"
az_model.save(path, True)
loaded_model = Model.load(path)
loaded_torchModel = TorchModel.from_value(loaded_model.value)
dummy_input = torch.ones(16, 2)
loaded_torchModel.forward(dummy_input.numpy())
loaded_torchModel.to_pytorch()
def _load(self, path):
return Model.loadModel(path, bigdl_type=self.bigdl_type)