Unduh pytorch2keras - Unduh Kode Sumber pytorch2keras

Pytorch2keras

Pytorch to Keras Model Converter.

Instalasi

 pip install pytorch2keras

Pemberitahuan penting

Untuk menggunakan konverter dengan benar, silakan, buat perubahan di ~/.keras/keras.json Anda:

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

Tensorflow.js

Untuk konversi yang tepat ke format TensorFlow.js, silakan gunakan names='short' .

Berikut adalah instruksi singkat cara mendapatkan model tensorflow.js:

Pertama -tama, Anda harus mengonversi model Anda menjadi keras dengan konverter ini:

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

Sekarang Anda memiliki model keras. Anda dapat menyimpannya sebagai file H5 dan kemudian mengonversinya dengan tensorflowjs_converter tetapi kadang -kadang tidak berhasil. Sebagai alternatif, Anda mungkin mendapatkan grafik TensorFlow dan menyimpannya sebagai model beku:

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

Anda akan melihat nama lapisan output, jadi, sekarang saatnya untuk mengonversi my_model.pb ke model TFJS:

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

Itu saja!

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

Cara menggunakan

Ini adalah konverter grafik pytorch ke model keras (tensorflow backend).

Pertama, kita perlu memuat (atau membuat) model Pytorch yang valid:

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

Langkah selanjutnya - Buat variabel dummy dengan bentuk yang benar:

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

Kami menggunakan dummy-variable untuk melacak model (dengan 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 )

Anda juga dapat mengatur dimensi H dan W menjadi tidak ada untuk membuat model-agnostik model Anda (misalnya NetowRK sepenuhnya konvolusional):

 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 )

Itu saja! Jika semua modul telah dikonversi dengan benar, model Keras akan disimpan dalam variabel k_model .

API

Berikut adalah satu -satunya metode pytorch_to_keras dari modul pytorch2keras .

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

Opsi:

model - model pytorch (nn.module) untuk dikonversi;
args - Daftar variabel dummy dengan bentuk yang tepat;
Daftar input_shapes - (eksperimental) dengan bentuk overrided untuk input;
change_ordering - (eksperimental) boolean, jika diaktifkan, konverter akan mencoba mengubah BCHW ke BHWC
verbose - boolean, log konversi terperinci
name_policy - (Eksperimental) Pilihan dari [ keep , short , random ]. Pemilih menetapkan kebijakan penamaan lapisan target.

Lapisan yang didukung

Aktivasi:
- Relu
- LEAKYRELU
- Selu
- Sigmoid
- Softmax
- Tanh
Konstanta
Konvolusi:
- Conv2d
- Convtrsnpose2d
Elemen-bijaksana:
- Menambahkan
- MUL
- Sub
- Div
Linear
Normalisasi:
- Batchnorm2d
- Instancenorm2d
Poolings:
- Maxpool2d
- Avgpool2d
- Global maxpool2d (pooling adaptif untuk membentuk [1, 1])