crfm-helm 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

helm/clients/huggingface_pipeline_client.py

@@ -0,0 +1,138 @@
+from threading import Lock
+from typing import Any, Dict, List, Optional, Union
+
+import transformers
+
+from helm.clients.client import CachingClient
+from helm.common.cache import CacheConfig
+from helm.common.hierarchical_logger import htrack_block, hwarn
+from helm.common.request import GeneratedOutput, Request, RequestResult, wrap_request_time
+from helm.proxy.retry import NonRetriableException
+
+
+_pipelines: Dict[str, transformers.Pipeline] = {}
+_pipelines_lock: Lock = Lock()
+
+
+def _get_pipeline(
+    helm_model_name: str,
+    pipeline_kwargs: Dict[str, Any],
+) -> Any:
+    """
+    Checks if the desired HuggingFaceModel is cached. Creates the HuggingFaceModel if it's not cached.
+    Returns the HuggingFaceModel.
+    """
+    global _pipelines
+    global _pipelines_lock
+    with _pipelines_lock:
+        if helm_model_name not in _pipelines:
+            huggingface_model_name = pipeline_kwargs["model"]
+            with htrack_block(
+                f"Loading HuggingFace model {huggingface_model_name} (kwargs={pipeline_kwargs}) "
+                f"for HELM model {helm_model_name} with transformers.pipeline"
+            ):
+                _pipelines[helm_model_name] = transformers.pipeline(**pipeline_kwargs)
+
+    return _pipelines[helm_model_name]
+
+
+class HuggingFacePipelineClient(CachingClient):
+    def __init__(
+        self,
+        cache_config: CacheConfig,
+        model_name: str,
+        pretrained_model_name_or_path: Optional[str] = None,
+        apply_chat_template: Optional[bool] = None,
+        **kwargs,
+    ):
+        # Include `pretrained_model_name_or_path` parameter so that model deployments can use
+        # the `pretrained_model_name_or_path` arg to override `model_name`
+        super().__init__(cache_config=cache_config)
+        self._helm_model_name = model_name
+        self._pipeline_kwargs = {
+            "model": pretrained_model_name_or_path or self._helm_model_name,
+            "task": "text-generation",
+            **kwargs,
+        }
+        self._pipeline = _get_pipeline(self._helm_model_name, self._pipeline_kwargs)
+        if apply_chat_template is not None:
+            self._apply_chat_template = apply_chat_template
+        else:
+            # If the user did not explicitly configure whether the model is a chat model with `apply_chat_template` arg,
+            # auto-infer if the model is a chat model based on whether the tokenizer has a chat template.
+            # Note: Auto-inference is incorrect for some non-chat models that still have chat templates
+            # e.g. Qwen2, Qwen 2.5.
+            # For these models, the `apply_chat_template` arg should be explicitly set to false.
+            self._apply_chat_template = bool(self._pipeline.tokenizer.chat_template)
+            hwarn(
+                f"Automatically set `apply_chat_template` to {self._apply_chat_template} based on "
+                "whether the tokenizer has a chat template. "
+                "If this is incorrect, please explicitly set `apply_chat_template`."
+            )
+
+    def make_text_inputs(self, request: Request) -> Union[str, List[Dict[str, str]]]:
+        if request.prompt and request.messages:
+            raise NonRetriableException(f"More than one of `prompt` and `messages` was set in request: {request}")
+        # Chat model expects a list of messages as input
+        if self._apply_chat_template:
+            if request.messages:
+                return request.messages
+            else:
+                return [{"role": "user", "content": request.prompt}]
+        # Base non-chat model expects a string as input
+        else:
+            if request.messages:
+                raise NonRetriableException("Chat mesages not supported by non-chat model")
+            else:
+                return request.prompt
+
+    def make_request(self, request: Request) -> RequestResult:
+        """Make a request"""
+        if request.model != self._helm_model_name:
+            raise NonRetriableException(
+                f"This instance of HuggingFacePipelineClient has loaded model {self._helm_model_name} but the request was for model {request.model}"  # noqa: E501
+            )
+        completions: List[GeneratedOutput] = []
+        do_sample = request.temperature > 0.0
+        raw_request = {
+            "text_inputs": self.make_text_inputs(request),
+            "return_full_text": request.echo_prompt,
+            "temperature": request.temperature if do_sample else None,
+            "num_return_sequences": request.num_completions,
+            "max_new_tokens": request.max_tokens,
+            "top_p": request.top_p,
+            "top_k": request.top_k_per_token if do_sample else None,
+            "do_sample": do_sample,
+            "return_dict_in_generate": True,
+        }
+        if request.stop_sequences:
+            stop_sequence_ids = self._pipeline.tokenizer(
+                request.stop_sequences, return_token_type_ids=False, add_special_tokens=False
+            )
+            if len(stop_sequence_ids.input_ids) == 1 and len(stop_sequence_ids.input_ids[0]) == 1:
+                raw_request["eos_token_id"] = stop_sequence_ids.input_ids[0][0]
+            else:
+                raise NonRetriableException(
+                    "Multiple stop sequences and stop sequences of multiple tokens, are not yet supported by HuggingFacePipelineClient"  # noqa: E501
+                )
+
+        def do_it() -> Dict[str, Any]:
+            pipeline_outputs = self._pipeline(**raw_request)
+            return {"outputs": pipeline_outputs}
+
+        cache_key = CachingClient.make_cache_key(
+            {"pipeline_kwargs": self._pipeline_kwargs, **raw_request},
+            request,
+        )
+
+        response, cached = self.cache.get(cache_key, wrap_request_time(do_it))
+        for raw_output in response["outputs"]:
+            completions.append(GeneratedOutput(text=raw_output["generated_text"], logprob=0, tokens=[]))
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=response["request_time"],
+            request_datetime=response["request_datetime"],
+            completions=completions,
+            embedding=[],
+        )

