A Fascinante Hugging Face

A primeira vez que assisti um vídeo no YouTube sobre a Hugging Face achei que era algo muito interessante.

Sabe aquelas coisas muito interessantes que existem mais você não conhece! Pois é, isso descreve um pouco de como eu me sentir quando conheci a Hugging Face. Algo muito interessante mas eu não conhecia.

Mas agora, que já tive o primeiro contato com essa plataforma, gostaria de passar esse conhecimento inicial a outras pessoas, através da transcrição e tradução de um vídeo do YouTube bem interessante que me fez conhecer essa plataforma muito interessante.

Eis aqui a transcrição e tradução do vídeo do YouTube:

Introdução

Se você está construindo aplicativos de IA, você precisa aprender a usar o Hugging Face. É uma das principais empresas de IA, avaliada em mais de 2 bilhões de dólares, com mais de 16.000 seguidores no GitHub. Seus produtos são usados por Google, Amazon, Microsoft e Meta.

Com mais de 200.000 tipos diferentes de modelos de IA, incluindo imagem para texto, texto para fala, texto para imagem e muitos outros.

É por isso que, se você está construindo aplicativos de IA, você precisa aprender a usá-lo.

E eu vou te mostrar como você pode usar a plataforma Hugging Face e construí-la com outras bibliotecas públicas como o LangChain. Vamos começar!

Visão Geral do Hugging Face

O Hugging Face é um lugar para você descobrir e compartilhar modelos de IA. A plataforma Hugging Face é composta por três partes: Modelos, Datasets e Spaces.

MODELOS

Primeiro, Modelos. Este é o lugar onde você pode encontrar todos os diferentes tipos de modelos para usar.

Por exemplo, se você estiver interessado em usar imagem para texto, você pode selecionar a categoria à esquerda e então no lado direito escolher qualquer um dos modelos populares de imagem para texto.

E uma vez que você entra na página do modelo selecionado, no lado esquerdo terá uma descrição sobre o modelo e no lado direito ele permite que você visualize e teste o modelo de IA diretamente na versão hospedada por eles.

E é por isso que o Hugging Face é tão útil, sem ele, você precisaria encontrar os modelos, baixá-los para sua máquina local ou hospedá-los em algum lugar e então tentar executá-los para saber se é o modelo certo para você.

Mas com o Hugging Face, eles estão hospedados nos servidores do Hugging Face e você pode testá-lo imediatamente.

Mas para este modelo de imagem para texto, você pode arrastar e soltar a imagem diretamente e ver que tipo de resultados ele vai obter.

E se você quiser usá-lo, ele permite que você implemente facilmente este modelo em diferentes servidores.

Você também pode usar a API de host no Hugging Face Hub gratuitamente. É um pouco lento e eles têm limites de taxa, mas é definitivamente suficiente para você executar alguns testes.

Mas por outro lado, se você prefere executar os modelos localmente em sua própria máquina, você também pode usar a biblioteca Transformers deles e eu vou falar sobre como fazer isso muito em breve.

Explorando os Recursos do Hugging Face

BIBLIOTECA TRANSFORMERS

A biblioteca Transformers da Hugging Face permite que você execute modelos de IA em sua própria máquina.

Você pode baixar a biblioteca do site deles e instalá-la em seu ambiente Python. Uma vez que você tenha instalado a biblioteca, você pode começar a carregar e executar modelos.

OBJETO PIPELINE

Para carregar um modelo, você pode usar a função `pipeline`. Esta função leva o nome do modelo como entrada e retorna um objeto pipeline. O objeto pipeline pode ser usado para executar o modelo em uma entrada de texto ou imagem.

Para executar um modelo, você pode usar o método `predict`. Este método leva a entrada de texto ou imagem como entrada e retorna a saída do modelo.

Aqui está um exemplo de como usar a biblioteca Transformers para executar um modelo de imagem para texto:

# python
from transformers import pipeline

# Carregar o modelo
model = pipeline("image-to-text")

# Executar o modelo
outputs = model("image.jpg")

# Imprimir a saída
print(outputs)

Este código irá carregar o modelo de imagem para texto, executar o modelo na imagem `image.jpg` e imprimir a saída do modelo.

DATASETS

A seção Datasets fornece acesso a vários conjuntos de dados para treinamento e avaliação de modelos de IA. Você pode encontrar conjuntos de dados para uma variedade de tarefas, incluindo classificação de imagem, tradução de idiomas e resposta a perguntas.

Esses dados são primariamente usados para os usuários treinarem os seus próprios modelos.

SPACES

A seção Spaces foi projetada inicialmente para que as pessoas mostrassem e compartilhassem os aplicativos de IA que construíram.

Eles permitem que você instale, muito facilmente, nas máquinas da Hugging face os aplicativos que você criar e eles fornecem uma versão gratuita também.

