evolveml 0.2.0__tar.gz

evolveml-0.2.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: evolveml
+Version: 0.2.0
+Summary: A Python ML library that evolves with your data. Batch + Real-time Learning, AutoML, XAI, NLP, RL, Anomaly Detection & more.
+Author: SAPPA VAMSI
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/evolveml
+Keywords: machine learning,online learning,automl,explainable ai,reinforcement learning,nlp,anomaly detection
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+
+# evolveml 🚀
+
+> A Python ML library that **evolves with your data.**  
+> Batch + Real-time Learning + Latest 2026 AI Trends — no sklearn needed!
+
+**Author: SAPPA VAMSI**
+
+---
+
+## Install
+
+```bash
+pip install evolveml
+```
+
+---
+
+## What's Inside (v0.2.0)
+
+### 🧠 Core Models
+| Module | Description |
+|---|---|
+| `DecisionTreeClassifier` | Decision Tree from scratch |
+| `LinearRegressionModel` | Linear Regression |
+| `LogisticRegressionModel` | Logistic Regression + online updates |
+| `NeuralNetwork` | Neural Network from scratch |
+
+### 🔄 Real-time / Online Learning
+| Module | Description |
+|---|---|
+| `StreamLearner` | Learns one sample at a time in real-time |
+
+### 🎯 Ready-to-use Tasks
+| Module | Description |
+|---|---|
+| `FraudDetector` | Real-time bank fraud detection |
+| `ImageClassifier` | Image classification |
+| `SpamDetector` | Email spam detection |
+| `StockPredictor` | Stock price prediction |
+
+### 🔥 Latest 2026 Trending Modules
+| Module | Trend | Description |
+|---|---|---|
+| `AutoFeatureSelector` | **AutoML** | Auto-selects best features |
+| `AnomalyDetector` | **Edge AI / IoT** | Detects anomalies in streams |
+| `ConceptDriftDetector` | **Adaptive ML** | Detects data distribution changes |
+| `ExplainableModel` | **XAI** | Explains WHY model predicted |
+| `ReinforcementAgent` | **Agentic AI** | Q-Learning agent |
+| `SentimentAnalyzer` | **NLP** | Real-time text sentiment |
+| `TransferLearner` | **Transfer Learning** | Reuse knowledge across tasks |
+
+---
+
+## Quick Examples
+
+### 🤖 AutoML - Auto Feature Selection
+```python
+from evolveml import AutoFeatureSelector
+selector = AutoFeatureSelector(top_k=5)
+X_best = selector.fit_transform(X_train, y_train)
+selector.report()
+```
+
+### 🚨 Anomaly Detection (IoT/Edge)
+```python
+from evolveml import AnomalyDetector
+detector = AnomalyDetector(threshold=2.5)
+detector.fit(normal_data)
+result = detector.detect(new_sensor_reading)
+print(result)  # {'is_anomaly': True, 'status': '🚨 ANOMALY'}
+```
+
+### 📉 Concept Drift Detection
+```python
+from evolveml import ConceptDriftDetector
+drift = ConceptDriftDetector()
+for pred, actual in prediction_stream:
+    status = drift.update(pred, actual)
+    if status['drift_detected']:
+        print("⚠️ Retrain your model!")
+```
+
+### 🔍 Explainable AI
+```python
+from evolveml import ExplainableModel, DecisionTreeClassifier
+model = DecisionTreeClassifier()
+model.fit(X_train, y_train)
+xai = ExplainableModel(model, feature_names=['age', 'amount', 'hour'])
+xai.fit(X_train, y_train)
+xai.explain(X_test[0])
+```
+
+### 🎮 Reinforcement Learning Agent
+```python
+from evolveml import ReinforcementAgent
+agent = ReinforcementAgent(n_states=100, n_actions=4)
+action = agent.act(state)
+agent.learn(state, action, reward=+1, next_state=next_state)
+```
+
+### 💬 Sentiment Analysis
+```python
+from evolveml import SentimentAnalyzer
+analyzer = SentimentAnalyzer()
+result = analyzer.analyze("This product is absolutely amazing!")
+print(result)  # {'sentiment': 'POSITIVE 😊', 'confidence': 0.87}
+analyzer.learn("brilliant", label='positive')  # teach new words
+```
+
+### 🔁 Transfer Learning
+```python
+from evolveml import TransferLearner, DecisionTreeClassifier
+source = DecisionTreeClassifier()
+source.fit(X_source, y_source)
+transfer = TransferLearner(source)
+transfer.fit(X_target, y_target)  # learns faster with less data!
+```
+
+---
+
+## License
+MIT — Free to use!