helm/clients/ibm_client.py

@@ -0,0 +1,267 @@
+from abc import ABC
+from abc import abstractmethod
+
+from helm.common.hierarchical_logger import hlog
+from helm.common.cache import CacheConfig
+from helm.common.request import (
+    Request,
+    RequestResult,
+    Token,
+    wrap_request_time,
+    EMBEDDING_UNAVAILABLE_REQUEST_RESULT,
+    GeneratedOutput,
+)
+
+from helm.clients.client import CachingClient
+from helm.common.optional_dependencies import handle_module_not_found_error
+from typing import TypeVar, Generic
+from typing import Any, Dict, List
+from threading import Semaphore, Lock
+import threading
+
+try:
+    from ibm_watsonx_ai import Credentials
+    from ibm_watsonx_ai.foundation_models import ModelInference
+    from ibm_watsonx_ai.metanames import GenTextParamsMetaNames as GenParams
+    from ibm_watsonx_ai.foundation_models.schema import (
+        TextChatParameters,
+        TextGenParameters,
+        ReturnOptionProperties,
+    )
+
+except ModuleNotFoundError as e:
+    handle_module_not_found_error(e, ["ibm"])
+
+# Define the maximum number of parallel executions is limited by IBM API
+MAX_CONCURRENT_REQUESTS = 8
+__semaphores: Dict[str, Semaphore] = dict()
+__semaphores_lock = Lock()
+
+
+def _get_semaphore(model: str) -> Semaphore:
+    with __semaphores_lock:
+        if model not in __semaphores:
+            __semaphores[model] = threading.Semaphore(MAX_CONCURRENT_REQUESTS)
+
+    return __semaphores[model]
+
+
+T = TypeVar("T", TextGenParameters, TextChatParameters)
+
+
+class ModelInferenceHandler(ABC, Generic[T]):
+    @abstractmethod
+    def __init__(self, inference_engine: ModelInference):
+        """
+        :type inference_engine: object
+        """
+        self.inference_engine = inference_engine
+
+    @abstractmethod
+    def serve_request(self, prompt: str, params: T) -> Dict:
+        pass
+
+    @abstractmethod
+    def parse_response(self, response: dict) -> List[GeneratedOutput]:
+        pass
+
+    @abstractmethod
+    def create_params(self, request: Request) -> T:
+        pass
+
+
+class GenerateInferenceHandler(ModelInferenceHandler[TextGenParameters]):
+
+    def __init__(self, inference_engine: ModelInference):
+        self.inference_engine = inference_engine
+
+    def create_params(self, request: Request) -> TextGenParameters:
+        def set_temperature_requirements():
+            # Default temperature 0.05 required by ibm/granite-13b-instruct-v2
+            if self.inference_engine.model_id == "ibm/granite-13b-instruct-v2":
+                return 0.05
+            return 1e-7 if request.temperature == 0 else request.temperature
+
+        return TextGenParameters(
+            temperature=set_temperature_requirements(),
+            top_p=request.top_p,
+            max_new_tokens=request.max_tokens,
+            return_options=ReturnOptionProperties(
+                input_text=True,
+                generated_tokens=True,
+                input_tokens=False,
+                token_logprobs=True,
+                token_ranks=False,
+            ),
+            include_stop_sequence=False,
+            prompt_variables=None,
+        )
+
+    def serve_request(self, prompt: str, params: TextGenParameters) -> Dict:
+        semaphore = _get_semaphore(self.inference_engine.model_id)
+
+        with semaphore:
+            response = self.inference_engine.generate(
+                prompt=prompt,
+                params=params,
+            )
+        return response
+
+    def parse_response(self, response: dict) -> List[GeneratedOutput]:
+        completions = []
+        try:
+            for r in response["results"]:
+                sequence_logprob: float = 0
+                tokens: List[Token] = []
+                generated_text = r["generated_text"]
+                for token_and_logprob in r["generated_tokens"]:
+                    logprob = token_and_logprob.get("logprob", 0)
+                    text = token_and_logprob["text"]
+                    tokens.append(Token(text=text, logprob=logprob))
+                    sequence_logprob += logprob
+
+                completion = GeneratedOutput(text=generated_text, logprob=sequence_logprob, tokens=tokens)
+                completions.append(completion)
+        except Exception as e:
+            hlog(f"GenerateInferenceHandler failed with exception {e} during parse_response {response}")
+        return completions
+
+
+class ChatModelInferenceHandler(ModelInferenceHandler[TextChatParameters]):
+    def __init__(self, inference_engine: ModelInference):
+        self.inference_engine = inference_engine
+
+    def create_params(self, request: Request) -> TextChatParameters:
+        return TextChatParameters(
+            logprobs=True,
+            presence_penalty=0,
+            frequency_penalty=0,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens,
+            top_p=request.top_p,
+        )
+
+    def parse_response(self, response: dict) -> List[GeneratedOutput]:
+        completions = []
+        try:
+            for raw_completion in response["choices"]:
+                sequence_logprob: float = 0
+                tokens: List[Token] = []
+                generated_text = raw_completion["message"]["content"]
+
+                for token_and_logprob in raw_completion["logprobs"]["content"]:
+                    logprob = token_and_logprob["logprob"]
+                    text = token_and_logprob["token"]
+                    tokens.append(Token(text=text, logprob=logprob))
+                    sequence_logprob += logprob
+
+                completion = GeneratedOutput(text=generated_text, logprob=sequence_logprob, tokens=tokens)
+                completions.append(completion)
+        except Exception as e:
+            hlog(f"ChatModelInferenceHandler failed with exception {e} during parse_response {response}")
+        return completions
+
+    def serve_request(self, prompt: str, params: TextChatParameters) -> Dict:
+        semaphore = _get_semaphore(self.inference_engine.model_id)
+
+        with semaphore:
+            response = self.inference_engine.chat(
+                messages=[{"role": "user", "content": prompt}],
+                params=params,
+            )
+        return response
+
+
+class IbmClient(CachingClient, ABC):
+    def __init__(
+        self,
+        cache_config: CacheConfig,
+        api_key: str,
+        region: str,
+        location: dict,
+        watsonx_model_name: str,
+        **kwargs,
+    ):
+        super().__init__(cache_config=cache_config)
+        self.project_id = None
+        self.url = None
+        self.watsonx_model_name = watsonx_model_name
+        self.api_key = api_key
+        self.region = region
+        self.kwargs = kwargs
+        for entry in location:
+            if entry["region"].lower() == self.region.lower():
+                self.project_id = entry["project_id"]
+                self.url = entry["url"]
+
+        assert self.project_id is not None, (
+            "Missed project_id for specified region configuration in credentials.conf, should be in list "
+            "of JSON objects with 'region', 'url', 'project_id' per region"
+        )
+        assert self.url is not None, (
+            "Missed url for specified region configuration in credentials.conf, should be in list "
+            "of JSON objects with 'region', 'url', 'project_id' per region"
+        )
+
+        self.inference_engine = ModelInference(
+            model_id=self.watsonx_model_name,
+            params={GenParams.MAX_NEW_TOKENS: 2000},
+            credentials=Credentials(api_key=api_key, url=self.url),
+            project_id=self.project_id,
+        )
+
+        hlog("Started IBM Client")
+
+    @abstractmethod
+    def make_request(self, request: Request) -> RequestResult:
+        pass
+
+    def do_call(self, inference_handler: ModelInferenceHandler, request: Request) -> RequestResult:
+        params = inference_handler.create_params(request=request)
+
+        def do_it() -> Dict[str, Any]:
+            return inference_handler.serve_request(prompt=request.prompt, params=params)
+
+        raw_request = {"prompt": request.prompt, "params": params.to_dict(), "model": request.model}
+
+        cache_key = CachingClient.make_cache_key(raw_request, request)
+        response, cached = self.cache.get(cache_key, wrap_request_time(do_it))
+        completions = inference_handler.parse_response(response)
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=response["request_time"],
+            request_datetime=response.get("request_datetime"),
+            completions=completions,
+            embedding=[],
+        )
+
+
+class IbmChatClient(IbmClient):
+
+    def make_request(self, request: Request) -> RequestResult:
+        # Embedding not supported for this model
+        if request.embedding:
+            return EMBEDDING_UNAVAILABLE_REQUEST_RESULT
+        try:
+            return self.do_call(
+                inference_handler=ChatModelInferenceHandler(inference_engine=self.inference_engine), request=request
+            )
+
+        except Exception as e:
+            error: str = f"IBM Chat client Model error: {e}"
+            return RequestResult(success=False, cached=False, error=error, completions=[], embedding=[])
+
+
+class IbmTextClient(IbmClient):
+    def make_request(self, request: Request) -> RequestResult:
+        # Embedding not supported for this model
+        if request.embedding:
+            return EMBEDDING_UNAVAILABLE_REQUEST_RESULT
+        try:
+            return self.do_call(
+                inference_handler=GenerateInferenceHandler(inference_engine=self.inference_engine), request=request
+            )
+        except Exception as e:
+            error: str = f"IBM Text client Model error: {e}"
+            return RequestResult(success=False, cached=False, error=error, completions=[], embedding=[])