E você ainda pode explorar outros aplicativos de IA que as pessoas estão construindo e há muitas coisas muito legais que você pode simplesmente clicar neles e começar a brincar com esses aplicativos e você também pode aprender como eles constroem essas coisas, basta clicar no ícone com três pontinhos, no canto superior direito da tela, que vai mostrar todos os modelos que foram usados para construir o APP.

E clicando em Files, mostrará todos os modelos que são usados para construir esse aplicativo.

Como vamos utilizar esses modelos do Hugging Face? Nós vamos implementar em LangChain.

Construindo um App de IA com Hugging Face

Vamos demonstrar a construção de um app de IA que converte uma imagem em uma história em áudio, mostrando a implementação passo a passo usando modelos do Hugging Face. O app usará três modelos do Hugging Face:

Modelo de imagem para texto (Blip) para entender o conteúdo da imagem.

Modelo de linguagem grande(LLM) para gerar uma história curta baseada na imagem.

Modelo de texto para fala para converter a história em áudio.

Iniciamente, criaremos um token de API e faremos o download dos modelos usando a biblioteca Transformers.

Implementando o Modelo de Imagem para Texto

Para iniciar você vai precisar criar uma conta no Hugging Face.

Para encontrar o modelo de Image-to-speech que vamos usar nesse projeto, vamos à pagina inicial do Hugging Face e filtramos a procura usando a opção de filtragem Image-to-Text, do lado esquerdo da página, na seção Multimodal.

Vá em Setting > Acess Tokens e crie um token de acesso para LangChain.

Em nosso computador, vamos abrir o Microsoft Visual Studio Code e criar um .env file onde vamos colocar as nossas credenciais. E vamos colocar aqui a Hugging Face Hub API Token, da seguinte forma:

HUGGINGFACEHUB_API_TOKEN = seu_huggingface_api_token_vai_aqui

Biblioteca Python dotenv

Agora, vamos importar algumas bibliotecas. Entretanto, primeiro, vamos importar dotenv para podermos acessar a Hugging Face Hub API Token que nós colocamos no arquivo .env.

Para isso, digite o comando abaixo no seu terminal.

pip install python-dotenv

A biblioteca dotenv facilita o gerenciamento de variáveis de ambiente em seus projetos Python.

O uso da biblioteca dotenv é útil especialmente em projetos onde você não deseja ou não pode expor informações sensíveis diretamente no código-fonte, como ao compartilhar o código em um repositório público.

Funções find_dotenv e load_dotenv

Agora, vamos importar as funções find_dotenv e load_dotenv, para o nosso código.

from dotenv import find_dotenv, load_dotenv

A função find_dotenv() procura um arquivo .env no diretório atual ou em seus diretórios pais.

Enquanto que a função load_dotenv() carrega as variáveis de ambiente definidas no arquivo .env para o dicionário os.environ.

Depois de importarmos as funcões mencionadas, vamos chamá-las(executar) com o comando abaixo:

load_dotenv(find_dotenv())

Biblioteca transformers

Nós vamos precisar da biblioteca Transformers que fornece acesso a diversos modelos pré-treinados e ferramentas para tarefas de Processamento de Linguagem Natural (PLN).

Para tanto, vamos instalá-la usando o seguinte código no terminal do nosso computador:

pip install transformers

Função Pipeline

Então, agora, nós vamos importar a função pipeline da biblioteca transformers, que acabamos de instalar.

Esta função simplifica a utilização de modelos pré-treinados para tarefas específicas de Processamento de Linguagem Natural (PLN). Ela lida com tarefas como pré-processamento de dados, inferência do modelo e pós-processamento, oferecendo uma interface amigável ao usuário.

Para importar essa função, utilizamos o comando abaixo no nosso terminal.

from transformers import pipeline

Criando o nosso modelo

Agora, estamos prontos para implementar o nosso modelo image to text.

Vamos fazer essa implementação através do código:

def img2text(url):
    img_to_text = pipeline("image-to-text", model="Salesforce/blip-captioning-base")

    text = image_to_text(url)[0]['generated_text']

    print(text)
    return text

    img2text("photo.png")

O código extrai com sucesso uma descrição textual da imagem.

Para você se familiarizar com os parâmetros das funcões pré-definidas pela Hugging Face, você pode acessar o seguinte site:

hugginggface.co/tasks

Então, no código acima, nós definimos uma função chamada img2text que recebe um parâmetro que chamamos de url.

Esse função chama(executa) a função pré-definida pipeline que nós importamos para o nosso código. E são passados dois parâmetros para essa função.

O primeiro parâmetro é o image-to-text. Essa expressão image-to-text é uma expressão reservada, pois foi definida na criação da função pipeline, que determina o que a função pipeline vai fazer. No caso, ler a imagem que será identificada e gerar uma descrição dessa imagem, em formato de texto.

O segundo parâmetro é o modelo que será usado na execução da função. Nesse caso: model=”Salesforce/blip-captioning-base”

