silver-diagnostics 0.1.0__py3-none-any.whl

silver_diagnostics/__init__.py

@@ -0,0 +1,5 @@
+from .dataset import diagnose_dataset
+from .metrics import diagnose_metrics
+from .models import Diagnostic, DiagnosticReport
+
+__all__ = ["Diagnostic", "DiagnosticReport", "diagnose_dataset", "diagnose_metrics"]

silver_diagnostics/dataset.py

@@ -0,0 +1,76 @@
+from typing import Any, List
+
+from .models import Diagnostic, DiagnosticReport
+from .utils import is_finite
+
+
+def diagnose_dataset(
+    features: List[List[float]], labels: List[float]
+) -> DiagnosticReport:
+    diagnostics: List[Diagnostic] = []
+    if len(features) == 0:
+        diagnostics.append(
+            Diagnostic(
+                code="empty_dataset",
+                severity="error",
+                message="The dataset contains no feature rows.",
+                details={},
+            )
+        )
+    if len(features) != len(labels):
+        diagnostics.append(
+            Diagnostic(
+                code="length_mismatch",
+                severity="error",
+                message="Features and labels must contain the same number of rows.",
+                details={"features": len(features), "labels": len(labels)},
+            )
+        )
+    if features:
+        expected_width = len(features[0])
+        inconsistent_widths = [
+            (index, len(row))
+            for index, row in enumerate(features)
+            if len(row) != expected_width
+        ]
+        if inconsistent_widths:
+            diagnostics.append(
+                Diagnostic(
+                    code="feature_width_mismatch",
+                    severity="error",
+                    message="Feature rows do not have a consistent width.",
+                    details={
+                        "expected": expected_width,
+                        "mismatches": inconsistent_widths[:5],
+                    },
+                )
+            )
+        for row_index, row in enumerate(features):
+            for column_index, value in enumerate(row):
+                if not isinstance(value, (int, float)) or not is_finite(value):
+                    diagnostics.append(
+                        Diagnostic(
+                            code="non_finite_feature",
+                            severity="error",
+                            message="A feature is not finite.",
+                            details={
+                                "row": row_index,
+                                "column": column_index,
+                                "value": value,
+                            },
+                        )
+                    )
+    for label_index, label in enumerate(labels):
+        if not isinstance(label, (int, float)) or not is_finite(label):
+            diagnostics.append(
+                Diagnostic(
+                    code="non_finite_label",
+                    severity="error",
+                    message="A label is not finite.",
+                    details={"index": label_index, "value": label},
+                )
+            )
+    return DiagnosticReport(
+        valid=not any(diagnostic.severity == "error" for diagnostic in diagnostics),
+        diagnostics=diagnostics,
+    )

silver_diagnostics/metrics.py

@@ -0,0 +1,36 @@
+from typing import Dict
+
+from .models import Diagnostic, DiagnosticReport
+from .utils import is_finite
+
+
+def diagnose_metrics(metrics: Dict[str, float]) -> DiagnosticReport:
+    diagnostics = []
+    for name, value in metrics.items():
+        if not isinstance(value, (int, float)) or not is_finite(value):
+            diagnostics.append(
+                Diagnostic(
+                    code="non_finite_metric",
+                    severity="error",
+                    message=f"{name} is not finite.",
+                    details={"name": name, "value": value},
+                )
+            )
+        if (
+            "gradient" in name.lower()
+            and isinstance(value, (int, float))
+            and is_finite(value)
+            and abs(value) > 1e4
+        ):
+            diagnostics.append(
+                Diagnostic(
+                    code="exploding_gradient",
+                    severity="warning",
+                    message=f"{name} is unusually large and may indicate exploding gradients.",
+                    details={"name": name, "value": value},
+                )
+            )
+    return DiagnosticReport(
+        valid=not any(diagnostic.severity == "error" for diagnostic in diagnostics),
+        diagnostics=diagnostics,
+    )

silver_diagnostics/models.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Literal
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    code: str
+    severity: Literal["error", "warning", "info"]
+    message: str
+    details: Dict[str, Any]
+
+
+@dataclass(frozen=True)
+class DiagnosticReport:
+    valid: bool
+    diagnostics: List[Diagnostic]

silver_diagnostics/utils.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+
+def is_finite(value: Any) -> bool:
+    try:
+        return value == value and abs(value) != float("inf")
+    except (TypeError, ValueError):
+        return False

silver_diagnostics-0.1.0.dist-info/METADATA

