Complete_Finetuning

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.11
+ 
+# Set the working directory
+
+WORKDIR /app
+ 
+# Update package lists, install dependencies, and clean up to reduce image size
+
+RUN apt update && apt install -y \
+
+    libgl1-mesa-glx \
+
+    curl && \
+
+    rm -rf /var/lib/apt/lists/*
+ 
+# Copy the requirements file first to leverage Docker caching
+
+COPY requirements.txt ./
+ 
+# Install Python dependencies with upgraded pip
+RUN python3 -m pip install --upgrade pip && \
+    python3 -m pip install --no-cache-dir -r requirements.txt && \
+    python3 -m pip list
+
+# Environment variables
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+  
+# Copy the rest of the application code
+
+COPY . .
+ 
+# Set the default command to run your application
+
+CMD ["python3", "handler.py"]
+ 

evaluation_handler.py

@@ -0,0 +1,83 @@
+import logging
+import json
+import subprocess
+import time
+from typing import Dict, Any
+import runpod
+
+def handler(job: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Handler function for running `llm_evaluation.py` in a RunPod serverless environment.
+
+    Args:
+        job (Dict[str, Any]): The job input containing parameters for evaluation.
+
+    Returns:
+        Dict[str, Any]: Evaluation results or error details.
+    """
+    start_time = time.time()
+    logging.info("Evaluation handler started.")
+
+    # Extract job input
+    job_input = job.get('input', {})
+    model_name = job_input.get('model_name')
+
+    if not model_name:
+        logging.error("Missing required field: 'model_name'")
+        return {
+            "status": "error",
+            "error": "Missing required field: 'model_name'"
+        }
+
+    try:
+        # Prepare evaluation input
+        evaluation_input = json.dumps({"model_name": model_name})
+        logging.info(f"Starting evaluation for model: {model_name}")
+
+        # Run `llm_evaluation.py` as a subprocess
+        result = subprocess.run(
+            ['python3', 'llm_evaluation.py', evaluation_input],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        logging.info("Model evaluation completed successfully.")
+
+        # Attempt to parse the output as JSON
+        try:
+            evaluation_results = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            evaluation_results = {"raw_output": result.stdout}
+
+        return {
+            "status": "success",
+            "model_name": model_name,
+            "processing_time": time.time() - start_time,
+            "evaluation_results": evaluation_results
+        }
+
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Evaluation process failed: {e.stderr}")
+        return {
+            "status": "error",
+            "error": f"Evaluation process failed: {e.stderr}",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+    except Exception as e:
+        logging.error(f"Unhandled error during evaluation: {str(e)}")
+        return {
+            "status": "error",
+            "error": str(e)
+        }
+
+if __name__ == "__main__":
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s"
+    )
+
+    # Start RunPod serverless endpoint
+    runpod.serverless.start({"handler": handler})
+

handler.py

@@ -0,0 +1,186 @@
+import logging
+import runpod
+import os
+import shutil
+import uuid
+import json
+import time
+import subprocess
+from typing import Dict, Any
+from azure.storage.blob import BlobServiceClient
+
+def get_azure_connection_string():
+    """Get Azure connection string from environment variable"""
+    conn_string ="DefaultEndpointsProtocol=https;AccountName=transcribedblobstorage;AccountKey=1Z7yKPP5DLbxnoHdh7NmHgwg3dFLaDiYHUELdid7dzfzR6/DvkZnnzpJ30lrXIMhtD5GYKo+71jP+AStC1TEvA==;EndpointSuffix=core.windows.net"
+    if not conn_string:
+        raise ValueError("Azure Storage connection string not found in environment variables")
+    return conn_string
+
+# def upload_file(file_path: str, blob_name: str, container_name: str) -> str:
+#     """Upload a file to Azure Blob Storage"""
+#     if not os.path.isfile(file_path):
+#         raise FileNotFoundError(f"The specified file does not exist: {file_path}")
+
+#     connection_string = get_azure_connection_string()
+#     blob_service_client = BlobServiceClient.from_connection_string(connection_string)
+#     container_client = blob_service_client.get_container_client(container_name)
+    
+#     with open(file_path, 'rb') as file:
+#         blob_client = container_client.get_blob_client(blob_name)
+#         blob_client.upload_blob(file)
+#         return blob_client.blob_name
+
+def download_blob(blob_name: str, download_file_path: str, container_name: str) -> None:
+    """Download a file from Azure Blob Storage"""
+    connection_string = get_azure_connection_string()
+    blob_service_client = BlobServiceClient.from_connection_string(connection_string)
+    container_client = blob_service_client.get_container_client(container_name)
+    blob_client = container_client.get_blob_client(blob_name)
+
+    os.makedirs(os.path.dirname(download_file_path), exist_ok=True)
+    
+    with open(download_file_path, "wb") as download_file:
+        download_stream = blob_client.download_blob()
+        download_file.write(download_stream.readall())
+    logging.info(f"Blob '{blob_name}' downloaded to '{download_file_path}'")
+
+def clean_directory(directory: str) -> None:
+    """Clean up a directory by removing all files and subdirectories"""
+    if os.path.exists(directory):
+        for filename in os.listdir(directory):
+            file_path = os.path.join(directory, filename)
+            try:
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.remove(file_path)
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+            except Exception as e:
+                logging.error(f'Failed to delete {file_path}. Reason: {e}')
+
+def handler(job: Dict[str, Any]) -> Dict[str, Any]:
+    start_time = time.time()
+    logging.info("Handler function started")
+
+    # Extract job input and validate
+    job_input = job.get('input', {})
+    required_fields = ['pdf_file', 'system_prompt', 'model_name', 'max_step', 'learning_rate', 'epochs', 'container']
+    missing_fields = [field for field in required_fields if field not in job_input]
+    
+    if missing_fields:
+        return {
+            "status": "error",
+            "error": f"Missing required fields: {', '.join(missing_fields)}"
+        }
+
+    work_dir = os.path.abspath(f"/tmp/work_{str(uuid.uuid4())}")
+    
+    try:
+        # Create working directory
+        os.makedirs(work_dir, exist_ok=True)
+        logging.info(f"Working directory created: {work_dir}")
+
+        # Download and process PDF
+        download_path = os.path.join(work_dir, "Input_PDF.pdf")
+        download_blob(job_input['pdf_file'], download_path, job_input['container'])
+
+        # Verify downloaded file exists
+        if not os.path.exists(download_path):
+            raise FileNotFoundError(f"Downloaded PDF file not found at: {download_path}")
+
+        # Save pipeline input as a JSON file
+        pipeline_input_path = os.path.join(work_dir, "pipeline_input.json")
+        pipeline_input = {
+            "pdf_file": download_path,
+            "system_prompt": job_input['system_prompt'],
+            "model_name": job_input['model_name'],
+            "max_step": job_input['max_step'],
+            "learning_rate": job_input['learning_rate'],
+            "epochs": job_input['epochs']
+        }
+        
+        with open(pipeline_input_path, 'w') as f:
+            json.dump(pipeline_input, f)
+
+        # Run fine-tuning and evaluation
+        return run_pipeline_and_evaluate(pipeline_input_path, job_input['model_name'], start_time)
+
+    except Exception as e:
+        error_message = f"Job failed after {time.time() - start_time:.2f} seconds: {str(e)}"
+        logging.error(error_message)
+        return {
+            "status": "error",
+            "error": error_message
+        }
+
+    finally:
+        # Clean up working directory
+        try:
+            clean_directory(work_dir)
+            os.rmdir(work_dir)
+        except Exception as e:
+            logging.error(f"Failed to clean up working directory: {str(e)}")
+
+def run_pipeline_and_evaluate(pipeline_input_path: str, model_name: str, start_time: float) -> Dict[str, Any]:
+    try:
+        # Read the pipeline input file
+        with open(pipeline_input_path, 'r') as f:
+            pipeline_input = json.load(f)
+            
+        # Convert the input to a JSON string for passing as an argument
+        pipeline_input_str = json.dumps(pipeline_input)
+        
+        # Run fine-tuning pipeline with JSON string as argument
+        logging.info(f"Running pipeline with input: {pipeline_input_str[:100]}...")
+        finetuning_result = subprocess.run(
+            ['python3', 'Finetuning_Pipeline.py', pipeline_input_str],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        logging.info("Fine-tuning completed successfully")
+
+        # Run evaluation
+        evaluation_input = json.dumps({"model_name": model_name})
+        result = subprocess.run(
+            ['python3', 'llm_evaluation.py', evaluation_input],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        try:
+            # Try to parse the evaluation output as JSON
+            evaluation_results = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            # If parsing fails, use the raw output
+            evaluation_results = {"raw_output": result.stdout}
+
+        return {
+            "status": "success",
+            "model_name": f"PharynxAI/{model_name}",
+            "processing_time": time.time() - start_time,
+            "evaluation_results": evaluation_results
+        }
+
+    except subprocess.CalledProcessError as e:
+        error_message = f"Pipeline process failed: {e.stderr}"
+        logging.error(error_message)
+        return {
+            "status": "error",
+            "error": error_message,
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+    except Exception as e:
+        error_message = f"Pipeline execution failed: {str(e)}"
+        logging.error(error_message)
+        return {
+            "status": "error",
+            "error": error_message
+        }
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    runpod.serverless.start({"handler": handler})

llm_evaluation.py

@@ -0,0 +1,119 @@
+import json
+from sentence_transformers import SentenceTransformer, util
+import nltk
+from openai import OpenAI
+import os
+from nltk.translate.bleu_score import sentence_bleu, SmoothingFunction
+import time
+import asyncio
+import logging
+import sys
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+# Download necessary NLTK resources
+nltk.download('punkt')
+def load_input_data():
+    """Load input data from command line arguments."""
+    try:
+        input_data = json.loads(sys.argv[1])
+        return input_data
+    except json.JSONDecodeError as e:
+        logging.error(f"Failed to decode JSON input: {e}")
+        sys.exit(1)
+
+def initialize_openai_client(api_key, base_url):
+    """Initialize the OpenAI client."""
+    return OpenAI(api_key=api_key, base_url=base_url)
+
+def load_model():
+    """Load the pre-trained models for evaluation."""
+    semantic_model = SentenceTransformer('all-MiniLM-L6-v2')
+    return semantic_model
+
+def evaluate_semantic_similarity(expected_response, model_response, semantic_model):
+    """Evaluate semantic similarity using Sentence-BERT."""
+    expected_embedding = semantic_model.encode(expected_response, convert_to_tensor=True)
+    model_embedding = semantic_model.encode(model_response, convert_to_tensor=True)
+    similarity_score = util.pytorch_cos_sim(expected_embedding, model_embedding)
+    return similarity_score.item()
+
+def evaluate_bleu(expected_response, model_response):
+    """Evaluate BLEU score using NLTK's sentence_bleu."""
+    expected_tokens = nltk.word_tokenize(expected_response.lower())
+    model_tokens = nltk.word_tokenize(model_response.lower())
+    smoothing_function = nltk.translate.bleu_score.SmoothingFunction().method1
+    bleu_score = nltk.translate.bleu_score.sentence_bleu([expected_tokens], model_tokens, smoothing_function=smoothing_function)
+    return bleu_score
+
+async def create_with_retries(client, **kwargs):
+    """Retry mechanism for handling transient server errors asynchronously."""
+    for attempt in range(3):  # Retry up to 3 times
+        try:
+            return client.chat.completions.create(**kwargs)
+        except Exception as e:  # Catch all exceptions since 'InternalServerError' is not defined
+            if attempt < 2:  # Only retry for the first two attempts
+                print(f"Error: {e}, retrying... (Attempt {attempt + 1}/3)")
+                await asyncio.sleep(5)  # Wait for 5 seconds before retrying
+            else:
+                raise Exception("API request failed after retries") from e
+
+
+async def evaluate_model(data, model_name, client, semantic_model):
+    """Evaluate the model using the provided data."""
+    semantic_scores = []
+    bleu_scores = []
+
+    for entry in data:
+        prompt = entry['prompt']
+        expected_response = entry['response']
+
+        # Create a chat completion using OpenAI API
+        response = await create_with_retries(
+            client,
+            model=f"PharynxAI/{model_name}",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.7,
+            max_tokens=200,
+            timeout=300
+        )
+
+        model_response = response.choices[0].message.content  # Extract model's response
+
+        # Evaluate scores
+        semantic_score = evaluate_semantic_similarity(expected_response, model_response, semantic_model)
+        semantic_scores.append(semantic_score)
+
+        bleu_score = evaluate_bleu(expected_response, model_response)
+        bleu_scores.append(bleu_score)
+
+    # Calculate average scores
+    avg_semantic_score = sum(semantic_scores) / len(semantic_scores) if semantic_scores else 0
+    avg_bleu_score = sum(bleu_scores) / len(bleu_scores) if bleu_scores else 0
+
+    logging.info("\nOverall Average Scores:")
+    logging.info(f"Average Semantic Similarity: {avg_semantic_score:.4f}")
+    logging.info(f"Average BLEU Score: {avg_bleu_score:.4f}")
+
+async def main():
+    # Load input data
+    input_data = load_input_data()
+    model_name = input_data["model_name"]
+    # Initialize the OpenAI Client with your RunPod API Key and Endpoint URL
+    client = OpenAI(
+        api_key="MIGZGJKYD6PU8KTHTBQ8FMEMGP2RAW5DVXABFVFD",
+        base_url="https://api.runpod.ai/v2/6vg8gj8ia9vd1w/openai/v1",
+    )
+    # Load pre-trained models
+    semantic_model = load_model()
+    # Load your dataset (replace with your actual JSON file)
+    with open('output_json.json', 'r') as f:
+        data = json.load(f)
+
+    # Run the evaluation asynchronously
+    await evaluate_model(data, model_name, client, semantic_model)
+
+# Start the event loop
+asyncio.run(main())

report.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f25f7c33338f3e3cb56051e865440ca3014a9f4fb083581f279fb1d5ee5a767
+size 1347277

requirements.txt

@@ -0,0 +1,19 @@
+azure-storage-blob==12.14.1
+runpod
+torch==2.3.1
+xformers==0.0.27
+transformers>=4.35.0
+accelerate>=0.34.1
+bitsandbytes>=0.43.3
+trl>=0.7.1
+peft>=0.7.0
+triton
+PyPDF2==2.11.2
+PyMuPDF
+pytesseract==0.3.10
+Pillow>=9.0.0
+openai>=1.0.0
+datasets>=2.13.1
+packaging==23.0
+tqdm==4.66.1
+git+https://github.com/unslothai/unsloth.git#egg=unsloth[colab-new]