From 37bb9fe76127b09d6ef81cbd943b68d704601d54 Mon Sep 17 00:00:00 2001 From: humbertoalcantaraluna <92alcantara@gmail.com> Date: Sun, 26 Mar 2023 02:12:23 -0600 Subject: [PATCH] complete --- .../.ipynb_checkpoints/main-checkpoint.ipynb | 885 ++++++++++++++++++ your-code/main.ipynb | 662 ++++++++++++- 2 files changed, 1505 insertions(+), 42 deletions(-) create mode 100644 your-code/.ipynb_checkpoints/main-checkpoint.ipynb diff --git a/your-code/.ipynb_checkpoints/main-checkpoint.ipynb b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb new file mode 100644 index 0000000..e88141b --- /dev/null +++ b/your-code/.ipynb_checkpoints/main-checkpoint.ipynb @@ -0,0 +1,885 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Before your start:\n", + "- Read the README.md file\n", + "- Comment as much as you can and use the resources (README.md file)\n", + "- Happy learning!" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import numpy and pandas\n", + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Challenge 1 - Loading and Evaluating The Data\n", + "\n", + "In this lab, we will look at a dataset of sensor data from a cellular phone. The phone was carried in the subject's pocket for a few minutes while they walked around.\n", + "\n", + "To load the data, run the code below." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Run this code:\n", + "\n", + "sensor = pd.read_csv('../sub_1.csv')\n", + "sensor.drop(columns=['Unnamed: 0'], inplace=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Examine the data using the `head` function." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
attitude.rollattitude.pitchattitude.yawgravity.xgravity.ygravity.zrotationRate.xrotationRate.yrotationRate.zuserAcceleration.xuserAcceleration.yuserAcceleration.z
01.528132-0.7338960.6963720.7418950.669768-0.0316720.3167380.7781801.0827640.294894-0.1844930.377542
11.527992-0.7169870.6777620.7530990.657116-0.0322550.8420320.4244460.6435740.2194050.0358460.114866
21.527765-0.7069990.6709510.7596110.649555-0.032707-0.138143-0.0407410.3435630.0107140.134701-0.167808
31.516768-0.7046780.6757350.7607090.647788-0.041140-0.025005-1.0487170.035860-0.0083890.1367880.094958
41.493941-0.7039180.6729940.7600620.647210-0.0585300.114253-0.9128900.0473410.1994410.353996-0.044299
\n", + "
" + ], + "text/plain": [ + " attitude.roll attitude.pitch attitude.yaw gravity.x gravity.y \\\n", + "0 1.528132 -0.733896 0.696372 0.741895 0.669768 \n", + "1 1.527992 -0.716987 0.677762 0.753099 0.657116 \n", + "2 1.527765 -0.706999 0.670951 0.759611 0.649555 \n", + "3 1.516768 -0.704678 0.675735 0.760709 0.647788 \n", + "4 1.493941 -0.703918 0.672994 0.760062 0.647210 \n", + "\n", + " gravity.z rotationRate.x rotationRate.y rotationRate.z \\\n", + "0 -0.031672 0.316738 0.778180 1.082764 \n", + "1 -0.032255 0.842032 0.424446 0.643574 \n", + "2 -0.032707 -0.138143 -0.040741 0.343563 \n", + "3 -0.041140 -0.025005 -1.048717 0.035860 \n", + "4 -0.058530 0.114253 -0.912890 0.047341 \n", + "\n", + " userAcceleration.x userAcceleration.y userAcceleration.z \n", + "0 0.294894 -0.184493 0.377542 \n", + "1 0.219405 0.035846 0.114866 \n", + "2 0.010714 0.134701 -0.167808 \n", + "3 -0.008389 0.136788 0.094958 \n", + "4 0.199441 0.353996 -0.044299 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your code here:\n", + "\n", + "sensor.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check whether there is any missing data. If there is any missing data, remove the rows containing missing data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "attitude.roll 0\n", + "attitude.pitch 0\n", + "attitude.yaw 0\n", + "gravity.x 0\n", + "gravity.y 0\n", + "gravity.z 0\n", + "rotationRate.x 0\n", + "rotationRate.y 0\n", + "rotationRate.z 0\n", + "userAcceleration.x 0\n", + "userAcceleration.y 0\n", + "userAcceleration.z 0\n", + "dtype: int64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your code here:\n", + "\n", + "sensor.isnull().sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How many rows and columns are in our data?" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1751, 12)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your code here:\n", + "\n", + "sensor.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To perform time series analysis on the data, we must change the index from a range index to a time series index. In the cell below, create a time series index using the `pd.date_range` function. Create a time series index starting at 1/1/2018 00:00:00 and ending at 1/1/2018 00:29:10. The number of periods is equal to the number of rows in `sensor`. The frequency should be set to `infer`." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 00:00:01',\n", + " '2018-01-01 00:00:02', '2018-01-01 00:00:03',\n", + " '2018-01-01 00:00:04', '2018-01-01 00:00:05',\n", + " '2018-01-01 00:00:06', '2018-01-01 00:00:07',\n", + " '2018-01-01 00:00:08', '2018-01-01 00:00:09',\n", + " ...\n", + " '2018-01-01 00:29:01', '2018-01-01 00:29:02',\n", + " '2018-01-01 00:29:03', '2018-01-01 00:29:04',\n", + " '2018-01-01 00:29:05', '2018-01-01 00:29:06',\n", + " '2018-01-01 00:29:07', '2018-01-01 00:29:08',\n", + " '2018-01-01 00:29:09', '2018-01-01 00:29:10'],\n", + " dtype='datetime64[ns]', length=1751, freq=None)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your code here:\n", + "pd.date_range(start='1/1/2018 00:00:00', end='1/1/2018 00:29:10', periods=1751)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Assign the time series index to the dataframe's index." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 00:00:01',\n", + " '2018-01-01 00:00:02', '2018-01-01 00:00:03',\n", + " '2018-01-01 00:00:04', '2018-01-01 00:00:05',\n", + " '2018-01-01 00:00:06', '2018-01-01 00:00:07',\n", + " '2018-01-01 00:00:08', '2018-01-01 00:00:09',\n", + " ...\n", + " '2018-01-01 00:29:01', '2018-01-01 00:29:02',\n", + " '2018-01-01 00:29:03', '2018-01-01 00:29:04',\n", + " '2018-01-01 00:29:05', '2018-01-01 00:29:06',\n", + " '2018-01-01 00:29:07', '2018-01-01 00:29:08',\n", + " '2018-01-01 00:29:09', '2018-01-01 00:29:10'],\n", + " dtype='datetime64[ns]', length=1751, freq=None)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your code here:\n", + "\n", + "index = pd.date_range(start='1/1/2018 00:00:00', end='1/1/2018 00:29:10', periods=1751)\n", + "sensor.index = pd.DatetimeIndex(index)\n", + "sensor.index" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our next step is to decompose the time series and evaluate the patterns in the data. Load the `statsmodels.api` submodule and plot the decomposed plot of `userAcceleration.x`. Set `freq=60` in the `seasonal_decompose` function. Your graph should look like the one below.\n", + "\n", + "![time series decomposition](../images/tsa_decompose.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: xlrd in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (2.0.1)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "import statsmodels.api as sm\n", + "%pip install --upgrade xlrd\n", + "import itertools\n", + "\n", + "import numpy as np \n", + "import pandas as pd \n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n", + "None\n" + ] + } + ], + "source": [ + "# Your code here:\n", + "#res = sm.tsa.seasonal_decompose(sensor['userAcceleration.x'])\n", + "#resplot = res.plot()\n", + "print(sensor.index.freq)\n", + "#df.index.freq = '120t'\n", + "sensor.asfreq('T')\n", + "print(sensor.index.freq)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "freq S not understood. Please report if you think this is in error.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [91]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43msm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtsa\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mseasonal_decompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43msensor\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43muserAcceleration.x\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m resplot \u001b[38;5;241m=\u001b[39m res\u001b[38;5;241m.\u001b[39mplot()\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/seasonal.py:156\u001b[0m, in \u001b[0;36mseasonal_decompose\u001b[0;34m(x, model, filt, period, two_sided, extrapolate_trend)\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m period \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pfreq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 156\u001b[0m pfreq \u001b[38;5;241m=\u001b[39m \u001b[43mfreq_to_period\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpfreq\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 157\u001b[0m period \u001b[38;5;241m=\u001b[39m pfreq\n\u001b[1;32m 158\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/tsatools.py:813\u001b[0m, in \u001b[0;36mfreq_to_period\u001b[0;34m(freq)\u001b[0m\n\u001b[1;32m 811\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m24\u001b[39m\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m: \u001b[38;5;66;03m# pragma : no cover\u001b[39;00m\n\u001b[0;32m--> 813\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 814\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfreq \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m not understood. Please report if you \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 815\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthink this is in error.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(freq)\n\u001b[1;32m 816\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: freq S not understood. Please report if you think this is in error." + ] + } + ], + "source": [ + "res = sm.tsa.seasonal_decompose(sensor['userAcceleration.x'])\n", + "resplot = res.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from statsmodels.tsa.seasonal import seasonal_decompose" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the decomposed time series of `rotationRate.x` also with a frequency of 60." + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 00:00:01',\n", + " '2018-01-01 00:00:02', '2018-01-01 00:00:03',\n", + " '2018-01-01 00:00:04', '2018-01-01 00:00:05',\n", + " '2018-01-01 00:00:06', '2018-01-01 00:00:07',\n", + " '2018-01-01 00:00:08', '2018-01-01 00:00:09',\n", + " ...\n", + " '2018-01-01 00:29:01', '2018-01-01 00:29:02',\n", + " '2018-01-01 00:29:03', '2018-01-01 00:29:04',\n", + " '2018-01-01 00:29:05', '2018-01-01 00:29:06',\n", + " '2018-01-01 00:29:07', '2018-01-01 00:29:08',\n", + " '2018-01-01 00:29:09', '2018-01-01 00:29:10'],\n", + " dtype='datetime64[ns]', length=1751, freq=None)" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sensor.index" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [], + "source": [ + "import statsmodels.api as sm\n", + "import matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "freq S not understood. Please report if you think this is in error.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [100]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m matplotlib\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfigure.figsize\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m7\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m descomp_serie \u001b[38;5;241m=\u001b[39m \u001b[43msm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtsa\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mseasonal_decompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43msensor\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43muserAcceleration.x\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m descomp_serie\u001b[38;5;241m.\u001b[39mplot()\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/seasonal.py:156\u001b[0m, in \u001b[0;36mseasonal_decompose\u001b[0;34m(x, model, filt, period, two_sided, extrapolate_trend)\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m period \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pfreq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 156\u001b[0m pfreq \u001b[38;5;241m=\u001b[39m \u001b[43mfreq_to_period\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpfreq\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 157\u001b[0m period \u001b[38;5;241m=\u001b[39m pfreq\n\u001b[1;32m 158\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/tsatools.py:813\u001b[0m, in \u001b[0;36mfreq_to_period\u001b[0;34m(freq)\u001b[0m\n\u001b[1;32m 811\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m24\u001b[39m\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m: \u001b[38;5;66;03m# pragma : no cover\u001b[39;00m\n\u001b[0;32m--> 813\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 814\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfreq \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m not understood. Please report if you \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 815\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthink this is in error.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(freq)\n\u001b[1;32m 816\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: freq S not understood. Please report if you think this is in error." + ] + } + ], + "source": [ + "matplotlib.rcParams['figure.figsize'] = (10, 7)\n", + "descomp_serie = sm.tsa.seasonal_decompose(sensor['userAcceleration.x'])\n", + "descomp_serie.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "seasonal_decompose() got an unexpected keyword argument 'freq'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [103]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mstatsmodels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mtsa\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mseasonal\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m seasonal_decompose\n\u001b[0;32m----> 2\u001b[0m decomposition \u001b[38;5;241m=\u001b[39m \u001b[43mseasonal_decompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43msensor\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43muserAcceleration.x\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43madditive\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilt\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m60\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m fig \u001b[38;5;241m=\u001b[39m decomposition\u001b[38;5;241m.\u001b[39mplot()\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[0;31mTypeError\u001b[0m: seasonal_decompose() got an unexpected keyword argument 'freq'" + ] + } + ], + "source": [ + "from statsmodels.tsa.seasonal import seasonal_decompose\n", + "decomposition = seasonal_decompose(sensor['userAcceleration.x'], model='additive', filt=None, freq=60)\n", + "fig = decomposition.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Comentario en la instrucción del probelma se solicita cambiar freq a 60 sin embargo en la función de se solicita no tiene soporte para ese argumento\n", + "# El index con las nuevas fechas tiene un freq de S que no se soporta en seasonal_decompose" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Challenge 2 - Modelling the Data\n", + "\n", + "To model our data, we should look at a few assumptions. First, let's plot the `lag_plot` to detect any autocorrelation. Do this for `userAcceleration.x`" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here:\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pd. plotting. lag_plot(sensor['userAcceleration.x'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create a lag plot for `rotationRate.x`" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Your code here:\n", + "pd. plotting. lag_plot(sensor['rotationRate.x'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What are your conclusions from both visualizations?" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "# Your conclusions here:\n", + "\n", + "# Ambas visualizaciones parecen tener una correlación con sus lags" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step will be to test both variables for stationarity. Perform the Augmented Dickey Fuller test on both variables below." + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06822624483241028" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Your code here:\n", + "\n", + "from statsmodels.tsa.stattools import adfuller\n", + " \n", + "adfuller(sensor['userAcceleration.x'])[1]\n", + "0.06822624483241028" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.320230335911989e-06" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adfuller(sensor['rotationRate.x'])[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What are your conclusions from this test?" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Your conclusions here:\n", + "\n", + "# Tenemos dos resultados diferentes, por parte de userAcceleration.x tenemos un p value grande por lo que no es estacionaria \n", + "# por parte de de rotationRate tenemos un p value pequeño, por lo que se puede concluir que si es estacionaria" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we'll create an ARMA model for `userAcceleration.x`. Load the `ARMA` function from `statsmodels`. The order of the model is (2, 1). Split the data to train and test. Use the last 10 observations as the test set and all other observations as the training set. " + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here:\n", + "from sklearn.model_selection import GridSearchCV, TimeSeriesSplit\n", + "from statsmodels.tsa.arima_model import ARMA\n", + "import itertools" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "from statsmodels.tsa.arima.model import ARIMA" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n" + ] + } + ], + "source": [ + "arima_model = ARIMA(sensor['rotationRate.x'], order = (2,1,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n" + ] + } + ], + "source": [ + "arima_model = ARIMA(sensor['userAcceleration.x'], order = (2,1,1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compare our predictions with the observed data, we can compute the RMSE (Root Mean Squared Error) from the submodule `statsmodels.tools.eval_measures`. You can read more about this function [here](https://www.statsmodels.org/dev/generated/statsmodels.tools.eval_measures.rmse.html). Compute the RMSE for the last 10 rows of the data by comparing the observed and predicted data for the `userAcceleration.x` column." + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "# Your code here:\n", + "\n", + "from sklearn import metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: statsmodels in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (0.13.2)\n", + "Requirement already satisfied: patsy>=0.5.2 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (0.5.2)\n", + "Requirement already satisfied: scipy>=1.3 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (1.7.3)\n", + "Requirement already satisfied: pandas>=0.25 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (1.4.2)\n", + "Requirement already satisfied: packaging>=21.3 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (21.3)\n", + "Requirement already satisfied: numpy>=1.17 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (1.21.5)\n", + "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from packaging>=21.3->statsmodels) (3.0.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from pandas>=0.25->statsmodels) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from pandas>=0.25->statsmodels) (2021.3)\n", + "Requirement already satisfied: six in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from patsy>=0.5.2->statsmodels) (1.16.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install statsmodels" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/your-code/main.ipynb b/your-code/main.ipynb index 89f1b11..e88141b 100644 --- a/your-code/main.ipynb +++ b/your-code/main.ipynb @@ -17,7 +17,8 @@ "outputs": [], "source": [ "# Import numpy and pandas\n", - "\n" + "import pandas as pd\n", + "import numpy as np" ] }, { @@ -33,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -52,12 +53,156 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
attitude.rollattitude.pitchattitude.yawgravity.xgravity.ygravity.zrotationRate.xrotationRate.yrotationRate.zuserAcceleration.xuserAcceleration.yuserAcceleration.z
01.528132-0.7338960.6963720.7418950.669768-0.0316720.3167380.7781801.0827640.294894-0.1844930.377542
11.527992-0.7169870.6777620.7530990.657116-0.0322550.8420320.4244460.6435740.2194050.0358460.114866
21.527765-0.7069990.6709510.7596110.649555-0.032707-0.138143-0.0407410.3435630.0107140.134701-0.167808
31.516768-0.7046780.6757350.7607090.647788-0.041140-0.025005-1.0487170.035860-0.0083890.1367880.094958
41.493941-0.7039180.6729940.7600620.647210-0.0585300.114253-0.9128900.0473410.1994410.353996-0.044299
\n", + "
" + ], + "text/plain": [ + " attitude.roll attitude.pitch attitude.yaw gravity.x gravity.y \\\n", + "0 1.528132 -0.733896 0.696372 0.741895 0.669768 \n", + "1 1.527992 -0.716987 0.677762 0.753099 0.657116 \n", + "2 1.527765 -0.706999 0.670951 0.759611 0.649555 \n", + "3 1.516768 -0.704678 0.675735 0.760709 0.647788 \n", + "4 1.493941 -0.703918 0.672994 0.760062 0.647210 \n", + "\n", + " gravity.z rotationRate.x rotationRate.y rotationRate.z \\\n", + "0 -0.031672 0.316738 0.778180 1.082764 \n", + "1 -0.032255 0.842032 0.424446 0.643574 \n", + "2 -0.032707 -0.138143 -0.040741 0.343563 \n", + "3 -0.041140 -0.025005 -1.048717 0.035860 \n", + "4 -0.058530 0.114253 -0.912890 0.047341 \n", + "\n", + " userAcceleration.x userAcceleration.y userAcceleration.z \n", + "0 0.294894 -0.184493 0.377542 \n", + "1 0.219405 0.035846 0.114866 \n", + "2 0.010714 0.134701 -0.167808 \n", + "3 -0.008389 0.136788 0.094958 \n", + "4 0.199441 0.353996 -0.044299 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Your code here:\n", - "\n" + "\n", + "sensor.head()" ] }, { @@ -69,12 +214,36 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "attitude.roll 0\n", + "attitude.pitch 0\n", + "attitude.yaw 0\n", + "gravity.x 0\n", + "gravity.y 0\n", + "gravity.z 0\n", + "rotationRate.x 0\n", + "rotationRate.y 0\n", + "rotationRate.z 0\n", + "userAcceleration.x 0\n", + "userAcceleration.y 0\n", + "userAcceleration.z 0\n", + "dtype: int64" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Your code here:\n", - "\n" + "\n", + "sensor.isnull().sum()" ] }, { @@ -86,12 +255,24 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(1751, 12)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Your code here:\n", - "\n" + "\n", + "sensor.shape" ] }, { @@ -103,12 +284,34 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 00:00:01',\n", + " '2018-01-01 00:00:02', '2018-01-01 00:00:03',\n", + " '2018-01-01 00:00:04', '2018-01-01 00:00:05',\n", + " '2018-01-01 00:00:06', '2018-01-01 00:00:07',\n", + " '2018-01-01 00:00:08', '2018-01-01 00:00:09',\n", + " ...\n", + " '2018-01-01 00:29:01', '2018-01-01 00:29:02',\n", + " '2018-01-01 00:29:03', '2018-01-01 00:29:04',\n", + " '2018-01-01 00:29:05', '2018-01-01 00:29:06',\n", + " '2018-01-01 00:29:07', '2018-01-01 00:29:08',\n", + " '2018-01-01 00:29:09', '2018-01-01 00:29:10'],\n", + " dtype='datetime64[ns]', length=1751, freq=None)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Your code here:\n", - "\n" + "pd.date_range(start='1/1/2018 00:00:00', end='1/1/2018 00:29:10', periods=1751)\n" ] }, { @@ -120,12 +323,37 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 00:00:01',\n", + " '2018-01-01 00:00:02', '2018-01-01 00:00:03',\n", + " '2018-01-01 00:00:04', '2018-01-01 00:00:05',\n", + " '2018-01-01 00:00:06', '2018-01-01 00:00:07',\n", + " '2018-01-01 00:00:08', '2018-01-01 00:00:09',\n", + " ...\n", + " '2018-01-01 00:29:01', '2018-01-01 00:29:02',\n", + " '2018-01-01 00:29:03', '2018-01-01 00:29:04',\n", + " '2018-01-01 00:29:05', '2018-01-01 00:29:06',\n", + " '2018-01-01 00:29:07', '2018-01-01 00:29:08',\n", + " '2018-01-01 00:29:09', '2018-01-01 00:29:10'],\n", + " dtype='datetime64[ns]', length=1751, freq=None)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Your code here:\n", - "\n" + "\n", + "index = pd.date_range(start='1/1/2018 00:00:00', end='1/1/2018 00:29:10', periods=1751)\n", + "sensor.index = pd.DatetimeIndex(index)\n", + "sensor.index" ] }, { @@ -139,12 +367,85 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: xlrd in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (2.0.1)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "import statsmodels.api as sm\n", + "%pip install --upgrade xlrd\n", + "import itertools\n", + "\n", + "import numpy as np \n", + "import pandas as pd \n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n", + "None\n" + ] + } + ], + "source": [ + "# Your code here:\n", + "#res = sm.tsa.seasonal_decompose(sensor['userAcceleration.x'])\n", + "#resplot = res.plot()\n", + "print(sensor.index.freq)\n", + "#df.index.freq = '120t'\n", + "sensor.asfreq('T')\n", + "print(sensor.index.freq)" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "freq S not understood. Please report if you think this is in error.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [91]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43msm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtsa\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mseasonal_decompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43msensor\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43muserAcceleration.x\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m resplot \u001b[38;5;241m=\u001b[39m res\u001b[38;5;241m.\u001b[39mplot()\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/seasonal.py:156\u001b[0m, in \u001b[0;36mseasonal_decompose\u001b[0;34m(x, model, filt, period, two_sided, extrapolate_trend)\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m period \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pfreq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 156\u001b[0m pfreq \u001b[38;5;241m=\u001b[39m \u001b[43mfreq_to_period\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpfreq\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 157\u001b[0m period \u001b[38;5;241m=\u001b[39m pfreq\n\u001b[1;32m 158\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/tsatools.py:813\u001b[0m, in \u001b[0;36mfreq_to_period\u001b[0;34m(freq)\u001b[0m\n\u001b[1;32m 811\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m24\u001b[39m\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m: \u001b[38;5;66;03m# pragma : no cover\u001b[39;00m\n\u001b[0;32m--> 813\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 814\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfreq \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m not understood. Please report if you \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 815\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthink this is in error.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(freq)\n\u001b[1;32m 816\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: freq S not understood. Please report if you think this is in error." + ] + } + ], + "source": [ + "res = sm.tsa.seasonal_decompose(sensor['userAcceleration.x'])\n", + "resplot = res.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ - "# Your code here:\n", - "\n" + "\n", + "from statsmodels.tsa.seasonal import seasonal_decompose" ] }, { @@ -154,6 +455,107 @@ "Plot the decomposed time series of `rotationRate.x` also with a frequency of 60." ] }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "DatetimeIndex(['2018-01-01 00:00:00', '2018-01-01 00:00:01',\n", + " '2018-01-01 00:00:02', '2018-01-01 00:00:03',\n", + " '2018-01-01 00:00:04', '2018-01-01 00:00:05',\n", + " '2018-01-01 00:00:06', '2018-01-01 00:00:07',\n", + " '2018-01-01 00:00:08', '2018-01-01 00:00:09',\n", + " ...\n", + " '2018-01-01 00:29:01', '2018-01-01 00:29:02',\n", + " '2018-01-01 00:29:03', '2018-01-01 00:29:04',\n", + " '2018-01-01 00:29:05', '2018-01-01 00:29:06',\n", + " '2018-01-01 00:29:07', '2018-01-01 00:29:08',\n", + " '2018-01-01 00:29:09', '2018-01-01 00:29:10'],\n", + " dtype='datetime64[ns]', length=1751, freq=None)" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sensor.index" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [], + "source": [ + "import statsmodels.api as sm\n", + "import matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "freq S not understood. Please report if you think this is in error.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [100]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m matplotlib\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfigure.figsize\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m7\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m descomp_serie \u001b[38;5;241m=\u001b[39m \u001b[43msm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtsa\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mseasonal_decompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43msensor\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43muserAcceleration.x\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m descomp_serie\u001b[38;5;241m.\u001b[39mplot()\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/seasonal.py:156\u001b[0m, in \u001b[0;36mseasonal_decompose\u001b[0;34m(x, model, filt, period, two_sided, extrapolate_trend)\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m period \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 155\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pfreq \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 156\u001b[0m pfreq \u001b[38;5;241m=\u001b[39m \u001b[43mfreq_to_period\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpfreq\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 157\u001b[0m period \u001b[38;5;241m=\u001b[39m pfreq\n\u001b[1;32m 158\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/tsatools.py:813\u001b[0m, in \u001b[0;36mfreq_to_period\u001b[0;34m(freq)\u001b[0m\n\u001b[1;32m 811\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m24\u001b[39m\n\u001b[1;32m 812\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m: \u001b[38;5;66;03m# pragma : no cover\u001b[39;00m\n\u001b[0;32m--> 813\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 814\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfreq \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m not understood. Please report if you \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 815\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mthink this is in error.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(freq)\n\u001b[1;32m 816\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: freq S not understood. Please report if you think this is in error." + ] + } + ], + "source": [ + "matplotlib.rcParams['figure.figsize'] = (10, 7)\n", + "descomp_serie = sm.tsa.seasonal_decompose(sensor['userAcceleration.x'])\n", + "descomp_serie.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "seasonal_decompose() got an unexpected keyword argument 'freq'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [103]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mstatsmodels\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mtsa\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mseasonal\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m seasonal_decompose\n\u001b[0;32m----> 2\u001b[0m decomposition \u001b[38;5;241m=\u001b[39m \u001b[43mseasonal_decompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43msensor\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43muserAcceleration.x\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43madditive\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilt\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfreq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m60\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m fig \u001b[38;5;241m=\u001b[39m decomposition\u001b[38;5;241m.\u001b[39mplot()\n\u001b[1;32m 4\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[0;31mTypeError\u001b[0m: seasonal_decompose() got an unexpected keyword argument 'freq'" + ] + } + ], + "source": [ + "from statsmodels.tsa.seasonal import seasonal_decompose\n", + "decomposition = seasonal_decompose(sensor['userAcceleration.x'], model='additive', filt=None, freq=60)\n", + "fig = decomposition.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Comentario en la instrucción del probelma se solicita cambiar freq a 60 sin embargo en la función de se solicita no tiene soporte para ese argumento\n", + "# El index con las nuevas fechas tiene un freq de S que no se soporta en seasonal_decompose" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -165,12 +567,44 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ "# Your code here:\n", - "\n" + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pd. plotting. lag_plot(sensor['userAcceleration.x'])" ] }, { @@ -182,12 +616,35 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEGCAYAAABsLkJ6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAtg0lEQVR4nO3df5Bc1XUn8O+Z5iH1YJsRQY5RGyHFcSQbhDTRLJatSu1KdiwSAR5LAWJjrzfeWtVWrSuBkHEGQxnwj9JUVBiyG1dtWNuV3UJ2JFswBsYugS25XNFGmBEjIRQkxxgQtOxlHDTYaBrUM3P2j+43evPm3fej+3W/9/p9P1UUmp7+cdXqvvfdc889V1QVRESUP11JN4CIiJLBAYCIKKc4ABAR5RQHACKinOIAQESUU+cl3YAoLr74Yl22bFnSzSAiypRDhw79SlUXu2/P1ACwbNkyjI6OJt0MIqJMEZEXvW5nCIiIKKc4ABAR5RQHACKinOIAQESUUxwAiIhyKlNZQEREaTY8VsaOvSdwaqKCJT1FDGxagf7eUsse1ywOAEREMRgeK+O2B4+iUp0GAJQnKrjtwaMA4NuZN/q4ODAEREQUgx17T8x24rZKdRo79p5oyePiwAGAiCgGpyYqkW5v9nFx4ABARBSDJT3FSLfberqthh4XBw4AREQxGNi0AkWrMOe2olXAwKYVxscMj5Xx+htT8263CjL7uOGxMtYP7cPywRGsH9qH4bFybG3mIjARUQzsBdso2Tw79p5AdWb+sbwXnH8e+ntLLV8g5gBARBST/t5SpI7ZFOd/rVIF4L9AHMcAwBAQEVFCgtYNWr1AzAGAiCghQesGjS4sh8UBgIgoIf29JWzfsgqlniIEQKmniO1bVs2GdxpZWI4isTUAEVkI4McAFtTb8R1VvTOp9hARJcFv3aCRheUoklwEfhPARlV9XUQsAP8kIt9X1YMJtomIYpZUnZtOEXVhOYrEBgBVVQCv13+06v/Nz4ciosxKss4NBUt0DUBECiJyGMArAB5X1Sc87rNNREZFZHR8fLztbSSixrWizk0rN0blTaIDgKpOq+oaAO8EcJWIXOFxn/tVtU9V+xYvnneoPRGlWNxpjPaMojxRgeLcjIKDQGNSkQWkqhMAfgTg6mRbQkRxijuNMcnKmZ0osQFARBaLSE/9z0UAHwJwPKn2EFH84k5jTLJyZidKMgvoEgD/W0QKqA1Eu1X10QTbQ0QxizuNcUlPEWWPzr4dlTM7UZJZQE8D6E3q9YmoPeJMYxzYtGJOVhEQ78aovGExOKKMy1Oefas3RuUNBwCiDMtjnn0rN0blDQcAopSJckXf6nLBlKxWz+44ABClSNQrembFdK52zO5SsQ+AiGqi5rm3ulwwJacdex44ABClSNQr+laXC6bktGN2xwGAKEWiXtEH1ZOn7GrH7I5rAEQp0kieezuzYtqZcpqn9FYv7djzwAGAKEXSnOfezpTTPKa3urXjsyC1svzZ0NfXp6Ojo0k3gyiX1g/t8yzDUOop4sDgxra91sCmFakcINNMRA6pap/7ds4AiCiUdqacmp7TngnkeWYQJy4CE1Eo7Uw5NT1nQYTloGPEAYCIQmlnyqnptaYNIWtufGsMBwAiCqWdKaem1ypx41usuAZAlDPNpFe2M+XU9FosBx0fDgBEKRZ3LnxW0yud70NPt4UF53XhtUqVWUBN4gBAlCLuju71N6ZQnanFvePorJupHhrHYNTIc7gHrdOTVRStAu69cQ07/iZxDYAoJeyOrjxRgaLW0dmdv63ZjJdGUzndbbMHo+GxcujXbvQ5eBB86yR5KPylIrJfRJ4VkWMi8hdJtYUoDbw6Oi/NZLw0msoZRyfc6HP47Qmg5iQZApoCcKuqPiUibwVwSEQeV9V/SbBNRIkJ27FHyXhxh1w2rFyMPYfKkRdR/WYOYcI6w2NlY4cd9Pc2HQQv9edlGKhxic0AVPUXqvpU/c+/AfAsAP5LUi4Mj5Wxfmgflg+OYP3QPgyPlUN17FEyXrxCLnsOlbF1bSlyKqepbRcWrcCwjt2OqM9tG9i0AuJxuwJzZg9e7yn5S8UagIgsA9AL4AmP320TkVERGR0fH29724jiZoqFb1i5eN7mJ6sg6ClaDeXdm0Iu+4+P48DgRjw/tBkHBjeGej7TxqyzU9OBYZ2g0Nbk2Snfzrq/twRTxTJ79tDI+gIHjBRkAYnIWwDsAXCzqv7a/XtVvR/A/UCtGFybm0cUO7+OefuWVbGlfcZZu8erMuWGlYvxwMGTvq/hF/qxnZ6sBmY3lQxhIHv2EDW7KavpsHFLdAAQEQu1zn+nqj6YZFuI2sWvY45zo5Updm4KuQTF8t1tWz+0z/e1g0I/TkGpqH618RtZX2gmHbaTJDYAiIgA+DqAZ1X1K0m1gyiqRvPh7ceZprFxlzOIcqCI6Yp49MVXsf/4uOff1W8mYZdsDpPVZPN7PlNtfAANrS+0s7JpmiU5A1gP4JMAjorI4fptn1PV7yXXJCJ/jYYO3I9za0U5gygHipiuiHcePDk7YLn/rqYZxqJuC/29Jdyy63Ck9gYNgF6zo/VD+xp6T3u6LZyerHrenieJDQCq+k+A5+I+UWo1GjrwuxoutbCcgSmk5J7FmEIo7tmK8+9qWgPYfOUlAMwhKC9WQYydtd+My++K3W/B3HQOVobOx4pF4ovARFnS6KYk0+MEaPg0rWZCUe5ZTBTliQrWD+3D5Nkpz9/vfOIk+i67yDMEZWToeINmXKZBpiD+15avVeZf/fvd3qlSkQZKlBWmMIW9KSnq48LG/d0pi3cMH224NEPU2LyX8kTFM4QC1K6iB759BAB8Szg7VWfUc0ewacZ19yPHAHinpwLAtKrv+9HOw23SjAMAUQSNbkryyvF3ZrH45aN75bjvPHiy4dIMYRc6u60uz841DFOH7serXaa2np6szu4C3r5llecVv9/70c7DbdKMAwBRBI1uSjLtwAUQeCXvdRUc1AaT4bFy6JW3yeoMtm9ZhUUNLozaf5ewISavq2+/K/Jbdx+ZHQRmIp4U1s7DbdKMawBEETW6KcnegevklcXiXlSOkpqo9ed0rwcMj5Vx9yPHjGEbLwUR9PeWsGPviUiPcz4+bKjJdPU9sGkFbjZkE9lhHiD6ngegvYfbpBVnAJSoLG7HDwofRMkxD3Nfv3UHL+5ZhD0jidqJ2+fvNlJ1s8vx+DDsQc/979/fW0JP0TwDsR/XipBOFj+bUXEAoMTEUWM+CUHhgygLjGHu69W5CWpX+6ZsF2f8u5lF32WDIw097sJuK9Tir1N5ooJbdh3GHcNzN3bddd3lvmsR9g7qOEM6Wf1sRsUQECUmy9vx/cIHUXbghrmvc0NXeaIy2/kD/lfZ9iwiid2tE5NV3Hnt5eHTQOsUwAMHa2mk9t/b/v+tu494/n17ui2sH9o3mw4bdFJYmPTZLH82o+AMgBLTqdvxo1yNhr1vf28JBwY3otRTNC4Au9mziCRSG+2sKPfCt184x+muh4/N+bm/t4R7bljtWS319TemQl+ph72y79TPphtnAJSYRhbu0sZ0NRllgTHKfcN2QFbXuZ21kTZkxag8UcGun7yEtyysdTOTZ6dwdipcGyY8NmR5lbY48+bUvPv6XamHvbLvhM9mGBwAKDFRQiVpYnf67g6iPFHBwHdqG6DCduhRd/OGLa/gDpUstLraPgAAtf0A9uJz1EVor9O+3IPlcsMaRdQrePftWf1sRsUQECUmi7nYzhCCl+q0zu5SjfJcdjjCaxHUybTz1W1Ga2GURjOA0iDMomvUHb1hb8/iZ7MRnAFQorKWix0mo8bubIfHyrjr4WOzIYpF3RbuvPbyOaEMrw1eO12LoE5eYRDTYDRRqeLuR44lcuUfh0p1GrfsPgzAPKOKeqUe5f5Z+2w2ggMAUQRhY/DDY2UMfPsIqjPnQjGnJ6u4eddh3LzrsHEzGVAbBG7dPTeUdMfwUXzriZcwrYqCCD72vkvxpf7aTmK/VM20X/nblVBNm72cdYXCDoh+YbSo9+90ohmqf9rX16ejo6NJN4NybP3QvsAYfE/RgkjznW/RKmDr2hJ2/eQkqjPzf/+JdUvxpf5V6P3CY6nv6E26BHj/71yE//vcq77ZTaWeYsNVUwkQkUOq2ue+nWsARBFsWLnY9/dWl+Ca1ZfE0iFXqtN44KB35w/U8uWXDY6ksvMPe9DHjAIHAjp/oPPSL9OCISDKlUZr6Nv2Hx83/s4OZ0StgtmJ7F3KUcpB+Om09Mu04ABAHcvd2W9YuRh7DpUjH+fo5Bf+sQeTqEchdqq4On/nngaKV6IDgIh8A8A1AF5R1SuSbAt1Fq+TpJzn29qibu/3u6oNqkxJ0fUULdx13eWJLNI2O1vMgqTXAP4BwNUJt4E6UJw19J38rmqdlSmtLh53HYVXR1S0Col2/iwG12Kq+mMRWZZkG6gzRenUo8SX/dI357wu+/9IvNa53RVN23klzmJwKSEi20RkVERGx8fNC3BETmFr6Efd3h+0E3dJTxE79p5AdTpc/LtLMLvbNOgg8zxynirWzivxvBSDS/0AoKr3q2qfqvYtXuyfgkdkMx0QctO6pYHb+/0OArFLBHhVtbQHkyidxMfftxQHBjfi+aHNuOeG1Zw4uHidKhb27ONm5OXQeGYBUUdqZMenu3QD4J0pZJcIMC0SehWK81K0uvCl/lVznic72zJbr2gVjGUsWn0lnpdicInvBK6vATwaJguIO4GpVdxZQ25RdqIOj5WNpQ1sVpdgx/WrASCRUs1pZ2f/mAbTduwM7qQsINNO4KTTQL8F4D8AuFhEXgZwp6p+Pck2UT4FFXmL+4pzShW37DoMkdpuWKopiOCeG2oDo3s2ZmvXlTiLwbWYqn4sydcnsgV18F6xX9MVYphy0PbEO0OluGLjPNLSbab+hrgL6dncFVWpOVwDIIL/5i2vK06vjWa3PXgUoy++msraPGmiMA8CdiVU036L7vPP46awGHEAoI7l9aUFvBeGTccmmq44TXni33ripdb+pTqE3yAQ5qD7djIN9kD4EiJpxQGAOpLXl3bgO0cAxWxoweuLHPYqz9QRBdW/ibNAWtYpgjfWuSWRhtnJm8I4AFBH8vrSem3Ocn6Rwyz62bMKUxfeFbCou9DqwpmzzPgBgg+DcbMKyRSF6+RNYRwAKPO8Qj1RvpxRTvnyS9ms7eb1HwDY+dfY6yp+G7qcIaIkF39N60OdsCmMAwBlmik+29NthV6MDftFDkoVVcB4eAudUxCZ3YHtVzr73hvXpCLE0smbwjgAUKaZ4rMLzuuat5PUKsicNQBg/hfZL9ujE6b8aTCjOvuemq6uF3Vbqej8gc4+R5gDAGWaqVN+rVLFvTeumXcgzMjTv5idGbhrzQdle7DOfzCrIIGF8JwzLtPV9Z3XXt6yNjaiUzeFpb4YHJEfU/hGgdna/M8PbcbAphXYc6g8Jyz05tTceI1pNnHr7iNYPjiCM29Oxd7+TnPjv7t0tqqpACi4zkVwz7js4npBBfqoNTgDoMwaHiv7dsrOK3hT5373I8cCQzx22qZXWQI6p6doYc+h8uz7pahdYb6t28LEZNUYOunUq+ss4ABALdeKXZRBGTk2O83T1LmfnqzOlnvuYo5+wwSACOan3s4oTk9WZ1M+2dGni+8AICILUTuz9w8ALAFQAfAMgBFVDS54QrnXql2UQRk5TvbAY4rf3/XwMbw5NcPOv0EC4APvuggHnnvVeJ927p5NQ9mGNLQhDOMagIjcBeAAgPcDeALA3wPYDWAKwJCIPC4iV7ajkZRdfrsomxF196hfyt5EpcpyzA0q9RRx07qleOrka4H3bcdBLmk4yzcNbQjLbxH4SVVdq6q3quo3VfUHqvqoqn5FVa8FcBOA89vUTsqoKLso/U7ict/PdHKW6cjH/t6S5yle1Di7Jv/+4+ORZmOt1KoLjqy1ISzjAKCqI34PVNVXVJWns5CvsEfrRblqMpViEMD3yMe7rrvc9zxfCs+ZzROlU2/17tk0lG1IQxvCamgRWETuV9VtcTeGOk/YXZRRCm6ZvkgK4Ev9q4xtsZ/Hr9wwhbN1be3oy1t2HTYunrurfZp2zzYaL/d6XBrKNqShDWH5rQFcZPjvtwD8cRvbSBkWNs87ylWT6YtUCvEF6+8tsfNvUtHqwp5D5dnZmtf7WbQK+MC7LprdE1AQwda189M9G42Xmx63YeXiebO8dpdtGNi0IvE2hOU3AxgH8CLmhlXtMt5vb2WjqLOEyfMOe9U0PFbG5Nn5uf9hvmD2oe/UnIqh4FFBBDOqs7uunXsCplWx51AZfZddNOez0GipZdPj9h8fx/YtqxLNwMlS6Qi/AeDnAD6oqifdvxCRWE69EJGrAfwtgAKAr6nqUBzPS+nnnr7bHcac2j1dgsmzU1g+OGK8DzC/pIPp9Xj4urcF53XN2xUNAJ9Yt3RO6YwgM6p4fmgzAGD90L5QHXuj8XK/x6VhY1ka2hCG3wBwH4BFAOYNAAD+ptkXFpECgK8C+EMALwN4UkQeVtV/afa5Kd289gbsOVTG1rUl7D8+jlMTFVxYtHDm7NRs51OeqGDnwZOei78XLPA/JnB4rMy4v4+CIaXqgYNeX30z52zN1EGXJypYP7RvduA3VW0NipdnKc6eZsYBQFW/6vO7/xHDa18F4Geq+nMAEJF/BPARABwAOpzf9P3A4EYAtStId+kFU/dtSindsfcEyhMV30PICZiMoYa1VRCcefPcbO3CouVZOkNwbg9HeaICq0vmFZArWgVsWLl4zkDhDqF0conmdkqyFEQJgDOU9DKA97nvJCLbAGwDgKVLl7anZTnUzp2LfleHdgcSdaPXnA5fAOfFPjv/1rAnDj3dFl5/Y2q2wy9PVOYVgbO5/y2qM4qeooULFpxnDAd67SLOUpw9zZIcALw+IfO+q6p6P4D7AaCvr4/f5RZo96HXfh28ndFh4pVauGHl4jntZ6SnPRTAffWS2+4wzrTfsWgur1WqOHznh2d/Drt+kJU4e5olWQ76ZQCXOn5+J4BTCbUl19q9c9ErTS6MolXw3OgVZScqxcuv0F5Y7rh9ljZSZV3oGYCILFLV0zG+9pMA3i0iywGUAfwpgI/H+PwUUru/cO7pe5hrxS6pZavsPHgSS3qKc44L9DtWkJpX6BLjFX1QoT23MJvDghZ4s1JoLQuizAB+GOcLq+oUgM8A2AvgWQC7WWE0GWHLNcSpv7eEA4Mbce+Na4x1fZxmtFa0zWuzEDM/WuutC87Dom7vOkp2B+ye0VkFgeVxGIxfqQ6b30aqLBVay4IoawBhvqeRqOr3AHwv7uelaJLMqDDV9QnijAl7tT9P7KvqRYaUymbZx2uaPiOmBVmv28Jcqfst8IZdH6Bwgs4D+I/2HwEscvwMVf0/rWwYtU+SGRXNhJnKExUMj5XR31vC6IuvRs5bz6qeogUReJ6yNTxWxucefDqW1E7bkp5i4GfEuSDrDNH0dFu4sGjh1ERldk0p7CDgdT+uD8QraAaw3PHnBQCWYX4YjzpAUhkVzR60ftuDRzH64qvYcyg/IYCJShVWQeasgwDnOt5KdQalejrlridfMh7S3lO08FqlOpt66bXr1zkTDPMZcWeUOZ8vjuwybgCLl2jInDkReUpVf7/F7fHV19eno6OsQN1JWKKhcd1WFxZdsGDOzmn3hqqta0vGHdTu/Ptmwja29UP7Agd0+xyBRnh9XopWgQfJBxCRQ6ra57490TUAIvtLezMzeSKbrM5gst7Zeu26rVSnMfL0L4zT9YlKdc7mrdsePIrtW1Y13DkD4UIxzYRruAEsXlEGgE+2rBWUW3bYglojyqJws4upw2Nl49kATs2Ga7gBLD6hBwBVfaaVDaHO5VwUvNCxgGmXEKhG2DVKrdXo1bkdmgnq/FmvJ12SLAVBOeCO2TpDFX5Xp4u6Lbw2WUV8uSwURqNX5167yYHaBr63LTy32MxwTbpwAKCWMnUMQe689nLc/tBRnDnLxeFmLOq28EZ1JtS/gV2pc/3QvsgdtfGYTsWcOj9hcKdv+wTuBBaR68PcRuSl0ZDCzbsOs/NvUtEq4M5rL8fWteE6Tzt408juWtPMQVHLDAr7XNzp215hSkHcFvI2onkuLHqXEKDWEjl3cLvfBrlST9GzzIOzGODwWBnrh/Zh+eCIsTP3K/AXpRNvd2HCvDOGgETkj1A7/L0kIv/d8au3AZh/KCuRB2HycCJUgV0/eSlwgf3A4EYsHxzx/N2p+k7rMKXCnemZXvsAwmYYcadve/mtAZwCcAjAdfX/234D4JZWNorMosZHk46nTrSgNk1eFESw0OpqOBQWNrvKb3dtlEPb7fTM5YMjnnsPTJ248zNqSiPlTt/W8DsS8giAIyKyU1X5LU6BqAe3hL1/mEGi0YGk2VIPeTat2pZ1EL9igKZS235X5FHKNbg/o16dP1NHW8e4BiAij4jItYbf/Y6IfEFEPt26ppFb1PhomPuHWXRrZmGu0cNfyFupp4iemNZV7Nh/f28J27es8izT3EipcL9yzm6mLLGCiG/JaIqHXwjovwD4SwD3icirAMYBLEStINxzAP5OVb/b8hbSrKjx0TC3h5niRwkDAHMPZC/Up/SFEDtEyZ9dQ8cUs3eyCgKoOQxkFQR3Xnv57M+m3bWNlAqPUq7B9BmdUcXzQ5uNr0Hx8AsB/RLAZwF8VkSWAbgEQAXAT1V1sj3NI6eolRDD3D9okBgeKxtDOF6PvWP46JziY3anz86/efb7bfp3LYhgRtWzsNuFPiWk/TRaeydsuQZW90xW4EYwEfkMgAdU9YXWN4f8RL0aC3N/vy+gHfoxcX5Jh8fKuOvhY55FySgedkqt6d/VK1QSR+iklbV3kjyMiMLtA3gHgFER2S0iV4swsS8pfrHaRu/vF6/128Xr/JLaAwU7/2gKEb9K9t2jfg7SrJP+LlkU6jyAeqf/YQB/BqAPwG4AX1fV5xp60dpO4rsAvAfAVaoaqsg/zwNoDVOGjymdDwDucxxGEqYGvG1Rt4Xu889jZlADBGBcnBrS1HkAqqoi8ksAv0RtE9giAN8RkcdV9bMNtOcZAFsA/H0Dj+1ISebrm6b4pvBQyXFEIBB+k45dmgAwbxgiM8bFKW5h1gD+HMCnAPwKwNcADKhqVUS6APwragvFkajqs/XnjvrQjhRnvn6cwsZnw+b6b9+yCgB4Ahhq76Pfe+A+d7XZuLjfZyfpzYKUnDAzgIsBbFHVF503quqMiFzTmmadIyLbAGwDgKVLl7b65RIRJs0y6iYwt0a+5GEyQIbHyjjzZrjKILzqP2f7llXG98Pd+QtqdX2aOajF9NkBEPpzxYGi84Q+EzjyE4v8ALUFZLfb7f0DIvIjAH+V9zUAU6zdGfM1xdnDnK/aqnNUeZ6vN5FaLR7T3oeCCO65YTWA+bMhd+dva+YcXb/PDoBQnyuexZttpjWAMFlADVHVD6nqFR7/cfOYS5jdls0UyWpVhcVGa/13qlJPEffduAbPb9+MF4Y2454bVnvugp5Wnb3KdmfAmC7HmimG5vfZCfu5YpXOzsQDYVKg2Xz9IK2qsMgKjee84JGdY18Z37r7yLyZQKU6jbsfOYbu88+bE1IxhYWaWQAO+uyEeT1W6exMLZsB+BGRj4rIywDeD2BERPYm0Y60aDZfP0gj9VzCYK3/Gr/aPP29JcwYwqynJ6vz6ittWLm44X9nE7/PTtjPVas+Q5SsRGYAqvoQgIeSeO20Ctpt2eiWfMB7hhHl+D+vxT8AOHOWx0JYXYK7rrvc+PsoJ1lVqtPYf3x8doE4rsXWMJ+doNfjjt3O1LJF4Fbo1EXgdnAWaPNKMTQt5pkW/xZaXb6HuueBAOjptoz1dYbHyhj49pHQdfnt54xrs1fcWTvMAsou0yIwB4CciZpNFGWXb95YBUF1+tz3xz2QNvLeNZPt48SsHXJqexYQpZNp0c4OB7nPfeUin7cuwZzOH6iFcG7edXj2/WvkvYsrpMKsHQqDA0DOmBbt7DUB94Evpvv3FC3keR+3X1THfv+iLpIv6rZiuzpn1g6FwQEgxYbHyp5X5c3YsHKx5+3u/sy+WvTKEhEAE5VqLgYAU8XOoEqeleo0RGqLxG5dUj+wxcFZJykOzNqhMDgApFQzxzD62X98PPR9T01U0N9bwta1pTkdnj1YzDTVkmyYVvVMk/zY+y4NPOpyYrKKHdevnpMmuqjbwlduWIMdf7K6pSWQm0kbpvzgRrCUinoMY1hRQgD2oTB7DpVze6JXQQRb15aw//j4vOyXvssu8q1vtKReNdXvvIZWMaV+ArXFaWbyEMABILX8FmubEbZyp/1aXrtY82RaFXsOlY2nbfX3lowZN62q3hmWe/BptqAgdR6GgFLKb7G2mTCQV2jATyd1/j1Fa7YAWhRB2TNxn2rVqvAfM4PIjQNASg1sWuG5yKpAU19Yu7Na1J2/Mg7XrL4EBwY3NjQIBIXO+ntLODC4Ec8PbcaBwY1NXVG3qqNmZhC5cQBIqf7ekrEypJ2z3+gVYX9vCd3n5y/6Zy+AmwZXP+3MnmlVR83MIHLjAJBifleqzYYF8ri7tzxRwfLBEezYewIfeNdFoQeBdmfPtKqjZmYQuXEASLGgeH0zYYGgPPZOZcfUf/LCady0bqlnKMwqyOxGt1akaAZpVUcd91oFZV/+4gAZ4kzlM12xNxIWGB7Lb1qnrTqtGHn6Fxj7/IdTV+SsmcqvYZ670zr8tP37ZQmLwWVEM0dCOvEYx7m8DnKh7GDRu3BYDC7j4goLdPoxjlZB0G3xY50XTG1tDr8pGdFs/NauK9Tpi7/VacWiCxbgvhvXzL5XptUOv5O8KBuY2tocrgFkSKPx27yFfewaRvZ75XUwS9BJXpQNzZyVTQkNACKyA8C1AM4CeA7An6nqRBJtSaugha0oC1+dEPbpEkB1ftVSL/aX3/ke9XRbUAVeq3if3kXZxKMqm5NUCOhxAFeo6pUAfgrgtoTakUpBpQCilgrohOnwV25Yg+eHNofaxbth5eJ579HpySrenJrBvTeuaXqnLqUHU1ubk9Sh8I85fjwI4E+SaEdaBVUCjVopNEoBuDQq1atqAuEGs/3Hx7H/+HhLqqlS+nRiamu7pGER+NMAvm/6pYhsE5FRERkdHw9fyz7Lgha2go51dM4EhsfKmDw7FX8j28g5ne8JUcPo1ESFi4NEIbRsBiAiPwDwDo9f3a6q363f53YAUwB2mp5HVe8HcD9Q2wfQgqamjumKvUsEywdH0CVi3MjlLPELIPOLvz3Fucckhtm2Yq8BcHGQyF/LBgBV/ZDf70XkUwCuAfBBzdJutDbwWtgCzpVmDtrFW6lO4+5HjmGiUvXsMAs+A0jauDN1XqtUfe/vXABMw+Igd6lSmiWVBXQ1gL8G8O9VdTKJNqRZmBIQgH9HfnrS3FEm2fkv6rbw+htTc1IyBd7ZPe6rf8B/PaPk0cEm2fnyABZKu0RKQYjIzwAsAPBv9ZsOqup/DXpclktBNHol6Ld5S5CtBd6CCO65YTWAuR3zhpWLsedQOdR2/ixt/Y+rfAdRs0ylIJLKAvrdJF43Kc1cCfotWtoDyS27DofKj0/atCpue/Aotm9ZNa8DtM/XDRogW1koLW5ciKa0407gNmjmgHfTFb4Asx3fzbsOx9ja1vL6e0edHWUl7Y+7VCnt0pAG2vEauRJ01u5x17IRADetWzrbCTZyxGGcor5+eaLS8Ka2LOEBLJR2HADaIOoJT85OEagtkNqDQKmniJvWLcX+4+NYPjiC9UP7sGHl4sT+Ia2CYGDTisiDwMC3j6D3C4/h5l2HO7aaI3epUtoxBNQGUeuVeIWMFOeyXJyFzcoTFTxw8KTn86x/10U4+PPTrc36qT+1KXXVpDqjvplKnRInz0q4ivKJM4A2iHol6BcyuuvhY3NSKP0c/Plp3HPDaliF8Mc/Luq2YHWFv391RnHr7iMAgO1bVsVWYplxcqLW44lgKWRKH1zUbfleNXsRABcWLVSnZ3DmrPnqvNAluOf61ejvLWF4rBx5YdnO5Y9jk1la0zqJsoongmWI1+KhVRC8/kb0mj4KYKJSxYwC9924Bi8MbcYn1i2ds7B8wfmF2c4fqM1YPrFuaeTXAZrfZFbqKWLr2lrBO3uNoxMWhInSiDOAlHKnRp55cwoTAWUQgkTdgHTH8FHj+kJUPUULFyw4D6cmKriwaOHM2SlUp8999uyrfsC7hANnBESNM80AOABkxPLBEeNmL6sguGrZolALvvfduGY2zBMm997vdcPy6sBNr8/ds/nDekmtxwEg43q/8Jgx/v+JdUvxpf5Vsz/7lY8oWgVsXVuaV3rBjuGX6qUZ9h8fx6mJirHyqKl+jxd70AnDNOAIgOeHNod8RcqKLJX2yLJUlYLIK/eVjrOjdV/5DI+Vcfcjx0It+tphGnsQ8EvJrFSn8a0nXprXqds/udNKvTp/exDZf3w8sA6R8zCXMLh7Nl+a2SVPzeMA0CZe9YCcHa27jv/Ad47MiZEH2XnwJPouu2hO3rkpk6eRhdqCCGZU5w1UQbONqLteecZrvrBeUrI4ALRJmIPZnTtgo3T+QO0K3nnVZB8dGVel0BlVzxCM3xe1kWm8V7G3DSsXY8feE7hl12HGiDsMZ3zJYhpom4S9oilPVBrutN1HQg5sWjGvjpAt/FavmqjlLKI+v1N/bwkHBjfi+aHNGNi0AnsOlTuyVhCxXlLSOAC0SZQrmmY6T2cH2d9bMi7U2gu+YV7P7wtpGmTsGUmz/GLElH2sl5QshoDaJEqtnGbzspyLaCXDFNuZVhllcdrNrxx1HHFcxog7H+slJafjB4C05Bjbr3nr7iOhF2GdpR96ihauWX1J6I1ZdjjIdNqW84q+2S+gaZCJI47LGDFR63T0AJC2M1nt1wwzEzBtfAqTemkrT1Sw51B5NmWzVYNgKzN3mBVE1DqJrAGIyBdF5GkROSwij4nIkla8Thrjx+6Yp1f1zaCYe5TqnpXqNPYfH8fAphVY0lPEqYkKduw9EesiaivjuIwRE7VOUofCv01Vf13/858DeG8rDoXPyq7SqGEq9yYxqwuozkR7Te62JMqPVO0Etjv/ugvQ/Lqnp6zEj6PG4N3399uMZcLdlkSUWBqoiHxZRF4CcBOAz7fiNdKeY2yf+9ts2eNGM2KYSUOUby0bAETkByLyjMd/HwEAVb1dVS8FsBPAZ3yeZ5uIjIrI6Pj4eKQ2pDl+HOdh6I3OaNI2EyKi9kq8GqiIXAZgRFWvCLpvJ1UDjbPssami4htT0zD983INgCg/UnUimIi82/HjdQCOJ9GOJMW5wck00/Eb29n5E1FS+wCGRGQFgBkALwIIzADqNHEvUHstJJuKwUUt0UxEnSmRGYCqblXVK1T1SlW9VlVzV9mrHQvUaV8EJ6JkdfRO4DTzKnsc9w7ddrwGEWVX4ovAUXTSIjARUbukahGYiIiSxwGAiCinOAAQEeUUBwAiopziAEBElFMcAIiIcooDABFRTnEAICLKKQ4AREQ5xQGAiCinOAAQEeUUBwAiopziAEBElFMcAIiIcornAaTc8FiZ9fyJqCU4AKSY+7D38kQFtz14FAA4CBBR0xINAYnIX4mIisjFSbYjrXbsPTHb+dsq1Wns2HsioRYRUSdJbAAQkUsB/CGAk0m1Ie1OeRzo7nc7EVEUSc4A7gXwWQDZOZOyzZb0FCPdTkQURSIDgIhcB6CsqkeSeP2sGNi0AkWrMOe2olXAwKYVCbWIiDpJyxaBReQHAN7h8avbAXwOwIdDPs82ANsAYOnSpbG1LwvshV5mARFRK4hqeyMwIrIKwA8BTNZveieAUwCuUtVf+j22r69PR0dHW9xCIqLOIiKHVLXPfXvb00BV9SiAt9s/i8gLAPpU9VftbgsRUZ5xJzARUU4lvhFMVZcl3QYiojziDICIKKc4ABAR5VTbs4CaISLjAF4MefeLAWRhYTkL7cxCGwG2M25ZaGcW2ggk387LVHWx+8ZMDQBRiMioV9pT2mShnVloI8B2xi0L7cxCG4H0tpMhICKinOIAQESUU508ANyfdANCykI7s9BGgO2MWxbamYU2AiltZ8euARARkb9OngEQEZEPDgBERDmViwEgzUdPisgXReRpETksIo+JyJKk2+RFRHaIyPF6Wx8SkZ6k2+RFRK4XkWMiMiMiqUq7E5GrReSEiPxMRAaTbo+JiHxDRF4RkWeSbouJiFwqIvtF5Nn6v/dfJN0mLyKyUER+IiJH6u28O+k2OXX8AJCBoyd3qOqVqroGwKMAPp9we0weB3CFql4J4KcAbku4PSbPANgC4MdJN8RJRAoAvgrgjwC8F8DHROS9ybbK6B8AXJ10IwJMAbhVVd8DYB2A/5bS9/NNABtVdTWANQCuFpF1yTbpnI4fAJDyoydV9deOHy9Aetv5mKpO1X88iNo5Dqmjqs+q6omk2+HhKgA/U9Wfq+pZAP8I4CMJt8mTqv4YwKtJt8OPqv5CVZ+q//k3AJ4FkLqTkrTm9fqPVv2/1HzHO3oAyMrRkyLyZRF5CcBNSO8MwOnTAL6fdCMypgTgJcfPLyOFHVYWicgyAL0Anki4KZ5EpCAihwG8AuBxVU1NOxMvB92suI6ebCW/Nqrqd1X1dgC3i8htAD4D4M62NrAuqJ31+9yO2vR7Zzvb5hSmnSkkHrel5kowq0TkLQD2ALjZNZtODVWdBrCmvm72kIhcoaqpWF/J/ACgqh/yur1+9ORyAEdEBKiFLJ4SkcCjJ+NmaqOHbwIYQUIDQFA7ReRTAK4B8EFNcANJhPczTV4GcKnjZ/soVGqQiFiodf47VfXBpNsTRFUnRORHqK2vpGIA6NgQkKoeVdW3q+qy+qEzLwP4/XZ3/kFE5N2OH68DcDyptvgRkasB/DWA61R1Muj+NM+TAN4tIstF5HwAfwrg4YTblFlSu6r7OoBnVfUrSbfHREQW2xlzIlIE8CGk6DvesQNAhgyJyDMi8jRq4apUprMB+DsAbwXweD1l9X8m3SAvIvJREXkZwPsBjIjI3qTbBAD1BfTPANiL2oLlblU9lmyrvInItwD8M4AVIvKyiPznpNvkYT2ATwLYWP88HhaRP066UR4uAbC//v1+ErU1gEcTbtMsloIgIsopzgCIiHKKAwARUU5xACAiyikOAEREOcUBgIgopzgAEDVBRC4RkUfrf17jTEUUkWvSVv2RyIkDAFFz/hLA/6r/eQ0AZy76CIDrRKS73Y0iCoP7AIhCEJEvAviVqv5t/ecvA/h/AG4G8B7U6vr8DEARQBnAdlXdJSL3AvhnVd2dSMOJfHAGQBTO1wF8CgBEpAu1Ug4HAJxW1TfrJZ4/D2CXqq5R1V31x40C+IMkGkwUJPPF4IjaQVVfEJF/E5FeAL8NYAzAAgDjAQ99BUAqT3kj4gBAFN7XAPwn1EpRfwNABcDCgMcsrN+PKHU4ABCF9xCAL6B2qtPHUevclzl+/xvUCuY5/R5SUvqXyI1rAEQh1eP8+1Gr5DmtqmcAPCciv1u/y34A761XpryxftsG1LKBiFKHWUBEIdUXf58CcL2q/mv9to8CWKuqd3jc/7cBfFNVP9jelhKFwxkAUQgi8l7U0jx/aHf+AKCqDwF4wfCwpQBubX3riBrDGQARUU5xBkBElFMcAIiIcooDABFRTnEAICLKKQ4AREQ59f8B5tCm1PgayAsAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Your code here:\n", - "\n" + "pd. plotting. lag_plot(sensor['rotationRate.x'])" ] }, { @@ -199,12 +656,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "# Your conclusions here:\n", - "\n" + "\n", + "# Ambas visualizaciones parecen tener una correlación con sus lags" ] }, { @@ -216,12 +674,47 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06822624483241028" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Your code here:\n", - "\n" + "\n", + "from statsmodels.tsa.stattools import adfuller\n", + " \n", + "adfuller(sensor['userAcceleration.x'])[1]\n", + "0.06822624483241028" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.320230335911989e-06" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adfuller(sensor['rotationRate.x'])[1]" ] }, { @@ -238,7 +731,9 @@ "outputs": [], "source": [ "# Your conclusions here:\n", - "\n" + "\n", + "# Tenemos dos resultados diferentes, por parte de userAcceleration.x tenemos un p value grande por lo que no es estacionaria \n", + "# por parte de de rotationRate tenemos un p value pequeño, por lo que se puede concluir que si es estacionaria" ] }, { @@ -250,12 +745,67 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 110, "metadata": {}, "outputs": [], "source": [ "# Your code here:\n", - "\n" + "from sklearn.model_selection import GridSearchCV, TimeSeriesSplit\n", + "from statsmodels.tsa.arima_model import ARMA\n", + "import itertools" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "from statsmodels.tsa.arima.model import ARIMA" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n" + ] + } + ], + "source": [ + "arima_model = ARIMA(sensor['rotationRate.x'], order = (2,1,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n", + "/Users/hal/opt/anaconda3/lib/python3.9/site-packages/statsmodels/tsa/base/tsa_model.py:471: ValueWarning: No frequency information was provided, so inferred frequency S will be used.\n", + " self._init_dates(dates, freq)\n" + ] + } + ], + "source": [ + "arima_model = ARIMA(sensor['userAcceleration.x'], order = (2,1,1))" ] }, { @@ -267,12 +817,40 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 122, "metadata": {}, "outputs": [], "source": [ "# Your code here:\n", - "\n" + "\n", + "from sklearn import metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: statsmodels in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (0.13.2)\n", + "Requirement already satisfied: patsy>=0.5.2 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (0.5.2)\n", + "Requirement already satisfied: scipy>=1.3 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (1.7.3)\n", + "Requirement already satisfied: pandas>=0.25 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (1.4.2)\n", + "Requirement already satisfied: packaging>=21.3 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (21.3)\n", + "Requirement already satisfied: numpy>=1.17 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from statsmodels) (1.21.5)\n", + "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from packaging>=21.3->statsmodels) (3.0.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from pandas>=0.25->statsmodels) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from pandas>=0.25->statsmodels) (2021.3)\n", + "Requirement already satisfied: six in /Users/hal/opt/anaconda3/lib/python3.9/site-packages (from patsy>=0.5.2->statsmodels) (1.16.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install statsmodels" ] }, { @@ -285,7 +863,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -299,9 +877,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.6" + "version": "3.9.12" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }