(CHORE)[cleanup]: Remove deprecated files and documentation related to, including, validation protocols, and preprocessing scripts for FTIR data. This cleanup streamlines the repository by eliminating outdated resources and focuses on current implementations.

AGENT_PROCESS.md

@@ -1,284 +0,0 @@
-# POLYMEROS Agent Development Process
-
-## Mission Context
-
-This document chronicles the decision-making process, alternatives explored, and insights gained during the implementation of the POLYMEROS Development Protocol for the polymer-aging-ml repository. It serves as both a research methodology record and a guide for future AI-assisted scientific software development.
-
-## Initial Analysis and Strategic Planning
-
-### Repository Assessment (Phase 1)
-
-**Timestamp**: Initial exploration  
-**Objective**: Understand current capabilities and identify transformation opportunities
-
-**Current State Discovered**:
-
-- Streamlit-based web application for polymer classification
-- Three CNN architectures: Figure2CNN, ResNet1D, ResNet18Vision
-- Raman spectroscopy focus with binary classification (Stable vs Weathered)
-- Modular architecture with separation of concerns
-- Existing comprehensive analysis report with detailed roadmap
-
-**Key Insights**:
-
-1. **Foundation Strength**: Solid modular structure provides good base for expansion
-2. **Scope Limitation**: Current binary classification is too narrow for research-grade applications
-3. **Educational Gap**: No interactive learning components despite educational goals
-4. **Collaboration Absence**: No features for team-based research or peer validation
-
-**Decision Point 1**: Transform vs. Rebuild  
-**Choice**: Transform existing architecture rather than rebuild from scratch  
-**Rationale**: Preserve working components while adding sophisticated capabilities
-
-### Framework Design Philosophy
-
-**Core Assumption Challenge**:
-Original assumption: "Software supports users"  
-POLYMEROS principle: "Platform enhances human decision-making and discovery"
-
-**This shift drives several key design decisions**:
-
-1. **Explanatory AI**: Every prediction must include reasoning chains
-2. **Adaptive Learning**: System improves through user interactions
-3. **Hypothesis Generation**: AI suggests research directions, not just classifications
-4. **Community Integration**: Built-in collaboration and validation tools
-
-## Implementation Strategy and Decision Rationale
-
-### Phase 1: Foundation Building
-
-#### Enhanced Data Management System
-
-**Challenge**: Simple file-based input limiting research potential  
-**Solution**: Contextual knowledge networks with metadata preservation
-
-**Implementation Decision**: Extend existing `utils/preprocessing.py` rather than replace  
-**Alternative Considered**: Complete rewrite of data pipeline  
-**Rationale**: Preserve proven preprocessing while adding advanced capabilities
-
-**Key Enhancements Planned**:
-
-```python
-class EnhancedDataManager:
-    - MetadataExtractor: Automatic experimental condition tracking
-    - ProvenanceTracker: Complete data lineage recording
-    - KnowledgeGraph: Relationship mapping between samples
-    - QualityAssessment: Automated data validation
-```
-
-#### Transparent AI Core
-
-**Challenge**: Black-box predictions unsuitable for scientific research  
-**Solution**: Multi-layered explainability with uncertainty quantification
-
-**Design Decision**: Wrapper approach around existing models  
-**Alternative**: Replace existing models entirely  
-**Rationale**: Maintain compatibility while adding sophisticated capabilities
-
-#### Educational Framework Foundation
-
-**Challenge**: No learning progression or skill assessment  
-**Solution**: Adaptive tutorial system with competency tracking
-
-### Phase 2: Advanced Integration
-
-#### Multi-Modal Spectroscopy Engine
-
-**Current Limitation**: Raman-only analysis  
-**Enhancement Target**: FTIR + Raman fusion with attention mechanisms
-
-**Technical Decision**: Attention-based fusion over simple concatenation  
-**Justification**: Attention allows model to focus on relevant spectral regions automatically
-
-#### Physics-Informed AI
-
-**Innovation**: Incorporate physical laws into neural network training  
-**Implementation**: Physics-Informed Neural Networks (PINNs) for constraint enforcement
-
-### Phase 3: Evolutionary Capabilities
-
-#### Self-Improving Systems
-
-**Concept**: Platform that enhances itself through usage patterns  
-**Implementation**: Meta-learning on user interactions and feedback
-
-#### Community-Driven Development
-
-**Vision**: Research community collaboratively improving the platform  
-**Tools**: Peer review integration, collaborative model development
-
-## Technical Implementation Insights
-
-### Challenge 1: Model Transparency
-
-**Problem**: Existing CNN models provide predictions without explanations  
-**Solution**: Integrated SHAP analysis with domain-specific interpretation
-
-**Code Pattern**:
-
-```python
-class TransparentPredictor:
-    def predict_with_explanation(self, spectrum):
-        prediction = self.model(spectrum)
-        explanation = self.explainer.explain(spectrum)
-        confidence = self.uncertainty_estimator(spectrum)
-        return {
-            'prediction': prediction,
-            'explanation': explanation,
-            'confidence': confidence,
-            'reasoning_chain': self.generate_reasoning(explanation)
-        }
-```
-
-### Challenge 2: Educational Progression
-
-**Problem**: How to assess user knowledge and adapt accordingly  
-**Solution**: Bayesian knowledge tracing with competency mapping
-
-**Insight**: Traditional linear tutorials fail for diverse backgrounds  
-**Innovation**: Adaptive pathways based on demonstrated understanding
-
-### Challenge 3: Community Validation
-
-**Problem**: Ensuring scientific rigor in collaborative environment  
-**Solution**: Weighted consensus with expertise tracking
-
-**Design Pattern**:
-
-```python
-class CommunityValidator:
-    def validate_claim(self, claim, user_submissions):
-        expertise_weights = self.calculate_expertise(user_submissions)
-        consensus_score = self.weighted_consensus(claim, expertise_weights)
-        confidence = self.uncertainty_estimation(consensus_score)
-        return ValidationResult(consensus_score, confidence, evidence_trail)
-```
-
-## Lessons Learned and Pattern Recognition
-
-### Pattern 1: Incremental Sophistication
-
-**Observation**: Users prefer gradual capability introduction over complete overhaul  
-**Application**: Progressive disclosure of advanced features  
-**Implementation**: Feature flags and user-controlled complexity levels
-
-### Pattern 2: Explanation Hierarchy
-
-**Discovery**: Different users need different levels of explanation detail  
-**Solution**: Layered explanations from high-level to molecular detail  
-**Code Structure**: Hierarchical explanation system with drill-down capability
-
-### Pattern 3: Community Dynamics
-
-**Insight**: Scientific collaboration requires trust and reputation systems  
-**Implementation**: Transparent expertise tracking with contribution history  
-**Balance**: Encouraging participation while maintaining quality standards
-
-## Novel AI Methodology Observations
-
-### Emergent Behavior in Scientific AI
-
-**Observation**: AI systems trained on scientific data exhibit different patterns than general ML  
-**Specific Findings**:
-
-1. **Uncertainty Awareness**: Scientific AI must communicate confidence more precisely
-2. **Explanation Requirements**: Scientific users demand mechanistic understanding, not just statistical correlations
-3. **Collaboration Patterns**: Scientific AI benefits from ensemble human-AI reasoning
-
-### Transfer Learning in Domain Science
-
-**Discovery**: Standard transfer learning approaches often fail in scientific domains  
-**Reason**: Distribution shifts in scientific data are more complex than natural images  
-**Solution**: Physics-informed transfer learning with domain adaptation
-
-### Interactive Learning Dynamics
-
-**Finding**: Users learn AI system capabilities while AI learns user preferences  
-**Implication**: Co-evolution of human and AI capabilities  
-**Design Response**: Adaptive interfaces that grow with user expertise
-
-## Validation Methodology
-
-### Scientific Validation Approach
-
-1. **Benchmark Testing**: Against established polymer classification datasets
-2. **Expert Review**: Validation of AI-generated hypotheses by domain experts
-3. **Reproducibility Testing**: Independent replication of results across institutions
-4. **Long-term Studies**: Tracking research outcomes using the platform
-
-### Educational Effectiveness Metrics
-
-1. **Learning Velocity**: Time to demonstrate competency on standard tasks
-2. **Knowledge Retention**: Long-term recall testing
-3. **Transfer Capability**: Application of learned concepts to novel problems
-4. **Engagement Sustainability**: Continued platform usage over time
-
-### Community Impact Assessment
-
-1. **Collaboration Frequency**: Inter-institutional project initiation rates
-2. **Knowledge Sharing**: Community contribution quality and quantity
-3. **Innovation Metrics**: Novel research directions discovered through platform use
-4. **Adoption Patterns**: Spread to related scientific domains
-
-## Future Research Directions
-
-### AI-Assisted Scientific Discovery
-
-**Question**: Can AI systems generate novel scientific hypotheses that lead to discoveries?  
-**Approach**: Hypothesis generation algorithms with experimental validation tracking  
-**Success Metric**: Number of AI-suggested experiments leading to published findings
-
-### Adaptive Scientific Interfaces
-
-**Question**: How should scientific software interfaces evolve with user expertise?  
-**Investigation**: User interface adaptation algorithms based on competency assessment  
-**Measurement**: Task completion efficiency and user satisfaction across expertise levels
-
-### Community-Driven Model Development
-
-**Question**: Can research communities collaboratively improve AI models?  
-**Framework**: Distributed model training with contribution attribution  
-**Validation**: Model performance improvement rates and community engagement levels
-
-## Reflection on AI Development Process
-
-### Meta-Learning Insights
-
-**Observation**: The process of developing AI for science reveals patterns applicable to AI development generally  
-**Key Insight**: Domain expertise integration is more critical than algorithm sophistication  
-**Application**: Prioritize domain expert involvement over purely technical optimization
-
-### Human-AI Collaboration Patterns
-
-**Discovery**: Most effective scientific AI systems augment rather than replace human reasoning  
-**Implementation**: Design for human-AI symbiosis, not automation  
-**Evidence**: Better outcomes when AI provides evidence and humans make decisions
-
-### Sustainability Considerations
-
-**Challenge**: Ensuring long-term platform viability and community engagement  
-**Strategy**: Design for community ownership and contribution  
-**Approach**: Open development with stakeholder involvement from inception
-
-## Conclusion
-
-The POLYMEROS development process demonstrates that successful scientific AI requires deep integration of domain knowledge, community needs, and technical capabilities. The key to success lies not in maximizing any single metric, but in creating adaptive systems that enhance human scientific reasoning.
-
-**Primary Insights**:
-
-1. **Transparency Over Performance**: Scientific users prioritize understanding over accuracy
-2. **Community Over Technology**: Long-term success depends on user community engagement
-3. **Evolution Over Perfection**: Adaptive systems that improve through use outperform static optimal solutions
-
-**Next Steps**:
-
-1. Implement core framework components identified in this analysis
-2. Begin user testing with domain experts to validate design decisions
-3. Establish community feedback loops for continuous improvement
-4. Document emergent behaviors and unexpected use patterns
-
-This process record serves as both a methodology guide and a research artifact, contributing to the broader understanding of AI development for scientific applications.
-
----
-
-_This document will be updated throughout the development process to capture new insights, pattern recognition, and methodology refinements._

