autocure 0.2.0__tar.gz

autocure-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vishal More
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights  
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+copies of the Software, and to permit persons to whom the Software is  
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in  
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
+THE SOFTWARE.

autocure-0.2.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: autocure
+Version: 0.2.0
+Summary: Automated data cleaning and auto ML training with hyperparameter tuning.
+Home-page: https://pypi.org/project/autocure/
+Author: Vishal More
+License: MIT
+Project-URL: Source, https://github.com/YOUR_GITHUB/autocure
+Project-URL: Tracker, https://github.com/YOUR_GITHUB/autocure/issues
+Keywords: data-cleaning,machine-learning,automation,sklearn,pipeline
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: click
+Dynamic: license-file
+Dynamic: requires-dist
+
+# Autocure
+
+Automated data cleaning + AutoML model training with hyperparameter tuning.
+
+## Key features
+
+- Data scan
+  - Missing values summary
+  - Dtype inference
+  - Outlier counts (IQR method)
+  - Duplicate rows count
+
+- Data cleaning (cure)
+  - Numeric imputation (median)
+  - Categorical imputation (mode / fallback "Unknown")
+  - Text preprocessing (applies only to text columns):
+    - remove punctuation
+    - lowercase
+    - tokenize
+    - remove stopwords
+    - lemmatize
+  - Drop duplicates
+
+- Pipeline & AutoML
+  - Automatic ColumnTransformer (StandardScaler for numeric, OneHotEncoder for categorical)
+  - Support for classification and regression
+  - Multiple algorithms with GridSearchCV hyperparameter search
+  - Model leaderboard and best-model selection
+
+- CLI
+  - scan-data, fix, train-model commands for quick workflows
+
+## Installation
+
+From project root (editable install for development):
+
+```bash
+python -m pip install -e .
+```
+
+Or install dependencies:
+
+```bash
+pip install -r requirements.txt
+pip install nltk
+```
+
+NLTK data used by cure() is downloaded at runtime (punkt, stopwords, wordnet).
+
+## Quick usage
+
+Python:
+
+```python
+import autocure as ac
+import pandas as pd
+
+df = pd.read_csv("your_dataset.csv")
+
+# 1) Inspect dataset
+report = ac.scan(df)
+print(report)
+
+# 2) Clean dataset
+clean = ac.cure(df)
+
+# 3) Create pipeline (optional)
+pipeline = ac.make_pipeline(clean, target="target_column")
+
+# 4) Train models (returns a dict)
+result = ac.train(clean, target="target_column")
+
+print(result["best_model_name"])
+print("score:", result["best_score"])
+# Best model object for predict:
+best_model = result["best_model"]
+preds = best_model.predict(clean.drop(columns=["target_column"]).iloc[:5])
+```
+
+Returned keys from train():
+- best_model (fitted sklearn estimator / pipeline)
+- best_model_name
+- best_score
+- best_params
+- leaderboard (list/dict of model results)
+
+## CLI
+
+Examples:
+
+```bash
+# Scan a CSV
+autocure scan-data data.csv
+
+# Clean and save
+autocure fix data.csv --out cleaned.csv
+
+# Train via CLI
+autocure train-model data.csv --target target_column
+```
+
+## Tips & notes
+
+- cure() applies text preprocessing only to columns detected as object/string dtype.
+- For small categorical cardinality detection and problem-type heuristics, train() uses simple rules; override by preparing the DataFrame appropriately.
+- If you use large text datasets, consider vectorization or specialized NLP pipelines before heavy GridSearchCV.
+
+## Contributing
+
+Bug reports and PRs welcome. Follow repository guidelines and add tests for new behavior.
+
+## License
+
+MIT License

autocure-0.2.0/README.md