helm/clients/image_generation/adobe_vision_client.py

@@ -9,7 +9,7 @@ from helm.common.tokenization_request import (
     DecodeRequestResult,
 )
 from helm.clients.client import Client, CachingClient
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 
 class AdobeVisionClient(Client):

helm/clients/image_generation/aleph_alpha_image_generation_client.py

@@ -9,7 +9,7 @@ from helm.common.tokenization_request import (
     DecodeRequestResult,
 )
 from helm.clients.client import Client, CachingClient
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 
 class AlephAlphaImageGenerationClient(Client):

helm/clients/image_generation/cogview2/sr_pipeline/__init__.py

@@ -6,9 +6,9 @@
 @Contact :   dm18@mails.tsinghua.edu.cn
 """
 
-from .direct_sr import DirectSuperResolution
-from .iterative_sr import IterativeSuperResolution
-from .sr_group import SRGroup
+from helm.clients.image_generation.cogview2.sr_pipeline.direct_sr import DirectSuperResolution
+from helm.clients.image_generation.cogview2.sr_pipeline.iterative_sr import IterativeSuperResolution
+from helm.clients.image_generation.cogview2.sr_pipeline.sr_group import SRGroup
 
 DirectSuperResolution
 IterativeSuperResolution

helm/clients/image_generation/cogview2/sr_pipeline/direct_sr.py

@@ -10,8 +10,11 @@
 import torch
 from icetk import icetk as tokenizer
 
-from .dsr_sampling import filling_sequence_dsr, IterativeEntfilterStrategy
-from .dsr_model import DsrModel
+from helm.clients.image_generation.cogview2.sr_pipeline.dsr_sampling import (
+    filling_sequence_dsr,
+    IterativeEntfilterStrategy,
+)
+from helm.clients.image_generation.cogview2.sr_pipeline.dsr_model import DsrModel
 from helm.common.optional_dependencies import handle_module_not_found_error
 
 

helm/clients/image_generation/cogview2/sr_pipeline/iterative_sr.py

@@ -8,8 +8,11 @@
 import torch
 from icetk import icetk as tokenizer
 
-from .itersr_sampling import filling_sequence_itersr, IterativeEntfilterStrategy
-from .itersr_model import ItersrModel
+from helm.clients.image_generation.cogview2.sr_pipeline.itersr_sampling import (
+    filling_sequence_itersr,
+    IterativeEntfilterStrategy,
+)
+from helm.clients.image_generation.cogview2.sr_pipeline.itersr_model import ItersrModel
 from helm.common.optional_dependencies import handle_module_not_found_error
 
 

helm/clients/image_generation/cogview2/sr_pipeline/sr_group.py

@@ -7,8 +7,8 @@
 """
 
 # here put the import lib