POLYMEROS_GUIDE.md

@@ -1,238 +0,0 @@
-# POLYMEROS Development Framework Guide
-
-## Executive Summary
-
-The POLYMEROS (Polymer Research Operating System) framework represents a transformative approach to polymer science research, integrating AI-driven analysis, advanced materials data management, and interactive educational tools into a cohesive, adaptive system. This guide outlines the technical architecture, implementation strategy, and evolutionary roadmap for building a next-generation polymer research platform.
-
-## Framework Overview
-
-### Core Philosophy
-
-POLYMEROS operates on the principle that scientific research tools should be:
-
-- **Adaptive**: Self-improving through use and feedback
-- **Transparent**: Providing clear explanations for all predictions and recommendations
-- **Educational**: Facilitating knowledge transfer from novice to expert levels
-- **Collaborative**: Enabling seamless teamwork across disciplines and institutions
-
-### Three-Pillar Architecture
-
-#### 1. AI for Scientific Analysis
-
-- **Reasoning-Focused Models**: Beyond prediction to hypothesis generation and testing
-- **Transparent Decision Pathways**: Every prediction includes confidence intervals and reasoning chains
-- **Multi-Modal Integration**: Seamless fusion of Raman, FTIR, and emerging spectroscopy techniques
-- **Uncertainty Quantification**: Bayesian approaches for robust confidence estimation
-
-#### 2. Materials Science Data Handling
-
-- **Contextual Knowledge Networks**: Data structures that preserve scientific context and relationships
-- **Intelligent Metadata Management**: Automatic extraction and tracking of experimental conditions
-- **Synthetic Data Generation**: Physics-informed augmentation for limited dataset scenarios
-- **Version Control for Science**: Complete provenance tracking for reproducibility
-
-#### 3. Educational Tools for Knowledge Building
-
-- **Interactive Exploration**: Guided discovery rather than passive information delivery
-- **Adaptive Learning Paths**: Personalized progression based on user expertise and interests
-- **Virtual Laboratory**: Hands-on experimentation in simulated environments
-- **Collaborative Learning**: Peer-to-peer knowledge sharing and validation
-
-## Technical Design
-
-### Data Architecture
-
-```python
-class PolymerosDataEngine:
-    """
-    Adaptive data management system that treats data as structured knowledge networks
-    rather than simple input files.
-    """
-    - SpectroscopyManager: Multi-modal spectral data handling with metadata
-    - KnowledgeGraph: Relationship mapping between materials, conditions, and properties
-    - ProvenanceTracker: Complete audit trail for scientific reproducibility
-    - SyntheticGenerator: Physics-informed data augmentation
-```
-
-### AI Reasoning Engine
-
-```python
-class PolymerosAI:
-    """
-    Transparent AI system that provides explanations alongside predictions.
-    """
-    - HypothesisGenerator: Automated scientific hypothesis creation from patterns
-    - ExplanationEngine: SHAP-based feature importance with domain context
-    - UncertaintyEstimator: Bayesian confidence intervals for all predictions
-    - BiasDetector: Automated identification of potential systematic errors
-```
-
-### Educational Framework
-
-```python
-class PolymerosEducation:
-    """
-    Interactive learning system that adapts to user expertise and learning goals.
-    """
-    - KnowledgeAssessment: Dynamic evaluation of user understanding
-    - LearningPathOptimizer: Personalized curriculum generation
-    - VirtualLab: Simulated experimentation environment
-    - CollaborationHub: Peer learning and expert mentorship tools
-```
-
-## Implementation Timeline
-
-### Phase 1: Foundation (Months 1-3)
-
-**Core Infrastructure Development**
-
-1. **Enhanced Data Pipeline**
-
-   - Implement contextual metadata extraction
-   - Build knowledge graph foundations
-   - Create provenance tracking system
-   - Develop physics-informed synthetic data generator
-
-2. **Transparent AI Core**
-
-   - Integrate SHAP explainability
-   - Implement Bayesian uncertainty quantification
-   - Build hypothesis generation algorithms
-   - Create bias detection framework
-
-3. **Educational Foundation**
-   - Design adaptive assessment system
-   - Build interactive tutorial framework
-   - Create virtual laboratory environment
-   - Implement collaborative tools
-
-### Phase 2: Integration (Months 4-6)
-
-**System Convergence and Enhancement**
-
-1. **Multi-Modal Spectroscopy**
-
-   - FTIR integration with attention-based fusion
-   - Advanced preprocessing with automated parameter optimization
-   - Cross-modal validation and consistency checking
-
-2. **Advanced AI Capabilities**
-
-   - Transformer-based architectures for spectral analysis
-   - Physics-Informed Neural Networks (PINNs) integration
-   - Transfer learning for cross-domain applications
-
-3. **Research Tools**
-   - Automated literature integration
-   - Citation tracking and methodology validation
-   - Collaborative research project management
-
-### Phase 3: Evolution (Months 7-12)
-
-**Self-Improving and Community-Driven Development**
-
-1. **Adaptive Systems**
-
-   - Machine learning on user interactions for system improvement
-   - Automated hyperparameter optimization
-   - Dynamic model selection based on data characteristics
-
-2. **Community Features**
-
-   - Peer review integration with AI assistance
-   - Community-driven dataset expansion
-   - Collaborative model development tools
-
-3. **Research Acceleration**
-   - Automated research direction suggestions
-   - Cross-disciplinary connection identification
-   - Novel material property prediction
-
-## Expected Outcomes
-
-### Quantitative Targets (Year 1)
-
-- **Publications**: 50+ peer-reviewed papers using the platform
-- **Validated Discoveries**: 5+ independently confirmed novel findings
-- **User Engagement**: 2x faster concept mastery for beginners
-- **Research Efficiency**: 30% reduction in time-to-discovery
-
-### Qualitative Indicators
-
-- **Novel Question Types**: Users asking questions not previously considered
-- **AI-Human Collaboration**: AI suggestions matching expert-level insights
-- **Cross-Disciplinary Adoption**: Platform use beyond polymer science
-- **Educational Impact**: Students contributing original research within months
-
-## Success Metrics and Validation
-
-### Scientific Validation
-
-- Benchmark against state-of-the-art polymer classification systems
-- Cross-validation with independent experimental datasets
-- Peer review of AI-generated hypotheses
-- Reproducibility testing across different research groups
-
-### Educational Effectiveness
-
-- Learning outcome assessments compared to traditional methods
-- User satisfaction and engagement metrics
-- Time-to-competency measurements
-- Knowledge retention studies
-
-### Platform Evolution
-
-- Community contribution rates
-- Feature adoption and usage patterns
-- System performance improvements over time
-- Novel use cases discovered by users
-
-## Risk Mitigation
-
-### Technical Risks
-
-- **Model Reliability**: Extensive validation protocols and uncertainty quantification
-- **Data Quality**: Automated quality assessment and provenance tracking
-- **System Complexity**: Modular architecture with clear interfaces
-
-### Scientific Risks
-
-- **Reproducibility**: Complete provenance tracking and version control
-- **Bias Introduction**: Automated bias detection and diverse training data
-- **Overfitting**: Cross-validation and independent test sets
-
-### Adoption Risks
-
-- **Learning Curve**: Progressive disclosure and adaptive tutorials
-- **Integration Challenges**: API-first design and standard data formats
-- **Community Resistance**: Transparent development and user involvement
-
-## Future Directions
-
-### Emerging Technologies Integration
-
-- **Quantum Computing**: Quantum-enhanced molecular simulation
-- **Edge Computing**: Real-time analysis on portable spectrometers
-- **AR/VR**: Immersive molecular visualization and manipulation
-
-### Expanding Domains
-
-- **Materials Beyond Polymers**: Metals, ceramics, composites
-- **Process Optimization**: Manufacturing and recycling workflows
-- **Environmental Monitoring**: Pollution detection and remediation
-
-### Advanced AI Capabilities
-
-- **Causal Inference**: Understanding cause-effect relationships in material properties
-- **Few-Shot Learning**: Rapid adaptation to new material classes
-- **Autonomous Experimentation**: AI-designed and executed experiments
-
-## Conclusion
-
-The POLYMEROS framework represents a paradigm shift from traditional research tools to intelligent, adaptive systems that enhance human scientific capabilities. By integrating advanced AI, sophisticated data management, and interactive education, POLYMEROS aims to accelerate scientific discovery while democratizing access to cutting-edge research tools.
-
-The success of POLYMEROS will be measured not just by its technical capabilities, but by its impact on the scientific community's ability to understand, predict, and design new materials that address global challenges in sustainability, energy, and health.
-
----
-
-_This document serves as a living guide that will evolve with the platform's development and user feedback. Regular updates will incorporate lessons learned, technological advances, and community contributions._