evolveml-0.2.0/README.md

@@ -0,0 +1,122 @@
+# evolveml 🚀
+
+> A Python ML library that **evolves with your data.**  
+> Batch + Real-time Learning + Latest 2026 AI Trends — no sklearn needed!
+
+**Author: SAPPA VAMSI**
+
+---
+
+## Install
+
+```bash
+pip install evolveml
+```
+
+---
+
+## What's Inside (v0.2.0)
+
+### 🧠 Core Models
+| Module | Description |
+|---|---|
+| `DecisionTreeClassifier` | Decision Tree from scratch |
+| `LinearRegressionModel` | Linear Regression |
+| `LogisticRegressionModel` | Logistic Regression + online updates |
+| `NeuralNetwork` | Neural Network from scratch |
+
+### 🔄 Real-time / Online Learning
+| Module | Description |
+|---|---|
+| `StreamLearner` | Learns one sample at a time in real-time |
+
+### 🎯 Ready-to-use Tasks
+| Module | Description |
+|---|---|
+| `FraudDetector` | Real-time bank fraud detection |
+| `ImageClassifier` | Image classification |
+| `SpamDetector` | Email spam detection |
+| `StockPredictor` | Stock price prediction |
+
+### 🔥 Latest 2026 Trending Modules
+| Module | Trend | Description |
+|---|---|---|
+| `AutoFeatureSelector` | **AutoML** | Auto-selects best features |
+| `AnomalyDetector` | **Edge AI / IoT** | Detects anomalies in streams |
+| `ConceptDriftDetector` | **Adaptive ML** | Detects data distribution changes |
+| `ExplainableModel` | **XAI** | Explains WHY model predicted |
+| `ReinforcementAgent` | **Agentic AI** | Q-Learning agent |
+| `SentimentAnalyzer` | **NLP** | Real-time text sentiment |
+| `TransferLearner` | **Transfer Learning** | Reuse knowledge across tasks |
+
+---
+
+## Quick Examples
+
+### 🤖 AutoML - Auto Feature Selection
+```python
+from evolveml import AutoFeatureSelector
+selector = AutoFeatureSelector(top_k=5)
+X_best = selector.fit_transform(X_train, y_train)
+selector.report()
+```
+
+### 🚨 Anomaly Detection (IoT/Edge)
+```python
+from evolveml import AnomalyDetector
+detector = AnomalyDetector(threshold=2.5)
+detector.fit(normal_data)
+result = detector.detect(new_sensor_reading)
+print(result)  # {'is_anomaly': True, 'status': '🚨 ANOMALY'}
+```
+
+### 📉 Concept Drift Detection
+```python
+from evolveml import ConceptDriftDetector
+drift = ConceptDriftDetector()
+for pred, actual in prediction_stream:
+    status = drift.update(pred, actual)
+    if status['drift_detected']:
+        print("⚠️ Retrain your model!")
+```
+
+### 🔍 Explainable AI
+```python
+from evolveml import ExplainableModel, DecisionTreeClassifier
+model = DecisionTreeClassifier()
+model.fit(X_train, y_train)
+xai = ExplainableModel(model, feature_names=['age', 'amount', 'hour'])
+xai.fit(X_train, y_train)
+xai.explain(X_test[0])
+```
+
+### 🎮 Reinforcement Learning Agent
+```python
+from evolveml import ReinforcementAgent
+agent = ReinforcementAgent(n_states=100, n_actions=4)
+action = agent.act(state)
+agent.learn(state, action, reward=+1, next_state=next_state)
+```
+
+### 💬 Sentiment Analysis
+```python
+from evolveml import SentimentAnalyzer
+analyzer = SentimentAnalyzer()
+result = analyzer.analyze("This product is absolutely amazing!")
+print(result)  # {'sentiment': 'POSITIVE 😊', 'confidence': 0.87}
+analyzer.learn("brilliant", label='positive')  # teach new words
+```
+
+### 🔁 Transfer Learning
+```python
+from evolveml import TransferLearner, DecisionTreeClassifier
+source = DecisionTreeClassifier()
+source.fit(X_source, y_source)
+transfer = TransferLearner(source)
+transfer.fit(X_target, y_target)  # learns faster with less data!
+```
+
+---
+
+## License
+MIT — Free to use!

evolveml-0.2.0/evolveml/anomaly.py

