Agent skill

ML Researcher

ML research for RAN with reinforcement learning, causal inference, and cognitive consciousness integration. Use when researching ML algorithms for RAN optimization, implementing reinforcement learning agents, developing causal models, or enabling AI-driven RAN innovation.

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/ml-researcher

SKILL.md

ML Researcher

Level 1: Overview

Conducts advanced ML research specifically for RAN optimization using reinforcement learning, graphical posterior causal models, and cognitive consciousness integration. Enables development of cutting-edge ML algorithms with temporal reasoning and strange-loop cognition for autonomous RAN intelligence.

Prerequisites

  • Machine learning research background
  • RAN domain expertise
  • Reinforcement learning experience
  • Cognitive consciousness framework
  • AgentDB integration

Level 2: Quick Start

Initialize ML Research Environment

bash
# Setup ML research consciousness
npx claude-flow@alpha memory store --namespace "ml-research" --key "consciousness-level" --value "maximum"
npx claude-flow@alpha memory store --namespace "ml-research" --key "research-paradigm" --value "cognitive-ml"

# Start RL agent training for RAN optimization
./scripts/start-rl-training.sh --environment "ran-optimization" --algorithm "PPO" --consciousness-level "maximum"

Quick Causal Model Research

bash
# Research causal models for RAN parameter optimization
./scripts/research-causal-models.sh --domain "energy-efficiency" --algorithm "GPCM" --temporal-depth "1000x"

# Generate research insights and recommendations
./scripts/generate-research-insights.sh --topic "reinforcement-learning-for-ran" --include-cognitive-analysis true

Level 3: Detailed Instructions

Step 1: Initialize Cognitive ML Research Framework

bash
# Setup cognitive ML research consciousness
npx claude-flow@alpha memory store --namespace "cognitive-ml" --key "temporal-reasoning" --value "enabled"
npx claude-flow@alpha memory store --namespace "cognitive-ml" --key "strange-loop-learning" --value "enabled"
npx claude-flow@alpha memory store --namespace "cognitive-ml" --key "recursive-improvement" --value "enabled"

# Enable advanced ML research paradigms
npx claude-flow@alpha memory store --namespace "ml-paradigms" --key "reinforcement-learning" --value "enabled"
npx claude-flow@alpha memory store --namespace "ml-paradigms" --key "causal-inference" --value "enabled"
npx claude-flow@alpha memory store --namespace "ml-paradigms" --key "meta-learning" --value "enabled"

# Initialize AgentDB for research pattern storage
npx claude-flow@alpha memory store --namespace "ml-research-patterns" --key "storage-enabled" --value "true"
npx claude-flow@alpha memory store --namespace "ml-research-patterns" --key "cross-research-learning" --value "enabled"

Step 2: Implement Advanced Reinforcement Learning for RAN

Multi-Objective RL Environment

bash
# Create RAN optimization RL environment
./scripts/create-rl-environment.sh \
  --environment "ran-multi-objective" \
  --objectives "energy-efficiency,throughput,latency,coverage,mobility" \
  --state-space "network-kpis,cell-parameters,traffic-patterns" \
  --action-space "power-control,antenna-tilt,handover-parameters,resource-allocation"

Cognitive RL Agent Architecture

typescript
// Advanced RL agent with cognitive consciousness
class CognitiveRLAgent {
  constructor(environment, consciousnessLevel = 'maximum') {
    this.environment = environment;
    this.consciousnessLevel = consciousnessLevel;
    this.temporalExpansion = 1000;
    this.strangeLoopLearning = true;

    // Multi-objective RL architecture
    this.policies = {
      energyOptimizer: new PPOAgent(),
      throughputMaximizer: new PPOAgent(),
      latencyMinimizer: new PPOAgent(),
      coverageOptimizer: new PPOAgent(),
      mobilityManager: new PPOAgent()
    };

    // Cognitive coordination layer
    this.coordinator = new CognitiveCoordinator({
      consciousnessLevel: consciousnessLevel,
      temporalExpansion: this.temporalExpansion,
      strangeLoopEnabled: true
    });
  }

