Ejecute varios modelos de aprendizaje profundo en GPU con puntos de enlace de varios modelos de Amazon SageMaker

A medida que la adopción de IA se acelera en toda la industria, los clientes están creando modelos sofisticados que aprovechan los nuevos avances científicos en el aprendizaje profundo. Estos modelos de próxima generación le permiten lograr un rendimiento similar al humano de última generación en los campos del procesamiento del lenguaje natural (NLP), visión por computadora, reconocimiento de voz, investigación médica, ciberseguridad, predicción de la estructura de proteínas y muchos otros. . Por ejemplo, los modelos de lenguaje grandes como GPT-3, OPT y BLOOM pueden traducir, resumir y escribir texto con matices similares a los humanos. En el espacio de la visión por computadora, los modelos de difusión de texto a imagen como DALL-E e Imagen pueden crear imágenes fotorrealistas a partir del lenguaje natural con un mayor nivel de comprensión visual y del lenguaje del mundo que nos rodea. Estos modelos multimodales brindan características más ricas para varias tareas posteriores y la capacidad de ajustarlas para dominios específicos, y brindan poderosas oportunidades comerciales a nuestros clientes.

Estos modelos de aprendizaje profundo siguen creciendo en términos de tamaño y, por lo general, contienen miles de millones de parámetros de modelo para escalar el rendimiento del modelo para una amplia variedad de tareas, como la generación de imágenes, el resumen de texto, la traducción de idiomas y más. También existe la necesidad de personalizar estos modelos para brindar una experiencia hiperpersonalizada a las personas. Como resultado, se está desarrollando una mayor cantidad de modelos ajustando estos modelos para varias tareas posteriores. Para cumplir con los objetivos de latencia y rendimiento de las aplicaciones de IA, se prefieren las instancias de GPU a las instancias de CPU (dada la potencia de cómputo que ofrecen las GPU). Sin embargo, las instancias de GPU son costosas y los costos pueden sumarse si implementa más de 10 modelos. Si bien estos modelos pueden traer potencialmente aplicaciones de IA impactantes, puede ser un desafío escalar estos modelos de aprendizaje profundo de manera rentable debido a su tamaño y cantidad de modelos.

Amazon SageMaker Los terminales multimodelo (MME) proporcionan una forma escalable y rentable de implementar una gran cantidad de modelos de aprendizaje profundo. Los MME son una opción de alojamiento popular para alojar cientos de modelos basados ​​en CPU entre clientes como Zendesk, Veeva y AT&T. Anteriormente, tenía opciones limitadas para implementar cientos de modelos de aprendizaje profundo que necesitaban procesamiento acelerado con GPU. Hoy anunciamos la compatibilidad con MME para GPU. Ahora puede implementar miles de modelos de aprendizaje profundo detrás de un punto final de SageMaker. Los MME ahora pueden ejecutar múltiples modelos en un núcleo de GPU, compartir instancias de GPU detrás de un punto final en múltiples modelos y cargar y descargar dinámicamente modelos en función del tráfico entrante. Con esto, puede ahorrar costos significativamente y lograr la mejor relación precio-rendimiento.

En esta publicación, mostramos cómo ejecutar múltiples modelos de aprendizaje profundo en GPU con MME de SageMaker.

MME de SageMaker

Los MME de SageMaker le permiten implementar varios modelos detrás de un único punto final de inferencia que puede contener una o más instancias. Con MME, cada instancia se administra para cargar y servir múltiples modelos. Los MME le permiten romper el costo linealmente creciente de hospedar múltiples modelos y reutilizar la infraestructura en todos los modelos.

El siguiente diagrama ilustra la arquitectura de SageMaker MME.

SageMaker MME descarga dinámicamente modelos de Servicio de almacenamiento simple de Amazon (Amazon S3) cuando se invoca, en lugar de descargar todos los modelos cuando se crea el punto final por primera vez. Como resultado, una invocación inicial a un modelo podría tener una latencia de inferencia más alta que las inferencias posteriores, que se completan con una latencia baja. Si el modelo ya está cargado en el contenedor cuando se invoca, se omite el paso de descarga y carga y el modelo devuelve las inferencias con baja latencia. Por ejemplo, suponga que tiene un modelo que solo se usa unas pocas veces al día. Se carga automáticamente a pedido, mientras que los modelos a los que se accede con frecuencia se retienen en la memoria y se invocan con una latencia constantemente baja.

