paddle(四)

1.embedding

词向量，将词id映射为词向量，

paddle.fluid.embedding(input, size, is_sparse=False, is_distributed=False, padding_idx=None, param_attr=None, dtype='float32')

input为id集合，要求dtype必须为int64

size为二维数组，size[0]为文章中词的数量，size[1]为词向量的宽度，最终结果为在原有input的shape基础上添加size[1]维

is_sparse (bool) - 是否使用稀疏的更新方式，这个参数只会影响反向的梯度更新的性能，sparse更新速度更快，推荐使用稀疏更新的方式。但某些optimizer不支持sparse更新，比如 AdadeltaOptimizer 、 AdamaxOptimizer 、 DecayedAdagradOptimizer 、 FtrlOptimizer 、 LambOptimizer 、LarsMomentumOptimizer ，此时is_sparse必须为False。默认为False。
is_distributed (bool) - 是否使用分布式的方式存储embedding矩阵，仅在多机分布式cpu训练中使用。默认为False。
padding_idx (int|long|None) - padding_idx需在区间[-vocab_size, vocab_size)，否则不生效，padding_idx<0时，padding_idx 会被改成 vocab_size + padding_idx，input中等于padding_index的id对应的embedding信息会被设置为0，且这部分填充数据在训练时将不会被更新。如果为none，不作处理，默认为None。
param_attr (ParamAttr) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 ParamAttr 。此外，可以通过 param_attr 参数加载用户自定义或预训练的词向量。只需将本地词向量转为numpy数据格式，且保证本地词向量的shape和embedding的 size 参数一致，然后使用 NumpyArrayInitializer 进行初始化，即可实现加载自定义或预训练的词向量。详细使用方法见代码示例2。
dtype (str|core.VarDesc.VarType) - 输出Tensor或LoDTensor的数据类型，数据类型必须为：float32，float64，默认为float32。

from __future__ import print_function
import paddle
import paddle.fluid as fluid
import numpy as np
import math
import sys

use_cuda = False
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
exe = fluid.Executor(place)

main_program = fluid.default_main_program()

data = [[3,6,2,5],[4,7,3,1]]

o = np.array(data)

data = np.resize(o,(100,4)).tolist()

data = [(o,[0]) for o in data]
def reader():
    for i in data:
        yield i

batch_reader = fluid.io.batch(reader, batch_size=2)

word = fluid.data('word', shape=[None,1], dtype='int64', lod_level=1)
label = fluid.data('label', shape=[None,1], dtype='int64', lod_level=1)

emb = fluid.embedding(input=word,size=[8,16],dtype='float32')

feeder = fluid.DataFeeder(feed_list=[word,label],place=place)

exe.run(fluid.default_startup_program())
for d in batch_reader():
    cost = exe.run(main_program,feed=feeder.feed(d),fetch_list=[emb.name],return_numpy=False)
    break

def LodTensor_to_Tensor(lod_tensor):
    lod = lod_tensor.lod()
    array = np.array(lod_tensor)
    new_array = []
    for i in range(len(lod[0]) - 1):
        new_array.append(array[lod[0][i]:lod[0][i + 1]])
    return new_array
tensor = LodTensor_to_Tensor(cost[0])

tensor[0].shape

#输出结果(4, 1, 16)

2.lodTensor

变长的张量，数据以一维形式存储，lod中存储shape

import paddle.fluid as fluid
import numpy as np

a = fluid.create_lod_tensor(np.array([[1],[1],[1],
                                  [1],[1],
                                  [1],[1],[1],[1],
                                  [1],
                                  [1],[1], [1],[1],[1]]).astype('int64') , [[3,1,2] , [3,2,4,1,2,3]], fluid.CPUPlace())

#查看lod-tensor嵌套层数 print (len(a.recursive_sequence_lengths())) # output：2 #查看最基础元素个数 print (sum(a.recursive_sequence_lengths()[-1])) def to_lodtensor(data, place): # 存储Tensor的长度作为LoD信息 seq_lens = [len(seq) for seq in data] cur_len = 0 lod = [cur_len] for l in seq_lens: cur_len += l lod.append(cur_len) # 对待转换的 Tensor 降维 flattened_data = np.concatenate(data, axis=0).astype("float32") flattened_data = flattened_data.reshape([len(flattened_data), 1]) # 为 Tensor 数据添加lod信息 res = fluid.LoDTensor() res.set(flattened_data, place) res.set_lod([lod]) return res def LodTensor_to_Tensor(lod_tensor): # 获取 LoD-Tensor 的 lod 信息 lod = lod_tensor.lod() # 转换成 array array = np.array(lod_tensor) new_array = [] # 依照原LoD-Tensor的层级信息，转换成Tensor for i in range(len(lod[0]) - 1): new_array.append(array[lod[0][i]:lod[0][i + 1]]) return new_array

3.fluid.layers.dynamic_lstm

输入必须是[None,1]格式

4.sequence_pool

fluid.layers.sequence_pool根据lodTensor的指定tensor格式进行卷积

a = fluid.create_lod_tensor(np.array([[1],[1],
                                  [1],[1],
                                  [1],[1],
                                  [1],[1]]).astype('int64') , [[2,2,2,2]],fluid.CPUPlace())
o = fluid.layers.sequence_pool(input=fc, pool_type='sum')

处理之后结果为[2,2,2,2]

猜你喜欢