TimeSeriesDatasets.hh

[詳解]

 
//
// Copyright (C) 2011-2021 Yokokura, Yuki
// This program is free software;
// you can redistribute it and/or modify it under the terms of the FreeBSD License.
// For details, see the License.txt file.
 
#ifndef TIMESERIESDATASETS
#define TIMESERIESDATASETS
 
#include <cassert>
#include <array>
#include <string>
#include <ctime>
#include "Matrix.hh"
#include "Statistics.hh"
#include "CsvManipulator.hh"
#include "FrameGraphics.hh"
#include "CuiPlot.hh"
 
// ARCS組込み用マクロ
#ifdef ARCS_IN
    // ARCSに組み込まれる場合
    #include "ARCSassert.hh"
    #include "ARCSeventlog.hh"
#else
    // ARCSに組み込まれない場合
    #define arcs_assert(a) (assert(a))
    #define PassedLog()
    #define EventLog(a)
    #define EventLogVar(a)
#endif
 
namespace ARCS {    // ARCS名前空間
template <size_t N, size_t K, size_t T, size_t W, size_t M>
class TimeSeriesDatasets {
    public:
        // 時系列データ
        std::array<Matrix<M,N>, W + 2> InputData;
        Matrix<M,K> TrainData;
        
        TimeSeriesDatasets(void)
            : InputData(), TrainData(), 
              TimeStamp(), InputMat(), TrainMat(), StdInputMat(), StdTrainMat(),
              xbarIn(), sigmaIn(), xbarTr(), sigmaTr()
        {
            PassedLog();
        }
        
        TimeSeriesDatasets(const std::string& InputFile, const std::string& TrainFile)
            : InputData(), TrainData(), 
              TimeStamp(), InputMat(), TrainMat(), StdInputMat(), StdTrainMat(),
              xbarIn(), sigmaIn(), xbarTr(), sigmaTr()
        {
            PassedLog();
            TimeStamp = tp(Matrix<1,T>::ramp());                        // タイムスタンプを生成
            
            // 時系列入力データの前処理
            Matrix<N,T> InputDataBuf;                                   // 入力データバッファ
            CsvManipulator::LoadFile(InputDataBuf, InputFile);          // CSVデータを行列として読み込み
            InputMat = tp(InputDataBuf);                                // 今後のために転置をしておく
            StandardizeDataset(InputMat, xbarIn, sigmaIn, StdInputMat); // データセットの標準化
            VectorizeInputData(StdInputMat, InputData);                 // 縦ベクトル配列化
            
            // 時系列訓練データの前処理
            Matrix<K,T> TrainDataBuf;                                   // 訓練データバッファ
            CsvManipulator::LoadFile(TrainDataBuf, TrainFile);          // CSVデータを行列として読み込み
            TrainMat = tp(TrainDataBuf);                                // 今後のために転置をしておく
            StandardizeDataset(TrainMat, xbarTr, sigmaTr, StdTrainMat); // データセットの標準化
            VectorizeTrainData(StdTrainMat, TrainData);                 // 縦ベクトル配列化
        }
        
        TimeSeriesDatasets(TimeSeriesDatasets&& r)
            : TimeStamp(r.TimeStamp), InputMat(r.InputTimeData), TrainMat(r.TrainMat),
              StdInputMat(r.StdInputMat), StdTrainMat(r.StdTrainMat),
              InputData(r.InputData), TrainData(r.TrainData),
              xbarIn(r.xbarIn), sigmaIn(r.sigmaIn), xbarTr(r.xbarTr), sigmaTr(r.sigmaTr)
        {
            
        }
        
        ~TimeSeriesDatasets(){
            PassedLog();
        }
        
        void StandardizeInput(Matrix<1,N>& x){
            x = (x - xbarIn) % sigmaIn; // 入力データの標準化値に基づいて入力を標準化
        }
        
        void DispInputAndTrainData(const size_t DispNum){
            printf("\nTime Series Input And Train Data :\n");
            for(size_t i = 1; i <= W; ++i){
                //if((i % DispNum) == 0){
                    printf("t = %zu :\n", i);
                    PrintMat(InputData.at(i));
                //}
            }
            PrintMat(TrainData);
            printf("Standardization Info :\n");
            PrintMat(xbarIn);
            PrintMat(sigmaIn);
            PrintMat(xbarTr);
            PrintMat(sigmaTr);
        }
        
