pytorch2keras

pytorch2keras

Convertisseur de modèle Pytorch vers Keras.

Installation

 pip install pytorch2keras 

Avis important

Pour utiliser correctement le convertisseur, veuillez apporter des modifications à votre ~/.keras/keras.json :

 ...
"backend" : " tensorflow " ,
"image_data_format" : " channels_first " ,
... 

Tensorflow.js

Pour la conversion appropriée au format tensorflow.js, veuillez utiliser les nouveaux names='short' .

Voici une courte instruction Comment obtenir un modèle Tensorflow.js:

1. Tout d'abord, vous devez convertir votre modèle en keras avec ce convertisseur:

 k_model = pytorch_to_keras ( model , input_var , [( 10 , 32 , 32 ,)], verbose = True , names = 'short' )  

2. Vous avez maintenant un modèle Keras. Vous pouvez l'enregistrer en tant que fichier H5, puis le convertir avec tensorflowjs_converter mais cela ne fonctionne pas parfois. Comme alternative, vous pouvez obtenir un graphique TensorFlow et l'enregistrer en tant que modèle gelé:

 # Function below copied from here:
# https://stackoverflow.com/questions/45466020/how-to-export-keras-h5-to-tensorflow-pb 
def freeze_session ( session , keep_var_names = None , output_names = None , clear_devices = True ):
    """
    Freezes the state of a session into a pruned computation graph.

    Creates a new computation graph where variable nodes are replaced by
    constants taking their current value in the session. The new graph will be
    pruned so subgraphs that are not necessary to compute the requested
    outputs are removed.
    @param session The TensorFlow session to be frozen.
    @param keep_var_names A list of variable names that should not be frozen,
                          or None to freeze all the variables in the graph.
    @param output_names Names of the relevant graph outputs.
    @param clear_devices Remove the device directives from the graph for better portability.
    @return The frozen graph definition.
    """
    from tensorflow . python . framework . graph_util import convert_variables_to_constants
    graph = session . graph
    with graph . as_default ():
        freeze_var_names = 
            list ( set ( v . op . name for v in tf . global_variables ()). difference ( keep_var_names or []))
        output_names = output_names or []
        output_names += [ v . op . name for v in tf . global_variables ()]
        input_graph_def = graph . as_graph_def ()
        if clear_devices :
            for node in input_graph_def . node :
                node . device = ""
        frozen_graph = convert_variables_to_constants ( session , input_graph_def ,
                                                      output_names , freeze_var_names )
        return frozen_graph


from keras import backend as K
import tensorflow as tf
frozen_graph = freeze_session ( K . get_session (),
                              output_names = [ out . op . name for out in k_model . outputs ])

tf . train . write_graph ( frozen_graph , "." , "my_model.pb" , as_text = False )
print ([ i for i in k_model . outputs ])

3. Vous verrez le nom de la couche de sortie, donc, il est maintenant temps de convertir my_model.pb en modèle TFJS:

tensorflowjs_converter  
    --input_format=tf_frozen_model 
    --output_node_names= ' TANHTObs/Tanh ' 
    my_model.pb 
    model_tfjs

4. C'est tout!

 const MODEL_URL = `model_tfjs/tensorflowjs_model.pb` ;
const WEIGHTS_URL = `model_tfjs/weights_manifest.json` ;
const model = await tf . loadFrozenModel ( MODEL_URL , WEIGHTS_URL ) ; 

Comment utiliser

C'est le convertisseur du graphique Pytorch en un modèle Keras (TensorFlow Backend).

Tout d'abord, nous devons charger (ou créer) un modèle Pytorch valide:

 class TestConv2d ( nn . Module ):
    """
    Module for Conv2d testing
    """

    def __init__ ( self , inp = 10 , out = 16 , kernel_size = 3 ):
        super ( TestConv2d , self ). __init__ ()
        self . conv2d = nn . Conv2d ( inp , out , stride = 1 , kernel_size = kernel_size , bias = True )

    def forward ( self , x ):
        x = self . conv2d ( x )
        return x

model = TestConv2d ()

# load weights here
# model.load_state_dict(torch.load(path_to_weights.pth))

L'étape suivante - Créez une variable factice avec une forme correcte:

 input_np = np . random . uniform ( 0 , 1 , ( 1 , 10 , 32 , 32 ))
input_var = Variable ( torch . FloatTensor ( input_np ))

Nous utilisons la variable factice pour tracer le modèle (avec jit.trace):

 from pytorch2keras import pytorch_to_keras
# we should specify shape of the input tensor
k_model = pytorch_to_keras ( model , input_var , [( 10 , 32 , 32 ,)], verbose = True )  

Vous pouvez également définir les dimensions H et W sur Nul pour rendre votre modèle en forme de forme (par exemple, Netowrk entièrement convolutionnel):

 from pytorch2keras . converter import pytorch_to_keras
# we should specify shape of the input tensor
k_model = pytorch_to_keras ( model , input_var , [( 10 , None , None ,)], verbose = True )  

C'est tout! Si tous les modules se sont convertis correctement, le modèle Keras sera stocké dans la variable k_model .

API

Voici la seule méthode pytorch_to_keras du module pytorch2keras .

 def pytorch_to_keras (
    model , args , input_shapes = None ,
    change_ordering = False , verbose = False , name_policy = None ,
):

Options:

• model - Un modèle pytorch (nn.module) à convertir;
• args - une liste de variables muettes avec des formes appropriées;
• input_shapes - (Expérimental) Liste avec des formes remplacées pour les entrées;
• change_ordering - (expérimental) Boolean, si elle est activée, le convertisseur essaiera de changer BCHW en BHWC
• verbose - booléen, journal détaillé de conversion
• name_policy - (expérimental) Choix de [ keep , short , random ]. Le sélecteur définit la politique de dénomination de la couche cible.

Couches prises en charge

• Activations:

  • Relu
  • Fallyrelu
  • Selu
  • Sigmoïde
  • Maxa
  • Tanh

• Constantes

• Convolutions:

  • Conv2D
  • Convtrsnpose2d

• En termes d'élément:

  • Ajouter
  • Mâle
  • Sous
  • Div

• Linéaire

• Normalisations:

  • Batchnorm2d
  • InstanceNorm2d

• Pathingings:

  • Maxpool2d
  • Avgpool2d
  • Global Maxpool2d (regroupement adaptatif à façonner [1, 1])

Modèles convertis avec Pytorch2keras

• Resnet *
• VGG *
• Préresnet *
• Densenet *
• Alexnet
• Mobilenet v2

Usage

Regardez le répertoire tests .

Licence

Ce logiciel est couvert par la licence MIT.