La generación de texto a imagen es una tarea en la que un modelo de aprendizaje automático (ML) genera una imagen a partir de una descripción textual. El objetivo es generar una imagen que coincida estrechamente con la descripción, capturando los detalles y matices del texto. Esta tarea es desafiante porque requiere que el modelo comprenda la semántica y la sintaxis del texto y genere imágenes fotorrealistas. Hay muchas aplicaciones prácticas de generación de texto a imagen en fotografía con IA, arte conceptual, arquitectura de edificios, moda, videojuegos, diseño gráfico y mucho más.

Difusión estable es un modelo de texto a imagen que le permite crear imágenes de alta calidad en segundos. Cuando el objetivo es la interacción en tiempo real con este tipo de modelo, garantizar una experiencia de usuario fluida depende del uso de hardware acelerado para la inferencia, como GPU o Inferencia de AWS2, el acelerador de inferencias de aprendizaje automático propio de Amazon. Los altos costos que implica el uso de GPU generalmente requieren optimizar la utilización de la computación subyacente, más aún cuando necesita implementar diferentes arquitecturas o modelos personalizados (afinados). Amazon SageMaker puntos finales de varios modelos (MMEs) lo ayudan a abordar este problema al ayudarlo a escalar miles de modelos en un punto final. Mediante el uso de un contenedor de servicio compartido, puede alojar varios modelos de manera rentable y escalable dentro del mismo punto final e incluso en la misma GPU.

En esta publicación, aprenderá sobre arquitecturas de modelos de difusión estable, diferentes tipos de modelos de difusión estable y técnicas para mejorar la calidad de la imagen. También le mostramos cómo implementar modelos Stable Diffusion de manera rentable utilizando SageMaker MME y NVIDIA Triton Inference Server.

Aviso: retrato de un lindo perro bernés, arte de elke Vogelsang, 8k ultrarrealista, tendencia en artstation, 4 k	Aviso: diseño de arquitectura de sala de estar, 8 k ultrarrealista, 4 k, hiperrealista, enfocado, detalles extremos	Aviso: Horizonte de Nueva York de noche, 8k, fotografía de plano general, motor irreal 5, cinemática, obra maestra

Arquitectura de difusión estable

Stable Diffusion es un modelo de código abierto de texto a imagen que puede usar para crear imágenes de diferentes estilos y contenido simplemente proporcionando un mensaje de texto. En el contexto de la generación de texto a imagen, un modelo de difusión es un modelo generativo que puede utilizar para generar imágenes de alta calidad a partir de descripciones textuales. Los modelos de difusión son un tipo de modelo generativo que puede capturar las dependencias complejas entre las modalidades de entrada y salida de texto e imágenes.

El siguiente diagrama muestra una arquitectura de alto nivel de un modelo de difusión estable.

Consta de los siguientes elementos clave:

• codificador de texto – CLIP es un modelo de codificador de texto basado en transformadores que toma el texto de solicitud de entrada y lo convierte en incrustaciones de tokens que representan cada palabra en el texto. CLIP está entrenado en un conjunto de datos de imágenes y sus leyendas, una combinación de codificador de imagen y codificador de texto.
• U-Net – Un modelo U-Net toma incrustaciones de tokens de CLIP junto con una matriz de entradas ruidosas y produce una salida sin ruido. Esto sucede a través de una serie de pasos iterativos, donde cada paso procesa un tensor latente de entrada y produce un nuevo tensor de espacio latente que representa mejor el texto de entrada.
• Codificador-decodificador automático – Este modelo crea las imágenes finales. Toma la salida latente final sin ruido del modelo U-Net y la convierte en imágenes que representan la entrada de texto.

Tipos de modelos de difusión estable

En esta publicación, exploramos los siguientes modelos de difusión estable preentrenados por Stability AI del centro de modelos Hugging Face.

estable-difusión-2-1-base

Utilice este modelo para generar imágenes basadas en un mensaje de texto. Esta es una versión base del modelo en el que se entrenó LAION-5B. El modelo fue entrenado en un subconjunto del conjunto de datos a gran escala. LAION-5B, y principalmente con subtítulos en inglés. Usamos StableDiffusionPipeline del desplegable diffusers biblioteca para generar imágenes a partir de indicaciones de texto. Este modelo puede crear imágenes de dimensión 512 x 512. Utiliza los siguientes parámetros:

