retof 0.1.0__py3-none-any.whl

retof/__init__.py

@@ -0,0 +1,57 @@
+from .data import (
+    DataAnalyzer,
+    DataPreprocessor,
+    DataVisualizer,
+)
+
+from .models import (
+    ModelTrain,
+    ModelEvaluator,
+    HyperparameterTuner,
+    ModelManager,
+)
+
+from .meta import (
+    MetaLearner,
+    MetadatasetBuilder,
+)
+
+from .experiments import (
+    ExperimentRunner,
+)
+
+from .automl import (
+    AutoML,
+)
+
+def fit(file_path, target_column=None, target=None, tune=True):
+    if target_column is None:
+        target_column = target
+
+    if target_column is None:
+        raise ValueError(
+            "Must provide target_column or target"
+        )
+
+    return AutoML(
+        tune=tune,
+        use_meta_learning=False
+    ).fit(
+        file_path,
+        target_column
+    )
+
+__all__ = [
+    "DataAnalyzer",
+    "DataPreprocessor",
+    "ModelTrain",
+    "ModelEvaluator",
+    "HyperparameterTuner",
+    "ModelManager",
+    "MetaLearner",
+    "MetadatasetBuilder",
+    "ExperimentRunner",
+    "AutoML",
+    "fit",
+    "DataVisalizer",
+]

retof/automl/AutoML.py

