BERT | （4）Bert生成句向量_pytorch

最新推荐文章于 2024-05-18 16:51:13 发布
最新推荐文章于 2024-05-18 16:51:13 发布
阅读量4k 收藏 35
点赞数 1
分类专栏： # BERT 文章标签： python bert
原文链接：https://blog.csdn.net/weixin_30034903/article/details/113399809
版权

原文地址：Bert生成句向量(pytorch)

本文主要讲如何调用transformers这个包来提取一个句子的特征。

Transformers是TensorFlow 2.0和PyTorch的最新自然语言处理库

Transformers(以前称为pytorch-transformers和pytorch-pretrained-bert)提供用于自然语言理解(NLU)和自然语言生成(NLG)的最先进的模型(BERT，GPT-2，RoBERTa，XLM，DistilBert，XLNet，CTRL …) ，拥有超过32种预训练模型，支持100多种语言，并且在TensorFlow 2.0和PyTorch之间具有深厚的互操作性。

 

Bert

1、安装transformers库

pip install transformers

2、从transformers库中导入Bert的上面所说到的3个类

 from transformers import  BertModel, BertConfig,BertTokenizer

1、文本处理

用BertTokenizer对输入文本进行处理，从预训练模型中加载tokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')

如果不想下载，可以先把bert-base-chinese-vocab.txt 下载下来加载进去。

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese-vocab.txt')

 

输入文本是两个sentence

需要在文本开头加上’[CLS]’，在每个句子后面加上’[SEP]’，这样输入到BertModel中才能被正确识别。

from transformers import BartModel,BertConfig, BertTokenizer
import torch

# 用BertTokenizer对输入文本进行处理，从预训练模型中加载tokenizer
tokenizer = BertTokenizer.from_pretrained('./bert-base-chinese/vocab.txt')

text = "[CLS] 今天天气不错，适合出行。 [SEP] 今天是晴天，可以出去玩。 [SEP]"
tokenized_text = tokenizer.tokenize(text) # 用tokenizer对句子分词

'''
输出;print(tokenized_text)
['[CLS]', '今', '天', '天', '气', '不', '错', '，', '适', '合', '出', '行', '。', 
'[SEP]', '今', '天', '是', '晴', '天', '，', '可', '以', '出', '去', '玩', '。', '[SEP]']
'''
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text) #词在预训练词表中的索引列表
# print(indexed_tokens)
'''
output:print(indexed_tokens)
[101, 791, 1921, 1921, 3698, 679, 7231, 8024, 6844, 1394, 1139, 6121, 511,
 102, 791, 1921, 3221, 3252, 1921, 8024, 1377, 809, 1139, 1343, 4381, 511, 102]
'''
#用来指定哪个是第一个句子，哪个是第二个句子，0的部分代表句子一, 1的部分代表句子二
segments_ids = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

#转换成PyTorch tensors
tokens_tensor = torch.tensor([indexed_tokens])
segments_tensors = torch.tensor([segments_ids])
'''
output:print(tokens_tensor)
tensor([[ 101,  791, 1921, 1921, 3698,  679, 7231, 8024, 6844, 1394, 1139, 6121,
          511,  102,  791, 1921, 3221, 3252, 1921, 8024, 1377,  809, 1139, 1343,
         4381,  511,  102]])

output:print(segments_tensors)
tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
'''

tokens_tensor，segments_tensors将作为BertModel的输入。

 

输入文本是一个sentence

很多时候输入文本是只有一个句子的，上面两个句子的情况只是简单提一下，下面主要是以一个句子为主。同样，先在句子前面加上’[CLS]’，后面加上’[SEP]’。一般神经网络提取文本特征是以batch为单位的，因此还需要用到一个输入input_masks，假设text是一个batch的数据。

from transformers import BartModel,BertConfig, BertTokenizer
import torch

# 用BertTokenizer对输入文本进行处理，从预训练模型中加载tokenizer
tokenizer = BertTokenizer.from_pretrained('./bert-base-chinese/vocab.txt')
texts = ["[CLS] 今天天气不错，适合出行。 [SEP]",
        "[CLS] 今天是晴天，可以出去玩。 [SEP]"]
tokens, segments, input_masks = [], [], []
for text in texts:
    tokenized_text = tokenizer.tokenize(text) #用tokenizer对句子分词
    indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)#索引列表
    tokens.append(indexed_tokens)
    segments.append([0] * len(indexed_tokens))
    input_masks.append([1] * len(indexed_tokens))
