feat: parameterized models

CHANGELOG.md

@@ -6,6 +6,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [0.1.1] - 2024-05-18
+
+- Parameterized models, now is possible to make use of new OpenAI models like gpt-4o
+
 ## [0.1.0] - 2024-04-09
 
 - First commit

README.md

@@ -133,7 +133,21 @@ license: cc-by-nd-4.0
 
 <img src="./docs/images/header.png" alt="LingAIcoach" width="1000" style="display: block; margin: 0 auto"/>
 
-Yo can access to the App through: [LinguAIcoach Web](https://linguaicoach.streamlit.app/)
+You can access to the App through Streamlit share: [LinguAIcoach Web](https://linguaicoach.streamlit.app/) or through Huggingface Spaces: [LinguAIcoach](https://huggingface.co/spaces/alvaroalon2/linguAIcoach)
+
+## Table of Contents
+
+- [Recent Activities](#recent-activities)
+- [Description](#description)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [License](#license)
+- [Authors](#authors)
+- [Next Steps](#next-steps)
+
+## Recent Activities
+- Parameterized models, now is possible to make use of new OpenAI models like gpt-4o.
 
 ## Description
 LinguAIcoach is a project that helps to improve your English with the assistance of AI. It provides tools for practicing, testing, and learning English using AI chatbots and other language processing technologies. The LinguAIcoach project utilizes DALL-E, GPT-4V, Whisper and GPT models to enhance English language learning in a multimodal way. The project offers a variety of exercises to enhance your English skills. The exercises cover different types of exams.

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "LinguAIcoach"
-version = "0.1.0"
+version = "0.1.1"
 description = "Help to improve your English with AI"
 authors = ["alvaroalon2"]
 readme = "README.md"

src/config.json

@@ -3,5 +3,18 @@
     "N_MAX_RETRY": 3,
     "OPENAI_TEMPERATURE_GEN": 0.8,
     "OPENAI_TEMPERATURE_EVAL": 0.3,
-    "IMG_GEN_SIZE": "256x256"
+    "IMG_PROMPT_TEMPERATURE": 0.3,
+    "IMG_GEN_SIZE": "256x256",
+    "EVALUATION_MODEL": {
+        "img_desc": {
+            "temperature": 0.3,
+            "model": "gpt-4o"
+        },
+        "qa": {
+            "temperature": 0.3,
+            "model": "gpt-4o"
+        }
+    },
+    "MODEL_TEXT_GEN": "gpt-4o",
+    "MODEL_IMG_PROMPT": "gpt-4o"
 }

src/main.py

@@ -80,11 +80,16 @@ if not st.session_state.openai_api_key:
     st.info("Please add your OpenAI API key to continue.")
     st.stop()
 
+eval_model = config["EVALUATION_MODEL"][st.session_state["exam_type"]]["model"]
+eval_temperature = config["EVALUATION_MODEL"][st.session_state["exam_type"]]["temperature"]
+
 model_eval = model_factory.create_model(
     model_class=st.session_state["exam_type"],
     openai_api_key=st.session_state.openai_api_key,
     level=level,
     chat_temperature=config["OPENAI_TEMPERATURE_EVAL"],
+    eval_model=eval_model,
+    eval_temperature=eval_temperature,
 )
 
 generator = gen_factory.create_model(
@@ -94,6 +99,10 @@ generator = gen_factory.create_model(
     level=level,
     description=exam_desc,
     chat_temperature=config["OPENAI_TEMPERATURE_GEN"],
+    n_messages_memory=config["N_MAX_HISTORY"],
+    chat_model=config["MODEL_TEXT_GEN"],
+    prompt_model=config["MODEL_IMG_PROMPT"],
+    prompt_model_temperature=config["IMG_PROMPT_TEMPERATURE"],
     history_chat=[
         AIMessage(content=f"Previous question (Don't repeat): {q.content}")
         for q in st.session_state["question"][-config["N_MAX_HISTORY"] :]

src/models/{lc_base_model.py → base/base_model.py}

@@ -10,11 +10,28 @@ from langchain_openai import ChatOpenAI
 
 class ChainGenerator(ABC):
 
-    def __init__(self, openai_api_key: SecretStr, chat_temperature: float = 0.3) -> None:
+    def __init__(
+        self,
+        openai_api_key: SecretStr,
+        chat_temperature: float = 0.3,
+        chat_model: str = "gpt-3.5-turbo",
+    ) -> None:
+        """
+        Initializes the class with the given parameters.
+
+        Args:
+            openai_api_key (SecretStr): The API key for OpenAI.
+            chat_temperature (float, optional): The temperature to use for chat. Defaults to 0.3.
+            chat_model (str, optional): The model to use for chat. Defaults to "gpt-3.5-turbo".
+
+        Returns:
+            None
+
+        """
         self.openai_api_key = openai_api_key
         self.chat_temperature = chat_temperature
 
-        self._initialize_chat_llm()
+        self._initialize_chat_llm(chat_model)
 
     @abstractmethod
     def _get_system_prompt(self) -> ChatPromptTemplate:
@@ -32,12 +49,12 @@ class ChainGenerator(ABC):
             RunnableSequence: Chain.
         """
 
-    def _initialize_chat_llm(self) -> None:
+    def _initialize_chat_llm(self, chat_model: str) -> None:
         """Initializes the ChatOpenAI language model."""
         self.chat_llm = ChatOpenAI(
             api_key=self.openai_api_key,
             temperature=self.chat_temperature,
-            model="gpt-3.5-turbo-1106",
+            model=chat_model,
         )
 
 
@@ -49,6 +66,11 @@ class EvaluationChatModel(ChainGenerator):
 
         Args:
             level (str): Level of the exam.
+            openai_api_key (SecretStr): OpenAI API key.
+            chat_temperature (float): Temperature for the chat model.
+
+        Returns:
+            None
         """
         super().__init__(openai_api_key=openai_api_key, chat_temperature=chat_temperature)
         self.level = level

src/models/{lc_img_desc_model.py → evaluator/img_evaluator.py}

@@ -6,10 +6,9 @@ from langchain.schema import HumanMessage
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.pydantic_v1 import BaseModel, Field, SecretStr
 from langchain_openai import ChatOpenAI
+from src.models.evaluator.text_evaluator import EvaluationChatModelQA
 from typing_extensions import override
 
-from src.models.lc_qa_model import EvaluationChatModelQA
-
 
 class EvaluationChatModelImg(EvaluationChatModelQA):
 
@@ -29,8 +28,30 @@ class EvaluationChatModelImg(EvaluationChatModelQA):
             description="Example of a response based on the AI image description following the given guidelines (just if there is)",
         )
 
-    def __init__(self, level: str, openai_api_key: SecretStr, chat_temperature: float = 0.3) -> None:
-        self.gpt4v = ChatOpenAI(temperature=0.3, model="gpt-4-vision-preview", max_tokens=1024, api_key=openai_api_key)
+    def __init__(
+        self,
+        eval_model: str,
+        level: str,
+        openai_api_key: SecretStr,
+        chat_temperature: float = 0.3,
+        eval_temperature: float = 0.3,
+    ) -> None:
+        """
+        Initializes the class with the given parameters.
+
+        Args:
+            eval_model (str): The vision model to use for image description.
+            level (str): The level of the exam.
+            openai_api_key (SecretStr): The API key for OpenAI.
+            chat_temperature (float, optional): The temperature to use for chat. Defaults to 0.3.
+            eval_temperature (float, optional): The temperature to use for image model. Defaults to 0.3.
+
+        Returns:
+            None
+        """
+        self.vision_model = ChatOpenAI(
+            temperature=eval_temperature, model=eval_model, max_tokens=1024, api_key=openai_api_key
+        )
         super().__init__(level, openai_api_key=openai_api_key, chat_temperature=chat_temperature)
 
     def _get_system_prompt(self) -> ChatPromptTemplate:
@@ -74,7 +95,7 @@ class EvaluationChatModelImg(EvaluationChatModelQA):
 
         multi_chain_dict.update(
             {
-                "ai_img_desc": itemgetter("image_url") | self.gpt4v | StrOutputParser(),
+                "ai_img_desc": itemgetter("image_url") | self.vision_model | StrOutputParser(),
                 "base_response": itemgetter("base_response"),
             }
         )
@@ -93,7 +114,7 @@ class EvaluationChatModelImg(EvaluationChatModelQA):
             Dict: The output of the prediction.
         """
         input_model = self.Input(user_desc=user_desc, image_url=image_url)
-        gpt4v_input = [
+        vision_model_input = [
             HumanMessage(
                 content=[
                     {"type": "text", "text": "What is this image showing?"},
@@ -105,6 +126,6 @@ class EvaluationChatModelImg(EvaluationChatModelQA):
             )
         ]
         result = self.chain.invoke(
-            {"base_response": input_model.user_desc, "image_url": gpt4v_input}, config=self.config
+            {"base_response": input_model.user_desc, "image_url": vision_model_input}, config=self.config
         )
         return result.dict(by_alias=True)

src/models/{lc_qa_model.py → evaluator/text_evaluator.py}

@@ -9,8 +9,7 @@ from langchain.prompts import ChatPromptTemplate, PromptTemplate
 from langchain_core.pydantic_v1 import BaseModel, Field, SecretStr
 from langchain_core.runnables import Runnable, RunnableConfig
 from langchain_openai import ChatOpenAI
-
-from src.models.lc_base_model import EvaluationChatModel
+from src.models.base.base_model import EvaluationChatModel
 
 logger = logging.getLogger(__name__)
 
@@ -60,7 +59,14 @@ class EvaluationChatModelQA(EvaluationChatModel):
             default="",
         )
 
-    def __init__(self, level: str, openai_api_key: SecretStr, chat_temperature: float = 0.3) -> None:
+    def __init__(
+        self,
+        level: str,
+        openai_api_key: SecretStr,
+        eval_model: str = "gpt-3.5-turbo",
+        chat_temperature: float = 0.3,
+        eval_temperature: float = 0.3,
+    ) -> None:
         """
         Initializes the class with the given parameters.
 
@@ -68,13 +74,16 @@ class EvaluationChatModelQA(EvaluationChatModel):
             exam_prompt (str): The prompt for the exam.
             level (str): The level of the exam.
             openai_api_key (SecretStr): The API key for OpenAI.
+            eval_model (str, optional): The model to use for evaluation. Defaults to "gpt-3.5-turbo".
+            chat_temperature (float, optional): The temperature to use for chat. Defaults to 0.3.
+            eval_temperature (float, optional): The temperature to use for evaluation. Defaults to 0.3.
 
         Returns:
             None
         """
         super().__init__(level=level, openai_api_key=openai_api_key, chat_temperature=chat_temperature)
 
-        self.checker_llm = ChatOpenAI(api_key=self.openai_api_key, temperature=0, model="gpt-3.5-turbo")
+        self.checker_llm = ChatOpenAI(api_key=self.openai_api_key, temperature=eval_temperature, model=eval_model)
         self.prompt = self._get_system_prompt()
 
         self.chain = self._create_chain()

src/models/gen/img_generator.py

@@ -0,0 +1,98 @@
+from typing import Any
+
+from langchain.prompts import ChatPromptTemplate, PromptTemplate
+from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.pydantic_v1 import SecretStr
+from langchain_core.runnables import Runnable
+from langchain_openai import ChatOpenAI
+from src.models.base.base_model import ContentGenerator
+
+
+class ImgGenerator(ContentGenerator):
+
+    def __init__(  # noqa: PLR0913
+        self,
+        exam_prompt: str,
+        level: str,
+        description: str,
+        openai_api_key: SecretStr,
+        chat_model: str = "gpt-3.5-turbo",
+        prompt_model: str = "gpt-3.5-turbo",
+        chat_temperature: float = 0.3,
+        prompt_model_temperature: float = 0.3,
+        img_size: str = "256x256",
+    ) -> None:
+        """
+        Initializes the class with the exam prompt, level, description, OpenAI API key, and optional image size.
+
+        Parameters:
+            exam_prompt (str): The prompt for the exam.
+            level (str): The level of the exam.
+            description (str): Description of the exam.
+            openai_api_key (SecretStr): The OpenAI API key.
+            chat_model (str, optional): The model to use for chat. Defaults to "gpt-3.5-turbo".
+            prompt_model (str, optional): The model to use for prompting img. Defaults to "gpt-3.5-turbo".
+            chat_temperature (float, optional): The temperature to use for chat. Defaults to 0.3.
+            prompt_model_temperature (float, optional): The temperature to use for prompting img. Defaults to 0.3.
+            img_size (str, optional): The size of the image. Default is "256x256".
+
+        Returns:
+            None
+        """
+        super().__init__(openai_api_key, chat_temperature, chat_model)
+        self.level = level
+        self.exam_prompt = exam_prompt
+        self.description = description
+        self.dalle = DallEAPIWrapper(
+            size=img_size, api_key=self.openai_api_key.get_secret_value()
+        )  # type: ignore[call-arg]
+        self.img_prompt_model = ChatOpenAI(
+            model=prompt_model, temperature=prompt_model_temperature, api_key=self.openai_api_key
+        )
+        self.chain = self._create_chain()
+
+    def _get_system_prompt(self) -> ChatPromptTemplate:
+
+        return ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    f"""You will generate a short image description (one paragraph max)
+                        which will be later used for generating an image taking into
+                        account that this images will be used for evaluating the
+                        user how well can describe this image in the context of
+                        an {self.level} Speaking English exam.
+
+                        {self.description}
+
+                        Topics about image descriptions which can appear:
+                        {self.exam_prompt}
+                        """,
+                ),
+                ("human", "{base_input}"),
+            ]
+        )
+
+    def _create_chain(self) -> Runnable[Any, Any]:
+
+        img_prompt = PromptTemplate(
+            input_variables=["image_desc"],
+            template="""You will now act as a prompt generator. I will describe an image to you, and you will create a prompt
+            that could be used for image-generation. The style must be realistic:
+            Description: {image_desc}""",
+        )
+
+        return (
+            {"image_desc": self._get_system_prompt() | self.chat_llm | StrOutputParser()}
+            | img_prompt
+            | self.img_prompt_model
+            | StrOutputParser()
+        )
+
+    def generate(self) -> str:
+        """
+        Generate function to create and return an image URL based on input parameters.
+        """
+        img_url = self.dalle.run(self.chain.invoke({"base_input": "Generate image description"})[:999])
+        return img_url

src/models/{generator.py → gen/text_generator.py}

@@ -3,18 +3,16 @@ from typing import Any, List, Type
 
 from langchain.memory import ChatMessageHistory, ConversationBufferWindowMemory
 from langchain.output_parsers import PydanticOutputParser
-from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, PromptTemplate
-from langchain.schema import AIMessage, HumanMessage
-from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.schema import BaseMessage
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.pydantic_v1 import BaseModel, Field, SecretStr
 from langchain_core.runnables import Runnable, RunnableLambda, RunnablePassthrough
-from langchain_openai import OpenAI
-
-from src.models.lc_base_model import ContentGenerator
+from src.models.base.base_model import ContentGenerator
 
 
 class QuestionGenerator(ContentGenerator):
+
     class Question(BaseModel):
         question: str = Field(alias="Question", description="A question based on the given guidelines")
 
@@ -23,9 +21,11 @@ class QuestionGenerator(ContentGenerator):
         exam_prompt: str,
         level: str,
         description: str,
-        history_chat: List[HumanMessage | AIMessage],
+        history_chat: List[BaseMessage],
         openai_api_key: SecretStr,
         chat_temperature: float = 0.3,
+        n_messages_memory: int = 20,
+        chat_model: str = "gpt-3.5-turbo",
     ) -> None:
         """
         Initializes the object with the given exam prompt, level, description, history chat, and OpenAI API key.
@@ -36,16 +36,18 @@ class QuestionGenerator(ContentGenerator):
             description (str): The description of the exam.
             history_chat (List[HumanMessage | AIMessage]): List of chat messages from history.
             openai_api_key (SecretStr): The API key for OpenAI.
+            chat_temperature (float, optional): The temperature to use for chat. Defaults to 0.3.
+            n_messages_memory (int, optional): The number of messages to keep in memory. Defaults to 20.
 
         Returns:
             None
         """
-        super().__init__(openai_api_key=openai_api_key, chat_temperature=chat_temperature)
+        super().__init__(openai_api_key=openai_api_key, chat_temperature=chat_temperature, chat_model=chat_model)
         self.level = level
         self.exam_prompt = exam_prompt
         self.description = description
         self.memory = ConversationBufferWindowMemory(
-            chat_memory=ChatMessageHistory(messages=history_chat), return_messages=True, k=20
+            chat_memory=ChatMessageHistory(messages=history_chat), return_messages=True, k=n_messages_memory
         )
         self.chain = self._create_chain()
 
@@ -126,80 +128,3 @@ class QuestionGenerator(ContentGenerator):
         self.memory.chat_memory.add_ai_message(response)
 
         return response
-
-
-class ImgGenerator(ContentGenerator):
-
-    def __init__(
-        self,
-        exam_prompt: str,
-        level: str,
-        description: str,
-        openai_api_key: SecretStr,
-        chat_temperature: float = 0.3,
-        img_size: str = "256x256",
-    ) -> None:
-        """
-        Initializes the class with the exam prompt, level, description, OpenAI API key, and optional image size.
-
-        Parameters:
-            exam_prompt (str): The prompt for the exam.
-            level (str): The level of the exam.
-            description (str): Description of the exam.
-            openai_api_key (SecretStr): The OpenAI API key.
-            img_size (str, optional): The size of the image. Default is "256x256".
-
-        Returns:
-            None
-        """
-        super().__init__(openai_api_key, chat_temperature)
-        self.level = level
-        self.exam_prompt = exam_prompt
-        self.description = description
-        self.dalle = DallEAPIWrapper(size=img_size, api_key=self.openai_api_key.get_secret_value())  # type: ignore[call-arg]
-        self.chain = self._create_chain()
-
-    def _get_system_prompt(self) -> ChatPromptTemplate:
-
-        return ChatPromptTemplate.from_messages(
-            [
-                (
-                    "system",
-                    f"""You will generate a short image description (one paragraph max)
-                        which will be later used for generating an image taking into
-                        account that this images will be used for evaluating the
-                        user how well can describe this image in the context of
-                        an {self.level} Speaking English exam.
-
-                        {self.description}
-
-                        Topics about image descriptions which can appear:
-                        {self.exam_prompt}
-                        """,
-                ),
-                ("human", "{base_input}"),
-            ]
-        )
-
-    def _create_chain(self) -> Runnable[Any, Any]:
-
-        img_prompt = PromptTemplate(
-            input_variables=["image_desc"],
-            template="""You will now act as a prompt generator. I will describe an image to you, and you will create a prompt
-            that could be used for image-generation. The style must be realistic:
-            Description: {image_desc}""",
-        )
-
-        return (
-            {"image_desc": self._get_system_prompt() | self.chat_llm | StrOutputParser()}
-            | img_prompt
-            | OpenAI(temperature=0.7, api_key=self.openai_api_key)
-            | StrOutputParser()
-        )
-
-    def generate(self) -> str:
-        """
-        Generate function to create and return an image URL based on input parameters.
-        """
-        img_url = self.dalle.run(self.chain.invoke({"base_input": "Generate image description"})[:999])
-        return img_url

src/models/model_factory.py

@@ -1,13 +1,14 @@
 from abc import ABC, abstractmethod
 from typing import Any, List, Optional
 
-from langchain.schema import AIMessage, HumanMessage
+from langchain.schema import BaseMessage
 from langchain_core.pydantic_v1 import SecretStr
 
-from src.models.generator import ImgGenerator, QuestionGenerator
-from src.models.lc_base_model import ChainGenerator, ContentGenerator, EvaluationChatModel
-from src.models.lc_img_desc_model import EvaluationChatModelImg
-from src.models.lc_qa_model import EvaluationChatModelQA
+from src.models.base.base_model import ChainGenerator, ContentGenerator, EvaluationChatModel
+from src.models.evaluator.img_evaluator import EvaluationChatModelImg
+from src.models.evaluator.text_evaluator import EvaluationChatModelQA
+from src.models.gen.img_generator import ImgGenerator
+from src.models.gen.text_generator import QuestionGenerator
 
 
 class ModelFactory(ABC):
@@ -21,7 +22,12 @@ class ModelFactory(ABC):
 
 class EvaluationChatModelFactory(ModelFactory):
 
-    def create_model(self, model_class: str, openai_api_key: SecretStr, **kwargs: Any) -> EvaluationChatModel:
+    def create_model(
+        self,
+        model_class: str,
+        openai_api_key: SecretStr,
+        **kwargs: Any,
+    ) -> EvaluationChatModel:
         """
         Create a model based on the provided model class and OpenAI API key.
 
@@ -38,9 +44,15 @@ class EvaluationChatModelFactory(ModelFactory):
         """
         match model_class:
             case "qa":
-                return EvaluationChatModelQA(openai_api_key=openai_api_key, **kwargs)
+                return EvaluationChatModelQA(
+                    openai_api_key=openai_api_key,
+                    **kwargs,
+                )
             case "img_desc":
-                return EvaluationChatModelImg(openai_api_key=openai_api_key, **kwargs)
+                return EvaluationChatModelImg(
+                    openai_api_key=openai_api_key,
+                    **kwargs,
+                )
             case _:
                 raise ValueError("Invalid model class provided")
 
@@ -51,7 +63,10 @@ class GeneratorModelFactory(ModelFactory):
         self,
         model_class: str,
         openai_api_key: SecretStr,
-        history_chat: Optional[List[HumanMessage | AIMessage]] = None,
+        history_chat: Optional[List[BaseMessage]] = None,
+        n_messages_memory: int = 20,
+        prompt_model: str = "gpt-3.5-turbo",
+        prompt_model_temperature: float = 0.3,
         img_size: str = "256x256",
         **kwargs: Any,
     ) -> ContentGenerator:
@@ -62,6 +77,9 @@ class GeneratorModelFactory(ModelFactory):
             model_class (str): The class of the model to create.
             openai_api_key (SecretStr): The API key for OpenAI.
             history_chat (Optional[list], optional): List of chat history. Defaults to None.
+            n_messages_memory (int, optional): Number of messages to keep in memory. Defaults to 20.
+            prompt_model (str, optional): The prompt model. Defaults to "gpt-3.5-turbo".
+            prompt_model_temperature (float, optional): The prompt model temperature. Defaults to 0.3.
             img_size (str, optional): The size of the image. Defaults to "256x256".
             **kwargs (Any): Additional keyword arguments.
 
@@ -70,8 +88,19 @@ class GeneratorModelFactory(ModelFactory):
         """
         match model_class:
             case "qa":
-                return QuestionGenerator(openai_api_key=openai_api_key, history_chat=history_chat or [], **kwargs)
+                return QuestionGenerator(
+                    openai_api_key=openai_api_key,
+                    history_chat=history_chat or [],
+                    n_messages_memory=n_messages_memory,
+                    **kwargs,
+                )
             case "img_desc":
-                return ImgGenerator(openai_api_key=openai_api_key, img_size=img_size, **kwargs)
+                return ImgGenerator(
+                    openai_api_key=openai_api_key,
+                    prompt_model=prompt_model,
+                    prompt_model_temperature=prompt_model_temperature,
+                    img_size=img_size,
+                    **kwargs,
+                )
             case _:
                 raise ValueError("Invalid model class provided")