• puntual – Un indicador puede ser una palabra de texto, una frase, una oración o un párrafo.
• aviso_negativo – También puede pasar un aviso negativo para excluir elementos específicos del proceso de generación de imágenes y mejorar la calidad de las imágenes generadas.
• guía_escala – Una escala de guía más alta da como resultado una imagen más estrechamente relacionada con el aviso, a expensas de la calidad de la imagen. Si se especifica, debe ser un flotante.

estable-difusión-2-profundidad

Este modelo se utiliza para generar nuevas imágenes a partir de las existentes conservando la forma y la profundidad de los objetos en la imagen original. Este stable-diffusion-2-depth model está afinado desde estable-difusión-2-base, un canal de entrada adicional para procesar la predicción de profundidad (relativa). Usamos StableDiffusionDepth2ImgPipeline del desplegable diffusers biblioteca para cargar la canalización y generar imágenes de profundidad. Los siguientes son los parámetros adicionales específicos del modelo de profundidad:

• imagen – La imagen inicial para condicionar la generación de nuevas imágenes.
• num_inferencia_pasos (opcional) – El número de pasos de eliminación de ruido. Más pasos de eliminación de ruido generalmente conducen a una imagen de mayor calidad a expensas de una inferencia más lenta. Este parámetro es modulado por strength.
• fuerza (opcional) – Conceptualmente, esto indica cuánto transformar la imagen de referencia. El valor debe estar entre 0 y 1. image se utiliza como punto de partida, añadiéndole más ruido cuanto mayor sea la fuerza. El número de pasos de eliminación de ruido depende de la cantidad de ruido inicialmente añadida. Cuando strength es 1, el ruido añadido será máximo y el proceso de eliminación de ruido se ejecutará durante el número total de iteraciones especificadas en num_inference_steps. Un valor de 1, por lo tanto, esencialmente ignora image. Para obtener más detalles, consulte el siguiente código.

estable-difusión-2-enpintura

Puede usar este modelo para casos de uso de restauración de imágenes de IA. También puede usarlo para crear diseños e imágenes novedosos a partir de las indicaciones y argumentos adicionales. Este modelo también se deriva del modelo base y tiene una estrategia de generación de máscaras. Especifica la máscara de la imagen original para representar los segmentos que se cambiarán y los segmentos que se dejarán sin cambios. Usamos StableDiffusionUpscalePipeline del desplegable diffusers Biblioteca para aplicar cambios de pintura en la imagen original. El siguiente parámetro adicional es específico del modelo de profundidad:

• máscara_entrada – Una imagen en la que la parte oscurecida permanece sin cambios durante la generación de la imagen y se reemplaza la parte blanca

estable-difusión-x4-upscaler

Este modelo también se deriva del modelo base, entrenado adicionalmente en el subconjunto 10M de LAION que contiene imágenes de 2048 x 2048. Como su nombre lo indica, se puede usar para mejorar las imágenes de menor resolución a resoluciones más altas.

Resumen del caso de uso

Para esta publicación, implementamos un servicio de imágenes de IA con múltiples capacidades, incluida la generación de imágenes novedosas a partir de texto, el cambio de estilos de las imágenes existentes, la eliminación de objetos no deseados de las imágenes y la ampliación de imágenes de baja resolución a resoluciones más altas. Con varias variaciones de los modelos Stable Diffusion, puede abordar todos estos casos de uso dentro de un único punto final de SageMaker. Esto significa que deberá alojar una gran cantidad de modelos de una manera eficiente, escalable y rentable. En esta publicación, mostramos cómo implementar múltiples modelos Stable Diffusion de manera rentable utilizando SageMaker MME y NVIDIA Triton Inference Server. Aprenderá sobre los detalles de implementación, las técnicas de optimización y las mejores prácticas para trabajar con modelos de texto a imagen.

La siguiente tabla resume los modelos de difusión estable que implementamos en un SageMaker MME.

