torchview

torche

TorchView fournit une visualisation des modèles Pytorch sous la forme de graphiques visuels. La visualisation comprend des tenseurs, des modules, des transactions de torche et des informations telles que les formes d'entrée / sortie.

Version pytorch de plot_model of keras (et plus)

Prend en charge les versions Pytorch $ geq $ 1.7.

Fonctionnalités utiles

Installation

Tout d'abord, vous devez installer Graphviz,

pip install graphviz

Pour que l'interface Python de Graphiz fonctionne, vous devez faire fonctionner la commande de disposition des points dans votre système. S'il n'est pas déjà installé, je vous suggère d'exécuter le dépèdre suivant sur votre système d'exploitation,

Distro Linux basée à Debian (par exemple Ubuntu):

apt-get install graphviz

Windows:

choco install graphviz

macos

brew install graphviz

Voir plus de détails ici

Ensuite, continuez avec l'installation de la torche à l'aide de PIP

pip install torchview

ou si vous voulez via conda

conda install -c conda-forge torchview

ou si vous voulez la version la plus récente, installez-vous directement à partir de repo

pip install git+https://github.com/mert-kurttutan/torchview.git

Comment utiliser

 from torchview import draw_graph

model = MLP ()
batch_size = 2
# device='meta' -> no memory is consumed for visualization
model_graph = draw_graph ( model , input_size = ( batch_size , 128 ), device = 'meta' )
model_graph . visual_graph 

Exemples de cahiers

Pour plus d'exemples, voir Colab Notebooks ci-dessous,

Note de carnet d'introduction:

Modèles de vision par ordinateur:

Modèles NLP:

Remarque: les visuels Graphviz de sortie renvoient les images avec les tailles souhaitées. Mais parfois, sur VSCODE, certaines formes sont recadrées en raison de la grande taille et du rendu SVG par VSCODE. Pour résoudre ce problème, je vous suggère d'exécuter ce qui suit

 import graphviz
graphviz . set_jupyter_format ( 'png' )

Ce problème ne se produit pas sur d'autres plateformes, par exemple JupyterLab ou Google Colab.

Fonctionnalités prises en charge

• Presque tous les modèles, RNN, séquentiels, saut de connexion, embrassement des modèles de visage
• Prise en charge des méta-tenseurs -> Pas de consommation de mémoire (pour les très grands modèles) (version pytorch $ geq $ 1.13).
• Montre les opérations entre les tenseurs (en plus des appels de module)
• Fonction de roulement / déroulante. Les modules utilisés récursivement peuvent être roulés visuellement, voir ci-dessous.
• Ensemble diversifié de types d'entrées / sorties, par exemple la structure de données imbriquée (dict, liste, etc.), sorties de tokenzer en étreinte