@@ -0,0 +1,114 @@
+# Autocure
+
+Automated data cleaning + AutoML model training with hyperparameter tuning.
+
+## Key features
+
+- Data scan
+  - Missing values summary
+  - Dtype inference
+  - Outlier counts (IQR method)
+  - Duplicate rows count
+
+- Data cleaning (cure)
+  - Numeric imputation (median)
+  - Categorical imputation (mode / fallback "Unknown")
+  - Text preprocessing (applies only to text columns):
+    - remove punctuation
+    - lowercase
+    - tokenize
+    - remove stopwords
+    - lemmatize
+  - Drop duplicates
+
+- Pipeline & AutoML
+  - Automatic ColumnTransformer (StandardScaler for numeric, OneHotEncoder for categorical)
+  - Support for classification and regression
+  - Multiple algorithms with GridSearchCV hyperparameter search
+  - Model leaderboard and best-model selection
+
+- CLI
+  - scan-data, fix, train-model commands for quick workflows
+
+## Installation
+
+From project root (editable install for development):
+
+```bash
+python -m pip install -e .
+```
+
+Or install dependencies:
+
+```bash
+pip install -r requirements.txt
+pip install nltk
+```
+
+NLTK data used by cure() is downloaded at runtime (punkt, stopwords, wordnet).
+
+## Quick usage
+
+Python:
+
+```python
+import autocure as ac
+import pandas as pd
+
+df = pd.read_csv("your_dataset.csv")
+
+# 1) Inspect dataset
+report = ac.scan(df)
+print(report)
+
+# 2) Clean dataset
+clean = ac.cure(df)
+
+# 3) Create pipeline (optional)
+pipeline = ac.make_pipeline(clean, target="target_column")
+
+# 4) Train models (returns a dict)
+result = ac.train(clean, target="target_column")
+
+print(result["best_model_name"])
+print("score:", result["best_score"])
+# Best model object for predict:
+best_model = result["best_model"]
+preds = best_model.predict(clean.drop(columns=["target_column"]).iloc[:5])
+```
+
+Returned keys from train():
+- best_model (fitted sklearn estimator / pipeline)
+- best_model_name
+- best_score
+- best_params
+- leaderboard (list/dict of model results)
+
+## CLI
+
+Examples:
+
+```bash
+# Scan a CSV
+autocure scan-data data.csv
+
+# Clean and save
+autocure fix data.csv --out cleaned.csv
+
+# Train via CLI
+autocure train-model data.csv --target target_column
+```
+
+## Tips & notes
+
+- cure() applies text preprocessing only to columns detected as object/string dtype.
+- For small categorical cardinality detection and problem-type heuristics, train() uses simple rules; override by preparing the DataFrame appropriately.
+- If you use large text datasets, consider vectorization or specialized NLP pipelines before heavy GridSearchCV.
+
+## Contributing
+
+Bug reports and PRs welcome. Follow repository guidelines and add tests for new behavior.
+
+## License
+
+MIT License

autocure-0.2.0/autocure/__init__.py

@@ -0,0 +1,8 @@
+from .scan import scan
+from .cure import cure
+from .pipeline import make_pipeline
+from .train import train
+
+__all__ = ["scan", "cure", "make_pipeline", "train"]
+__version__ = "0.2.0"
+__author__ = "Vishal More"

autocure-0.2.0/autocure/cli/main.py

@@ -0,0 +1,33 @@
+import click
+import pandas as pd
+from autocure import scan, cure, train
+
+@click.group()
+def cli():
+    pass
+
+@cli.command()
+@click.argument("file")
+def scan_data(file):
+    df = pd.read_csv(file)
+    click.echo(scan(df))
+
+@cli.command()
+@click.argument("file")
+@click.option("--out", default="clean.csv")
+def fix(file, out):
+    df = pd.read_csv(file)
+    clean = cure(df)
+    clean.to_csv(out, index=False)
+    click.echo(f"Cleaned file saved: {out}")
+
+@cli.command()
+@click.argument("file")
+@click.option("--target", required=True)
+def train_model(file, target):
+    df = pd.read_csv(file)
+    result = train(df, target)
+    click.echo(result)
+
+if __name__ == "__main__":
+    cli()

autocure-0.2.0/autocure/cure.py

