第十五章双向LSTM时间预测

最新推荐文章于 2024-07-22 21:25:10 发布
最新推荐文章于 2024-07-22 21:25:10 发布
阅读量461 收藏 8
点赞数 8
文章标签： lstm 人工智能 rnn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45742413/article/details/134614103
版权
本文介绍了如何使用Python和TensorFlow构建双向LSTM神经网络进行时间序列预测，包括一个使用LR_scheduler动态调整学习率的模型和一个保持固定学习率的模型。实验展示了两种情况下预测结果和误差的对比。
摘要由CSDN通过智能技术生成

#从网上下载数据集生成时间序列
#搭建两个RNN神经网络，一个使用LR_scheduler机制调整学习率，另一个不做处理
#展示预测结果

import numpy as np
import matplotlib.pyplot as plt
def plot_series(time, series, format="-", start=0, end=None):
    plt.plot(time[start:end], series[start:end], format)
    plt.xlabel("Time")
    plt.ylabel("Value")
    plt.grid(True)

!wget --no-check-certificate \
    https://storage.googleapis.com/laurencemoroney-blog.appspot.com/Sunspots.csv \
    -O /tmp/sunspots.csv


# 从网上下载数据集生成时间序列
import csv
time_step = []
sunspots = []

with open('/tmp/sunspots.csv') as csvfile:
  reader = csv.reader(csvfile, delimiter=',')
  next(reader)
  for row in reader:
    sunspots.append(float(row[2]))
    time_step.append(int(row[0]))

series = np.array(sunspots)
time = np.array(time_step)
plt.figure(figsize=(10, 6))
plot_series(time, series)

在这里插入图片描述

series = np.array(sunspots)
time = np.array(time_step)
plt.figure(figsize=(10, 6))
plot_series(time, series)

在这里插入图片描述

split_time = 3000
time_train = time[:split_time]
x_train = series[:split_time]
time_valid = time[split_time:]
x_valid = series[split_time:]

window_size = 30
batch_size = 32
shuffle_buffer_size = 1000

def windowed_dataset(series, window_size, batch_size, shuffle_buffer):
    series = tf.expand_dims(series, axis=-1)
    ds = tf.data.Dataset.from_tensor_slices(series)
    ds = ds.window(window_size + 1, shift=1, drop_remainder=True)
    ds = ds.flat_map(lambda w: w.batch(window_size + 1))
    ds = ds.shuffle(shuffle_buffer)
    ds = ds.map(lambda w: (w[:-1], w[1:]))
    return ds.batch(batch_size).prefetch(1)

def model_forecast(model, series, window_size):
    ds = tf.data.Dataset.from_tensor_slices(series)
    ds = ds.window(window_size, shift=1, drop_remainder=True)
    ds = ds.flat_map(lambda w: w.batch(window_size))
    ds = ds.batch(32).prefetch(1)
    forecast = model.predict(ds)
    return forecast

# 搭建RNN神经网络，使用LR_scheduler机制调整学习率
tf.keras.backend.clear_session()
tf.random.set_seed(51)
np.random.seed(51)
window_size = 64
batch_size = 256
train_set = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)
print(train_set)
print(x_train.shape)

model = tf.keras.models.Sequential([
  tf.keras.layers.Conv1D(filters=32, kernel_size=5,
                      strides=1, padding="causal",
                      activation="relu",
                      input_shape=[None, 1]),
  tf.keras.layers.LSTM(64, return_sequences=True),
  tf.keras.layers.LSTM(64, return_sequences=True),
  tf.keras.layers.Dense(30, activation="relu"),
  tf.keras.layers.Dense(10, activation="relu"),
  tf.keras.layers.Dense(1),
  tf.keras.layers.Lambda(lambda x: x * 400)
])

lr_schedule = tf.keras.callbacks.LearningRateScheduler(
    lambda epoch: 1e-8 * 10**(epoch / 20))
optimizer = tf.keras.optimizers.SGD(lr=1e-8, momentum=0.9)
model.compile(loss=tf.keras.losses.Huber(),
              optimizer=optimizer,
              metrics=["mae"])
history = model.fit(train_set, epochs=100, callbacks=[lr_schedule])

在这里插入图片描述

plt.semilogx(history.history["lr"], history.history["loss"])
plt.axis([1e-8, 1e-4, 0, 60])

