精华内容
下载资源
问答
  • 【pytorch】构建多元时间序列数据集 Dataset
    千次阅读
    2020-05-21 19:19:56

    假设原本数据集是如下的 csv 格式,行代表时间,列数代表变量数。
    在这里插入图片描述

    用它来构造机器学习的数据集,也就是有监督标签的样本。

    在这里插入图片描述

    代码一

    import torch
    import torch.utils.data
    import os
    import numpy as np
    import pandas as pd
    
    class MTSDataset(torch.utils.data.Dataset):
        """Multi-variate Time-Series Dataset for *.txt file
    
        Returns:
            [sample, label]
        """
    
        def __init__(self,
                    window,
                    horizon,
                    data_name='electricity',
                    set_type='train',    # 'train'/'validation'/'test'
                    data_dir='./data'):
            assert type(set_type) == type('str')
            self.window = window
            self.horizon = horizon
            self.data_dir = data_dir
            self.set_type = set_type
    
            file_path = os.path.join(data_dir, data_name, '{}_{}.txt'.format(data_name, set_type))
    
            rawdata = np.loadtxt(open(file_path), delimiter=',')
            self.len, self.var_num = rawdata.shape
            self.sample_num = max(self.len - self.window - self.horizon + 1, 0)
            self.samples, self.labels = self.__getsamples(rawdata)
    
        def __getsamples(self, data):
            X = torch.zeros((self.sample_num, self.window, self.var_num))
            Y = torch.zeros((self.sample_num, 1, self.var_num))
    
            for i in range(self.sample_num):
                start = i
                end = i + self.window
                X[i, :, :] = torch.from_numpy(data[start:end, :])
                Y[i, :, :] = torch.from_numpy(data[end+self.horizon-1, :])
    
            return (X, Y)
    
        def __len__(self):
            return self.sample_num
    
        def __getitem__(self, idx):
            sample = [self.samples[idx, :, :], self.labels[idx, :, :]]
            return sample
    
    
    dataset = MTSDataset(
        window=16,
        horizon=3,
        data_name='electricity',
        set_type='train',
        data_dir='.'
    )
    i = 0
    sample = dataset[i]
    print(sample[0].shape)  # torch.Size([16, 321])
    print(sample[1].shape)  # torch.Size([1, 321])
    
    

    代码二

    import torch
    import numpy as np
    from torch.autograd import Variable
    
    
    def normal_std(x):
        return x.std() * np.sqrt((len(x) - 1.)/(len(x)))   # 样本标准差转化成总体标准差
    
    class Data_utility(object):
        # train and valid is the ratio of training set and validation set. test = 1 - train - valid
        def __init__(self, file_name, train, valid, cuda, horizon, window, normalize = 2):
            self.cuda = cuda;
            self.P = window;
            self.h = horizon
            fin = open(file_name);
            self.rawdat = np.loadtxt(fin,delimiter=',');
            self.dat = np.zeros(self.rawdat.shape);
            self.n, self.m = self.dat.shape;
            self.normalize = 2
            self.scale = np.ones(self.m)  # 维数等于数据列数
            self._normalized(normalize)   # 当 normalize = 2, 修改 scale 为每一列的最大绝对值, 使每列数据绝对值最大值为 1
            self._split(int(train * self.n), int((train+valid) * self.n), self.n)
            
            self.scale = torch.from_numpy(self.scale).float()
            tmp = self.test[1] * self.scale.expand(self.test[1].size(0), self.m)  # shape: [batch, n_var]
                
            if self.cuda:
                self.scale = self.scale.cuda();
            self.scale = Variable(self.scale);
            
            self.rse = normal_std(tmp);
            self.rae = torch.mean(torch.abs(tmp - torch.mean(tmp)));
        
        def _normalized(self, normalize):
           
            if (normalize == 0):
                self.dat = self.rawdat
            
            #normalized by the maximum value of entire matrix.
            if (normalize == 1):
                self.dat = self.rawdat / np.max(self.rawdat);
                
            #normlized by the maximum value of each column(sensor).
            if (normalize == 2):
                for i in range(self.m):
                    self.scale[i] = np.max(np.abs(self.rawdat[:,i]))
                    self.dat[:,i] = self.rawdat[:,i] / self.scale[i]
                
            
        def _split(self, train, valid, test):
            
            train_set = range(self.P+self.h-1, train);
            valid_set = range(train, valid)
            test_set = range(valid, self.n)
            self.train = self._batchify(train_set, self.h)  # [batch, p, n_multiv], [batch, n_multiv]
            self.valid = self._batchify(valid_set, self.h)
            self.test = self._batchify(test_set, self.h)
            
            
        def _batchify(self, idx_set, horizon):
            
            n = len(idx_set);
            X = torch.zeros((n,self.P,self.m));
            Y = torch.zeros((n,self.m));
            
            for i in range(n):
                end = idx_set[i] - self.h + 1;
                start = end - self.P;
                X[i,:,:] = torch.from_numpy(self.dat[start:end, :]);
                Y[i,:] = torch.from_numpy(self.dat[idx_set[i], :]);
    
            return [X, Y];
    
        def get_batches(self, inputs, targets, batch_size, shuffle=True):
            length = len(inputs)
            if shuffle:
                index = torch.randperm(length)
            else:
                index = torch.LongTensor(range(length))
            start_idx = 0
            while (start_idx < length):
                end_idx = min(length, start_idx + batch_size)
                excerpt = index[start_idx:end_idx]
                X = inputs[excerpt]; Y = targets[excerpt];
                if (self.cuda):
                    X = X.cuda();
                    Y = Y.cuda();  
                yield Variable(X), Variable(Y);
                start_idx += batch_size
    
    
    data = Data_utility(file_name='solar_AL.txt', train=0.6, valid=0.2, cuda=False, horizon=12, window=24, normalize = 2)
    print(data.rawdat.shape)  # (52560, 137)
    print(data.train[0].shape, data.train[1].shape)  # torch.Size([31501, 24, 137]) torch.Size([31501, 137])
    
    def train(data, X, Y, model, criterion, optim, batch_size):
        model.train();
        total_loss = 0;
        n_samples = 0;
        for X, Y in data.get_batches(X, Y, batch_size, True):   # <<< attention!
            model.zero_grad();
            output = model(X);
            scale = data.scale.expand(output.size(0), data.m)   # <<< attention!
            loss = criterion(output * scale, Y * scale);
            loss.backward();
            grad_norm = optim.step();
            total_loss += loss.item();
            n_samples += (output.size(0) * data.m);
        return total_loss / n_samples
    

    参考文献

    1. DSANet: Dual Self-Attention Network for Multivariate Time Series Forecasting
    2. Modeling Long- and Short-Term Temporal Patterns with Deep Neural Networks
    更多相关内容
  • 数据集描述包括样本数量、类别数、特征数、时间序列长度,除了Libras数据集时间序列长度为等长的,其他数据集时间序列长度为不等长。
  • 时间序列界的“Imagnet”,发文章必跑数据集。大约有128个数据集,如ECG5000,GunPoint,coffee等数据集 相比于2015版有了大量更新,2018年秋季:该数据资源的早期工作由NSF职业奖0237918资助,并通过NSF IIS-...
  • 时间序列数据集(UCR).rar
  • 电力需求分析 在时间序列数据集上分析房屋的电力需求。 还使用基于电力需求的 K-Means 聚类创建了电器检测系统。
  • 单变量时间序列公开数据集,格式.csv,字段Datetime和AEP_MW,时间间隔为小时!
  • 城市轨道客流时间序列数据集
  • 超级商店时间序列数据集。超市购买的时间序列数据,可以训练和测试您的模型。 superstore_test.csv test_result.csv superstore_train.csv
  • 前言数据是驱动科技发展的源泉,平时我们科研中也经常需要在各种开源数据上验证自己模型的效果。那时间序列目前可以使用的开源数据集有哪些呢?本期为大家做一次较为全面的整理汇总。UCR Time ...

    前言

    数据是驱动科技发展的源泉,平时我们科研中也经常需要在各种开源数据上验证自己模型的效果。那时间序列目前可以使用的开源数据集有哪些呢?本期为大家做一次较为全面的整理汇总。

    UCR Time Series

    UCR时间序列数据集是时序领域的“Imagnet”,涵盖医疗/电力/地理 等诸多领域,目前全量数据有128种。涉及时间序列预测、回归、聚类等诸多任务,可以说是发Paper必跑数据集,由加州大学河滨分校计算机系的教授 Eamonn Keogh 所在的课题组维护。

    http://www.cs.ucr.edu/~eamonn/time_series_data/

    FigShare

    figShare是一个研究成果共享平台,这里向全世界开放免费的研究成果及科学数据。

    https://figshare.com/

    Awesome Public Datasets


    该项目提供了一个非常全面的数据获取渠道,包含各个细分领域的数据库资源,自然科学和社会科学的覆盖都很全面,适合做研究和数据分析的人员。

    https://github.com/awesomedata/awesome-public-datasets

    服务监控数据集

    该数据集是由人工神经网络公司Numenta所提供的,包含互联网服务场景下的各种流式数据与评测脚本。NAB是用于评估数据流实时应用中异常检测算法的新颖基准,它由50多个带有标签的真实世界和人工时间序列数据文件以及为实时应用程序设计的新颖评分机制组成。

    https://github.com/numenta/NAB

    音乐数据库


    这个数据集包含了海量的公开音乐数据库,适用于包含音乐推荐、分类在内的各种任务

    http://millionsongdataset.com/

    mir_datas

    国家经济数据库

    国家统计局经常会统计涉及经济民生等多个方面的指标,提供了非常丰富的开源时间序列数据。这里简单为大家列举一些可以获取这些数据的渠道:

    国家数据

    数据来源中华人民共和国国家统计局,包含了我国经济民生等多个方面的数据,并且在月度、季度、年度都有覆盖,较为全面。

    https://data.stats.gov.cn/

    CEIC

    涵盖超过195个国家400多万个时间序列的数据源,最完整的一套超过128个国家的经济数据,能够精确查找GDP、CPI、进口、出口、外资直接投资、零售、销售以及国际利率等深度数据。

    https://www.ceicdata.com/zh-hans

    万得

    被誉为中国的Bloomberg,在金融业有着全面的数据覆盖,金融数据的类目更新非常快,据说很受国内的商业分析者和投资人的亲睐。

    https://www.wind.com.cn/

    中国统计信息网

    国家统计局的官方网站,汇集了全国各级政府各年度的国民经济和社会发展统计信息,建立了以统计公报为主,统计年鉴、阶段发展数据、统计分析、经济新闻、主要统计指标排行等。

    http://www.tjcn.org/

    政府开放数据

    除了上述国家经济数据库以外,各地方也有自己的开放数据。这里简单列举:

    · 北京市政务数据资源网:包含竞技、交通、医疗、天气等数据。

    https://data.beijing.gov.cn/

    · 深圳市政府数据开放平台:交通、文娱、就业、基础设施等数据。

    https://opendata.sz.gov.cn/

    · 上海市政务数据服务网:覆盖经济建设、文化科技、信用服务、交通出行等12个重点领域数据。

    https://data.sh.gov.cn/

    · 贵州省政府数据开放平台:贵州省在政务数据开放方面做的确实不错。

    http://data.guizhou.gov.cn/

    · Data.Gov:美国政府开放数据,包含气候、教育、能源金融等各领域数据。

    https://www.data.gov/

    ts_0.

    数据竞赛平台

    除了上面整理的常用的开源时间序列数据以外,我们如果想获取针对特定任务的时间序列数据,还可以通过各种竞赛平台获取数据。这些数据集通常干净且科研性非常高。包括:

    • DataCastle:专业的数据科学竞赛平台 

      https://js.dclab.run/v2/index.html

    • Kaggle:全球最大的数据竞赛平台 

      https://www.kaggle.com/

    • 天池:阿里旗下数据科学竞赛平台

      https://tianchi.aliyun.com/

    • Datafountain:CCF制定大数据竞赛平台

      https://www.datafountain.cn/

    展开全文
  • 开源时间序列数据集

    千次阅读 2021-01-21 09:22:19
    数据是驱动科技发展的源泉,我们平常科研中也常常需要在各种开源数据上验证自己模型的效果。时间序列目前可以使用的开源数据集有哪些呢?本期为大家做一次梳理。

    关注微信公众号“时序人”获取更好的阅读体验
    在这里插入图片描述

    时间序列学术前沿

    1. NeurIPS 2020 | 时间序列相关论文一览
    2. ICML 2020 | 时间序列相关论文一览
    3. KDD 2020 | 时间序列相关论文一览
    4. 智能运维 | 故障诊断与根因分析论文一览
    5. WWW 2020 | 通过多源时间序列诊断微服务故障根因
    6. WWW 2020 | 多源时序数据驱动用于窃电行为识别
    7. AAAI 2020 | 时序转化为图用于可解释可推理的异常检测
    8. KDD 2018 | 小波分解网络用于可解释的时间序列分析
    9. RRCF: 基于数据流的时序实时异常检测

    数据是驱动科技发展的源泉,我们平常科研中也常常需要在各种开源数据上验证自己模型的效果。时间序列目前可以使用的开源数据集有哪些呢?本期为大家做一次梳理。

    UCR Time Series

    在这里插入图片描述

    UCR时间序列数据集是时序领域的“Imagnet”,涵盖医疗/电力/地理 等诸多领域,目前全量数据有128种。涉及时间序列预测,回归,聚类等诸多任务,可以说是发Paper必跑数据集,由加州大学河滨分校计算机系的教授 Eamonn Keogh 所在的课题组维护

    http://www.cs.ucr.edu/~eamonn/time_series_data/

    FigShare

    在这里插入图片描述
    这是一个研究成果共享平台,这里向全世界开放免费的研究成果及科学数据。

    https://figshare.com/

    Awesome Public Datasets

    在这里插入图片描述
    该项目提供了一个非常全面的数据获取渠道,包含各个细分领域的数据库资源,自然科学和社会科学的覆盖都很全面,适合做研究和数据分析的人员。

    https://github.com/awesomedata/awesome-public-datasets

    服务监控数据集

    在这里插入图片描述
    该数据集是由人工神经网络公司Numenta所提供的,包含互联网服务场景下的各种流式数据与评测脚本。 NAB是用于评估数据流实时应用中异常检测算法的新颖基准,它由50多个带有标签的真实世界和人工时间序列数据文件以及为实时应用程序设计的新颖评分机制组成。

    https://github.com/numenta/NAB

    音乐数据库

    在这里插入图片描述
    这是数据集包含了海量的公开音乐数据库,适用于包含音乐推荐、分类在内的各种任务

    http://millionsongdataset.com/

    国家经济数据

    国家统计局经常会统计涉及经济民生等多个方面的指标,提供了非常丰富的开源时间序列数据。这里简单为大家列举一些可以获取这些数据的渠道:

    国家数据

    在这里插入图片描述
    数据来源中华人民共和国国家统计局,包含了我国经济民生等多个方面的数据,并且在月度、季度、年度都有覆盖,较为全面。

    https://data.stats.gov.cn/

    CEIC

    在这里插入图片描述
    涵盖超过195个国家400多万个时间序列的数据源,最完整的一套超过128个国家的经济数据,能够精确查找GDP、CPI、进口、出口、外资直接投资、零售、销售以及国际利率等深度数据。

    https://www.ceicdata.com/zh-hans

    万得

    在这里插入图片描述
    被誉为中国的Bloomberg,在金融业有着全面的数据覆盖,金融数据的类目更新非常快,据说很受国内的商业分析者和投资人的亲睐。

    https://www.wind.com.cn/

    中国统计信息网

    在这里插入图片描述

    国家统计局的官方网站,汇集了全国各级政府各年度的国民经济和社会发展统计信息,建立了以统计公报为主,统计年鉴、阶段发展数据、统计分析、经济新闻、主要统计指标排行等。

    http://www.tjcn.org/

    政府开放数据

    数据竞赛网站

    除了上面整理的常用的开源时间序列数据以外,如果我们想获取针对特定任务的时间序列数据,我们常常可以通过各种竞赛平台获取数据。这些数据集通常干净且科研性非常高。包括:


    更多原创内容与系列分享,欢迎关注微信公众号“时序人”获取。
    在这里插入图片描述

    展开全文
  • 截止到目前最新整理的的UCR数据集(UCRArchive)。这是以一个完整的压缩包,共有129个数据集。压缩包没有解压码。
  • 非线性时间序列 建模 预测>>书的数据集以及代码
  • 通过数学模型介绍了,非常热门,应用广泛,高大上的一些机器学习模型
  • 第1章 数据集 1.1 数据集概述 1.2 从文件中读取数据 1.3 提取有效数据 第2章 全连接网络的拟合 2.1 定义全连接网络 2.2 定义loss与优化器 2.3 训练前准备 2.4 开始训练 2.5 loss显示 2.6 结果分析 第3章...

    作者主页(文火冰糖的硅基工坊):文火冰糖(王文兵)的博客_文火冰糖的硅基工坊_CSDN博客

    本文网址:https://blog.csdn.net/HiWangWenBing/article/details/121526014


    目录

    第1章 概述

    1.1 业务需求概述

    1.2 业务分析

    1.3 导入库

    第1章 数据集

    1.1 数据集概述

    1.2 从文件中读取数据

    1.3 提取有效数据

    第2章 全连接网络的拟合

    2.1 定义全连接网络

    2.2 定义loss与优化器

    2.3 训练前准备

    2.4 开始训练

    2.5 loss显示 

    2.6 结果分析

    第3章 RNN网络的拟合

    3.1 定义RNN网络

    3.2 生成网络

    3.3 定义loss与优化器

    3.4 训练前的准备

    3.5 开始训练

    3.6 显示loss

    3.7 分析



    第1章 概述

    1.1 业务需求概述

    有一批最近52周的销售数据,希望能够根据这些数据,预测未来几周销售数据。

    1.2 业务分析

    这是一个线性拟合的问题,那么每周的数据之间是独立的?还是每周的数据之间有时间的相关性?

    本文就采用层数的全连接网络和RNN网络对数据进行拟合与比较。

    如果全连接网络的拟合度比RNN网络好,则证明每周的数据是独立无关的。

    如果全连接网络的拟合度没有RNN网络好,则证明每周的数据是具有时间相关性。

    1.3 导入库

    %matplotlib inline
    import torch
    import torch.nn as nn
    from torch.nn import functional as F
    from torch.autograd import Variable
    from torch import optim
    
    import numpy as np
    import math, random
    import matplotlib.pyplot as plt
    import pandas as pd
    
    from torch.utils.data import Dataset
    from torch.utils.data import DataLoader
    

    第1章 数据集

    1.1 数据集概述

    销售数据是通过Excel存放的:包含多个样本数据,每个样本包含52周的数据,如下图所示:

    横轴:不同的样本

    纵轴:每个样本包含的序列52周的销售数据。

    1.2 从文件中读取数据

    # 从excel文件中数据
    sales_data = pd.read_csv('time_serise_sale.csv')
    
    sales_data.head()

    1.3 提取有效数据

    # 提取有效数据
    source_data = sales_data
    source_data.values.shape
    source_data.values
    array([[0.00000000e+00, 2.29157429e+00, 2.88283833e+00, ...,
            2.52078778e+00, 2.63721001e+00, 2.74892268e+00],
           [1.00000000e+00, 6.09664112e-01, 2.52360427e+00, ...,
            1.66285479e+00, 2.48192522e+00, 2.41120153e+00],
           [2.00000000e+00, 3.42279275e+00, 1.81265116e+00, ...,
            1.72005177e+00, 2.16993942e+00, 2.16170153e+00],
           ...,
           [1.50490000e+04, 3.83370716e+00, 3.54807088e+00, ...,
            3.03134190e+00, 1.85208859e+00, 3.00563077e+00],
           [1.50500000e+04, 3.18643937e+00, 1.70323164e+00, ...,
            1.19605309e+00, 3.34099104e+00, 2.92155740e+00],
           [1.50510000e+04, 3.10427003e+00, 2.82717086e+00, ...,
            1.33781619e+00, 2.71468770e+00, 2.34349413e+00]])
    # 显示数据集数据
    source_data
    Unnamed: 0week_1week_2week_3week_4week_5week_6week_7week_8week_9...week_43week_44week_45week_46week_47week_48week_49week_50week_51week_52
    002.2915742.8828383.5818054.0138751.1099242.8342472.6250452.1968844.208887...1.2422502.7710723.7781433.1616343.7926452.0154812.8261842.5207882.6372102.748923
    110.6096642.5236042.6095373.6959973.3992722.6166121.6519351.3482953.862523...2.4775052.2845133.4617833.1010523.4424201.9157762.4261681.6628552.4819252.411202
    223.4227931.812651-0.0979661.7240643.0936601.7812782.8499462.9497073.560835...2.2196672.3598341.9320292.7319471.8362451.2199331.2227401.7200522.1699392.161702
    333.3722832.5772543.8543083.4496792.5176762.6356792.3527062.8562161.948434...1.6709120.9091133.2166521.7753463.2704842.3997093.0320711.7036661.7505851.821736
    442.9977271.7994153.6480902.3915672.3767781.8647170.4080622.3467263.260303...2.3040583.0389052.0387332.8251862.2329372.5090502.881796-1.7121312.1403661.926818
    ..................................................................
    15047150471.9527261.5476371.9027890.8132612.6009792.9106382.8783960.5942163.526187...0.4860733.3362523.3072703.0268351.4721163.2207922.6640441.5461533.0269482.611774
    15048150480.6528243.5891913.2577072.8212762.1859372.534801-0.7743753.8356953.776809...2.6841531.3849123.1845702.8329412.0920332.6061980.7531933.1605993.0858002.814394
    15049150493.8337073.5480713.1941601.9934373.0135471.8250472.3051960.5224753.126647...2.9289371.6337543.0785982.4665630.4893803.5187253.4064663.0313421.8520893.005631
    15050150503.1864391.7032323.1965912.407803-0.4743703.8799433.7624083.4156691.790529...1.6426122.3877702.1498930.6884633.1508053.2422092.9727281.1960533.3409912.921557
    15051150513.1042702.8271711.1764283.2749672.9346552.3491882.4129351.2190542.843297...2.5512590.8192033.4165323.2420212.8101772.0374872.6816941.3378162.7146882.343494

    15052 rows × 53 columns

    第2章 全连接网络的拟合

    2.1 定义全连接网络

    class FullyConnected(nn.Module):
        def __init__(self, x_size, hidden_size, output_size):
            super(FullyConnected, self).__init__()
            self.hidden_size = hidden_size
    
            self.linear_with_tanh = nn.Sequential(
                nn.Linear(10, self.hidden_size),
                nn.Tanh(),
                nn.Linear(self.hidden_size, self.hidden_size),
                nn.Tanh(),
                nn.Linear(self.hidden_size, output_size)
            )
            
        def forward(self, x):
            yhat = self.linear_with_tanh(x)
            
            return yhat
    # 输入样本的size
    x_size = 1
    
    # 隐藏层的size:try to change this parameters 
    hidden_size = 2 
    
    #数据特征的size
    output_size = 10
    
    fc_model = FullyConnected(x_size = x_size, hidden_size = hidden_size, output_size = output_size)
    print(fc_model)
    
    fc_model = fc_model.double()
    print(fc_model)
    FullyConnected(
      (linear_with_tanh): Sequential(
        (0): Linear(in_features=10, out_features=2, bias=True)
        (1): Tanh()
        (2): Linear(in_features=2, out_features=2, bias=True)
        (3): Tanh()
        (4): Linear(in_features=2, out_features=10, bias=True)
      )
    )
    
    
    fc_model.state_dict()['linear_with_tanh.0.weight']
    tensor([[ 0.2028,  0.0721,  0.0101,  0.2866, -0.3106,  0.1612,  0.0082, -0.1394,
              0.2630, -0.2903],
            [ 0.0596, -0.2646,  0.2036, -0.2676, -0.0198,  0.2969,  0.2596,  0.0965,
              0.0746, -0.0195]], dtype=torch.float64)

    2.2 定义loss与优化器

    #定义loss函数
    criterion = nn.MSELoss()
    
    # 使用 Adam 优化器 比课上使用的 SGD 优化器更加稳定 
    optimizer = optim.AdamW(fc_model.parameters(), lr=0.01) 

    2.3 训练前准备

    n_epochs = 30
    n_layers = 1
    batch_size = seq_length
    seq_length = 10
    
    fc_losses = np.zeros(n_epochs) 
    
    
    data_loader = torch.utils.data.DataLoader(source_data.values, batch_size = batch_size, shuffle=True)
    print(data_loader)
    print(data_loader.batch_size )

    2.4 开始训练

    # 开始训练
    for epoch in range(n_epochs):
        # 定义用于每个epoch的平均loss
        epoch_losses = []
        
        # 读取batch数据
        for iter_, data in enumerate(data_loader):
            #当读到数据不足batch size时,跳过batch size
            if data.shape[0] != batch_size: 
                continue 
            
            #随机的获取长度=seq_length的数据
            random_index = random.randint(0, data.shape[-1] - seq_length - 1)
            train_x = data[:, random_index: random_index+seq_length]
            #train_y = data[:, random_index + 1: random_index + seq_length + 1]
            train_y = train_x
            
            #进行前向运算
            outputs = fc_model(train_x.double())
            
            #复位梯度
            optimizer.zero_grad()
            
            #求此次前向运算的loss
            loss = criterion(outputs, train_y)
            
            #反向求导
            loss.backward()
            
            #梯度迭代
            optimizer.step()
    
            #
            epoch_losses.append(loss.detach())
            
            if iter_  == 0:
                plt.clf();
                plt.ion()
                plt.title("Epoch {}, iter {}".format(epoch, iter_))
                plt.plot(torch.flatten(train_y),'c-',linewidth=1,label='Label')
                #plt.plot(torch.flatten(train_x),'g-',linewidth=1,label='Input')
                plt.plot(torch.flatten(outputs.detach()),'r-',linewidth=1,label='Output')
                plt.draw();
                plt.pause(0.05);
        fc_losses[epoch] = np.mean(epoch_losses)

     ................................................................

    2.5 loss显示 

    plt.plot(fc_losses)

    2.6 结果分析

    全连接网络应对这种时序序列问题,拟合性不是很好。

    第3章 RNN网络的拟合

    3.1 定义RNN网络

    class SimpleRNN(nn.Module):
        def __init__(self, x_size, hidden_size, n_layers, batch_size, output_size):
            super(SimpleRNN, self).__init__()
            self.hidden_size = hidden_size
            self.n_layers = n_layers
            self.batch_size = batch_size
            #self.inp = nn.Linear(1, hidden_size) 
            self.rnn = nn.RNN(x_size, hidden_size, n_layers, batch_first=True)
            self.out = nn.Linear(hidden_size, output_size) # 10 in and 10 out
    
        def forward(self, inputs, hidden=None):
            hidden = self.__init__hidden()
            #print("Forward hidden {}".format(hidden.shape))
            #print("Forward inps {}".format(inputs.shape))
            output, hidden = self.rnn(inputs.float(), hidden.float())
            #print("Out1 {}".format(output.shape))
            output = self.out(output.float());
            #print("Forward outputs {}".format(output.shape))
    
            return output, hidden
    
        def __init__hidden(self):
            hidden = torch.zeros(self.n_layers, self.batch_size, self.hidden_size, dtype=torch.float64)
            return hidden

    3.2 生成网络

    x_size = 1
    hidden_size = 2 # try to change this parameters 
    n_layers = 1
    seq_length = 10
    output_size = 1
    
    #rnn_model = SimpleRNN(x_size, hidden_size, n_layers, seq_length, output_size)
    rnn_model = SimpleRNN(x_size, hidden_size, n_layers, seq_length, output_size)
    
    print(rnn_model)
    SimpleRNN(
      (rnn): RNN(1, 2, batch_first=True)
      (out): Linear(in_features=2, out_features=1, bias=True)
    )

    3.3 定义loss与优化器

    # 定义loss
    criterion = nn.MSELoss()
    
    #定义优化器
    optimizer = optim.AdamW(rnn_model.parameters(), lr=0.01) # 使用 Adam 优化器 比课上使用的 SGD 优化器更加稳定 

    3.4 训练前的准备

    # 训练前的准备
    n_epochs = 30
    rnn_losses = np.zeros(n_epochs) 
    
    data_loader = torch.utils.data.DataLoader(source_data.values, batch_size=seq_length, shuffle=True)

    3.5 开始训练

    # 开始训练
    for epoch in range(n_epochs):
        for iter_, t in enumerate(data_loader):
            if t.shape[0] != seq_length: continue 
    
            random_index = random.randint(0, t.shape[-1] - seq_length - 1)
            train_x = t[:, random_index: random_index+seq_length]
            #train_y = t[:, random_index + 1: random_index + seq_length + 1]
            train_y = train_x
            
            #获取输出
            outputs, hidden = rnn_model(train_x.double().unsqueeze(2), hidden_size)
            
            #梯度复位
            optimizer.zero_grad()
            
            #定义损失函数
            loss = criterion(outputs.double(), train_y.double().unsqueeze(2))
            
            # 反向求导
            loss.backward()
            
            #梯度迭代
            optimizer.step()
            
            #记录loss
            epoch_losses.append(loss.detach())
            
            #显示拟合图像
            if iter_ == 0:
                plt.clf();
                plt.ion()
                plt.title("Epoch {}, iter {}".format(epoch, iter_))
                plt.plot(torch.flatten(train_y),'c-',linewidth=1,label='Label')
                plt.plot(torch.flatten(train_x),'g-',linewidth=1,label='Input')
                plt.plot(torch.flatten(outputs.detach()),'r-',linewidth=1,label='Output')
                plt.draw();
                plt.pause(0.05);
        rnn_losses[epoch] = np.mean(epoch_losses)
    

     

    3.6 显示loss

    3.7 分析

    RNN网络在第一个epoch完成后,拟合度就非常好。


    作者主页(文火冰糖的硅基工坊):文火冰糖(王文兵)的博客_文火冰糖的硅基工坊_CSDN博客

    本文网址:https://blog.csdn.net/HiWangWenBing/article/details/121526014

    展开全文
  • 时间序列有高度的自相关性,所以我不能随机打乱。 如果1-6月训练,7、8验证,9、10测试的话,实验结果表明测试精度远差于验证逻辑上很好解释,中间差了两个月,市场行情发生了很大的变化,模型没见过跟不...
  • 时间序列论文常用数据集

    千次阅读 2020-05-20 21:30:52
    下载地址:laiguokun/multivariate-time-series-data. electricity (行,列) = (26304, 321) 每日的用电量有一定的季节性,图中只画出 10 列 exchange_rate (行,列) = (7588, 8) solar-energy ...
  • 时间序列数据简介

    千次阅读 2021-08-11 19:14:18
    前言 1. 引言 1.1 时间序列定义 1.2 应用场景 1.3研究方法的递进 2. 时间序列数据 2.1 数据的获取 2.2 数据时间轴的确定 2.3 时间序列遇到问题
  • 使用 TimeGAN 建模和生成时间序列数据

    万次阅读 热门讨论 2021-09-09 09:20:12
    时间序列数据集有一个额外的维度——时间。 我们可以将其视为 3D 数据集。 比如说,我们有一个包含 5 个特征和 5 个输入实例的数据集。 那么时间序列数据基本上是该表在第 3 维的扩展,其中每个新表只是新时间步长...
  • 时间序列预测03:如何为CNN/LSTM模型构建数据集

    千次阅读 多人点赞 2020-04-06 15:38:51
    时间序列数据必须经过变换才能用来拟合有监督的学习模型。在这种形式下,数据可以立即用于拟合有监督的机器学习算法,甚至多层感知器神经...本文介绍了如何将时间序列数据集转换为三维结构,以便适合CNN或LSTM模型。
  • 用Pandas和Streamlit对时间序列数据集进行可视化过滤 介绍 我们每天处理的数据最多的类型可能是时间序列数据。基本上,使用日期,时间或两者同时索引的任何内容都可以视为时间序列数据集。在我们工作中,可能经常...
  • MATLAB实现ARIMA时间序列预测数据集
  • 可用于进行序列预测的一维数据集,取自某支股票的某时间段内的价格。
  • MATLAB时间序列回归Data_TSReg2数据集
  • 数据集处理方法之多维时间序列

    千次阅读 2020-11-02 23:24:36
    为了在接下来的程序中对这些时间序列进行聚类以及评估聚类效果,需要读取这些数据,并且将状态(分类)作为标签附在每一段数据上。鉴于标签和时间序列的格式不一致,本人采用了字典格式。 具体代码如下: def ...
  • MATLAB实现RNN(循环神经网络)时间序列预测数据集
  • data = pd.read_excel(r'你的数据位置',index_col=0)#读取数据 data data1 = data.values[:,:]#截取所需要的数据 data1.shape import numpy as np X = []#开一个空的东西用来存数据 for i in range(0,n,m):#n是你所...
  • 提出的TSkmeans算法可以有效地利用时间序列数据集的固有子空间信息来增强聚类性能。 更具体地说,平滑子空间由加权时间戳表示,加权时间戳指示这些时间戳对于聚类对象的相对判别力。 我们工作的主要贡献包括设计一...
  • 时间序列数据在许多不同的行业中都非常重要。它在研究、金融行业、制药、社交媒体、网络服务等领域尤为重要。对时间序列数据的分析也变得越来越重要。在分析中有什么比一些好的可视化效果更好呢?没有一些视觉效果,...
  • 时间序列预测可以被构造为一个监督学习问题。通过对时间序列数据的重构,可以针对不同问题使用相关的机器学习算法。本文介绍了如何将时间序列问题重新构造为机器学习中的监督学习问题。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 247,652
精华内容 99,060
关键字:

时间序列数据集