langfun 0.0.2.dev20240420__tar.gz → 0.0.2.dev20240423__tar.gz

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langfun
-Version: 0.0.2.dev20240420
+Version: 0.0.2.dev20240423
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/langfun/core/component.py

@@ -210,6 +210,12 @@ def get_contextual_override(var_name: str) -> ContextualOverride | None:
   return _get_scoped_value(_global_tls, _CONTEXT_OVERRIDES, var_name)
 
 
+def all_contextual_values() -> dict[str, Any]:
+  """Returns all contextual values provided from `lf.context` in scope."""
+  overrides = getattr(_global_tls, _CONTEXT_OVERRIDES, {})
+  return {k: v.value for k, v in overrides.items()}
+
+
 @contextlib.contextmanager
 def _contextual_scope(
     tls: threading.local, tls_key, **variables

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/langfun/core/component_test.py

@@ -84,6 +84,7 @@ class ComponentContextTest(unittest.TestCase):
           lf.get_contextual_override('y'),
           lf.ContextualOverride(3, cascade=False, override_attrs=False),
       )
+      self.assertEqual(lf.all_contextual_values(), dict(x=3, y=3, z=3))
 
       # Member attributes take precedence over `lf.context`.
       self.assertEqual(a1.x, 1)

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/langfun/core/language_model.py

@@ -24,6 +24,9 @@ from langfun.core import console
 from langfun.core import message as message_lib
 import pyglove as pg
 
+TOKENS_PER_REQUEST = 250  # Estimated num tokens for a single request
+DEFAULT_MAX_CONCURRENCY = 1  # Use this as max concurrency if no RPM or TPM data
+
 
 class LMSample(pg.Object):
   """Response candidate."""
@@ -604,3 +607,14 @@ class LanguageModel(component.Component):
             f'score: {r.score}',
             color='blue',
         )
+
+  def rate_to_max_concurrency(
+      self, requests_per_min: float = 0, tokens_per_min: float = 0
+  ) -> int:
+    """Converts a rate to a max concurrency."""
+    if tokens_per_min > 0:
+      return max(int(tokens_per_min / TOKENS_PER_REQUEST / 60), 1)
+    elif requests_per_min > 0:
+      return max(int(requests_per_min / 60), 1)  # Max concurrency can't be zero
+    else:
+      return DEFAULT_MAX_CONCURRENCY  # Default of 1

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/langfun/core/language_model_test.py

@@ -394,6 +394,38 @@ class LanguageModelTest(unittest.TestCase):
     with self.assertRaises(NotImplementedError):
       MockModel().score('hi', ['1', '2'])
 
+  def test_rate_to_max_concurrency_no_rpm_no_tpm(self) -> None:
+    lm = MockModel()
+    self.assertEqual(
+        lm_lib.DEFAULT_MAX_CONCURRENCY,
+        lm.rate_to_max_concurrency(requests_per_min=0, tokens_per_min=0),
+    )
+    self.assertEqual(
+        lm_lib.DEFAULT_MAX_CONCURRENCY,
+        lm.rate_to_max_concurrency(requests_per_min=-1, tokens_per_min=-1),
+    )
+
+  def test_rate_to_max_concurrency_only_rpm_specified_uses_rpm(self) -> None:
+    lm = MockModel()
+    test_rpm = 1e4
+    self.assertEqual(
+        lm.rate_to_max_concurrency(requests_per_min=test_rpm),
+        int(test_rpm / 60)
+    )
+
+  def test_rate_to_max_concurrency_tpm_specified_uses_tpm(self) -> None:
+    lm = MockModel()
+    test_tpm = 1e7
+    self.assertEqual(
+        lm.rate_to_max_concurrency(requests_per_min=1, tokens_per_min=test_tpm),
+        int(test_tpm / lm_lib.TOKENS_PER_REQUEST / 60),
+    )
+
+  def test_rate_to_max_concurrency_small_rate_returns_one(self) -> None:
+    lm = MockModel()
+    self.assertEqual(lm.rate_to_max_concurrency(requests_per_min=1), 1)
+    self.assertEqual(lm.rate_to_max_concurrency(tokens_per_min=1), 1)
+
 
 if __name__ == '__main__':
   unittest.main()

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/langfun/core/llms/__init__.py

