Descargar pytorch2keras - Descargar el código fuente de pytorch2keras

pytorch2keras

Pytorch a Keras Model Converter.

Instalación

 pip install pytorch2keras

Aviso

Para usar el convertidor correctamente, por favor, realice cambios en su ~/.keras/keras.json :

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

Tensorflow.js

Para la conversión adecuada a un formato tensorflow.js, use los nuevos names='short' .

Aquí hay una breve instrucción cómo obtener un modelo TensorFlow.js:

En primer lugar, debe convertir su modelo a Keras con este convertidor:

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

Ahora tienes el modelo Keras. Puede guardarlo como archivo H5 y luego convertirlo con tensorflowjs_converter pero a veces no funciona. Como alternativa, puede obtener el gráfico TensorFlow y guardarlo como un modelo congelado:

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

Verá el nombre de la capa de salida, así que ahora es el momento de convertir my_model.pb en modelo TFJS:

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

¡Eso es todo!

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

Cómo usar

Es el convertidor de Pytorch Graph a un modelo Keras (TensorFlow Backend).

En primer lugar, necesitamos cargar (o crear) un modelo Pytorch válido:

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

El siguiente paso: cree una variable ficticia con la forma correcta:

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

Utilizamos la variable ficticia para rastrear el modelo (con 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 )

También puede establecer dimensiones H y W a ninguna para hacer que su modelo sea agnóstico (por ejemplo, NETOWRK totalmente convolucional):

 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 )

¡Eso es todo! Si todos los módulos se han convertido correctamente, el modelo Keras se almacenará en la variable k_model .

API

Aquí está el único método pytorch_to_keras del módulo pytorch2keras .

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

Opciones:

model : un modelo Pytorch (Nn.Module) para convertir;
args : una lista de variables ficticias con formas adecuadas;
input_shapes - Lista (experimental) con formas anuladas para entradas;
change_ordering - (experimental) booleano, si está habilitado, el convertidor intentará cambiar BCHW a BHWC
Leging de conversión detallado, verbose - booleano
name_policy - (experimental) opción de [ keep , short , random ]. El selector establece la política de nombres de la capa de destino.

Capas compatibles

Activaciones:
- Rehacer
- Fleatyrelu
- Selú
- Sigmoideo
- Softmax
- Tanh
Constantes
Convoluciones:
- Conv2d
- Convtrsnpose2d
En cuanto al elemento:
- Agregar
- Mul
- Sub
- Div
Lineal
Normalizaciones:
- Batchnorm2d
- Instancenorm2d
Agrupaciones:
- Maxpool2d
- AVGPOOL2D
- Global Maxpool2D (agrupación adaptativa a la forma [1, 1])