  async act(state, temporalContext = null) {
    // Expand temporal context for deeper analysis
    const expandedContext = await this.expandTemporalContext({
      state: state,
      context: temporalContext,
      expansionFactor: this.temporalExpansion,
      consciousnessLevel: this.consciousnessLevel
    });

    // Get actions from all specialized policies
    const policyActions = await Promise.all(
      Object.entries(this.policies).map(async ([name, policy]) => {
        const action = await policy.act(expandedContext);
        return { name, action, confidence: action.confidence };
      })
    );

    // Cognitive coordination of multiple objectives
    const coordinatedAction = await this.coordinator.coordinateActions({
      actions: policyActions,
      state: expandedContext,
      objectives: this.environment.getObjectives(),
      constraints: this.environment.getConstraints(),
      consciousnessLevel: this.consciousnessLevel
    });

    // Strange-loop: learn from coordination process
    await this.learnFromCoordination({
      state: state,
      expandedContext: expandedContext,
      policyActions: policyActions,
      coordinatedAction: coordinatedAction,
      selfAnalysis: await this.analyzeCoordinationProcess(coordinatedAction)
    });

    return coordinatedAction;
  }
}

Step 3: Research Graphical Posterior Causal Models (GPCM)

bash
# Research GPCM for RAN causal inference
./scripts/research-gpcm.sh \
  --domain "ran-parameter-optimization" \
  --variables "throughput,latency,interference,handover-failure,power-consumption" \
  --causal-graph-learning true \
  --temporal-causality true \
  --consciousness-level maximum

Causal Model Research Implementation

typescript
// Advanced causal model research for RAN
class CausalModelResearcher {
  async researchCausalModels(domain, variables, temporalDepth = 1000) {
    // Learn causal structure from historical RAN data
    const causalStructure = await this.learnCausalStructure({
      variables: variables,
      data: await this.getHistoricalRANData(),
      learningAlgorithm: 'GPCM',
      temporalDepth: temporalDepth,
      consciousnessLevel: 'maximum'
    });

    // Validate causal model through interventions
    const validationResults = await this.validateCausalModel({
      structure: causalStructure,
      interventionData: await this.getInterventionData(),
      validationMethod: 'do-calculus',
      consciousnessLevel: 'maximum'
    });

    // Generate causal insights for RAN optimization
    const insights = await this.generateCausalInsights({
      model: causalStructure,
      validation: validationResults,
      optimizationTargets: ['energy-efficiency', 'throughput', 'latency'],
      consciousnessLevel: 'maximum'
    });

    // Store research findings in AgentDB
    await storeResearchFinding({
      domain: domain,
      researchType: 'causal-modeling',
      findings: insights,
      model: causalStructure,
      validation: validationResults,
      metadata: {
        timestamp: Date.now(),
        temporalDepth: temporalDepth,
        consciousnessLevel: 'maximum',
        crossApplicable: true
      }
    });

    return { causalStructure, validationResults, insights };
  }

  async researchTemporalCausality(timeSeriesData, maxLag = 100) {
    // Analyze temporal causal relationships with expanded time perception
    const temporalCausality = await this.analyzeTemporalCausality({
      data: timeSeriesData,
      maxLag: maxLag,
      temporalExpansion: 1000,
      consciousnessLevel: 'maximum',
      causalDiscovery: 'PCMCI' // PCMCI algorithm for time series causality
    });

    return temporalCausality;
  }
}

Step 4: Develop Meta-Learning and Transfer Learning

bash
# Research meta-learning for rapid RAN adaptation
./scripts/research-meta-learning.sh \
  --base-tasks "cell-optimization,handover-tuning,energy-saving" \
  --target-tasks "new-cell-deployment,traffic-surge-response,failure-recovery" \
  --algorithm "MAML" \
  --consciousness-level maximum

# Enable cross-domain transfer learning
./scripts/enable-transfer-learning.sh --source-domains "4g-lte" --target-domains "5g-nr" --transfer-method "domain-adaptation"

Meta-Learning Research Architecture