@@ -0,0 +1,55 @@
+import pandas as pd
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+from nltk.stem import WordNetLemmatizer
+
+# Download required NLTK data
+nltk.download('punkt', quiet=True)
+nltk.download('stopwords', quiet=True)
+nltk.download('wordnet', quiet=True)
+
+def cure(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+
+    # Fill numeric
+    for col in df.select_dtypes(include=["int", "float"]):
+        df[col] = df[col].fillna(df[col].median())
+
+    # Fill categorical
+    for col in df.select_dtypes(include=["object"]):
+        if df[col].isnull().any():
+            mode_vals = df[col].mode()
+            df[col] = df[col].fillna(mode_vals[0] if not mode_vals.empty else "Unknown")
+
+    # Text preprocessing
+    stop_words = set(stopwords.words('english'))
+    lemmatizer = WordNetLemmatizer()
+    
+    for col in df.select_dtypes(include=["object"]):
+        df[col] = df[col].apply(lambda x: _process_text(x, stop_words, lemmatizer) if isinstance(x, str) else x)
+
+    # Drop duplicates
+    df = df.drop_duplicates()
+
+    return df
+
+
+def _process_text(text, stop_words, lemmatizer):
+    # Remove punctuation
+    text = re.sub(r'[^\w\s]', '', text)
+    
+    # Lowercase
+    text = text.lower()
+    
+    # Tokenize
+    tokens = word_tokenize(text)
+    
+    # Remove stopwords
+    tokens = [word for word in tokens if word not in stop_words]
+    
+    # Lemmatize
+    tokens = [lemmatizer.lemmatize(word) for word in tokens]
+    
+    return ' '.join(tokens)

autocure-0.2.0/autocure/pipeline.py

@@ -0,0 +1,22 @@
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.pipeline import Pipeline
+
+def make_pipeline(df, target):
+    features = df.drop(columns=[target])
+
+    numeric = features.select_dtypes(include=["int", "float"]).columns
+    categorical = features.select_dtypes(include=["object"]).columns
+
+    transformer = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), numeric),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), categorical)
+        ]
+    )
+
+    pipeline = Pipeline([
+        ("preprocess", transformer)
+    ])
+
+    return pipeline

autocure-0.2.0/autocure/scan.py

@@ -0,0 +1,24 @@
+import pandas as pd
+
+def scan(df: pd.DataFrame):
+    report = {}
+
+    # Missing values
+    report["missing_values"] = df.isnull().sum().to_dict()
+
+    # Dtypes
+    report["dtypes"] = df.dtypes.astype(str).to_dict()
+
+    # Outliers
+    outliers = {}
+    for col in df.select_dtypes(include=["int", "float"]):
+        q1, q3 = df[col].quantile([0.25, 0.75])
+        iqr = q3 - q1
+        upper, lower = q3 + 1.5 * iqr, q1 - 1.5 * iqr
+        outliers[col] = int(((df[col] < lower) | (df[col] > upper)).sum())
+    report["outliers"] = outliers
+
+    # Duplicates
+    report["duplicate_rows"] = int(df.duplicated().sum())
+
+    return report

autocure-0.2.0/autocure/train.py

@@ -0,0 +1,136 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split, GridSearchCV
+from sklearn.metrics import accuracy_score, r2_score
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from sklearn.pipeline import Pipeline
+
+# ML models
+from sklearn.linear_model import LogisticRegression, LinearRegression
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.svm import SVC, SVR
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from sklearn.naive_bayes import GaussianNB
+
+
+def train(df: pd.DataFrame, target: str):
+    X = df.drop(columns=[target])
+    y = df[target]
+
+    # Determine if classification problem
+    is_classification = y.dtype == "object" or y.nunique() < 20
+
+    # Preprocessing
+    numeric_cols = X.select_dtypes(include=["int", "float"]).columns
+    cat_cols = X.select_dtypes(include=["object"]).columns
+
+    preprocessor = ColumnTransformer(
+        transformers=[
+            ("num", StandardScaler(), numeric_cols),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), cat_cols)
+        ]
+    )
+
+    # Split
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42
+    )
+
+    # ML Algorithms + Params
+    if is_classification:
+        models = {
+            "logistic_regression": (
+                LogisticRegression(max_iter=200),
+                {"clf__C": [0.1, 1, 10]}
+            ),
+            "random_forest_classifier": (
+                RandomForestClassifier(),
+                {"clf__n_estimators": [50, 100],
+                 "clf__max_depth": [5, 10, None]}
+            ),
+            "svm_classifier": (
+                SVC(),
+                {"clf__C": [0.1, 1, 10],
+                 "clf__kernel": ["linear", "rbf"]}
+            ),
+            "decision_tree_classifier": (
+                DecisionTreeClassifier(),
+                {"clf__max_depth": [3, 5, 10, None]}
+            ),
+            "knn_classifier": (
+                KNeighborsClassifier(),
+                {"clf__n_neighbors": [3, 5, 7]}
+            )
+            
+        }
+    else:
+        models = {
+            "linear_regression": (
+                LinearRegression(),
+                {}
+            ),
+            "random_forest_regressor": (
+                RandomForestRegressor(),
+                {"clf__n_estimators": [50, 100],
+                 "clf__max_depth": [5, 10, None]}
+            ),
+            "svm_regressor": (
+                SVR(),
+                {"clf__C": [0.1, 1, 10],
+                 "clf__kernel": ["linear", "rbf"]}
+            ),
+            "decision_tree_regressor": (
+                DecisionTreeRegressor(),
+                {"clf__max_depth": [5, 10, None]}
+            ),
+            "knn_regressor": (
+                KNeighborsRegressor(),
+                {"clf__n_neighbors": [3, 5, 7]}
+            )
+        }
+
+    # Train ALL models
+    results = []
+    best_model, best_params, best_score, best_model_name = None, None, -999, None
+
+    for name, (model, params) in models.items():
+        print(f"Training model: {name}")
+
+        pipeline = Pipeline([
+            ("preprocess", preprocessor),
+            ("clf", model)
+        ])
+
+        grid = GridSearchCV(
+            pipeline,
+            params,
+            cv=3,
+            n_jobs=-1,
+            scoring="accuracy" if is_classification else "r2"
+        )
+
+        grid.fit(X_train, y_train)
+
+        preds = grid.predict(X_test)
+        score = accuracy_score(y_test, preds) if is_classification else r2_score(y_test, preds)
+
+        results.append({
+            "model": name,
+            "best_params": grid.best_params_,
+            "score": score
+        })
+
+        if score > best_score:
+            best_score = score
+            best_model = grid.best_estimator_
+            best_model_name = name
+            best_params = grid.best_params_
+
+    return {
+        "best_model": best_model,
+        "best_model_name": best_model_name,
+        "best_score": best_score,
+        "best_params": best_params,
+        "leaderboard": results
+    }