VALIDATION_PROTOCOLS.md

@@ -1,423 +0,0 @@
-# POLYMEROS Validation Protocols
-
-## Overview
-
-This document establishes comprehensive validation protocols for the POLYMEROS platform, ensuring scientific rigor, educational effectiveness, and system reliability. The validation framework operates on multiple levels: technical performance, scientific accuracy, educational impact, and community adoption.
-
-## Scientific Validation Framework
-
-### 1. Model Accuracy and Reliability
-
-#### Benchmark Testing Protocol
-
-**Objective**: Establish platform performance against established datasets and state-of-the-art methods
-
-**Implementation**:
-
-1. **Standard Dataset Validation**
-
-   - NIST Polymer Database cross-validation
-   - FTIR-Plastics Database compatibility testing
-   - Independent laboratory dataset validation
-   - Cross-instrument validation (multiple Raman/FTIR systems)
-
-2. **Performance Metrics**
-
-   ```python
-   validation_metrics = {
-       "accuracy": ">95% on standard datasets",
-       "precision": ">90% per polymer class",
-       "recall": ">90% per polymer class",
-       "f1_score": ">90% overall",
-       "uncertainty_calibration": "Brier score <0.1"
-   }
-   ```
-
-3. **Robustness Testing**
-   - Noise resilience (SNR degradation testing)
-   - Baseline drift tolerance
-   - Instrumental variation effects
-   - Sample preparation differences
-
-#### Statistical Validation
-
-**Protocol**: Bayesian validation with uncertainty quantification
-
-**Requirements**:
-
-- Confidence intervals for all predictions
-- Cross-validation with stratified sampling
-- Bootstrap resampling for stability assessment
-- Multiple independent test sets
-
-### 2. Scientific Hypothesis Validation
-
-#### AI-Generated Hypothesis Testing
-
-**Objective**: Validate the scientific merit of AI-generated hypotheses
-
-**Protocol**:
-
-1. **Expert Review Process**
-
-   - Panel of 5+ polymer science experts
-   - Blind evaluation of AI vs. human-generated hypotheses
-   - Scoring criteria: novelty, testability, scientific rigor
-
-2. **Experimental Validation**
-
-   - Select top 10% of AI hypotheses for experimental testing
-   - Collaborate with research institutions for validation
-   - Track hypothesis-to-discovery conversion rate
-
-3. **Literature Integration**
-   - Automatic citation checking for hypothesis claims
-   - Novelty verification against existing literature
-   - Impact tracking through subsequent research
-
-#### Reproducibility Standards
-
-**Requirements**:
-
-- Complete provenance tracking for all analyses
-- Reproducible computational environments
-- Version control for all algorithms and datasets
-- Independent replication by external groups
-
-### 3. Data Quality and Integrity
-
-#### Metadata Validation
-
-**Protocol**: Comprehensive metadata verification
-
-**Implementation**:
-
-```python
-metadata_validation = {
-    "completeness": "90% of critical fields populated",
-    "accuracy": "Cross-reference with instrument logs",
-    "consistency": "Temporal and spatial consistency checks",
-    "traceability": "Complete chain of custody documentation"
-}
-```
-
-#### Quality Assessment Metrics
-
-1. **Spectral Quality Indicators**
-
-   - Signal-to-noise ratio thresholds
-   - Baseline stability measures
-   - Peak resolution requirements
-   - Calibration accuracy verification
-
-2. **Automated Quality Control**
-   - Real-time quality assessment during upload
-   - Automated flagging of problematic spectra
-   - Quality score integration into model training
-   - User feedback loop for quality improvement
-
-## Educational Effectiveness Validation
-
-### 1. Learning Outcome Assessment
-
-#### Competency Measurement Protocol
-
-**Objective**: Validate educational effectiveness across user groups
-
-**Methodology**:
-
-1. **Pre/Post Assessment Design**
-
-   - Standardized competency tests
-   - Practical skill evaluations
-   - Knowledge retention testing (1, 3, 6 months)
-   - Transfer learning assessment
-
-2. **Control Group Studies**
-   - Traditional learning methods comparison
-   - Platform vs. textbook learning outcomes
-   - Instructor-led vs. self-guided comparison
-   - Long-term retention studies
-
-#### Learning Analytics Validation
-
-**Metrics**:
-
-```python
-educational_metrics = {
-    "learning_velocity": "Time to competency achievement",
-    "knowledge_retention": "Long-term recall accuracy",
-    "skill_transfer": "Novel problem-solving capability",
-    "engagement_sustainability": "Continued platform usage rates"
-}
-```
-
-### 2. Adaptive Learning System Validation
-
-#### Personalization Effectiveness
-
-**Protocol**: A/B testing of adaptive vs. static learning paths
-
-**Measurements**:
-
-- Learning outcome improvements with personalization
-- User satisfaction and engagement metrics
-- Completion rates across different user types
-- Expert validation of learning path recommendations
-
-#### Assessment Accuracy
-
-**Validation Process**:
-
-- Expert validation of competency assessments
-- Cross-validation with external skill tests
-- Bias detection in assessment algorithms
-- Fairness across demographic groups
-
-### 3. Virtual Laboratory Validation
-
-#### Simulation Accuracy
-
-**Requirements**:
-
-- Physics-based validation of simulations
-- Comparison with real experimental data
-- Expert review of simulation parameters
-- User feedback on realism and educational value
-
-#### Learning Effectiveness
-
-**Protocol**:
-
-- Pre/post knowledge testing
-- Hands-on skill transfer to real laboratories
-- Expert evaluation of virtual experiment designs
-- Long-term learning impact assessment
-
-## System Performance Validation
-
-### 1. Technical Performance
-
-#### Scalability Testing
-
-**Protocol**: Load testing and performance benchmarking
-
-**Requirements**:
-
-```python
-performance_requirements = {
-    "response_time": "<2 seconds for predictions",
-    "concurrent_users": "1000+ simultaneous users",
-    "data_throughput": "100+ spectra/minute processing",
-    "uptime": "99.5% availability",
-    "data_integrity": "Zero data loss tolerance"
-}
-```
-
-#### Security Validation
-
-**Components**:
-
-- Data encryption verification
-- User authentication testing
-- Access control validation
-- Privacy compliance (GDPR, FERPA)
-- Vulnerability scanning and penetration testing
-
-### 2. User Experience Validation
-
-#### Usability Testing
-
-**Protocol**: Multi-group usability studies
-
-**Participants**:
-
-- Novice users (students, new researchers)
-- Expert users (experienced scientists)
-- Educators and instructors
-- Industry professionals
-
-**Metrics**:
-
-- Task completion rates
-- Time to task completion
-- Error rates and recovery
-- User satisfaction scores
-- Feature adoption rates
-
-#### Accessibility Validation
-
-**Requirements**:
-
-- WCAG 2.1 AA compliance
-- Screen reader compatibility
-- Keyboard navigation support
-- Color blindness accommodation
-- Multi-language support validation
-
-## Community Impact Validation
-
-### 1. Adoption and Usage Metrics
-
-#### Platform Adoption
-
-**Tracking Metrics**:
-
-```python
-adoption_metrics = {
-    "user_growth": "Monthly active user increase",
-    "institution_adoption": "Academic/industry organization uptake",
-    "geographic_spread": "Global usage distribution",
-    "retention_rate": "Long-term user engagement",
-    "feature_utilization": "Platform capability usage patterns"
-}
-```
-
-#### Research Impact
-
-**Validation**:
-
-- Publications citing platform use
-- Novel discoveries enabled by platform
-- Research collaboration facilitation
-- Cross-disciplinary adoption tracking
-- Industry application validation
-
-### 2. Community Contribution Validation
-
-#### Peer Review System
-
-**Protocol**: Community-driven validation mechanisms
-
-**Implementation**:
-
-- Expert reviewer credentialing
-- Contribution quality scoring
-- Consensus mechanism validation
-- Bias detection in peer review
-- Reputation system accuracy
-
-#### Knowledge Sharing Effectiveness
-
-**Metrics**:
-
-- Community-generated content quality
-- Knowledge transfer success rates
-- Collaborative project outcomes
-- Cross-institutional collaboration frequency
-- Innovation emergence tracking
-
-## Continuous Validation Process
-
-### 1. Ongoing Monitoring
-
-#### Real-Time Validation
-
-**System**: Continuous monitoring and alerting
-
-**Components**:
-
-- Model performance drift detection
-- Data quality degradation alerts
-- User experience issue identification
-- Security threat monitoring
-- Educational outcome tracking
-
-#### Feedback Integration
-
-**Process**: Systematic incorporation of validation results
-
-**Implementation**:
-
-- Regular validation report generation
-- Stakeholder feedback collection
-- Improvement priority assessment
-- Update validation protocols
-- Community validation participation
-
-### 2. Validation Reporting
-
-#### Transparency Requirements
-
-**Documentation**:
-
-- Public validation reports (quarterly)
-- Methodology transparency
-- Limitation acknowledgment
-- Improvement roadmap publication
-- Community feedback incorporation
-
-#### Stakeholder Communication
-
-**Audiences**:
-
-- Scientific community updates
-- Educational institution reports
-- Industry partner briefings
-- Regulatory compliance documentation
-- Public transparency reports
-
-## Validation Success Criteria
-
-### Year 1 Targets
-
-```python
-year_1_targets = {
-    "scientific_accuracy": {
-        "benchmark_performance": ">95% accuracy on standard datasets",
-        "hypothesis_validation": "20% of AI hypotheses experimentally confirmed",
-        "reproducibility": "100% of analyses reproducible by independent groups"
-    },
-    "educational_effectiveness": {
-        "learning_improvement": "2x faster competency achievement vs. traditional methods",
-        "knowledge_retention": "90% retention after 6 months",
-        "user_satisfaction": "4.5/5 average user rating"
-    },
-    "platform_performance": {
-        "uptime": "99.5% system availability",
-        "response_time": "<2 seconds average",
-        "user_growth": "1000+ active monthly users"
-    },
-    "community_impact": {
-        "publications": "50+ papers citing platform use",
-        "discoveries": "5+ validated novel findings",
-        "collaborations": "100+ inter-institutional collaborations"
-    }
-}
-```
-
-### Long-Term Success Indicators
-
-- Platform becomes standard tool in polymer research community
-- Educational curricula integrate platform usage
-- Industry adoption for quality control and R&D
-- Emergence of unexpected use cases and applications
-- Self-sustaining community-driven development
-
-## Risk Mitigation
-
-### Validation Risks
-
-1. **Confirmation Bias**: Multiple independent validation groups
-2. **Overfitting to Benchmarks**: Regular benchmark updates and novel test sets
-3. **Selection Bias**: Diverse user group representation
-4. **Temporal Drift**: Longitudinal validation studies
-5. **Cultural Bias**: International collaboration and validation
-
-### Mitigation Strategies
-
-- Independent validation committees
-- Adversarial testing protocols
-- Diverse stakeholder involvement
-- Transparent methodology publication
-- Regular protocol updates based on emerging best practices
-
-## Conclusion
-
-The POLYMEROS validation framework ensures that the platform meets the highest standards of scientific rigor, educational effectiveness, and system reliability. Through comprehensive, multi-layered validation protocols, we aim to build trust in the platform's capabilities while continuously improving its performance and impact.
-
-Success in validation will be measured not only by meeting technical benchmarks but by the platform's ability to accelerate scientific discovery, enhance educational outcomes, and foster collaboration within the polymer research community.
-
----
-
-_This validation protocol will be updated regularly based on emerging best practices, community feedback, and technological advances. All validation results will be transparently reported to maintain scientific integrity and community trust._