Resumen de la solución

Los siguientes pasos están involucrados en la implementación de modelos de difusión estable en MME de SageMaker:

1. Use el hub Hugging Face para descargar los modelos de difusión estable a un directorio local. Esto se descargará scheduler, text_encoder, tokenizer, unet, and vae para cada modelo de Difusión Estable en su directorio local correspondiente. usamos el revision="fp16" versión del modelo.
2. Configure el repositorio de modelos de NVIDIA Triton, las configuraciones de modelos y la lógica de servicio de modelos model.py. Triton usa estos artefactos para servir predicciones.
3. Empaquete el entorno conda con dependencias adicionales y el repositorio de modelos de paquetes que se implementará en SageMaker MME.
4. Empaquete los artefactos del modelo en un formato específico de NVIDIA Triton y cárguelos model.tar.gz a Servicio de almacenamiento simple de Amazon (Amazon S3). El modelo se utilizará para generar imágenes.
5. Configure un modelo de SageMaker, una configuración de punto final e implemente SageMaker MME.
6. Ejecute la inferencia y envíe indicaciones al extremo de SageMaker para generar imágenes mediante el modelo de difusión estable. Especificamos el TargetModel variable e invoque diferentes modelos de difusión estable para comparar los resultados visualmente.

Hemos publicado el código para implementar esta arquitectura de solución en el Repositorio GitHub. Siga las instrucciones LÉAME para comenzar.

Servir modelos con un backend de Python del servidor de inferencia NVIDIA Triton

Usamos un backend de Triton Python para implementar el modelo de canalización Stable Diffusion en un SageMaker MME. El backend de Python le permite servir modelos escritos en Python por Triton Inference Server. Para usar el backend de Python, debe crear un archivo de Python model.py que tiene la siguiente estructura: Cada backend de Python puede implementar cuatro funciones principales en el TritonPythonModel clase:

import triton_python_backend_utils as pb_utils
class TritonPythonModel: """Your Python model must use the same class name. Every Python model
that is created must have "TritonPythonModel" as the class name. """
def auto_complete_config(auto_complete_model_config):
def initialize(self, args):
def execute(self, requests):
def finalize(self):

Cada backend de Python puede implementar cuatro funciones principales en el TritonPythonModel clase: auto_complete_config, initialize, executey finalize.

initialize se llama cuando se carga el modelo. Implementar initialize es opcional. initialize le permite realizar las inicializaciones necesarias antes de ejecutar la inferencia. En el initialize función, creamos una tubería y cargamos las tuberías usando from_pretrained puntos de control Configuramos programadores desde la configuración del programador de canalización pipe.scheduler.config. Finalmente, especificamos xformers optimizaciones para habilitar la xformer parámetro de memoria eficiente enable_xformers_memory_efficient_attention. Brindamos más detalles sobre xformers más adelante en esta publicación. Puede consultar model.py de cada modelo para comprender los diferentes detalles de la canalización. Este archivo se puede encontrar en el repositorio de modelos.

La execute La función se llama cada vez que se realiza una solicitud de inferencia. Cada modelo de Python debe implementar el execute función. En el execute función, se le da una lista de InferenceRequest objetos. Pasamos el indicador de texto de entrada a la canalización para obtener una imagen del modelo. Las imágenes se decodifican y la imagen generada se devuelve desde esta llamada de función.

Obtenemos el tensor de entrada del nombre definido en la configuración del modelo. config.pbtxt archivo. De la solicitud de inferencia, obtenemos prompt, negative_prompty gen_argsy decodificarlos. Pasamos todos los argumentos al objeto de canalización modelo. Codifique la imagen para devolver las predicciones de imagen generadas. Puedes referirte a la config.pbtxt archivo de cada modelo para comprender los diferentes detalles de la tubería. Este archivo se puede encontrar en el repositorio de modelos. Finalmente, envolvemos la imagen generada en InferenceResponse y devolver la respuesta.

Poner en marcha finalize es opcional. Esta función le permite realizar las limpiezas necesarias antes de que el modelo se descargue de Triton Inference Server.

