From cd0e811849b396b6f3eb081e86722d73cbc35e23 Mon Sep 17 00:00:00 2001
From: "Rossdan Craig rossdan@lastmileai.dev" <>
Date: Wed, 10 Jan 2024 01:39:03 -0500
Subject: [PATCH 1/6] [HF][streaming][1/n] Text Summarization

TSIA

Adding streaming functionality to text summarization model parser

## Test Plan
Rebase onto and test it with https://github.com/lastmile-ai/aiconfig/pull/852/commits/11ace0a5a31b9404a97965e5fa478d5b19adcb67.

Follow the README from AIConfig Editor https://github.com/lastmile-ai/aiconfig/tree/main/python/src/aiconfig/editor#dev, then run these command
```bash
aiconfig_path=/Users/rossdancraig/Projects/aiconfig/cookbooks/Gradio/huggingface.aiconfig.json
parsers_path=/Users/rossdancraig/Projects/aiconfig/cookbooks/Gradio/hf_model_parsers.py
alias aiconfig="python3 -m 'aiconfig.scripts.aiconfig_cli'"
aiconfig edit --aiconfig-path=$aiconfig_path --server-port=8080 --server-mode=debug_servers --parsers-module-path=$parsers_path
```

Then in AIConfig Editor run the prompt (it will be streaming format by default)


https://github.com/lastmile-ai/aiconfig/assets/151060367/e91a1d8b-a3e9-459c-9eb1-2d8e5ec58e73
---
 cookbooks/Gradio/huggingface.aiconfig.json    | 21 +++++++++++++++++++
 .../local_inference/text_generation.py        |  2 +-
 .../local_inference/text_summarization.py     | 11 ++++++++--
 3 files changed, 31 insertions(+), 3 deletions(-)
 create mode 100644 cookbooks/Gradio/huggingface.aiconfig.json

diff --git a/cookbooks/Gradio/huggingface.aiconfig.json b/cookbooks/Gradio/huggingface.aiconfig.json
new file mode 100644
index 000000000..2ab54cc38
--- /dev/null
+++ b/cookbooks/Gradio/huggingface.aiconfig.json
@@ -0,0 +1,21 @@
+{
+  "name": "",
+  "schema_version": "latest",
+  "metadata": {
+    "parameters": {},
+    "models": {}
+  },
+  "description": "",
+  "prompts": [
+    {
+      "name": "prompt_1",
+      "input": "",
+      "metadata": {
+        "model": "gpt-4",
+        "parameters": {}
+      },
+      "outputs": []
+    }
+  ],
+  "$schema": "https://json.schemastore.org/aiconfig-1.0"
+}
\ No newline at end of file
diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py
index e0941b0fd..c6218c82e 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py
@@ -251,7 +251,7 @@ async def run_inference(
             not "stream" in completion_data or completion_data.get("stream") != False
         )
         if should_stream:
-            tokenizer : AutoTokenizer = AutoTokenizer.from_pretrained(model_name)
+            tokenizer: AutoTokenizer = AutoTokenizer.from_pretrained(model_name)
             streamer = TextIteratorStreamer(tokenizer)
             completion_data["streamer"] = streamer
 
diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py
index bba735b4f..32b90b908 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py
@@ -128,13 +128,18 @@ def construct_stream_output(
             "metadata": {},
         }
     )
+
     accumulated_message = ""
     for new_text in streamer:
         if isinstance(new_text, str):
+            # For some reason these symbols aren't filtered out by the streamer
+            new_text = new_text.replace("</s>", "")
+            new_text = new_text.replace("<s>", "")
+
             accumulated_message += new_text
             options.stream_callback(new_text, accumulated_message, 0)
-
             output.data = accumulated_message
+
     return output
 
 
