AWS in a nutshell 11: Alta disponibilidad

11.1 Configuración de Amazon S3 Glacier 

Podemos configurar el almacenamiento de bajo costo a largo plazo con Amazon S3 Glacier.

Una forma de hacerlo es marcar elementos específicos almacenados actualmente en S3 para usar una clase de almacenamiento diferente en forma de depósito Glacier, y otra forma es configurar una regla de ciclo de vida en el depósito para migrar automáticamente los datos más antiguos a Glacier. 

Desde la Consola de AWS tecleamos → S3 → (elegimos un bucket S3) 

11.2 Tipos de balanceo de carga de AWS

El balanceador de carga de Amazon Elastic, o ELB, es una consideración importante cuando planeamos el uso de aplicaciones en AWS. Una de las razones es que podemos mejorar el rendimiento y otra razón es que podemos aumentar la alta disponibilidad. Esto se debe a que hay varios contenedores backend o instancias EC2 que admiten una aplicación y, por lo tanto, se mejora el rendimiento o se logra una alta disponibilidad. Porque si una instancia de backend, por ejemplo, falla, otras están disponibles para tomar el relevo. ELB también es escalable.

11.3 Implementación del equilibrador de carga de red

Un balanceador de carga de red está diseñado para aumentar la disponibilidad de una aplicación, porque las solicitudes pasan por la interfaz del balanceador de carga y hay un grupo de servidores backend separado en la aplicación. Incluso si una aplicación deja de funcionar, otros servidores o instancias pueden manejar la solicitud. Por lo tanto, aumenta la alta disponibilidad y también el rendimiento. Tenemos más jobs esencialmente sirviendo la aplicación.

Consola → EC2 → (panel izquerdo) Load Balancer → (botón) create Load Balancer

11.4 Grupos de ubicación

En Amazon Web Services, se puede especificar un grupo de ubicación cuando se lanza una nueva instancia, y también se puede cambiar después del hecho, como usar la AWS CLI.  Cuando creamos un grupo de ubicación, lo hacemos para poder determinar cómo se distribuyen varias máquinas virtuales o instancias EC2, por ejemplo, en el hardware de los centros de datos de AWS.

Consola → EC2 → (panel izquerdo) Placement Groups→ (Botón) create Placement Group

11.5 Replicación entre regiones de S3 

Podemos lograr una alta disponibilidad con el contenido almacenado en un bucket de S3 habilitando la replicación entre regiones, también conocida como CRR.

Para comenzar, desde la Consola de administración de AWS, tecleamos S3 para iniciar la Consola de administración de S3, donde luego vemos una lista de buckets. 

Consola → S3 → (elegimos un bucket S3) → Management → replication

11.6 Gateway de almacenamiento

AWS Storage Gateway es una solución de almacenamiento híbrida. Los servicios locales que podemos tener en ejecución pueden comunicarse con el dispositivo de almacenamiento de AWS e incluso pueden comunicarse con el almacenamiento de AWS a través del dispositivo para acceder a almacenamiento adicional en la nube. Por lo que se puede utilizar como una solución de copia de seguridad en la nube. También es una solución de emulación de cinta en la nube, por lo que parece un dispositivo de cinta para los hosts locales que podrían necesitar realizar una copia de seguridad, cuando en realidad es la puerta de enlace de almacenamiento de AWS la que a su vez almacena esas copias de seguridad en la nube. 

Por lo tanto, también podemos usar recursos compartidos de archivos locales respaldados en la nube.

Consola → Storage Gateway → get started

11.7 Réplicas de bases de datos MySQL

En la Consola de administración de AWS, podemos realizar una réplica de una implementación de MySQL existente.

Podríamos hacer esto para implementar nuestra réplica de solo lectura en una ubicación alternativa donde habrá mucho acceso de lectura, como consultas, pero al mismo tiempo significa que también tenemos una copia adicional de los datos replicados actualizados. 

Consola → RDS → databases

11.8 Copia de seguridad de AWS (AWS Backup) 

