《Tensorflow in partice》——Course 4. Sequences, Time Series and Prediction——week 4

最新推荐文章于 2022-12-07 22:56:13 发布
最新推荐文章于 2022-12-07 22:56:13 发布
阅读量414 收藏 2
点赞数
分类专栏： Tensorflow in practice 文章标签： tensorflow 神经网络 机器学习 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Minion_Yellow/article/details/106438442
版权

《Tensorflow in partice》——Course 4. Sequences, Time Series and Prediction——week 4

week 4.1

import tensorflow as tf
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)

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):
    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

建立模型：

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

window_size = 30
train_set = windowed_dataset(x_train, window_size, batch_size=128, shuffle_buffer=shuffle_buffer_size)

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.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),
  tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),
  tf.keras.layers.Dense(1),
  tf.keras.layers.Lambda(lambda x: x * 200)
])
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, 30])

在这里插入图片描述
添加conv1d层：

tf.keras.backend.clear_session()
tf.random.set_seed(51)
np.random.seed(51)
#batch_size = 16
dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)

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

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(dataset,epochs=500)

在这里插入图片描述

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
#-----------------------------------------------------------
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[200:]
mae_zoom = mae[200:]
loss_zoom = loss[200:]

#------------------------------------------------
# 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()

在这里插入图片描述

week 4.2

前面用的都是自己模型的虚拟数据，现在来使用真实的太阳光子的数据。

import tensorflow as tf
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)

添加数据：

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)

在这里插入图片描述
划分数据

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 = 60
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

训练模型：DNN

dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)

model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(20, input_shape=[window_size], activation="relu"), 
    tf.keras.layers.Dense(10, activation="relu"),
    tf.keras.layers.Dense(1)
])

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

验证数据：

forecast=[]
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)

在这里插入图片描述

# 误差
tf.keras.metrics.mean_absolute_error(x_valid, results).numpy()

在这里插入图片描述

week 4.3

import tensorflow as tf
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)

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)

在这里插入图片描述

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

建立模型：

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])

在这里插入图片描述
调整超参数：

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=500)

在这里插入图片描述

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[200:]
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()

在这里插入图片描述

