sirven - Crear imagen de la estructura de red neuronal

redes neuronales ejemplos

Question

Muchos periódicos usan imágenes muy bonitas de redes neuronales. También me gusta crear una imagen para un informe que estoy escribiendo.

Un ejemplo: "SegNet: Un codificador convolucional profundo-Arquitectura del decodificador para la segmentación de imágenes" de V. Badrinarayanan et al., Página 4

https://arxiv.org/pdf/1511.00561v3.pdf

Mi pregunta: ¿Qué herramienta podría usarse para crear tales imágenes? Especialmente los rectángulos convvolución se ven muy bien.

Muchas gracias

Answer 1

Escribí una clase pequeña que ayuda a dibujar tales imágenes. Probablemente lo extenderé y lo limpiaré pronto.

Es posible definir algunas capas (colores / tipos), dibujarlas y agregar algunas conexiones entre ellas. El resultado es un archivo svg.

Ejemplo de salida

Código (al final (ver if __name__ == ''__main__'' ) existe el código para generar la imagen de arriba):

import svgwrite
import math
def layer_def(type, height, id=None):
return {
''type'': type,
''height'': height,
''id'': id
}
class CNNDraw:
def __init__(self, dwg):
self.__dwg = dwg
def draw_arrow(self, p_points, width=2, color=''black''):
marker = self.__dwg.marker(insert=(2.1, 2), size=(2, 4), orient=''auto'')
marker.add(self.__dwg.path(d=''M0,0 V4 L2,2 Z'', fill=color))
self.__dwg.defs.add(marker)
line = self.__dwg.add(svgwrite.shapes.Polyline(
p_points, stroke_width=width,
stroke=''black'', fill=''none''))
line.set_markers((self.__dwg.marker(), self.__dwg.marker(), marker))
def draw_3d_rectangle(self, p_start, width, height, stretch, fg_color=''white'', bg_color=''grey'', border_color=''black''):
x_start, y_start = p_start
x_end, y_end = x_start + width, y_start + height
polygon1 = [(x_start, y_start), (x_start + width, y_start), (x_start + width, y_start + height), (x_start, y_start + height)]
polygon2 = [(x_start, y_start), (x_start + stretch, y_start - stretch), (x_end + stretch, y_start - stretch), (x_end, y_start)]
polygon3 = [(x_end, y_start), (x_end + stretch, y_start - stretch), (x_end + stretch, y_end - stretch), (x_end, y_end)]
self.__dwg.add(svgwrite.shapes.Polygon(polygon1, fill=fg_color, stroke=border_color))
self.__dwg.add(svgwrite.shapes.Polygon(polygon2, fill=bg_color, stroke=border_color))
self.__dwg.add(svgwrite.shapes.Polygon(polygon3, fill=bg_color, stroke=border_color))
def draw_multiple_layers(self, p_start, p_stretch=0.4, layer_width=10, space_width=7, layers=[], return_hash=True): # layers = (height, color)
if len(layers) == 0:
return
max_height = max(map(lambda l: l[1], filter(lambda l: isinstance(l, tuple), layers)))
x_offset = 0
side_width_before = 0
drawn_polygons = []
for n in xrange(len(layers)):
layer = layers[n]
if not isinstance(layer, tuple):
x_offset += layer
continue
id, height, fg_color, bg_color = layer
side_width = math.floor(height * p_stretch)
total_width = side_width + layer_width
if n > 0:
space_offset = space_width
if total_width < side_width_before:
space_offset = math.floor((side_width_before - total_width) * 0.5)
space_offset = max(space_width, space_offset)
pass
x_offset += space_offset
curr_p_start = (p_start[0] + x_offset, p_start[1] + math.floor((max_height - height) * 0.5))
self.draw_3d_rectangle(curr_p_start, layer_width, height, side_width, fg_color, bg_color)
drawn_polygons.append((id, curr_p_start, layer_width, height, side_width))
side_width_before = side_width
x_offset += layer_width
if return_hash:
polygons = {}
for polygon in filter(lambda l: l[0] is not None, drawn_polygons):
polygons[polygon[0]] = polygon[1:]
drawn_polygons = polygons
return drawn_polygons
def draw_multiple_defined_layers(self, p_start, layer_definitions={}, layers=[]):
plain_layers = []
for layer in layers:
if not isinstance(layer, dict):
plain_layers.append(layer)
else:
layer_definition = layer_definitions[layer[''type'']]
if ''ignore'' in layer_definition and layer_definition[''ignore'']:
continue
plain_layer = (layer[''id''], layer[''height''], layer_definition[''fg_color''], layer_definition[''bg_color''])
if ''add_space_before'' in layer_definition:
plain_layers.append(layer_definition[''add_space_before''])
plain_layers.append(plain_layer)
if ''add_space_after'' in layer_definition:
plain_layers.append(layer_definition[''add_space_after''])
return self.draw_multiple_layers(p_start, layers=plain_layers)
def draw_arrow_between_points(self, source_point, target_point, text=None, y_delta=10, bottom=False):
if not bottom:
y = min(source_point[1], target_point[1]) - y_delta
else:
y = max(source_point[1], target_point[1]) + y_delta
source_delta = source_point[1] - y
target_delta = target_point[1] - y
if not bottom:
mp0 = (source_point[0] + source_delta, source_point[1] - source_delta)
mp1 = (target_point[0] - target_delta, target_point[1] - target_delta)
else:
mp0 = (source_point[0] - source_delta, source_point[1] - source_delta)
mp1 = (target_point[0] + target_delta, target_point[1] - target_delta)
points = [
source_point,
mp0, mp1,
target_point,
]
self.draw_arrow(points)
# If required: Draw the text
if text is not None:
text_lines = text.split(''/n'')
line_height = 15
mp_middle = (math.floor((mp0[0] + mp1[0]) * 0.5), math.floor((mp0[1] + mp1[1]) * 0.5))
if not bottom:
y_offset = -10 - line_height * (len(text_lines) - 1)
else:
y_offset = 13
for text_line in text_lines:
mp_text = (mp_middle[0], mp_middle[1] + y_offset)
self.__dwg.add(self.__dwg.text(text_line, insert=mp_text, text_anchor="middle", style="font-family:Sans-Serif"))
y_offset += line_height
def draw_arrow_between_layers(self, source_layer, target_layer, text=None, y_delta=10):
source_point = (source_layer[0][0] + source_layer[1] + source_layer[3], source_layer[0][1] - source_layer[3])
target_point = (target_layer[0][0] + target_layer[3], target_layer[0][1] - target_layer[3])
self.draw_arrow_between_points(source_point, target_point, text, y_delta)
def draw_additive_arrow_between_layers(self, source_layers, target_layer, text=None, y_delta=10, y_add=0, bottom=True):
if bottom:
target_point = (target_layer[0][0], target_layer[0][1] + target_layer[2])
# Get the source points
sp0 = min(map(lambda l: (l[0][0] + math.floor(l[1] * 0.5), l[0][1] + l[2]), source_layers), key=lambda l: l[0])
sp1 = max(map(lambda l: (l[0][0] + math.floor(l[1] * 0.5), l[0][1] + l[2]), source_layers), key=lambda l: l[0])
sp_y = max(map(lambda l: l[0][1] + l[2], source_layers)) + 5
sp0d = (sp0[0], sp_y + y_add)
sp1d = (sp1[0], sp_y + y_add)
else:
target_point = (target_layer[0][0] + target_layer[3], target_layer[0][1] - target_layer[3])
# Get the source points
sp0 = min(map(lambda l: (l[0][0] + l[3] + math.floor(l[1] * 0.5), l[0][1] - l[3]), source_layers), key=lambda l: l[0])
sp1 = max(map(lambda l: (l[0][0] + l[3] + math.floor(l[1] * 0.5), l[0][1] - l[3]), source_layers), key=lambda l: l[0])
sp_y = min(map(lambda l: l[0][1] - l[3], source_layers)) - 5
sp0d = (sp0[0], sp_y - y_add)
sp1d = (sp1[0], sp_y - y_add)
self.__dwg.add(svgwrite.shapes.Polyline([sp0, sp0d], stroke_width=2, stroke=''black'', fill=''none''))
self.__dwg.add(svgwrite.shapes.Polyline([sp1, sp1d], stroke_width=2, stroke=''black'', fill=''none''))
if bottom:
mp0 = (sp0d[0] + y_delta, sp0d[1] + y_delta)
mp1 = (sp1d[0] - y_delta, sp1d[1] + y_delta)
else:
mp0 = (sp0d[0] + y_delta, sp0d[1] - y_delta)
mp1 = (sp1d[0] - y_delta, sp1d[1] - y_delta)
mp_middle = (math.floor((mp0[0] + mp1[0]) * 0.5), math.floor((mp0[1] + mp1[1]) * 0.5))
# Draw the first line
self.__dwg.add(svgwrite.shapes.Polyline(
[sp0d, mp0, mp1, sp1d], stroke_width=2,
stroke=''black'', fill=''none''))
# And now the line itself
self.draw_arrow_between_points(mp_middle, target_point, text, y_delta, bottom=bottom)
if __name__ == ''__main__'':
dwg = svgwrite.Drawing(''test.svg'')
cnn_draw = CNNDraw(dwg)
# Draw multiple layers
layer_polygons = cnn_draw.draw_multiple_defined_layers((100, 200), { # Start coordinate
# Define several layer types
''dropout'': {''fg_color'': ''#ffffcc'', ''bg_color'': ''#ffff99'', ''ignore'': True},
''conv'': {''fg_color'': ''#e6faff'', ''bg_color'': ''#99ebff''},
''t_conv'': {''fg_color'': ''#ffe6cc'', ''bg_color'': ''#ffcc99''},
''pool'': {''fg_color'': ''#ccffcc'', ''bg_color'': ''#99ff99'', ''add_space_after'': 20},
''upscale'': {''fg_color'': ''#e6ccff'', ''bg_color'': ''#cc99ff''}
}, [
# The layers to draw; as can be seen a layer can have an id
layer_def(''dropout'', 300),
layer_def(''conv'', 300),
layer_def(''conv'', 300),
layer_def(''pool'', 300, id=''POOL1''),
layer_def(''dropout'', 250),
layer_def(''conv'', 250),
layer_def(''conv'', 250),
layer_def(''pool'', 250, id=''POOL2''),
layer_def(''dropout'', 200),
layer_def(''conv'', 200),
layer_def(''conv'', 200),
layer_def(''pool'', 200, id=''POOL3''),
layer_def(''dropout'', 150),
layer_def(''conv'', 150),
layer_def(''conv'', 150),
layer_def(''pool'', 150, id=''POOL4''),
layer_def(''dropout'', 100),
layer_def(''conv'', 100),
layer_def(''conv'', 100),
layer_def(''pool'', 100, id=''POOL5''),
layer_def(''dropout'', 50),
layer_def(''conv'', 50),
layer_def(''conv'', 50),
layer_def(''pool'', 50, id=''POOL6''),
layer_def(''dropout'', 30),
layer_def(''conv'', 30, id=''FINAL''),
# Plain numbers are just space
100,
layer_def(''t_conv'', 50, id=''T_CONV1''),
60,
layer_def(''t_conv'', 100, id=''T_CONV2''),
60,
layer_def(''t_conv'', 150, id=''T_CONV3''),
60,
layer_def(''t_conv'', 250, id=''T_CONV4''),
layer_def(''conv'', 250),
layer_def(''conv'', 250),
layer_def(''conv'', 250),
layer_def(''dropout'', 250),
layer_def(''conv'', 250),
layer_def(''conv'', 250, id=''FINAL_CONV''),
50,
layer_def(''upscale'', 300, id=''UPSCALED'')
])
cnn_draw.draw_arrow_between_layers(layer_polygons[''FINAL''], layer_polygons[''T_CONV1''], text="transposed conv.")
cnn_draw.draw_additive_arrow_between_layers([layer_polygons[''POOL5''], layer_polygons[''T_CONV1'']], layer_polygons[''T_CONV2''], text="element-wise sum and/ntransposed conv.", y_add=0)
cnn_draw.draw_additive_arrow_between_layers([layer_polygons[''POOL4''], layer_polygons[''T_CONV2'']], layer_polygons[''T_CONV3''], text="element-wise sum and/ntransposed conv.", y_add=0, bottom=False)
cnn_draw.draw_additive_arrow_between_layers([layer_polygons[''POOL3''], layer_polygons[''T_CONV3'']], layer_polygons[''T_CONV4''], text="element-wise sum and/ntransposed conv.", y_add=0)
cnn_draw.draw_arrow_between_layers(layer_polygons[''FINAL_CONV''], layer_polygons[''UPSCALED''], text="upscale")
dwg.save()

Answer 2

Si desea obtener el código del programa, entonces D3.js es la mejor solución que le dará una imagen clara de limpieza como desee. También puede poner la lógica matemática allí.