Keras to TensorFlow (Python): nefunguje převod

Keras to TensorFlow (Python): nefunguje převod
« kdy: 02. 01. 2020, 11:02:36 »
Takze do noveho ruku mam novy chalange. Na uvod poprosim len komentare k veci.
Vygeneroval som .h5 a hdf5 siet pomocov mnou upraveneho kodu
Rad by som to skonvertoval na tensorflow pd idealne to yolo formatu (nie je podmienka ale potesilo by).
Vyskusal som co google ponukol ale bez uspechu.

Kód: [Vybrat]
from keras import backend as K

import tensorflow as tf
from import freeze_graph
from import optimize_for_inference_lib
from keras.models import load_model



tf.train.write_graph(K.get_session().graph_def, 'out', MODEL_NAME + '_graph.pbtxt')

tf.train.Saver().save(K.get_session(), 'out/' + MODEL_NAME + '.chkp')

freeze_graph.freeze_graph('out/' + MODEL_NAME + '_graph.pbtxt', None, False, 'out/' + MODEL_NAME + '.chkp', output_node_name, "save/restore_all", "save/Const:0", 'out1/frozen_' + MODEL_NAME + '.pb', True, "")

input_graph_def = tf.GraphDef()
with tf.gfile.Open('out1/frozen_' + MODEL_NAME + '.pb', "rb") as f:

output_graph_def = optimize_for_inference_lib.optimize_for_inference(
            input_graph_def, input_node_names, [output_node_name],

with tf.gfile.FastGFile('out1/opt_' + MODEL_NAME + '.pb', "wb") as f:

print("graph saved!")

hadze "ValueError: Cannot create group in read only mode."
a je jedno ci skusam .h5 alebo .hdf5

druhy kod ktory som nasiel je

Kód: [Vybrat]
import tensorflow as tf
from tensorflow.python.framework import graph_util
from tensorflow.python.framework import graph_io
from pathlib import Path
from absl import app
from absl import flags
from absl import logging
import keras
from keras import backend as K
from keras.models import model_from_json, model_from_yaml, load_model


flags.DEFINE_string('input_model', "C:\GeorgeYOLO\Data\on350Images\model.h5", 'Path to the input model.')
flags.DEFINE_string('input_model_json', None, 'Path to the input model "C:\GeorgeYOLO\Data\on350Images\data.json" '
                                              'architecture in json format.')
flags.DEFINE_string('input_model_yaml', "C:\GeorgeYOLO\Data\on350Images\data.yaml", 'Path to the input model '
                                              'architecture in yaml format.')
flags.DEFINE_string('output_model', "C:\GeorgeYOLO\Data\on350Images\model.pb", 'Path where the converted model will '
                                          'be stored.')
flags.DEFINE_boolean('save_graph_def', False,
                     'Whether to save the graphdef.pbtxt file which contains '
                     'the graph definition in ASCII format.')
flags.DEFINE_string('output_nodes_prefix', None,
                    'If set, the output nodes will be renamed to '
                    '`output_nodes_prefix`+i, where `i` will numerate the '
                    'number of of output nodes of the network.')
flags.DEFINE_boolean('quantize', False,
                     'If set, the resultant TensorFlow graph weights will be '
                     'converted from float into eight-bit equivalents. See '
                     'documentation here: '
flags.DEFINE_boolean('channels_first', False,
                     'Whether channels are the first dimension of a tensor. '
                     'The default is TensorFlow behaviour where channels are '
                     'the last dimension.')
flags.DEFINE_boolean('output_meta_ckpt', False,
                     'If set to True, exports the model as .meta, .index, and '
                     '.data files, with a checkpoint file. These can be later '
                     'loaded in TensorFlow to continue training.')


def load_model(input_model_path, input_json_path=None, input_yaml_path=None):
    if not Path(input_model_path).exists():
        raise FileNotFoundError(
            'Model file `{}` does not exist.'.format(input_model_path))
        model = keras.models.load_model(input_model_path)
        return model
    except FileNotFoundError as err:
        logging.error('Input mode file (%s) does not exist.', FLAGS.input_model)
        raise err
    except ValueError as wrong_file_err:
        if input_json_path:
            if not Path(input_json_path).exists():
                raise FileNotFoundError(
                    'Model description json file `{}` does not exist.'.format(
                model = model_from_json(open(str(input_json_path)).read())
                return model
            except Exception as err:
                logging.error("Couldn't load model from json.")
                raise err
        elif input_yaml_path:
            if not Path(input_yaml_path).exists():
                raise FileNotFoundError(
                    'Model description yaml file `{}` does not exist.'.format(
                model = model_from_yaml(open(str(input_yaml_path)).read())
                return model
            except Exception as err:
                logging.error("Couldn't load model from yaml.")
                raise err
                'Input file specified only holds the weights, and not '
                'the model definition. Save the model using '
                ' which will contain the network '
                'architecture as well as its weights. '
                'If the model is saved using the '
                'model.save_weights(filename) function, either '
                'input_model_json or input_model_yaml flags should be set to '
                'to import the network architecture prior to loading the '
                'weights. \n'
                'Check the keras documentation for more details '
            raise wrong_file_err

def main(args):
    # If output_model path is relative and in cwd, make it absolute from root
    output_model = FLAGS.output_model
    if str(Path(output_model).parent) == '.':
        output_model = str((Path.cwd() / output_model))

    output_fld = Path(output_model).parent
    output_model_name = Path(output_model).name
    output_model_stem = Path(output_model).stem
    output_model_pbtxt_name = output_model_stem + '.pbtxt'

    # Create output directory if it does not exist
    Path(output_model).parent.mkdir(parents=True, exist_ok=True)

    if FLAGS.channels_first:

    model = load_model(FLAGS.input_model, FLAGS.input_model_json, FLAGS.input_model_yaml)

    # TODO(amirabdi): Support networks with multiple inputs
    orig_output_node_names = [ for node in model.outputs]
    if FLAGS.output_nodes_prefix:
        num_output = len(orig_output_node_names)
        pred = [None] * num_output
        converted_output_node_names = [None] * num_output

        # Create dummy tf nodes to rename output
        for i in range(num_output):
            converted_output_node_names[i] = '{}{}'.format(
                FLAGS.output_nodes_prefix, i)
            pred[i] = tf.identity(model.outputs[i],
        converted_output_node_names = orig_output_node_names'Converted output node names are: %s',
    sess = K.get_session()
    if FLAGS.output_meta_ckpt:
        saver = tf.train.Saver(), str(output_fld / output_model_stem))

    if FLAGS.save_graph_def:
        tf.train.write_graph(sess.graph.as_graph_def(), str(output_fld),
                             output_model_pbtxt_name, as_text=True)'Saved the graph definition in ascii format at %s',
                     str(Path(output_fld) / output_model_pbtxt_name))

    if FLAGS.quantize:
        from import TransformGraph
        transforms = ["quantize_weights", "quantize_nodes"]
        transformed_graph_def = TransformGraph(sess.graph.as_graph_def(), [],
        constant_graph = graph_util.convert_variables_to_constants(
        constant_graph = graph_util.convert_variables_to_constants(

    graph_io.write_graph(constant_graph, str(output_fld), output_model_name,
                         as_text=False)'Saved the freezed graph at %s',
                 str(Path(output_fld) / output_model_name))

if __name__ == "__main__":
tam je to o tom istom bud vracia hadze "ValueError: Cannot create group in read only mode." ak pouzijem .h5 pripadne NameError: name 'yolo_head' is not defined ak idem skrz json alebo skusam .hdf5

Nemam ani len tusenia ci je chyba v generovani .h5  a chyba mi parameter ale skusal som aj
ModelCheckpoint(filepath, monitor='val_loss', verbose=2, save_best_only=True, save_weights_only=False, mode='auto', period=1)
ModelCheckpoint(filepath, monitor='val_loss', verbose=2, save_best_only=False, save_weights_only=False, mode='auto', period=1)
ModelCheckpoint(filepath, monitor='val_loss', verbose=2, save_best_only=False, save_weights_only=True, mode='auto', period=1)

bez zmeny. Vedel by niekto poradit kde je chyba? Pripadne co robim zle?
Tensorflow 1.15
Windows 10
Python 3.6.4

« Poslední změna: 02. 01. 2020, 13:26:37 od Petr Krčmář »

Re:Keras to TensorFlow (Python): nefunguje převod
« Odpověď #1 kdy: 05. 01. 2020, 09:38:04 »
Takze si aj odpoviem a mozno to niekomu niekedy pomoze.
S YOLO je to problem (neproblem) pretoze s implementaciou kerasu vygeneruje .h5 resp. .hdf5 .
Tento subor je mozne rovno pouzit ale pokial nepouzivame aplikaciu s tensorflowom je lepsie konvertovat model v mojom pripade do tensorflow formatu pd . Na to je potrebne graf zmrazit.
Je to mozne pomocov tohoto prikazu
Kód: [Vybrat]
python --input_type image_tensor --pipeline_config_path training/faster_rcnn_inception_v2_coco.config --trained_checkpoint_prefix training/model.ckpt-5729 --output_directory inference_graph
kde  faster_rcnn_inception_v2_coco.config je nutne zamenit za configuraciu ktoru uzivate pouzil pre generovanie modelu a 5729 - je cislo kroku ktory chceme zamrazit. Potom to ide bez problemu aj na Windows.

Poznamka : Na GTX 1660 to jednoduchu siet s 2 triedamy po 100 obrazkoch a 20 obrazkov na kontrolu vygenerovalo za 35 minut. Aktualna kalkulacia na 4 triedach po 200 obrazkov a 100 na kontrolu chruma uz 9 hodin.

Poznamka 2 : Velka vyhoda je v tom ze ak prerusite vypocet skrz CTRL+C a znova spustime trening pokracuje kde prestal.

Pekny den