小黄人的黄
关注
专栏目录
《Tensorflow in partice》——Course 4. Sequences, Time Series and Prediction——week 1
Minion_Yellow的博客
05-29 396
4.Sequences, Time Series and prediction 对序列数据的处理，过程依然和以前的一样， 需要划分训练数据和训练目标，第一周介绍序列数据的基本性质和概念，第二周构造数据进行预测，第三周RNN，第四周LSTM。 week 1.1 构造一些简单的序列，用以观察序列的性质。 # 导入第三方模块 import numpy as np import matplotlib.pyplot as plt #定义画时间序列图的函数 def plot_series(time,series):
Tensorflow in partice (lesson two)
Minion_Yellow的博客
05-15 392
Tensorflow in Parctice 中的第二们课程中涉及的代码，图片生成器、数据扩充、迁移学习、多分类任务
sequences-timeseries-and-prediction:@coursera“序列，时间序列和预测”课程的练习册和注释
03-13
sequences-timeseries-and-prediction:@coursera“序列，时间序列和预测”课程的练习册和注释
Cousera Sequence,Time Series and PredictionWK1
elsieyin的博客
04-20 540
本文内容为Cousera，deepAI， Tensorflow in practise的笔记，原视频地址 Time series examples It’s typically defined as an ordered sequence of values that are usually equally spaced over time. Univariant e.g. stock pric...
Sequences, Time Series and Prediction in Tessorflow quizs on Coursera (二）
jackhh1的博客
01-31 224
第二周 第三周 第四周：
《Tensorflow in partice》——Course 4. Sequences, Time Series and Prediction——week 2
Minion_Yellow的博客
05-29 432
Tensorflow in partice coures4 week2 训练序列数据
《Tensorflow in partice》——Course 4. Sequences, Time Series and Prediction——week 3
Minion_Yellow的博客
05-30 490
《Tensorflow in partice》——Course 4. Sequences, Time Series and Prediction——week 3 关于第四课序列数据的处理，第一周是处理数据构建虚拟的序列，通过分析序列的趋势性，周期性，噪声性，自相关性等。第二周是将序列数据通过window函数，将数据分为了sample和label。然后通过DNN来实现了对数据的预测，第三周通过调整数据的内部模型，通过RNN来实现对序列的预测。 week 3.1 import tensorflow as tf
Tensorflow in partice (lesson three) Course 3 Natural Language Processing in TensorFlow
Minion_Yellow的博客
05-22 427
自然语言处理： 创建语料库----对文本进行编码----送入模型------模型训练-----预测数据-----生成文本
Partice PG in TCL and TK
05-19
尽管从给定的文件片段中直接获取具体知识点存在困难，但通过对TCL和TK的总体了解，我们可以推断出“Partice PG in TCL and TK”可能是关于如何使用TCL/TK进行高级图形编程的技术讨论。考虑到作者Brent Welch是TCL...
Partice_Core
03-22
"Partice_Core"是一个专为构建粒子系统设计的框架，它在IT行业中主要用于创建复杂的视觉效果，如烟雾、火焰、水波等。粒子系统是一种常见的计算机图形学技术，广泛应用于游戏开发、影视特效和软件界面设计等领域。...
Keras中LSTM的return_sequences和return_state
Mr.horse的博客
07-25 2030
keras.layers.LSTM()函数有两个重要的参数return_sequences和return_state return_sequences和return_state默认都为false，接下来分别讲解当return_sequences和return_state取不同值时LSTM函数的返回值 return_sequences=True会返回每个时间步的隐藏状态，=False只会返回最后一个时间步的隐藏状态 return_state=True时会返回三个变量：lstm, state_h, sta
深度学习框架Keras介绍及实战
xiaoyaGrace的博客
12-30 319
Keras 是一个用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。Keras 的开发重点是支持快速的实验。能够以最小的时延把你的想法转换为实验结果，是做好研究的关键。 本文以Kaggle上的项目:IMDB影评情感分析为例,学习如何用K...
python在Keras中使用LSTM解决序列问题
最新发布
拓端研究室TRL
12-07 925
时间序列预测是指我们必须根据时间相关的输入来预测结果的问题类型。时间序列数据的典型示例是股市数据，其中股价随时间变化。 递归神经网络（RNN）已被证明可以有效解决序列问题。特别地，作为RNN的变体的长期短期记忆网络（LSTM）当前正在各种领域中用于解决序列问题。LSTM神经网络架构和原理及其在Python中的预测应用序列问题可以大致分为以下几类： 在本文中，我们将了解如何使用LSTM及其不同的变体来解决一对一和多对一的序列问题。 阅读本文后，您将能够基于历史数据解决诸如股价预测，天气预报等问题。由于文本也是
keras中lstm参数,Keras：了解可训练的LSTM参数的数量
weixin_34498545的博客
12-20 653
I have run a Keras LSTM demo containing the following code (after line 166):m = 1model=Sequential()dim_in = mdim_out = mnb_units = 10model.add(LSTM(input_shape=(None, dim_in),return_sequences=True,uni...
Lstm输入参数详细解释
weixin_44885180的博客
03-19 8003
Lstm输入参数详细解释： 比如建立双层lstm，以mnist数据集来进行叙述： 我们知道mnist数据集，是28*28；用lstm训练mnist数据集过程； def DoubleLSTM(train_x,train_y,valid_x,valid_y,test_x,test_y): #创建模型 model=Sequential() model.add(LSTM(64,input_shape=(28,28),return_sequences=True)) #返回所有节点的输出
使用TensorFlow训练神经网络进行价格预测
weixin_26752765的博客
09-07 1440
Using Deep Neural Networks for regression problems might seem like overkill (and quite often is), but for some cases where you have a significant amount of high dimensional data they can outperform an...
Pytorch 学习率衰减 lr_scheduler
人生当苦无妨
03-19 8414
torch.optim.lr_scheduler 提供了一些基于 epoch 调整学习率的方法，基本使用方法如下： optimizer = torch.optim.SGD(model.parameters(), lr=1e-2, momentum=0.9, weight_decay=1e-5) scheduler = torch.optim.lr_scheduler.xxx() for ep...
老外Sunspot案例
qq_43309133的博客
09-26 369
或另一种复杂模型（预测sunspot用的） 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.ke
时间序列预测15：Multi-input / Multi-head CNN 实现用电量/发电量预测
热门推荐
stay hungry, stay foolish
04-10 1万+
接上文，本文介绍如何为多变量数据开发多通道多步时间序列预测的CNN模型和多头多步时间序列预测的CNN模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值