@@ -245,7 +250,9 @@ async def run_inference(self, prompt: Prompt, aiconfig: "AIConfigRuntime", optio
 
         # if stream enabled in runtime options and config, then stream. Otherwise don't stream.
         streamer = None
-        should_stream = (options.stream if options else False) and (not "stream" in completion_data or completion_data.get("stream") != False)
+        should_stream = (options.stream if options else False) and (
+            not "stream" in completion_data or completion_data.get("stream") != False
+        )
         if should_stream:
             tokenizer: AutoTokenizer = AutoTokenizer.from_pretrained(model_name)
             streamer = TextIteratorStreamer(tokenizer)

From 5888ac3ef5137d67ed100d754c7b3ab8ce0615ce Mon Sep 17 00:00:00 2001
From: "Rossdan Craig rossdan@lastmileai.dev" <>
Date: Wed, 10 Jan 2024 02:08:54 -0500
Subject: [PATCH 2/6] [HF][streaming][2/n] Text Translation

TSIA

Adding streaming output support for text translation model parser. I also fixed a bug where we didn't pass in `"translation"` key into the pipeline

## Test Plan
Rebase onto and test it: https://github.com/lastmile-ai/aiconfig/commit/5b7434483e2521110bbe3cc3380d9b99a6d4e8be.

Follow the README from AIConfig Editor https://github.com/lastmile-ai/aiconfig/tree/main/python/src/aiconfig/editor#dev, then run these command
```bash
aiconfig_path=/Users/rossdancraig/Projects/aiconfig/cookbooks/Gradio/huggingface.aiconfig.json
parsers_path=/Users/rossdancraig/Projects/aiconfig/cookbooks/Gradio/hf_model_parsers.py
alias aiconfig="python3 -m 'aiconfig.scripts.aiconfig_cli'"
aiconfig edit --aiconfig-path=$aiconfig_path --server-port=8080 --server-mode=debug_servers --parsers-module-path=$parsers_path
```

With Streaming

https://github.com/lastmile-ai/aiconfig/assets/151060367/d7bc9df2-2993-4709-bf9b-c5b7979fb00f

Without Streaming

https://github.com/lastmile-ai/aiconfig/assets/151060367/71eb6ab3-5d6f-4c5d-8b82-f3daf4c5e610
---
 .../HuggingFace/python/requirements.txt       |  5 ++--
 .../local_inference/text_translation.py       | 24 +++++++++++++++----
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/extensions/HuggingFace/python/requirements.txt b/extensions/HuggingFace/python/requirements.txt
index 6388e1c9e..79e5db10b 100644
--- a/extensions/HuggingFace/python/requirements.txt
+++ b/extensions/HuggingFace/python/requirements.txt
@@ -10,11 +10,12 @@ huggingface_hub
 
 #Hugging Face Libraries - Local Inference Tranformers & Diffusors
 accelerate # Used to help speed up image generation
-diffusers # Used for image + audio generation
+diffusers # Used for image generation
+scipy # array -> wav file, text-speech. torchaudio.save seems broken.
+sentencepiece # Used for text translation
 torch
 torchvision
 torchaudio
-scipy # array -> wav file, text-speech. torchaudio.save seems broken.
 transformers # Used for text generation
 
 #Other
diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_translation.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_translation.py
index 9ee8bb357..860a11e46 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_translation.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_translation.py
@@ -129,12 +129,19 @@ def construct_stream_output(
             "metadata": {},
         }
     )
+
     accumulated_message = ""
     for new_text in streamer:
         if isinstance(new_text, str):
+            # For some reason these symbols aren't filtered out by the streamer
+            new_text = new_text.replace("</s>", "")
+            new_text = new_text.replace("<s>", "")
+            new_text = new_text.replace("<pad>", "")
+
             accumulated_message += new_text
             options.stream_callback(new_text, accumulated_message, 0)
             output.data = accumulated_message
+
     return output
 
 
