Tensorflow Différentes manières d'exporter et d'exécuter un graphique en C ++

Pour l'importation de votre réseau formé pour le C++, vous devez exporter votre réseau pour être en mesure de le faire. Après la recherche d'un lot et de trouver presque aucune information à ce sujet, il a été précisé que nous devrions utiliser freeze_graph() pour être en mesure de le faire.

Grâce à la nouvelle version 0.7 de Tensorflow, ils ont ajouté la documentation.

Après la recherche dans la documentation, j'ai trouvé qu'il existe quelques méthodes similaires, pouvez-vous dire quelle est la différence entre freeze_graph() et:
tf.train.export_meta_graph comme elle a les mêmes paramètres, mais il semble qu'il peut également être utilisé pour l'importation de modèles de C++ (je suppose que la différence est que pour l'utilisation du fichier de sortie par cette méthode, vous ne pouvez utiliser import_graph_def() ou c'est autre chose?)

Également une question sur la façon d'utiliser write_graph():
Dans la documentation de la graph_def est donnée par sess.graph_def mais dans les exemples de freeze_graph() il est sess.graph.as_graph_def(). Quelle est la différence entre ces deux?

Cette question est liée à ce problème.

Merci!

source d'informationauteur Hamed MP

  1. 26

    Voici ma solution en utilisant la V2 de points de contrôle introduites dans TF 0.12.

    Il n'y a pas besoin de convertir l'ensemble des variables constantes ou geler le graphique.

    Juste pour plus de clarté, une V2 de point de contrôle ressemble à ça dans mon répertoire,models: 

    checkpoint  # some information on the name of the files in the checkpoint
my-model.data-00000-of-00001  # the saved weights
my-model.index  # probably definition of data layout in the previous file
my-model.meta  # protobuf of the graph (nodes and topology info)

    Partie Python (économie)

    with tf.Session() as sess:
    tf.train.Saver(tf.trainable_variables()).save(sess, 'models/my-model')

    Si vous créez le Saver avec tf.trainable_variables()vous pouvez vous épargner les maux de tête et de l'espace de stockage. Mais peut-être que certains des modèles plus compliqués besoin de toutes les données à enregistrer, puis supprimer cet argument pour Saverassurez-vous que vous êtes en train de créer le Saver après votre graphe est créé. Il est également très sage de donner toutes les variables/couches des noms propres, sinon vous pouvez exécuter dans différents problèmes.

    Partie Python (inférence)

    with tf.Session() as sess:
    saver = tf.train.import_meta_graph('models/my-model.meta')
    saver.restore(sess, tf.train.latest_checkpoint('models/'))
    outputTensors = sess.run(outputOps, feed_dict=feedDict)

    C++ partie (inférence)

    Noter que checkpointPath n'est pas un chemin d'accès à tous les fichiers existants, juste de leur préfixe commun. Si par erreur vous mettez là le chemin de la .index fichier, TF ne vais pas vous dire que c'était faux, mais il va mourir lors de l'inférence en raison de variables non initialisées.

    #include <tensorflow/core/public/session.h>
#include <tensorflow/core/protobuf/meta_graph.pb.h>
using namespace std;
using namespace tensorflow;
...
//set up your input paths
const string pathToGraph = "models/my-model.meta"
const string checkpointPath = "models/my-model";
...
auto session = NewSession(SessionOptions());
if (session == nullptr) {
throw runtime_error("Could not create Tensorflow session.");
}
Status status;
//Read in the protobuf graph we exported
MetaGraphDef graph_def;
status = ReadBinaryProto(Env::Default(), pathToGraph, &graph_def);
if (!status.ok()) {
throw runtime_error("Error reading graph definition from " + pathToGraph + ": " + status.ToString());
}
//Add the graph to the session
status = session->Create(graph_def.graph_def());
if (!status.ok()) {
throw runtime_error("Error creating graph: " + status.ToString());
}
//Read weights from the saved checkpoint
Tensor checkpointPathTensor(DT_STRING, TensorShape());
checkpointPathTensor.scalar<std::string>()() = checkpointPath;
status = session->Run(
{{ graph_def.saver_def().filename_tensor_name(), checkpointPathTensor },},
{},
{graph_def.saver_def().restore_op_name()},
nullptr);
if (!status.ok()) {
throw runtime_error("Error loading checkpoint from " + checkpointPath + ": " + status.ToString());
}
//and run the inference to your liking
auto feedDict = ...
auto outputOps = ...
std::vector<tensorflow::Tensor> outputTensors;
status = session->Run(feedDict, outputOps, {}, &outputTensors);
  2. 15

    Pour prédire (et tous les autres opérations), vous pouvez faire quelque chose comme ceci:

    Tout d'abord en python, vous devriez nom vos variables ou de l'exploitation pour l'utilisation future

    self.init = tf.initialize_variables(tf.all_variables(), name="nInit")

    Après la formation, les calculs de donc.. quand vous avez votre les variables assignées aller à travers eux tous et enregistrer en tant que constantes à votre graphique. (presque la même chose peut être fait avec ce gel de l'outil, mais j'ai l'habitude de le faire par moi-même, cochez la case "nom=nWeights" dans la py et de la rpc ci-dessous)

    def save(self, filename):
for variable in tf.trainable_variables():
tensor = tf.constant(variable.eval())
tf.assign(variable, tensor, name="nWeights")
tf.train.write_graph(self.sess.graph_def, 'graph/', 'my_graph.pb', as_text=False)

    Allez maintenant c++ et de la charge de notre graphique et charger des variables à partir enregistré constantes:

    void load(std::string my_model) {
auto load_graph_status =
ReadBinaryProto(tensorflow::Env::Default(), my_model, &graph_def);
auto session_status = session->Create(graph_def);
std::vector<tensorflow::Tensor> out;
std::vector<string> vNames;
int node_count = graph_def.node_size();
for (int i = 0; i < node_count; i++) {
auto n = graph_def.node(i);
if (n.name().find("nWeights") != std::string::npos) {
vNames.push_back(n.name());
}
}
session->Run({}, vNames, {}, &out);

    Maintenant, vous avez toutes vos neurones poids net ou d'autres variables chargé.

    De la même manière, vous pouvez effectuer d'autres opérations (rappelez-vous au sujet des noms?); faire l'entrée et la sortie des tenseurs de bonne taille, le remplir d'entrée du tenseur de données et l'exécution de la session comme suit:

    auto operationStatus = session->Run(input, {"put_your_operation_here"}, {}, &out);