# 搭建RNN神经网络，使对学习率不作处理
tf.keras.backend.clear_session()
tf.random.set_seed(51)
np.random.seed(51)
train_set = windowed_dataset(x_train, window_size=60, batch_size=100, shuffle_buffer=shuffle_buffer_size)
model = tf.keras.models.Sequential([
  tf.keras.layers.Conv1D(filters=60, kernel_size=5,
                      strides=1, padding="causal",
                      activation="relu",
                      input_shape=[None, 1]),
  tf.keras.layers.LSTM(60, return_sequences=True),
  tf.keras.layers.LSTM(60, return_sequences=True),
  tf.keras.layers.Dense(30, activation="relu"),
  tf.keras.layers.Dense(10, activation="relu"),
  tf.keras.layers.Dense(1),
  tf.keras.layers.Lambda(lambda x: x * 400)
])


optimizer = tf.keras.optimizers.SGD(lr=1e-5, momentum=0.9)
model.compile(loss=tf.keras.losses.Huber(),
              optimizer=optimizer,
              metrics=["mae"])
history = model.fit(train_set,epochs=100)

# 展示预测结果，计算误差loss和平均绝对误差MAE
rnn_forecast = model_forecast(model, series[..., np.newaxis], window_size)
rnn_forecast = rnn_forecast[split_time - window_size:-1, -1, 0]

plt.figure(figsize=(10, 6))
plot_series(time_valid, x_valid)
plot_series(time_valid, rnn_forecast)

tf.keras.metrics.mean_absolute_error(x_valid, rnn_forecast).numpy()

import matplotlib.image  as mpimg
import matplotlib.pyplot as plt

#-----------------------------------------------------------
# Retrieve a list of list results on training and test data
# sets for each training epoch
#-----------------------------------------------------------
loss=history.history['loss']

epochs=range(len(loss)) # Get number of epochs


#------------------------------------------------
# Plot training and validation loss per epoch
#------------------------------------------------
plt.plot(epochs, loss, 'r')
plt.title('Training loss')
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend(["Loss"])

plt.figure()                                            



zoomed_loss = loss[20:]
zoomed_epochs = range(200,500)


#------------------------------------------------
# Plot training and validation loss per epoch
#------------------------------------------------
plt.plot(zoomed_epochs, zoomed_loss, 'r')
plt.title('Training loss')
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend(["Loss"])

plt.figure()

print(rnn_forecast)

双向LSTM时间预测：

# 模拟生成时间序列
# 模拟生成数据集
# 搭建两个LSTM神经网络，一个使用LR_scheduler机制调整学习率，另一个不做处理
# 结果对比，计算误差loss和平均绝对误差MAE

!pip install tf-nightly-2.0-preview

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
print(tf.__version__)

在这里插入图片描述

# 模拟生成时间序列
def plot_series(time, series, format="-", start=0, end=None):
    plt.plot(time[start:end], series[start:end], format)
    plt.xlabel("Time")
    plt.ylabel("Value")
    plt.grid(True)

def trend(time, slope=0):
    return slope * time

def seasonal_pattern(season_time):
    """Just an arbitrary pattern, you can change it if you wish"""
    return np.where(season_time < 0.4,
                    np.cos(season_time * 2 * np.pi),
                    1 / np.exp(3 * season_time))

def seasonality(time, period, amplitude=1, phase=0):
    """Repeats the same pattern at each period"""
    season_time = ((time + phase) % period) / period
    return amplitude * seasonal_pattern(season_time)

def noise(time, noise_level=1, seed=None):
    rnd = np.random.RandomState(seed)
    return rnd.randn(len(time)) * noise_level

time = np.arange(4 * 365 + 1, dtype="float32")
baseline = 10
series = trend(time, 0.1)  
baseline = 10
amplitude = 40
slope = 0.05
noise_level = 5

# Create the series
series = baseline + trend(time, slope) + seasonality(time, period=365, amplitude=amplitude)
# Update with noise
series += noise(time, noise_level, seed=42)

split_time = 1000
time_train = time[:split_time]
x_train = series[:split_time]
time_valid = time[split_time:]
x_valid = series[split_time:]

window_size = 20
batch_size = 32
shuffle_buffer_size = 1000

在这里插入图片描述

# 模拟生成数据集
def windowed_dataset(series, window_size, batch_size, shuffle_buffer):
  dataset = tf.data.Dataset.from_tensor_slices(series)
  dataset = dataset.window(window_size + 1, shift=1, drop_remainder=True)
  dataset = dataset.flat_map(lambda window: window.batch(window_size + 1))
  dataset = dataset.shuffle(shuffle_buffer).map(lambda window: (window[:-1], window[-1]))
  dataset = dataset.batch(batch_size).prefetch(1)
  return dataset


# 搭建双向LSTM神经网络，使用LR_scheduler机制调整学习率

