speedy-utils 1.1.34__tar.gz → 1.1.36__tar.gz

{speedy_utils-1.1.34 → speedy_utils-1.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.34
+Version: 1.1.36
 Summary: Fast and easy-to-use package for data science
 Project-URL: Homepage, https://github.com/anhvth/speedy
 Project-URL: Repository, https://github.com/anhvth/speedy

speedy_utils-1.1.36/debug/debug_generate_response.py

@@ -0,0 +1,33 @@
+"""Debug the actual response from generate endpoint."""
+
+import requests
+import json
+
+base_url = 'http://localhost:8000'
+
+# Encode input first
+response = requests.post(
+    f'{base_url}/tokenize',
+    json={'prompt': 'Hello, how are you?', 'add_special_tokens': True},
+)
+token_ids = response.json()['tokens']
+print(f'Input token IDs: {token_ids}')
+print()
+
+# Call generate
+request_data = {
+    'token_ids': token_ids,
+    'sampling_params': {
+        'max_tokens': 20,
+        'temperature': 0.7,
+        'n': 1,
+    },
+}
+
+response = requests.post(
+    f'{base_url}/inference/v1/generate',
+    json=request_data,
+)
+print(f'Status code: {response.status_code}')
+print(f'Response JSON:')
+print(json.dumps(response.json(), indent=2))

speedy_utils-1.1.36/debug/debug_n_param.py

@@ -0,0 +1,22 @@
+"""Debug n parameter."""
+
+from llm_utils.lm import LLM
+import json
+
+lm = LLM(client=8000)
+
+# Test with different n values
+for n_val in [1, 2, 3, 4]:
+    print(f'\nTesting n={n_val}')
+    results = lm.generate('AI is', max_tokens=10, n=n_val, temperature=0.8)
+    
+    if isinstance(results, list):
+        print(f'  Returned {len(results)} results (expected {n_val})')
+        raw = results[0].get('_raw_response', {})
+    else:
+        print(f'  Returned single dict (expected {n_val})')
+        raw = results.get('_raw_response', {})
+    
+    # Check raw response
+    if 'choices' in raw:
+        print(f'  Raw response has {len(raw["choices"])} choices')

speedy_utils-1.1.36/debug/debug_n_structure.py

@@ -0,0 +1,33 @@
+"""Debug n parameter structure."""
+
+from llm_utils.lm import LLM
+import json
+
+lm = LLM(client=8000)
+
+result = lm.generate('Test', max_tokens=5, n=3, temperature=0.8)
+
+print('Type:', type(result))
+print('Length:', len(result) if isinstance(result, list) else 'N/A')
+print()
+
+if isinstance(result, list):
+    print('First result keys:', result[0].keys())
+    raw = result[0]['_raw_response']
+    print('Raw response type:', type(raw))
+    print('Raw response keys:', raw.keys() if isinstance(raw, dict) else 'N/A')
+    print()
+    
+# Get actual response
+import requests
+base_url = 'http://localhost:8000'
+token_ids = lm.encode('Test')
+response = requests.post(
+    f'{base_url}/inference/v1/generate',
+    json={
+        'token_ids': token_ids,
+        'sampling_params': {'max_tokens': 5, 'n': 3, 'temperature': 0.8},
+    },
+)
+print('Actual API response:')
+print(json.dumps(response.json(), indent=2))

speedy_utils-1.1.36/debug/integration_test.py

@@ -0,0 +1,88 @@
+"""Final integration test for encode/decode/generate functionality."""
+
+from llm_utils.lm import LLM
+
+print('Testing LLM encode/decode/generate integration...\n')
+
+# Initialize
+lm = LLM(client=8000)
+
+# Test 1: Encode/Decode
+print('✓ Test 1: Encode/Decode')
+text = 'Hello, world!'
+tokens = lm.encode(text)
+decoded = lm.decode(tokens)
+print(f'  Original: {text}')
+print(f'  Tokens: {tokens}')
+print(f'  Decoded: {decoded}')
+assert isinstance(tokens, list)
+assert all(isinstance(t, int) for t in tokens)
+print()
+
+# Test 2: Generate from text
+print('✓ Test 2: Generate from text')
+result = lm.generate('The answer is', max_tokens=10, temperature=0.5)
+print(f'  Input: "The answer is"')
+print(f'  Output: {result["text"][:50]}')
+assert 'text' in result
+print()
+
+# Test 3: Generate from token IDs
+print('✓ Test 3: Generate from token IDs')
+input_ids = lm.encode('Python is')
+result = lm.generate(input_ids, max_tokens=15, return_token_ids=True)
+print(f'  Input IDs: {input_ids}')
+print(f'  Output: {result["text"][:50]}')
+print(f'  Output IDs: {result.get("token_ids", "N/A")}')
+assert 'text' in result
+assert 'token_ids' in result
+print()
+
+# Test 4: Multiple generations
+print('✓ Test 4: Multiple generations (n=3)')
+results = lm.generate('AI is', max_tokens=10, n=3, temperature=0.8)
+print(f'  Input: "AI is"')
+for i, r in enumerate(results, 1):
+    print(f'  {i}. {r["text"][:40]}')
+# Note: Server may return fewer choices than requested
+assert isinstance(results, list)
+assert len(results) >= 1
+print()
+
+# Test 5: Temperature control
+print('✓ Test 5: Temperature control')
+low_temp = lm.generate('1 + 1 =', max_tokens=5, temperature=0.1, seed=42)
+high_temp = lm.generate('1 + 1 =', max_tokens=5, temperature=1.5, seed=123)
+print(f'  Low temp (0.1): {low_temp["text"][:30]}')
+print(f'  High temp (1.5): {high_temp["text"][:30]}')
+print()
+
+# Test 6: Stop sequences
+print('✓ Test 6: Stop sequences')
+result = lm.generate(
+    'Count: 1, 2, 3,',
+    max_tokens=50,
+    stop=[', 6', '\n'],
+    temperature=0.7,
+)
+print(f'  Input: "Count: 1, 2, 3,"')
+print(f'  Output (stop at ", 6"): {result["text"][:50]}')
+print()
+
+# Test 7: Seed reproducibility
+print('✓ Test 7: Seed reproducibility')
+r1 = lm.generate('Test', max_tokens=10, seed=999, temperature=0.8)
+r2 = lm.generate('Test', max_tokens=10, seed=999, temperature=0.8)
+print(f'  Run 1: {r1["text"][:40]}')
+print(f'  Run 2: {r2["text"][:40]}')
+print(f'  Match: {r1["text"] == r2["text"]}')
+print()
+
+print('=' * 60)
+print('✅ All tests passed!')
+print('=' * 60)
+print()
+print('Available methods:')
+print('  - lm.encode(text) -> list[int]')
+print('  - lm.decode(token_ids) -> str')
+print('  - lm.generate(input, **kwargs) -> dict')

speedy_utils-1.1.36/debug/test_decode_api.py

@@ -0,0 +1,19 @@
+from llm_utils.lm import LLM
+
+lm = LLM(client=8000)
+
+# Encode text to tokens
+token_ids = lm.encode('Hello, world!')
+print(f'Token IDs: {token_ids}')
+
+# Decode tokens back to text
+text = lm.decode(token_ids)
+print(f'Decoded text: {text}')
+
+# Get token strings for debugging
+ids, strs = lm.encode('Hello', return_token_strs=True)
+print(f'IDs: {ids}')
+print(f'Strings: {strs}')
+print(f'Tokens with strings:')
+for i, s in zip(ids, strs):
+    print(f'  {i:6d} -> "{s}"')

speedy_utils-1.1.36/debug/test_endpoints.py

@@ -0,0 +1,27 @@
+from llm_utils.lm import LLM
+
+lm = LLM(client=8000)
+
+# Debug: Check the base_url
+print(f"Client base_url: {lm.client.base_url}")
+
+# Try to manually check what endpoints are available
+import requests
+
+# Try different endpoint paths
+test_urls = [
+    "http://localhost:8000/tokenize",
+    "http://localhost:8000/v1/tokenize",
+]
+
+for url in test_urls:
+    try:
+        response = requests.post(
+            url,
+            json={"prompt": "test", "add_special_tokens": True}
+        )
+        print(f"✓ {url} - Status: {response.status_code}")
+        if response.status_code == 200:
+            print(f"  Response: {response.json()}")
+    except Exception as e:
+        print(f"✗ {url} - Error: {e}")

speedy_utils-1.1.36/debug/test_generate.py

@@ -0,0 +1,78 @@
+"""Test the generate method with HuggingFace-style interface."""
+
+from llm_utils.lm import LLM
+
+# Initialize LLM
+lm = LLM(client=8000)
+
+print('=' * 60)
+print('Test 1: Basic text generation')
+print('=' * 60)
+result = lm.generate(
+    'The capital of France is',
+    max_tokens=50,
+    temperature=0.7,
+)
+print(f"Input: 'The capital of France is'")
+print(f"Generated: {result.get('text', 'N/A')}")
+print()
+
+print('=' * 60)
+print('Test 2: Generation with token IDs input')
+print('=' * 60)
+# Encode input first
+input_text = 'Hello, how are you?'
+token_ids = lm.encode(input_text)
+print(f'Input text: {input_text}')
+print(f'Token IDs: {token_ids}')
+
+result = lm.generate(
+    token_ids,
+    max_tokens=30,
+    temperature=0.8,
+    return_token_ids=True,
+)
+print(f"Generated text: {result.get('text', 'N/A')}")
+print(f"Generated token IDs: {result.get('token_ids', 'N/A')}")
+print()
+
+print('=' * 60)
+print('Test 3: Multiple generations (n=3)')
+print('=' * 60)
+results = lm.generate(
+    'Once upon a time',
+    max_tokens=30,
+    temperature=0.9,
+    n=3,
+)
+for i, result in enumerate(results, 1):
+    print(f"Generation {i}: {result.get('text', 'N/A')}")
+print()
+
+print('=' * 60)
+print('Test 4: Generation with sampling parameters')
+print('=' * 60)
+result = lm.generate(
+    'The best programming language is',
+    max_tokens=40,
+    temperature=0.5,
+    top_p=0.9,
+    top_k=50,
+    repetition_penalty=1.1,
+)
+print(f"Generated: {result.get('text', 'N/A')}")
+print()
+
+print('=' * 60)
+print('Test 5: Generation with stop sequences')
+print('=' * 60)
+result = lm.generate(
+    'List three colors:\n1.',
+    max_tokens=100,
+    temperature=0.7,
+    stop=['\n4.', 'That'],
+)
+print(f"Generated: {result.get('text', 'N/A')}")
+print()
+
+print('✓ All tests completed!')

speedy_utils-1.1.36/debug/test_generate_endpoint.py

@@ -0,0 +1,28 @@
+"""Check which endpoint path works for generate."""
+
+import requests
+
+# Test different endpoint paths
+test_urls = [
+    'http://localhost:8000/inference/v1/generate',
+    'http://localhost:8000/v1/inference/v1/generate',
+    'http://localhost:8000/generate',
+]
+
+# Dummy request payload
+dummy_payload = {
+    'token_ids': [1, 2, 3],
+    'sampling_params': {
+        'max_tokens': 10,
+        'temperature': 1.0,
+    },
+}
+
+for url in test_urls:
+    try:
+        response = requests.post(url, json=dummy_payload)
+        print(f'✓ {url} - Status: {response.status_code}')
+        if response.status_code in [200, 400, 422]:  # 400/422 might be validation error but endpoint exists
+            print(f'  Endpoint exists!')
+    except Exception as e:
+        print(f'✗ {url} - Error: {type(e).__name__}')

speedy_utils-1.1.36/docs/GENERATE_QUICKREF.md

@@ -0,0 +1,125 @@
+# Quick Reference: generate() Method
+
+## Summary
+
+The `LLM.generate()` method provides a HuggingFace Transformers-style interface for low-level text generation, working directly with token IDs.
+
+## Basic Signature
+
+```python
+lm.generate(
+    input_context: str | list[int],
+    max_tokens=512,
+    temperature=1.0,
+    n=1,
+    **kwargs
+) -> dict | list[dict]
+```
+
+## Common Use Cases
+
+### 1. Simple Generation
+```python
+result = lm.generate('Hello world', max_tokens=50)
+print(result['text'])
+```
+
+### 2. From Token IDs
+```python
+token_ids = lm.encode('Hello')
+result = lm.generate(token_ids, max_tokens=50, return_token_ids=True)
+```
+
+### 3. Multiple Outputs
+```python
+results = lm.generate('Start:', max_tokens=30, n=5)  # 5 different completions
+```
+
+### 4. Temperature Control
+```python
+# Deterministic (low temp)
+result = lm.generate(prompt, temperature=0.1)
+
+# Creative (high temp)
+result = lm.generate(prompt, temperature=1.5)
+```
+
+### 5. Advanced Sampling
+```python
+result = lm.generate(
+    prompt,
+    temperature=0.8,
+    top_k=50,
+    top_p=0.95,
+    repetition_penalty=1.2,
+)
+```
+
+### 6. Stop Sequences
+```python
+result = lm.generate(
+    'List:\n1.',
+    max_tokens=200,
+    stop=['\n\n', 'End'],
+)
+```
+
+### 7. Reproducible
+```python
+result = lm.generate(prompt, seed=42)  # Same seed = same output
+```
+
+## Parameter Guide
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `input_context` | str \| list[int] | required | Text or token IDs |
+| `max_tokens` | int | 512 | Max tokens to generate |
+| `temperature` | float | 1.0 | Randomness (0.0-2.0) |
+| `top_p` | float | 1.0 | Nucleus sampling |
+| `top_k` | int | -1 | Top-k sampling (-1=off) |
+| `n` | int | 1 | Number of completions |
+| `stop` | str \| list | None | Stop sequences |
+| `seed` | int | None | Random seed |
+| `repetition_penalty` | float | 1.0 | Repeat penalty (1.0=off) |
+| `return_token_ids` | bool | False | Include token IDs |
+| `return_text` | bool | True | Include text |
+
+## Return Format
+
+Single generation (n=1):
+```python
+{
+    'text': 'generated text...',
+    'token_ids': [1, 2, 3, ...],  # if return_token_ids=True
+    'finish_reason': 'length',
+    '_raw_response': {...}
+}
+```
+
+Multiple generations (n>1):
+```python
+[
+    {'text': '...', 'finish_reason': '...'},
+    {'text': '...', 'finish_reason': '...'},
+    ...
+]
+```
+
+## Comparison to HuggingFace
+
+| HuggingFace | llm_utils | Notes |
+|-------------|-----------|-------|
+| `model.generate(input_ids=...)` | `lm.generate(token_ids)` | Same concept |
+| `max_length` | `max_tokens` | Different naming |
+| `num_return_sequences` | `n` | Different naming |
+| `do_sample=True` | `temperature > 0` | Auto-enabled |
+| `num_beams` | N/A | Not supported |
+
+## Tips
+
+1. **Token Counting**: Use `len(lm.encode(text))` to count tokens before generating
+2. **Reproducibility**: Set `seed` for deterministic output
+3. **Quality vs Speed**: Lower temperature for quality, higher for creativity
+4. **Stop Early**: Use `stop` sequences to control output format
+5. **Debug**: Check `result['_raw_response']` for full API response