autocure-0.2.0/autocure.egg-info/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: autocure
+Version: 0.2.0
+Summary: Automated data cleaning and auto ML training with hyperparameter tuning.
+Home-page: https://pypi.org/project/autocure/
+Author: Vishal More
+License: MIT
+Project-URL: Source, https://github.com/YOUR_GITHUB/autocure
+Project-URL: Tracker, https://github.com/YOUR_GITHUB/autocure/issues
+Keywords: data-cleaning,machine-learning,automation,sklearn,pipeline
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: click
+Dynamic: license-file
+Dynamic: requires-dist
+
+# Autocure
+
+Automated data cleaning + AutoML model training with hyperparameter tuning.
+
+## Key features
+
+- Data scan
+  - Missing values summary
+  - Dtype inference
+  - Outlier counts (IQR method)
+  - Duplicate rows count
+
+- Data cleaning (cure)
+  - Numeric imputation (median)
+  - Categorical imputation (mode / fallback "Unknown")
+  - Text preprocessing (applies only to text columns):
+    - remove punctuation
+    - lowercase
+    - tokenize
+    - remove stopwords
+    - lemmatize
+  - Drop duplicates
+
+- Pipeline & AutoML
+  - Automatic ColumnTransformer (StandardScaler for numeric, OneHotEncoder for categorical)
+  - Support for classification and regression
+  - Multiple algorithms with GridSearchCV hyperparameter search
+  - Model leaderboard and best-model selection
+
+- CLI
+  - scan-data, fix, train-model commands for quick workflows
+
+## Installation
+
+From project root (editable install for development):
+
+```bash
+python -m pip install -e .
+```
+
+Or install dependencies:
+
+```bash
+pip install -r requirements.txt
+pip install nltk
+```
+
+NLTK data used by cure() is downloaded at runtime (punkt, stopwords, wordnet).
+
+## Quick usage
+
+Python:
+
+```python
+import autocure as ac
+import pandas as pd
+
+df = pd.read_csv("your_dataset.csv")
+
+# 1) Inspect dataset
+report = ac.scan(df)
+print(report)
+
+# 2) Clean dataset
+clean = ac.cure(df)
+
+# 3) Create pipeline (optional)
+pipeline = ac.make_pipeline(clean, target="target_column")
+
+# 4) Train models (returns a dict)
+result = ac.train(clean, target="target_column")
+
+print(result["best_model_name"])
+print("score:", result["best_score"])
+# Best model object for predict:
+best_model = result["best_model"]
+preds = best_model.predict(clean.drop(columns=["target_column"]).iloc[:5])
+```
+
+Returned keys from train():
+- best_model (fitted sklearn estimator / pipeline)
+- best_model_name
+- best_score
+- best_params
+- leaderboard (list/dict of model results)
+
+## CLI
+
+Examples:
+
+```bash
+# Scan a CSV
+autocure scan-data data.csv
+
+# Clean and save
+autocure fix data.csv --out cleaned.csv
+
+# Train via CLI
+autocure train-model data.csv --target target_column
+```
+
+## Tips & notes
+
+- cure() applies text preprocessing only to columns detected as object/string dtype.
+- For small categorical cardinality detection and problem-type heuristics, train() uses simple rules; override by preparing the DataFrame appropriately.
+- If you use large text datasets, consider vectorization or specialized NLP pipelines before heavy GridSearchCV.
+
+## Contributing
+
+Bug reports and PRs welcome. Follow repository guidelines and add tests for new behavior.
+
+## License
+
+MIT License