tf.keras.backend.clear_session()
tf.random.set_seed(51)
np.random.seed(51)

tf.keras.backend.clear_session()
dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)

model = tf.keras.models.Sequential([
  tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),
                      input_shape=[None]),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
  tf.keras.layers.Dense(1),
  tf.keras.layers.Lambda(lambda x: x * 100.0)
])

lr_schedule = tf.keras.callbacks.LearningRateScheduler(
    lambda epoch: 1e-8 * 10**(epoch / 20))
optimizer = tf.keras.optimizers.SGD(lr=1e-8, momentum=0.9)
model.compile(loss=tf.keras.losses.Huber(),
              optimizer=optimizer,
              metrics=["mae"])
history = model.fit(dataset, epochs=100, callbacks=[lr_schedule])

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

plt.semilogx(history.history["lr"], history.history["loss"])
plt.axis([1e-8, 1e-4, 0, 30])

在这里插入图片描述
在这里插入图片描述

# 搭建双向LSTM神经网络，对学习率不作处理
tf.keras.backend.clear_session()
tf.random.set_seed(51)
np.random.seed(51)

tf.keras.backend.clear_session()
dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)

model = tf.keras.models.Sequential([
  tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),
                      input_shape=[None]),
   tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
  tf.keras.layers.Dense(1),
  tf.keras.layers.Lambda(lambda x: x * 100.0)
])


model.compile(loss="mse", optimizer=tf.keras.optimizers.SGD(lr=1e-5, momentum=0.9),metrics=["mae"])
history = model.fit(dataset,epochs=100,verbose=0)

在这里插入图片描述

forecast = []
results = []
for time in range(len(series) - window_size):
  forecast.append(model.predict(series[time:time + window_size][np.newaxis]))

forecast = forecast[split_time-window_size:]
results = np.array(forecast)[:, 0, 0]


plt.figure(figsize=(10, 6))

plot_series(time_valid, x_valid)
plot_series(time_valid, results)

在这里插入图片描述

# 结果对比，计算误差loss和平均绝对误差MAE
tf.keras.metrics.mean_absolute_error(x_valid, results).numpy()

7.344548

在这里插入图片描述

import matplotlib.image  as mpimg
import matplotlib.pyplot as plt

#-----------------------------------------------------------
# Retrieve a list of list results on training and test data
# sets for each training epoch
#-----------------------------------------------------------
mae=history.history['mae']
loss=history.history['loss']

epochs=range(len(loss)) # Get number of epochs

#------------------------------------------------
# Plot MAE and Loss
#------------------------------------------------
plt.plot(epochs, mae, 'r')
plt.plot(epochs, loss, 'b')
plt.title('MAE and Loss')
plt.xlabel("Epochs")
plt.ylabel("Accuracy")
plt.legend(["MAE", "Loss"])

plt.figure()

epochs_zoom = epochs[20:]
mae_zoom = mae[20:]
loss_zoom = loss[20:]

#------------------------------------------------
# Plot Zoomed MAE and Loss
#------------------------------------------------
plt.plot(epochs_zoom, mae_zoom, 'r')
plt.plot(epochs_zoom, loss_zoom, 'b')
plt.title('MAE and Loss')
plt.xlabel("Epochs")
plt.ylabel("Accuracy")
plt.legend(["MAE", "Loss"])

plt.figure()

在这里插入图片描述
在这里插入图片描述

# 调整不同的学习率和神经网络层数来训练
tf.keras.backend.clear_session()
dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)

model = tf.keras.models.Sequential([
  tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),
                      input_shape=[None]),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
  tf.keras.layers.Dense(1),
  tf.keras.layers.Lambda(lambda x: x * 100.0)
])


model.compile(loss="mse", optimizer=tf.keras.optimizers.SGD(lr=1e-6, momentum=0.9))
model.fit(dataset,epochs=100, verbose=0)

tf.keras.backend.clear_session()
dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)

model = tf.keras.models.Sequential([
  tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),
                      input_shape=[None]),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
  tf.keras.layers.Dense(1),
  tf.keras.layers.Lambda(lambda x: x * 100.0)
])


model.compile(loss="mse", optimizer=tf.keras.optimizers.SGD(lr=1e-6, momentum=0.9))
model.fit(dataset,epochs=100)

在这里插入图片描述

