Dessinez un diagramme CNN en Python
ConvNet Drawer (ajouté le 4 janvier 2018)
** Les outils suivants ont été publiés et nous vous recommandons de les utiliser. ** ** J'ai créé un outil qui illustre l'architecture lorsque le réseau de neurones convolutifs est défini comme Keras
Lorsque vous définissez un modèle dans une notation comme le modèle séquentiel de Keras, nous avons créé un outil qui illustre bien l'architecture. Il peut s'agir d'une bibliothèque dépendante car c'est un outil qui ne produit que du texte. https://github.com/yu4u/convnet-drawer
Aperçu
Utilisez Python + pydot + Graphviz pour dessiner un diagramme de l'architecture CNN. Ma motivation était de regarder https://github.com/jettan/tikz_cnn et de vouloir dessiner un diagramme similaire en Python au lieu de TeX.
Préparation
Installez pydotplus et graphviz. J'utilise conda, mais je pense que pip est correct (non vérifié).
conda install -c conda-forge pydotplus
conda install graphviz
Préparez un fichier de points approprié, chargez-le avec pydotplus, enregistrez l'image et affichez l'image. (L'image est affichée sur Jupyter. Veuillez la modifier si nécessaire.)
drawCNN.py
import pydotplus
from IPython.display import Image
graph = pydotplus.graphviz.graph_from_dot_file('dot/pytorchainer.dot')
graph.write_png('img/pytorchainer.png')
Image(graph.create_png())
pytorchainer.dot
digraph G {
Python [shape=box]
Torch
Chainer -> "Chainer v2"
Chainer -> ChainerMN
Python -> PyTorch
Torch -> PyTorch
Chainer -> PyTorch
PyTorch -> PyTorChainer
"Chainer v2" -> PyTorChainer
ChainerMN -> PyTorChainer
Ce chiffre est une fiction.[shape=plaintext]
}
Vous êtes maintenant prêt à dessiner le fichier dot de Python.
Veuillez vous référer à ce qui suit pour les spécifications du langage dot et de PyDot Plus. Résumé de la façon de dessiner des graphiques en graphviz et en langage à points PyDotPlus API Reference
Dessin CNN
Maintenant, dessinons un diagramme de l'architecture CNN. Cela dit, tout ce que vous avez à faire est d'ajouter des couches (et des flèches) écrites en langage par points. Ci-dessous, le chiffre magique pour l'ajustement de la position danse, mais pardonnez-moi s'il vous plaît.
drawCNN.py
class CNNDot():
def __init__(self):
self.layer_id = 0
self.arrow_id = 0
def get_layer_str(self, size, channels, xoffset=0.0, yoffset=0.0, fillcolor='white', caption=''):
width = size * 0.5
height = size
x = xoffset
y = height * 0.5 + yoffset
x_caption = x - width * 0.25
y_caption = -y - 0.7
layer_str = """
layer{} [
shape=polygon, sides=4, skew=-2, orientation=90,
label="", style=filled, fixedsize=true, fillcolor="{}",
width={}, height={}, pos="{},{}!"
]
""".format(self.layer_id, fillcolor, width, height, x, y)
if caption != '':
layer_str += """
layer_caption{} [
shape=plaintext, label="{}", fixedsize=true, fontsize=24,
pos="{},{}!"
]
""".format(self.layer_id, caption, x_caption, y_caption)
self.layer_id += 1
return layer_str
def get_arrow_str(self, xmin, ymin, xmax, ymax):
arrow_str = """
arrow{0}_tail [
shape=none, label="", fixedsize=true, width=0, height=0,
pos="{1},{2}!"
]
arrow{0}_head [
shape=none, label="", fixedsize=true, width=0, height=0,
pos="{3},{4}!"
]
arrow{0}_tail -> arrow{0}_head
""".format(self.arrow_id, xmin, ymin, xmax, ymax)
self.arrow_id += 1
return arrow_str
cnndot = CNNDot()
# layers
graph_data_main = cnndot.get_layer_str(3.0, 0, -1.00, fillcolor='gray') # input
graph_data_main += cnndot.get_layer_str(3.0, 0, 0.00, caption='conv') # encoder begin
graph_data_main += cnndot.get_layer_str(3.0, 0, 0.50)
graph_data_main += cnndot.get_layer_str(2.5, 0, 1.25, caption='conv')
graph_data_main += cnndot.get_layer_str(2.5, 0, 1.75)
graph_data_main += cnndot.get_layer_str(2.0, 0, 2.50, caption='conv')
graph_data_main += cnndot.get_layer_str(2.0, 0, 3.00)
graph_data_main += cnndot.get_layer_str(1.5, 0, 3.75, caption='conv')
graph_data_main += cnndot.get_layer_str(1.5, 0, 4.25)
graph_data_main += cnndot.get_layer_str(1.0, 0, 5.00, caption='conv')
graph_data_main += cnndot.get_layer_str(1.0, 0, 5.50)
graph_data_main += cnndot.get_layer_str(1.0, 0, 6.25, caption='deconv') # decoder begin
graph_data_main += cnndot.get_layer_str(1.0, 0, 6.75)
graph_data_main += cnndot.get_layer_str(1.5, 0, 7.50, caption='deconv')
graph_data_main += cnndot.get_layer_str(1.5, 0, 8.00)
graph_data_main += cnndot.get_layer_str(2.0, 0, 8.75)
graph_data_main += cnndot.get_layer_str(2.0, 0, 9.25)
graph_data_main += cnndot.get_layer_str(2.5, 0, 10.00)
graph_data_main += cnndot.get_layer_str(2.5, 0, 10.50)
graph_data_main += cnndot.get_layer_str(3.0, 0, 11.25)
graph_data_main += cnndot.get_layer_str(3.0, 0, 11.75)
graph_data_main += cnndot.get_layer_str(3.0, 0, 12.75, fillcolor='#FF8080') # output
# arrows
graph_data_main += cnndot.get_arrow_str(0.50, 3.0*1.2, 11.25-0.22, 3.0*1.2)
graph_data_main += cnndot.get_arrow_str(1.75, 2.5*1.2, 10.00-0.20, 2.5*1.2)
graph_data_main += cnndot.get_arrow_str(3.00, 2.0*1.2, 8.75-0.18, 2.0*1.2)
graph_data_main += cnndot.get_arrow_str(4.25, 1.5*1.2, 7.50-0.16, 1.5*1.2)
graph_data_main += cnndot.get_arrow_str(5.50, 1.0*1.2, 6.25-0.14, 1.0*1.2)
graph_data_setting = 'graph[ layout = neato, size="16,8"]'
graph_data = 'digraph G {{ \n{}\n{}\n }}'.format(graph_data_setting, graph_data_main)
graph = pydotplus.graphviz.graph_from_dot_data(graph_data)
# save and show image
graph.write_png('img/encoder-decoder.png')
Image(graph.create_png())
Pour ce code, vous verrez quelque chose comme ce qui suit: (C'est une spécification que chaque couche est mince. Si vous étirez les côtés, vous devriez être en mesure de dessiner un corps carré.)
Impressions
- Un simple diagramme comme celui-ci convient, mais je pense qu'il est difficile de dessiner avec des points.
- Ce serait bien s'il pouvait être affiché automatiquement en coopération avec le framework.
Dessin Inception V3 (PostScript 2017/4/30)
C'est différent du code ci-dessus, mais j'ai essayé de dessiner un modèle Keras (InceptionV3). Le carré est dessiné et collé avec une écriture svg.
Recommended Posts