SageMaker MME con compatibilidad con GPU

Los MME de SageMaker con GPU funcionan con Servidor de inferencia NVIDIA Triton. NVIDIA Triton Inference Server es un software de servicio de inferencia de código abierto que simplifica el proceso de servicio de inferencia y proporciona un alto rendimiento de inferencia. Triton admite todos los principales marcos de capacitación e inferencia, como TensorFlow, NVIDIA® TensorRT™, PyTorch, MXNet, Python, ONNX, XGBoost, Scikit-learn, RandomForest, OpenVINO, C++ personalizado y más. Ofrece procesamiento por lotes dinámico, ejecuciones simultáneas, cuantificación posterior al entrenamiento y configuración óptima del modelo para lograr una inferencia de alto rendimiento. Además, NVIDIA Triton Inference Server se ha ampliado para implementar Contrato API MME, para integrarse con MME.

El siguiente diagrama ilustra un flujo de trabajo MME.

Los pasos del flujo de trabajo son los siguientes:

1. SageMaker MME recibe una solicitud de invocación HTTP para un modelo en particular usando TargetModel en la solicitud junto con la carga útil.
2. SageMaker enruta el tráfico a la instancia correcta detrás del punto final donde se carga el modelo de destino. SageMaker comprende el patrón de tráfico en todos los modelos detrás del MME y enruta las solicitudes de manera inteligente.
3. SageMaker se encarga de la administración de modelos detrás del punto final, carga dinámicamente el modelo en la memoria del contenedor y descarga el modelo basado en la flota compartida de instancias de GPU para brindar el mejor rendimiento de precio.
4. SageMaker descarga dinámicamente modelos de Amazon S3 al volumen de almacenamiento de la instancia. Si el modelo invocado no está disponible en el volumen de almacenamiento de la instancia, el modelo se descarga en el volumen de almacenamiento de la instancia. Si el volumen de almacenamiento de la instancia alcanza su capacidad, SageMaker elimina todos los modelos no utilizados del volumen de almacenamiento.
5. SageMaker carga el modelo en la memoria del contenedor NVIDIA Triton en una instancia acelerada por GPU y atiende la solicitud de inferencia. El núcleo de GPU es compartido por todos los modelos en una instancia. Si el modelo ya está cargado en la memoria del contenedor, las solicitudes posteriores se atienden más rápido porque SageMaker no necesita descargarlo y cargarlo nuevamente.
6. SageMaker se ocupa de dar forma al tráfico en el punto final de MME y mantiene copias de modelo óptimas en las instancias de GPU para obtener el mejor rendimiento de precio. Continúa enrutando el tráfico a la instancia donde se carga el modelo. Si los recursos de la instancia alcanzan su capacidad debido a una alta utilización, SageMaker descarga los modelos menos utilizados del contenedor para liberar recursos para cargar modelos de uso más frecuente.

Los MME de SageMaker pueden escalar horizontalmente mediante una política de escalado automático y aprovisionar instancias de cómputo de GPU adicionales en función de métricas como invocaciones por instancia y utilización de GPU para atender cualquier aumento de tráfico a los puntos finales de MME.

Resumen de la solución

En esta publicación, le mostramos cómo usar las nuevas funciones de SageMaker MME con GPU con un caso de uso de visión artificial. Para fines de demostración, utilizamos un modelo preentrenado de red neuronal convolucional ResNet-50 que puede clasificar imágenes en 1,000 categorías. Discutimos cómo hacer lo siguiente:

• Use un contenedor de inferencia NVIDIA Triton en MME de SageMaker, usando diferentes backends del marco del modelo Triton, como PyTorch y TensorRT.
• Convierta los modelos ResNet-50 al formato optimizado del motor TensorRT e impleméntelos con un SageMaker MME
• Configurar políticas de escalado automático para el MME
• Obtenga información sobre las métricas de instancia e invocación mediante Reloj en la nube de Amazon

Crear artefactos modelo

Esta sección recorre los pasos para preparar un modelo preentrenado ResNet-50 para implementarlo en un SageMaker MME usando las configuraciones del modelo Triton Inference Server. Puede reproducir todos los pasos utilizando el cuaderno paso a paso en GitHub.