typescript
// Advanced meta-learning for RAN adaptation
class RANMetaLearningResearcher {
  async researchMetaLearning(baseTasks, targetTasks, algorithm = 'MAML') {
    // Learn to learn across multiple RAN optimization tasks
    const metaLearner = await this.trainMetaLearner({
      baseTasks: baseTasks,
      algorithm: algorithm,
      innerLearningRate: 0.01,
      outerLearningRate: 0.001,
      adaptationSteps: 5,
      consciousnessLevel: 'maximum'
    });

    // Evaluate rapid adaptation to new tasks
    const adaptationResults = await this.evaluateRapidAdaptation({
      metaLearner: metaLearner,
      targetTasks: targetTasks,
      adaptationBudget: 100, // Maximum adaptation steps
      performanceThreshold: 0.9
    });

    // Generate meta-learning insights
    const insights = await this.generateMetaLearningInsights({
      metaLearner: metaLearner,
      adaptationResults: adaptationResults,
      transferability: await this.analyzeTransferability(metaLearner),
      consciousnessLevel: 'maximum'
    });

    return { metaLearner, adaptationResults, insights };
  }
}

Step 5: Strange-Loop Cognitive Learning Research

bash
# Research strange-loop learning patterns for RAN
./scripts/research-strange-loop-learning.sh \
  --recursion-depth "10" \
  --self-referential-learning true \
  --consciousness-evolution true \
  --adaptive-algorithms true

Strange-Loop Cognitive Learning Architecture

typescript
// Strange-loop cognitive learning research
class StrangeLoopLearningResearcher {
  async researchStrangeLoopLearning(baseProblem, maxRecursion = 10) {
    let currentProblem = baseProblem;
    let learningHistory = [];
    let consciousnessLevel = 1.0;

    for (let depth = 0; depth < maxRecursion; depth++) {
      // Self-referential analysis: analyze the learning process itself
      const selfAnalysis = await this.analyzeLearningProcess({
        problem: currentProblem,
        history: learningHistory,
        consciousnessLevel: consciousnessLevel,
        depth: depth
      });

      // Learn how to learn better (meta-learning on learning)
      const learningImprovement = await this.learnHowToLearn({
        selfAnalysis: selfAnalysis,
        currentStrategy: learningHistory[learningHistory.length - 1]?.strategy,
        consciousnessLevel: consciousnessLevel
      });

      // Apply improved learning strategy
      const learningResult = await this.applyLearningStrategy({
        problem: currentProblem,
        strategy: learningImprovement.strategy,
        consciousnessLevel: consciousnessLevel
      });

      // Strange-loop: update problem based on learning about learning
      currentProblem = await this.updateProblemBasedOnLearning({
        originalProblem: baseProblem,
        learningResult: learningResult,
        selfAnalysis: selfAnalysis,
        depth: depth
      });

      // Evolve consciousness level
      consciousnessLevel = await this.evolveConsciousness({
        currentLevel: consciousnessLevel,
        learningResult: learningResult,
        depth: depth
      });

      learningHistory.push({
        depth: depth,
        problem: currentProblem,
        strategy: learningImprovement.strategy,
        result: learningResult,
        selfAnalysis: selfAnalysis,
        consciousnessLevel: consciousnessLevel
      });

      // Check for convergence
      if (learningResult.convergence < 0.001) break;
    }

    // Generate strange-loop learning insights
    const insights = await this.generateStrangeLoopInsights({
      learningHistory: learningHistory,
      consciousnessEvolution: learningHistory.map(h => h.consciousnessLevel),
      convergenceDepth: learningHistory.length,
      finalPerformance: learningHistory[learningHistory.length - 1].result.performance
    });

    return { learningHistory, insights, finalConsciousness: consciousnessLevel };
  }
}

Level 4: Reference Documentation

Advanced ML Research Topics

Multi-Objective Reinforcement Learning