La solución de respaldo de AWS se basa en el uso de instantáneas, que se toman de una variedad de fuentes diferentes, ya sean locales o en la nube. Y estas instantáneas sirven como copias de seguridad. Las fuentes de respaldo incluyen una variedad de elementos disponibles en AWS, así como aplicaciones locales. La ubicación de almacenamiento predeterminada para los elementos respaldados por AWS se encuentra dentro de los buckets de S3. Los servicios de AWS que se pueden respaldar incluyen volúmenes de EBS, bases de datos RDS, DynamoDB, Amazon EFS y también el volumen de AWS Storage Gateway podemos hacer que los elementos locales estén disponibles para respaldo utilizando AWS Backup para almacenamiento en la nube.

Consola → AWS Backup → Backup vaults → (botón ) Create Backup vault

11.9 Copias de seguridad bajo demanda

Una vez que hayamos configurado los planes de copia de seguridad en la copia de seguridad de AWS, que normalmente se programan, podemos, por supuesto, realizar una copia de seguridad bajo demanda en cualquier momento. 

Consola → AWS Backup → Backup plans

11.10 Restauración de copia de seguridad de AWS

Con el Backup de AWS, podemos crear un plan de respaldo para programar backups de recursos de AWS, podemos copiarlos en regiones alternativas y podemos realizar respaldos bajo demanda.

Consola → AWS Backup → Protected resources

11.11 Instantáneas de la base de datos MySQL

Al igual que podemos tomar una instantánea de un volumen de EBS para su custodia, de modo que podemos volver a usarlo en caso de corrupción o eliminación de datos, podemos hacer lo mismo con una base de datos MySQL: podemos crear una instantánea de la misma.

Consola → RDS → Databases 

11.12 Restauración de instantáneas de base de datos

Si hemos tomado instantáneas de bases de datos, podemos restaurarlas en caso de que surja un problema con la base de datos de origen.

12.13 Instantáneas de volumen

Es posible utilizar la Consola de administración de AWS para crear una instantánea de volumen de EBS.  ¿para qué haríamos esto? Pues por seguridad. En el caso de que haya algún tipo de corrupción o problema en el volumen de EBS de origen, tenemos una instantánea a la que básicamente podríamos volver.

Incluso podríamos usar esa instantánea como un punto de partida de origen para crear otros volúmenes de EBS, incluso si no hay ningún problema con el volumen de origen. 

Consola → EC2 → (menu izqud) Elastic Block store → volumes

Autoencoders y GAN´s (Redes Generativas Antagónicas)

Los Autoencoders (codificadores automáticos) son redes neuronales artificiales capaces de aprender representaciones densas de los datos de entrada, llamados representaciones latentes o codificadores (codings), sin supervisión, es decir entrenamiento no etiquetado. Estos codificadores normalmente tienen mucha menor dimensión que los datos de entrada, haciendo los codificadores útiles para la reducción dimensional, especialmente para propósitos de visualización. También funcionan como detectores de características y se pueden utilizar para preentrenar redes neuronales profundas. Finalmente algunos codificadores sirven como modelos generativos, son capaces de generar aleatoriamente nuevos datos muy similares a los datos de entrenamiento. Por ejemplo, si lo entrenamos con caras humanas, son capaces de generar nuevas aunque normalmente serán borrosas o con características que las hacen irreales.

En contraste, las caras humanas creadas por las Redes Generativas Adversarias (GAN) son bastante convincentes y es difícil cree que la gente que representan no existe. Las GAN´s son utilizadas actualmente para incrementar la resolución de una imagen, colorear imágenes en blanco y negro, hacer potentes ediciones de imágenes y convertir bocetos en fotos realistas etc.

Los codificadores y las GAN son ambos no supervisados, aprenden representaciones densas y son utilizados ambos como modelos generativos, y tienen aplicaciones muy similares sin embargo trabajan de forma muy diferente.

Autoencoders (Codificadores)

Simplemente aprenden a copiar la entrada en la salida. Esto puede sonar bastante trivial, pero veremos cómo algunas limitaciones en la red, lo convertirán en una tarea más bien difícil. Por ejemplo, podemos añadir ruido a una imagen de entrada y entrenar la red para que nos devuelva la imagen original. ,Esta limitaciones impiden que el codificador copie directamente la entrada en la salida y los fuerza a aprender vías eficientes de representación de datos.

