@things-factory/integration-label-studio 9.1.19

package/server/utils/task-transformer.ts

@@ -0,0 +1,342 @@
+/**
+ * Task Transformer
+ *
+ * Flexible data transformation from any source format to Label Studio tasks.
+ * Supports nested data, predictions, and custom field mapping.
+ */
+
+export interface TaskTransformRule {
+  /**
+   * Field mapping: Label Studio field name -> source data path
+   * Example: { "image": "image_url", "date": "metadata.timestamp" }
+   */
+  dataFields: { [lsField: string]: string }
+
+  /**
+   * Prediction configuration (optional)
+   */
+  predictions?: PredictionConfig
+
+  /**
+   * Metadata to attach to task (optional)
+   */
+  meta?: { [key: string]: string }
+}
+
+export interface PredictionConfig {
+  /**
+   * Enable predictions
+   */
+  enabled: boolean
+
+  /**
+   * Path to prediction result in source data
+   */
+  resultPath: string
+
+  /**
+   * Path to confidence score (optional)
+   */
+  scorePath?: string
+
+  /**
+   * Model version identifier (optional)
+   */
+  modelVersion?: string
+
+  /**
+   * Transform function for prediction result
+   */
+  resultTransform?: (result: any) => any
+}
+
+export interface LabelStudioTask {
+  data: string // JSON string
+  predictions?: Array<{
+    result: any
+    score?: number
+    model_version?: string
+  }>
+  meta?: any
+}
+
+export class TaskTransformer {
+  /**
+   * Transform source data to Label Studio tasks
+   *
+   * @param sourceData - Array of source data objects
+   * @param rule - Transformation rules
+   * @returns Array of Label Studio tasks
+   */
+  static transform(sourceData: any[], rule: TaskTransformRule): LabelStudioTask[] {
+    return sourceData.map(data => this.transformOne(data, rule)).filter(task => task !== null) as LabelStudioTask[]
+  }
+
+  /**
+   * Transform a single data object
+   */
+  static transformOne(sourceData: any, rule: TaskTransformRule): LabelStudioTask | null {
+    try {
+      // Build task data
+      const taskData: any = {}
+      for (const [lsField, sourcePath] of Object.entries(rule.dataFields)) {
+        const value = this.getNestedValue(sourceData, sourcePath)
+        if (value !== undefined) {
+          taskData[lsField] = value
+        }
+      }
+
+      // Skip if no data extracted
+      if (Object.keys(taskData).length === 0) {
+        return null
+      }
+
+      const task: LabelStudioTask = {
+        data: JSON.stringify(taskData)
+      }
+
+      // Add predictions if configured
+      if (rule.predictions?.enabled) {
+        const prediction = this.buildPrediction(sourceData, rule.predictions)
+        if (prediction) {
+          task.predictions = [prediction]
+        }
+      }
+
+      // Add metadata if configured
+      if (rule.meta) {
+        const meta: any = {}
+        for (const [metaKey, sourcePath] of Object.entries(rule.meta)) {
+          const value = this.getNestedValue(sourceData, sourcePath)
+          if (value !== undefined) {
+            meta[metaKey] = value
+          }
+        }
+        if (Object.keys(meta).length > 0) {
+          task.meta = meta
+        }
+      }
+
+      return task
+    } catch (error) {
+      console.error('Failed to transform task:', error)
+      return null
+    }
+  }
+
+  /**
+   * Build prediction object from source data
+   */
+  private static buildPrediction(
+    sourceData: any,
+    config: PredictionConfig
+  ): { result: any; score?: number; model_version?: string } | null {
+    const result = this.getNestedValue(sourceData, config.resultPath)
+    if (!result) {
+      return null
+    }
+
+    const prediction: any = {
+      result: config.resultTransform ? config.resultTransform(result) : result
+    }
+
+    if (config.scorePath) {
+      const score = this.getNestedValue(sourceData, config.scorePath)
+      if (score !== undefined) {
+        prediction.score = score
+      }
+    }
+
+    if (config.modelVersion) {
+      prediction.model_version = config.modelVersion
+    }
+
+    return prediction
+  }
+
+  /**
+   * Get nested value from object using dot notation path
+   * Example: "metadata.user.name" -> obj.metadata.user.name
+   */
+  private static getNestedValue(obj: any, path: string): any {
+    if (!path || !obj) return undefined
+
+    const keys = path.split('.')
+    let current = obj
+
+    for (const key of keys) {
+      if (current === null || current === undefined) {
+        return undefined
+      }
+
+      // Support array indexing: "items[0].name"
+      const arrayMatch = key.match(/^(\w+)\[(\d+)\]$/)
+      if (arrayMatch) {
+        const [, arrayKey, index] = arrayMatch
+        current = current[arrayKey]?.[parseInt(index, 10)]
+      } else {
+        current = current[key]
+      }
+    }
+
+    return current
+  }
+
+  /**
+   * Transform with multiple rules (useful for heterogeneous data)
+   */
+  static transformMultiRule(sourceData: any[], rules: TaskTransformRule[]): LabelStudioTask[] {
+    const tasks: LabelStudioTask[] = []
+
+    for (const rule of rules) {
+      tasks.push(...this.transform(sourceData, rule))
+    }
+
+    return tasks
+  }
+}
+
+/**
+ * Pre-built transformation templates for common scenarios
+ */
+export class TaskTransformTemplates {
+  /**
+   * WBM Image Classification with AI predictions
+   */
+  static wbmImageClassification(includeAiPrediction: boolean = true): TaskTransformRule {
+    const rule: TaskTransformRule = {
+      dataFields: {
+        image: 'image_url',
+        date: 'timestamp',
+        device_id: 'device_id'
+      },
+      meta: {
+        wafer_id: 'wafer_id',
+        lot_id: 'lot_id'
+      }
+    }
+
+    if (includeAiPrediction) {
+      rule.predictions = {
+        enabled: true,
+        resultPath: 'ai_prediction',
+        scorePath: 'confidence',
+        modelVersion: 'wbm-classifier-v1',
+        resultTransform: result => {
+          // Transform AI result to Label Studio format
+          return [
+            {
+              from_name: 'rank1',
+              to_name: 'data',
+              type: 'choices',
+              value: {
+                choices: [result.rank1]
+              }
+            },
+            {
+              from_name: 'rank2',
+              to_name: 'data',
+              type: 'choices',
+              value: {
+                choices: [result.rank2]
+              }
+            },
+            {
+              from_name: 'rank3',
+              to_name: 'data',
+              type: 'choices',
+              value: {
+                choices: [result.rank3]
+              }
+            }
+          ]
+        }
+      }
+    }
+
+    return rule
+  }
+
+  /**
+   * Simple image classification
+   */
+  static imageClassification(imageField: string = 'image_url'): TaskTransformRule {
+    return {
+      dataFields: {
+        image: imageField
+      }
+    }
+  }
+
+  /**
+   * Text classification with metadata
+   */
+  static textClassification(textField: string = 'text', metaFields: string[] = []): TaskTransformRule {
+    const rule: TaskTransformRule = {
+      dataFields: {
+        text: textField
+      }
+    }
+
+    if (metaFields.length > 0) {
+      rule.meta = {}
+      for (const field of metaFields) {
+        rule.meta[field] = field
+      }
+    }
+
+    return rule
+  }
+
+  /**
+   * Time series data
+   */
+  static timeSeries(valuesField: string, timestampField?: string): TaskTransformRule {
+    const dataFields: any = {
+      timeseries: valuesField
+    }
+
+    if (timestampField) {
+      dataFields.timestamp = timestampField
+    }
+
+    return {
+      dataFields
+    }
+  }
+
+  /**
+   * Object detection with bounding box predictions
+   */
+  static objectDetection(imageField: string = 'image_url', predictionsField?: string): TaskTransformRule {
+    const rule: TaskTransformRule = {
+      dataFields: {
+        image: imageField
+      }
+    }
+
+    if (predictionsField) {
+      rule.predictions = {
+        enabled: true,
+        resultPath: predictionsField,
+        resultTransform: bboxes => {
+          // Transform bounding boxes to Label Studio format
+          return bboxes.map((bbox: any) => ({
+            from_name: 'bbox',
+            to_name: 'data',
+            type: 'rectanglelabels',
+            value: {
+              x: bbox.x,
+              y: bbox.y,
+              width: bbox.width,
+              height: bbox.height,
+              rectanglelabels: [bbox.label]
+            }
+          }))
+        }
+      }
+    }
+
+    return rule
+  }
+}

