Module 4: Build Sprint 3

Understanding Your Third Ticket

Learn how to approach your third ticket in the Labs project and understand the development workflow.

Third Ticket Details

View your third ticket details and requirements on GitHub:

Third Ticket Documentation

Step-by-Step Workflow

  1. Familiarize Yourself with the Repository
    1. Read the documentation thoroughly to understand the repository. This may include API contracts, READMEs, or docs on Google/Notion.
    2. Check the README of the ticket you have been assigned to know what is expected of you.
  2. Understanding the Deliverable
    1. Check the deployed version of the product to see the expected output and match it with what you have to build.
    2. Read the example of the expected output provided in the README.
  3. Code Unit Test (if applicable)
    1. If a relevant test exists, follow the test-driven development approach to guide your development.
    2. Validate your code using the unit test to ensure you've produced the expected outcome.
  4. Code the Component/Feature
    1. Code your deliverable, the feature described in the ticket.
  5. Record a Loom Video
    1. Demonstrate the feature in the video.
    2. Provide a detailed explanation of your thought process while coding.

Approaching Your Third Feature

Learn how to implement a machine learning model interface, train and tune models, and integrate them with your API.

Implementation Checklist

  • Create a Jupyter notebook for model testing and tuning
  • Train and tune at least 3 different models
  • Implement the Machine Learning interface class
  • Add model serialization functionality
  • Integrate the model with the API
  • Test model predictions and probabilities
  • Ensure proper model saving and loading
  • Add model information endpoint
# Example Machine Learning Implementation

from pandas import DataFrame
from sklearn.ensemble import RandomForestClassifier
from joblib import dump, load
from datetime import datetime


class Machine:
    """Machine Learning interface for monster predictions."""
    
    def __init__(self, df: DataFrame):
        """Initialize the machine learning model.
        
        Args:
            df: DataFrame containing training data
        """
        self.name = "Random Forest Classifier"
        self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        target = df["Rarity"]
        features = df.drop(columns=["Rarity"])
        self.model = RandomForestClassifier()
        self.model.fit(features, target)

    def __call__(self, pred_basis: DataFrame):
        """Make predictions using the trained model.
        
        Args:
            pred_basis: DataFrame of features for prediction
            
        Returns:
            Tuple of (prediction, probability)
        """
        prediction = self.model.predict(pred_basis)[0]
        probability = self.model.predict_proba(pred_basis)[0]
        return prediction, probability

    def save(self, filepath: str):
        """Save the trained model to disk.
        
        Args:
            filepath: Path to save the model
        """
        dump(self.model, filepath)

    @classmethod
    def open(cls, filepath: str):
        """Load a saved model from disk.
        
        Args:
            filepath: Path to the saved model
            
        Returns:
            Loaded Machine instance
        """
        model = load(filepath)
        instance = cls.__new__(cls)
        instance.model = model
        return instance

    def info(self) -> str:
        """Get information about the model.
        
        Returns:
            String containing model name and timestamp
        """
        return f"Model: {self.name}, Initialized: {self.timestamp}"


# Example usage in FastAPI endpoint
@app.get("/model")
async def get_model_info():
    machine = Machine(monster_db.dataframe())
    return {"info": machine.info()}

Resources