-from .direct_sr import DirectSuperResolution
-from .iterative_sr import IterativeSuperResolution
+from helm.clients.image_generation.cogview2.sr_pipeline.direct_sr import DirectSuperResolution
+from helm.clients.image_generation.cogview2.sr_pipeline.iterative_sr import IterativeSuperResolution
 
 from helm.common.optional_dependencies import handle_module_not_found_error
 

helm/clients/image_generation/cogview2_client.py

@@ -20,7 +20,7 @@ from helm.common.tokenization_request import (
 )
 from helm.clients.client import Client, CachingClient
 from helm.clients.image_generation.cogview2.coglm_strategy import CoglmStrategy
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 
 class CogView2Client(Client):

helm/clients/image_generation/dalle2_client.py

@@ -15,7 +15,7 @@ from helm.common.tokenization_request import (
 )
 from helm.clients.moderation_api_client import ModerationAPIClient
 from helm.clients.client import Client, CachingClient
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 try:
     import openai

helm/clients/image_generation/dalle3_client.py

@@ -7,8 +7,8 @@ from helm.common.optional_dependencies import handle_module_not_found_error
 from helm.common.request import Request, RequestResult, GeneratedOutput, wrap_request_time
 from helm.clients.moderation_api_client import ModerationAPIClient
 from helm.clients.client import CachingClient
