pytorch2keras Download - pytorch2keras download de código fonte

pytorch2keras

Conversor de modelos pytorch para keras.

Instalação

 pip install pytorch2keras

Aviso importante

Para usar o conversor corretamente, faça alterações em seus ~/.keras/keras.json :

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

Tensorflow.js

Para a conversão adequada para um formato TensorFlow.js, use os novos names='short' .

Aqui está uma breve instrução de como obter um modelo Tensorflow.js:

Primeiro de tudo, você deve converter seu modelo em Keras com este conversor:

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

Agora você tem modelo Keras. Você pode salvá -lo como arquivo H5 e convertê -lo com tensorflowjs_converter , mas às vezes não funciona. Como alternativa, você pode obter gráfico de tensorflow e salvá -lo como um 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 ])

Você verá o nome da camada de saída, então agora é hora de converter o modelo my_model.pb em tfjs:

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

Isso é tudo!

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

Como usar

É o conversor do gráfico Pytorch em um modelo Keras (back -end Tensorflow).

Em primeiro lugar, precisamos carregar (ou criar) um 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))

A próxima etapa - crie uma variável dummy com a forma correta:

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

Usamos a variável fictícia para rastrear o modelo (com 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 )

Você também pode definir as dimensões H e W nenhuma para tornar o seu modelo agnóstico (por exemplo, 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 )

Isso é tudo! Se todos os módulos tiverem convertido corretamente, o modelo Keras será armazenado na variável k_model .

API

Aqui está o único método pytorch_to_keras do módulo pytorch2keras .

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

Opções:

model - Um modelo Pytorch (nn.Module) para converter;
args - Uma lista de variáveis fictícias com formas adequadas;
Lista de input_shapes - (Experimental) com formas substituídas para entradas;
change_ordering - (Experimental) Boolean, se ativado, o conversor tentará alterar BCHW para BHWC
verbose - Boolean, registro detalhado da conversão
name_policy - (Experimental) Escolha de [ keep , short , random ]. O seletor definiu a política de nomeação da camada de destino.

Camadas suportadas

Ativações:
- Relu
- LeakyRelu
- Selu
- Sigmóide
- Softmax
- Tanh
Constantes
Convvoluções:
- Conv2d
- CONVTRSNPOSE2D
Em termos de elemento:
- Adicionar
- Mul
- Sub
- Div
Linear
Normalizações:
- BatchNorm2d
- Instancenorm2d
Poolings:
- Maxpool2d
- Avgpool2d
- Global Maxpool2D (pool adaptável para formar [1, 1])