진행 추적 및 결과

5.1 Machine Learning in Digital Therapeutics

Phase 3 introduces artificial intelligence and machine learning to create adaptive, personalized therapeutic experiences. Unlike static content delivery, ML-powered systems learn from each interaction to optimize content, timing, and approach for maximum clinical benefit.

ML Applications in Mental Healthcare

Treatment Response Prediction Model

// ML Model for Treatment Selection
class TreatmentPredictionModel {
  private model: RandomForestClassifier;
  private featureExtractor: FeatureExtractor;
  
  async predictOptimalTreatment(
    patient: PatientData
  ): Promise {
    // Extract features
    const features = await this.featureExtractor.extract({
      demographics: {
        age: patient.age,
        gender: patient.gender,
        educationLevel: patient.educationLevel
      },
      clinical: {
        phq9Score: patient.baselinePHQ9,
        gad7Score: patient.baselineGAD7,
        primaryDiagnosis: patient.diagnosis,
        comorbidities: patient.comorbidities,
        previousTreatments: patient.treatmentHistory
      },
      behavioral: {
        engagementHistory: patient.platformEngagement,
        preferredModality: patient.preferences.learningStyle,
        deviceUsage: patient.deviceMetrics
      },
      social: {
        socialSupport: patient.socialSupport,
        employmentStatus: patient.employment,
        livingArrangement: patient.living
      }
    });
    
    // Predict treatment efficacy for each modality
    const predictions = await this.model.predict(features);
    
    // Results: probability of 50%+ symptom improvement
    const results = {
      CBT: predictions[0],        // 0.78 (78% likelihood)
      DBT: predictions[1],        // 0.45
      ACT: predictions[2],        // 0.82 (best match!)
      IPT: predictions[3],        // 0.61
      MBCT: predictions[4]        // 0.55
    };
    
    // Select best treatment
    const recommended = Object.entries(results)
      .sort(([,a], [,b]) => b - a)[0];
    
    return {
      primaryRecommendation: recommended[0],
      confidence: recommended[1],
      alternativeOptions: this.getAlternatives(results),
      reasoning: this.generateExplanation(features, recommended[0]),
      expectedOutcome: this.predictOutcome(features, recommended[0])
    };
  }
  
  private generateExplanation(
    features: Features, 
    treatment: string
  ): string {
    // Explainable AI - SHAP values for feature importance
    const shapValues = this.model.explain(features, treatment);
    
    const topFactors = shapValues
      .sort((a, b) => Math.abs(b.value) - Math.abs(a.value))
      .slice(0, 3)
      .map(s => s.feature);
    
    return `${treatment} recommended based on: ${topFactors.join(', ')}`;
  }
}

// Training Pipeline
class ModelTrainingPipeline {
  async trainTreatmentPredictionModel(): Promise {
    // Load historical treatment outcome data
    const data = await this.loadTrainingData({
      minPatients: 10000,
      outcomeDefinition: '50% symptom reduction',
      followUpPeriod: 12 // weeks
    });
    
    // Feature engineering
    const features = this.engineerFeatures(data);
    
    // Train-test split (80-20)
    const [trainSet, testSet] = this.splitData(features, 0.8);
    
    // Hyperparameter tuning with cross-validation
    const bestParams = await this.gridSearch({
      n_estimators: [100, 200, 300],
      max_depth: [10, 20, 30, null],
      min_samples_split: [2, 5, 10],
      class_weight: ['balanced', null]
    }, trainSet, cv=5);
    
    // Train final model
    const model = new RandomForestClassifier(bestParams);
    await model.fit(trainSet.X, trainSet.y);
    
    // Evaluate performance
    const metrics = await this.evaluate(model, testSet);
    console.log('Model Performance:', {
      accuracy: metrics.accuracy,      // 0.85
      precision: metrics.precision,    // 0.83
      recall: metrics.recall,          // 0.81
      f1Score: metrics.f1,            // 0.82
      auc: metrics.aucRoc             // 0.89
    });
    
    // Validate on held-out set
    const validation = await this.validateClinically(model);
    
    if (validation.acceptable) {
      return model.save();
    } else {
      throw new Error('Model failed clinical validation');
    }
  }
}

5.2 Adaptive Content Delivery

Traditional digital therapeutics deliver the same content to all users in the same sequence. Adaptive systems dynamically adjust content difficulty, pacing, and modality based on individual learner profiles and real-time performance.

Personalization Dimensions

Adaptive Learning Algorithm

class AdaptiveContentEngine {
  private userModel: UserLearningModel;
  private contentLibrary: ContentRepository;
  
