pytorch2keras Download - pytorch2keras Quellcode Download

Pytorch2keras

Pytorch zum Keras -Modellwandler.

Installation

 pip install pytorch2keras

Wichtige Bekanntmachung

Um den Konverter ordnungsgemäß zu verwenden, ändern Sie bitte Änderungen in Ihrem ~/.keras/keras.json :

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

Tensorflow.js

Für die ordnungsgemäße Konvertierung in ein TensorFlow.js -Format verwenden Sie bitte die neuen names='short' .

Hier finden Sie eine kurze Anweisung, wie Sie ein TensorFlow.js -Modell erhalten:

Zunächst müssen Sie Ihr Modell mit diesem Konverter in Keras konvertieren:

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

Jetzt haben Sie ein Kerasmodell. Sie können es als H5 -Datei speichern und dann mit tensorflowjs_converter konvertieren, aber es funktioniert manchmal nicht. Als Alternative können Sie den TensorFlow -Diagramm erhalten und als gefrorenes Modell speichern:

 # 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 ])

Sie sehen den Namen Ausgangsschicht. Jetzt ist es Zeit, my_model.pb in das TFJS -Modell umzuwandeln:

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

Das ist alles!

 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 ) ;

Wie man benutzt

Es ist der Konverter des Pytorch -Diagramms zu einem Keras -Modell (TensorFlow Backend).

Zunächst müssen wir ein gültiges Pytorch -Modell laden (oder erstellen):

 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))

Der nächste Schritt - Erstellen Sie eine Dummy -Variable mit korrekter Form:

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

Wir verwenden das Dummy-Variable, um das Modell (mit Jit.Trace) zu verfolgen:

 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 )

Sie können auch H- und W-Dimensionen auf keine festlegen, um Ihr Modell form-Agnostic (z.

 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 )

Das ist alles! Wenn alle Module ordnungsgemäß konvertiert wurden, wird das Keras -Modell in der k_model -Variablen gespeichert.

API

Hier ist die einzige Methode pytorch_to_keras aus pytorch2keras -Modul.

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

Optionen:

model - ein Pytorch -Modell (nn.module) zum Konvertieren;
args - eine Liste von Dummy -Variablen mit richtigen Formen;
input_shapes - (experimentelle) Liste mit überschriebenen Formen für Eingaben;
change_ordering - (experimentell) boolean, falls aktiviert, versucht der Konverter, BCHW in BHWC zu ändern
verbose - Boolescher, detailliertes Protokoll der Konvertierung
name_policy - (experimental) Auswahl von [ keep , short , random ]. Der Selektor hat die Zielschicht -Benennungsrichtlinie festgelegt.

Unterstützte Schichten

Aktivierungen:
- Relu
- Leakyrelu
- Selu
- Sigmoid
- Softmax
- Tanh
Konstanten
Konvolutionen:
- Conv2d
- Curprsnpose2d
Element:
- Hinzufügen
- Mul
- Sub
- Div
Linear
Normalisierungen:
- Batchnorm2d
- Instancenorm2d
Poolings:
- Maxpool2d
- Avgpool2d
- Global Maxpool2d (adaptive Pooling zu Form [1, 1])