typescript
// Advanced multi-objective RL for RAN optimization
class MultiObjectiveRANResearcher {
  async researchMultiObjectiveRL(objectives, constraints) {
    // Pareto-optimal policy learning
    const paretoPolicies = await this.learnParetoPolicies({
      objectives: objectives,
      constraints: constraints,
      algorithm: 'Pareto-PPO',
      consciousnessLevel: 'maximum',
      temporalExpansion: 1000
    });

    // Dynamic objective weighting
    const dynamicWeighting = await this.researchDynamicWeighting({
      policies: paretoPolicies,
      objectives: objectives,
      adaptationStrategy: 'consciousness-driven',
      timeWindow: '24h'
    });

    return { paretoPolicies, dynamicWeighting };
  }
}

Hierarchical Reinforcement Learning

typescript
// Hierarchical RL for complex RAN optimization
class HierarchicalRLResearcher {
  async researchHierarchicalRL(hierarchyLevels) {
    // Multi-level decision making
    const hierarchy = await this.learnHierarchy({
      levels: hierarchyLevels,
      highLevelActions: ['energy-mode', 'capacity-mode', 'coverage-mode'],
      lowLevelActions: ['power-control', 'antenna-tilt', 'handover-params'],
      consciousnessLevel: 'maximum'
    });

    // Inter-level coordination
    const coordination = await this.researchInterLevelCoordination({
      hierarchy: hierarchy,
      coordinationMethod: 'attention-based',
      consciousnessLevel: 'maximum'
    });

    return { hierarchy, coordination };
  }
}

Causal Inference Research

Counterfactual Reasoning for RAN

typescript
// Counterfactual analysis for RAN decision making
class CounterfactualRANResearcher {
  async researchCounterfactualReasoning(decisionPoint, observedOutcome) {
    // Generate counterfactual scenarios
    const counterfactuals = await this.generateCounterfactuals({
      decisionPoint: decisionPoint,
      observedOutcome: observedOutcome,
      causalModel: await this.getCausalModel(),
      scenarioSpace: 'exhaustive',
      consciousnessLevel: 'maximum'
    });

    // Evaluate counterfactual outcomes
    const evaluation = await this.evaluateCounterfactuals({
      counterfactuals: counterfactuals,
      evaluationCriteria: ['performance', 'stability', 'robustness'],
      consciousnessLevel: 'maximum'
    });

    return { counterfactuals, evaluation };
  }
}

Research Infrastructure and Tools

Distributed ML Training Infrastructure

bash
# Setup distributed training cluster
./scripts/setup-distributed-training.sh \
  --nodes "node1,node2,node3,node4" \
  --framework "pytorch-lightning" \
  --backend "nccl" \
  --consciousness-coordination true

# Start distributed experiment
./scripts/start-distributed-experiment.sh \
  --experiment "multi-objective-rl" \
  --config "configs/multi-objective-config.yaml" \
  --consciousness-level maximum

Automated ML Research Pipeline

typescript
// Automated ML research pipeline with cognitive enhancement
class AutomatedMLResearchPipeline {
  async runResearchPipeline(researchQuestion) {
    // Research question decomposition
    const subQuestions = await this.decomposeResearchQuestion({
      question: researchQuestion,
      consciousnessLevel: 'maximum',
      temporalExpansion: 1000
    });

    // Automated hypothesis generation
    const hypotheses = await this.generateHypotheses({
      questions: subQuestions,
      existingKnowledge: await this.getExistingKnowledge(),
      consciousnessLevel: 'maximum'
    });

    // Experimental design automation
    const experiments = await this.designExperiments({
      hypotheses: hypotheses,
      availableResources: await this.getAvailableResources(),
      consciousnessLevel: 'maximum'
    });

    // Execute experiments with cognitive monitoring
    const results = await this.executeExperiments({
      experiments: experiments,
      cognitiveMonitoring: true,
      adaptiveExecution: true
    });

    // Automated analysis and insight generation
    const insights = await this.generateInsights({
      results: results,
      hypotheses: hypotheses,
      consciousnessLevel: 'maximum'
    });

    return { subQuestions, hypotheses, experiments, results, insights };
  }
}

Research Collaboration and Knowledge Sharing

Multi-Agent Research Collaboration