-from .dalle2_client import DALLE2Client
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.dalle2_client import DALLE2Client
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 try:
     import openai

helm/clients/image_generation/dalle_mini/__init__.py

@@ -1,3 +1,3 @@
 __version__ = "0.1.4"
 
-from .model import DalleBart, DalleBartProcessor
+from helm.clients.image_generation.dalle_mini.model import DalleBart, DalleBartProcessor

helm/clients/image_generation/dalle_mini/data.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import numpy as np
 from datasets import Dataset, load_dataset
 
-from .model.text import TextNormalizer
+from helm.clients.image_generation.dalle_mini.model.text import TextNormalizer
 from helm.common.optional_dependencies import handle_module_not_found_error
 
 try:

helm/clients/image_generation/dalle_mini/model/__init__.py

@@ -1,5 +1,5 @@
-from .configuration import DalleBartConfig
-from .modeling import DalleBart
-from .partitions import set_partitions
-from .processor import DalleBartProcessor
-from .tokenizer import DalleBartTokenizer
+from helm.clients.image_generation.dalle_mini.model.configuration import DalleBartConfig
+from helm.clients.image_generation.dalle_mini.model.modeling import DalleBart
+from helm.clients.image_generation.dalle_mini.model.partitions import set_partitions
+from helm.clients.image_generation.dalle_mini.model.processor import DalleBartProcessor
+from helm.clients.image_generation.dalle_mini.model.tokenizer import DalleBartTokenizer

helm/clients/image_generation/dalle_mini/model/configuration.py

@@ -12,13 +12,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-""" DalleBart model configuration """
+"""DalleBart model configuration"""
 import warnings
 
 from transformers.configuration_utils import PretrainedConfig
 from transformers.utils import logging
 
-from .utils import PretrainedFromWandbMixin
+from helm.clients.image_generation.dalle_mini.model.utils import PretrainedFromWandbMixin
 
 logger = logging.get_logger(__name__)
 

