Generating_Time_Series.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt \n",
    "import pandas as pd\n",
    "from itertools import permutations, product\n",
    "from scipy.stats import norm\n",
    "\n",
    "from scipy.integrate import odeint\n",
    "from scipy import signal "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Lorenz(t, state0 = [1.0, 1.0, 1.0], rho = 28.0, sigma = 10.0, beta = 8.0 / 3.0):\n",
    "    \n",
    "    def f(state, t):\n",
    "        x, y, z = state  \n",
    "        return sigma * (y - x), x * (rho - z) - y, x * y - beta * z \n",
    "\n",
    "    out = odeint(f, state0, t)[:,0]\n",
    "    out = out/np.max(np.abs(out))\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ARMA(t, ar = [ 0.40319316, -0.35915379], ma = [-0.29403158, -0.70584929], sigma2 = 0.0177):\n",
    "    x = np.sqrt(sigma2)*np.random.randn(len(t))\n",
    "    x = signal.lfilter(ma, ar, x)\n",
    "    x = x/np.max(np.abs(x))\n",
    "    return x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def WhiteNoise(t):\n",
    "    out = np.random.randn(len(t))\n",
    "    out = out/np.max(np.abs(out))\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RandomWalk(t, prob = 0.5):\n",
    "    x = np.zeros(len(t))\n",
    "    for t_i in range(len(t)):\n",
    "        if np.random.rand() < prob:\n",
    "            x[t_i] += 1 \n",
    "        else: \n",
    "            x[t_i] -= 1 \n",
    "    out = np.cumsum(x) \n",
    "    out = out/np.max(np.abs(out))\n",
    "    return out   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Chirp(t, f_start = 0, f_end = 1):\n",
    "    f = np.linspace(f_start, f_end, len(t))\n",
    "    out = np.sin(2*np.pi*f*t)\n",
    "    out = out/np.max(np.abs(out))\n",
    "    return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SineWave(t, f = 0.5):\n",
    "    out = np.sin(2*np.pi*f*t)\n",
    "    out = out/np.max(np.abs(out))\n",
    "    return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initial Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ts = 5e-2 # Sampling time \n",
    "T_tot = 40 # seconds - Observation time \n",
    "Monte = 60 \n",
    "\n",
    "t = np.arange(0.0, T_tot, Ts)\n",
    "path = 'Dataset'\n",
    "np.save(path + '/Monte.npy', Monte)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Lorenz System"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "lorenz_time_series = np.zeros((Monte, len(t)))\n",
    "for m in range(Monte):\n",
    "    lorenz_time_series[m] = Lorenz(t, rho=28.0*(Monte + m+1)/Monte)\n",
    "lorenz_dataframe = np.append(np.expand_dims(t, axis = 0), lorenz_time_series, axis = 0).T\n",
    "columns = ['{}'.format(i) for i in range(Monte)] \n",
    "columns.insert(0, 'time')\n",
    "\n",
    "df = pd.DataFrame(lorenz_dataframe, columns = columns)\n",
    "df.to_csv(path + '/lorenz_dataframe.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) ARMA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "ARMA_time_series = np.zeros((Monte, len(t)))\n",
    "for m in range(Monte):\n",
    "    ARMA_time_series[m] = ARMA(t)\n",
    "ARMA_dataframe = np.append(np.expand_dims(t, axis = 0), ARMA_time_series, axis = 0).T\n",
    "columns = ['{}'.format(i) for i in range(Monte)] \n",
    "columns.insert(0, 'time')\n",
    "\n",
    "df = pd.DataFrame(ARMA_dataframe, columns = columns)\n",
    "df.to_csv(path + '/ARMA_dataframe.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) White Noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "WhiteNoise_time_series = np.zeros((Monte, len(t)))\n",
    "for m in range(Monte):\n",
    "    WhiteNoise_time_series[m] = WhiteNoise(t)\n",
    "WhiteNoise_dataframe = np.append(np.expand_dims(t, axis = 0), WhiteNoise_time_series, axis = 0).T\n",
    "columns = ['{}'.format(i) for i in range(Monte)] \n",
    "columns.insert(0, 'time')\n",
    "\n",
    "df = pd.DataFrame(WhiteNoise_dataframe, columns = columns)\n",
    "df.to_csv(path + '/WhiteNoise_dataframe.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4) Random Walk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "RandomWalk_time_series = np.zeros((Monte, len(t)))\n",
    "for m in range(Monte):\n",
    "    RandomWalk_time_series[m] = RandomWalk(t)\n",
    "RandomWalk_dataframe = np.append(np.expand_dims(t, axis = 0), RandomWalk_time_series, axis = 0).T\n",
    "columns = ['{}'.format(i) for i in range(Monte)] \n",
    "columns.insert(0, 'time')\n",
    "\n",
    "df = pd.DataFrame(RandomWalk_dataframe, columns = columns)\n",
    "df.to_csv(path + '/RandomWalk_dataframe.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5) Chirp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "Chirp_time_series = np.zeros((Monte, len(t)))\n",
    "for m in range(Monte):\n",
    "    Chirp_time_series[m] = Chirp(t, f_end=(m + 1)/Monte)\n",
    "Chirp_dataframe = np.append(np.expand_dims(t, axis = 0), Chirp_time_series, axis = 0).T\n",
    "columns = ['{}'.format(i) for i in range(Monte)] \n",
    "columns.insert(0, 'time')\n",
    "\n",
    "df = pd.DataFrame(Chirp_dataframe, columns = columns)\n",
    "df.to_csv(path + '/Chirp_dataframe.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6) Sine Wave "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "SineWave_time_series = np.zeros((Monte, len(t)))\n",
    "for m in range(Monte):\n",
    "    SineWave_time_series[m] = SineWave(t, f = 0.5*(m + 1)/Monte)\n",
    "SineWave_dataframe = np.append(np.expand_dims(t, axis = 0), SineWave_time_series, axis = 0).T\n",
    "columns = ['{}'.format(i) for i in range(Monte)] \n",
    "columns.insert(0, 'time')\n",
    "\n",
    "df = pd.DataFrame(SineWave_dataframe, columns = columns)\n",
    "df.to_csv(path + '/SineWave_dataframe.csv', index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}