Cuando se trabaja con el backend de Python, es responsabilidad del usuario asegurarse de que las entradas se procesen por lotes y que las respuestas se devuelvan en consecuencia. Para conseguirlo, te recomendamos seguir estos pasos:

1. Recorra todas las solicitudes en el requests objeto de formar un batched_input.
2. Ejecutar inferencia en el batched_input.
3. Dividir los resultados en múltiples InferenceResponse objetos y concatenarlos como las respuestas.

Para obtener más detalles sobre cómo diseñar y realizar los esfuerzos de seguimiento y evaluación, refierase a Documentación de back-end de Triton Python or Aloja modelos de aprendizaje automático en Amazon SageMaker con Triton: backend de Python para más información.

Configuración y repositorio de modelos de NVIDIA Triton

El repositorio de modelos contiene el script de servicio del modelo, los artefactos del modelo y los artefactos del tokenizador, un entorno de conda empaquetado (con las dependencias necesarias para la inferencia), el archivo de configuración de Triton y el script de Python utilizado para la inferencia. Este último es obligatorio cuando usa el backend de Python, y debe usar el archivo de Python model.py. Exploremos el archivo de configuración del modelo inpaint Stable Diffusion y comprendamos las diferentes opciones especificadas:

name: "sd_inpaint"
backend: "python"
max_batch_size: 8
input [ { name: "prompt" data_type: TYPE_STRING dims: [ -1 ] }, { name: "negative_prompt" data_type: TYPE_STRING dims: [ -1 ] optional: true }, { name: "image" data_type: TYPE_STRING dims: [ -1 ] }, { name: "mask_image" data_type: TYPE_STRING dims: [ -1 ] }, { name: "gen_args" data_type: TYPE_STRING dims: [ -1 ] optional: true }
]
output [ { name: "generated_image" data_type: TYPE_STRING dims: [ -1 ] }
]
instance_group [ { kind: KIND_GPU }
]
parameters: { key: "EXECUTION_ENV_PATH", value: {string_value: "/tmp/conda/sd_env.tar.gz" }
}

La siguiente tabla explica los distintos parámetros y valores:

Para obtener detalles sobre el repositorio de modelos y las configuraciones de otros modelos de difusión estable, consulte el código en el Repositorio GitHub. Cada directorio contiene artefactos para los modelos de difusión estable específicos.

Empaquete un entorno conda y amplíe el contenedor SageMaker Triton

Las imágenes de contenedor SageMaker NVIDIA Triton no contienen bibliotecas como transformer, accelerate, and diffusers para implementar y servir modelos de difusión estable. Sin embargo, Triton le permite traer dependencias adicionales usando paquete conda. Comencemos por crear el entorno conda con las dependencias necesarias descritas en el environment.yml archivar y crear un artefacto de modelo tar sd_env.tar.gz archivo que contiene el entorno conda con dependencias instaladas en él. Ejecute el siguiente archivo YML para crear un conda-pack artefacto y copie el artefacto en el directorio local desde donde se cargará en Amazon S3. Tenga en cuenta que cargaremos los artefactos de conda como uno de los modelos en el MME e invocaremos este modelo para configurar el entorno de conda en la instancia de aprendizaje automático de alojamiento de SageMaker.

%%writefile environment.yml
name: mme_env
dependencies: - python=3.8 - pip - pip: - numpy - torch --extra-index-url https://download.pytorch.org/whl/cu118 - accelerate - transformers - diffusers - xformers - conda-pack !conda env create -f environment.yml –force

Cargue artefactos de modelos en Amazon S3

SageMaker espera que el archivo .tar.gz que contiene cada repositorio de modelos de Triton se aloje en el extremo de varios modelos. Por lo tanto, creamos un artefacto tar con contenido del repositorio de modelos de Triton. Podemos usar este depósito de S3 para alojar miles de artefactos de modelos, y SageMaker MME usará modelos de esta ubicación para cargar y servir dinámicamente una gran cantidad de modelos. Almacenamos todos los modelos de difusión estable en esta ubicación de Amazon S3.

Implementar SageMaker MME

En esta sección, repasamos los pasos para implementar SageMaker MME definiendo la especificación del contenedor, el modelo de SageMaker y las configuraciones de puntos finales.