'''
output:print(tokenized_text)
['[CLS]', '今', '天', '是', '晴', '天', '，
', '可', '以', '出', '去', '玩', '。', '[SEP]']

output:print(segments)
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

output:print(segments)
[[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]

'''
max_len = max([len(single) for single in tokens])  # 最大的句子长度

'''
# segments列表全0，因为只有一个句子1，没有句子2
# input_masks列表1的部分代表句子单词，而后面0的部分代表paddig，只是用于保持输入整齐，没有实际意义。
# 相当于告诉BertModel不要利用后面0的部分
'''

for j in range(len(tokens)):
    padding = [0] * (max_len - len(tokens[j]))
    tokens[j] += padding
    segments[j] += padding
    input_masks[j] += padding
#转换成PyTorch tensors
tokens_tensor = torch.tensor(tokens)
segments_tensors = torch.tensor(segments)
input_masks_tensors = torch.tensor(input_masks)

tokens_tensor，segments_tensors，input_masks_tensors 将作为BertModel的输入。

2、构建BertModel 

在BertModel后面加上一个全连接层，能够调整输出feature的维度。

 
class BertTextNet(nn.Module):
    def __init__(self,  code_length): #code_length为fc映射到的维度大小
        super(TextNet, self).__init__()
 
        modelConfig = BertConfig.from_pretrained('bert-base-chinese-config.json')
        self.textExtractor = BertModel.from_pretrained(
            'bert-base-chinese-pytorch_model.bin', config=modelConfig)
        embedding_dim = self.textExtractor.config.hidden_size
 
        self.fc = nn.Linear(embedding_dim, code_length)
        self.tanh = torch.nn.Tanh()
 
    def forward(self, tokens, segments, input_masks):
        output=self.textExtractor(tokens, token_type_ids=segments,
                                 		attention_mask=input_masks)
        text_embeddings = output[0][:, 0, :]  
        #output[0](batch size, sequence length, model hidden dimension)
 
        features = self.fc(text_embeddings)
        features = self.tanh(features)
        return features

使用pytorch_transformers本身提供的预训练BertConfig，以及加载预训练模型。

config = BertConfig.from_pretrained('bert-base-chinese')
self.textExtractor = BertModel.from_pretrained('bert-base-chinese', config=modelConfig)

否则还是像上面模型那样加载本地下载的预训练模型。

把输入到BertModel后得到的输出output，一般是使用它的第0维信息。

outputs[0]  # The last hidden-state is the first element of the output tuple

其中output[0][:,0,:]代表下图中的C的输出向量，参考论文Bert

3、完整代码

 

from transformers import BertModel,BertConfig, BertTokenizer
import torch
import torch.nn as nn


# 用BertTokenizer对输入文本进行处理，从预训练模型中加载tokenizer
# tokenizer = BertTokenizer.from_pretrained('./bert-base-chinese/vocab.txt')
#
# text = "[CLS] 今天天气不错，适合出行。 [SEP] 今天是晴天，可以出去玩。 [SEP]"
# tokenized_text = tokenizer.tokenize(text) # 用tokenizer对句子分词
#
# '''
# 输出;print(tokenized_text)
# ['[CLS]', '今', '天', '天', '气', '不', '错', '，', '适', '合', '出', '行', '。',
# '[SEP]', '今', '天', '是', '晴', '天', '，', '可', '以', '出', '去', '玩', '。', '[SEP]']
# '''
# indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text) #词在预训练词表中的索引列表
# # print(indexed_tokens)
# '''
# output:print(indexed_tokens)
# [101, 791, 1921, 1921, 3698, 679, 7231, 8024, 6844, 1394, 1139, 6121, 511,
#  102, 791, 1921, 3221, 3252, 1921, 8024, 1377, 809, 1139, 1343, 4381, 511, 102]
# '''
# #用来指定哪个是第一个句子，哪个是第二个句子，0的部分代表句子一, 1的部分代表句子二
# segments_ids = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
#
# #转换成PyTorch tensors
# tokens_tensor = torch.tensor([indexed_tokens])
# segments_tensors = torch.tensor([segments_ids])
# '''
# output:print(tokens_tensor)
# tensor([[ 101,  791, 1921, 1921, 3698,  679, 7231, 8024, 6844, 1394, 1139, 6121,
#           511,  102,  791, 1921, 3221, 3252, 1921, 8024, 1377,  809, 1139, 1343,
#          4381,  511,  102]])
#
# output:print(segments_tensors)
# tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
# '''
#

