LLM Resource Tuner

What It Does

Installation

pip install transformers pyyaml

Usage

python llm_resource_tuner.py --model <model_name> --gpu_memory <gpu_memory> [--output <output_file>]

python llm_resource_tuner.py --model gpt-3 --gpu_memory 8GB --output recommendations.yaml

Source Code

import argparse
import yaml
from transformers import AutoModel, AutoTokenizer

def analyze_resources(model_name, gpu_memory):
    """
    Analyze the model and hardware specifications to suggest optimal configurations.

    Args:
        model_name (str): Name of the model to analyze.
        gpu_memory (str): Available GPU memory in GB (e.g., '8GB').

    Returns:
        dict: Suggested configurations including batch size, precision, and hardware tweaks.
    """
    try:
        # Mocked model and tokenizer loading for testing purposes
        model = AutoModel.from_pretrained(model_name)
        tokenizer = AutoTokenizer.from_pretrained(model_name)
    except Exception as e:
        return {"error": f"Failed to load model or tokenizer: {str(e)}"}

    # Parse GPU memory
    try:
        gpu_memory_gb = int(gpu_memory.upper().replace('GB', '').strip())
    except ValueError:
        return {"error": "Invalid GPU memory format. Use format like '8GB'."}

    # Suggest configurations based on GPU memory
    if gpu_memory_gb >= 16:
        batch_size = 32
        precision = 'fp16'
    elif gpu_memory_gb >= 8:
        batch_size = 16
        precision = 'fp16'
    elif gpu_memory_gb >= 4:
        batch_size = 8
        precision = 'fp32'
    else:
        return {"error": "Insufficient GPU memory. Minimum 4GB required."}

    # Generate recommendations
    recommendations = {
        "model_name": model_name,
        "gpu_memory": gpu_memory,
        "recommended_batch_size": batch_size,
        "recommended_precision": precision,
        "notes": "Consider using gradient checkpointing for large models."
    }

    return recommendations

def save_to_yaml(data, output_file):
    """
    Save the recommendations to a YAML file.

    Args:
        data (dict): Data to save.
        output_file (str): Path to the output YAML file.
    """
    with open(output_file, 'w') as file:
        yaml.dump(data, file)

def main():
    parser = argparse.ArgumentParser(description="LLM Resource Tuner: Optimize resource usage for large language models.")
    parser.add_argument('--model', required=True, help="Name of the model (e.g., 'gpt-3').")
    parser.add_argument('--gpu_memory', required=True, help="Available GPU memory (e.g., '8GB').")
    parser.add_argument('--output', help="Optional output file to save recommendations as YAML.")

    args = parser.parse_args()

    # Analyze resources and get recommendations
    recommendations = analyze_resources(args.model, args.gpu_memory)

    if "error" in recommendations:
        print(f"Error: {recommendations['error']}")
    else:
        print("Recommended Configuration:")
        print(yaml.dump(recommendations, default_flow_style=False))

        # Save to YAML if output file is provided
        if args.output:
            save_to_yaml(recommendations, args.output)
            print(f"Recommendations saved to {args.output}")

if __name__ == "__main__":
    main()