@@ -240,19 +247,26 @@ async def run_inference(self, prompt: Prompt, aiconfig: "AIConfigRuntime", optio
 
         model_name: str = aiconfig.get_model_name(prompt)
         if isinstance(model_name, str) and model_name not in self.translators:
-            self.translators[model_name] = pipeline(model_name)
+            self.translators[model_name] = pipeline("translation", model_name)
         translator = self.translators[model_name]
 
         # if stream enabled in runtime options and config, then stream. Otherwise don't stream.
         streamer = None
-        should_stream = (options.stream if options else False) and (not "stream" in completion_data or completion_data.get("stream") != False)
+        should_stream = (options.stream if options else False) and (
+            not "stream" in completion_data or completion_data.get("stream") != False
+        )
         if should_stream:
-            raise NotImplementedError("Streaming is not supported for HuggingFace Text Translation")
+            tokenizer: AutoTokenizer = AutoTokenizer.from_pretrained(model_name)
+            streamer = TextIteratorStreamer(tokenizer)
+            completion_data["streamer"] = streamer
+
+        def _translate():
+            return translator(inputs, **completion_data)
 
         outputs: List[Output] = []
         output = None
         if not should_stream:
-            response: List[Any] = translator(inputs, **completion_data)
+            response: List[Any] = _translate()
             for count, result in enumerate(response):
                 output = construct_regular_output(result, count)
                 outputs.append(output)
@@ -263,7 +277,7 @@ async def run_inference(self, prompt: Prompt, aiconfig: "AIConfigRuntime", optio
                 raise ValueError("Stream option is selected but streamer is not initialized")
 
             # For streaming, cannot call `translator` directly otherwise response will be blocking
-            thread = threading.Thread(target=translator, kwargs=completion_data)
+            thread = threading.Thread(target=_translate)
             thread.start()
             output = construct_stream_output(streamer, options)
             if output is not None:

From 617682ee7a6e69edfebec25264494ef20159c4cf Mon Sep 17 00:00:00 2001
From: "Rossdan Craig rossdan@lastmileai.dev" <>
Date: Wed, 10 Jan 2024 02:49:07 -0500
Subject: [PATCH 3/6] [HF][streaming][3/n] Text2Speech (no streaming, but
 updating docs on completion params)

Ok this one is weird. Today, streaming is only ever supported on text outputs in Transformers library. See `BaseStreamer` in here: https://github.com/search?q=repo%3Ahuggingface%2Ftransformers%20BaseStreamer&type=code

In the future it may support other formats, but not yet. For example, OpenAI supports it: https://community.openai.com/t/streaming-from-text-to-speech-api/493784

Anyways, I basically here only did some updates to docs to clarify why completion params were null. Jonathan and I synced about this briefly ofline, but I forgot again so wanted to capture it here so no one forgets
---
 .../local_inference/text_2_speech.py                   | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_2_speech.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_2_speech.py
index 85dee4add..97e172fde 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_2_speech.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_2_speech.py
@@ -25,6 +25,8 @@
 
 # Step 1: define Helpers
 def refine_pipeline_creation_params(model_settings: Dict[str, Any]) -> List[Dict[str, Any]]:
+    # There are from the transformers Github repo: 
+    # https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2534
     supported_keys = {
         "torch_dtype",
         "force_download",
@@ -61,9 +63,11 @@ def refine_pipeline_creation_params(model_settings: Dict[str, Any]) -> List[Dict
 
 
 def refine_completion_params(unfiltered_completion_params: Dict[str, Any]) -> Dict[str, Any]:
-    supported_keys = {
-        # ???
-    }
+    # Note: There seems to be no public API docs on what completion
+    # params are supported for text to speech: 
+    # https://huggingface.co/docs/transformers/tasks/text-to-speech#inference
+    # The only one mentioned is `forward_params` which can contain `speaker_embeddings`
+    supported_keys = {}
 
     completion_params: Dict[str, Any] = {}
     for key in unfiltered_completion_params:

From a5a26aa85e6f59e1d30aff3da65640e47ef7845a Mon Sep 17 00:00:00 2001
From: "Rossdan Craig rossdan@lastmileai.dev" <>
Date: Wed, 10 Jan 2024 04:16:16 -0500
Subject: [PATCH 4/6] [HF][streaming][4/n] Image2Text (no streaming, but lots
 of fixing)

This model parser does not support streaming (surprising!):

```
TypeError: ImageToTextPipeline._sanitize_parameters() got an unexpected keyword argument 'streamer'
```

In general, I mainly just did a lot of fixing up to make sure that this worked as expected. Things I fixed:

1. Now works for multiple images (it did before, but didn't process responses for each properly, just put the entire response)
2. Constructing responses to be in pure text output
3. Specified the completion params that are supported (only 2: https://github.com/huggingface/transformers/blob/701298d2d3d5c7bde45e71cce12736098e3f05ef/src/transformers/pipelines/image_to_text.py#L97-L102C13)

Next diff I will add support for b64 encoded image format --> we need to convert this to a PIL, see https://github.com/huggingface/transformers/blob/701298d2d3d5c7bde45e71cce12736098e3f05ef/src/transformers/pipelines/image_to_text.py#L83

## Test Plan
Rebase onto and test it: 5f3b667f8c31b59c23555a269ccd4d17388f6361.

Follow the README from AIConfig Editor https://github.com/lastmile-ai/aiconfig/tree/main/python/src/aiconfig/editor#dev, then run these command
```bash
aiconfig_path=/Users/rossdancraig/Projects/aiconfig/cookbooks/Gradio/huggingface.aiconfig.json
parsers_path=/Users/rossdancraig/Projects/aiconfig/cookbooks/Gradio/hf_model_parsers.py
alias aiconfig="python3 -m 'aiconfig.scripts.aiconfig_cli'"
aiconfig edit --aiconfig-path=$aiconfig_path --server-port=8080 --server-mode=debug_servers --parsers-module-path=$parsers_path
```

Then in AIConfig Editor run the prompt (streaming not supported so just took screenshots)
---
 .../local_inference/image_2_text.py           | 116 +++++++++++++++---
 .../local_inference/text_generation.py        |  16 +--
 .../local_inference/text_summarization.py     |   4 +-
 3 files changed, 107 insertions(+), 29 deletions(-)

diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py
index ad408ca17..aab79c965 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py
@@ -1,11 +1,21 @@
+import json
 from typing import Any, Dict, Optional, List, TYPE_CHECKING
+from transformers import (
+    Pipeline,
+    pipeline,
+)
+
 from aiconfig import ParameterizedModelParser, InferenceOptions
 from aiconfig.callback import CallbackEvent
-import torch
-from aiconfig.schema import Prompt, Output, ExecuteResult, Attachment
-
-from transformers import pipeline, Pipeline
-
+from aiconfig.schema import (
+    Attachment,
+    ExecuteResult,
+    Output,
+    OutputDataWithValue,
+    Prompt,
+)
+
+# Circular Dependency Type Hints
 if TYPE_CHECKING:
     from aiconfig import AIConfigRuntime
 
@@ -93,10 +103,11 @@ async def deserialize(
         await aiconfig.callback_manager.run_callbacks(CallbackEvent("on_deserialize_start", __name__, {"prompt": prompt, "params": params}))
 
         # Build Completion data
-        completion_params = self.get_model_settings(prompt, aiconfig)
+        model_settings = self.get_model_settings(prompt, aiconfig)
+        completion_params = refine_completion_params(model_settings)
 
+        #Add image inputs
         inputs = validate_and_retrieve_image_from_attachments(prompt)
-
         completion_params["inputs"] = inputs
 
         await aiconfig.callback_manager.run_callbacks(CallbackEvent("on_deserialize_complete", __name__, {"output": completion_params}))
@@ -110,24 +121,93 @@ async def run_inference(self, prompt: Prompt, aiconfig: "AIConfigRuntime", optio
                 {"prompt": prompt, "options": options, "parameters": parameters},
             )
         )
-        model_name = aiconfig.get_model_name(prompt)
-
-        self.pipelines[model_name] = pipeline(task="image-to-text", model=model_name)
 
-        captioner = self.pipelines[model_name]
         completion_data = await self.deserialize(prompt, aiconfig, parameters)
         inputs = completion_data.pop("inputs")
-        model = completion_data.pop("model")
-        response = captioner(inputs, **completion_data)
 
-        output = ExecuteResult(output_type="execute_result", data=response, metadata={})
+        model_name: str | None = aiconfig.get_model_name(prompt)
+        if isinstance(model_name, str) and model_name not in self.pipelines:
+            self.pipelines[model_name] = pipeline(task="image-to-text", model=model_name)
+        captioner = self.pipelines[model_name]
+
+        outputs: List[Output] = []
+        response: List[Any] = captioner(inputs, **completion_data)
+        for count, result in enumerate(response):
+            output: Output = construct_regular_output(result, count)
+            outputs.append(output)
 
-        prompt.outputs = [output]
-        await aiconfig.callback_manager.run_callbacks(CallbackEvent("on_run_complete", __name__, {"result": prompt.outputs}))
+        prompt.outputs = outputs
+        print(f"{prompt.outputs=}")
+        await aiconfig.callback_manager.run_callbacks(
+            CallbackEvent(
+                "on_run_complete",
+                __name__,
+                {"result": prompt.outputs},
+            )
+        )
         return prompt.outputs
 
-    def get_output_text(self, response: dict[str, Any]) -> str:
-        raise NotImplementedError("get_output_text is not implemented for HuggingFaceImage2TextTransformer")
+    def get_output_text(
+        self,
+        prompt: Prompt,
+        aiconfig: "AIConfigRuntime",
+        output: Optional[Output] = None,
+    ) -> str:
+        if output is None:
+            output = aiconfig.get_latest_output(prompt)
+
+        if output is None:
+            return ""
+
+        # TODO (rossdanlm): Handle multiple outputs in list
+        # https://github.com/lastmile-ai/aiconfig/issues/467
+        if output.output_type == "execute_result":
+            output_data = output.data
+            if isinstance(output_data, str):
+                return output_data
+            if isinstance(output_data, OutputDataWithValue):
+                if isinstance(output_data.value, str):
+                    return output_data.value
+                # HuggingFace Text summarization does not support function
+                # calls so shouldn't get here, but just being safe
+                return json.dumps(output_data.value, indent=2)
+        return ""
+
+
+def refine_completion_params(model_settings: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Refines the completion params for the HF image to text api. Removes any unsupported params.
+    The supported keys were found by looking at the HF ImageToTextPipeline.__call__ method
+    """
+    supported_keys = {
+        "max_new_tokens",
+        "timeout",
+    }
+
+    completion_data = {}
+    for key in model_settings:
+        if key.lower() in supported_keys:
+            completion_data[key.lower()] = model_settings[key]
+
+    return completion_data
+
+# Helper methods
+def construct_regular_output(result: Dict[str, str], execution_count: int) -> Output:
+    """
+    Construct regular output per response result, without streaming enabled
+    """
+    output = ExecuteResult(
+        **{
+            "output_type": "execute_result",
+            # For some reason result is always in list format we haven't found
+            # a way of being able to return multiple sequences from the image 
+            # to text pipeline
+            "data": result[0]["generated_text"],
+            "execution_count": execution_count,
+            "metadata": {},
+        }
+    )
+    return output
 
 
 def validate_attachment_type_is_image(attachment: Attachment):
diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py
index c6218c82e..4da5d7037 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_generation.py
@@ -153,7 +153,7 @@ def __init__(self):
                 config.register_model_parser(parser)
         """
         super().__init__()
-        self.generators : dict[str, Pipeline]= {}
+        self.generators: dict[str, Pipeline]= {}
 
     def id(self) -> str:
         """
@@ -217,14 +217,14 @@ async def deserialize(
         # Build Completion data
         model_settings = self.get_model_settings(prompt, aiconfig)
         completion_data = refine_chat_completion_params(model_settings)
-        
+
         #Add resolved prompt
         resolved_prompt = resolve_prompt(prompt, params, aiconfig)
         completion_data["prompt"] = resolved_prompt
         return completion_data
 
     async def run_inference(
-        self, prompt: Prompt, aiconfig : "AIConfigRuntime", options : InferenceOptions, parameters: Dict[str, Any]
+        self, prompt: Prompt, aiconfig: "AIConfigRuntime", options: InferenceOptions, parameters: Dict[str, Any]
     ) -> List[Output]:
         """
         Invoked to run a prompt in the .aiconfig. This method should perform
@@ -239,8 +239,8 @@ async def run_inference(
         """
         completion_data = await self.deserialize(prompt, aiconfig, options, parameters)
         completion_data["text_inputs"] = completion_data.pop("prompt", None)
-        
-        model_name : str = aiconfig.get_model_name(prompt)
+
+        model_name: str | None = aiconfig.get_model_name(prompt)
         if isinstance(model_name, str) and model_name not in self.generators:
             self.generators[model_name] = pipeline('text-generation', model=model_name)
         generator = self.generators[model_name]
@@ -255,10 +255,10 @@ async def run_inference(
             streamer = TextIteratorStreamer(tokenizer)
             completion_data["streamer"] = streamer
 
-        outputs : List[Output] = []
+        outputs: List[Output] = []
         output = None
         if not should_stream:
-            response : List[Any] = generator(**completion_data)
+            response: List[Any] = generator(**completion_data)
             for count, result in enumerate(response):
                 output = construct_regular_output(result, count)
                 outputs.append(output)
@@ -267,7 +267,7 @@ async def run_inference(
                 raise ValueError("Sorry, TextIteratorStreamer does not support multiple return sequences, please set `num_return_sequences` to 1")
             if not streamer:
                 raise ValueError("Stream option is selected but streamer is not initialized")
-            
+
             # For streaming, cannot call `generator` directly otherwise response will be blocking
             thread = threading.Thread(target=generator, kwargs=completion_data)
             thread.start()
diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py
index 32b90b908..2b3b61358 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/text_summarization.py
@@ -258,12 +258,10 @@ async def run_inference(self, prompt: Prompt, aiconfig: "AIConfigRuntime", optio
             streamer = TextIteratorStreamer(tokenizer)
             completion_data["streamer"] = streamer
 
-        outputs: List[Output] = []
-        output = None
-
         def _summarize():
             return summarizer(inputs, **completion_data)
 
+        outputs: List[Output] = []
         if not should_stream:
             response: List[Any] = _summarize()
             for count, result in enumerate(response):

From ff61f49d0eb2adb9045110665e9e5498e595eb05 Mon Sep 17 00:00:00 2001
From: "Rossdan Craig rossdan@lastmileai.dev" <>
Date: Wed, 10 Jan 2024 04:58:48 -0500
Subject: [PATCH 5/6] [HF][5/n] Image2Text: Allow base64 inputs for images

Before we didn't allow base64, only URI (either local or http or https). This is good becuase our text2Image model parser outputs into a base64 format, so this will allow us to chain model prompts!

## Test Plan
---
 .../local_inference/image_2_text.py           | 25 +++++++++++++------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py
index aab79c965..ddb0eb624 100644
--- a/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py
+++ b/extensions/HuggingFace/python/src/aiconfig_extension_hugging_face/local_inference/image_2_text.py
@@ -1,5 +1,8 @@
+import base64
 import json
-from typing import Any, Dict, Optional, List, TYPE_CHECKING
+from io import BytesIO
+from PIL import Image
+from typing import Any, Dict, Optional, List, TYPE_CHECKING, Union
 from transformers import (
     Pipeline,
     pipeline,
@@ -107,7 +110,7 @@ async def deserialize(
         completion_params = refine_completion_params(model_settings)
 
         #Add image inputs
-        inputs = validate_and_retrieve_image_from_attachments(prompt)
+        inputs = validate_and_retrieve_images_from_attachments(prompt)
         completion_params["inputs"] = inputs
 
         await aiconfig.callback_manager.run_callbacks(CallbackEvent("on_deserialize_complete", __name__, {"output": completion_params}))
@@ -218,7 +221,7 @@ def validate_attachment_type_is_image(attachment: Attachment):
         raise ValueError(f"Invalid attachment mimetype {attachment.mime_type}. Expected image mimetype.")
 
 
-def validate_and_retrieve_image_from_attachments(prompt: Prompt) -> list[str]:
+def validate_and_retrieve_images_from_attachments(prompt: Prompt) -> list[Union[str, Image]]:
     """
     Retrieves the image uri's from each attachment in the prompt input.
 
@@ -232,15 +235,23 @@ def validate_and_retrieve_image_from_attachments(prompt: Prompt) -> list[str]:
     if not hasattr(prompt.input, "attachments") or len(prompt.input.attachments) == 0:
         raise ValueError(f"No attachments found in input for prompt {prompt.name}. Please add an image attachment to the prompt input.")
 
-    image_uris: list[str] = []
+    images: list[Union[str, Image]] = []
 
     for i, attachment in enumerate(prompt.input.attachments):
         validate_attachment_type_is_image(attachment)
 
-        if not isinstance(attachment.data, str):
+        input_data = attachment.data
+        if not isinstance(input_data, str):
             # See todo above, but for now only support uri's
             raise ValueError(f"Attachment #{i} data is not a uri. Please specify a uri for the image attachment in prompt {prompt.name}.")
 
-        image_uris.append(attachment.data)
+        # Really basic heurestic to check if the data is a base64 encoded str
+        # vs. uri. This will be fixed once we have standardized inputs
+        # See https://github.com/lastmile-ai/aiconfig/issues/829
+        if len(input_data) > 10000:
+            pil_image : Image = Image.open(BytesIO(base64.b64decode(input_data)))
+            images.append(pil_image)
+        else:
+            images.append(input_data)
 
-    return image_uris
+    return images

From 0d7ae2b32ac2eb75cd41ac91e222c5bb6bb5c918 Mon Sep 17 00:00:00 2001
From: "Rossdan Craig rossdan@lastmileai.dev" <>
Date: Wed, 10 Jan 2024 04:58:48 -0500
Subject: [PATCH 6/6] Testing streaming outputs

Various version of this PR are for testing streaming implementations of the HuggingFace model parsers
---
 cookbooks/Gradio/hf_model_parsers.py        | 39 ++++++++++++
 cookbooks/Gradio/huggingface.aiconfig.json  | 66 +++++++++++++++++++--
 python/src/aiconfig/editor/server/server.py |  4 +-
 3 files changed, 101 insertions(+), 8 deletions(-)
 create mode 100644 cookbooks/Gradio/hf_model_parsers.py

diff --git a/cookbooks/Gradio/hf_model_parsers.py b/cookbooks/Gradio/hf_model_parsers.py
new file mode 100644
index 000000000..50cb40f79
--- /dev/null
+++ b/cookbooks/Gradio/hf_model_parsers.py
@@ -0,0 +1,39 @@
+from aiconfig_extension_hugging_face import (
+    HuggingFaceAutomaticSpeechRecognitionTransformer, # Haven't tested yet
+
+    HuggingFaceImage2TextTransformer, # Tested, model doesn't support streaming
+    HuggingFaceTextSummarizationTransformer, # Tested
+    HuggingFaceText2ImageDiffusor, # Tested, model doesn't support streaming
+    HuggingFaceText2SpeechTransformer, # Tested, model doesn't support streaming
+    HuggingFaceTextGenerationTransformer, # Tested
+    HuggingFaceTextTranslationTransformer, # Tested
+)
+from aiconfig import (AIConfigRuntime, ModelParserRegistry)
+
+def register_model_parsers() -> None:
+    """Register model parsers for HuggingFace models.
+    """
+    # Audio --> Text
+    # AIConfigRuntime.register_model_parser(HuggingFaceAutomaticSpeechRecognitionTransformer(), "AutomaticSpeechRecognition")
+
+    # # Image --> Text
+    # AIConfigRuntime.register_model_parser(HuggingFaceImage2TextTransformer(), "Image2Text")
+
+    # # Text --> Image
+    # AIConfigRuntime.register_model_parser(HuggingFaceText2ImageDiffusor(), "Text2Image")
+
+    # # Text --> Audio
+    # AIConfigRuntime.register_model_parser(HuggingFaceText2SpeechTransformer(), "Text2Speech")
+
+    # # Text --> Text
+    # AIConfigRuntime.register_model_parser(HuggingFaceTextGenerationTransformer(), "TextGeneration")
+    # AIConfigRuntime.register_model_parser(HuggingFaceTextSummarizationTransformer(), "TextSummarization")
+    # ModelParserRegistry.register_model_parser(HuggingFaceText2SpeechTransformer())
+    # ModelParserRegistry.register_model_parser(HuggingFaceTextGenerationTransformer())
+    ModelParserRegistry.register_model_parser(HuggingFaceImage2TextTransformer())
+    
+    # ModelParserRegistry.register_model_parser(HuggingFaceAutomaticSpeechRecognitionTransformer())
+    # ModelParserRegistry.register_model_parser(HuggingFaceTextSummarizationTransformer())
+    # ModelParserRegistry.register_model_parser(HuggingFaceText2ImageDiffusor())
+    # ModelParserRegistry.register_model_parser(HuggingFaceTextTranslationTransformer())
+    # AIConfigRuntime.register_model_parser(HuggingFaceTextTranslationTransformer(), "TextTranslation")
diff --git a/cookbooks/Gradio/huggingface.aiconfig.json b/cookbooks/Gradio/huggingface.aiconfig.json
index 2ab54cc38..9c2366d5c 100644
--- a/cookbooks/Gradio/huggingface.aiconfig.json
+++ b/cookbooks/Gradio/huggingface.aiconfig.json
@@ -1,19 +1,73 @@
 {
-  "name": "",
+  "name": "The Tale of the Quick Brown Fox",
   "schema_version": "latest",
   "metadata": {
     "parameters": {},
-    "models": {}
+    "models": {
+      "Salesforce/blip-image-captioning-base": {}
+    },
+    "default_model": "Salesforce/blip-image-captioning-base",
+    "model_parsers": {
+      "Salesforce/blip-image-captioning-base": "HuggingFaceImage2TextTransformer"
+    }
   },
-  "description": "",
+  "description": "The Tale of the Quick Brown Fox",
   "prompts": [
     {
-      "name": "prompt_1",
-      "input": "",
+      "name": "prompt_2",
+      "input": {
+        "attachments": [
+          {
+            "data": "/Users/rossdancraig/Downloads/fox_in_forest.png",
+            "mime_type": "image/png"
+          },
+          {
+            "data": "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",
+            "mime_type": "image/png"
+          }
+        ]
+      },
       "metadata": {
-        "model": "gpt-4",
+        "model": {
+          "name": "Salesforce/blip-image-captioning-base",
+          "settings": {
+            "max_new_tokens": 500
+          }
+        },
         "parameters": {}
       },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "execution_count": 0,
+          "data": "a red fox in the woods",
+          "metadata": {}
+        },
+        {
+          "output_type": "execute_result",
+          "execution_count": 1,
+          "data": "a bear sitting on a rock eating honey",
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "name": "Generate a caption based on this image",
+      "input": "Once upon a time, in the booming metropolis of Santa Cruz",
+      "metadata": {
+        "model": {
+          "name": "Salesforce/blip-image-captioning-base",
+          "settings": {
+            "max_length": 100,
+            "min_length": 50,
+            "num_beams": 1,
+            "stream": false
+          }
+        },
+        "parameters": {
+          "city": "New York"
+        }
+      },
       "outputs": []
     }
   ],
diff --git a/python/src/aiconfig/editor/server/server.py b/python/src/aiconfig/editor/server/server.py
index 9c257804a..3d54ece4a 100644
--- a/python/src/aiconfig/editor/server/server.py
+++ b/python/src/aiconfig/editor/server/server.py
@@ -293,9 +293,9 @@ def kill_thread(thread_id: int | None):
 
             # Yea I know time.sleep() isn't super accurate, but it's fine,
             # we can fix later
-            time.sleep(0.1)
+            # time.sleep(0.1)
             wait_time_in_seconds += SLEEP_DELAY_SECONDS
-            print(f"Output queue is currently empty. Waiting for {wait_time_in_seconds:.1f}s...")
+            # print(f"Output queue is currently empty. Waiting for {wait_time_in_seconds:.1f}s...")
 
         # Yield in flask is weird and you either need to send responses as a
         # string, or artificially wrap them around "[" and "]"