audit-access-check.txt

@@ -1 +0,0 @@
-chatgpt-access-check: 2025-09-02

preprocess_ftir_legacy.py

@@ -1,85 +0,0 @@
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-import numpy as np
-import pandas as pd
-from scipy.interpolate import interp1d
-from scipy.signal import savgol_filter
-from sklearn.preprocessing import minmax_scale
-
-def parse_ftir_file(filepath, num_points=500):
-    df = pd.read_csv(filepath, skiprows=5, header=None, names=["Wavenumber", "Transmittance"])
-    df.dropna(inplace=True)
-    x = df["Wavenumber"].values
-    y = df["Transmittance"].values
-
-    if x[0] > x[-1]:  # Ensure increasing order
-        x = x[::-1]
-        y = y[::-1]
-
-    f_interp = interp1d(x, y, kind="linear", fill_value="extrapolate")
-    x_uniform = np.linspace(x.min(), x.max(), num_points)
-    y_uniform = f_interp(x_uniform)
-
-    return y_uniform
-
-def label_from_filename(filename):
-    """ Assign label based on sample prefix:
-        - '2015a', '2015b', '2015c', '2016a', '2016b' => 1 (Aged)
-        - All other number prefixes (1 . . 19)        => 0 (Unaged)
-    """
-    lower_filename = filename.lower()
-    if lower_filename.startswith(("2015a", "2015b", "2015c", "2016a", "2016b")):
-        return 1    # Aged
-    else:
-        return 0    # Unaged
-
-def remove_baseline(y):
-    x = np.arange(len(y))
-    coeffs = np.polyfit(x, y, deg=2)
-    baseline = np.polyval(coeffs, x)
-    return y - baseline
-
-def normalize_spectrum(y):
-    return minmax_scale(y)
-
-def smooth_spectrum(y, window_length=11, polyorder=2):
-    return savgol_filter(y, window_length, polyorder)
-
-def preprocess_ftir(directory, target_len=500, baseline_correction=False, apply_smoothing=False, normalize=False):
-    X, y = [], []
-
-    for root, _, files in os.walk(directory):
-        for file in files:
-            if file.endswith(".csv") and "fcl" in file.lower():
-                filepath = os.path.join(root, file)
-                try:
-                    spectrum = parse_ftir_file(filepath, num_points=target_len)
-
-                    if baseline_correction:
-                        spectrum = remove_baseline(spectrum)
-                    if apply_smoothing:
-                        spectrum = smooth_spectrum(spectrum)
-                    if normalize:
-                        spectrum = normalize_spectrum(spectrum)
-
-                    label = label_from_filename(file)
-                    X.append(spectrum)
-                    y.append(label)
-                except Exception as e:
-                    print(f"Failed to process {file}: {e}")
-                    with open("scripts/ftir_failures.log", "a", encoding="utf-8") as log_file:
-                        log_file.write(f"{file} - {e}\n")
-
-    X = np.array(X)
-    y = np.array(y)
-
-    print(f"Processed {len(X)} FTIR samples.")
-    return X, y
-
-if __name__ == "__main__":
-    data_dir = os.path.join("datasets", "ftir")
-    X, y = preprocess_ftir(data_dir)
-    print(f"X shape: {X.shape}")
-    print(f"y shape: {y.shape}")
-    print(f"Label distribution: {np.bincount(y)}")

