Phi-3 Mini: Microsoft's Small Language Model for Edge Devices

# Step 1: Update your system packages
sudo apt update && sudo apt upgrade -y

# Step 2: Install essential Python packages
pip install torch torchvision torchaudio
pip install transformers accelerate bitsandbytes
pip install peft optimum

# Step 3: Clone the Phi-3 Mini repository
git clone https://github.com/microsoft/Phi-3.git
cd Phi-3

# Step 4: Download the pre-trained model weights
python download_model.py --model phi3-mini-4k-instruct

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
import time

def load_phi3_mini():
    model_name = "microsoft/Phi-3-mini-4k-instruct"
    
    # Load tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.float16,
        device_map="auto",
        load_in_4bit=True  # Reduce memory usage
    )
    
    return tokenizer, model

def inference(model, tokenizer, prompt):
    # Prepare the prompt
    messages = [{"role": "user", "content": prompt}]
    formatted_prompt = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        tokenize=True
    ).unsqueeze(0)
    
    # Generate response
    with torch.no_grad():
        outputs = model.generate(
            formatted_prompt,
            max_new_tokens=512,
            temperature=0.7,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id
        )
    
    # Decode and return response
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response

# Main execution
if __name__ == "__main__":
    print("Loading Phi-3 Mini model...")
    tokenizer, model = load_phi3_mini()
    print("Model loaded successfully!")
    
    # Example conversation
    while True:
        user_input = input("\nYou: ")
        if user_input.lower() in ['exit', 'quit']:
            break
        
        start_time = time.time()
        response = inference(model, tokenizer, user_input)
        end_time = time.time()
        
        print(f"Assistant: {response}")
        print(f"Response time: {end_time - start_time:.2f} seconds")

# Memory optimization settings
import torch
from transformers import BitsAndBytesConfig

# Configure 4-bit quantization
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

# Apply configuration to model loading
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    torch_dtype=torch.float16
)

import speech_recognition as sr
import pyaudio
from threading import Thread
import queue

class VoiceAssistant:
    def __init__(self):
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()
        self.response_queue = queue.Queue()
        self.is_listening = False
        
        # Initialize Phi-3 Mini (reuse from previous example)
        self.tokenizer, self.model = load_phi3_mini()
        
    def listen_for_command(self):
        with self.microphone as source:
            self.recognizer.adjust_for_ambient_noise(source)
            try:
                audio = self.recognizer.listen(source, timeout=5, phrase_time_limit=10)
                command = self.recognizer.recognize_google(audio)
                self.response_queue.put(f"user: {command}")
            except sr.WaitTimeoutError:
                return
            except sr.UnknownValueError:
                return
    
    def generate_response(self, text):
        prompt = f"Translate this to Hindi: {text}"
        response = inference(self.model, self.tokenizer, prompt)
        self.response_queue.put(f"assistant: {response}")
    
    def run(self):
        # Start listening in background thread
        listen_thread = Thread(target=self.listen_for_command)
        listen_thread.daemon = True
        listen_thread.start()
        
        while True:
            try:
                message = self.response_queue.get(timeout=1)
                print(message)
                
                # Simple command processing
                if "translate" in message.lower():
                    user_text = message.split(": ")[1]
                    self.generate_response(user_text)
                    
            except queue.Empty:
                continue

# Run the assistant
assistant = VoiceAssistant()
assistant.run()

def code_generator(model, tokenizer, language, description):
    prompt = f"""
    Generate Python code for {language} to: {description}
    
    Requirements:
    1. Write clean, well-documented code
    2. Include error handling
    3. Follow PEP 8 standards
    4. Add comments explaining each step
    
    Code:
    """
    
    response = inference(model, tokenizer, prompt)
    return response

# Example usage
code_request = "Create a web scraper for Amazon products using Python"
generated_code = code_generator(model, tokenizer, "Python", code_request)
print(generated_code)

# Dynamic power management
import psutil
import time

def adaptive_inference(model, tokenizer, prompt, max_power_watts=10):
    # Check current power consumption
    cpu_percent = psutil.cpu_percent()
    estimated_power = cpu_percent * 0.05  # Rough estimation
    
    if estimated_power > max_power_watts:
        print("High power consumption detected, using optimized settings")
        # Reduce model complexity
        return inference_optimized(model, tokenizer, prompt)
    else:
        return standard_inference(model, tokenizer, prompt)

def optimized_generation(model, tokenizer, prompt):
    # Experiment with different temperatures
    temperatures = [0.1, 0.3, 0.5, 0.7, 0.9]
    results = []
    
    for temp in temperatures:
        response = inference(
            model, tokenizer, prompt,
            temperature=temp,
            top_p=0.95
        )
        results.append((temp, response))
    
    # Return the best response (you can implement quality scoring)
    return results[2][1]  # Middle temperature often works well