@@ -0,0 +1,294 @@
+Metadata-Version: 2.4
+Name: silver-diagnostics
+Version: 0.1.0
+Summary: Framework-neutral ML data and training diagnostics for Silver.
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/adfgdartec/silver-diagnostics
+Project-URL: Repository, https://github.com/adfgdartec/silver-diagnostics
+Project-URL: Issues, https://github.com/adfgdartec/silver-diagnostics/issues
+Keywords: machine-learning,diagnostics,debugging,data-quality,python
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# silver-diagnostics
+
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](tests/)
+[![Code Style](https://img.shields.io/badge/code%20style-flake8-blue.svg)](https://flake8.pycqa.org/)
+
+Framework-neutral ML data and training diagnostics for Silver. A Python package designed for ML researchers who need robust data validation and training stability checks across different frameworks.
+
+## Installation
+
+```bash
+pip install silver-diagnostics
+```
+
+## Quick Start
+
+```python
+from silver_diagnostics import diagnose_dataset, diagnose_metrics
+
+# Diagnose dataset issues
+features = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]
+labels = [0.0, 1.0, 0.0]
+
+report = diagnose_dataset(features, labels)
+if not report.valid:
+    print("Dataset issues found:")
+    for diagnostic in report.diagnostics:
+        print(f"  [{diagnostic.severity}] {diagnostic.message}")
+
+# Diagnose metrics issues
+metrics = {"loss": 0.5, "accuracy": 0.9, "gradient_norm": 1e6}
+report = diagnose_metrics(metrics)
+for diagnostic in report.diagnostics:
+    print(f"[{diagnostic.severity}] {diagnostic.message}")
+```
+
+## Features
+
+- **Dataset Validation**: Comprehensive checks for empty data, length mismatches, and structural issues
+- **Non-Finite Detection**: Automatic detection of NaN and infinity values in features and labels
+- **Metrics Diagnostics**: Training metrics validation for numerical stability
+- **Exploding Gradient Detection**: Specialized checks for gradient explosion during training
+- **Framework-Agnostic**: Works with PyTorch, TensorFlow, JAX, or any numeric data
+- **Detailed Reporting**: Structured diagnostic information with severity levels and context
+- **Type Safety**: Full type hints for better IDE support and fewer bugs
+
+## Use Cases
+
+### Training Pipeline Validation
+
+```python
+from silver_diagnostics import diagnose_dataset, diagnose_metrics
+import torch
+
+# Validate training data before training
+train_features = torch.randn(1000, 10).numpy()
+train_labels = torch.randint(0, 2, (1000,)).numpy()
+
+report = diagnose_dataset(train_features.tolist(), train_labels.tolist())
+if not report.valid:
+    print("Cannot train with invalid dataset:")
+    for diagnostic in report.diagnostics:
+        print(f"  {diagnostic.code}: {diagnostic.message}")
+else:
+    print("Dataset is valid for training")
+```
+
+### Training Stability Monitoring
+
+```python
+from silver_diagnostics import diagnose_metrics
+
+# Monitor training metrics for stability
+def check_training_stability(metrics):
+    report = diagnose_metrics(metrics)
+    
+    # Check for errors
+    errors = [d for d in report.diagnostics if d.severity == "error"]
+    if errors:
+        print("Training stability issues:")
+        for error in errors:
+            print(f"  {error.code}: {error.message}")
+            return False
+    
+    # Check for warnings
+    warnings = [d for d in report.diagnostics if d.severity == "warning"]
+    if warnings:
+        print("Training stability warnings:")
+        for warning in warnings:
+            print(f"  {warning.code}: {warning.message}")
+    
+    return True
+
+# During training loop
+for epoch in range(10):
+    loss = train_epoch()
+    metrics = {
+        "loss": loss,
+        "gradient_norm": compute_gradient_norm(),
+        "accuracy": evaluate()
+    }
+    
+    if not check_training_stability(metrics):
+        print("Training unstable - stopping")
+        break
+```
+
+### Data Quality Assurance
+
+```python
+from silver_diagnostics import diagnose_dataset
+
+def validate_ml_pipeline_data(X_train, y_train, X_val, y_val):
+    """Validate all datasets in ML pipeline"""
+    datasets = {
+        "training": (X_train, y_train),
+        "validation": (X_val, y_val)
+    }
+    
+    all_valid = True
+    for name, (features, labels) in datasets.items():
+        report = diagnose_dataset(features.tolist(), labels.tolist())
+        
+        print(f"\n{name} dataset:")
+        if report.valid:
+            print(f"  ✓ Valid ({len(features)} samples)")
+        else:
+            print(f"  ✗ Invalid")
+            for diagnostic in report.diagnostics:
+                print(f"    {diagnostic.message}")
+            all_valid = False
+    
+    return all_valid
+```
+
+### Framework Integration
+
+```python
+from silver_diagnostics import diagnose_dataset, diagnose_metrics
+import tensorflow as tf
+import torch
+
+# Works with TensorFlow tensors
+tf_features = tf.random.normal((100, 10))
+tf_labels = tf.random.uniform((100,), maxval=2, dtype=tf.int32)
+
+report = diagnose_dataset(
+    tf_features.numpy().tolist(),
+    tf_labels.numpy().tolist()
+)
+
+# Works with PyTorch tensors
+torch_features = torch.randn(100, 10)
+torch_labels = torch.randint(0, 2, (100,))
+
+report = diagnose_dataset(
+    torch_features.tolist(),
+    torch_labels.tolist()
+)
+```
+
+## Advanced Usage
+
+### Custom Diagnostic Processing
+
+```python
+from silver_diagnostics import diagnose_dataset, Diagnostic
+
+def categorize_diagnostics(report):
+    """Categorize diagnostics by type"""
+    categories = {
+        "structural": [],
+        "data_quality": [],
+        "numerical": []
+    }
+    
+    for diagnostic in report.diagnostics:
+        if diagnostic.code in ["empty_dataset", "length_mismatch", "feature_width_mismatch"]:
+            categories["structural"].append(diagnostic)
+        elif diagnostic.code in ["non_finite_feature", "non_finite_label"]:
+            categories["numerical"].append(diagnostic)
+        else:
+            categories["data_quality"].append(diagnostic)
+    
+    return categories
+
+report = diagnose_dataset(features, labels)
+categories = categorize_diagnostics(report)
+
+for category, diagnostics in categories.items():
+    if diagnostics:
+        print(f"{category.upper()} ({len(diagnostics)}):")
+        for diag in diagnostics:
+            print(f"  - {diag.message}")
+```
+
+### Batch Validation
+
+```python
+from silver_diagnostics import diagnose_dataset
+
+def validate_multiple_datasets(dataset_dict):
+    """Validate multiple datasets at once"""
+    results = {}
+    
+    for name, (features, labels) in dataset_dict.items():
+        report = diagnose_dataset(features, labels)
+        results[name] = {
+            "valid": report.valid,
+            "error_count": sum(1 for d in report.diagnostics if d.severity == "error"),
+            "warning_count": sum(1 for d in report.diagnostics if d.severity == "warning"),
+            "diagnostics": report.diagnostics
+        }
+    
+    return results
+
+datasets = {
+    "train": (X_train.tolist(), y_train.tolist()),
+    "val": (X_val.tolist(), y_val.tolist()),
+    "test": (X_test.tolist(), y_test.tolist())
+}
+
+validation_results = validate_multiple_datasets(datasets)
+for name, result in validation_results.items():
+    status = "✓" if result["valid"] else "✗"
+    print(f"{status} {name}: {result['error_count']} errors, {result['warning_count']} warnings")
+```
+
+## Requirements
+
+- Python 3.8+
+
+## Development
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=silver_diagnostics --cov-report=html
+
+# Run linting
+flake8 src/ tests/
+mypy src/
+```
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+Apache-2.0 - see [LICENSE](LICENSE) file for details.
+
+## Related Packages
+
+- [silver-data](https://github.com/adfgdartec/silver-data) - Dataset handling
+- [silver-run](https://github.com/adfgdartec/silver-run) - Training lifecycle
+- [silver-adapters](https://github.com/adfgdartec/silver-adapters) - Framework adapters

silver_diagnostics-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+silver_diagnostics/__init__.py,sha256=IpfWo06ghsPkb3y-wwrxGDfi2H16wSJ13NO1DPvmi5Q,211
+silver_diagnostics/dataset.py,sha256=hFeE4cqoz4jJ5BQNdEUqFhguBmyPuwjoE1lIgH6icZU,2812
+silver_diagnostics/metrics.py,sha256=gwisKFEkU_YOjCwLyoXEd1GFvd5IvKm3nSP5teGQ8PQ,1262
+silver_diagnostics/models.py,sha256=dPUzlOrYik26Aa32u4u8PyPmAySclBVf-A_kJsmR2N0,331
+silver_diagnostics/utils.py,sha256=moXFkGpck4rhkc8-VRWJc4KYGRTP1pSd1kqdz9x0njY,187
+silver_diagnostics-0.1.0.dist-info/licenses/LICENSE,sha256=9uEgZddcCAZ2jYIKny4rlbkQMZFhKRvSGbxctAg4wjI,517
+silver_diagnostics-0.1.0.dist-info/METADATA,sha256=CA-ki2uzHB_S875rXHfw30F20Htys-nSdSaMeuvBrk8,9071
+silver_diagnostics-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+silver_diagnostics-0.1.0.dist-info/top_level.txt,sha256=GAdKKkhCBVR1rBV_Hv-Y0c7hfrXJR13C1tKCRcgr8Ng,19
+silver_diagnostics-0.1.0.dist-info/RECORD,,

silver_diagnostics-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

silver_diagnostics-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,12 @@
+Apache License
+Version 2.0, January 2004
+
+Copyright 2026 Silver Contributors
+
+Licensed under the Apache License, Version 2.0. You may obtain a copy of the
+License at https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

silver_diagnostics-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+silver_diagnostics