Definir el recipiente de servicio

En la definición del contenedor, defina el ModelDataUrl para especificar el directorio S3 que contiene todos los modelos que SageMaker MME usará para cargar y entregar predicciones. Colocar Mode a MultiModel para indicar que SageMaker creará 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 Algoritmos, marcos e instancias compatibles para más información.

Vemos los tres artefactos modelo en el siguiente Amazon S3 ModelDataUrl ubicación:

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

Crear un objeto MME

Usamos el cliente SageMaker Boto3 para crear el modelo usando el crear_modelo 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=sm_model_name, ExecutionRoleArn=role, PrimaryContainer=container
)

Definir configuraciones para el MME

Cree una configuración MME usando el crear_endpoint_config API de Boto3. Especifique una instancia informática de GPU acelerada en InstanceType (usamos el mismo tipo de instancia que estamos usando para alojar nuestro cuaderno SageMaker). Recomendamos configurar sus terminales con al menos dos instancias con casos de uso de la vida real. Esto permite que SageMaker proporcione un conjunto de predicciones de alta disponibilidad en múltiples zonas de disponibilidad para los modelos.

create_endpoint_config_response = sm_client.create_endpoint_config( EndpointConfigName=endpoint_config_name, ProductionVariants=[ { "InstanceType": instance_type, "InitialVariantWeight": 1, "InitialInstanceCount": 1, "ModelName": sm_model_name, "VariantName": "AllTraffic", } ],
)

Crear un MME

Utilice la configuración de punto final anterior para crear un nuevo punto final de SageMaker y espere a que finalice la implementación:

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

El estado cambiará a InService cuando la implementación es exitosa.

Genere imágenes usando diferentes versiones de modelos Stable Diffusion

Comencemos invocando el modelo base con un aviso y obteniendo la imagen generada. Pasamos las entradas al modelo base con prompt, negative_prompt, and gen_args como diccionario. Establecemos el tipo de datos y la forma de cada elemento de entrada en el diccionario y lo pasamos como entrada al modelo.

inputs = dict(prompt = "Infinity pool on top of a high rise overlooking Central Park", negative_prompt = "blur,low detail, low quality", gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=8))
)
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_base.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
decode_image(output[0]["data"][0])

Aviso: piscina infinita en la parte superior de un rascacielos con vistas al parque central

Trabajando con esta imagen, podemos modificarla con el versátil modelo de profundidad Stable Diffusion. Por ejemplo, podemos cambiar el estilo de la imagen a una pintura al óleo, o cambiar la configuración de Central Park a Parque Nacional de Yellowstone simplemente pasando la imagen original junto con un mensaje que describe los cambios que nos gustaría ver.

Invocamos el modelo de profundidad especificando sd_depth.tar.gz existentes TargetModel de las invoke_endpoint Llamada de función. En los resultados, observe cómo se conserva la orientación de la imagen original, pero, por ejemplo, los edificios de la ciudad de Nueva York se han transformado en formaciones rocosas de la misma forma.

inputs = dict(prompt = "highly detailed oil painting of an inifinity pool overlooking central park", image=image, gen_args = json.dumps(dict(num_inference_steps=50, strength=0.9)) )
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_depth.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
print("original image")
display(original_image)
print("generated image")
display(decode_image(output[0]["data"][0]))

Imagen original	Pintura al óleo	Parque de Yellowstone

Otro modelo útil es Stable Diffusion inpainting, que podemos usar para eliminar ciertas partes de la imagen. Digamos que desea eliminar el árbol en la siguiente imagen de ejemplo. Podemos hacerlo invocando el modelo inpaint sd_inpaint.tar.gz. Para quitar el árbol, necesitamos pasar un mask_image, que indica qué regiones de la imagen deben conservarse y cuáles deben rellenarse. La porción de píxeles negros de la imagen de máscara indica las regiones que deben permanecer sin cambios y los píxeles blancos indican qué debe reemplazarse.