GANs 

Están compuestas por dos redes neuronales: un generador que intenta generar datos similares a los de entrenamiento de la red y un discriminador, que trata de averiguar si la imagen recibida pertenece a los datos de entrenamiento o ha sido generada por el generador. El generador y el discriminador compiten entre sí durante el entrenamiento. El generador intenta generar imágenes nuevas pero indistinguibles de las del swet de entrenamiento, mientras que el discriminador trata de averiguar si  la imagen que procesa pertenece al set de entrenamiento o la ha generado el generador.

Autoencoders

Un autoecoder está siempre compuesto de dos partes: un codificador (o red de reconocimiento) que convierte la entrada en una representación latente, seguido de un decodificador (o red generativa) que convierte la representación interna en salidas. Un autoencoder tiene la misma arquitectura que un perceptrón multicapa (una red neuronal) excepto que el número de neuronas en la capa de salida debe ser igual al número de entradas. 

A menudo las salidas, son llamadas reconstrucciones por que el autoencoder trata de reconstruir las entradas, y la función de coste contiene una reconstrucción de pérdida que penaliza el modelo que penaliza el modelo cuando la reconstrucción difiere de la entrada.

Como la representación interna tiene una dimensionalidad inferior que los datos de entrada (por ejemplo contiene una representación en dos dimensiones 2D de un objeto de tres dimensiones 3D) el autoencoder se dice que es incompleto. Un autoencoder incompleto no puede copiar trivialmente sus entradas a los codificadores, antes debe encontrar una vía para trasladar una copia desde las entradas a las salidas, por tanto es forzado a aprender las características más importantes de los datos de entrada y eliminar las que nos son importantes.

A continuación vamos a implementar un autoencoder incompleto muy simple para reducir la dimensionalidad.

Ejecutando PCA (Principal Component Analisis) con un Autoencoder incompleto lineal

Si el autoencoder utiliza solamente activaciones lineales y la función de coste es el error cuadrático medio (MSE). Entonces termina actuando como un PCA.

Un PCA es un algoritmo que identifica el plano óptimo sobre el que representar los datos y proyecta sobre dicho plano el dataset, de modo que se produce una reducción de dimensionalidad con una pérdida mínima de información.

El siguiente código sirve para construir un Autoencoder lineal simple para ejecutar PCA desde un dataset de 3D y proyectarlo sobre un plano 2D.

Lo primero de todo es activar nuestro entorno virtual aislado y abrir un notebook de Jupyter apuntando a nuestro entorno virtual aislado. 

Primero, importaremos algunos módulos comunes, y nos aseguramos de que MatplotLib traza las figuras online y prepararemos una función para guardar las imágenes. También verificamos que la versión de Python sea 3.5 o posterior y esté instalado, así como Scikit-Learn ≥0.20 y TensorFlow ≥2.0.

# Se necesita una versión de Python ≥3.5

import sys

assert sys.version_info >= (3, 5)

 

# Se require una version de Scikit-Learn ≥0.20

import sklearn

assert sklearn.__version__ >= "0.20"

 

try:

    # %tensorflow_version solo existe en Colab.

    %tensorflow_version 2.x

    IS_COLAB = True

except Exception:

    IS_COLAB = False

 

# Se requiere TensorFlow ≥2.0

import tensorflow as tf

from tensorflow import keras

assert tf.__version__ >= "2.0"

 

if not tf.config.list_physical_devices('GPU'):

    print("No se ha detectado una GPU. LSTMs y CNNs pueden ser muy lentas sin una GPU")

    if IS_COLAB:

        print("Ir a Runtime > Change runtime y seleccionar GPU hardware accelerator.")

 

# Impoeraciones comunes

import numpy as np

import os

 

# para hacer este cuaderno estable

np.random.seed(42)

tf.random.set_seed(42)

 

# Para mostrar en pantalla gráficos

%matplotlib inline

import matplotlib as mpl

import matplotlib.pyplot as plt

mpl.rc('axes', labelsize=14)

mpl.rc('xtick', labelsize=12)

mpl.rc('ytick', labelsize=12)

 