清☆茶
关注
BiLSTM(双向LSTM)实现时间序列预测(PyTorch版)
CSDN 精品推荐
01-12 3507
本专栏整理了《深度学习时间序列预测案例》，内包含了各种不同的基于深度学习模型的时间序列预测方法，例如LSTM、GRU、CNN（一维卷积、二维卷积）、LSTM-CNN、BiLSTM、Self-Attention、LSTM-Attention、Transformer等经典模型，包含项目原理以及源码，每一个项目实例都附带有完整的代码+数据集。
使用双向 LSTM 网络的需求预测：使用双向长短期记忆 (biLSTM) 的需求预测-matlab开发
05-29
使用双向长短期记忆 (biLSTM) 进行需求预测这是一个回归问题。 在这个问题中，我们想根据过去记录中的 3 个因素来预测未来的需求。 您可以更改选择的数量（过去的记录数量）。 此外，您可以更改输入的数量。 例如，您也可以包括过去的需求，或删除一些输入。
双向长短期记忆网络（BiLSTM）及其Python和MATLAB实现
最新发布
qq_45441438的博客
07-22 1046
除了基本的LSTM结构外，双向长短期记忆网络（Bidirectional LSTM，BiLSTM）是在LSTM的基础上发展而来，结合了前向和后向的信息流，能更全面地理解和分析输入序列的语义。LSTM引入了三个门控单元：遗忘门、输入门和输出门，以及一个细胞状态，能够控制信息的流动和记忆。总之，BiLSTM作为一种强大的序列建模工具，在各种任务中都展现了出色的性能，它的双向结构使得模型能够更好地理解和处理输入序列中的相关信息，为深度学习在序列数据处理中带来了重要的进展和应用。% numWords为单词数量。
【Python时序预测系列】基于双向LSTM实现单变量时间序列预测（源码）
数据杂坛
03-21 546
基于双向LSTM实现单变量时间序列预测（源码）
基于双向LSTM模型进行电力需求预测（Matlab代码实现）
weixin_46039719的博客
08-15 764
基于双向LSTM模型进行电力需求预测（Matlab代码实现）
LSTM实现时间序列预测(PyTorch版)
CSDN 精品推荐
01-09 1万+
为了训练数据，首先定义LSTM模型，然后再定义对应的损失函数，由于我们这里是风速预测，显然是个回归问题，所以采用回归问题常用的MESLoss()，如果可以的话，可以自定义损失函数，针对自己的项目需求定义对应的损失函数。对于优化器来讲，使用的也是目前常用的Adam优化器，对于新手来讲也可以多多尝试其它的优化器，比如SGDRMSprop等，对于优化器的选择，可以参考这篇文章Pytorch 30种优化器总结。
时间序列预测 — BiLSTM实现多变量多步光伏预测(Tensorflow)
几度春风里的博客
12-09 1706
通过前5天的timesteps数据预测后一天的数据predict_steps个，需要对数据集进行滚动划分（也就是前timesteps行的特征和后predict_steps行的标签训练，后面预测时就可通过timesteps行特征预测未来的predict_steps个标签）。通过前5天的96*5数据预测后一天的数据96个，需要对数据集进行滚动划分（也就是前96*5行的特征和后96行的标签训练，后面预测时就可通过96*5行特征预测未来的96个标签）构造训练数据，也是真正预测未来的关键。网络模块的链式形式。
【BiLSTM数据预测】基于matlab双向长短时记忆BiLSTM数据预测【含Matlab源码 1824期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
03-28 4662
双向长短时记忆BiLSTM数据预测 完整代码和数据，数据可直接替换，适合小白！可提供运行操作视频！
Keras深度学习实战（33）——基于LSTM的序列预测模型
盼小辉丶的博客
11-02 5922
长短时记忆网络 (LSTM) 可以返回最后一个时间戳的结果，即输出为一维数据，而多对多神经网络架构输出为多个维度，其中每个维度对应一个输出，而非多个类别的 softmax 激活函数值。例如，在股价预测中，我们可以使用多对多神经网络架构预测未来 5 天的股价，而不仅是下一个交易日的股价。在这类情况下，我们构建神经网络模型的方式有所不同。本文基于 LSTM 研究各类不同模型的序列预测问题，包括一对一架构以及多对多架构，并且通过实战验证了不同架构的输出结果。
BiLSTM 实现股票多变量时间序列预测(PyTorch版)
君子不器 大道无方
07-17 1372
在本文中，我们将探讨如何使用PyTorch框架实现基于双向长短期记忆网络（BiLSTM）的多变量时间序列预测模型。多变量时间序列预测涉及多个输入变量和一个或多个输出变量，这些变量随时间变化并可能相互影响。通过利用BiLSTM的双向特性，我们的模型将能够同时考虑历史数据和未来趋势，从而更准确地预测时间序列的未来值。
【LSTM预测】基于双向长短时记忆（biLSTM）实现数据回归预测含Matlab源码.zip
06-04
擅长智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真。
股票预测（LSTM）
01-24
文件利用lstm进行股票第二日最高价预测，偏差大概在百分之一点五左右，里面有数据集，还有其他获取数据的代码，是进行预测的方法
双向 LSTM
极客X养成计划
08-11 3587
本文结构：为什么用双向 LSTM什么是双向 LSTM例子为什么用双向 LSTM？单向的 RNN，是根据前面的信息推出后面的，但有时候只看前面的词是不够的，例如，我今天不舒服，我打算__一天。只根据‘不舒服‘，可能推出我打算‘去医院‘，‘睡觉‘，‘请假‘等等，但如果加上后面的‘一天‘，能选择的范围就变小了，‘去医院‘这种就不能选了，而‘请假‘‘休息‘之类的被选择概率就会更大。什么是双向 LSTM？双
时间序列预测——双向LSTM(Bi-LSTM)
行者无疆的博客
04-12 2万+
  本文展示了使用双向LSTM(Bi-LSTM)进行时间序列预测的全过程，包含详细的注释。整个过程主要包括：数据导入、数据清洗、结构转化、建立Bi-LSTM模型、训练模型（包括动态调整学习率和earlystopping的设置）、预测、结果展示、误差评估等完整的时间序列预测流程。   本文使用的数据集在本人上传的资源中，链接为mock_kaggle.csv 代码如下： import pandas as pd import numpy as np import math import keras from ma
