| from openai import OpenAI |
| import warnings |
| from concurrent.futures import ThreadPoolExecutor |
| from typing import ( |
| Optional, |
| Dict, |
| Any, |
| Callable, |
| List, |
| ) |
|
|
| class OpenAIClient(OpenAI): |
| """ |
| A subclass of ``openai.OpenAI`` that wraps around the chat completions API to provide a simple interface |
| for generating text with the OpenAI language models, along with cost estimation. |
| |
| This class provides functionality for interacting with OpenAI's chat models, allowing for |
| customized generation with options like temperature, top_p, streaming. |
| It also supports post-processing of the generated content and retrying the request up to a |
| specified tolerance level if any errors occur during the API call. |
| """ |
|
|
| def get_text_generation_output( |
| self, |
| messages: List[Dict[str, str]], |
| model: str = "gpt-4o", |
| post_processor: Optional[Callable[[str], Any]] = None, |
| max_tolerance: int = 3, |
| temperature: float = 0.75, |
| top_p: float = 0.95, |
| stream: bool = True, |
| **kwargs |
| ) -> Dict[str, Any]: |
| """ |
| Generate text using the OpenAI chat completions API and return the response content, |
| with optional post-processing. |
| """ |
| response_content = None |
| counter = 0 |
| content = '' |
| reasoning_content = None |
|
|
| while response_content is None and counter <= max_tolerance: |
| try: |
| response = self.chat.completions.create( |
| model=model, |
| messages=messages, |
| temperature=temperature, |
| top_p=top_p, |
| stream=stream, |
| **kwargs |
| ) |
| if stream: |
| chunks = [] |
| reasoning_chunks = [] |
| for chunk in response: |
| if len(chunk.choices) > 0: |
| chunks.append(chunk.choices[0].delta.content or '') |
| if hasattr(chunk.choices[0].delta, "reasoning_content"): |
| reasoning_chunks.append(chunk.choices[0].delta.reasoning_content or '') |
| else: |
| warnings.warn( |
| "Find a chunk without `choices` attribute. " |
| "The model may reject to answer the question. " |
| "Please check the question and the model you use.", |
| UserWarning |
| ) |
| content = ''.join(chunks) |
| if len(reasoning_chunks) > 0: |
| reasoning_content = ''.join(reasoning_chunks) |
| else: |
| content = response.choices[0].message.content |
| if hasattr(response.choices[0].message, "reasoning_content"): |
| reasoning_content = response.choices[0].message.reasoning_content |
| except Exception as e: |
| print(e) |
| finally: |
| response_content = content if post_processor is None else post_processor(content) |
| counter += 1 |
| |
| outputs = { |
| "content": content, |
| "processed_content": response_content, |
| } |
| if reasoning_content is not None: |
| outputs["reasoning_content"] = reasoning_content |
|
|
| return outputs |
|
|
| def openai_api_batch_inference( |
| clients: List[OpenAIClient], |
| messages_list: List[List[Dict[str, str]]], |
| model: str = "gpt-4o", |
| post_processor: Optional[Callable[[str], Any]] = None, |
| max_tolerance: int = 3, |
| temperature: float = 0.75, |
| top_p: float = 0.95, |
| stream: bool = True, |
| **kwargs |
| ) -> List[Dict[str, Any]]: |
| """Process multiple OpenAI API requests in parallel using thread pool.""" |
| n_jobs = len(clients) |
| if len(messages_list) != n_jobs: |
| raise ValueError(f"The number of clients ({n_jobs}) must match the number of messages ({len(messages_list)}).") |
| |
| apply_func = lambda client, messages: client.get_text_generation_output( |
| messages, |
| model, |
| post_processor, |
| max_tolerance, |
| temperature, |
| top_p, |
| stream, |
| **kwargs, |
| ) |
|
|
| with ThreadPoolExecutor(max_workers=n_jobs) as executor: |
| futures = [ |
| executor.submit(apply_func, clients[i], messages_list[i]) |
| for i in range(n_jobs) |
| ] |
| results = [future.result() for future in futures] |
|
|
| return results |
|
|
| class NativeLLMClient: |
| """A client for native LLM inference. Powered by vLLM.""" |
|
|
| def __init__(self, model: str, **kwargs) -> None: |
| from transformers import AutoTokenizer |
| from vllm import LLM |
| self.model = LLM(model=model, **kwargs) |
| self.tokenizer = AutoTokenizer.from_pretrained(model) |
|
|
| def __call__( |
| self, |
| messages_list: List[List[Dict[str, str]]], |
| post_processor: Optional[Callable[[str], Any]] = None, |
| enable_thinking: Optional[bool] = None, |
| **kwargs |
| ) -> Dict[str, Any] | List[Dict[str, Any]]: |
| """Generate text using the native LLM.""" |
| if enable_thinking is not None: |
| texts = self.tokenizer.apply_chat_template( |
| messages_list, |
| tokenize=False, |
| add_generation_prompt=True, |
| enable_thinking=enable_thinking, |
| ) |
| else: |
| texts = self.tokenizer.apply_chat_template( |
| messages_list, |
| tokenize=False, |
| |
| |
| add_generation_prompt=True, |
| ) |
| |
| if len(kwargs) > 0: |
| from vllm import SamplingParams |
| sampling_params = SamplingParams(**kwargs) |
| outputs = self.model.generate(texts, sampling_params) |
| else: |
| |
| outputs = self.model.generate(texts) |
|
|
| new_outputs = [] |
| for output in outputs: |
| content = output.outputs[0].text |
| processed_content = content |
| if post_processor is not None: |
| processed_content = post_processor(content) |
| if isinstance(processed_content, dict): |
| new_outputs.append( |
| { |
| "content": content, |
| **processed_content, |
| } |
| ) |
| else: |
| new_outputs.append( |
| { |
| "content": content, |
| "processed_content": processed_content, |
| } |
| ) |
|
|
| return new_outputs if len(new_outputs) > 1 else new_outputs[0] |
| |
| class OpenAIClientPool: |
| """A pool of OpenAI clients for batch inference.""" |
|
|
| def __init__( |
| self, |
| api_keys: List[str] | str, |
| base_urls: List[str] | str, |
| model: str = "gpt-4o", |
| **kwargs |
| ) -> None: |
| """Initialize a pool of OpenAI clients.""" |
| if len(api_keys) != len(base_urls): |
| raise ValueError( |
| f"The number of api_key ({len(api_keys)}) must match the number of base_url ({len(base_urls)})." |
| ) |
| |
| self.client_pool = [ |
| OpenAIClient( |
| api_key=api_key, |
| base_url=base_url, |
| **kwargs |
| ) |
| for api_key, base_url in zip(api_keys, base_urls) |
| ] |
| self.model = model |
| |
| def __call__( |
| self, |
| messages_list: List[List[Dict[str, str]]], |
| post_processor: Optional[Callable[[str], Any]] = None, |
| **kwargs |
| ) -> Dict[str, Any] | List[Dict[str, Any]]: |
| """Generate text using the OpenAI clients.""" |
| max_batch_size = len(self.client_pool) |
|
|
| outputs = [] |
| for i in range(0, len(messages_list), max_batch_size): |
| batch_messages_list = messages_list[i: i + max_batch_size] |
| batch_clients = self.client_pool[0: len(batch_messages_list)] |
| if len(batch_clients) == 1: |
| client = batch_clients[0] |
| outputs.append( |
| client.get_text_generation_output( |
| batch_messages_list[0], |
| model=self.model, |
| post_processor=post_processor, |
| **kwargs |
| ) |
| ) |
| else: |
| outputs.extend( |
| openai_api_batch_inference( |
| batch_clients, |
| batch_messages_list, |
| model=self.model, |
| post_processor=post_processor, |
| **kwargs |
| ) |
| ) |
|
|
| return outputs if len(outputs) > 1 else outputs[0] |
| |
| @property |
| def pool_size(self) -> int: |
| return len(self.client_pool) |
|
|
| def get_interface_for_inference( |
| model: str, |
| api_keys: Optional[List[str] | str] = None, |
| base_urls: Optional[List[str] | str] = None, |
| **kwargs |
| ) -> OpenAIClientPool | NativeLLMClient: |
| """Get an interface for inference.""" |
| if api_keys is not None and base_urls is not None: |
| return OpenAIClientPool(api_keys, base_urls, model, **kwargs) |
| if api_keys is not None or base_urls is not None: |
| raise ValueError( |
| "Either both `api_keys` and `base_urls` must be provided, or neither." |
| ) |
| interface = NativeLLMClient(model, **kwargs) |
| return interface |