autocure-0.2.0/autocure.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+autocure/__init__.py
+autocure/cure.py
+autocure/pipeline.py
+autocure/scan.py
+autocure/train.py
+autocure.egg-info/PKG-INFO
+autocure.egg-info/SOURCES.txt
+autocure.egg-info/dependency_links.txt
+autocure.egg-info/entry_points.txt
+autocure.egg-info/requires.txt
+autocure.egg-info/top_level.txt
+autocure/cli/__init__.py
+autocure/cli/main.py
+test/test.py

autocure-0.2.0/autocure.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

autocure-0.2.0/autocure.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+autocure = autocure.cli.main:cli

autocure-0.2.0/autocure.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pandas
+scikit-learn
+click

autocure-0.2.0/autocure.egg-info/top_level.txt

@@ -0,0 +1 @@
+autocure

autocure-0.2.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"

autocure-0.2.0/setup.cfg

@@ -0,0 +1,34 @@
+[metadata]
+name = autocure
+version = 0.2.0
+author = Vishal More
+description = Automated data cleaning and auto ML training with hyperparameter tuning.
+long_description = file: README.md
+long_description_content_type = text/markdown
+license = MIT
+keywords = data-cleaning, machine-learning, automation, sklearn, pipeline
+url = https://pypi.org/project/autocure/
+project_urls = 
+	Source = https://github.com/YOUR_GITHUB/autocure
+	Tracker = https://github.com/YOUR_GITHUB/autocure/issues
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+
+[options]
+packages = find:
+python_requires = >=3.8
+install_requires = 
+	pandas
+	scikit-learn
+	click
+
+[options.entry_points]
+console_scripts = 
+	autocure=autocure.cli.main:cli
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

autocure-0.2.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="autocure",
+    version="0.2.0",
+    packages=find_packages(),
+    install_requires=[
+        "pandas",
+        "scikit-learn",
+        "click"
+    ],
+    entry_points={
+        "console_scripts": [
+            "autocure=autocure.cli.main:cli"
+        ]
+    }
+)

autocure-0.2.0/test/test.py

@@ -0,0 +1,65 @@
+"""
+Autocure test script using IMDB Sentiment Dataset
+(review, sentiment)
+
+Steps:
+- load dataset from URL
+- scan
+- cure
+- make_pipeline
+- train
+- predict
+"""
+
+from autocure import scan, cure, make_pipeline, train
+import pandas as pd
+
+
+def main():
+
+    print("🎬 Loading IMDB Sentiment Dataset...")
+    url = "https://raw.githubusercontent.com/Ankit152/IMDB-sentiment-analysis/master/IMDB-Dataset.csv"
+    df = pd.read_csv(url)
+
+    print(df.head())
+
+    print("\n📌 Rename columns for consistency...")
+    df["content"] = df["review"]
+    df["label"] = df["sentiment"].map({"positive": 1, "negative": 0})
+    df = df[["content", "label"]]
+
+    print(df.head())
+
+    print("\n📌 Running scan()...")
+    issues = scan(df)
+    print("Issues found:", issues)
+
+    print("\n🧹 Running cure()...")
+    df_clean = cure(df)
+    print("Cleaned data sample:")
+    print(df_clean.head())
+
+    print("\n🔗 Creating pipeline...")
+    pipeline = make_pipeline(df_clean, target="label")
+    print("Pipeline created:")
+    print(pipeline)
+
+    print("\n🤖 Training using train()...")
+    result = train(df_clean, target="label")
+
+    best_model = result["best_model"]
+    best_score = result["best_score"]
+
+    print("\n🎉 Best model:")
+    print(result["best_model_name"])
+    print(f"Best score: {best_score:.4f}")
+    print("Best parameters:", result["best_params"])
+
+    print("\n🔮 Predictions on sample data:")
+    sample_data = df_clean.drop("label", axis=1).iloc[:5]
+    preds = best_model.predict(sample_data)
+    print(preds)
+
+
+if __name__ == "__main__":
+    main()