深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
热门推荐
KI的博客
01-18 8万+
深入理解PyTorch中LSTM的输入和输出（从input输入到Linear输出）
【Python时序预测系列】基于双向LSTM实现多变量时间序列预测（案例+源码）
数据杂坛
04-10 492
基于双向LSTM实现多变量时间序列预测（案例+源码）
（五）通俗易懂理解——双向LSTM
qq_36696494的博客
04-04 6万+
中文翻译作者博客：https://www.cnblogs.com/wangduo/p/6773601.html?utm_source=itdadao&utm_medium=referral 英文原文作者网址：http://colah.github.io/posts/2015-08-Understanding-LSTMs/ 参考相关网址：https://www.imooc.com/art...
双向lstm回归预测pytorch
11-27
双向 LSTM 是一种循环神经网络（RNN）的变体，在处理序列数据时表现出色。PyTorch 是一种广泛使用的深度学习框架，它提供了便捷的工具和函数来构建和训练神经网络模型。 使用 PyTorch 来进行双向 LSTM 的回归预测非常简单。首先，我们需要导入 PyTorch 的相关库： ```python import torch import torch.nn as nn import torch.optim as optim ``` 接下来，我们需要定义一个双向 LSTM 模型的类，可以继承自 PyTorch 的 nn.Module 类。在该类中，我们需要定义模型的初始化方法、前向传播方法和初始化隐藏状态的方法。 ```python class BiLSTM(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(BiLSTM, self).__init__() self.hidden_size = hidden_size self.lstm = nn.LSTM(input_size, hidden_size, bidirectional=True) self.linear = nn.Linear(hidden_size*2, output_size) def forward(self, sequence): outputs, _ = self.lstm(sequence) prediction = self.linear(outputs[-1]) return prediction def init_hidden(self): return (torch.zeros(2, 1, self.hidden_size), torch.zeros(2, 1, self.hidden_size)) ``` 在这个双向 LSTM 模型中，我们使用了一个 LSTM 层，它将输入序列作为输入，并返回每个时间步的输出序列。我们还通过一个线性层将最后一个时间步的输出转换为预测结果。 接下来，我们可以定义数据集和训练过程。在这里，我们假设有一个包含多个序列的训练集和相应的目标值。我们可以使用均方误差（MSE）作为损失函数，使用随机梯度下降（SGD）作为优化器。 ```python # 定义训练集和目标值 train_sequences = ... train_targets = ... # 定义模型 model = BiLSTM(input_size, hidden_size, output_size) # 定义损失函数和优化器 criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=0.1) # 进行训练 for epoch in range(num_epochs): model.init_hidden() optimizer.zero_grad() # 前向传播 prediction = model(train_sequences) # 计算损失 loss = criterion(prediction, train_targets) # 反向传播 loss.backward() optimizer.step() ``` 以上就是使用 PyTorch 中的双向 LSTM 进行回归预测的简单示例。要注意的是，这只是一个基本的框架，你可能需要根据具体的数据和需求进行调整和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值