<jupyter_start><jupyter_text>Ejemplo 13: Series temporales con Keras Paso 1: Gestión de los datos En primer lugar, se cargan las bibliotecas necesarias para la gestión de datos<jupyter_code>import numpy as np
import matplotlib.pyplot as plt
import pandas as pd<jupyter_output><empty_output><jupyter_text>**1.1-Carga de datos**En este caso, los datos están disponibles como un CSV que se carga desde un directorio.<jupyter_code>from google.colab import drive
drive.mount('/content/drive')
dataset = pd.read_csv("/content/drive/My Drive/Colab Notebooks/data/NSE-TATAGLOBAL.csv")
dataset.head()
#print(len(dataset))<jupyter_output><empty_output><jupyter_text>Se seleccionan las columnas 1 y 2.<jupyter_code>training_set = dataset.iloc[:, 1:2].values
print(len(training_set))
print(training_set)<jupyter_output>2035
[[234.05]
 [234.55]
 [240.  ]
 ...
 [121.8 ]
 [120.3 ]
 [122.1 ]]<jupyter_text>**1.2-Visualización de los datos***   Se puede comprobar la forma que tienen nuestros datos.<jupyter_code>plt.figure(figsize = (15, 5))
plt.plot(dataset.iloc[:, 1].values, label = "Open")
plt.plot(dataset.iloc[:, 2].values, label = "High")
plt.xlabel("Días")
plt.ylabel("")
plt.title("Valores por días")
plt.legend()
plt.show()<jupyter_output><empty_output><jupyter_text>**1.3-Codificar los datos**En este caso los datos son numéricos con lo que sólo requieren procesamiento para escalarlos:* Los datos ya son numéricos.* Se realizar una escacla de los datos con MinMax en la zona 0-1, Una ventaja es que se da estabilidad a los datos pero, un problema es que comprime los datos de entrada entre unos límites empíricos (el máximo y el mínimo de la variable). Esto quiere decir que si existe ruido, se va a ampliar.<jupyter_code>from sklearn.preprocessing import MinMaxScaler
sc = MinMaxScaler(feature_range = (0, 1))
training_set_scaled = sc.fit_transform(training_set)
training_set_scaled<jupyter_output><empty_output><jupyter_text>**1.4-Seleccionar los datos**En este caso, los datos se separan por la ventana que queremos controlar (60 días).<jupyter_code>window_size = 60
X_train = [] #Lista de listas de 60 observaciones
y_train = [] #Lista de valores
for i in range(window_size, len(training_set)):
    X_train.append(training_set_scaled[i-60:i, 0]) #Take [0:60,0] [60:120,0] se generan listas de 60 observaciones
    y_train.append(training_set_scaled[i, 0])#Take [60,0] [120,0]


X_train, y_train = np.array(X_train), np.array(y_train)

X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], 1))

print(len(X_train[0]))<jupyter_output><empty_output><jupyter_text>Paso 2: Arquitectura e implementación de nuestra red1.   La entrada de nuestra red será una capa con la forma de los datos de entrada.2.  La función de activación en la capa de salida se establece para que sea un número. 4. La función de pérdida será  **mse**.5. La función de optimización **adam**.<jupyter_code>from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
regressor = Sequential()

regressor.add(LSTM(units = 50, return_sequences = True, input_shape = (X_train.shape[1], 1)))
regressor.add(Dropout(0.2))

regressor.add(LSTM(units = 50, return_sequences = True))
regressor.add(Dropout(0.2))

regressor.add(LSTM(units = 50, return_sequences = True))
regressor.add(Dropout(0.2))

regressor.add(LSTM(units = 50))
regressor.add(Dropout(0.2))

regressor.add(Dense(units = 1))

regressor.compile(optimizer = 'adam', loss = 'mean_squared_error')<jupyter_output><empty_output><jupyter_text>Paso 3:  Entrenamiento<jupyter_code>from matplotlib import pyplot
history = regressor.fit(X_train, y_train, epochs = 10, batch_size = 64)
print(history)
print(history.history)<jupyter_output>{'loss': [0.0023194083247239454, 0.002245409493039869, 0.0020821630932343536, 0.0022651717262460462, 0.002011301252766972, 0.0018462412571534515, 0.0018464375247506874, 0.0019472022510216207, 0.0020134318585778715, 0.0018142159509507915]}<jupyter_text>Paso 4:  Test y Predicción En este caso, se va a validar con el conjunto de test:*   Se pasa como parámetro el modelo entrenado.*   Se pasan los valores de entrada y los esperados de salida (X,Y)*   Se calculan valores para los datos de entrenamiento y de test.*   Se calcula RMSE (error cuadrático medio). Se busca penalizar tanto los valores por defecto como por exceso. El valor preferente es pequeño indicando que que los valores pronosticados están cerca de los valores observados.<jupyter_code>dataset_test = pd.read_csv("/content/drive/My Drive/Colab Notebooks/data/tatatest.csv")
real_stock_price = dataset_test.iloc[:, 1:2].values
print(real_stock_price)#Se obtienen los valores reales
#Se crea un frame con dos columnas: los valores de entrenamiento y de test
dataset_total = pd.concat((dataset['Open'], dataset_test['Open']), axis = 0)
inputs = dataset_total[len(dataset_total) - len(dataset_test) - 60:].values
print(inputs)
#Se preparan los datos en la forma adecudad
inputs = inputs.reshape(-1,1) #-1-->la forma se infiere
inputs = sc.transform(inputs) #se escalan los datos
X_test = [] #se generan la lista de lista de observaciones
for i in range(60, 76):
    X_test.append(inputs[i-60:i, 0])
X_test = np.array(X_test) #Se transforma a un array de numpy
X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
predicted_stock_price = regressor.predict(X_test)#Se realiza la predicción obteniendo un array de valores.
print(predicted_stock_price)
predicted_stock_price = sc.inverse_transform(predicted_stock_price) #Se realiza la inversa para obtener el valor real (previamente se habían normalizado los valores de entrada)
print(predicted_stock_price)
import math
from sklearn.metrics import mean_squared_error
print("Valores reales: "+str(real_stock_price))
print("Valores predicción: "+str(predicted_stock_price))
rmse = math.sqrt(mean_squared_error(real_stock_price, predicted_stock_price))
print("Test data score: %.2f RMSE" % rmse)
plt.plot(real_stock_price, color = 'black', label = 'TATA Stock Price')
plt.plot(predicted_stock_price, color = 'green', label = 'Predicted TATA Stock Price')
plt.title('TATA Stock Price Prediction')
plt.xlabel('Time')
plt.ylabel('TATA Stock Price')
plt.legend()
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11004478566858605, 'fraction_numerical': 0.05326295585412668, 'mean_word_length': 6.2540603248259865, 'pattern_counts': {'":': 0, '<': 35, '<?xml version=': 0, '>': 36, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '512892', 'license': 'Apache-2.0', 'n_tokens_mistral': 2478, 'n_tokens_neox': 2234, 'n_words': 615, 'path': 'intro-deep-learning-es/Ejemplo-13.ipynb', 'repo_name': 'chemaar/python-programming-course', 'size': '6252'}