# # 用BertTokenizer对输入文本进行处理，从预训练模型中加载tokenizer
# tokenizer = BertTokenizer.from_pretrained('./bert-base-chinese/vocab.txt')
# texts = ["[CLS] 今天天气不错，适合出行。 [SEP]",
#         "[CLS] 今天是晴天，可以出去玩。 [SEP]"]
# tokens, segments, input_masks = [], [], []
# for text in texts:
#     tokenized_text = tokenizer.tokenize(text) #用tokenizer对句子分词
#     indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)#索引列表
#     tokens.append(indexed_tokens)
#     segments.append([0] * len(indexed_tokens))
#     input_masks.append([1] * len(indexed_tokens))
# '''
# output:print(tokenized_text)
# ['[CLS]', '今', '天', '是', '晴', '天', '，
# ', '可', '以', '出', '去', '玩', '。', '[SEP]']
#
# output:print(segments)
# [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
#
# output:print(segments)
# [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
#  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
#
# '''
# max_len = max([len(single) for single in tokens])  # 最大的句子长度
#
# '''
# # segments列表全0，因为只有一个句子1，没有句子2
# # input_masks列表1的部分代表句子单词，而后面0的部分代表paddig，只是用于保持输入整齐，没有实际意义。
# # 相当于告诉BertModel不要利用后面0的部分
# '''
#
# for j in range(len(tokens)):
#     padding = [0] * (max_len - len(tokens[j]))
#     tokens[j] += padding
#     segments[j] += padding
#     input_masks[j] += padding
# #转换成PyTorch tensors
# tokens_tensor = torch.tensor(tokens)
# segments_tensors = torch.tensor(segments)
# input_masks_tensors = torch.tensor(input_masks)



# 1.构建模型
class BertTextNet(nn.Module):
    def __init__(self, code_length):  # code_length为fc映射到的维度大小
        super(BertTextNet, self).__init__()

        modelConfig = BertConfig.from_pretrained('./bert-base-chinese/bert_config.json')
        self.textExtractor = BertModel.from_pretrained(
            './bert-base-chinese/pytorch_model.bin', config=modelConfig, from_tf=True)
        embedding_dim = self.textExtractor.config.hidden_size

        self.fc = nn.Linear(embedding_dim, code_length)
        self.tanh = torch.nn.Tanh()

    def forward(self, tokens, segments, input_masks):
        output = self.textExtractor(tokens, token_type_ids=segments,
                                    attention_mask=input_masks)
        text_embeddings = output[0][:, 0, :]
        # output[0](batch size, sequence length, model hidden dimension)

        features = self.fc(text_embeddings)
        features = self.tanh(features)
        return features

textNet = BertTextNet(code_length=32)

# 2.数据处理
# 用BertTokenizer对输入文本进行处理，从预训练模型中加载tokenizer
tokenizer = BertTokenizer.from_pretrained('./bert-base-chinese/vocab.txt')
texts = ["[CLS] 今天天气不错，适合出行。 [SEP]",
        "[CLS] 今天是晴天，可以出去玩。 [SEP]"]
tokens, segments, input_masks = [], [], []
for text in texts:
    tokenized_text = tokenizer.tokenize(text) #用tokenizer对句子分词
    indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)#索引列表
    tokens.append(indexed_tokens)
    segments.append([0] * len(indexed_tokens))
    input_masks.append([1] * len(indexed_tokens))

max_len = max([len(single) for single in tokens])  # 最大的句子长度

for j in range(len(tokens)):
    padding = [0] * (max_len - len(tokens[j]))
    tokens[j] += padding
    segments[j] += padding
    input_masks[j] += padding
#转换成PyTorch tensors
tokens_tensor = torch.tensor(tokens)
segments_tensors = torch.tensor(segments)
input_masks_tensors = torch.tensor(input_masks)

# 3.提取文本特征——————
text_hashCodes = textNet(tokens_tensor,segments_tensors,input_masks_tensors) #text_hashCodes是一个32-dim文本特征
print(text_hashCodes)

 

在运行过程中出现如下的问题:

OSError: Unable to load weights from pytorch checkpoint file for './bert-base-chinese' at './bert-base-chinese/pytorch_model.bin'If you tried to load a PyTorch model from a TF 2.0 checkpoint, please set from_tf=True. 

不知道是啥子原因，但是叫我set from_tf=True. 那我就设置吧！

self.textExtractor = BertModel.from_pretrained(
            './bert-base-chinese/pytorch_model.bin', config=modelConfig, from_tf=True)

然后接着告诉我，没有安装TensorFlow

那就装呗！装的时候又告诉我：

ERROR: Cannot uninstall 'six'. It is a distutils installed project and thus we cannot accurately determine which files belong to it which would lead to only a partial uninstall.

 找了好久，找到解决办法：

pip install six --upgrade --ignore-installed six

装好了，运行，艹！

这特么貌似是h5文件加载错误，但是我特么文件都是官方的呀？于是我往上看，发现最早的一个错误：

貌似又是TensorFlow这个坑逼框架在作妖，差了一下又是啥显卡版本与TensorFlow版本不兼容什么东西！

弄一下午，害……放弃了……TensorFlow就是一个坑！！！！

借同学服务器跑出来的结果：

 

 

郭畅小渣渣
关注
  • 1
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
annotated_wikisql_and_PyTorch_bert_param.zip
10-19
《自然语言转SQL任务：NL2SQL与PyTorch BERT参数...结合PyTorch BERT模型，我们可以构建一个能够理解自然语言并生成SQL查询的强大系统。这个领域的研究不仅有助于提高人机交互的效率，也有望推动数据库查询技术的革新。
Pytorch下用Bert+MLP实现文本情感分类网络
01-03
在Pyrotch上实现情感分类模型，包含一个BERT 模型和一个分类器（MLP），两者间有一个dropout层。BERT模型实现了预训练参数加载功能，预训练的参数...然后将句向量经过dropout层再输入分类器，最后输出二元分类预测。
【NLP】bert4vec：一个基于预训练的句向量生成工具
fengdu78的博客
02-12 1003
一个基于预训练的句向量生成工具 bert4vec： https://github.com/zejunwang1/bert4vec环境transformers>=4.6.0,&l...
Pytorch中使用Bert预训练模型，并给定句子得到对应的向量
qq_33812659的博客
07-19 1万+
写在前面 本次的需求是：通过预训练好的Bert模型，得到不同语境下，不同句子的句向量。相比于word2vec、glove这种静态词向量，会含有更丰富的语义，并能解决不同场景不同意思的问题。 建议大家先看Bert原论文（看之前最好懂得ELMo，一定要懂transformer），再结合这个博客（墙裂推荐） 开始 本次记录一共分成以下四步： 安装transformer包 导入BertTokenizer和BertModel 将要输入的句子修改为Bert要求的输入形式 输入Bert模型，得到token向量 安装t
为什么我直接pip install transformers安装的并不是最新的版本，而当我pip install transformers==4.41.0安装的确是最新的版本
Flemington7的博客
05-18 748
在使用pip命令时，安装的并不是最新版本。
利用bert预训练模型生成句向量或词向量.zip
01-07
先下载相应的预训练模型 配置conf.py里边的路径 利用extract_sen_vec.py 里的 gen_sen_vec()函数生成句向量，gen_word_vec()生成词向量
BERT句向量(一)：Sentence-BERT
sgyuanshi的博客
04-26 1万+
前言 句向量：能够表征整个句子语义的向量，目前效果比较好的方法还是通过bert模型结构来实现，也是本文的主题。 有了句向量，我们可以用来进行聚类，处理大规模的文本相似度比较，或者基于语义搜索的信息检索。 例如搜索系统中的输入query和匹配文档document、Q&A任务的问题和答案等等，都可以转化为计算两个句子的语义相似/相关度，相关度最高的n个作为模型的返回结果。 题外话 这种类似的模型一般称为passage retrieval models，即段落检索，有两个代表： sparse model
bert生成句向量(python)
weixin_43957354的博客
02-24 1548
bert生成句向量
使用BERT生成句向量
热门推荐
u012526436的博客
02-19 3万+
转载请注明出处，原文地址 在阅读本文之前如果您对BERT并不了解，请参阅我的其他博文BERT完全指南 简介 之前的文章介绍了BERT的原理、并用BERT做了文本分类与相似度计算，本文将会教大家用BERT来生成句向量，核心逻辑代码参考了hanxiao大神的bert-as-service，我的代码地址如下： 代码地址：BERT句向量 传统的句向量 对于传统的句向量生成方式，更多的是采用word emb...
【中文编码】利用bert-base-chinese中的Tokenizer实现中文编码嵌入
qq_43426908的博客
12-02 5628
按我通俗的理解，就是文本要进入模型，得编码成数字的形式，那么，怎么给定数字的形式呢，不能随便给一个数字吧，此时就需要一个词表，该表中有很多很多的字，每个字都有在该表中唯一的位置，每个字编码时，采用其在词表中的位置。
基于Pytorch实现的Bert模型
08-27
基于PyTorch实现的BERT模型。BERT（Bidirectional Encoder Representations from Transformers）是一种预训练的自然语言处理模型，它在大规模文本数据上进行预训练，然后可以通过微调适应各种NLP任务，如文本分类、...
基于中文预训练字向量finetune的Bert与BiLSTM模型的网络
最新发布
05-27
Bert部分参考了pytorch_transformers，预训练模型为中文预训练BERT-wwm BiLSTM的预训练词向量使用的是 word2vec的预训练词向量(Baidu Encyclopedia 百度百科 + Word + Character + Ngram 300d ) 可在 Chinese Word ...
Pytorch框架基于Bert构建词向量+Bi-LSTM+Attention实现情感分类任务python源码+数据集.zip
05-24
Pytorch框架基于Bert构建词向量+Bi-LSTM+Attention实现情感分类任务python源码+数据集.zip个人经导师指导并认可通过的高分毕业设计项目，评审分98分。主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的...
NLP实战：Pytorch实现6大经典深度学习中文短文本分类-bert+ERNIE+bert_CNN+bert_RNN+bert_RCNN+bert_DPCNN
小胡说人工智能的博客
07-09 5949
本文基于PyTorch框架，实现了6种经典的深度学习中文文本分类模型，这些模型包括基于Transformer模型的Bert和ERNIE，以及结合卷积神经网络、循环神经网络和深度金字塔卷积神经网络的bert_CNN、bert_RNN、bert_RCNN和bert_DPCNN，并对各模型进行了训练与结果比较。
Bert生成句向量（tensorflow）
huangcy的博客
02-02 2592
BERT句向量 Bert包括两个版本，12层的transformers与24层的transformers，官方提供了12层的中文模型，下文也将基于12层的transformers来讲解 每一层的transformers的输出值，理论来说都可以作为句向量，但是到底该取哪一层呢，根据hanxiao大神的实验数据，最佳结果是取倒数第二层，最后一层太过于接近目标，前面几层可能语义还未充分的学习到。 接下来从代码的角度来进行详解。 先看下args.py，介绍几个重要参数。这里主要说一下layer_inde
BERT之提取特征向量 及 bert-as-server的使用
ling620的专栏
07-05 1万+
本文内容列表提取句向量1、句向量简介1-1传统句向量1-2、BERT句向量2、 extract_features.py源码分析2-1 main函数 前一篇文章 BERT介绍及中文文本相似度任务实践 简单介绍了使用BERT进行中文文本相似度计算的方法，这篇文章着重对特征提取方法进行讲述。 提取句向量 1、句向量简介 1-1传统句向量 更多采用word embedding的方式取加权平均，该方法的一大...
还在用[CLS]？从BERT得到最强句子Embedding的打开方式！
夕小瑶科技说
12-24 3614
文：涅生编：兔子酱你有尝试从 BERT 提取编码后的 sentence embedding 吗？很多小伙伴的第一反应是：不就是直接取顶层的[CLS] token的embedding作为句...
Pytorch 转换为tensor类型数据格式
weixin_59057086的博客
06-26 2056
pytorch中numpy数据类型转换为tensor数据类型
介绍一下pytorch来获取bert词向量
05-10
首先，要使用PyTorch获取BERT词向量，需要安装Transformers库。Transformers库是一个基于PyTorch和TensorFlow的自然语言处理库，其中包含了BERT等预训练模型。 以下是获取BERT词向量的步骤： 1. 导入必要的库和模型 ```python import torch from transformers import BertTokenizer, BertModel # 加载预训练模型和词汇表 tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') model = BertModel.from_pretrained('bert-base-uncased') ``` 2. 输入文本，并进行分词 ```python # 输入文本 text = "Hello, how are you?" # 对文本进行分词 tokens = tokenizer.tokenize(text) # 将分词结果转换为模型可接受的输入格式 input_ids = torch.tensor(tokenizer.encode(text, add_special_tokens=True)).unsqueeze(0) ``` 3. 使用BERT模型获取词向量 ```python # 获取BERT模型的输出 outputs = model(input_ids) # 获取最后一层的输出，即词向量 last_hidden_states = outputs[0] ``` 最后，`last_hidden_states`即为BERT模型对输入文本中每个词的词向量表示。需要注意的是，`last_hidden_states`的形状为`(batch_size, sequence_length, hidden_size)`，其中`batch_size`为1，`sequence_length`为输入文本的长度，`hidden_size`为BERT模型的隐藏层的大小。如果需要获取整个文本的向量表示，可以对所有词向量取平均或加权平均。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值