@@ -66,6 +66,13 @@ from langfun.core.llms.anthropic import Claude3Opus
 from langfun.core.llms.anthropic import Claude3Sonnet
 from langfun.core.llms.anthropic import Claude3Haiku
 
+from langfun.core.llms.groq import Groq
+from langfun.core.llms.groq import GroqLlama3_70B
+from langfun.core.llms.groq import GroqLlama3_8B
+from langfun.core.llms.groq import GroqLlama2_70B
+from langfun.core.llms.groq import GroqMistral_8x7B
+from langfun.core.llms.groq import GroqGemma7B_IT
+
 
 # LLaMA C++ models.
 from langfun.core.llms.llama_cpp import LlamaCppRemote

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/langfun/core/llms/anthropic.py

@@ -26,12 +26,15 @@ import requests
 
 SUPPORTED_MODELS_AND_SETTINGS = {
     # See https://docs.anthropic.com/claude/docs/models-overview
-    'claude-3-opus-20240229': pg.Dict(max_tokens=4096, max_concurrency=16),
-    'claude-3-sonnet-20240229': pg.Dict(max_tokens=4096, max_concurrency=16),
-    'claude-3-haiku-20240307': pg.Dict(max_tokens=4096, max_concurrency=16),
-    'claude-2.1': pg.Dict(max_tokens=4096, max_concurrency=16),
-    'claude-2.0': pg.Dict(max_tokens=4096, max_concurrency=16),
-    'claude-instant-1.2': pg.Dict(max_tokens=4096, max_concurrency=16),
+    # Rate limits from https://docs.anthropic.com/claude/reference/rate-limits
+    #     RPM/TPM for Claude-2.1, Claude-2.0, and Claude-Instant-1.2 estimated
+    #     as RPM/TPM of the largest-available model (Claude-3-Opus).
+    'claude-3-opus-20240229': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-3-sonnet-20240229': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-3-haiku-20240307': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-2.1': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-2.0': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-instant-1.2': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
 }
 
 
@@ -81,6 +84,7 @@ class Anthropic(lf.LanguageModel):
     super()._on_bound()
     self._api_key = None
     self.__dict__.pop('_api_initialized', None)
+    self.__dict__.pop('_session', None)
 
   @functools.cached_property
   def _api_initialized(self):
@@ -93,6 +97,17 @@ class Anthropic(lf.LanguageModel):
     self._api_key = api_key
     return True
 
+  @functools.cached_property
+  def _session(self) -> requests.Session:
+    assert self._api_initialized
+    s = requests.Session()
+    s.headers.update({
+        'x-api-key': self._api_key,
+        'anthropic-version': _ANTHROPIC_API_VERSION,
+        'content-type': 'application/json',
+    })
+    return s
+
   @property
   def model_id(self) -> str:
     """Returns a string to identify the model."""
@@ -100,7 +115,11 @@ class Anthropic(lf.LanguageModel):
 
   @property
   def max_concurrency(self) -> int:
-    return SUPPORTED_MODELS_AND_SETTINGS[self.model].max_concurrency
+    rpm = SUPPORTED_MODELS_AND_SETTINGS[self.model].get('rpm', 0)
+    tpm = SUPPORTED_MODELS_AND_SETTINGS[self.model].get('tpm', 0)
+    return self.rate_to_max_concurrency(
+        requests_per_min=rpm, tokens_per_min=tpm
+    )
 
   def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
     assert self._api_initialized
@@ -165,8 +184,8 @@ class Anthropic(lf.LanguageModel):
   def _parse_response(self, response: requests.Response) -> lf.LMSamplingResult:
     """Parses Anthropic's response."""
     # NOTE(daiyip): Refer https://docs.anthropic.com/claude/reference/errors
-    output = response.json()
     if response.status_code == 200:
+      output = response.json()
       message = self._message_from_content(output['content'])
       input_tokens = output['usage']['input_tokens']
       output_tokens = output['usage']['output_tokens']
@@ -181,12 +200,11 @@ class Anthropic(lf.LanguageModel):
     else:
       if response.status_code == 429:
         error_cls = RateLimitError
