Instructions to use ayjays132/Phillnet-2 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use ayjays132/Phillnet-2 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="ayjays132/Phillnet-2", trust_remote_code=True)
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("ayjays132/Phillnet-2", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("ayjays132/Phillnet-2", trust_remote_code=True, device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use ayjays132/Phillnet-2 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "ayjays132/Phillnet-2"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ayjays132/Phillnet-2",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/ayjays132/Phillnet-2

SGLang

How to use ayjays132/Phillnet-2 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "ayjays132/Phillnet-2" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ayjays132/Phillnet-2",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "ayjays132/Phillnet-2" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ayjays132/Phillnet-2",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use ayjays132/Phillnet-2 with Docker Model Runner:
```
docker model run hf.co/ayjays132/Phillnet-2
```

Phillnet-2 / memory_optimization /__init__.py

ayjays132

Upload 478 files

101858b verified 6 months ago

Raw History Blame Contribute Delete

1.88 kB

"""
Memory Optimization Module
Unified memory management system with shared Qwen model integration.
"""
from .config import MemoryOptimizationConfig
from .manager import UnifiedMemoryManager
from .tensor_pool import TensorPool
from .model_cache import ModelCache
from .cleanup import MemoryCleanup

# Global unified memory manager instance
_unified_memory_manager = None

def get_unified_memory_manager() -> UnifiedMemoryManager:
    """Get the global unified memory manager instance"""
    global _unified_memory_manager
    if _unified_memory_manager is None:
        _unified_memory_manager = UnifiedMemoryManager()
    return _unified_memory_manager

# Convenience functions for backward compatibility
def get_shared_model(model_name: str, model_type: str = "transformer", **kwargs):
    """Get shared model instance"""
    return get_unified_memory_manager().get_shared_model(model_name, model_type, **kwargs)

def get_tensor(shape, dtype=None, requires_grad: bool = False, module_name: str = "default"):
    """Get optimized tensor from unified pool"""
    return get_unified_memory_manager().get_tensor(shape, dtype, requires_grad, module_name)

def return_tensor(tensor, module_name: str = "default") -> None:
    """Return tensor to unified pool"""
    get_unified_memory_manager().return_tensor(tensor, module_name)

def clear_memory() -> None:
    """Clear all memory"""
    get_unified_memory_manager().clear_all_memory()

def get_memory_stats():
    """Get memory statistics"""
    return get_unified_memory_manager().get_memory_stats()

__all__ = [
    'MemoryOptimizationConfig',
    'UnifiedMemoryManager',
    'TensorPool',
    'ModelCache',
    'MemoryCleanup',
    'get_unified_memory_manager',
    'get_shared_model',
    'get_tensor',
    'return_tensor',
    'clear_memory',
    'get_memory_stats',
]

	"""
	Memory Optimization Module
	Unified memory management system with shared Qwen model integration.
	"""
	from .config import MemoryOptimizationConfig
	from .manager import UnifiedMemoryManager
	from .tensor_pool import TensorPool
	from .model_cache import ModelCache
	from .cleanup import MemoryCleanup

	# Global unified memory manager instance
	_unified_memory_manager = None

	def get_unified_memory_manager() -> UnifiedMemoryManager:
	"""Get the global unified memory manager instance"""
	global _unified_memory_manager
	if _unified_memory_manager is None:
	_unified_memory_manager = UnifiedMemoryManager()
	return _unified_memory_manager

	# Convenience functions for backward compatibility
	def get_shared_model(model_name: str, model_type: str = "transformer", **kwargs):
	"""Get shared model instance"""
	return get_unified_memory_manager().get_shared_model(model_name, model_type, **kwargs)

	def get_tensor(shape, dtype=None, requires_grad: bool = False, module_name: str = "default"):
	"""Get optimized tensor from unified pool"""
	return get_unified_memory_manager().get_tensor(shape, dtype, requires_grad, module_name)

	def return_tensor(tensor, module_name: str = "default") -> None:
	"""Return tensor to unified pool"""
	get_unified_memory_manager().return_tensor(tensor, module_name)

	def clear_memory() -> None:
	"""Clear all memory"""
	get_unified_memory_manager().clear_all_memory()

	def get_memory_stats():
	"""Get memory statistics"""
	return get_unified_memory_manager().get_memory_stats()

	__all__ = [
	'MemoryOptimizationConfig',
	'UnifiedMemoryManager',
	'TensorPool',
	'ModelCache',
	'MemoryCleanup',
	'get_unified_memory_manager',
	'get_shared_model',
	'get_tensor',
	'return_tensor',
	'clear_memory',
	'get_memory_stats',
	]