Tutorial #6: Few-Shot Learning for PLC Validation

✅ CORE MISSION OF THIS TUTORIAL

By the end of this tutorial, the reader will be able to:

• ✅ Understand what few-shot learning is in practical engineering terms
• ✅ Provide high-quality PLC examples that guide the model toward consistency
• ✅ Validate PLC logic using controlled, auditable prompts
• ✅ Prevent "creative" or unsafe reinterpretations of logic
• ✅ Prepare the foundation for structured, advisory logic reviews (Tutorial #7)

Few-shot learning is how you teach AI patterns, not rules — safely.

1️⃣ WHAT IS FEW-SHOT LEARNING?

In engineering terms:

We are not fine-tuning the model.
We are not training weights.

Instead:

• ▸ We show the LLM how a good validation looks
• ▸ It imitates the format, structure, and tone
• ▸ It becomes far more predictable

Few-shot learning directly increases:

2️⃣ REFERENCE SCENARIO — VALIDATING SIMPLE MOTOR LOGIC

We define a "golden example" for validating a minimal motor control block:

IF StartButton THEN
    MotorRunning := TRUE;
END_IF;

IF StopButton THEN
    MotorRunning := FALSE;
END_IF;

3️⃣ CONSTRUCTING A PROPER FEW-SHOT PROMPT

A few-shot validator prompt contains:

graph LR
    A[Rules] --> B[Examples]
    B --> C[Code Input]
    C --> D[Validation Output]

    style A fill:#1a1a1e,stroke:#9e4aff,stroke-width:2px,color:#fff
    style B fill:#1a1a1e,stroke:#9e4aff,stroke-width:2px,color:#fff
    style C fill:#1a1a1e,stroke:#04d9ff,stroke-width:2px,color:#fff
    style D fill:#1a1a1e,stroke:#00ff7f,stroke-width:2px,color:#00ff7f

This tutorial includes two experiments demonstrating how each layer improves reliability.

4️⃣ PRACTICAL EXPERIMENTS

⚠️ THE INTEGRATION CHALLENGE

In production: validation outputs need to feed dashboards, trigger alerts, and drive automated workflows. Free-form text breaks all of these.

Few-shot learning improves consistency, but the output is still free-form text:

# Run 1:
validation_output_1 = """
- Logic correctly sets MotorRunning TRUE on StartButton.
- Logic correctly resets MotorRunning on StopButton.
- No latches, timers, or safety logic present.
- Behavior matches expected specification.
"""

# Run 2 (same logic, slight rewording):
validation_output_2 = """
- StartButton correctly sets MotorRunning to TRUE.
- StopButton correctly resets MotorRunning to FALSE.
- Safety interlocks: none detected.
- Specification compliance: confirmed.
"""

# Run 3 (extra commentary):
validation_output_3 = """
Analysis complete. The logic behaves as expected:
- MotorRunning becomes TRUE when StartButton activates
- MotorRunning becomes FALSE when StopButton activates
No safety logic or fault handling was found in this block.
"""

# Now try to parse them:
def has_safety_logic(text):
    if "no safety logic" in text.lower():
        return False  # Works for Run 1
    if "safety interlocks: none" in text.lower():
        return False  # Works for Run 2
    if "no safety logic or fault handling" in text.lower():
        return False  # Works for Run 3
    return None  # Can't determine

# Change one word → parser breaks
# Reorder bullets → parser breaks
# Add commentary → parser breaks
# Whitespace changes → parser breaks

# Problem: Free text requires fragile, unmaintainable string parsing

Tutorial #9 will teach you schema-first design + validation + retry loops — forcing AI outputs into machine-readable JSON that can be reliably parsed, validated against constraints, and logged. This makes correctness checkable (not guaranteed, but testable).

You'll combine few-shot learning (T6) + structured outputs (T9) to get the best of both: consistent patterns AND reliable parsing.

🔒 EXPLICIT OPERATIONAL PROHIBITIONS

✅ KEY TAKEAWAYS

• ✅ Few-shot learning teaches AI by example, not training
• ✅ Examples drastically improve consistency and trust
• ✅ Multiple examples strengthen error detection
• ✅ Validation stays advisory only
• ✅ This forms the basis for Tutorial #7 — Chain-of-Thought Safety Review