DeepSeek-R1 vs OpenAI o1: A guide to reasoning model setup and evaluation

apt-get update
apt-get install -y curl
curl https://ollama.ai/install.sh | sh
ollama pull deepseek-r1:14b
ollama serve > server.log 2>&1 &
ollama --version

pip install torch wandb weave langchain-ollama accelerate transformers


import requests
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama.llms import OllamaLLM
import transformers
import torch
import weave; weave.init("r1_local_inference")

# Define the prompt template
template = """System: {system}
User: {user}
Response:"""
prompt = ChatPromptTemplate.from_template(template)

# Input messages for inference
system_message = "You are a pirate chatbot who always responds in pirate speak!"
user_message = "Who are you?"


# Function to check if Ollama server is running
def is_ollama_running():
    try:
        response = requests.get("http://localhost:11434", timeout=2)
        return response.status_code == 200
    except requests.ConnectionError:
        return False

# Hugging Face model setup
@weave.op
def run_huggingface_inference(system_message, user_message):
    print("Using Hugging Face for inference...")
    model_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B"
    pipeline = transformers.pipeline(
        "text-generation",
        model=model_id,
        model_kwargs={"torch_dtype": torch.bfloat16},
        device_map="auto",
    )
    messages = [
        {"role": "system", "content": system_message},
        {"role": "user", "content": user_message},
    ]
    outputs = pipeline(
        messages,
        max_new_tokens=32768,
        temperature=0.6,
        top_p=0.95,
    )
    return outputs[0]["generated_text"]

# Ollama inference setup
@weave.op
def run_ollama_inference(system_message, user_message):
    print("Using Ollama for inference...")
    model = OllamaLLM(
        model="deepseek-r1:14b",
        temperature=0.6,
        top_p=0.95,
        max_tokens=32768,
    )
    chain = prompt | model
    response = chain.invoke({"system": system_message, "user": user_message})
    return response

# Main function to decide which backend to use
if __name__ == "__main__":
    if is_ollama_running():
        response = run_ollama_inference(system_message, user_message)
    else:
        response = run_huggingface_inference(system_message, user_message)
    print("Generated Response:")
    print(response)


pip install weave openai

import os
import asyncio
import weave
from openai import OpenAI

# Initialize Weave
weave.init("deepseek_r1_api")

# Set up your DeepSeek-R1 API key
r1_api_key = os.getenv("DEEPSEEK_API_KEY")  # Replace with your API key or set it as an environment variable

# Initialize the DeepSeek-R1 API client
r1_client = OpenAI(api_key=r1_api_key, base_url="https://api.deepseek.com")

