AI Ecosysteem op stoom

AI modellen met UI en API

Onderstaand een kleine selectie van bestaande AI applicaties met een Gradio UI/API:

• Stable Diffusion Prompt Generator: Genereert een geoptimaliseerde prompt voor een image generator.
• Stable Diffusion Image Generator: Genereert een image op basis van een prompt.
• Image Caption Generator: Genereert een ondertitel op basis van een image
• Text To Video Generator: Genereert een video gebaseerd op een prompt.

Speel er mee, ieder van deze applicaties heeft waarde op zichzelf, een UI om ze interactief te gebruiken en een API om ze vanuit andere software te integreren. Maar het echte mooie is dat ze als building blocks gebruikt kunnen worden om een complexere AI gebaseerde applicaties te bouwen.

Van bovenstaande werk ik de Stable Diffusion PromptGenerator wat verder uit. Op genoemde URL vindt je dus zowel de UI als API om achterliggend Promptist model te gebruiken. Merk op dat deze modellen op Hugging Face zogenaamde model cards hebben waar je meer informatie kunt vinden over gebruik en beperkingen.

De User Interface van de Stable Diffusion Prompt Generator ziet er als onderstaand uit:

Onder aan bovenstaande pagina staat een link naar een REST API beschrijving en test pagina: Daarnaast heeft Gradio een client package waarmee de API laagdrempelig bevraagd kan worden:

from gradio_client import Client

client = Client("microsoft/Promptist") 

client.view_api()
# Client.predict() Usage Info
# ---------------------------
# Named API endpoints: 1
#
#  - predict(initial_text, api_name="/predict") -> optimized_prompt
#     Parameters:
#      - [Textbox] initial_text: str (string value)
#     Returns:
#      - [Textbox] optimized_prompt: str (string value)

response = client.predict("Please create a photo of a dog riding a skateboard")
# A dog riding a skateboard, digital painting, artstation, 
# concept art, smooth, sharp focus, illustration, art by artgerm 
# and greg rutkowski and alphonse mucha

Onderstaand sequence diagram geeft globale indruk van de flow:

Elk van de andere genoemde AI applicaties kan op een zelfde manier uitgewerkt worden

Het Langchain framework

Langchain is groot en snelgroeiend, in grote lijnen omvat het de volgende componenten:

• Models: ondersteuning van verschillende modeltypen en modelintegraties
• Prompts: o.a. beheer, optimalisatie en serialisatie.
• Memory: een standaardinterface voor het persistent maken van de status tussen oproepen, zowel binnen de sessie scope (kort geheugen) als over sessies (lang geheugen).
• Indexes: taalmodellen zijn vaak krachtiger wanneer ze worden gecombineerd met eigen tekstgegevens.
• Chains: Ketens gaan verder dan slechts één LLM-oproep en bestaan uit sequenties van oproepen (of het nu naar een LLM of een andere hulpprogramma is).
• Agents: Agenten zorgen dat LLM beslissingen neemt over welke acties hij moet ondernemen, die actie onderneemt, een observatie ziet en dit herhaalt totdat het klaar is.

Langchain is heel groot, maar zoals gezegd spits ik mij toe op uitwerking rondom AI modellen met een Gradio User interface die ook als API te benaderen zijn, dan kan ik in Langchain gebruik maken van het recent verschenen Gradio tools en de verschillende AI applicaties laten samenwerken in een keten.

De relevante Langchain gerelateerde code is:

llm = OpenAI(temperature=0)
memory = ConversationBufferMemory(memory_key="chat_history", 
                                  input_key='input', 
                                  output_key="output")
tools = [StableDiffusionTool().langchain, 
         ImageCaptioningTool().langchain,
         StableDiffusionPromptGeneratorTool().langchain, 
         TextToVideoTool().langchain]


agent = initialize_agent(tools, 
                         llm, 
                         memory=memory, 
                         agent="conversational-react-description", 
                         verbose=True)
response = agent(question)