@@ -0,0 +1,53 @@
+import numpy as np
+
+class AnomalyDetector:
+    """
+    Real-time Anomaly Detection for IoT / Edge AI.
+    Detects unusual patterns in streaming sensor data.
+
+    Usage:
+        from evolveml.anomaly import AnomalyDetector
+        detector = AnomalyDetector(threshold=2.5)
+        detector.fit(normal_data)
+        result = detector.detect(new_sample)
+    """
+    def __init__(self, threshold=2.5):
+        self.threshold = threshold
+        self.mean_ = None
+        self.std_ = None
+        self.history = []
+
+    def fit(self, X):
+        X = np.array(X)
+        self.mean_ = X.mean(axis=0)
+        self.std_ = X.std(axis=0)
+        self.std_[self.std_ == 0] = 1e-10
+        print(f"✅ AnomalyDetector trained on {len(X)} samples")
+        return self
+
+    def _z_score(self, x):
+        return np.abs((np.array(x) - self.mean_) / self.std_).mean()
+
+    def detect(self, x):
+        """Detect if a single sample is anomalous"""
+        score = self._z_score(x)
+        is_anomaly = score > self.threshold
+        self.history.append({'score': score, 'anomaly': is_anomaly})
+        return {
+            'is_anomaly': bool(is_anomaly),
+            'score': float(score),
+            'threshold': self.threshold,
+            'status': '🚨 ANOMALY' if is_anomaly else '✅ NORMAL'
+        }
+
+    def detect_batch(self, X):
+        """Detect anomalies in batch"""
+        return [self.detect(x) for x in np.array(X)]
+
+    def update(self, x):
+        """Online update - adapt to new normal patterns"""
+        x = np.array(x)
+        alpha = 0.05  # learning rate for mean/std update
+        self.mean_ = (1 - alpha) * self.mean_ + alpha * x
+        self.std_ = (1 - alpha) * self.std_ + alpha * np.abs(x - self.mean_)
+        self.std_[self.std_ == 0] = 1e-10

evolveml-0.2.0/evolveml/automl.py

@@ -0,0 +1,47 @@
+import numpy as np
+
+class AutoFeatureSelector:
+    """
+    AutoML - Automatically selects the best features from your dataset.
+    No manual feature engineering needed!
+
+    Usage:
+        from evolveml.automl import AutoFeatureSelector
+        selector = AutoFeatureSelector(top_k=10)
+        selector.fit(X_train, y_train)
+        X_selected = selector.transform(X_train)
+    """
+    def __init__(self, top_k=10):
+        self.top_k = top_k
+        self.selected_indices_ = None
+        self.scores_ = None
+
+    def _correlation_score(self, X, y):
+        scores = []
+        for i in range(X.shape[1]):
+            col = X[:, i]
+            if col.std() == 0:
+                scores.append(0.0)
+            else:
+                corr = np.corrcoef(col, y)[0, 1]
+                scores.append(abs(corr) if not np.isnan(corr) else 0.0)
+        return np.array(scores)
+
+    def fit(self, X, y):
+        X, y = np.array(X), np.array(y)
+        self.scores_ = self._correlation_score(X, y)
+        k = min(self.top_k, X.shape[1])
+        self.selected_indices_ = np.argsort(self.scores_)[::-1][:k]
+        print(f"✅ AutoFeatureSelector: Selected top {k} features out of {X.shape[1]}")
+        return self
+
+    def transform(self, X):
+        return np.array(X)[:, self.selected_indices_]
+
+    def fit_transform(self, X, y):
+        return self.fit(X, y).transform(X)
+
+    def report(self):
+        print("\n📊 Feature Importance Scores:")
+        for rank, idx in enumerate(self.selected_indices_):
+            print(f"  Rank {rank+1}: Feature[{idx}] → Score: {self.scores_[idx]:.4f}")

evolveml-0.2.0/evolveml/drift.py

@@ -0,0 +1,63 @@
+import numpy as np
+
+class ConceptDriftDetector:
+    """
+    Detects when data distribution changes over time (Concept Drift).
+    Essential for adaptive/continual learning systems.
+
+    Usage:
+        from evolveml.drift import ConceptDriftDetector
+        detector = ConceptDriftDetector()
+        for prediction, actual in stream:
+            status = detector.update(prediction, actual)
+            if status['drift_detected']:
+                print("⚠️ Drift detected! Retrain model.")
+    """
+    def __init__(self, window_size=30, warning_threshold=0.1, drift_threshold=0.2):
+        self.window_size = window_size
+        self.warning_threshold = warning_threshold
+        self.drift_threshold = drift_threshold
+        self.errors = []
+        self.drift_points = []
+        self.n_samples = 0
+
+    def update(self, predicted, actual):
+        """Feed one prediction and check for drift"""
+        error = int(predicted != actual)
+        self.errors.append(error)
+        self.n_samples += 1
+
+        if len(self.errors) < self.window_size:
+            return {'drift_detected': False, 'warning': False, 'error_rate': None}
+
+        # Sliding window error rate
+        recent = self.errors[-self.window_size:]
+        error_rate = np.mean(recent)
+
+        # Baseline from first window
+        baseline = np.mean(self.errors[:self.window_size])
+        change = abs(error_rate - baseline)
+
+        drift = change > self.drift_threshold
+        warning = change > self.warning_threshold
+
+        if drift:
+            self.drift_points.append(self.n_samples)
+
+        return {
+            'drift_detected': bool(drift),
+            'warning': bool(warning),
+            'error_rate': float(error_rate),
+            'baseline_error': float(baseline),
+            'change': float(change),
+            'status': '🚨 DRIFT!' if drift else ('⚠️ WARNING' if warning else '✅ STABLE')
+        }
+
+    def reset(self):
+        """Reset after model retraining"""
+        self.errors = []
+        print("🔄 Drift detector reset after retraining")
+
+    @property
+    def n_drifts(self):
+        return len(self.drift_points)