train_ftir_model.py

@@ -1,139 +0,0 @@
-"""
-Module: train_ftir_model
-------------------------
-This module trains the Figure2CNN model on preprocessed FTIR (Fourier-transform infrared spectroscopy) data.
-It includes data loading, preprocessing, splitting into training and testing sets, and a training loop
-with loss and accuracy tracking.
-
-Workflow:
-1. Load preprocessed FTIR data using `preprocess_ftir`.
-2. Split the data into training and testing sets (80% train, 20% test).
-3. Convert the data into PyTorch tensors and wrap them in DataLoaders.
-4. Instantiate the Figure2CNN model and define the loss function and optimizer.
-5. Train the model over a specified number of epochs, tracking loss and accuracy.
-6. Evaluate the model on the test set and report accuracy.
-
-Dependencies:
-- os
-- numpy
-- torch
-- sklearn.model_selection (for train-test split)
-- preprocess_ftir (for data preprocessing)
-- models.figure2_cnn (for the CNN model)
-
-Usage:
-Run this script directly to train the Figure2CNN model on the FTIR dataset.
-The script outputs training loss and accuracy for each epoch, as well as test set accuracy.
-"""
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-import numpy as np
-import torch
-from torch import optim
-from torch import nn
-from sklearn.model_selection import train_test_split
-from torch.utils.data import TensorDataset, DataLoader
-from preprocess_ftir import preprocess_ftir
-from models.figure2_cnn import Figure2CNN
-
-# Load preprocessed Raman data
-data_dir = os.path.join("datasets", "ftir")
-X, y = preprocess_ftir(data_dir)
-
-# Print shape for confirmation
-print(f"Total Samples: {X.shape[0]}")
-print(f"Feature Shape per Sample: {X.shape[1]}")
-
-# Split into 80% train, 20% test
-X_train, X_test, y_train, y_test = train_test_split(
-    X,
-    y,
-    test_size=0.2,
-    random_state=42,  # for reproductability
-    stratify=y,  # balances label distribution (e.g.,0s & 1s)
-)
-
-# Confirm Results
-print(f"Training Samples: {X_train.shape[0]}")
-print(f"Test Samples: {X_test.shape[0]}")
-
-# Convert to PyTorch tensors
-X_train_tensor = torch.tensor(X_train, dtype=torch.float32).unsqueeze(
-    1
-)  # shape (N, 1, 500)
-y_train_tensor = torch.tensor(y_train, dtype=torch.long)
-X_test_tensor = torch.tensor(X_test, dtype=torch.float32).unsqueeze(1)
-y_test_tensor = torch.tensor(y_test, dtype=torch.long)
-
-# Wrap in TensorDataset
-train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
-test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
-
-# Create DataLoaders
-train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
-test_loader = DataLoader(test_dataset, batch_size=16)
-
-# Instantiate model
-model = Figure2CNN(input_length=500)
-
-# Set to evaluation or training mode as needed
-model.train()
-
-# Define loss function
-criterion = nn.CrossEntropyLoss()
-
-# Optimizer
-optimizer = optim.Adam(model.parameters(), lr=0.001)
-
-# Training loop
-num_epochs = 10
-
-for epoch in range(num_epochs):
-    model.train()
-    running_loss = 0.0
-    correct = 0
-    total = 0
-
-    for inputs, labels in train_loader:
-        # Forward pass
-        outputs = model(inputs)
-        loss = criterion(outputs, labels)
-
-        # Backpropagation + optimization
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-
-        # Track metrics
-        running_loss += loss.item()
-        _, predicted = torch.max(outputs, 1)
-        total += labels.size(0)
-        correct += (predicted == labels).sum().item()
-
-    # Epoch summary
-    epoch_loss = running_loss / len(train_loader)
-    epoch_acc = correct / total * 100
-
-    print(
-        f"Epoch [{epoch+1}/{num_epochs}] - Loss: {epoch_loss:.4f} - Accuracy: {epoch_acc:.2f}%"
-    )
-
-
-# -------------------------------
-# Step 6.1.5 — Evaluation on Test Set
-# -------------------------------
-
-model.eval()
-correct = 0
-total = 0
-
-with torch.no_grad():
-    for inputs, labels in test_loader:
-        outputs = model(inputs)
-        _, predicted = torch.max(outputs, 1)
-        total += labels.size(0)
-        correct += (predicted == labels).sum().item()
-
-test_acc = correct / total * 100
-print(f"\nTest Set Accuracy: {test_acc:.2f}%")