In woorden: gebruik default OpenAI model als LLM basis, gebruik type geheugen dat optimaal is voor chat historie, bij beantwoording van de vragen mag gebruik gemaakt worden van de eerder besproken lijst van tools (AI applicaties). Start een Agent die dit alles orchestreert.

Onderstaand de relevante Gradio UI gerelateerde code:

with gr.Blocks() as demo:
    with gr.Column():
        gallery = gr.Gallery(
            label="Generated images", 
            elem_id="gallery"
        ).style(columns=[4], 
                rows=[1], 
                object_fit="contain", 
                height="400px")
        with gr.Row():
            with gr.Column(scale=3):
                input = gr.TextArea(label="question")
            with gr.Column(scale=1):
                video = gr.Video(label="video")

        btn = gr.Button(value="Send")
        examples = gr.Examples(examples=[
            "Please create a photo of a dog riding a skateboard "
            "but improve my prompt prior to using an image generator."
            "Please caption the generated image and create a video for it using the improved prompt."
          ],
          inputs=[input])

    demo.load(handle_question, [input], gallery, examples)

De User Interface, na beantwoording van de vraag ziet er dan zo uit:

Onderstaand sequence diagram geeft een impressie van hoe de verschillende componenten in een sessie samenwerken om tot het resultaat te komen:

Qua intermediate steps wordt het volgende gegeneerd door Langchain (lange strings heb ik handmatig over meerdere regels verdeeld):

[
  [
    [
      "StableDiffusionPromptGenerator",
      "A dog riding a skateboard",
      "\nThought: Do I need to use a tool? Yes\nAction:"
      "StableDiffusionPromptGenerator\nAction Input: A dog riding a skateboard"
    ],
    "A dog riding a skateboard, digital painting, artstation, concept art,"  
    "smooth, sharp focus, illustration, art by artgerm and greg rutkowski "  
    "and alphonse mucha"
  ],
  [
    [
      "StableDiffusion",
      "A dog riding a skateboard, digital painting, artstation, concept art, "
      "smooth, sharp focus, illustration, art by artgerm and greg rutkowski " 
      "and alphonse mucha",
      " Do I need to use a tool? Yes\nAction: StableDiffusion\nAction Input:"
      "A dog riding a skateboard, digital painting, artstation, concept art, "
      "smooth, sharp focus, illustration, art by artgerm and greg rutkowski " 
      "and alphonse mucha"
    ],
    "/projects/huggingface/appareto/"
    "0ced182a-3ef0-4ea4-93a1-1327e79570d3/tmpavc2fe12.jpg"
  ],
  [
    [
      "ImageCaptioner",
      "/media/data/eve/projects/huggingface/appareto/"
      "0ced182a-3ef0-4ea4-93a1-1327e79570d3/tmpavc2fe12.jpg",
      " Do I need to use a tool? Yes\nAction: ImageCaptioner\nAction Input:"
      "/projects/huggingface/appareto/"
      "0ced182a-3ef0-4ea4-93a1-1327e79570d3/tmpavc2fe12.jpg"
    ],
    "a drawing of a dog on a skateboard"
  ],
  [
    [
      "TextToVideo",
      "a drawing of a dog on a skateboard",
      " Do I need to use a tool? Yes\nAction: TextToVideo\nAction Input:"
      "a drawing of a dog on a skateboard"
    ],
    "/projects/huggingface/appareto/"
    "0ced182a-3ef0-4ea4-93a1-1327e79570d3/tmp4n2aecan4tvzd9o0.mp4"
  ]
]

Afsluitend

Ik hoop dat iets duidelijker is welke grote stappen het AI ecosysteem voor ontwikkelaars gemaakt heeft in afgelopen periode. Start er zelf mee en gebruik AI modellen binnen jouw eigen organisatie! En, zonodig, wil ik natuurlijk graag helpen, bv. bij het ontwikkelen van een Proof of Concept of het verder uitbouwen daarvan.