# Directorio donde se guardarán las imágenes

PROJECT_ROOT_DIR = "."

CHAPTER_ID = "autoencoders"

IMAGES_PATH = os.path.join(PROJECT_ROOT_DIR, "imagenes", CHAPTER_ID)

os.makedirs(IMAGES_PATH, exist_ok=True)

 

def save_fig(fig_id, tight_layout=True, fig_extension="png", resolution=300):

    path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)

    print("Guardando imagen", fig_id)

    if tight_layout:

        plt.tight_layout()

    plt.savefig(path, format=fig_extension, dpi=resolution)

Implementamos un par de funciones de utilidad para trazar una imagen en escala de grises de 28x28:

def plot_image(image):

    plt.imshow(image, cmap="binary")

    plt.axis("off")

 Creamos un dataset de tres dimensiones

np.random.seed(4)

def generate_3d_data(m, w1=0.1, w2=0.3, noise=0.1):

    angles = np.random.rand(m) * 3 * np.pi / 2 - 0.5

    data = np.empty((m, 3))

    data[:, 0] = np.cos(angles) + np.sin(angles)/2 + noise * np.random.randn(m) / 2

    data[:, 1] = np.sin(angles) * 0.7 + noise * np.random.randn(m) / 2

    data[:, 2] = data[:, 0] * w1 + data[:, 1] * w2 + noise * np.random.randn(m)

    return data

X_train = generate_3d_data(60)

X_train = X_train - X_train.mean(axis=0, keepdims=0)

Y creamos el autoencoder

np.random.seed(42)

tf.random.set_seed(42)

encoder = keras.models.Sequential([keras.layers.Dense(2, input_shape=[3])])

decoder = keras.models.Sequential([keras.layers.Dense(3, input_shape=[2])])

autoencoder = keras.models.Sequential([encoder, decoder])

autoencoder.compile(loss="mse", optimizer=keras.optimizers.SGD(lr=1.5))

Este código en realidad no es muy diferente de cualquier MLP (Perceptrón multicapa) pero tiene algunas diferencias:

Hemos organizado el autoencoder en dos subcomponentes: el codificador y el decodificador. Ambos son modelos de secuencia regular cada uno con una capa densa simple y el autoencoder es un modelo secuencial que contiene el codificador seguido por el decodificador (cada modelo puede ser utilizado como una capa en otro modelo).

El número de salidas del autoencoder es igual al número de entradas, en este caso tres.

Al ejecutar un PCA simple no podemos usar ninguna función de activación, es decir, todas las neuronas tienen activación lineal, y la función de coste es el error cuadrático medio.

Vamos a entrenar el modelo con un dataset 3D simple y lo vamos a utilizar para codificar el mismo dataset y proyectarlo sobre dos dimensiones 2D. 

history = autoencoder.fit(X_train, X_train, epochs=20)

codings = encoder.predict(X_train)

fig = plt.figure(figsize=(4,3))

plt.plot(codings[:,0], codings[:, 1], "b.")

plt.xlabel("$z_1$", fontsize=18)

plt.ylabel("$z_2$", fontsize=18, rotation=0)

plt.grid(True)

save_fig("autoencoder lineal_pca")

plt.show()

El mismo dataset X_train se utiliza en las entradas y en los objetivos (la proyección de dicho dataset en un plano de 2D) que es la salida de la capa oculta del autoencoder. El autoencoder encuentra el mejor plano para proyectrar el dataset en 2D preservando la máxima varianza de los datos sobre dicho plano, justo como haría un PCA.

Podemos pensar que los autoencoders son una forma de aprendizaje autosupervisado, utilizando una técnica de aprendizaje con etiquetas generadas automáticamente.

Si vamos a la carpeta imágenes de nuestro entorno virtual aislado podemos ver que nos ha guardado la imagen del dataset de 3D proyectado sobre un plano 2D.

 

Traducido del capítulo 17 de “Hands-On Machine Learning with Scikit-Learn, Keras and Tensorflow, 2nd Edition by Aurelien Géron (O’Reilly). Copyright 2019 Kiwisoft S.A.S., 978-1-492-03264-9”