Exemplo n.º 1
0
            def test():
                data = conf_helps.data_layer(name="word", size=dict_dim)
                label = conf_helps.data_layer(name="label", size=label_dim)
                emb = conf_helps.embedding_layer(input=data, size=word_dim)
                boot_layer = conf_helps.data_layer(name="boot", size=10)
                boot_layer = conf_helps.fc_layer(
                    name='boot_fc', input=boot_layer, size=10)

                def step(y, wid):
                    z = conf_helps.embedding_layer(input=wid, size=word_dim)
                    mem = conf_helps.memory(
                        name="rnn_state",
                        size=hidden_dim,
                        boot_layer=boot_layer)
                    out = conf_helps.fc_layer(
                        input=[y, z, mem],
                        size=hidden_dim,
                        act=conf_helps.TanhActivation(),
                        bias_attr=True,
                        name="rnn_state")
                    return out

                out = conf_helps.recurrent_group(
                    name="rnn", step=step, input=[emb, data])

                rep = conf_helps.last_seq(input=out)
                prob = conf_helps.fc_layer(
                    size=label_dim,
                    input=rep,
                    act=conf_helps.SoftmaxActivation(),
                    bias_attr=True)

                conf_helps.outputs(
                    conf_helps.classification_cost(
                        input=prob, label=label))
Exemplo n.º 2
0
            def test():
                data = conf_helps.data_layer(name="word", size=dict_dim)
                label = conf_helps.data_layer(name="label", size=label_dim)
                emb = conf_helps.embedding_layer(input=data, size=word_dim)
                boot_layer = conf_helps.data_layer(name="boot", size=10)
                boot_layer = conf_helps.fc_layer(name='boot_fc',
                                                 input=boot_layer,
                                                 size=10)

                def step(y, wid):
                    z = conf_helps.embedding_layer(input=wid, size=word_dim)
                    mem = conf_helps.memory(name="rnn_state",
                                            size=hidden_dim,
                                            boot_layer=boot_layer)
                    out = conf_helps.fc_layer(input=[y, z, mem],
                                              size=hidden_dim,
                                              act=conf_helps.TanhActivation(),
                                              bias_attr=True,
                                              name="rnn_state")
                    return out

                out = conf_helps.recurrent_group(name="rnn",
                                                 step=step,
                                                 input=[emb, data])

                rep = conf_helps.last_seq(input=out)
                prob = conf_helps.fc_layer(size=label_dim,
                                           input=rep,
                                           act=conf_helps.SoftmaxActivation(),
                                           bias_attr=True)

                conf_helps.outputs(
                    conf_helps.classification_cost(input=prob, label=label))
Exemplo n.º 3
0
 def step(y):
     mem = conf_helps.memory(name="rnn_state", size=hidden_dim)
     out = conf_helps.fc_layer(input=[y, mem],
                               size=hidden_dim,
                               act=activation.Tanh(),
                               bias_attr=True,
                               name="rnn_state")
     return out
Exemplo n.º 4
0
 def step(y):
     mem = conf_helps.memory(name="rnn_state", size=hidden_dim)
     out = conf_helps.fc_layer(
         input=[y, mem],
         size=hidden_dim,
         act=activation.Tanh(),
         bias_attr=True,
         name="rnn_state")
     return out
Exemplo n.º 5
0
 def step(y, wid):
     z = conf_helps.embedding_layer(input=wid, size=word_dim)
     mem = conf_helps.memory(name="rnn_state",
                             size=hidden_dim,
                             boot_layer=boot_layer)
     out = conf_helps.fc_layer(input=[y, z, mem],
                               size=hidden_dim,
                               act=conf_helps.TanhActivation(),
                               bias_attr=True,
                               name="rnn_state")
     return out
Exemplo n.º 6
0
 def step(y, wid):
     z = conf_helps.embedding_layer(input=wid, size=word_dim)
     mem = conf_helps.memory(
         name="rnn_state",
         size=hidden_dim,
         boot_layer=boot_layer)
     out = conf_helps.fc_layer(
         input=[y, z, mem],
         size=hidden_dim,
         act=conf_helps.TanhActivation(),
         bias_attr=True,
         name="rnn_state")
     return out
Exemplo n.º 7
0
                               padding=1,
                               stride=1,
                               num_channels=1,
                               num_filters=6,
                               filter_size=5,
                               act=paddle.LinearActivation())

pool_1 = paddle.img_pool_layer(input=conv_1,
                               stride=2,
                               pool_size=2,
                               pool_type=paddle.MaxPooling())

conv_2 = paddle.img_conv_layer(input=pool_1,
                               stride=1,
                               num_filters=16,
                               filter_size=5,
                               act=paddle.LinearActivation())
pool_2 = paddle.img_pool_layer(input=conv_2,
                               stride=2,
                               pool_size=2,
                               pool_type=paddle.MaxPooling())

fc_1 = paddle.fc_layer(input=pool_2, size=500, act=paddle.SigmoidActivation())
fc_2 = paddle.fc_layer(input=fc_1, size=10, act=paddle.SoftmaxActivation())

label = paddle.data_layer(name='label', size=10)

cost = paddle.classification_cost(input=fc_2, label=label)

paddle.outputs(cost)