Skills System

Skills in Airtrain represent atomic capabilities that can be combined to form complex task behaviors. Each skill is a self-contained unit with defined inputs, outputs, processing logic, and validation rules.

Skill Structure

A skill consists of several key components:

from airtrain import Skill, InputSchema, OutputSchema

class TextAnalysisSkill(Skill):
    input_schema = InputSchema(...)
    output_schema = OutputSchema(...)
    
    def process(self, input_data):
        # Core processing logic
        pass
        
    def validate_input(self, input_data):
        # Input validation logic
        pass
        
    def validate_output(self, output_data):
        # Output validation logic
        pass
        
    def evaluate(self, test_dataset=None):
        # Evaluation logic
        pass

Skill Components

Schema Definitions

Each skill requires both input and output schemas:

class SentimentAnalysisInput(InputSchema):
    text: str
    language: Optional[str] = "en"
    model_preferences: Optional[Dict] = {}

class SentimentAnalysisOutput(OutputSchema):
    sentiment: float
    confidence: float
    analysis_metadata: Dict

Processor Method

The core logic implementation of the skill:

def process(self, input_data: SentimentAnalysisInput) -> SentimentAnalysisOutput:
    """
    Process the input and generate output according to defined schemas.
    
    Args:
        input_data: Validated input conforming to input_schema
        
    Returns:
        Output conforming to output_schema
        
    Raises:
        ProcessingError: If processing fails
    """
    # Implementation of core skill logic
    pass

Validators

Two types of validators ensure data integrity:

def validate_input(self, input_data: Any) -> None:
    """
    Validate input data before processing.
    
    Args:
        input_data: Raw input data
        
    Raises:
        InputValidationError: If validation fails
    """
    if not isinstance(input_data.text, str):
        raise InputValidationError("Text must be a string")
    
def validate_output(self, output_data: Any) -> None:
    """
    Validate output data after processing.
    
    Args:
        output_data: Processed output data
        
    Raises:
        OutputValidationError: If validation fails
    """
    if not (-1 <= output_data.sentiment <= 1):
        raise OutputValidationError("Sentiment must be between -1 and 1")

Error Handling

Implement specific handlers for validation errors:

@handle_input_validation_error
def on_input_validation_error(self, error: InputValidationError):
    """Handle input validation failures"""
    log_error(error)
    return error.message

@handle_output_validation_error
def on_output_validation_error(self, error: OutputValidationError):
    """Handle output validation failures"""
    log_error(error)
    return error.message

Evaluator

The evaluation system for skill performance:

def evaluate(self, test_dataset: Optional[Dataset] = None) -> EvaluationResult:
    """
    Evaluate skill performance.
    
    Args:
        test_dataset: Optional dataset for evaluation
        
    Returns:
        EvaluationResult containing metrics
    """
    if not test_dataset:
        test_dataset = self.get_default_test_dataset()
        
    results = []
    for test_case in test_dataset:
        output = self.process(test_case.input)
        results.append(self.compare_output(output, test_case.expected))
        
    return EvaluationResult(results)

Skill Sets

Skills can be grouped into skill sets for better organization and reuse:

class TextAnalysisSkillSet(SkillSet):
    required_permissions = [
        NLPServicePermission,
        StoragePermission
    ]
    
    skills = [
        SentimentAnalysisSkill,
        EntityExtractionSkill,
        TextClassificationSkill
    ]

Skill Set Management

• Group related skills
• Share common permissions
• Manage shared resources
• Provide unified interfaces

Resource Management

Skills and skill sets can share resources:

class NLPResources(ResourceGroup):
    model_cache: ModelCache
    tokenizer: Tokenizer
    embeddings: EmbeddingService

Best Practices

1. Skill Design

   • Keep skills atomic and focused
   • Clear input/output contracts
   • Comprehensive validation rules
   • Meaningful evaluation metrics

2. Validation

   • Validate both input and output
   • Include type checking
   • Add domain-specific rules
   • Provide clear error messages

3. Evaluation

   • Define relevant metrics
   • Create comprehensive test datasets
   • Include edge cases
   • Monitor performance over time

4. Error Handling

   • Implement specific error types
   • Provide recovery mechanisms
   • Log validation failures
   • Include debugging context

Example Implementation

Here's a complete example of a skill implementation:

class TextSummarizationSkill(Skill):
    input_schema = TextInputSchema
    output_schema = SummaryOutputSchema
    
    def process(self, input_data):
        validated_text = self.validate_input(input_data)
        summary = self.summarize_text(validated_text)
        validated_summary = self.validate_output(summary)
        return validated_summary
        
    def validate_input(self, input_data):
        if len(input_data.text) < 10:
            raise InputValidationError("Text too short for summarization")
        return input_data.text
        
    def validate_output(self, output_data):
        if len(output_data.summary) > len(output_data.original_text):
            raise OutputValidationError("Summary longer than original text")
        return output_data
        
    def evaluate(self, test_dataset=None):
        # Evaluate using ROUGE scores
        pass

Next Steps

Learn how to create custom skills, combine them into skill sets, and integrate them into your tasks.