Para esta publicación, demostramos la implementación con dos modelos. Sin embargo, puede preparar e implementar cientos de modelos. Los modelos pueden o no compartir el mismo marco.

Preparar un modelo PyTorch

Primero, cargamos un modelo ResNet50 previamente entrenado usando el paquete de modelos torchvision. Guardamos el modelo como un archivo model.pt en formato TorchScript optimizado y serializado. TorchScript compila un paso hacia adelante del modelo ResNet50 en modo ansioso con entradas de ejemplo, por lo que pasamos una instancia de una imagen RGB con tres canales de color de dimensión 224 x 224.

Luego, debemos preparar los modelos para Triton Inference Server. El siguiente código muestra el repositorio de modelos para el backend del marco PyTorch. Triton usa el archivo model.pt ubicado en el repositorio de modelos para brindar predicciones.

resnet
├── 1
│   └── model.pt
└── config.pbtxt

El archivo de configuración del modelo. config.pbtxt debe especificar el nombre del modelo (resnet), la plataforma y las propiedades de backend (pytorch_libtorch), max_batch_size (128), y los tensores de entrada y salida junto con el tipo de datos (TYPE_FP32) información. Además, puede especificar instance_group y dynamic_batching propiedades para lograr una inferencia de alto rendimiento. Ver el siguiente código:

name: "resnet"
platform: "pytorch_libtorch"
max_batch_size: 128
input {
  name: "INPUT__0"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "OUTPUT__0"
  data_type: TYPE_FP32
  dims: 1000
}

Preparar el modelo TensorRT

TensorRT de NVIDIA es un SDK para la inferencia de aprendizaje profundo de alto rendimiento e incluye un optimizador de inferencia de aprendizaje profundo y un tiempo de ejecución que ofrece baja latencia y alto rendimiento para aplicaciones de inferencia. Usamos la herramienta de línea de comando trtexec para generar un motor serializado TensorRT a partir de un ONNX formato modelo. Complete los siguientes pasos para convertir un modelo preentrenado ResNet-50 a NVIDIA TensorRT:

1. Exporte el modelo ResNet-50 previamente entrenado a un formato ONNX usando antorcha.onnx.Este paso ejecuta el modelo una vez para rastrear su ejecución con una entrada de muestra y luego exporta el modelo rastreado al archivo especificado model.onnx.
2. Use trtexec para crear un plan de motor TensorRT desde el model.onnx expediente. Opcionalmente, puede reducir la precisión de los cálculos de punto flotante, ya sea simplemente ejecutándolos en punto flotante de 16 bits o cuantificando los valores de punto flotante para que los cálculos se puedan realizar usando números enteros de 8 bits.

El siguiente código muestra la estructura del repositorio de modelos para el modelo TensorRT:

resnet
├── 1
│   └── model.plan
└── config.pbtxt

Para el modelo TensorRT, especificamos tensorrt_plan como plataforma e ingrese las especificaciones de Tensor de la imagen de dimensión 224 x 224, que tiene los canales de color. El tensor de salida con 1,000 dimensiones es de tipo TYPE_FP32, correspondientes a las diferentes categorías de objetos. Ver el siguiente código:

name: "resnet"
platform: "tensorrt_plan"
max_batch_size: 128
input {
  name: "input"
  data_type: TYPE_FP32
  dims: 3
  dims: 224
  dims: 224
}
output {
  name: "output"
  data_type: TYPE_FP32
  dims: 1000
}
model_warmup {
    name: "bs128 Warmup"
    batch_size: 128
    inputs: {
        key: "input"
        value: {
            data_type: TYPE_FP32
            dims: 3
            dims: 224
            dims: 224
            zero_data: false
        }
    }
}

Almacenar artefactos de modelos en Amazon S3

SageMaker espera que los artefactos del modelo en .tar.gz formato. También deben cumplir con los requisitos del contenedor Triton, como el nombre del modelo, la versión, config.pbtxt archivos y más. tar la carpeta que contiene el archivo del modelo como .tar.gz y subirlo a Amazon S3:

!mkdir -p triton-serve-pt/resnet/1/
!mv -f workspace/model.pt triton-serve-pt/resnet/1/
!tar -C triton-serve-pt/ -czf resnet_pt_v0.tar.gz resnet
model_uri_pt = sagemaker_session.upload_data(path="resnet_pt_v0.tar.gz", key_prefix="resnet-mme-gpu")
!mkdir -p triton-serve-trt/resnet/1/
!mv -f workspace/model.plan triton-serve-trt/resnet/1/
!tar -C triton-serve-trt/ -czf resnet_trt_v0.tar.gz resnet
model_uri_trt = sagemaker_session.upload_data(path="resnet_trt_v0.tar.gz", key_prefix="resnet-mme-gpu")

Ahora que hemos subido los artefactos del modelo a Amazon S3, podemos crear un SageMaker MME.

Implementar modelos con un MME

Ahora implementamos un modelo ResNet-50 con dos backends de marco diferentes (PyTorch y TensorRT) en un SageMaker MME.

Tenga en cuenta que puede implementar cientos de modelos y los modelos pueden usar el mismo marco. También pueden usar diferentes marcos, como se muestra en esta publicación.

Usamos la AWS SDK para Python (Boto3) API crear_modelo, crear_endpoint_configy crear_punto final para crear un MME.

Definir el recipiente de servicio

En la definición del contenedor, defina el model_data_url para especificar el directorio S3 que contiene todos los modelos que SageMaker MME usa para cargar y entregar predicciones. Establecer Mode a MultiModel para indicar que SageMaker crea el punto final con las especificaciones del contenedor MME. Configuramos el contenedor con una imagen que admita la implementación de MME con GPU. Ver el siguiente código:

container = {
"Image": ,
"ModelDataUrl": ,
"Mode": "MultiModel"
}

Crear un objeto multimodelo

Use el cliente SageMaker Boto3 para crear el modelo usando el create_model API. Pasamos la definición del contenedor a la API de modelo de creación junto con ModelName y ExecutionRoleArn:

create_model_response = sm_client.create_model(
    ModelName=, ExecutionRoleArn=role, PrimaryContainer=container
)

Definir configuraciones MME

Cree configuraciones MME usando el create_endpoint_config API de Boto3. Especifique una instancia informática de GPU acelerada en InstanceType (usamos el tipo de instancia g4dn.4xlarge). Recomendamos configurar sus terminales con al menos dos instancias. Esto permite que SageMaker proporcione un conjunto de predicciones de alta disponibilidad en múltiples zonas de disponibilidad para los modelos.

Según nuestros hallazgos, puede obtener una mejor relación precio-rendimiento en instancias optimizadas para ML con un solo núcleo de GPU. Por lo tanto, la compatibilidad con MME para la característica de GPU solo está habilitada para instancias de un solo núcleo de GPU. Para obtener una lista completa de las instancias admitidas, consulte Tipos de instancias de GPU compatibles.

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName=,
    ProductionVariants=[
        {
            "InstanceType": "ml.g4dn.4xlarge",
            "InitialVariantWeight": 1,
            "InitialInstanceCount": 2,
            "ModelName": ,
            "VariantName": "AllTraffic",
        }
    ],
)

Crear un MME

Con la configuración de punto final anterior, creamos un SageMaker MME usando el crear_punto final API. SageMaker crea el MME, lanza la instancia informática de ML g4dn.4xlarge e implementa los modelos PyTorch y TensorRT ResNet-50 en ellos. Ver el siguiente código:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=, EndpointConfigName=
)

Invocar el modelo de destino en el MME

Después de crear el punto final, podemos enviar una solicitud de inferencia al MME usando el invoke_enpoint API. Especificamos el TargetModel en la llamada de invocación y pase la carga útil para cada tipo de modelo. El siguiente código es una invocación de muestra para el modelo PyTorch y el modelo TensorRT:

runtime_sm_client.invoke_endpoint(
    EndpointName=,
    ContentType="application/octet-stream",
    Body=json.dumps(pt_payload),
    TargetModel='resnet_pt_v0.tar.gz', #PyTorch Model
)
runtime_sm_client.invoke_endpoint(
    EndpointName=, 
    ContentType="application/octet-stream", 
    Body=json.dumps(trt_payload),
    TargetModel='resnet_trt_v0.tar.gz' #TensorRT Model
)

Configurar políticas de escalado automático para GPU MME