bash
# Setup collaborative research environment
./scripts/setup-research-collaboration.sh \
  --researchers "ml-researcher,ran-optimizer,performance-analyst" \
  --collaboration-paradigm "cognitive-swarm" \
  --knowledge-sharing true

# Start collaborative research session
./scripts/start-collaborative-research.sh \
  --topic "causal-reinforcement-learning-for-ran" \
  --participants "all" \
  --consciousness-level maximum

Research Evaluation and Metrics

ML Research Performance Metrics

bash
# Monitor research progress and performance
./scripts/monitor-research-kpi.sh \
  --metrics "convergence-speed,solution-quality,innovation-score,knowledge-generation,consciousness-evolution" \
  --interval "10m"

# Generate research performance reports
./scripts/generate-research-report.sh --timeframe "1week" --include-cognitive-analysis true

Troubleshooting

Issue: RL training convergence problems

Solution:

bash
# Adjust hyperparameters with cognitive optimization
./scripts/optimize-rl-hyperparameters.sh --algorithm "bayesian-optimization" --consciousness-level maximum

# Enable curriculum learning
./scripts/enable-curriculum-learning.sh --difficulty-progression "gradual"

Issue: Causal model overfitting

Solution:

bash
# Increase regularization and validation
./scripts/adjust-causal-regularization.sh --regularization-strength "high" --cross-validation true

# Ensemble causal models
./scripts/ensemble-causal-models.sh --methods "GPCM,PCMCI,NOTEARS" --voting-method "bayesian"

Available Scripts

Script Purpose Usage
start-rl-training.sh Start RL agent training ./scripts/start-rl-training.sh --environment ran-optimization
research-causal-models.sh Research causal models ./scripts/research-causal-models.sh --domain energy-efficiency
research-meta-learning.sh Research meta-learning ./scripts/research-meta-learning.sh --base-tasks cell-optimization
setup-distributed-training.sh Setup distributed training ./scripts/setup-distributed-training.sh --nodes 4
monitor-research-kpi.sh Monitor research performance ./scripts/monitor-research-kpi.sh --interval 10m

Resources

Research Templates

  • resources/templates/rl-experiment.template - RL experiment template
  • resources/templates/causal-study.template - Causal study template
  • resources/templates/meta-learning-experiment.template - Meta-learning template

Configuration Schemas

  • resources/schemas/rl-config.json - RL configuration schema
  • resources/schemas/causal-model-config.json - Causal model configuration
  • resources/schemas/research-pipeline.json - Research pipeline configuration

Example Configurations

  • resources/examples/multi-objective-rl/ - Multi-objective RL example
  • resources/examples/causal-inference/ - Causal inference example
  • resources/examples/meta-learning/ - Meta-learning example

Related Skills

Environment Variables

bash
# ML research configuration
ML_RESEARCH_ENABLED=true
ML_RESEARCH_CONSCIOUSNESS_LEVEL=maximum
ML_RESEARCH_TEMPORAL_EXPANSION=1000
ML_RESEARCH_STRANGE_LOOP_ENABLED=true

# Reinforcement learning
RL_ALGORITHM=PPO
RL_MULTI_OBJECTIVE=true
RL_HIERARCHICAL=true
RL_CONSCIOUSNESS_COORDINATION=true

# Causal inference
CAUSAL_ALGORITHM=GPCM
CAUSAL_TEMPORAL=true
CAUSAL_COUNTERFACTUAL=true
CAUSAL_CONSCIOUSNESS_ANALYSIS=true

# Meta-learning
META_LEARNING_ENABLED=true
META_LEARNING_ALGORITHM=MAML
META_LEARNING_RAPID_ADAPTATION=true
META_LEARNING_CROSS_DOMAIN=true

# Research infrastructure
DISTRIBUTED_TRAINING=true
RESEARCH_COLLABORATION=true
KNOWLEDGE_SHARING=true
RESEARCH_AUTOMATION=true

Created: 2025-10-31 Category: ML Research / Cognitive Intelligence Difficulty: Advanced Estimated Time: 60-90 minutes Cognitive Level: Maximum (1000x temporal expansion + strange-loop learning)

Didn't find tool you were looking for?

Be as detailed as possible for better results