  async getNextActivity(
    userId: string,
    sessionContext: SessionContext
  ): Promise {
    // Get user's current state
    const userState = await this.userModel.getCurrentState(userId);
    
    // Factors to consider:
    // 1. Learning objectives not yet mastered
    const unmastered = this.identifyGaps(
      userState.learningObjectives,
      userState.assessmentResults
    );
    
    // 2. User's cognitive load (avoid overwhelm)
    const cognitiveLoad = this.estimateCognitiveLoad(
      userState.recentPerformance,
      sessionContext.timeOfDay,
      sessionContext.sessionNumber
    );
    
    // 3. Preferred learning modalities
    const preferences = userState.modalityPreferences;
    
    // 4. Activities that helped similar users
    const collaborative = await this.getCollaborativeRecommendations(
      userId,
      unmastered[0] // highest priority gap
    );
    
    // 5. Spaced repetition for retention
    const dueForReview = this.getSpacedRepetitionItems(
      userState.itemHistory
    );
    
    // Score candidate activities
    const candidates = await this.contentLibrary.search({
      objectives: unmastered,
      maxDifficulty: this.getDifficultyThreshold(cognitiveLoad),
      modalities: preferences.top3,
      excludeRecent: userState.recentActivities
    });
    
    const scored = candidates.map(activity => ({
      activity,
      score: this.scoreActivity(
        activity,
        unmastered,
        preferences,
        collaborative,
        dueForReview,
        cognitiveLoad
      )
    }));
    
    // Select highest-scoring activity
    const selected = scored.sort((a, b) => b.score - a.score)[0];
    
    // Log for model improvement
    await this.logRecommendation({
      userId,
      activity: selected.activity,
      context: sessionContext,
      reasoning: selected.reasoning
    });
    
    return selected.activity;
  }
  
  private scoreActivity(
    activity: Activity,
    gaps: LearningGap[],
    preferences: Preferences,
    collaborative: Recommendation[],
    dueForReview: Item[],
    cognitiveLoad: number
  ): number {
    let score = 0;
    
    // Address highest-priority gap: +50 points
    if (activity.addresses(gaps[0])) score += 50;
    
    // Matches preferred modality: +30 points
    if (preferences.includes(activity.modality)) score += 30;
    
    // Recommended by collaborative filtering: +20 points
    const collab = collaborative.find(c => c.activityId === activity.id);
    if (collab) score += 20 * collab.confidence;
    
    // Spaced repetition due: +25 points
    if (dueForReview.some(i => activity.reviews(i))) score += 25;
    
    // Appropriate difficulty: +15 points (or penalty)
    const difficultyMatch = this.assessDifficultyMatch(
      activity.difficulty,
      cognitiveLoad
    );
    score += difficultyMatch * 15;
    
    // Novelty bonus: +10 points (avoid boredom)
    if (!activity.recentlyShown) score += 10;
    
    return score;
  }
}

5.3 Natural Language Processing for Sentiment Analysis

NLP enables automated analysis of patient text entries (journal entries, chat messages, thought records) to detect emotional states, identify concerning patterns, and provide real-time support.

NLP Pipeline Architecture

class NLPSentimentAnalyzer {
  private bertModel: TransformerModel;
  private emotionClassifier: EmotionModel;
  private crisisDetector: CrisisModel;
  
  async analyzeText(text: string): Promise {
    // Parallel processing of multiple models
    const [sentiment, emotions, crisis, topics] = await Promise.all([
      this.analyzeSentiment(text),
      this.detectEmotions(text),
      this.assessCrisisRisk(text),
      this.extractTopics(text)
    ]);
    
    return {
      sentiment: {
        polarity: sentiment.polarity,     // -1 to +1
        score: sentiment.confidence,       // 0 to 1
        label: sentiment.label             // positive/negative/neutral
      },
      emotions: {
        joy: emotions.joy,
        sadness: emotions.sadness,
        anger: emotions.anger,
        fear: emotions.fear,
        surprise: emotions.surprise,
        disgust: emotions.disgust
      },
      crisis: {
        riskLevel: crisis.level,           // none/low/medium/high/severe
        confidence: crisis.confidence,
        triggers: crisis.detectedKeywords,
        recommendedActions: crisis.actions
      },
      topics: topics.map(t => ({
        topic: t.label,
        confidence: t.score,
        keywords: t.keywords
      })),
      metadata: {
        wordCount: text.split(/\s+/).length,
        readingLevel: this.calculateReadability(text),
        processingTime: Date.now()
      }
    };
  }
  
  private async analyzeSentiment(text: string): Promise {
    // Use pre-trained BERT model fine-tuned on mental health text
    const inputs = await this.bertModel.tokenize(text);
    const outputs = await this.bertModel.predict(inputs);
    
    // Get sentiment logits
    const [negative, neutral, positive] = outputs.logits;
    
    // Apply softmax
    const probs = this.softmax([negative, neutral, positive]);
    
    // Determine polarity (-1 to +1 scale)
    const polarity = (probs[2] - probs[0]);
    
    return {
      polarity,
      confidence: Math.max(...probs),
      label: probs[2] > probs[0] ? 
        (probs[2] > probs[1] ? 'positive' : 'neutral') : 
        'negative',
      distribution: {
        negative: probs[0],
        neutral: probs[1],
        positive: probs[2]
      }
    };
  }
  
  private async detectEmotions(text: string): Promise {
    // Multi-label emotion classification
    const features = await this.extractFeatures(text);
    const predictions = await this.emotionClassifier.predict(features);
    
    return {
      joy: predictions[0],
      sadness: predictions[1],
      anger: predictions[2],
      fear: predictions[3],
      surprise: predictions[4],
      disgust: predictions[5],
      primary: this.getPrimaryEmotion(predictions)
    };
  }
}

5.4 Predictive Outcome Modeling

By analyzing patterns in patient data over time, ML models can predict treatment outcomes weeks or months in advance, enabling proactive interventions when patients are at risk of poor outcomes.

Outcome Prediction Metrics