# API Inference Function with Weave Logging
@weave.op
async def r1_api_inference(prompt: str) -> str:

    # Perform inference using the API client
    response = r1_client.chat.completions.create(
        model="deepseek-reasoner",
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content


if __name__ == "__main__":
    example_prompt = "What is the derivative of x^3 + 5x^2?"
    try:
        # Run the inference and log the results with Weave
        api_result = asyncio.run(r1_api_inference(example_prompt))
        print("DeepSeek-R1 API Result:")
        print(api_result)


    except Exception as e:
        print(f"An error occurred: {e}")

import json
import asyncio
from openai import AzureOpenAI
import weave

# Initialize Weave
weave.init("aime_evaluation")

# Define model IDs
o1_model_id = "your o1 model id"
o1_mini_model_id = "your o1 mini model id"

# Initialize AzureOpenAI clients
az_o1_client = AzureOpenAI(
    azure_endpoint="https://your-azure-endpoint.openai.azure.com/openai/deployments/o1/chat/completions?api-version=2024-09-01-preview",
    api_key="your-azure-api-key",
    api_version="2024-09-01-preview"
)

az_o1mini_client = AzureOpenAI(
    azure_endpoint="https://your-azure-endpoint.openai.azure.com/openai/deployments/o1-mini/chat/completions?api-version=2024-09-01-preview",
    api_key="your-azure-api-key",
    api_version="2024-09-01-preview"
)

@weave.op
def run_inference(prompt, client, model_id):
    try:
        response = client.chat.completions.create(
            model=model_id,
            messages=[
                {"role": "user", "content": prompt}
            ]
        )
        response_json = json.loads(response.model_dump_json(indent=2))
        choices = response_json.get("choices", [])
        if choices:
            content = choices[0].get("message", {}).get("content", "")
            print("Generated Content:")
            print(content)
            return content
        else:
            print("No content found in response")
            return None
    except Exception as e:
        print(f"Failed to get response: {e}")
        return None

# Main function
async def main():
    prompt = "What is the derivative of x^2?"
    system_message = "Solve the following problem. Put your final answer within \\boxed{}:"

    # Run inference with O1 model
    print("Running inference with O1 model...")
    o1_response = run_inference(f"{system_message} {prompt}", az_o1_client, o1_model_id)
    print(f"O1 Response: {o1_response}")

    # Run inference with O1-Mini model
    print("Running inference with O1-Mini model...")
    o1mini_response = run_inference(f"{system_message} {prompt}", az_o1mini_client, o1_mini_model_id)
    print(f"O1-Mini Response: {o1mini_response}")

if __name__ == "__main__":
    asyncio.run(main())

import os
import asyncio
import requests
from litellm import acompletion
from datasets import load_dataset
from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama.llms import OllamaLLM
from openai import OpenAI
import json
from openai import AzureOpenAI
import weave; weave.init("aime_evaluation") # Initialize Weave

az_4o_client = AzureOpenAI(
    azure_endpoint="your azure 4o endpoint url",
    api_key="your 4o azure api key",
    api_version="2024-09-01-preview"
)


o1_model_id = "your azure o1 model id"
o1_mini_model_id = "your azure o1 mini model id"

# Initialize AzureOpenAI clients for o1 and o1-mini models
az_o1_client = AzureOpenAI(
    azure_endpoint="your o1 enpoint url",
    api_key="your o1 api key",
    api_version="2024-09-01-preview"
)

az_o1mini_client = AzureOpenAI(
    azure_endpoint="your o1 mini enpoint url",
    api_key="your o1 mini api key",
    api_version="2024-09-01-preview"
)


r1_api_key = "your r1 api key"
r1_client = OpenAI(api_key=r1_api_key, base_url="https://api.deepseek.com")


# Check if Ollama is running
def is_ollama_running():
    try:
        response = requests.get("http://localhost:11434", timeout=2)
        return response.status_code == 200
    except requests.ConnectionError:
        print("OLLAMA IS NOT RUNNING!!")
        return False

USE_OLLAMA = is_ollama_running()

# Initialize models based on Ollama availability
r1_model = None
if USE_OLLAMA:
    print("Ollama is running. Using Ollama for inference.")
    r1_model = OllamaLLM(model="deepseek-r1:14b", temperature=0.6, top_p=0.95, max_tokens=32768)

# Consistent system message for all models
system_message = "Solve the following problem. put your final answer within \boxed{}: "


# Function to perform inference using the AzureOpenAI client
def run_inference(prompt, client, model_id):

    try:
        response = client.chat.completions.create(
        
            model=model_id,
            messages=[
                {"role": "user", "content": prompt}
            ]
        )
        
        # Parse the response
        response_json = json.loads(response.model_dump_json(indent=2))
        choices = response_json.get("choices", [])
        
        if choices:
            content = choices[0].get("message", {}).get("content", "")
            print("Generated Content:")
            print(content)
            return content
        else:
            print("No content found in response")
            return None
            
    except Exception as e:
        print(f"Failed to get response: {e}")
        return None


async def o1_inference(prompt: str, model_id: str) -> str:
    """
    Generate steps for solving the problem using AzureOpenAI clients for o1 and o1-mini.
    """
    client = az_o1_client if model_id == o1_model_id else az_o1mini_client
    return run_inference(f"{system_message}{prompt}", client, model_id)


# Ollama inference function
async def ollama_r1_inference(prompt: str) -> str:
    # Define the input to the prompt template
    inputs = {
        "system": "",
        "user": system_message + prompt,
    }

    # Define the prompt template
    template = """
User: {user}
Response:"""
    prompt_template = ChatPromptTemplate.from_template(template)

    # Create the chain and invoke it
    chain = prompt_template | r1_model
    response = chain.invoke(inputs)
    return response


class R1APIModel(weave.Model):
    @weave.op
    async def predict(self, text: str) -> str:
        messages = [{"role": "user", "content": system_message + text}]
        response = r1_client.chat.completions.create(
            model="deepseek-reasoner",
            messages=messages
        )
        return response.choices[0].message.content
    

class O1MiniModel(weave.Model):
    @weave.op
    async def predict(self, text: str) -> str:
        return await o1_inference(text, model_id=o1_mini_model_id)


# Define the o1-mini model
class O1Model(weave.Model):
    @weave.op
    async def predict(self, text: str) -> str:
        return await o1_inference(text, model_id=o1_model_id)


# Define the R1-14B model
class R1_14B_Model(weave.Model):
    @weave.op
    async def predict(self, text: str) -> str:
        return await ollama_r1_inference(text)



@weave.op
async def gpt4o_scorer(label: str, model_output: str) -> dict:
    """Score the model's output by comparing it with the ground truth."""
    query = f"""
    YOU ARE A LLM JUDGE DETERMINING IF THE FOLLOWING MODEL GENERATED ANSWER IS THE SAME AS THE CORRECT ANSWER 
    I WILL GIVE YOU THE LAST 100 CHARS OF THE MODEL'S REASONING PATH, WHICH WILL CONTAIN THE FINAL ANSWER -> 

    Model's Answer (last 100 chars): {str(model_output)[-100:]}
    Correct Answer: {label}
    
    Your task:
    1. State the model's predicted answer (answer only).
    2. State the ground truth (answer only).
    3. Determine if the model's final answer is correct (ignore formatting differences, etc.). RESPOND with the predicted and ground truth answer, followed with a JSON object containing the correctness encapsulated within the following delimiters:
       ```json
       {{ "correctness": true/false }}
       ```
    """
    
    # Perform inference using AzureOpenAI client
    response = run_inference(query, az_4o_client, "gpt-4o")
    
    if response is None:
        return {"correctness": False, "reasoning": "Inference failed."}
    
    try:
        # Extract correctness JSON object from the response
        json_start = response.index("```json") + 7
        json_end = response.index("```", json_start)
        correctness = json.loads(response[json_start:json_end].strip()).get("correctness", False)
    except (ValueError, IndexError):
        correctness = False

    return {"correctness": correctness, "reasoning": response}




# Load and preprocess dataset
def load_ds():
    print("Loading AIME dataset...")
    dataset = load_dataset("Maxwell-Jia/AIME_2024")["train"] # no test set here 
    return [{"text": row["Problem"], "label": row["Answer"]} for row in dataset]


# Run evaluations for each model
async def run_evaluations():
    print("Loading dataset...")
    dataset = load_ds()
    print("Initializing models...")


    models = {
        "o1": O1Model(),
        "o1-mini": O1MiniModel(),
        "r1_api": R1APIModel()
    }

    if USE_OLLAMA:
        models["r1-14b"] = R1_14B_Model()


    print("Preparing dataset for evaluation...")
    dataset_prepared = [{"text": row["text"], "label": row["label"]} for row in dataset]  

    print("Running evaluations...")
    scorers = [gpt4o_scorer]
    for model_name, model in models.items():
        print(f"\nEvaluating {model_name}...")
        evaluation = weave.Evaluation(
            dataset=dataset_prepared,
            scorers=scorers,
            name=f"{model_name} Evaluation"
        )
        results = await evaluation.evaluate(model)
        print(f"Results for {model_name}: {results}")

if __name__ == "__main__":
    asyncio.run(run_evaluations())