Documentation

 def draw_graph (
    model : nn . Module ,
    input_data : INPUT_DATA_TYPE | None = None ,
    input_size : INPUT_SIZE_TYPE | None = None ,
    graph_name : str = 'model' ,
    depth : int | float = 3 ,
    device : torch . device | str | None = None ,
    dtypes : list [ torch . dtype ] | None = None ,
    mode : str | None = None ,
    strict : bool = True ,
    expand_nested : bool = False ,
    graph_dir : str | None = None ,
    hide_module_functions : bool = True ,
    hide_inner_tensors : bool = True ,
    roll : bool = False ,
    show_shapes : bool = True ,
    save_graph : bool = False ,
    filename : str | None = None ,
    directory : str = '.' ,
    ** kwargs : Any ,
) -> ComputationGraph :
    '''Returns visual representation of the input Pytorch Module with
    ComputationGraph object. ComputationGraph object contains:

    1) Root nodes (usually tensor node for input tensors) which connect to all
    the other nodes of computation graph of pytorch module recorded during forward
    propagation.

    2) graphviz.Digraph object that contains visual representation of computation
    graph of pytorch module. This graph visual shows modules/ module hierarchy,
    torch_functions, shapes and tensors recorded during forward prop, for examples
    see documentation, and colab notebooks.


    Args:
        model (nn.Module):
            Pytorch model to represent visually.

        input_data (data structure containing torch.Tensor):
            input for forward method of model. Wrap it in a list for
            multiple args or in a dict or kwargs

        input_size (Sequence of Sizes):
            Shape of input data as a List/Tuple/torch.Size
            (dtypes must match model input, default is FloatTensors).
            Default: None

        graph_name (str):
            Name for graphviz.Digraph object. Also default name graphviz file
            of Graph Visualization
            Default: 'model'

        depth (int):
            Upper limit for depth of nodes to be shown in visualization.
            Depth is measured how far is module/tensor inside the module hierarchy.
            For instance, main module has depth=0, whereas submodule of main module
            has depth=1, and so on.
            Default: 3

        device (str or torch.device):
            Device to place and input tensors. Defaults to
            gpu if cuda is seen by pytorch, otherwise to cpu.
            Default: None

        dtypes (list of torch.dtype):
            Uses dtypes to set the types of input tensor if
            input size is given.

        mode (str):
            Mode of model to use for forward prop. Defaults
            to Eval mode if not given
            Default: None

        strict (bool):
            if true, graphviz visual does not allow multiple edges
            between nodes. Mutiple edge occurs e.g. when there are tensors
            from module node to module node and hiding those tensors
            Default: True
        
        expand_nested(bool):
            if true shows nested modules with dashed borders

        graph_dir (str):
            Sets the direction of visual graph
            'TB' -> Top to Bottom
            'LR' -> Left to Right
            'BT' -> Bottom to Top
            'RL' -> Right to Left
            Default: None -> TB

        hide_module_function (bool):
            Determines whether to hide module torch_functions. Some
            modules consist only of torch_functions (no submodule),
            e.g. nn.Conv2d.
            True => Dont include module functions in graphviz
            False => Include modules function in graphviz
            Default: True

        hide_inner_tensors (bool):
            Inner tensor is all the tensors of computation graph
            but input and output tensors
            True => Does not show inner tensors in graphviz
            False => Shows inner tensors in graphviz
            Default: True

        roll (bool):
            If true, rolls recursive modules.
            Default: False

        show_shapes (bool):
            True => Show shape of tensor, input, and output
            False => Dont show
            Default: True

        save_graph (bool):
            True => Saves output file of graphviz graph
            False => Does not save
            Default: False

        filename (str):
            name of the file to store dot syntax representation and
            image file of graphviz graph. Defaults to graph_name

        directory (str):
            directory in which to store graphviz output files.
            Default: .

    Returns:
        ComputationGraph object that contains visualization of the input
        pytorch model in the form of graphviz Digraph object
    ''' 

Exemples

Version roulée des réseaux récursifs

 from torchview import draw_graph

model_graph = draw_graph (
    SimpleRNN (), input_size = ( 2 , 3 ),
    graph_name = 'RecursiveNet' ,
    roll = True
)
model_graph . visual_graph 

Afficher / masquer les tenseurs et fonctionnels intermédiaires (cachés)

 # Show inner tensors and Functionals
model_graph = draw_graph (
    MLP (), input_size = ( 2 , 128 ),
    graph_name = 'MLP' ,
    hide_inner_tensors = False ,
    hide_module_functions = False ,
)

model_graph . visual_graph 

Resnet / Skip Connection / Prise en charge des opérations de torche / modules imbriqués

 import torchvision

model_graph = draw_graph ( resnet18 (), input_size = ( 1 , 3 , 32 , 32 ), expand_nested = True )
model_graph . visual_graph 

FAIRE

• Informations sur les paramètres du module d'affichage
• Prise en charge du réseau neuronal graphique (GNN)
• Prise en charge des bords non dirigés pour GNNS
• Prise en charge des fonctions basées sur la torche ¹

Contributif

Tous les problèmes et les demandes de traction sont très appréciés! Si vous vous demandez comment construire le projet:

• Torchview est activement développé en utilisant la dernière version de Python.
• Les changements doivent être en arrière compatibles avec Python 3.7 et suivront les conseils de fin de vie de Python pour les anciennes versions.
• Exécutez pip install -r requirements-dev.txt . Nous utilisons les dernières versions de tous les packages de développement.
• Pour exécuter des tests unitaires, exécutez pytest .
• Pour mettre à jour les fichiers de sortie attendus, exécutez pytest --overwrite .
• Pour sauter des tests de fichiers de sortie, utilisez pytest --no-output

Références

• Les pièces liées au traitement et à la validation des entrées sont prises / inspirées du référentiel Torchinfo !!.
• De nombreuses pièces liées au logiciel (tests par exemple) sont également prises / inspirées du référentiel Torchinfo. Tellement grand merci à @tyleryep !!!
• L'algorithme pour la construction de graphiques visuels est grâce à __torch_function__ et à la sous-classe torch.Tensor . Un grand merci à tous ceux qui ont développé cette API !!.

Notes de bas de page

1. Ici, les fonctions basées sur la torche se réfèrent à toute fonction qui utilise uniquement des fonctions et des modules de torche. C'est plus général que les modules. ↩