evolveml-0.2.0/evolveml/explain.py

@@ -0,0 +1,75 @@
+import numpy as np
+
+class ExplainableModel:
+    """
+    Explainable AI (XAI) - Shows WHY your model made a prediction.
+    Wraps any evolveml model and adds explanations.
+
+    Usage:
+        from evolveml.explain import ExplainableModel
+        from evolveml import DecisionTreeClassifier
+
+        base_model = DecisionTreeClassifier()
+        base_model.fit(X_train, y_train)
+
+        xai = ExplainableModel(base_model, feature_names=['age', 'amount', 'hour'])
+        xai.fit(X_train, y_train)
+        explanation = xai.explain(X_test[0])
+        print(explanation)
+    """
+    def __init__(self, model, feature_names=None):
+        self.model = model
+        self.feature_names = feature_names
+        self.X_train = None
+        self.y_train = None
+
+    def fit(self, X, y):
+        self.X_train = np.array(X)
+        self.y_train = np.array(y)
+        if not hasattr(self.model, 'weights') and not hasattr(self.model, 'root'):
+            self.model.fit(X, y)
+        return self
+
+    def _feature_importance(self, x):
+        """Estimate feature importance using perturbation"""
+        x = np.array(x).flatten()
+        base_pred = self.model.predict(x.reshape(1, -1))[0]
+        importances = []
+        for i in range(len(x)):
+            x_perturbed = x.copy()
+            x_perturbed[i] = self.X_train[:, i].mean() if self.X_train is not None else 0
+            perturbed_pred = self.model.predict(x_perturbed.reshape(1, -1))[0]
+            importances.append(abs(float(base_pred) - float(perturbed_pred)))
+        return np.array(importances)
+
+    def explain(self, x):
+        """Explain a single prediction"""
+        x = np.array(x).flatten()
+        prediction = self.model.predict(x.reshape(1, -1))[0]
+        importances = self._feature_importance(x)
+        total = importances.sum() + 1e-10
+        names = self.feature_names or [f'Feature[{i}]' for i in range(len(x))]
+
+        ranked = sorted(zip(names, importances, x),
+                        key=lambda t: t[1], reverse=True)
+
+        explanation = {
+            'prediction': int(prediction),
+            'top_reasons': [
+                {
+                    'feature': name,
+                    'value': float(val),
+                    'importance': float(imp),
+                    'contribution': f"{imp/total*100:.1f}%"
+                }
+                for name, imp, val in ranked[:5]
+            ]
+        }
+
+        print(f"\n🔍 EXPLANATION")
+        print(f"  Prediction : {prediction}")
+        print(f"  Top Reasons:")
+        for r in explanation['top_reasons']:
+            print(f"    → {r['feature']} = {r['value']:.3f}  |  Impact: {r['contribution']}")
+
+        return explanation

evolveml-0.2.0/evolveml/init.py

@@ -0,0 +1,26 @@
+"""
+evolveml - A Python library that evolves with your data.
+Supports Batch + Real-time Online Learning + Latest 2026 ML Trends.
+Author: SAPPA VAMSI
+"""
+
+from .models.decision_tree import DecisionTreeClassifier
+from .models.linear import LinearRegressionModel, LogisticRegressionModel
+from .models.neural_net import NeuralNetwork
+from .stream_learner import StreamLearner
+from .tasks.fraud_detection import FraudDetector
+from .tasks.image_classifier import ImageClassifier
+from .tasks.spam_detector import SpamDetector
+from .tasks.stock_predictor import StockPredictor
+from .automl import AutoFeatureSelector
+from .anomaly import AnomalyDetector
+from .drift import ConceptDriftDetector
+from .explain import ExplainableModel
+from .rl import ReinforcementAgent
+from .nlp import SentimentAnalyzer
+from .transfer import TransferLearner
+from .metrics import accuracy, mse, rmse, f1_score
+from .utils import normalize, train_test_split
+
+__version__ = "0.26.0"
+__author__ = "SAPPA VAMSI"

