def block_2(inputs,
            text1,
            output_text,
            hidden_layer_text="$h_{2M \\times Q}$",
            no_box=False,
            use_121=False,
            offset=0,
            x_offset=0,
            box_colour='grey'):
    hidden_layer_node_num = 3
    node_spacing = (1.2 * size, 0)

    # hidden layers 1
    nb = NodeBrush(['lime', 'circle', 'none'], size=size * .5)
    xys = custom_node_seq(hidden_layer_node_num,
                          (x_offset, offset + -1 * step),
                          space=node_spacing)
    __nb = NodeBrush('invisible', size=size * .5)
    _inner_block_1 = [
        nb >> xys[0],
        __nb >> xys[1],
        nb >> xys[2],
    ]
    _inner_block_1[0].text("$h_{1}$", 'center', fontsize=font_size_small)
    _inner_block_1[1].text("$\cdots$", 'center', fontsize=font_size_small)
    _inner_block_1[1].brush.style = "invisible"

    _inner_block_1[2].text(hidden_layer_text,
                           'center',
                           fontsize=font_size_small)
    if use_121:
        viznet.connect121(pin_bot(inputs), _inner_block_1, eb)
    else:
        viznet.connecta2a(pin_bot(inputs), pin_top(_inner_block_1), eb)

    if not no_box:
        # hidden layers 1 Act
        _inner_block_2, _inner_block_2_connectable = box_with_connectable(
            text=text1,
            node_spacing=node_spacing,
            hidden_layer_node_num=hidden_layer_node_num,
            box_loc=(x_offset, offset + -1.25 * step),
            box_size=(size * 1.8, size / 7.3),
            box_colour=box_colour)
        viznet.connect121(_inner_block_1, _inner_block_2_connectable, eb)

    # output
    nb = NodeBrush('nn.output', size=size * .5)
    output = viznet.node_sequence(nb,
                                  1, (x_offset, offset + -1.6 * step),
                                  space=node_spacing)
    output[0].text(output_text, 'center', fontsize=font_size)

    if not no_box:
        viznet.connecta2a(pin_bot(_inner_block_2_connectable), pin_top(output),
                          eb)
        return _inner_block_1, _inner_block_2, _inner_block_2_connectable, output
    else:
        viznet.connecta2a(pin_bot(_inner_block_1), pin_top(output), eb)
        return _inner_block_1, output
Exemplo n.º 2
0
    def draw(self, file=None, size=(10, 6)):
        """
        Draw the network architecture 
        Param:
            - file: The file where the image will be saved. Default: None
            - size: the image size. Default: (10,6)
        """

        with DynamicShow(size, filename=file) as d:

            num_hidden_layer = len(self.architecture) - 2
            token_list = ['\sigma^z'] + [
                'y^{(%s)}' % (i + 1) for i in range(num_hidden_layer)
            ] + ['\psi']
            kind_list = ['nn.input'
                         ] + ['nn.hidden'] * num_hidden_layer + ['nn.output']
            radius_list = [0.1] + [0.2] * num_hidden_layer + [0.3]
            x_list = 1.5 * np.arange(len(self.architecture)) + 1.5

            seq_list = []

            # Input pins
            inputPins = NodeBrush('qc.C', d.ax)
            seq_list.append(
                node_sequence(inputPins,
                              self.inputs,
                              center=(0, 0),
                              space=(0, 1)))

            # Network and connections
            for n, kind, radius, y in zip(self.architecture, kind_list,
                                          radius_list, x_list):
                b = NodeBrush(kind, d.ax)
                seq_list.append(
                    node_sequence(b, n, center=(y, 0), space=(0, 1)))

            for st, et in zip(seq_list[:-1], seq_list[1:]):
                connecta2a(st, et, EdgeBrush('-->', d.ax))

            # Output pins
            outputEdge = EdgeBrush('---', d.ax)
            outputPins = NodeBrush('qc.C', d.ax)
            seq_list.append(
                node_sequence(outputPins,
                              self.architecture[-1],
                              center=(x_list[-1] + 1.5, 0),
                              space=(0, 1)))
            connect121(seq_list[-2], seq_list[-1], outputEdge)