package/test-ai-prediction.js

@@ -0,0 +1,268 @@
+/**
+ * Test script for AI Prediction integration with Label Studio
+ *
+ * This script tests the complete flow:
+ * 1. Get a task from Label Studio
+ * 2. Run AI inference on the task's image
+ * 3. Convert AI results to Label Studio format
+ * 4. Create prediction in Label Studio
+ */
+
+const axios = require('axios')
+
+// Configuration
+// NOTE: With subdomain cookie-sharing approach, we access Label Studio directly
+// No proxy path needed - Label Studio runs on its own subdomain
+const LABEL_STUDIO_URL = process.env.LABEL_STUDIO_URL || 'http://label.dataset.localhost:8080'
+const LABEL_STUDIO_TOKEN = process.env.LABEL_STUDIO_API_TOKEN || ''
+const THINGS_FACTORY_GRAPHQL = process.env.THINGS_FACTORY_GRAPHQL || 'http://dataset.localhost:3000/graphql'
+
+// Test configuration
+const PROJECT_ID = process.env.TEST_PROJECT_ID || 2  // Change to your project ID
+const TASK_ID = process.env.TEST_TASK_ID  // Optional: specific task ID
+
+async function testLabelStudioConnection() {
+  console.log('\n🔍 Testing Label Studio connection...')
+  console.log(`   URL: ${LABEL_STUDIO_URL}`)
+
+  try {
+    const response = await axios.get(`${LABEL_STUDIO_URL}/api/projects`, {
+      headers: {
+        'Authorization': `Token ${LABEL_STUDIO_TOKEN}`
+      }
+    })
+
+    console.log(`✅ Label Studio connected successfully`)
+    console.log(`   Found ${response.data.results?.length || 0} projects`)
+    return true
+  } catch (error) {
+    console.error(`❌ Label Studio connection failed:`, error.message)
+    return false
+  }
+}
+
+async function getTestTask() {
+  console.log(`\n🔍 Getting test task from project ${PROJECT_ID}...`)
+
+  try {
+    // Get tasks from project
+    const response = await axios.get(
+      `${LABEL_STUDIO_URL}/api/projects/${PROJECT_ID}/tasks`,
+      {
+        headers: { 'Authorization': `Token ${LABEL_STUDIO_TOKEN}` },
+        params: { page_size: 10 }
+      }
+    )
+
+    const tasks = response.data.results || response.data
+
+    if (!tasks || tasks.length === 0) {
+      console.log(`⚠️  No tasks found in project ${PROJECT_ID}`)
+      return null
+    }
+
+    // Find a task with an image
+    const taskWithImage = tasks.find(task => task.data && task.data.image)
+
+    if (!taskWithImage) {
+      console.log(`⚠️  No tasks with images found`)
+      return null
+    }
+
+    console.log(`✅ Found task ${taskWithImage.id}`)
+    console.log(`   Image: ${taskWithImage.data.image}`)
+    console.log(`   Annotations: ${taskWithImage.annotations?.length || 0}`)
+    console.log(`   Predictions: ${taskWithImage.predictions?.length || 0}`)
+
+    return taskWithImage
+  } catch (error) {
+    console.error(`❌ Failed to get task:`, error.message)
+    return null
+  }
+}
+
+async function testAIInference(imageUrl) {
+  console.log(`\n🤖 Testing AI inference...`)
+  console.log(`   Image: ${imageUrl}`)
+
+  try {
+    const query = `
+      query DetectObjects($input: InferenceRequest!) {
+        detectObjects(input: $input) {
+          className
+          confidence
+          bbox {
+            x
+            y
+            width
+            height
+          }
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query,
+      variables: {
+        input: {
+          imageUrl,
+          confidenceThreshold: 0.5
+        }
+      }
+    })
+
+    if (response.data.errors) {
+      console.error(`❌ GraphQL errors:`, response.data.errors)
+      return null
+    }
+
+    const objects = response.data.data.detectObjects
+    console.log(`✅ AI detected ${objects.length} objects:`)
+    objects.forEach((obj, i) => {
+      console.log(`   ${i + 1}. ${obj.className} (${(obj.confidence * 100).toFixed(1)}%)`)
+    })
+
+    return objects
+  } catch (error) {
+    console.error(`❌ AI inference failed:`, error.message)
+    if (error.response?.data) {
+      console.error(`   Response:`, JSON.stringify(error.response.data, null, 2))
+    }
+    return null
+  }
+}
+
+async function testPredictionGeneration(taskId, imageUrl) {
+  console.log(`\n🎯 Testing prediction generation for task ${taskId}...`)
+
+  try {
+    const mutation = `
+      mutation GeneratePrediction($input: GeneratePredictionRequest!) {
+        generatePrediction(input: $input) {
+          taskId
+          predictionId
+          success
+          objectCount
+          avgConfidence
+          error
+        }
+      }
+    `
+
+    const response = await axios.post(THINGS_FACTORY_GRAPHQL, {
+      query: mutation,
+      variables: {
+        input: {
+          taskId,
+          imageUrl,
+          confidenceThreshold: 0.5
+        }
+      }
+    })
+
+    if (response.data.errors) {
+      console.error(`❌ GraphQL errors:`, response.data.errors)
+      return null
+    }
+
+    const result = response.data.data.generatePrediction
+
+    if (result.success) {
+      console.log(`✅ Prediction created successfully!`)
+      console.log(`   Prediction ID: ${result.predictionId}`)
+      console.log(`   Objects detected: ${result.objectCount}`)
+      console.log(`   Avg confidence: ${(result.avgConfidence * 100).toFixed(1)}%`)
+    } else {
+      console.log(`⚠️  Prediction generation reported error:`, result.error)
+    }
+
+    return result
+  } catch (error) {
+    console.error(`❌ Prediction generation failed:`, error.message)
+    if (error.response?.data) {
+      console.error(`   Response:`, JSON.stringify(error.response.data, null, 2))
+    }
+    return null
+  }
+}
+
+async function verifyPrediction(taskId) {
+  console.log(`\n✓ Verifying prediction in Label Studio...`)
+
+  try {
+    const response = await axios.get(
+      `${LABEL_STUDIO_URL}/api/tasks/${taskId}`,
+      {
+        headers: { 'Authorization': `Token ${LABEL_STUDIO_TOKEN}` }
+      }
+    )
+
+    const task = response.data
+    const predictionCount = task.predictions?.length || 0
+
+    console.log(`✅ Task has ${predictionCount} prediction(s)`)
+
+    if (predictionCount > 0) {
+      const latestPrediction = task.predictions[task.predictions.length - 1]
+      console.log(`   Latest prediction:`)
+      console.log(`   - ID: ${latestPrediction.id}`)
+      console.log(`   - Model: ${latestPrediction.model_version}`)
+      console.log(`   - Score: ${(latestPrediction.score * 100).toFixed(1)}%`)
+      console.log(`   - Objects: ${latestPrediction.result?.length || 0}`)
+    }
+
+    return true
+  } catch (error) {
+    console.error(`❌ Failed to verify prediction:`, error.message)
+    return false
+  }
+}
+
+async function main() {
+  console.log('🚀 Starting AI Prediction Integration Test\n')
+  console.log('=' .repeat(60))
+
+  // Step 1: Test Label Studio connection
+  const lsConnected = await testLabelStudioConnection()
+  if (!lsConnected) {
+    console.log('\n❌ Cannot proceed without Label Studio connection')
+    process.exit(1)
+  }
+
+  // Step 2: Get a test task
+  const task = await getTestTask()
+  if (!task) {
+    console.log('\n❌ Cannot proceed without a test task')
+    console.log('💡 Please create a task with an image in Label Studio project', PROJECT_ID)
+    process.exit(1)
+  }
+
+  // Step 3: Test AI inference (optional - direct test)
+  const objects = await testAIInference(task.data.image)
+  if (!objects) {
+    console.log('\n⚠️  AI inference test failed, but continuing with prediction generation...')
+  }
+
+  // Step 4: Generate prediction via GraphQL
+  const result = await testPredictionGeneration(task.id, task.data.image)
+  if (!result || !result.success) {
+    console.log('\n❌ Prediction generation failed')
+    process.exit(1)
+  }
+
+  // Step 5: Verify prediction was created
+  await verifyPrediction(task.id)
+
+  console.log('\n' + '='.repeat(60))
+  console.log('✨ Test completed successfully!')
+  console.log(`\n📝 Next steps:`)
+  console.log(`   1. Open Label Studio: ${LABEL_STUDIO_URL}/projects/${PROJECT_ID}`)
+  console.log(`   2. Open task ${task.id} to see the AI-generated prediction`)
+  console.log(`   3. The prediction should appear as pre-labeled regions`)
+}
+
+// Run the test
+main().catch(error => {
+  console.error('\n💥 Test failed with error:', error)
+  process.exit(1)
+})