train_ftir_model_cv.py

@@ -1,201 +0,0 @@
-"""
-This script performs 10-fold cross-validation on FTIR data using a CNN model.
-It includes optional preprocessing steps such as baseline correction, smoothing, and normalization.
-"""
-
-import os
-import sys
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-import json
-import argparse
-from datetime import datetime
-import warnings
-
-import numpy as np
-import torch
-from torch.utils.data import TensorDataset, DataLoader
-from sklearn.model_selection import StratifiedKFold
-from sklearn.metrics import confusion_matrix
-
-from models.figure2_cnn import Figure2CNN
-from depracated_scripts.preprocess_ftir import preprocess_ftir
-
-# Argument parser
-parser = argparse.ArgumentParser(
-    description="Run 10-fold CV on FTIR data with optional preprocessing.")
-parser.add_argument(
-    "--target-len", type=int, default=500,
-    help="Number of points to resample spectra to"
-)
-parser.add_argument(
-    "--baseline", action="store_true",
-    help="Apply baseline correction"
-)
-parser.add_argument(
-    "--smooth", action="store_true",
-    help="Apply Savitzky-Golay smoothing"
-)
-parser.add_argument(
-    "--normalize", action="store_true",
-    help="Apply min-max normalization"
-)
-parser.add_argument(
-    "--batch-size", type=int, default=16,
-    help="Batch size for training"
-)
-parser.add_argument(
-    "--epochs", type=int, default=10,
-    help="Number of training epochs."
-)
-parser.add_argument(
-    "--learning-rate", type=float,
-    default=1e-3, help="Learning rate for optimizer."
-)
-
-args = parser.parse_args()
-
-
-# Print configuration
-print("Preprocessing Configuration:")
-print(f"    Reseample to    : {args.target_len} points")
-print(f"    Baseline Correct: {'✅' if args.baseline else '❌'}")
-print(f"    Smoothing       : {'✅' if args.smooth else '❌'}")
-print(f"    Normalization   : {'✅' if args.normalize else '❌'}")
-
-# Constants
-DATASET_PATH = 'datasets/ftir'
-BATCH_SIZE = args.batch_size
-EPOCHS = args.epochs
-NUM_FOLDS = 10
-LEARNING_RATE = args.learning_rate
-DEVICE = torch.device("cuda" if torch.cuda.is_available() else 'cpu')
-
-# Load and preprocess dataset
-print("🔄 Loading and preprocessing FTIR data ...")
-X, y = preprocess_ftir(
-    DATASET_PATH,
-    target_len=args.target_len,
-    baseline_correction=args.baseline,
-    apply_smoothing=args.smooth,
-    normalize=args.normalize
-)
-X = np.array(X, dtype=np.float32)
-y = np.array(y, dtype=np.int64)
-print(f"✅ Data Loaded: {X.shape[0]} samples, {X.shape[1]} features each.")
-input_channels = 4
-
-# Cross-validation setup
-skf = StratifiedKFold(n_splits=NUM_FOLDS, shuffle=True, random_state=42)
-fold_accuracies = []
-all_conf_matrices = []
-
-# Cross-validation loop
-with warnings.catch_warnings():
-    warnings.simplefilter("ignore", category=UserWarning)
-    for fold, (train_idx, val_idx) in enumerate(skf.split(X, y), 1):
-        print(f"\n🔁 Fold {fold}/{NUM_FOLDS} Training...")
-
-        X_train, X_val = X[train_idx], X[val_idx]
-        y_train, y_val = y[train_idx], y[val_idx]
-
-        train_dataset = TensorDataset(torch.tensor(X_train), torch.tensor(y_train))
-        val_dataset = TensorDataset(torch.tensor(X_val), torch.tensor(y_val))
-        train_loader = DataLoader(
-            train_dataset, batch_size=BATCH_SIZE, shuffle=True)
-        val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE)
-
-        model = Figure2CNN(input_length=args.target_len, input_channels=input_channels).to(DEVICE)
-        model.describe_model()
-        optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
-        criterion = torch.nn.CrossEntropyLoss()
-
-
-        # Training
-        for epoch in range(EPOCHS):
-            model.train()
-            RUNNING_LOSS = 0.0
-            for inputs, labels in train_loader:
-                inputs = inputs.view(inputs.size(0), input_channels, args.target_len).to(DEVICE)
-                labels = labels.to(DEVICE)
-
-                optimizer.zero_grad()
-                outputs = model(inputs)
-                loss = criterion(outputs, labels)
-                loss.backward()
-                optimizer.step()
-                RUNNING_LOSS += loss.item()
-
-        # After fold loop (outside the epoch loop), print 1 line:
-        print(f"✅ Fold {fold} completed. Final training loss: {RUNNING_LOSS:.4f}")
-
-        torch.save(model.state_dict(), "outputs/ftir_model.pth")
-
-        # Evaluation
-        model.eval()
-        all_true = []
-        all_pred = []
-        with torch.no_grad():
-            for inputs, labels in val_loader:
-                inputs = inputs.view(inputs.size(0), input_channels, args.target_len).to(DEVICE)
-                labels = labels.to(DEVICE)
-                outputs = model(inputs)
-                _, predicted = torch.max(outputs, 1)
-                all_true.extend(labels.cpu().numpy())
-                all_pred.extend(predicted.cpu().numpy())
-
-        accuracy = 100 * np.mean(np.array(all_true) == np.array(all_pred))
-        fold_accuracies.append(accuracy)
-        conf_mat = confusion_matrix(all_true, all_pred)
-        all_conf_matrices.append(conf_mat)
-
-        print(f"✅ Fold {fold} Accuracy: {accuracy:.2f}%")
-        print(f"Confusion Matrix Fold {fold}):\n{conf_mat}")
-
-# Final summary
-print("\n📊 Final Cross-Validation Results:")
-for i, acc in enumerate(fold_accuracies, 1):
-    print(f"Fold {i}: {acc:.2f}%")
-
-mean_acc = np.mean(fold_accuracies)
-std_acc = np.std(fold_accuracies)
-print(f"\n✅ Mean Accuracy: {mean_acc:.2f}% ± {std_acc:.2f}%")
-print("✅ Model saved to outputs/ftir_model.pth")
-
-
-# Diagnostics log saving
-def save_diagnostics_log(fold_accs, conf_matrices, config_args, output_path="logs/ftir_cv_diagnostics.json"):
-    fold_metrics = [
-        {
-            "fold": i + 1,
-            "accuracy": acc,
-            "confusion_matrix": cm.tolist()
-        }
-        for i, (acc, cm) in enumerate(zip(fold_accs, conf_matrices))
-    ]
-    log = {
-        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "preprocessing": {
-            "target_len": config_args.target_len,
-            "baseline_correction": config_args.baseline,
-            "smoothin": config_args.smooth,
-            "normalization": config_args.normalize,
-        },
-        "fold_metrics": fold_metrics,
-        "overall": {
-            "mean_accuracy": float(np.mean(fold_accs)),
-            "std_accuracy": float(np.std(fold_accs)),
-            "num_folds": len(fold_accs),
-            "batch_size": BATCH_SIZE,
-            "epochs": EPOCHS,
-            "learning_rate": LEARNING_RATE,
-            "device": str(DEVICE)
-        }
-    }
-    os.makedirs("logs", exist_ok=True)
-    with open(output_path, "w", encoding="utf-8") as f:
-        json.dump(log, f, indent=2)
-    print(f"🧠 Diagnostics written to {output_path}")
-
-
-# Run diagnostics save
-save_diagnostics_log(fold_accuracies, all_conf_matrices, args)