def block_1(inputs, text1, text2, use_121=False, offset=0, box_colour='grey'):
    # hidden layers 1
    nb = NodeBrush(['grey', 'circle', 'none'], size=size * .1)
    # _inner_block_1 = viznet.node_sequence(nb, hidden_layer_node_num, (0, offset + -1*step), space=node_spacing)
    xys = custom_node_seq(hidden_layer_node_num, (0, offset + -1 * step),
                          space=node_spacing)
    _inner_block_1 = []
    for i, xy in enumerate(xys):
        if i == len(xys) // 2:
            __nb = NodeBrush('invisible', size=size * .1)
            _inner_block_1.append(__nb >> xy)
            _inner_block_1[-1].text("$\cdots\cdots$",
                                    'center',
                                    fontsize=font_size_small)
        else:
            _inner_block_1.append(nb >> xy)
            if i == len(xys) - 1:
                _inner_block_1[-1].text(f"$h_{1} \sim h_{{500}}$",
                                        'right',
                                        fontsize=font_size_small)

    if use_121:
        viznet.connect121(pin_bot(inputs), _inner_block_1, eb)
    else:
        viznet.connecta2a(pin_bot(inputs), pin_top(_inner_block_1), eb)

    # hidden layers 1 Act
    _inner_block_2, _inner_block_2_connectable = box_with_connectable(
        text=text1,
        node_spacing=node_spacing,
        hidden_layer_node_num=hidden_layer_node_num,
        text_pos='left',
        box_loc=(0, offset + -1.04 * step),
        box_size=(size * 4.5, size * .05),
        # text_kwargs={'color' : 'red'}
    )
    viznet.connect121(_inner_block_1, _inner_block_2_connectable, eb)

    # hidden layers 1 BN
    _inner_block_3, _inner_block_3_connectable = box_with_connectable(
        text=text2,
        node_spacing=node_spacing,
        hidden_layer_node_num=hidden_layer_node_num,
        box_loc=(0, offset + -1.06 * step),
        box_size=(size * 4.5, size * .05),
        box_colour=box_colour)
    viznet.connect121(_inner_block_2_connectable, _inner_block_3_connectable,
                      eb)

    return _inner_block_1, _inner_block_2, _inner_block_2_connectable, _inner_block_3, _inner_block_3_connectable
def block_1(inputs, text1, text2, use_121=False, offset=0, box_colour='grey'):
    # hidden layers 1
    nb = NodeBrush(['lime', 'circle', 'none'], size=size * .5)
    # _inner_block_1 = viznet.node_sequence(nb, hidden_layer_node_num, (0, offset + -1*step), space=node_spacing)
    xys = custom_node_seq(hidden_layer_node_num, (0, offset + -1 * step),
                          space=node_spacing)
    _inner_block_1 = []
    for i, xy in enumerate(xys):
        if i == len(xys) // 2:
            __nb = NodeBrush('invisible', size=size * .5)
            _inner_block_1.append(__nb >> xy)
            _inner_block_1[-1].text("$\cdots$",
                                    'center',
                                    fontsize=font_size_small)
        else:
            if i > len(xys) // 2:
                i = 500 - (len(xys) - i)
            _inner_block_1.append(nb >> xy)
            _inner_block_1[-1].text(f"$h_{{{i+1}}}$",
                                    'center',
                                    fontsize=font_size_small)
    if use_121:
        viznet.connect121(pin_bot(inputs), _inner_block_1, eb)
    else:
        viznet.connecta2a(pin_bot(inputs), pin_top(_inner_block_1), eb)

    # hidden layers 1 Act
    _inner_block_2, _inner_block_2_connectable = box_with_connectable(
        text=text1,
        node_spacing=node_spacing,
        hidden_layer_node_num=hidden_layer_node_num,
        box_loc=(0, offset + -1.25 * step),
        box_size=(size * 6.6, size / 7.3),
    )
    viznet.connect121(_inner_block_1, _inner_block_2_connectable, eb)

    # hidden layers 1 BN
    _inner_block_3, _inner_block_3_connectable = box_with_connectable(
        text=text2,
        node_spacing=node_spacing,
        hidden_layer_node_num=hidden_layer_node_num,
        box_loc=(0, offset + -1.38 * step),
        box_size=(size * 6.6, size / 7.3),
        box_colour=box_colour)
    viznet.connect121(_inner_block_2_connectable, _inner_block_3_connectable,
                      eb)

    return _inner_block_1, _inner_block_2, _inner_block_2_connectable, _inner_block_3, _inner_block_3_connectable
def block_1(inputs, text1, text2, use_121=False, offset=0, box_colour='grey'):
    # hidden layers 1
    nb = NodeBrush('nn.hidden', size=size * .5)
    _inner_block_1 = viznet.node_sequence(nb,
                                          hidden_layer_node_num,
                                          (0, offset + -1 * step),
                                          space=node_spacing)
    for i, n in enumerate(_inner_block_1):
        if i > len(_inner_block_1) // 2:
            i = 500 - (len(_inner_block_1) - i)
        _t = f"$h_{{{i+1}}}$"
        if i == len(_inner_block_1) // 2:
            _t = "$h_{...}$"
        n.text(_t, 'center', fontsize=font_size_small)
    if use_121:
        viznet.connect121(pin_bot(inputs), _inner_block_1, eb)
    else:
        viznet.connecta2a(pin_bot(inputs), pin_top(_inner_block_1), eb)

    # hidden layers 1 Act
    _inner_block_2, _inner_block_2_connectable = box_with_connectable(
        text=text1,
        box_loc=(0, offset + -1.4 * step),
        box_size=(size * 9, size / 2.8))
    viznet.connect121(_inner_block_1, _inner_block_2_connectable, eb)

    # hidden layers 1 BN
    _inner_block_3, _inner_block_3_connectable = box_with_connectable(
        text=text2,
        box_loc=(0, offset + -1.7 * step),
        box_size=(size * 9, size / 2.8),
        box_colour=box_colour)
    viznet.connect121(_inner_block_2_connectable, _inner_block_3_connectable,
                      eb)

    return _inner_block_1, _inner_block_2, _inner_block_2_connectable, _inner_block_3, _inner_block_3_connectable