Você pode obter o nome dos modelos clicando no botão Use in Transformers que fica localizado no lado direito da página.

Implementando o Modelo de Linguagem Grande (LLM)

A próxima etapa é implementar o LLM para gerar uma história baseada na descrição da imagem.

Aqui você pode usar modelos open source mas aqui usaremos o ChatGPT.

Para isso, colocaremos a nossa OpenAI API key no nosso arquivo .env.

OPENAI_API_KEY=coloque-a-sua-openai-key-aqui.

E também vamos importar mais uma biblioteca, agora da langchain.

pip install langchain

Depois, de instalarmos a biblioteca langchain podemos importar as funções PromptTemplate, LLMChan e OpenAI, que vamos precisar.

from langchain import PromptTemplate, LLMChain, OpenAI

E agora, vamos criar uma função que vai gerar o texto baseado na imagem.

def generate_story(scenario):
    template = """
    You are a story teller;
    You can generate a short story based on a simple narrative, the story should be no more than 20 words.

    CONTEXT: {scenario}
    STORY:
    """
    prompt = PromptTemplate(template=template, input_variables=[scenario])

    story_llm = LLMChain(llm=OpenaAI(model_name="gpt-3.5-turbo", temperature=1), prompt=prompt, verbose=True)

    story = story_llm.predict(scenario=scenario)

Implementando o Modelo de Texto para Fala (método alternativo)

Vamos até a página que se encontram os modelos e procure por um modelo Text-to-Speech, que fica sob a seção Audio, no lado esquerdo da página, e escolha um dos mais populares.

Método Alternativo

Mas nós usaremos um modelo do Hugging Face.

Você pode clicar no botão Deploy e escolher Inference API. Essa é uma maneira rápida para você testar a Hugging Face API de graça.

Vamos adicionar ao nosso código:

import request
import os //para extrairmos os API Tokens

E incluiremos o Hugging Face API Token em nosso código, para passarmos quando requisitado pelo API.

HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")

Então, criamos a função text2speech:

def text2speech(message):
    API_URL = "http://api-inference.huggingface.co/models/espnet/kan-bayashi_ljspeech_vits"
    headers = {"Authorization": f"Bearer {HUGGINGFACEHUB_API_TOKEN}"}
    payloads = {
        "inputs": message
    }

    response = requests.post(API_URL, heeaders=headers, json=payloads)
    with open('audio.flac', 'wb') as file:
        file.write(response.content)

scenario = img2text("photo.png")
story = generate_story(scenario)
text2speech(story)

Construindo a Interface do Usuário

Para criarmos a interface do usuário vamos fazer uso da biblioteca Python Streamlit.

Para tanto, precisamos instarmos essa biblioteca:

pip install streamlit

Agora, podemos importar para o nosso programa:

import streamlit as st

No final, vamos acrescentar:

 if __name__=='__main__':
    main()

Vamos criar a função main(), que vamos chamá-la quando o APP for acionado.

def main():
    st.set_page_config(page_title="img 2 audio story", page_icon="")
    
    st.header("Turn img into audio story")

# File upload para o usuário enviar um arquivo.
    uploaded_file = st.file_uploader("Choose an image...", type="jpg")

   if uploaded_file is not Nome:
# Se o arquivo for uploaded, salvamos o arquivo.
       bytes_data = upload_file.getvalue()
       with open(uploaded_file.name, "wb") as file:
           file.write(bytes_data)

# mostra a imagem
       st.image(uploaded_file,caption='Uploaded Image.', use_column_width=True)

# executamos a função img2text para criar o texto a partir da imagem
       scenario = img2text(uploaded_file.name)

# cria a estória baseada no cenário passado como argumento.
       story = generate_story(scenario)

# gera o oudio a partir da estória criada.
       text2speech(story)

# mostra(display) o cenário e a estória
       with st.expander("scenario"):
            st.write(scenario)
       with st.expanderr("story")
            st.write(story)

# display o arquivo de audio final
        st.audio("audio.flac")

Esse trecho de código acima, mostra elementos básicos da interface do usuário, como título, cabeçalho e carregador de arquivos.

O carregador permitirá que os usuários insiram imagens para o aplicativo.

Para executarmos o programa, digitamos no terminal:

streamlit run app.py

E então, vai carrega a página no seu localhost e você vai poder subir uma imagem que será analizada, será gerada uma história baseada na imagem e finalmente será gerado o audio.

Pode-se também usar uma outra plataforma de IA de low code, a Relevance AI, para facilitar a construção desse tipo de aplicativos. Dêem uma olhada no Relevance AI, parece muito bom.

Pronto, nosso projeto está concluído. O Hugging face tem uma infinidade de modelos open source que podem ser aproveitados nos seus projetos.

_________

Fonte Youtube vídeo: Hugging Face + Langchain in 5 mins | Access 200k+ FREE AI models for your AI apps (youtube.com)
Transcrição e tradução Google Bard e Admin