-      elif response.status_code == 529:
+      elif response.status_code in (502, 529):
         error_cls = OverloadedError
       else:
         error_cls = AnthropicError
-      error = output['error']
-      raise error_cls(f'{error["type"]}: {error["message"]}')
+      raise error_cls(f'{response.status_code}: {response.content}')
 
   def _sample_single(self, prompt: lf.Message) -> lf.LMSamplingResult:
     request = dict()
@@ -198,17 +216,13 @@ class Anthropic(lf.LanguageModel):
             ]
         )
     )
-    response = requests.post(
-        _ANTHROPIC_MESSAGE_API_ENDPOINT,
-        json=request,
-        headers={
-            'x-api-key': self._api_key,
-            'anthropic-version': _ANTHROPIC_API_VERSION,
-            'content-type': 'application/json',
-        },
-        timeout=self.timeout,
-    )
-    return self._parse_response(response)
+    try:
+      response = self._session.post(
+          _ANTHROPIC_MESSAGE_API_ENDPOINT, json=request, timeout=self.timeout,
+      )
+      return self._parse_response(response)
+    except ConnectionError as e:
+      raise OverloadedError(str(e)) from e
 
 
 class Claude3(Anthropic):

{langfun-0.0.2.dev20240420 → langfun-0.0.2.dev20240423}/langfun/core/llms/anthropic_test.py

@@ -98,20 +98,20 @@ def mock_requests_post_error(status_code, error_type, error_message):
   return _mock_requests
 
 
-class AuthropicTest(unittest.TestCase):
+class AnthropicTest(unittest.TestCase):
 
   def test_basics(self):
     self.assertEqual(
         anthropic.Claude3Haiku().model_id, 'claude-3-haiku-20240307'
     )
-    self.assertEqual(anthropic.Claude3Haiku().max_concurrency, 16)
+    self.assertGreater(anthropic.Claude3Haiku().max_concurrency, 0)
 
   def test_api_key(self):
     lm = anthropic.Claude3Haiku()
     with self.assertRaisesRegex(ValueError, 'Please specify `api_key`'):
       lm('hi')
 
-    with mock.patch('requests.post') as mock_request:
+    with mock.patch('requests.Session.post') as mock_request:
       mock_request.side_effect = mock_requests_post
 
       lm = anthropic.Claude3Haiku(api_key='fake key')
@@ -123,7 +123,7 @@ class AuthropicTest(unittest.TestCase):
       del os.environ['ANTHROPIC_API_KEY']
 
   def test_call(self):
-    with mock.patch('requests.post') as mock_request:
+    with mock.patch('requests.Session.post') as mock_request:
       mock_request.side_effect = mock_requests_post
       lm = anthropic.Claude3Haiku(api_key='fake_key')
       response = lm('hello', temperature=0.0, top_k=0.1, top_p=0.2, stop=['\n'])
@@ -140,7 +140,7 @@ class AuthropicTest(unittest.TestCase):
       self.assertIsNotNone(response.usage.total_tokens, 3)
 
   def test_mm_call(self):
-    with mock.patch('requests.post') as mock_mm_request:
+    with mock.patch('requests.Session.post') as mock_mm_request:
       mock_mm_request.side_effect = mock_mm_requests_post
       lm = anthropic.Claude3Haiku(api_key='fake_key')
       response = lm(lf_modalities.Image.from_bytes(image_content), lm=lm)
@@ -152,13 +152,13 @@ class AuthropicTest(unittest.TestCase):
         (529, 'service_unavailable', 'Service unavailable.'),
         (500, 'bad_request', 'Bad request.'),
     ]:
-      with mock.patch('requests.post') as mock_mm_request:
+      with mock.patch('requests.Session.post') as mock_mm_request:
         mock_mm_request.side_effect = mock_requests_post_error(
             status_code, error_type, error_message
         )
         lm = anthropic.Claude3Haiku(api_key='fake_key')
         with self.assertRaisesRegex(
-            Exception, f'{error_type}: {error_message}'
+            Exception, f'.*{status_code}: .*{error_message}'
         ):
           lm('hello', lm=lm, max_attempts=1)
 