Los MME de SageMaker admiten el escalado automático de sus modelos alojados. El escalado automático ajusta dinámicamente la cantidad de instancias aprovisionadas para un modelo en respuesta a los cambios en su carga de trabajo. Cuando aumenta la carga de trabajo, el escalado automático pone más instancias en línea. Cuando la carga de trabajo disminuye, el escalado automático elimina las instancias innecesarias para que no pague por las instancias aprovisionadas que no está utilizando.

En la siguiente política de escala, usamos la métrica personalizada GPUUtilization existentes TargetTrackingScalingPolicyConfiguration configuración y establecer un TargetValue of 60.0 para el valor objetivo de esa métrica. Esta política de escalado automático aprovisiona instancias adicionales hasta MaxCapacity cuando la utilización de la GPU es superior al 60 %.

auto_scaling_client = boto3.client('application-autoscaling')

resource_id='endpoint/' +  + '/variant/' + 'AllTraffic' 
response = auto_scaling_client.register_scalable_target(
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount',
    MinCapacity=1,
    MaxCapacity=5
)

response = auto_scaling_client.put_scaling_policy(
    PolicyName='GPUUtil-ScalingPolicy',
    ServiceNamespace='sagemaker',
    ResourceId=resource_id,
    ScalableDimension='sagemaker:variant:DesiredInstanceCount', 
    PolicyType='TargetTrackingScaling',
    TargetTrackingScalingPolicyConfiguration={
        'TargetValue': 60.0, 
        'CustomizedMetricSpecification':
        {
            'MetricName': 'GPUUtilization',
            'Namespace': '/aws/sagemaker/Endpoints',
            'Dimensions': [
                {'Name': 'EndpointName', 'Value':  },
                {'Name': 'VariantName','Value': 'AllTraffic'}
            ],
            'Statistic': 'Average',
            'Unit': 'Percent'
        },
        'ScaleInCooldown': 600,
        'ScaleOutCooldown': 200 
    }
)

Recomendamos usar GPUUtilization or InvocationsPerInstance para configurar políticas de escalado automático para su MME. Para más detalles, consulte Establecer políticas de ajuste de escala automático para implementaciones de puntos finales de varios modelos

Métricas de CloudWatch para GPU MME

Los MME de SageMaker proporcionan las siguientes métricas a nivel de instancia para monitorear:

• Número de modelos cargados – Número de modelos cargados en los contenedores
• Uso de GPU – Porcentaje de unidades de GPU que utilizan los contenedores
• Utilización de memoria GPU – Porcentaje de memoria GPU utilizada por los contenedores
• Utilización de disco – Porcentaje de espacio en disco utilizado por los contenedores

Estas métricas le permiten planificar la utilización eficaz de los recursos de la instancia de GPU. En el siguiente gráfico vemos GPUMemoryUtilization fue del 38.3% cuando se cargaron más de 16 modelos ResNet-50 en el contenedor. La suma de la utilización de cada núcleo de CPU individual (CPUUtilization) fue del 60.9%, y porcentaje de memoria utilizada por los contenedores (MemoryUtilization) fue del 9.36%.

Los MME de SageMaker también proporcionan métricas de carga de modelos para obtener información a nivel de invocación de modelos:

• ModeloCargandoEspereTiempo – Intervalo de tiempo para que el modelo sea descargado o cargado
• ModeloDescargaTiempo – Intervalo de tiempo para descargar el modelo del contenedor
• ModeloDownloadingTime – Hora de descargar el modelo de Amazon S3
• ModeloCacheHit – Número de invocaciones al modelo que ya están cargadas en el contenedor

En el siguiente gráfico, podemos observar que un modelo tardó 8.22 segundos en responder a una solicitud de inferencia (ModelLatency), y se agregaron 24.1 milisegundos a la latencia de un extremo a otro debido a los gastos generales de SageMaker (OverheadLatency). También podemos ver las métricas de errores de las llamadas para invocar una llamada API de punto final, como Invocation4XXErrors y Invocation5XXErrors.

Para obtener más información sobre las métricas de MME CloudWatch, consulte Métricas de CloudWatch para implementaciones de terminales de varios modelos.

Resumen

