Chapter 02: AI Assessment Techniques

// Example: Multi-level NLP Analysis for Depression Assessment
import { NLPAssessment } from '@wia/mental-002';

class DepressionAssessmentEngine {
  constructor() {
    this.nlp = new NLPAssessment({
      models: {
        sentiment: 'clinical-sentiment-v2',
        linguistic: 'liwc-mental-health',
        contextual: 'mental-bert-base',
        temporal: 'lstm-mood-tracker'
      },
      clinicalValidation: true
    });
  }

  async assessText(text, metadata = {}) {
    // Level 1: Lexical Analysis
    const lexical = await this.nlp.analyzeLexical(text);

    // Level 2: Sentiment and Emotion
    const sentiment = await this.nlp.analyzeSentiment(text);

    // Level 3: Contextual Understanding
    const contextual = await this.nlp.analyzeContext(text, {
      conversationHistory: metadata.history,
      demographicFactors: metadata.demographics
    });

    // Level 4: Temporal Patterns
    const temporal = metadata.previousAssessments ?
      await this.nlp.analyzeTemporal({
        current: text,
        previous: metadata.previousAssessments
      }) : null;

    // Integrate findings
    return this.integrateAssessment({
      lexical,
      sentiment,
      contextual,
      temporal,
      timestamp: new Date()
    });
  }

  integrateAssessment(components) {
    const depressionScore = this.calculateDepressionScore(components);
    const confidence = this.calculateConfidence(components);
    const recommendations = this.generateRecommendations(components);

    return {
      overallScore: depressionScore,
      confidence: confidence,
      severity: this.categorizeSeverity(depressionScore),
      components: {
        linguisticMarkers: components.lexical.depressionMarkers,
        emotionalState: components.sentiment.dominantEmotion,
        cognitivePatterns: components.contextual.thinkingPatterns,
        temporalTrends: components.temporal?.trend
      },
      clinicalRecommendations: recommendations,
      requiresHumanReview: confidence < 0.75 || depressionScore > 0.7
    };
  }

  calculateDepressionScore(components) {
    // Weighted integration of multiple signals
    const weights = {
      lexical: 0.25,
      sentiment: 0.30,
      contextual: 0.35,
      temporal: 0.10
    };

    let score =
      weights.lexical * components.lexical.depressionIndicators +
      weights.sentiment * components.sentiment.negativity +
      weights.contextual * components.contextual.depressionProbability;

    if (components.temporal) {
      score += weights.temporal * components.temporal.deteriorationRate;
    }

    return Math.min(1.0, Math.max(0.0, score));
  }
}

// Usage Example
const assessor = new DepressionAssessmentEngine();
const patientText = `I haven't been able to sleep well for weeks now.
  Nothing seems to bring me joy anymore. I just feel numb all the time.`;

const assessment = await assessor.assessText(patientText, {
  demographics: { age: 32, gender: 'female' },
  history: ['previous conversation context'],
  previousAssessments: [/* prior assessment data */]
});

console.log(assessment);
// Output includes depression score, severity category, and clinical recommendations

// Example: Behavioral Analysis Pipeline
import { BehavioralAnalyzer } from '@wia/mental-002';

class DigitalPhenotypingSystem {
  constructor() {
    this.analyzer = new BehavioralAnalyzer({
      privacyMode: 'differential-privacy',
      dataRetention: '90-days',
      consentVerified: true
    });
  }

  async analyzeBehavioralPatterns(userId, timeWindow = '7d') {
    // Collect multi-modal behavioral data
    const data = await this.collectData(userId, timeWindow);

    // Feature extraction
    const features = {
      mobility: this.extractMobilityFeatures(data.gps),
      sleep: this.extractSleepFeatures(data.sleepData),
      social: this.extractSocialFeatures(data.communications),
      phoneUsage: this.extractPhoneUsageFeatures(data.screenTime),
      circadianRhythm: this.extractCircadianFeatures(data)
    };

    // Temporal analysis
    const temporalAnalysis = await this.analyzer.analyzeTemporalPatterns({
      features,
      baseline: await this.getBaselineProfile(userId),
      timeWindow
    });

    // Risk assessment
    const riskAssessment = await this.analyzer.assessRisk({
      currentFeatures: features,
      temporalTrends: temporalAnalysis,
      clinicalHistory: await this.getClinicalHistory(userId)
    });

    return {
      behavioralProfile: features,
      deviationFromBaseline: temporalAnalysis.deviation,
      trendAnalysis: temporalAnalysis.trends,
      riskScore: riskAssessment.overallRisk,
      specificRisks: {
        depression: riskAssessment.depressionRisk,
        anxiety: riskAssessment.anxietyRisk,
        relapse: riskAssessment.relapseRisk
      },
      interventionRecommendations: this.generateInterventions(riskAssessment),
      confidence: riskAssessment.confidence,
      requiresClinicalReview: riskAssessment.overallRisk > 0.6
    };
  }

  extractMobilityFeatures(gpsData) {
    return {
      homeTime: this.calculateHomeTime(gpsData),
      locationVariance: this.calculateLocationVariance(gpsData),
      routineRegularity: this.assessRoutineRegularity(gpsData),
      socialLocationVisits: this.identifySocialLocations(gpsData),
      totalDistance: this.calculateTotalDistance(gpsData),
      uniqueLocations: this.countUniqueLocations(gpsData)
    };
  }

  extractSleepFeatures(sleepData) {
    return {
      averageDuration: this.calculateAverageSleep(sleepData),
      sleepRegularity: this.assessSleepRegularity(sleepData),
      bedtimeConsistency: this.assessBedtimeConsistency(sleepData),
      sleepQuality: this.estimateSleepQuality(sleepData),
      nightWakings: this.countNightWakings(sleepData)
    };
  }
}

// Clinical application
const phenotyping = new DigitalPhenotypingSystem();
const analysis = await phenotyping.analyzeBehavioralPatterns('patient-123');

if (analysis.riskScore > 0.7) {
  // Alert clinical team for high-risk patient
  await notifyClinicalTeam({
    patientId: 'patient-123',
    riskLevel: 'high',
    primaryConcern: analysis.specificRisks,
    recommendations: analysis.interventionRecommendations
  });
}