        void WriteInputPlot(const double Min, const double Max, const std::string& FileName){
            // グラフ設定
            FrameGraphics FG(GRAPH_WIDTH, GRAPH_HEIGHT);
            CuiPlot Plot(FG, 0, 0, GRAPH_WIDTH, GRAPH_HEIGHT);
            Plot.SetAxisLabels("Time Index", FileName);
            Plot.SetRanges(0, T, Min, Max);
            Plot.SetGridLabelFormat("%5.0f", "%3.0f");
            Plot.DrawAxis();
            
            // 入力データチャネルごとにプロット
            for(size_t i = 1; i <= N; ++ i){
                Plot.DrawLegend(i, "Variable_i", FGcolors::CYAN);
                Plot.Plot(tp(TimeStamp), tp(getrow(StdInputMat,i)), CuiPlotTypes::PLOT_LINE, FGcolors::CYAN);
            }
            
            // PNG画像ファイル出力
            FG.SavePngImageFile(FileName);
        }
        
        void WriteTrainPlot(const double Min, const double Max, const std::string& FileName){
            // グラフ設定
            FrameGraphics FG(GRAPH_WIDTH, GRAPH_HEIGHT);
            CuiPlot Plot(FG, 0, 0, GRAPH_WIDTH, GRAPH_HEIGHT);
            Plot.SetAxisLabels("Time Index", FileName);
            Plot.SetRanges(0, T, Min, Max);
            Plot.SetGridLabelFormat("%5.0f", "%3.0f");
            Plot.DrawAxis();
            
            // 入力データチャネルごとにプロット
            for(size_t i = 1; i <= K; ++ i){
                Plot.DrawLegend(i, "Variable_i", FGcolors::CYAN);
                Plot.Plot(tp(TimeStamp), tp(getrow(StdTrainMat,i)), CuiPlotTypes::PLOT_LINE, FGcolors::MAGENTA);
            }
            
            // PNG画像ファイル出力
            FG.SavePngImageFile(FileName);
        }
        
    private:
        TimeSeriesDatasets(const TimeSeriesDatasets&) = delete;                 
        const TimeSeriesDatasets& operator=(const TimeSeriesDatasets&) = delete;
        
        // 時系列データの時間波形グラフの設定
        static constexpr int GRAPH_WIDTH = 1000;    
        static constexpr int GRAPH_HEIGHT = 500;    
        
        // 内部用時系列データ
        Matrix<T,1> TimeStamp;  
        Matrix<T,N> InputMat;   
        Matrix<T,K> TrainMat;   
        Matrix<T,N> StdInputMat;
        Matrix<T,K> StdTrainMat;
        
        // データセットの各種パラメータ
        Matrix<1,N> xbarIn;     
        Matrix<1,N> sigmaIn;    
        Matrix<1,N> xbarTr;     
        Matrix<1,N> sigmaTr;    
        
        static void StandardizeDataset(const Matrix<T,N>& RawData, Matrix<1,N>& Mean, Matrix<1,N>& Std, Matrix<T,N>& StdData){
            Statistics::MeanRow(RawData, Mean);             // 行方向の平均の計算
            Statistics::StandardDeviationRow(RawData, Std); // 行方向の標準偏差の計算
            Matrix<1,N> buff;
            for(size_t i = 1; i <= T; ++i){
                buff = (getcolumn(RawData, i) - Mean) % Std;// データセットを標準化
                setcolumn(StdData, buff, i);
            }
        }
        
        static void VectorizeInputData(const Matrix<T,N>& MatData, std::array<Matrix<M,N>, W + 2>& VecData){
            for(size_t i = 1; i <= W; ++i){
                getvvector(MatData, i, 1, VecData.at(i));
            }
        }
        
        static void VectorizeTrainData(const Matrix<T,K>& MatData, Matrix<M,K>& VecData){
            getvvector(MatData, W + 1, 1, VecData);
        }
        
};
}
 
#endif