llm-human-feedback-collector-chat-interface-dpo

Sleeping

App Files Files Community

davidberenstein1957 HF staff commited on Jul 25

Commit

a38b23a

•

1 Parent(s): 7c45d36

Update error message duplicate mistakes

Browse files

Files changed (3) hide show

README.md +1 -1
app.py +8 -4
chat_interface_preference.py +87 -77

README.md CHANGED Viewed

@@ -4,7 +4,7 @@ emoji: 🦾💪🏽
 colorFrom: pink
 colorTo: blue
 sdk: gradio
-sdk_version: 4.36.1
 app_file: app.py
 pinned: true
 license: mit

 colorFrom: pink
 colorTo: blue
 sdk: gradio
+sdk_version: 4.39
 app_file: app.py
 pinned: true
 license: mit

app.py CHANGED Viewed

@@ -1,13 +1,17 @@
 #!/usr/bin/env python
 import os
 import random
-from threading import Thread
 from typing import Iterator
 import gradio as gr
 import spaces
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
 from chat_interface_preference import ChatInterface
@@ -118,7 +122,7 @@ chat_interface = ChatInterface(
     title="💪🏽🦾 Human Feedback Collector | Meta-Llama-3.1-8B-Instruct | (DPO) 🦾💪🏽",
     description="".join(
         [
-            "This is an adaptation of the [`gr.ChatInferface`](https://www.gradio.app/docs/gradio/chatinterface) and [`huggingface_hub.CommitScheduler`](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/hf_api#huggingface_hub.CommitScheduler) which allows for human feedback collection. ",
             "Another cool tool for capturing Gradio interactions is the [`gr.HuggingFaceDatasetSaver`](https://www.gradio.app/guides/using-flagging#the-hugging-face-dataset-saver-callback). ",
             "This demo shows how you might capture human feedback directly from applications within Gradio. ",
             "The captured feedback can directly be used for fine-tuning LLMs within framework like [transformers](https://github.com/huggingface/transformers), [TRL](https://github.com/huggingface/trl) or [AutoTrain](https://huggingface.co/autotrain), ",

 #!/usr/bin/env python
 import os
 import random
+from threading import Thread  # noqa
 from typing import Iterator
 import gradio as gr
 import spaces
+import torch  # noqa
+from transformers import (
+    AutoModelForCausalLM,  # noqa
+    AutoTokenizer,  # noqa
+    TextIteratorStreamer,  # noqa
+)
 from chat_interface_preference import ChatInterface
     title="💪🏽🦾 Human Feedback Collector | Meta-Llama-3.1-8B-Instruct | (DPO) 🦾💪🏽",
     description="".join(
         [
+            "This is an adaptation of the [`gr.ChatInferface`](https://www.gradio.app/docs/gradio/chatinterface) which also uses the [`huggingface_hub.CommitScheduler`](https://huggingface.co/docs/huggingface_hub/main/en/package_reference/hf_api#huggingface_hub.CommitScheduler) to allow for human feedback collection. ",
             "Another cool tool for capturing Gradio interactions is the [`gr.HuggingFaceDatasetSaver`](https://www.gradio.app/guides/using-flagging#the-hugging-face-dataset-saver-callback). ",
             "This demo shows how you might capture human feedback directly from applications within Gradio. ",
             "The captured feedback can directly be used for fine-tuning LLMs within framework like [transformers](https://github.com/huggingface/transformers), [TRL](https://github.com/huggingface/trl) or [AutoTrain](https://huggingface.co/autotrain), ",

chat_interface_preference.py CHANGED Viewed

@@ -607,7 +607,7 @@ class ChatInterface(Blocks):
             if turn[-1]:
                 conversation += self._get_chat_message(turn[-1], role="user", turn=(idx + 1))
-        return "<body>" + self.css + conversation + "</body>"
     def _get_conversation_in_openai_format(self, history):
         conversation = []
@@ -644,6 +644,7 @@ class ChatInterface(Blocks):
     @staticmethod
     def _check_if_two_responses(response):
         if response:
             matches = pattern.findall(response)
             return matches
@@ -683,30 +684,34 @@ class ChatInterface(Blocks):
         self._check_message(message)
         self._check_num_turns(history)
-        _, response = history_with_input[-1]
         if self._check_if_two_responses(response):
-            raise Error("Two options detected: undo, log or random pick continuation.")
-        inputs, _, _ = special_args(self.fn, inputs=[message, history, *args], request=request)
-        async def _get_response():
-            if self.is_async:
-                response = await self.fn(*inputs)
             else:
-                response = await anyio.to_thread.run_sync(self.fn, *inputs, limiter=self.limiter)
-            return response
-        if n_generations == 1:
-            response = await _get_response()
-        else:
-            response_one, response_two = await _get_response(), await _get_response()
-            response = self._get_chat_message_comparison(response_one, response_two)
-        if self.multimodal and isinstance(message, dict):
-            self._append_multimodal_history(message, response, history)
-        elif isinstance(message, str):
-            history.append([message, response])
-        return history, history
     async def _stream_fn(
         self,
@@ -723,67 +728,35 @@ class ChatInterface(Blocks):
             history = history_with_input[:-1]
         self._check_message(message)
         self._check_num_turns(history)
-        _, response = history_with_input[-1]
-        if self._check_if_two_responses(response):
-            raise Error("Two options detected: undo, log or random pick continuation.")
-        inputs, _, _ = special_args(self.fn, inputs=[message, history, *args], request=request)
-        try:
-            if self.is_async:
-                generator = self.fn(*inputs)
-            else:
-                generator = await anyio.to_thread.run_sync(self.fn, *inputs, limiter=self.limiter)
-            generator = SyncToAsyncIterator(generator, self.limiter)
-            first_response = await async_iteration(generator)
-            if n_generations == 2:
-                first_response_formatted = self._get_chat_message_comparison(first_response, "")
-            else:
-                first_response_formatted = first_response
-            if self.multimodal and isinstance(message, dict):
-                for x in message["files"]:
-                    history.append([(x,), None])
-                update = history + [[message["text"], first_response_formatted]]
-                yield update, update
-            else:
-                update = history + [[message, first_response_formatted]]
-                yield update, update
-        except StopIteration:
-            if self.multimodal and isinstance(message, dict):
-                self._append_multimodal_history(message, None, history)
-                yield history, history
-            else:
-                update = history + [[message, None]]
-                yield update, update
-        async for response in generator:
-            if n_generations == 2:
-                response_formatted = self._get_chat_message_comparison(response, "")
-            else:
-                response_formatted = response
-            if self.multimodal and isinstance(message, dict):
-                update = history + [[message["text"], response_formatted]]
-                yield update, update
-            else:
-                update = history + [[message, response_formatted]]
-                yield update, update
-        if n_generations == 2:
-            if self.is_async:
-                generator_two = self.fn(*inputs)
-            else:
-                generator_two = await anyio.to_thread.run_sync(self.fn, *inputs, limiter=self.limiter)
-                generator_two = SyncToAsyncIterator(generator_two, self.limiter)
             try:
-                first_response_two = await async_iteration(generator_two)
-                first_response_two_formatted = self._get_chat_message_comparison(response, first_response_two)
                 if self.multimodal and isinstance(message, dict):
                     for x in message["files"]:
                         history.append([(x,), None])
-                    update = history + [[message["text"], first_response_two_formatted]]
                     yield update, update
                 else:
-                    update = history + [[message, first_response_two_formatted]]
                     yield update, update
             except StopIteration:
                 if self.multimodal and isinstance(message, dict):
@@ -792,15 +765,52 @@ class ChatInterface(Blocks):
                 else:
                     update = history + [[message, None]]
                     yield update, update
-            async for response_two in generator_two:
-                response_two = self._get_chat_message_comparison(response, response_two)
                 if self.multimodal and isinstance(message, dict):
-                    update = history + [[message["text"], response_two]]
                     yield update, update
                 else:
-                    update = history + [[message, response_two]]
                     yield update, update
     async def _log_fn(
         self, message: str | dict[str, list], history: list[list[str | tuple | None]], log: str
     ) -> tuple[

             if turn[-1]:
                 conversation += self._get_chat_message(turn[-1], role="user", turn=(idx + 1))
+        return "<body>" + conversation + "</body>"
     def _get_conversation_in_openai_format(self, history):
         conversation = []
     @staticmethod
     def _check_if_two_responses(response):
+        print(response)
         if response:
             matches = pattern.findall(response)
             return matches
         self._check_message(message)
         self._check_num_turns(history)
+        if history:
+            _, response = history[-1]
+        else:
+            response = None
         if self._check_if_two_responses(response):
+            Info("Two options detected: provide preference, undo or clear to continue conversation.")
+            return history, history
+        else:
+            inputs, _, _ = special_args(self.fn, inputs=[message, history, *args], request=request)
+            async def _get_response():
+                if self.is_async:
+                    response = await self.fn(*inputs)
+                else:
+                    response = await anyio.to_thread.run_sync(self.fn, *inputs, limiter=self.limiter)
+                return response
+            if n_generations == 1:
+                response = await _get_response()
             else:
+                response_one, response_two = await _get_response(), await _get_response()
+                response = self._get_chat_message_comparison(response_one, response_two)
+            if self.multimodal and isinstance(message, dict):
+                self._append_multimodal_history(message, response, history)
+            elif isinstance(message, str):
+                history.append([message, response])
+            return history, history
     async def _stream_fn(
         self,
             history = history_with_input[:-1]
         self._check_message(message)
         self._check_num_turns(history)
+        if history:
+            _, response = history[-1]
+        else:
+            response = None
+        if self._check_if_two_responses(response):
+            Info("Two options detected: provide preference, undo or clear to continue conversation.")
+            yield history, history
+        else:
+            inputs, _, _ = special_args(self.fn, inputs=[message, history, *args], request=request)
             try:
+                if self.is_async:
+                    generator = self.fn(*inputs)
+                else:
+                    generator = await anyio.to_thread.run_sync(self.fn, *inputs, limiter=self.limiter)
+                generator = SyncToAsyncIterator(generator, self.limiter)
+                first_response = await async_iteration(generator)
+                if n_generations == 2:
+                    first_response_formatted = self._get_chat_message_comparison(first_response, "")
+                else:
+                    first_response_formatted = first_response
                 if self.multimodal and isinstance(message, dict):
                     for x in message["files"]:
                         history.append([(x,), None])
+                    update = history + [[message["text"], first_response_formatted]]
                     yield update, update
                 else:
+                    update = history + [[message, first_response_formatted]]
                     yield update, update
             except StopIteration:
                 if self.multimodal and isinstance(message, dict):
                 else:
                     update = history + [[message, None]]
                     yield update, update
+            async for response in generator:
+                if n_generations == 2:
+                    response_formatted = self._get_chat_message_comparison(response, "")
+                else:
+                    response_formatted = response
                 if self.multimodal and isinstance(message, dict):
+                    update = history + [[message["text"], response_formatted]]
                     yield update, update
                 else:
+                    update = history + [[message, response_formatted]]
                     yield update, update
+            if n_generations == 2:
+                if self.is_async:
+                    generator_two = self.fn(*inputs)
+                else:
+                    generator_two = await anyio.to_thread.run_sync(self.fn, *inputs, limiter=self.limiter)
+                    generator_two = SyncToAsyncIterator(generator_two, self.limiter)
+                try:
+                    first_response_two = await async_iteration(generator_two)
+                    first_response_two_formatted = self._get_chat_message_comparison(response, first_response_two)
+                    if self.multimodal and isinstance(message, dict):
+                        for x in message["files"]:
+                            history.append([(x,), None])
+                        update = history + [[message["text"], first_response_two_formatted]]
+                        yield update, update
+                    else:
+                        update = history + [[message, first_response_two_formatted]]
+                        yield update, update
+                except StopIteration:
+                    if self.multimodal and isinstance(message, dict):
+                        self._append_multimodal_history(message, None, history)
+                        yield history, history
+                    else:
+                        update = history + [[message, None]]
+                        yield update, update
+                async for response_two in generator_two:
+                    response_two = self._get_chat_message_comparison(response, response_two)
+                    if self.multimodal and isinstance(message, dict):
+                        update = history + [[message["text"], response_two]]
+                        yield update, update
+                    else:
+                        update = history + [[message, response_two]]
+                        yield update, update
     async def _log_fn(
         self, message: str | dict[str, list], history: list[list[str | tuple | None]], log: str
     ) -> tuple[