@@ -0,0 +1,206 @@
+import pandas as pd
+from ..data.DataPreprocessor import DataPreprocessor
+from ..data.DataVisualizer import DataVisualizer
+from ..models.ModelTrain import ModelTrain
+from ..models.ModelEvaluator import ModelEvaluator
+from ..models.HyperparameterTuner import HyperparameterTuner
+from ..experiments.ExperimentRunner import ExperimentRunner
+from ..models.ModelManager import ModelManager
+from ..meta.MetaLearner import MetaLearner
+from ..meta.MetadatasetBuilder import MetadatasetBuilder
+from ..utils.formatter import OutputFormatter
+
+
+class AutoML:
+    def __init__(self, tune=True, use_meta_learning=False):
+        self.tune = tune
+        self.use_meta_learning = use_meta_learning
+        self.model_manager = None
+        self.results = {}
+        self._fitted = False
+        self._preprocessor = None
+        self._trainer = None
+        self._evaluator = None
+        self._experiments = []
+        self.meta_learner = None
+        self.recommender = None
+
+    def fit(self, file_path, target_column):
+        self._preprocessor = DataPreprocessor(file_path, target_column)
+        self._trainer = ModelTrain(self._preprocessor.df)
+        self._evaluator = ModelEvaluator({}, None, None, None)
+
+        runner = ExperimentRunner(
+            self._preprocessor,
+            self._trainer,
+            self._evaluator,
+            hyperparameter_tuner_class=HyperparameterTuner,
+        )
+
+        result = runner.get_results(target_column, tune=self.tune)
+
+        self.model_manager = ModelManager(
+            model=result["best_model"],
+            preprocessor=self._preprocessor,
+            target_encoder=getattr(self._trainer, 'target_encoder', None),
+            feature_names=self._trainer.feature_names,
+            target_column=target_column,
+            problem_type=getattr(self._trainer, 'problem_type', None),
+        )
+        self.results = result
+        self._fitted = True
+
+        if self.use_meta_learning:
+            self._init_meta_learning()
+
+        return self
+
+    def _init_meta_learning(self):
+        self.meta_learner = MetaLearner(self._trainer, self._evaluator)
+
+    def add_dataset(self, file_path, target_column):
+        if not self.use_meta_learning:
+            raise RuntimeError("Meta-learning not enabled.")
+        if not self._fitted:
+            raise RuntimeError("Call fit() first.")
+
+        preprocessor = DataPreprocessor(file_path, target_column)
+        trainer = ModelTrain(preprocessor.df)
+        evaluator = ModelEvaluator({}, None, None, None)
+        runner = ExperimentRunner(
+            preprocessor,
+            trainer,
+            evaluator,
+            hyperparameter_tuner_class=HyperparameterTuner,
+        )
+
+        result = runner.get_results(target_column, tune=False)
+
+        experiment_payload = {
+            "file_path": file_path,
+            "data": result["data"],
+            "target_column": target_column,
+            "models": runner.model_train.models,
+            "best_model_name": result["best_model_name"],
+            "best_model": result["best_model"],
+            "best_params": result.get("best_params"),
+            "evaluation_results": result["evaluation_results"],
+        }
+        self._experiments.append(experiment_payload)
+        return experiment_payload
+
+    def build_meta_dataset(self):
+        if not self.use_meta_learning or self.meta_learner is None:
+            raise RuntimeError("Meta-learning not enabled.")
+        meta_dataset = self.meta_learner.build_meta_dataset(self._experiments)
+        if len(meta_dataset) >= 2:
+            try:
+                self.recommender = self.meta_learner.train_recommender(meta_dataset)
+            except Exception:
+                pass
+        return meta_dataset
+
+    def predict(self, data):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        return self.model_manager.predict(data)
+
+    def predict_proba(self, data):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        return self.model_manager.predict_proba(data)
+
+    def save(self, file_path):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        self.model_manager.save_model(file_path)
+
+    @staticmethod
+    def load(file_path):
+        return ModelManager.load_model(file_path)
+
+    def results(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        return self.results
+
+    def get_model_info(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        return self.model_manager.get_model_info()
+
+    def print_results(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        OutputFormatter.print_results(
+            self.results.get("evaluation_results", {})
+        )
+
+    def print_full(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        dataset_info = {
+            "rows": len(self.results["data"]),
+            "features": len(self.results["data"].columns),
+            "problem_type": getattr(self._trainer, "problem_type", "N/A"),
+            "target": self.results.get("target_column", "N/A"),
+        }
+        best_model_name = self.results.get("best_model_name", "N/A")
+        evaluation_results = self.results.get("evaluation_results", {})
+        best_model_metrics = evaluation_results.get(best_model_name, {})
+        OutputFormatter.format_full(
+            evaluation_results,
+            dataset_info,
+            best_model_name,
+            best_model_metrics,
+        )
+
+    def print_meta_dataset(self, records=None):
+        if not self.use_meta_learning:
+            raise RuntimeError("Meta-learning not enabled.")
+        if records is None:
+            records = self._experiments
+        OutputFormatter.print_meta_dataset(records)
+
+    def plot_data(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        visualizer = DataVisualizer(self._preprocessor.df, self._preprocessor.target_column)
+        visualizer.plot_missing_values()
+        visualizer.plot_target_distribution()
+        visualizer.plot_numeric_distributions()
+        visualizer.plot_categorical_distributions()
+        visualizer.plot_correlation_matrix()
+        visualizer.plot_feature_target_relationship()
+        visualizer.plot_outliers()
+
+    def plot_target(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        visualizer = DataVisualizer(self._preprocessor.df, self._preprocessor.target_column)
+        visualizer.plot_target_distribution()
+
+    def plot_correlation(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        visualizer = DataVisualizer(self._preprocessor.df, self._preprocessor.target_column)
+        visualizer.plot_correlation_matrix()
+
+    def plot_models(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        evaluation_results = self.results.get("evaluation_results", {})
+        visualizer = DataVisualizer(self._preprocessor.df, self._preprocessor.target_column)
+        visualizer.plot_model_comparison(evaluation_results)
+
+    def plot_feature_importance(self):
+        if not self._fitted:
+            raise RuntimeError("Model not trained. Call fit() first.")
+        best_model_name = self.results.get("best_model_name")
+        best_model = self.results.get("best_model")
+        if not best_model_name or best_model is None:
+            print("No best model available.")
+            return
+        feature_names = getattr(self._trainer, 'feature_names', None)
+        visualizer = DataVisualizer(self._preprocessor.df, self._preprocessor.target_column)
+        visualizer.plot_feature_importance(best_model, feature_names=feature_names)

retof/automl/__init__.py

@@ -0,0 +1,5 @@
+from .AutoML import AutoML
+
+__all__ = [
+    "AutoML",
+]

retof/data/DataPreprocessor.py

@@ -0,0 +1,144 @@
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import OrdinalEncoder
+
+
+class DataPreprocessor:
+    def __init__(self, file_path, target_column):
+        self.data_path = file_path
+        self.target_column = target_column
+        self.df = pd.read_csv(file_path)
+        self.X = None
+        self.y = None
+        self.scaler = None
+        self.target_encoder = None
+        self.categorical_columns = []
+        self.numeric_columns = []
+        self.feature_preprocessor = None
+        self.feature_names = []
+
+    def separate_features_target(self):
+        if self.target_column not in self.df.columns:
+            raise ValueError(f"Target column '{self.target_column}' not found.")
+        self.X = self.df.drop(columns=[self.target_column]).copy()
+        self.y = self.df[self.target_column].copy()
+
+    def _get_feature_types(self):
+        if self.X is None:
+            self.separate_features_target()
+        self.numeric_columns = self.X.select_dtypes(include=['float64', 'int64']).columns.tolist()
+        self.categorical_columns = self.X.select_dtypes(include=['object', 'category']).columns.tolist()
+
+    def remove_constant_columns(self):
+        if self.X is None:
+            self.separate_features_target()
+        constant_columns = [col for col in self.X.columns if self.X[col].nunique() <= 1]
+        self.X = self.X.drop(columns=constant_columns)
+        self._get_feature_types()
+        return self.X
+
+    def remove_duplicates(self):
+        if self.X is None:
+            self.separate_features_target()
+        mask = self.X.duplicated()
+        self.X = self.X[~mask].copy()
+        self.y = self.y[~mask].copy().reset_index(drop=True)
+        return self.X
+
+    def handle_missing_values(self, strategy='fill'):
+        if self.X is None:
+            self.separate_features_target()
+        if strategy == 'drop':
+            mask = self.X.isnull().any(axis=1)
+            self.X = self.X[~mask].copy()
+            self.y = self.y[~mask].copy().reset_index(drop=True)
+        elif strategy == 'fill':
+            for col in self.numeric_columns:
+                if col in self.X.columns:
+                    self.X[col] = self.X[col].fillna(self.X[col].median())
+            for col in self.categorical_columns:
+                if col in self.X.columns:
+                    mode_val = self.X[col].mode()
+                    if not mode_val.empty:
+                        self.X[col] = self.X[col].fillna(mode_val.iloc[0])
+        return self.X
+
+    def encode_target(self):
+        if self.y is None:
+            self.separate_features_target()
+        if self.y.dtype == 'object' or self.y.dtype.name == 'category':
+            self.target_encoder = LabelEncoder()
+            self.y = pd.Series(
+                self.target_encoder.fit_transform(self.y),
+                index=self.y.index,
+                name=self.y.name
+            )
+        return self.y
+
+    def get_processed_data(self):
+        if self.X is None:
+            self.separate_features_target()
+        return self.X, self.y
+
+    def process(self):
+        self.separate_features_target()
+        self._get_feature_types()
+        self.remove_constant_columns()
+        self.remove_duplicates()
+        self.handle_missing_values(strategy='fill')
+        self.encode_target()
+
+        num_cols = [c for c in self.numeric_columns if c in self.X.columns]
+        cat_cols = [c for c in self.categorical_columns if c in self.X.columns]
+
+        numeric_transformer = StandardScaler()
+        categorical_transformer = OrdinalEncoder(
+            handle_unknown='use_encoded_value',
+            unknown_value=-1
+        )
+
+        self.feature_preprocessor = ColumnTransformer(
+            transformers=[
+                ('num', numeric_transformer, num_cols),
+                ('cat', categorical_transformer, cat_cols),
+            ],
+            remainder='drop'
+        )
+
+        self.feature_preprocessor.fit(self.X)
+
+        X_transformed = self.feature_preprocessor.transform(self.X)
+        raw_names = self.feature_preprocessor.get_feature_names_out()
+        feature_names = [name.split('__', 1)[-1] for name in raw_names]
+
+        processed_df = pd.DataFrame(X_transformed, columns=feature_names, index=self.X.index)
+        processed_df[self.target_column] = self.y.values
+        self.df = processed_df.reset_index(drop=True)
+
+        self.X = processed_df.drop(columns=[self.target_column])
+        self.feature_names = list(self.X.columns)
+
+        return self.df
+
+    def transform(self, X):
+        if self.feature_preprocessor is None:
+            raise RuntimeError("Preprocessor not fitted. Call process() first.")
+        X_transformed = self.feature_preprocessor.transform(X)
+        raw_names = self.feature_preprocessor.get_feature_names_out()
+        feature_names = [name.split('__', 1)[-1] for name in raw_names]
+        return pd.DataFrame(X_transformed, columns=feature_names, index=X.index)
+
+    def load_dataset(self, data_path, target_column):
+        self.data_path = data_path
+        self.target_column = target_column
+        self.df = pd.read_csv(data_path)
+        self.X = None
+        self.y = None
+        self.scaler = None
+        self.target_encoder = None
+        self.categorical_columns = []
+        self.numeric_columns = []
+        self.feature_preprocessor = None
+        self.feature_names = []

retof/data/DataVisualizer.py

@@ -0,0 +1,261 @@
+# src/retof/data/DataVisualizer.py
+import pandas as pd
+import numpy as np
+
+
+class DataVisualizer:
+    def __init__(self, df, target_column=None):
+        self.df = df
+        self.target_column = target_column
+
+    def _get_plt(self):
+        try:
+            import matplotlib.pyplot as plt
+            return plt
+        except ImportError:
+            raise ImportError("matplotlib is required. Install with: pip install matplotlib")
+
+    def _get_sns(self):
+        try:
+            import seaborn as sns
+            return sns
+        except ImportError:
+            raise ImportError("seaborn is required. Install with: pip install seaborn")
+
+    def plot_missing_values(self, figsize=(10, 6)):
+        plt = self._get_plt()
+        missing = self.df.isnull().sum()
+        missing = missing[missing > 0].sort_values(ascending=True)
+        if missing.empty:
+            print("No missing values found.")
+            return
+        fig, ax = plt.subplots(figsize=figsize)
+        ax.barh(missing.index, missing.values, color='steelblue')
+        ax.set_xlabel('Missing Values Count')
+        ax.set_title('Missing Values per Column')
+        ax.grid(axis='x', alpha=0.3)
+        plt.tight_layout()
+        plt.show()
+
+    def plot_target_distribution(self, figsize=(10, 6)):
+        if self.target_column is None or self.target_column not in self.df.columns:
+            print("Target column not specified.")
+            return
+        plt = self._get_plt()
+        target = self.df[self.target_column].dropna()
+        fig, ax = plt.subplots(figsize=figsize)
+        if pd.api.types.is_numeric_dtype(target) and target.nunique() > 20:
+            ax.hist(target, bins=30, color='steelblue', edgecolor='black', alpha=0.7)
+            ax.set_xlabel(self.target_column)
+            ax.set_ylabel('Frequency')
+        else:
+            target.value_counts().plot(kind='bar', ax=ax, color='steelblue')
+            ax.set_xlabel(self.target_column)
+            ax.set_ylabel('Count')
+        ax.set_title(f'Target Distribution: {self.target_column}')
+        ax.grid(axis='y', alpha=0.3)
+        plt.tight_layout()
+        plt.show()
+
+    def plot_numeric_distributions(self, figsize=(16, 10)):
+        plt = self._get_plt()
+        numeric_cols = self.df.select_dtypes(include=['float64', 'int64']).columns
+        if self.target_column in numeric_cols:
+            numeric_cols = numeric_cols.drop(self.target_column)
+        if len(numeric_cols) == 0:
+            print("No numeric columns.")
+            return
+        n_cols = min(4, len(numeric_cols))
+        n_rows = (len(numeric_cols) + n_cols - 1) // n_cols
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=figsize)
+        axes = axes.flatten() if len(numeric_cols) > 1 else [axes]
+        for idx, col in enumerate(numeric_cols):
+            self.df[col].hist(bins=30, ax=axes[idx], color='steelblue', edgecolor='black', alpha=0.7)
+            axes[idx].set_title(f'Distribution of {col}')
+            axes[idx].set_xlabel(col)
+            axes[idx].set_ylabel('Frequency')
+            axes[idx].grid(axis='y', alpha=0.3)
+        for idx in range(len(numeric_cols), len(axes)):
+            fig.delaxes(axes[idx])
+        plt.tight_layout()
+        plt.show()
+
+    def plot_categorical_distributions(self, figsize=(16, 10)):
+        plt = self._get_plt()
+        cat_cols = self.df.select_dtypes(include=['object', 'category']).columns
+        if self.target_column in cat_cols:
+            cat_cols = cat_cols.drop(self.target_column)
+        if len(cat_cols) == 0:
+            print("No categorical columns.")
+            return
+        n_cols = min(4, len(cat_cols))
+        n_rows = (len(cat_cols) + n_cols - 1) // n_cols
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=figsize)
+        axes = axes.flatten() if len(cat_cols) > 1 else [axes]
+        for idx, col in enumerate(cat_cols):
+            self.df[col].value_counts().plot(kind='bar', ax=axes[idx], color='steelblue')
+            axes[idx].set_title(f'Distribution of {col}')
+            axes[idx].set_xlabel(col)
+            axes[idx].set_ylabel('Count')
+            axes[idx].grid(axis='y', alpha=0.3)
+        for idx in range(len(cat_cols), len(axes)):
+            fig.delaxes(axes[idx])
+        plt.tight_layout()
+        plt.show()
+
+    def plot_correlation_matrix(self, figsize=(12, 10)):
+        plt = self._get_plt()
+        sns = self._get_sns()
+        numeric_df = self.df.select_dtypes(include=['float64', 'int64'])
+        if self.target_column in numeric_df.columns:
+            numeric_df = numeric_df.drop(columns=[self.target_column])
+        if numeric_df.shape[1] < 2:
+            print("Not enough numeric features for correlation matrix.")
+            return
+        corr = numeric_df.corr()
+        fig, ax = plt.subplots(figsize=figsize)
+        sns.heatmap(corr, annot=True, fmt='.2f', cmap='coolwarm', center=0, ax=ax)
+        ax.set_title('Correlation Matrix')
+        plt.tight_layout()
+        plt.show()
+
+    def plot_feature_target_relationship(self, figsize=(16, 10)):
+        plt = self._get_plt()
+        if self.target_column is None or self.target_column not in self.df.columns:
+            print("Target column not specified.")
+            return
+        numeric_cols = self.df.select_dtypes(include=['float64', 'int64']).columns
+        numeric_cols = numeric_cols.drop(self.target_column, errors='ignore')
+        if len(numeric_cols) == 0:
+            print("No numeric features for relationship plot.")
+            return
+        n_cols = min(4, len(numeric_cols))
+        n_rows = (len(numeric_cols) + n_cols - 1) // n_cols
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=figsize)
+        axes = axes.flatten() if len(numeric_cols) > 1 else [axes]
+        for idx, col in enumerate(numeric_cols):
+            axes[idx].scatter(self.df[col], self.df[self.target_column], alpha=0.5, color='steelblue')
+            axes[idx].set_xlabel(col)
+            axes[idx].set_ylabel(self.target_column)
+            axes[idx].set_title(f'{col} vs {self.target_column}')
+            axes[idx].grid(alpha=0.3)
+        for idx in range(len(numeric_cols), len(axes)):
+            fig.delaxes(axes[idx])
+        plt.tight_layout()
+        plt.show()
+
+    def plot_outliers(self, figsize=(16, 10)):
+        plt = self._get_plt()
+        numeric_cols = self.df.select_dtypes(include=['float64', 'int64']).columns
+        if self.target_column in numeric_cols:
+            numeric_cols = numeric_cols.drop(self.target_column)
+        if len(numeric_cols) == 0:
+            print("No numeric columns for outlier detection.")
+            return
+        n_cols = min(4, len(numeric_cols))
+        n_rows = (len(numeric_cols) + n_cols - 1) // n_cols
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=figsize)
+        axes = axes.flatten() if len(numeric_cols) > 1 else [axes]
+        for idx, col in enumerate(numeric_cols):
+            axes[idx].boxplot(self.df[col].dropna(), vert=True, patch_artist=True,
+                              boxprops=dict(facecolor='steelblue', alpha=0.7))
+            axes[idx].set_title(f'Outliers in {col}')
+            axes[idx].set_ylabel(col)
+            axes[idx].grid(axis='y', alpha=0.3)
+        for idx in range(len(numeric_cols), len(axes)):
+            fig.delaxes(axes[idx])
+        plt.tight_layout()
+        plt.show()
+
+    def plot_model_comparison(self, results):
+        plt = self._get_plt()
+        if not results:
+            print("No results to plot.")
+            return
+
+        valid_results = {k: v for k, v in results.items() if isinstance(v, dict) and 'error' not in v}
+        if not valid_results:
+            print("No valid model results to plot.")
+            return
+
+        first_metrics = next(iter(valid_results.values()))
+        is_classification = 'accuracy' in first_metrics
+
+        models = list(valid_results.keys())
+
+        if is_classification:
+            accuracies = [valid_results[m].get('accuracy', 0) for m in models]
+            f1_scores = [valid_results[m].get('f1_macro', 0) for m in models]
+            x = range(len(models))
+            fig, ax = plt.subplots(figsize=(12, 6))
+            width = 0.35
+            ax.bar([i - width/2 for i in x], accuracies, width, label='Accuracy', color='steelblue')
+            ax.bar([i + width/2 for i in x], f1_scores, width, label='F1 Macro', color='darkorange')
+            ax.set_ylabel('Score')
+            ax.set_title('Model Comparison')
+            ax.set_xticks(x)
+            ax.set_xticklabels(models, rotation=45, ha='right')
+            ax.set_ylim(0, 1.1)
+            ax.legend()
+            ax.grid(axis='y', alpha=0.3)
+            plt.tight_layout()
+            plt.show()
+        else:
+            r2_scores = [valid_results[m].get('r2', 0) for m in models]
+            rmse_scores = [valid_results[m].get('rmse', 0) for m in models]
+            x = range(len(models))
+            fig, ax = plt.subplots(figsize=(12, 6))
+            ax.bar(x, r2_scores, color='steelblue', label='R²')
+            ax.set_ylabel('R² Score')
+            ax.set_title('Model Comparison (R²)')
+            ax.set_xticks(x)
+            ax.set_xticklabels(models, rotation=45, ha='right')
+            ax.set_ylim(0, 1.1)
+            ax.grid(axis='y', alpha=0.3)
+            plt.tight_layout()
+            plt.show()
+
+    def plot_feature_importance(self, model, feature_names=None):
+        plt = self._get_plt()
+        if feature_names is None:
+            feature_names = self.df.drop(columns=[self.target_column]).columns if self.target_column in self.df.columns else self.df.columns
+
+        if hasattr(model, 'feature_importances_'):
+            importances = model.feature_importances_
+        elif hasattr(model, 'coef_'):
+            coef = model.coef_
+            if coef.ndim == 2:
+                importances = np.mean(np.abs(coef), axis=0)
+            else:
+                importances = np.abs(coef)
+        else:
+            print("Model does not support feature importance.")
+            return
+
+        indices = importances.argsort()[::-1]
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.bar(range(len(importances)), importances[indices], color='steelblue')
+        ax.set_xticks(range(len(importances)))
+        ax.set_xticklabels([feature_names[i] for i in indices], rotation=45, ha='right')
+        ax.set_ylabel('Importance')
+        ax.set_title('Feature Importance')
+        ax.grid(axis='y', alpha=0.3)
+        plt.tight_layout()
+        plt.show()
+
+    def generate_report(self):
+        print("=== Dataset Summary ===")
+        print(f"Shape: {self.df.shape}")
+        print(f"Columns: {list(self.df.columns)}")
+        print(f"Missing values: {int(self.df.isnull().sum().sum())}")
+        print(f"Duplicate rows: {int(self.df.duplicated().sum())}")
+        print(f"Numeric features: {len(self.df.select_dtypes(include=['float64', 'int64']).columns)}")
+        print(f"Categorical features: {len(self.df.select_dtypes(include=['object', 'category']).columns)}")
+        if self.target_column and self.target_column in self.df.columns:
+            target = self.df[self.target_column]
+            print(f"Target column: {self.target_column}")
+            print(f"Target unique values: {target.nunique()}")
+            if pd.api.types.is_object_dtype(target) or target.nunique() <= 20:
+                print(f"Target distribution:\n{target.value_counts()}")
+            else:
+                print(f"Target stats:\n{target.describe()}")

retof/data/__init__.py

@@ -0,0 +1,9 @@
+from .ejik import DataAnalyzer
+from .DataPreprocessor import DataPreprocessor
+from .DataVisualizer import DataVisualizer
+
+__all__ = [
+    "DataAnalyzer",
+    "DataPreprocessor",
+    "DataVisualizer",
+]