AI Engineer

# Production-ready RAG system with vector database
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Pinecone
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationalRetrievalChain
import pinecone

class ProductionRAGSystem:
    def __init__(self, api_key: str, pinecone_env: str, index_name: str):
        # Initialize embeddings
        self.embeddings = OpenAIEmbeddings(
            model="text-embedding-ada-002",
            openai_api_key=api_key
        )
        
        # Initialize Pinecone vector store
        pinecone.init(
            api_key=api_key,
            environment=pinecone_env
        )
        
        self.vectorstore = Pinecone.from_existing_index(
            index_name=index_name,
            embedding=self.embeddings
        )
        
        # Initialize LLM
        self.llm = ChatOpenAI(
            model="gpt-4",
            temperature=0.7,
            openai_api_key=api_key
        )
        
        # Create retrieval chain
        self.qa_chain = ConversationalRetrievalChain.from_llm(
            llm=self.llm,
            retriever=self.vectorstore.as_retriever(
                search_kwargs={"k": 4}
            ),
            return_source_documents=True,
            verbose=True
        )
    
    def query(self, question: str, chat_history: list = None):
        """Query the RAG system with conversation context"""
        if chat_history is None:
            chat_history = []
        
        result = self.qa_chain({
            "question": question,
            "chat_history": chat_history
        })
        
        return {
            "answer": result["answer"],
            "sources": [doc.metadata for doc in result["source_documents"]]
        }
    
    def add_documents(self, documents: list):
        """Add new documents to the vector store"""
        texts = [doc.page_content for doc in documents]
        metadatas = [doc.metadata for doc in documents]
        
        self.vectorstore.add_texts(
            texts=texts,
            metadatas=metadatas
        )

# Usage
rag_system = ProductionRAGSystem(
    api_key="your-api-key",
    pinecone_env="us-west1-gcp",
    index_name="company-docs"
)

response = rag_system.query(
    "How do I implement authentication?",
    chat_history=[]
)

print(f"Answer: {response['answer']}")
print(f"Sources: {response['sources']}")

# ML model training with MLflow tracking
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
import pandas as pd

class MLModelPipeline:
    def __init__(self, experiment_name: str):
        mlflow.set_experiment(experiment_name)
        self.model = None
    
    def train_model(self, X: pd.DataFrame, y: pd.Series, params: dict):
        """Train model with MLflow tracking"""
        with mlflow.start_run():
            # Log parameters
            mlflow.log_params(params)
            
            # Split data
            X_train, X_test, y_train, y_test = train_test_split(
                X, y, test_size=0.2, random_state=42
            )
            
            # Train model
            self.model = RandomForestClassifier(**params)
            self.model.fit(X_train, y_train)
            
            # Make predictions
            y_pred = self.model.predict(X_test)
            
            # Calculate metrics
            metrics = {
                "accuracy": accuracy_score(y_test, y_pred),
                "f1_score": f1_score(y_test, y_pred, average='weighted'),
                "precision": precision_score(y_test, y_pred, average='weighted'),
                "recall": recall_score(y_test, y_pred, average='weighted')
            }
            
            # Log metrics
            mlflow.log_metrics(metrics)
            
            # Log model
            mlflow.sklearn.log_model(
                self.model,
                "model",
                registered_model_name="production_classifier"
            )
            
            return metrics
    
    def deploy_model(self, model_uri: str):
        """Load and deploy model from MLflow"""
        self.model = mlflow.sklearn.load_model(model_uri)
        return self.model
    
    def predict_with_monitoring(self, X: pd.DataFrame):
        """Make predictions with monitoring"""
        if self.model is None:
            raise ValueError("Model not loaded")
        
        # Make predictions
        predictions = self.model.predict(X)
        
        # Log inference metrics
        mlflow.log_metric("inference_count", len(predictions))
        
        return predictions

# Usage
pipeline = MLModelPipeline("user_churn_prediction")

# Train model
metrics = pipeline.train_model(
    X=features_df,
    y=labels_series,
    params={
        "n_estimators": 100,
        "max_depth": 10,
        "min_samples_split": 5
    }
)

print(f"Model Performance: {metrics}")

# Bias detection and fairness evaluation
from fairlearn.metrics import MetricFrame, selection_rate
from fairlearn.reductions import ExponentiatedGradient, DemographicParity
import pandas as pd

class FairnessEvaluator:
    def __init__(self, sensitive_features: list):
        self.sensitive_features = sensitive_features
    
    def evaluate_fairness(self, y_true, y_pred, sensitive_data: pd.DataFrame):
        """Evaluate model fairness across demographic groups"""
        # Calculate metrics by group
        metric_frame = MetricFrame(
            metrics={
                "accuracy": accuracy_score,
                "selection_rate": selection_rate,
                "false_positive_rate": self._false_positive_rate,
                "false_negative_rate": self._false_negative_rate
            },
            y_true=y_true,
            y_pred=y_pred,
            sensitive_features=sensitive_data[self.sensitive_features]
        )
        
        # Calculate disparities
        disparities = {
            metric: metric_frame.difference(method="between_groups")[metric]
            for metric in metric_frame.by_group.columns
        }
        
        return {
            "by_group": metric_frame.by_group,
            "overall": metric_frame.overall,
            "disparities": disparities
        }
    
    def mitigate_bias(self, X_train, y_train, sensitive_train, base_estimator):
        """Train model with bias mitigation"""
        mitigator = ExponentiatedGradient(
            base_estimator,
            constraints=DemographicParity()
        )
        
        mitigator.fit(X_train, y_train, sensitive_features=sensitive_train)
        
        return mitigator
    
    @staticmethod
    def _false_positive_rate(y_true, y_pred):
        tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
        return fp / (fp + tn)
    
    @staticmethod
    def _false_negative_rate(y_true, y_pred):
        tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
        return fn / (fn + tp)

# Usage
evaluator = FairnessEvaluator(sensitive_features=["gender", "race"])

fairness_results = evaluator.evaluate_fairness(
    y_true=y_test,
    y_pred=predictions,
    sensitive_data=demographic_data
)

print("Fairness Evaluation:")
print(fairness_results["by_group"])
print(f"\nDisparities: {fairness_results['disparities']}")