Download components/ethical_learner.py from TRuCAL-Labs/TRuCAL: direct link, hf CLI and curl.
- Browser
- Download file 6.15 kB
-
https://huggingface.co/datasets/TRuCAL-Labs/TRuCAL/resolve/main/components/ethical_learner.py
- Command line
-
hf download hf://datasets/TRuCAL-Labs/TRuCAL/components/ethical_learner.py
-
curl -L -o ethical_learner.py https://huggingface.co/datasets/TRuCAL-Labs/TRuCAL/resolve/main/components/ethical_learner.py
6.15 kB
| """ | |
| Ethical Learner Module for TRuCAL | |
| Integrates the RecursiveLearner with the existing EthicalProcessor | |
| for a complete ethical reasoning and learning system. | |
| """ | |
| from typing import Dict, Any, Optional, Tuple | |
| import torch | |
| from .ethical_processor import EthicalProcessor | |
| from .recursive_learner import RecursiveLearner | |
| class EthicalLearner: | |
| """ | |
| A unified ethical reasoning system that combines: | |
| - Rule-based ethical frameworks (from EthicalProcessor) | |
| - Case-based learning (from RecursiveLearner) | |
| """ | |
| def __init__(self, | |
| casebase_path: str = 'casebase.json', | |
| similarity_threshold: float = 0.6, | |
| model_name: str = 'all-MiniLM-L6-v2', | |
| d_model: int = 512): | |
| """ | |
| Initialize the ethical learner. | |
| Args: | |
| casebase_path: Path to save/load the casebase | |
| similarity_threshold: Minimum similarity score (0-1) to consider a match | |
| model_name: Name of the sentence transformer model to use for embeddings | |
| d_model: Dimensionality of the ethical processor model | |
| """ | |
| self.ethical_processor = EthicalProcessor(d_model=d_model) | |
| self.recursive_learner = RecursiveLearner( | |
| casebase_path=casebase_path, | |
| similarity_threshold=similarity_threshold, | |
| model_name=model_name | |
| ) | |
| def process_query(self, query: str, context: Optional[Dict] = None) -> Dict[str, Any]: | |
| """ | |
| Process an ethical query using both rule-based and case-based reasoning. | |
| Args: | |
| query: The ethical question or scenario | |
| context: Additional context for the query | |
| Returns: | |
| Dictionary containing the response and metadata | |
| """ | |
| # First try to get a response from the case-based learner | |
| case_response, case_metadata = self.recursive_learner.get_response(query) | |
| # If we have a good match, use it | |
| if case_metadata.get('similarity', 0) >= self.recursive_learner.similarity_threshold: | |
| # Apply ethical processing to the case response | |
| ethical_analysis = self.ethical_processor.analyze(query) | |
| return { | |
| 'response': case_response, | |
| 'source': 'case_based', | |
| 'confidence': case_metadata['similarity'], | |
| 'case_id': case_metadata.get('case_id'), | |
| 'ethical_analysis': ethical_analysis, | |
| 'metadata': { | |
| 'case_metadata': case_metadata, | |
| 'ethical_frameworks': self.ethical_processor.get_active_frameworks() | |
| } | |
| } | |
| # If no good case match, use the ethical processor | |
| ethical_response = self.ethical_processor.process(query, context or {}) | |
| return { | |
| 'response': ethical_response, | |
| 'source': 'rule_based', | |
| 'confidence': 1.0, # High confidence in rule-based responses | |
| 'metadata': { | |
| 'ethical_frameworks': self.ethical_processor.get_active_frameworks(), | |
| 'development_phase': self.ethical_processor.get_development_phase() | |
| } | |
| } | |
| def add_case(self, question: str, response: str, tags: List[str] = None, | |
| metadata: Optional[Dict] = None) -> Dict: | |
| """ | |
| Add a new case to the casebase. | |
| Args: | |
| question: The ethical question or scenario | |
| response: The response or analysis | |
| tags: Optional list of tags for categorization | |
| metadata: Additional metadata about the case | |
| Returns: | |
| Dictionary with status and case information | |
| """ | |
| case = self.recursive_learner.add_case( | |
| question=question, | |
| response=response, | |
| tags=tags, | |
| metadata=metadata or {} | |
| ) | |
| return { | |
| 'status': 'success', | |
| 'case_id': id(case), | |
| 'similarity': 1.0, # New case, so perfect match to itself | |
| 'total_cases': len(self.recursive_learner.casebase) | |
| } | |
| def provide_feedback(self, case_id: int, was_helpful: bool): | |
| """ | |
| Provide feedback on a case's helpfulness. | |
| Args: | |
| case_id: The ID of the case | |
| was_helpful: Whether the response was helpful | |
| """ | |
| self.recursive_learner.provide_feedback(case_id, was_helpful) | |
| def get_stats(self) -> Dict[str, Any]: | |
| """Get statistics about the ethical learner.""" | |
| stats = self.recursive_learner.get_stats() | |
| stats.update({ | |
| 'ethical_frameworks': self.ethical_processor.get_active_frameworks(), | |
| 'development_phase': self.ethical_processor.get_development_phase() | |
| }) | |
| return stats | |
| def save(self): | |
| """Save the current state of the learner.""" | |
| self.recursive_learner._save_casebase() | |
| def load(self): | |
| """Load the saved state of the learner.""" | |
| self.recursive_learner._load_casebase() | |
| # Example usage | |
| if __name__ == "__main__": | |
| # Initialize the ethical learner | |
| learner = EthicalLearner() | |
| # Example query | |
| query = "Is it ethical to use personal data for targeted advertising?" | |
| result = learner.process_query(query) | |
| print(f"Query: {query}") | |
| print(f"Response: {result['response']}") | |
| print(f"Source: {result['source']}") | |
| print(f"Confidence: {result['confidence']:.2f}") | |
| # Add a new case | |
| print("\nAdding new case...") | |
| learner.add_case( | |
| question="What are the ethics of data privacy in AI?", | |
| response=("Data privacy in AI involves balancing innovation with individual rights. " | |
| "Key considerations include informed consent, data minimization, purpose limitation, " | |
| "and ensuring transparency about how data is used."), | |
| tags=["privacy", "AI", "ethics"] | |
| ) | |
| # Get stats | |
| print("\nLearner statistics:") | |
| print(learner.get_stats()) | |