train_model.py

@@ -1,135 +0,0 @@
-"""
-Module: train_model
--------------------
-This module trains the Figure2CNN model on preprocessed Raman spectroscopy data. 
-It includes data loading, preprocessing, splitting into training and testing sets, 
-and a training loop with loss and accuracy tracking.
-
-Workflow:
-1. Load preprocessed Raman data using `preprocess_dataset`.
-2. Split the data into training and testing sets (80% train, 20% test).
-3. Convert the data into PyTorch tensors and wrap them in DataLoaders.
-4. Instantiate the Figure2CNN model and define the loss function and optimizer.
-5. Train the model over a specified number of epochs, tracking loss and accuracy.
-
-Dependencies:
-- os
-- numpy
-- torch
-- sklearn.model_selection (for train-test split)
-- preprocess_dataset (for data preprocessing)
-- models.figure2_cnn (for the CNN model)
-
-Usage:
-Run this script directly to train the Figure2CNN model on the Raman dataset. 
-The script outputs training loss and accuracy for each epoch.
-"""
-import sys
-import os
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-import torch
-from torch.utils.data import TensorDataset, DataLoader
-from sklearn.model_selection import train_test_split
-import torch.nn as nn
-import torch.optim as optim
-from preprocess_dataset import preprocess_dataset
-from models.figure2_cnn import Figure2CNN
-
-
-# Load preprocessed Raman data
-data_dir = os.path.join("datasets", "rdwp")
-X, y = preprocess_dataset(data_dir)
-
-# Print shape for confirmation
-print(f"Total Samples: {X.shape[0]}")
-print(f"Feature Shape per Sample: {X.shape[1]}")
-
-# Split into 80% train, 20% test
-X_train, X_test, y_train, y_test = train_test_split(
-    X, y,
-    test_size=0.2,
-    random_state=42,  # for reproductability
-    stratify=y       # balances label distribution (e.g.,0s & 1s)
-)
-
-# Confirm Results
-print(f"Training Samples: {X_train.shape[0]}")
-print(f"Test Samples: {X_test.shape[0]}")
-
-# Convert to PyTorch tensors
-X_train_tensor = torch.tensor(
-    X_train, dtype=torch.float32).unsqueeze(1)  # shape (N, 1, 500)
-y_train_tensor = torch.tensor(y_train, dtype=torch.long)
-X_test_tensor = torch.tensor(X_test, dtype=torch.float32).unsqueeze(1)
-y_test_tensor = torch.tensor(y_test, dtype=torch.long)
-
-# Wrap in TensorDataset
-train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
-test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
-
-# Create DataLoaders
-train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
-test_loader = DataLoader(test_dataset, batch_size=16)
-
-# Instantiate model
-model = Figure2CNN(input_length=500)
-
-# Set to evaluation or training mode as needed
-model.train()
-
-# Define loss function
-criterion = nn.CrossEntropyLoss()
-
-# Optimizer
-optimizer = optim.Adam(model.parameters(), lr=0.001)
-
-# Training loop
-num_epochs = 10
-
-for epoch in range(num_epochs):
-    model.train()
-    running_loss = 0.0
-    correct = 0
-    total = 0
-
-    for inputs, labels in train_loader:
-        # Forward pass
-        outputs = model(inputs)
-        loss = criterion(outputs, labels)
-
-        # Backpropagation + optimization
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-
-        # Track metrics
-        running_loss += loss.item()
-        _, predicted = torch.max(outputs, 1)
-        total += labels.size(0)
-        correct += (predicted == labels).sum().item()
-
-    # Epoch summary
-    epoch_loss = running_loss / len(train_loader)
-    epoch_acc = correct / total * 100
-
-    print(
-        f"Epoch [{epoch+1}/{num_epochs}] - Loss: {epoch_loss:.4f} - Accuracy: {epoch_acc:.2f}%")
-
-
-# -------------------------------
-# Step 6.1.5 — Evaluation on Test Set
-# -------------------------------
-
-model.eval()
-correct = 0
-total = 0
-
-with torch.no_grad():
-    for inputs, labels in test_loader:
-        outputs = model(inputs)
-        _, predicted = torch.max(outputs, 1)
-        total += labels.size(0)
-        correct += (predicted == labels).sum().item()
-
-test_acc = correct / total * 100
-print(f"\nTest Set Accuracy: {test_acc:.2f}%")