evolveml-0.2.0/evolveml/metrics.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+def accuracy(y_true, y_pred):
+    """Accuracy score"""
+    return float(np.mean(np.array(y_true) == np.array(y_pred)))
+
+def mse(y_true, y_pred):
+    """Mean Squared Error"""
+    return float(np.mean((np.array(y_true) - np.array(y_pred)) ** 2))
+
+def rmse(y_true, y_pred):
+    """Root Mean Squared Error"""
+    return float(np.sqrt(mse(y_true, y_pred)))
+
+def f1_score(y_true, y_pred):
+    """F1 Score for binary classification"""
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    tp = np.sum((y_pred == 1) & (y_true == 1))
+    fp = np.sum((y_pred == 1) & (y_true == 0))
+    fn = np.sum((y_pred == 0) & (y_true == 1))
+    precision = tp / (tp + fp + 1e-10)
+    recall = tp / (tp + fn + 1e-10)
+    return float(2 * precision * recall / (precision + recall + 1e-10))

evolveml-0.2.0/evolveml/models/decision_tree.py

@@ -0,0 +1,82 @@
+import numpy as np
+
+class DecisionNode:
+    def __init__(self, feature=None, threshold=None, left=None, right=None, value=None):
+        self.feature = feature
+        self.threshold = threshold
+        self.left = left
+        self.right = right
+        self.value = value
+
+class DecisionTreeClassifier:
+    """
+    Decision Tree Classifier - Batch Learning
+    
+    Usage:
+        from evolveml import DecisionTreeClassifier
+        model = DecisionTreeClassifier(max_depth=10)
+        model.fit(X_train, y_train)
+        predictions = model.predict(X_test)
+        print(model.score(X_test, y_test))
+    """
+    def __init__(self, max_depth=10, min_samples_split=2):
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.root = None
+
+    def fit(self, X, y):
+        X, y = np.array(X), np.array(y)
+        self.classes_ = np.unique(y)
+        self.root = self._build_tree(X, y, depth=0)
+        return self
+
+    def _build_tree(self, X, y, depth):
+        n_samples, n_features = X.shape
+        if (depth >= self.max_depth or n_samples < self.min_samples_split or len(np.unique(y)) == 1):
+            return DecisionNode(value=self._most_common(y))
+        best_feature, best_threshold = self._best_split(X, y, n_features)
+        if best_feature is None:
+            return DecisionNode(value=self._most_common(y))
+        left_idx = X[:, best_feature] <= best_threshold
+        left = self._build_tree(X[left_idx], y[left_idx], depth + 1)
+        right = self._build_tree(X[~left_idx], y[~left_idx], depth + 1)
+        return DecisionNode(feature=best_feature, threshold=best_threshold, left=left, right=right)
+
+    def _best_split(self, X, y, n_features):
+        best_gain, best_feature, best_threshold = -1, None, None
+        features = np.random.choice(n_features, min(n_features, 20), replace=False)
+        for feature in features:
+            for threshold in np.unique(X[:, feature])[:10]:
+                gain = self._info_gain(y, X[:, feature], threshold)
+                if gain > best_gain:
+                    best_gain, best_feature, best_threshold = gain, feature, threshold
+        return best_feature, best_threshold
+
+    def _info_gain(self, y, col, threshold):
+        parent = self._entropy(y)
+        left, right = y[col <= threshold], y[col > threshold]
+        if len(left) == 0 or len(right) == 0:
+            return 0
+        n = len(y)
+        return parent - (len(left)/n * self._entropy(left) + len(right)/n * self._entropy(right))
+
+    def _entropy(self, y):
+        counts = np.bincount(y.astype(int))
+        probs = counts[counts > 0] / len(y)
+        return -np.sum(probs * np.log2(probs))
+
+    def _most_common(self, y):
+        return np.bincount(y.astype(int)).argmax()
+
+    def predict(self, X):
+        return np.array([self._traverse(x, self.root) for x in np.array(X)])
+
+    def _traverse(self, x, node):
+        if node.value is not None:
+            return node.value
+        if x[node.feature] <= node.threshold:
+            return self._traverse(x, node.left)
+        return self._traverse(x, node.right)
+
+    def score(self, X, y):
+        return float(np.mean(self.predict(X) == np.array(y)))