En esta publicación, aprendió sobre la nueva compatibilidad multimodelo de SageMaker para GPU, que le permite alojar de manera rentable cientos de modelos de aprendizaje profundo en hardware de cómputo acelerado. Aprendió a usar NVIDIA Triton Inference Server, que crea una configuración de repositorio de modelos para diferentes backends de framework, y cómo implementar un MME con escalado automático. Esta función le permitirá escalar cientos de modelos hiperpersonalizados que están ajustados para satisfacer las experiencias únicas del usuario final en aplicaciones de IA. También puede aprovechar esta función para lograr el rendimiento de precio necesario para su aplicación de inferencia utilizando GPU fraccionarias.

Para comenzar con la compatibilidad con MME para GPU, consulte Compatibilidad con puntos finales de varios modelos para GPU.

Sobre los autores

Patel Dhawal es Arquitecto Principal de Aprendizaje Automático en AWS. Ha trabajado con organizaciones que van desde grandes empresas hasta empresas emergentes medianas en problemas relacionados con la computación distribuida y la inteligencia artificial. Se enfoca en el aprendizaje profundo, incluidos los dominios de PNL y visión por computadora. Ayuda a los clientes a lograr una inferencia de modelos de alto rendimiento en Amazon SageMaker.

Vikram Elango es Arquitecto Senior de Soluciones Especializado en IA/ML en Amazon Web Services, con sede en Virginia, EE. UU. Vikram ayuda a los clientes globales de la industria financiera y de seguros con diseño, implementación y liderazgo de pensamiento para construir e implementar aplicaciones de aprendizaje automático a escala. Actualmente se centra en el procesamiento del lenguaje natural, la IA responsable, la optimización de inferencias y el escalado de ML en toda la empresa. En su tiempo libre, disfruta viajar, hacer caminatas, cocinar y acampar con su familia.

Saurabh Trikande es gerente sénior de productos para Amazon SageMaker Inference. Le apasiona trabajar con clientes y está motivado por el objetivo de democratizar el aprendizaje automático. Se enfoca en los desafíos principales relacionados con la implementación de aplicaciones de ML complejas, modelos de ML de múltiples inquilinos, optimizaciones de costos y hacer que la implementación de modelos de aprendizaje profundo sea más accesible. En su tiempo libre, a Saurabh le gusta caminar, aprender sobre tecnologías innovadoras, seguir TechCrunch y pasar tiempo con su familia.

Deepti Ragha es ingeniero de desarrollo de software en el equipo de Amazon SageMaker. Su trabajo actual se centra en la creación de funciones para alojar modelos de aprendizaje automático de manera eficiente. En su tiempo libre, le gusta viajar, hacer caminatas y cultivar plantas.

Nikhil Kulkarni es un desarrollador de software con AWS Machine Learning, que se enfoca en hacer que las cargas de trabajo de aprendizaje automático tengan más rendimiento en la nube y es cocreador de AWS Deep Learning Containers para capacitación e inferencia. Le apasionan los sistemas de aprendizaje profundo distribuidos. Fuera del trabajo, le gusta leer libros, tocar la guitarra y hacer pizza.

jiahong liu es arquitecto de soluciones en el equipo de proveedores de servicios en la nube de NVIDIA. Ayuda a los clientes a adoptar soluciones de inteligencia artificial y aprendizaje automático que aprovechan la computación acelerada de NVIDIA para abordar sus desafíos de capacitación e inferencia. En su tiempo libre, disfruta del origami, proyectos de bricolaje y jugar al baloncesto.

Eliuth Triana es Gerente de Relaciones con Desarrolladores en el equipo de NVIDIA-AWS. Conecta a los líderes de productos, desarrolladores y científicos de Amazon y AWS con tecnólogos y líderes de productos de NVIDIA para acelerar las cargas de trabajo de Amazon ML / DL, los productos EC2 y los servicios de IA de AWS. Además, Eliuth es un apasionado del ciclismo de montaña, esquiador y jugador de póquer.

Maximiliano Maccanti es ingeniero principal en AWS actualmente con DynamoDB, formé parte del equipo de lanzamiento de SageMaker en re:Invent 2017 y pasé los siguientes 5 años en la plataforma de alojamiento agregando todo tipo de características para los clientes. En mi tiempo libre colecciono, reparo y juego con consolas de videojuegos antiguas.