image = encode_image(original_image).decode("utf8")
mask_image = encode_image(Image.open("sample_images/bertrand-gabioud-mask.png")).decode("utf8")
inputs = dict(prompt = "building, facade, paint, windows", image=image, mask_image=mask_image, negative_prompt = "tree, obstruction, sky, clouds", gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=10)) )
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_inpaint.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
decode_image(output[0]["data"][0])

Imagen original	Imagen de máscara	imagen pintada

En nuestro ejemplo final, reducimos el tamaño de la imagen original que se generó anteriormente de su resolución de 512 x 512 a 128 x 128. Luego invocamos el modelo de escalador Stable Diffusion para escalar la imagen de nuevo a 512 x 512. Usamos el mismo indicador para escalar la imagen como lo que usamos para generar la imagen inicial. Si bien no es necesario, proporcionar un aviso que describa la imagen ayuda a guiar el proceso de mejora y debería conducir a mejores resultados.

low_res_image = output_image.resize((128, 128))
inputs = dict(prompt = "Infinity pool on top of a high rise overlooking Central Park", image=encode_image(low_res_image).decode("utf8")
) payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
} response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_upscale.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
upscaled_image = decode_image(output[0]["data"][0])

Imagen de baja resolución	Imagen mejorada

Aunque la imagen mejorada no es tan detallada como la original, es una mejora notable con respecto a la de baja resolución.

Optimizar para memoria y velocidad

La xformers biblioteca es una forma de acelerar la generación de imágenes. Esta optimización solo está disponible para GPU NVIDIA. Acelera la generación de imágenes y reduce el uso de VRAM. hemos usado el xformers Biblioteca para una atención y velocidad eficientes en la memoria. Cuando el enable_xformers_memory_efficient_attention está habilitada, debería observar un menor uso de la memoria de la GPU y una posible aceleración en el momento de la inferencia.

Limpiar

Siga las instrucciones en la sección de limpieza del cuaderno para eliminar la parte aprovisionada de recursos de este blog para evitar cargos innecesarios. Referirse Precios de Amazon SageMaker para obtener más detalles, el costo de las instancias de inferencia.

Conclusión

En esta publicación, discutimos los modelos Stable Diffusion y cómo puede implementar diferentes versiones de los modelos Stable Diffusion de manera rentable utilizando puntos finales de varios modelos de SageMaker. Puede utilizar este enfoque para crear una herramienta de edición y generación de imágenes de creador. Consulte los ejemplos de código en el Repositorio GitHub para comenzar y háganos saber acerca de la genial herramienta de IA generativa que usted crea.

Acerca de los autores

Simón Zamarin es un arquitecto de soluciones de IA / ML cuyo objetivo principal es ayudar a los clientes a extraer valor de sus activos de datos. En su tiempo libre, a Simon le gusta pasar tiempo con la familia, leer ciencia ficción y trabajar en varios proyectos de bricolaje.

Vikram Elango es Arquitecto de soluciones especialista en inteligencia artificial/aprendizaje automático sénior en AWS, con sede en Virginia, EE. UU. Actualmente se enfoca en IA generativa, LLM, ingeniería rápida, optimización de inferencia de modelos grandes y escalamiento de ML en todas las empresas. Vikram ayuda a los clientes de la industria financiera y de seguros con el diseño y la arquitectura para construir e implementar aplicaciones ML a escala. En su tiempo libre, disfruta viajar, hacer caminatas, cocinar y acampar con su familia.

joão moura es Arquitecto de Soluciones Especialista en AI/ML en AWS, con sede en España. Ayuda a los clientes con la capacitación de modelos de aprendizaje profundo y la optimización de inferencias y, en términos más generales, con la creación de plataformas de aprendizaje automático a gran escala en AWS. También es un defensor activo de hardware especializado en aprendizaje automático y soluciones de aprendizaje automático de bajo código.

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.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoAiStream. Inteligencia de datos Web3. Conocimiento amplificado. Accede Aquí.
• Acuñando el futuro con Adryenn Ashley. Accede Aquí.
• Compra y Vende Acciones en Empresas PRE-IPO con PREIPO®. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/create-high-quality-images-with-stable-diffusion-models-and-deploy-them-cost-efficiently-with-amazon-sagemaker/