langfun-0.0.2.dev20240423/langfun/core/llms/groq.py

@@ -0,0 +1,260 @@
+# Copyright 2024 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+"""Language models from Groq."""
+
+import functools
+import os
+from typing import Annotated, Any
+
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+import pyglove as pg
+import requests
+
+
+SUPPORTED_MODELS_AND_SETTINGS = {
+    # Refer https://console.groq.com/docs/models
+    'llama3-8b-8192': pg.Dict(max_tokens=8192, max_concurrency=16),
+    'llama3-70b-8192': pg.Dict(max_tokens=8192, max_concurrency=16),
+    'llama2-70b-4096': pg.Dict(max_tokens=4096, max_concurrency=16),
+    'mixtral-8x7b-32768': pg.Dict(max_tokens=32768, max_concurrency=16),
+    'gemma-7b-it': pg.Dict(max_tokens=8192, max_concurrency=16),
+}
+
+
+class GroqError(Exception):  # pylint: disable=g-bad-exception-name
+  """Base class for Groq errors."""
+
+
+class RateLimitError(GroqError):
+  """Error for rate limit reached."""
+
+
+class OverloadedError(GroqError):
+  """Groq's server is temporarily overloaded."""
+
+
+_CHAT_COMPLETE_API_ENDPOINT = 'https://api.groq.com/openai/v1/chat/completions'
+
+
+@lf.use_init_args(['model'])
+class Groq(lf.LanguageModel):
+  """Groq LLMs through REST APIs (OpenAI compatible).
+
+  See https://platform.openai.com/docs/api-reference/chat
+  """
+
+  model: pg.typing.Annotated[
+      pg.typing.Enum(
+          pg.MISSING_VALUE, list(SUPPORTED_MODELS_AND_SETTINGS.keys())
+      ),
+      'The name of the model to use.',
+  ]
+
+  multimodal: Annotated[bool, 'Whether this model has multimodal support.'] = (
+      False
+  )
+
+  api_key: Annotated[
+      str | None,
+      (
+          'API key. If None, the key will be read from environment variable '
+          "'GROQ_API_KEY'."
+      ),
+  ] = None
+
+  def _on_bound(self):
+    super()._on_bound()
+    self._api_key = None
+    self.__dict__.pop('_api_initialized', None)
+    self.__dict__.pop('_session', None)
+
+  @functools.cached_property
+  def _api_initialized(self):
+    api_key = self.api_key or os.environ.get('GROQ_API_KEY', None)
+    if not api_key:
+      raise ValueError(
+          'Please specify `api_key` during `__init__` or set environment '
+          'variable `GROQ_API_KEY` with your Groq API key.'
+      )
+    self._api_key = api_key
+    return True
+
+  @functools.cached_property
+  def _session(self) -> requests.Session:
+    assert self._api_initialized
+    s = requests.Session()
+    s.headers.update({
+        'Authorization': f'Bearer {self._api_key}',
+        'Content-Type': 'application/json',
+    })
+    return s
+
+  @property
+  def model_id(self) -> str:
+    """Returns a string to identify the model."""
+    return self.model
+
+  @property
+  def max_concurrency(self) -> int:
+    return SUPPORTED_MODELS_AND_SETTINGS[self.model].max_concurrency
+
+  def _get_request_args(self, options: lf.LMSamplingOptions) -> dict[str, Any]:
+    """Returns a dict as request arguments."""
+    # `logprobs` and `top_logprobs` flags are not supported on Groq yet.
+    args = dict(
+        model=self.model,
+        n=options.n,
+        stream=False,
+    )
+
+    if options.temperature is not None:
+      args['temperature'] = options.temperature
+    if options.max_tokens is not None:
+      args['max_tokens'] = options.max_tokens
+    if options.top_p is not None:
+      args['top_p'] = options.top_p
+    if options.stop:
+      args['stop'] = options.stop
+    return args
+
+  def _content_from_message(self, prompt: lf.Message) -> list[dict[str, Any]]:
+    """Converts an message to Groq's content protocol (list of dicts)."""
+    # Refer: https://platform.openai.com/docs/api-reference/chat/create
+    content = []
+    for chunk in prompt.chunk():
+      if isinstance(chunk, str):
+        item = dict(type='text', text=chunk)
+      elif (
+          self.multimodal
+          and isinstance(chunk, lf_modalities.Image)
+          and chunk.uri
+      ):
+        # NOTE(daiyip): Groq only support image URL.
+        item = dict(type='image_url', image_url=chunk.uri)
+      else:
+        raise ValueError(f'Unsupported modality object: {chunk!r}.')
+      content.append(item)
+    return content
+
+  def _message_from_choice(self, choice: dict[str, Any]) -> lf.Message:
+    """Converts Groq's content protocol to message."""
+    # Refer: https://platform.openai.com/docs/api-reference/chat/create
+    content = choice['message']['content']
+    if isinstance(content, str):
+      return lf.AIMessage(content)
+    return lf.AIMessage.from_chunks(
+        [x['text'] for x in content if x['type'] == 'text']
+    )
+
+  def _parse_response(self, response: requests.Response) -> lf.LMSamplingResult:
+    """Parses Groq's response."""
+    # Refer: https://platform.openai.com/docs/api-reference/chat/object
+    if response.status_code == 200:
+      output = response.json()
+      samples = [
+          lf.LMSample(self._message_from_choice(choice), score=0.0)
+          for choice in output['choices']
+      ]
+      usage = output['usage']
+      return lf.LMSamplingResult(
+          samples,
+          usage=lf.LMSamplingUsage(
+              prompt_tokens=usage['prompt_tokens'],
+              completion_tokens=usage['completion_tokens'],
+              total_tokens=usage['total_tokens'],
+          ),
+      )
+    else:
+      # https://platform.openai.com/docs/guides/error-codes/api-errors
+      if response.status_code == 429:
+        error_cls = RateLimitError
+      elif response.status_code in (500, 502, 503):
+        error_cls = OverloadedError
+      else:
+        error_cls = GroqError
+      raise error_cls(f'{response.status_code}: {response.content}')
+
+  def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
+    assert self._api_initialized
+    return self._parallel_execute_with_currency_control(
+        self._sample_single,
+        prompts,
+        retry_on_errors=(RateLimitError, OverloadedError),
+    )
+
+  def _sample_single(self, prompt: lf.Message) -> lf.LMSamplingResult:
+    request = dict()
+    request.update(self._get_request_args(self.sampling_options))
+    request.update(
+        dict(
+            messages=[
+                dict(role='user', content=self._content_from_message(prompt))
+            ]
+        )
+    )
+    try:
+      response = self._session.post(
+          _CHAT_COMPLETE_API_ENDPOINT,
+          json=request,
+          timeout=self.timeout,
+      )
+      return self._parse_response(response)
+    except ConnectionError as e:
+      raise OverloadedError(str(e)) from e
+
+
+class GroqLlama3_8B(Groq):  # pylint: disable=invalid-name
+  """Llama3-8B with 8K context window.
+
+  See: https://huggingface.co/meta-llama/Meta-Llama-3-8B
+  """
+
+  model = 'llama3-8b-8192'
+
+
+class GroqLlama3_70B(Groq):  # pylint: disable=invalid-name
+  """Llama3-70B with 8K context window.
+
+  See: https://huggingface.co/meta-llama/Meta-Llama-3-70B
+  """
+
+  model = 'llama3-70b-8192'
+
+
+class GroqLlama2_70B(Groq):  # pylint: disable=invalid-name
+  """Llama2-70B with 4K context window.
+
+  See: https://huggingface.co/meta-llama/Llama-2-70b
+  """
+
+  model = 'llama2-70b-4096'
+
+
+class GroqMistral_8x7B(Groq):  # pylint: disable=invalid-name
+  """Mixtral 8x7B with 32K context window.
+
+  See: https://huggingface.co/meta-llama/Llama-2-70b
+  """
+
+  model = 'mixtral-8x7b-32768'
+
+
+class GroqGemma7B_IT(Groq):  # pylint: disable=invalid-name
+  """Gemma 7B with 8K context window.
+
+  See: https://huggingface.co/google/gemma-1.1-7b-it
+  """
+
+  model = 'gemma-7b-it'