helm/clients/image_generation/dalle_mini/model/modeling.py

@@ -12,7 +12,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-""" DalleBart model. """
+"""DalleBart model."""
 
 import math
 from functools import partial
@@ -35,8 +35,8 @@ from transformers.utils import ModelOutput, logging
 from transformers.generation.configuration_utils import GenerationConfig
 
 from helm.common.optional_dependencies import handle_module_not_found_error
-from .configuration import DalleBartConfig
-from .utils import PretrainedFromWandbMixin
+from helm.clients.image_generation.dalle_mini.model.configuration import DalleBartConfig
+from helm.clients.image_generation.dalle_mini.model.utils import PretrainedFromWandbMixin
 
 try:
     import flax

helm/clients/image_generation/dalle_mini/model/processor.py

@@ -1,11 +1,11 @@
-""" DalleBart processor """
+"""DalleBart processor"""
 
 from typing import List
 
-from .configuration import DalleBartConfig
-from .text import TextNormalizer
-from .tokenizer import DalleBartTokenizer
-from .utils import PretrainedFromWandbMixin
+from helm.clients.image_generation.dalle_mini.model.configuration import DalleBartConfig
+from helm.clients.image_generation.dalle_mini.model.text import TextNormalizer
+from helm.clients.image_generation.dalle_mini.model.tokenizer import DalleBartTokenizer
+from helm.clients.image_generation.dalle_mini.model.utils import PretrainedFromWandbMixin
 from helm.common.optional_dependencies import handle_module_not_found_error
 
 

helm/clients/image_generation/dalle_mini/model/tokenizer.py

@@ -1,8 +1,8 @@
-""" DalleBart tokenizer """
+"""DalleBart tokenizer"""
 
 from transformers import BartTokenizerFast
 
-from .utils import PretrainedFromWandbMixin
+from helm.clients.image_generation.dalle_mini.model.utils import PretrainedFromWandbMixin
 
 
 class DalleBartTokenizer(PretrainedFromWandbMixin, BartTokenizerFast):

helm/clients/image_generation/dalle_mini/vqgan_jax/__init__.py

@@ -1 +1 @@
-from . import *
+from helm.clients.image_generation.dalle_mini.vqgan_jax import *

helm/clients/image_generation/dalle_mini/vqgan_jax/convert_pt_model_to_jax.py

@@ -2,8 +2,8 @@ import re
 
 import torch
 
-from .modeling_flax_vqgan import VQModel
-from .configuration_vqgan import VQGANConfig
+from helm.clients.image_generation.dalle_mini.vqgan_jax.modeling_flax_vqgan import VQModel
+from helm.clients.image_generation.dalle_mini.vqgan_jax.configuration_vqgan import VQGANConfig
 from helm.common.optional_dependencies import handle_module_not_found_error
 
 try:

helm/clients/image_generation/dalle_mini/vqgan_jax/modeling_flax_vqgan.py

@@ -6,7 +6,7 @@ import math
 
 from transformers.modeling_flax_utils import FlaxPreTrainedModel
 
-from .configuration_vqgan import VQGANConfig
+from helm.clients.image_generation.dalle_mini.vqgan_jax.configuration_vqgan import VQGANConfig
 from helm.common.optional_dependencies import handle_module_not_found_error
 
 try:

helm/clients/image_generation/dalle_mini_client.py

@@ -15,7 +15,7 @@ from helm.common.tokenization_request import (
     TokenizationRequestResult,
 )
 from helm.clients.client import Client, CachingClient
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 
 class DALLEMiniClient(Client):

helm/clients/image_generation/deep_floyd_client.py

@@ -9,7 +9,7 @@ from helm.common.tokenization_request import (
     DecodeRequestResult,
 )
 from helm.clients.client import Client, CachingClient
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 
 class DeepFloydClient(Client):

helm/clients/image_generation/huggingface_diffusers_client.py

@@ -17,7 +17,7 @@ from helm.common.tokenization_request import (
     TokenizationRequestResult,
 )
 from helm.clients.client import Client, CachingClient
-from .image_generation_client_utils import get_single_image_multimedia_object
+from helm.clients.image_generation.image_generation_client_utils import get_single_image_multimedia_object
 
 
 _models_lock: Lock = Lock()