Completed
Iris Flower Classification Pipeline - Week of 19 Oct 2026
This challenge has ended. You can still review the details below.
Explore the latest challenge for this roleBuild an end-to-end machine learning pipeline in Python to classify iris flowers using the Iris dataset. Your solution will demonstrate data cleaning, exploratory analysis, feature engineering, model training, and evaluation—with version control and SQL integration for data retrieval.
Data Scientist
Solo only.
Share this challenge

The Challenge Brief
Problem definition
Input data (download): https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv
The Iris dataset contains 150 flower measurements across four numeric features (sepal_length, sepal_width, petal_length, petal_width) and a categorical target (species: setosa, versicolor, virginica). You will build a supervised classification system that ingests raw CSV data, cleans and explores it, engineers predictive features, trains a machine learning model, and evaluates performance using standard metrics. The pipeline must be reproducible, version-controlled, and include a SQL query to retrieve a subset of the data. Every line under Success criteria is in scope for this challenge. Build the core scope in Task brief. Topic coverage uses repository evidence where available and the comprehension conversation; it does not require a separate feature for every topic.
Task brief
You will implement a complete machine learning workflow covering Version Control, SQL, Python Programming, Pandas, Data Cleaning & Preprocessing, Exploratory Data Analysis, Statistical Fundamentals, Data Visualization, Feature Engineering, Machine Learning, and Model Evaluation. Clone the system-created private repository, load the Iris CSV, write a SQL query to filter records by species, clean and preprocess the data (handle missing values, normalize features), perform exploratory analysis with summary statistics and visualizations, engineer at least two new features, train a classification model (e.g., logistic regression or random forest), evaluate using accuracy, precision, recall, and F1-score, and commit all code with clear messages. Expected effort: 6–8 hours with AI assistance.
Version Control
Version Control is the practice of tracking and managing changes to code over time using Git. In this project, you will initialize a Git repository for the iris classification pipeline, commit your data loading, cleaning, feature engineering, model training, and evaluation code at logical checkpoints, create feature branches for experimental work, and merge changes back to the main branch. This ensures your pipeline is reproducible, your team can review changes, and you can recover previous versions if needed.
SQL
SQL is used in this project to retrieve and filter iris flower measurements from a database or CSV-backed data store. You will write SELECT queries with WHERE clauses to extract subsets of the 150 records, use JOINs to combine species metadata if available, and apply GROUP BY with aggregation functions to summarize measurements by species. These queries support data exploration and validation within the reproducible classification pipeline.
Python Programming
Build a reproducible Python classification pipeline for the Iris dataset that ingests CSV data, performs exploratory analysis, engineers features, trains a machine learning model, and evaluates performance. Python Programming is the core implementation language; your code must be organized into reusable functions and classes, include type hints, run in a virtual environment with declared dependencies, and be version-controlled in a repository for team review and extension.
Pandas
Use Pandas to load the Iris CSV, clean and explore the data, and prepare it for classification. You will apply groupby operations to summarize measurements by species and merge or join data subsets to construct your feature matrix. Pandas is central to the data ingestion and transformation pipeline that feeds your machine learning model.
Data Cleaning & Preprocessing
Implement Data Cleaning & Preprocessing to ingest the raw Iris CSV, handle missing values and outliers, and apply scaling and normalization to prepare the dataset for supervised classification. This step ensures data quality and consistency before feature engineering and model training.
Exploratory Data Analysis
Perform Exploratory Data Analysis (EDA) on the raw Iris CSV dataset to understand feature distributions, relationships, and data quality before model training. Load the data, profile its structure and statistics, examine correlations between numeric features, and document key patterns that inform feature engineering and model selection decisions.
Statistical Fundamentals
Statistical Fundamentals underpins the entire iris classification pipeline. You will compute descriptive statistics to summarize the four numeric features, apply probability concepts to understand feature distributions and class proportions, and conduct hypothesis tests to identify which features significantly differ across species. These statistical insights will guide your feature engineering and model validation decisions.
Data Visualization
Create exploratory data visualizations of the Iris dataset using Matplotlib and Seaborn to understand feature distributions, relationships, and species separation before model training. Generate at least two publication-quality plots (e.g., pairplot, distribution plots, or scatter plots with species coloring) that will be included in your repository and discussed during the comprehension conversation.
Feature Engineering
Feature Engineering transforms raw iris measurements into predictive features that improve model performance. You will select the most informative numeric features from the four available measurements and encode the categorical species target appropriately, then integrate these engineered features into your classification pipeline to demonstrate how feature choices impact model accuracy.
Machine Learning
Machine Learning focuses on building and evaluating supervised classification models to predict iris species from flower measurements. You will implement multiple algorithms (logistic regression, decision trees, random forest, and k-means clustering), compare their performance using standard metrics, and document your model selection rationale. Linear regression serves as a baseline to understand prediction mechanics before moving to classification.
Model Evaluation
Model Evaluation focuses on assessing the trained classification model using standard metrics and validation techniques to ensure it generalizes well to unseen iris flower data. You will implement cross-validation to estimate model performance, generate a confusion matrix to analyze per-class errors, and compute precision, recall, and F1 scores to evaluate the balance between false positives and false negatives across the three species.
Language and stack
Python 3, pytest, scikit-learn, pandas, matplotlib or seaborn, and SQLite (or pandas SQL query simulation). All code must be testable and version-controlled in Git.
Scenario
You are a junior data scientist at a botanical research firm. The team has collected iris flower measurements and needs a reproducible classification system to automatically identify species from new measurements. Your manager expects a clean, documented pipeline that other team members can run, understand, and extend. The deadline is one business day; you will submit your code repository and then discuss your approach in a mandatory conversation to verify your understanding.
Deliverables
- A Python module (e.g., pipeline.py) that loads the Iris CSV, applies data cleaning and preprocessing, performs EDA with at least two visualizations, engineers features, trains a classifier, and outputs evaluation metrics.
- A SQL query (in a separate file or as a docstring) that retrieves iris records filtered by species or another criterion.
- Unit tests (test_pipeline.py) using pytest that verify data loading, preprocessing steps, and model output shape; at least three test cases.
Success criteria
These are repository evidence checks within the core scope, not additional feature requests. One implementation or test may provide evidence for several topics. Missing implementation evidence remains unverified; explanations alone do not demonstrate implementation proficiency.
Version Control
- Repository Setup (beginner): Git repository initialized in the project root with a .gitignore file excluding data downloads, model artifacts, and Python cache; git log shows at least one commit.
- Basic Commands (beginner): Repository contains evidence of git add, git commit, and git status usage; commits are present with meaningful messages describing the work (e.g., data loading, model training).
- Commits (beginner): At least 4 distinct commits in the main branch, each capturing a logical step of the pipeline (e.g., data ingestion, exploratory analysis, feature engineering, model evaluation).
- Branching (beginner): At least one feature branch created and merged into main; git branch history shows the branch name and merge commit.
- Merging (beginner): Feature branch successfully merged into main without unresolved conflicts; merge commit is present in git log.
- Conflict Resolution (intermediate): If merge conflicts occur during the project, evidence of manual conflict resolution in the repository (conflicted file edited, markers removed, and commit message documenting the resolution); if no conflicts arise naturally, assess only if present.
- Pull Requests (intermediate): If a pull request workflow is used, evidence of a pull request created, reviewed, and merged (e.g., PR description, approval, or merge commit referencing the PR); if the learner uses direct commits instead, assess only if present.
SQL
- SELECT Queries (beginner): Repository contains at least one SQL SELECT query that retrieves a subset of iris records (e.g., filtering by species or sepal_length threshold); query executes without syntax error and returns expected rows.
- JOINs (intermediate): If the repository includes a second table (e.g., species metadata or measurement source), a JOIN query combines iris measurements with that table and returns correct joined results; if no second table exists, assess only if present.
- GROUP BY (intermediate): Repository contains a GROUP BY query that aggregates measurements by species (e.g., average sepal_length per species) and produces correct grouped output with aggregation functions (COUNT, AVG, or similar).
- Basic SQL Queries (intermediate): inspect relevant code or tests within the core scope if present; do not add a feature solely for this topic. Missing implementation evidence remains unverified.
- SQL Join S (intermediate): inspect relevant code or tests within the core scope if present; do not add a feature solely for this topic. Missing implementation evidence remains unverified.
- Aggregation & Grouping (intermediate): inspect relevant code or tests within the core scope if present; do not add a feature solely for this topic. Missing implementation evidence remains unverified.
- Basic Subqueries & Cte S (beginner): inspect relevant code or tests within the core scope if present; do not add a feature solely for this topic. Missing implementation evidence remains unverified.
Python Programming
- Virtual Environments (beginner): Repository contains a requirements.txt or pyproject.toml file listing all dependencies; pipeline runs successfully in a fresh virtual environment without manual package installation.
- Functions & Modules (mixed): Code is organized into reusable functions (e.g., load_data, preprocess, train_model, evaluate) with clear separation of concerns; functions are called consistently throughout the pipeline; explain how function decomposition supports reproducibility and team collaboration.
- Object-Oriented Programming (mixed): At least one class is implemented (e.g., IrisClassifier or DataPipeline) with methods for training and prediction; class is instantiated and used in the main workflow; explain the design choice and how encapsulation benefits pipeline maintenance.
- Type Hints (mixed): Function signatures include type annotations for parameters and return values (e.g., def load_data(path: str) -> pd.DataFrame); type hints are applied consistently across the pipeline; explain how type hints improve code clarity and catch errors early.
- Python Syntax & Data Structures (intermediate): Code demonstrates correct use of lists, dictionaries, pandas DataFrames, and control flow (loops, conditionals) appropriate to data loading, cleaning, and iteration tasks within the pipeline.
- Basic OOP Concepts (beginner): Code instantiates and uses at least one class with attributes and methods; class behavior is observable in the pipeline execution.
- Error Handling & Debugging (intermediate): Pipeline includes try-except blocks or validation checks for common failures (e.g., missing files, invalid data types, model training errors); error messages are informative and logged or printed.
Pandas
- GroupBy (intermediate): Repository contains groupby aggregation on the Iris dataframe (e.g., mean, count, or std of numeric features grouped by species) with results used or validated in the pipeline.
- Merge & Join (intermediate): Repository contains at least one merge or join operation that combines data subsets or enriches the feature matrix; evidence may be conditional on a multi-source or augmented dataset being present in the core scope.
Data Cleaning & Preprocessing
- Missing Values: Code detects and handles missing values in the dataset (if present) using an appropriate strategy (e.g., removal, imputation); behavior is observable in the preprocessing module or test output.
- Outlier Detection: Code identifies outliers in numeric features using a statistical or distance-based method (e.g., IQR, z-score, isolation forest); outlier detection logic is present and callable within the pipeline.
- Scaling & Normalization: Code applies a scaling or normalization technique (e.g., StandardScaler, MinMaxScaler) to numeric features; the transformed output is verified in tests or pipeline output.
Exploratory Data Analysis
- Scaling & Normalization (intermediate): Repository contains code that loads the Iris CSV, computes summary statistics (mean, std, min, max) for all four numeric features, and demonstrates awareness of feature scale differences (e.g., sepal measurements vs. petal measurements); if normalization or scaling is applied during EDA or later pipeline stages, verify the approach and document rationale in code comments or notebook markdown.
- Data Profiling (intermediate): Repository includes code that inspects dataset shape, data types, missing values, and class distribution across the three species; output or assertions confirm 150 rows, four numeric features, one categorical target, and balanced or imbalanced class counts.
- Correlation Analysis (intermediate): Repository contains code that computes and visualizes (e.g., correlation matrix, heatmap, or pairplot) relationships between numeric features; output or plot shows which feature pairs are strongly correlated and which are independent.
- Business Insights (intermediate): Repository includes a summary (code comments, markdown cell, or docstring) that translates EDA findings into actionable observations for the classification task (e.g., which features best separate species, whether any features are redundant, data quality concerns that affect model training).
Statistical Fundamentals
- Descriptive Statistics (intermediate): Repository contains Python code that computes mean, standard deviation, quartiles, and correlation matrix for the four iris features; output is logged or visualized in the notebook or test output.
- Probability (intermediate): Code demonstrates calculation of class prior probabilities (proportion of each species) and conditional feature distributions; assess only if present in exploratory analysis or feature engineering module.
- Hypothesis Testing (intermediate): Code or test output shows at least one statistical test (e.g., t-test or ANOVA) comparing feature means across species groups, with p-values and interpretation documented.
Data Visualization
- Matplotlib (intermediate): Repository contains at least one plot created with Matplotlib (e.g., scatter plot, histogram, or line plot) saved as a PNG or displayed in a Jupyter notebook with labeled axes, title, and legend where applicable.
- Seaborn (intermediate): Repository contains at least one Seaborn plot (e.g., pairplot, heatmap, or violinplot) that visualizes relationships between features or species distributions, with appropriate styling and labels.
Feature Engineering
- Feature Selection (intermediate): Repository contains code that evaluates and selects a subset of the four numeric features (e.g. via correlation analysis, variance, or domain reasoning) and documents why those features were chosen; the final model training uses the selected features, not all four by default.
- Feature Encoding (intermediate): Repository contains code that encodes the categorical species target (setosa, versicolor, virginica) into a numeric format suitable for scikit-learn classifiers (e.g. label encoding or one-hot encoding) and applies the same encoding consistently during training and evaluation.
Machine Learning
- Linear Regression (intermediate): Training script loads iris CSV, fits a linear regression model on numeric features, and outputs predictions or coefficients; evidence present in repository code or test output.
- Logistic Regression (intermediate): Classifier trained on iris features with species as target; model achieves >80% accuracy on a held-out test set; code includes train-test split and accuracy or F1 metric calculation.
- Decision Trees (intermediate): Decision tree classifier trained and evaluated; tree depth, feature importance, or split criteria are logged or printed; test accuracy reported.
- Random Forest (intermediate): Random forest classifier trained with multiple trees; feature importance extracted and compared to single decision tree; test accuracy and cross-validation score reported.
- K-Means Clustering (intermediate): K-means model fitted to iris features (unsupervised); cluster assignments and silhouette score or inertia metric calculated and logged; results compared to true species labels.
Model Evaluation
- Cross Validation (intermediate): Repository contains code that splits the iris dataset using k-fold cross-validation (k >= 3) and reports mean and standard deviation of cross-validated accuracy or F1 scores.
- Confusion Matrix (intermediate): Repository contains code that generates and displays a confusion matrix from model predictions on a held-out test set or cross-validation fold, showing true positives, false positives, true negatives, and false negatives for each species.
- Precision Recall F1 (intermediate): Repository contains code that computes precision, recall, and F1 score for each class (setosa, versicolor, virginica) and reports macro or weighted averages; if present, code includes a classification report or per-class metric display.
What to explain
AI assistance is allowed while building the submission. During the comprehension conversation, answer independently without AI tools, search, or outside help. Be ready to trace your actual code, explain decisions and limitations, and reason about a small change or failure case. Conceptual topics do not require a separate coded feature.
Version Control
- Repository Setup (beginner): Explain why initializing a Git repository and using .gitignore is important for a team project; what files should be excluded and why.
- Basic Commands (beginner): Describe the purpose of git add, git commit, and git status; explain when you would use each command in your pipeline workflow.
- Commits (beginner): Walk through one of your commits; explain what changes it contains and why you grouped those changes together.
- Branching (beginner): Describe the feature branch you created; explain what work you did on it and why you chose to branch instead of committing directly to main.
- Merging (beginner): Explain how you merged your feature branch into main; describe any steps you took to ensure the merge was clean.
- Conflict Resolution (intermediate): If conflicts occurred, describe the conflict, how you identified it, and how you resolved it; if no conflicts arose, explain a scenario where a conflict might occur in a multi-person team and how you would handle it.
- Pull Requests (intermediate): If you used pull requests, describe the review process and how feedback was incorporated; if you used direct commits, explain when and why a pull request workflow would be beneficial for this project and how it would change your process.
SQL
- SELECT Queries (beginner): Explain the WHERE clause logic in your query and why you chose those filter conditions to extract the iris subset.
- JOINs (intermediate): Describe the relationship between the tables you joined, which columns you used as keys, and how the join type (INNER, LEFT, etc.) affects the result set.
- GROUP BY (intermediate): Walk through your GROUP BY query: what column did you group by, which aggregation functions did you apply, and what business insight does the grouped result provide for species classification?
- Basic SQL Queries (intermediate): Explain how your SELECT queries support data exploration and validation in the classification pipeline; what questions about the iris data do they answer?
- SQL Join S (intermediate): explain a concrete behavior, constraint, or tradeoff; where code exists, trace it and predict a small change or failure case. Explanation alone does not establish implementation proficiency.
- Aggregation & Grouping (intermediate): explain a concrete behavior, constraint, or tradeoff; where code exists, trace it and predict a small change or failure case. Explanation alone does not establish implementation proficiency.
- Basic Subqueries & Cte S (beginner): explain a concrete behavior, constraint, or tradeoff; where code exists, trace it and predict a small change or failure case. Explanation alone does not establish implementation proficiency.
Python Programming
- Virtual Environments (beginner): Explain why isolating dependencies in a virtual environment prevents conflicts and ensures reproducibility across team members and machines.
- Functions & Modules (intermediate): Walk through your function decomposition: why did you separate data loading from preprocessing? How would a teammate extend the pipeline by adding a new preprocessing step?
- Object-Oriented Programming (intermediate): Describe your class design: what state does it encapsulate, and how do its methods interact? How would you modify the class to support multiple model types?
- Type Hints (intermediate): Show an example of a type hint in your code and explain how it documents expected input and output; discuss how type hints would help catch a bug if a caller passed the wrong data type.
- Python Syntax & Data Structures (intermediate): Trace through your data loading and cleaning code: which data structures (list, dict, DataFrame) did you choose and why? How do you iterate over rows or columns to apply transformations?
- Basic OOP Concepts (beginner): Explain what attributes and methods your class has and how they work together to accomplish a task in the pipeline.
- Error Handling & Debugging (intermediate): Describe one error condition your pipeline might encounter (e.g., malformed CSV, missing feature column) and how your code detects and handles it; what would a user see if this error occurs?
Pandas
- GroupBy (intermediate): Explain why you chose specific aggregation functions for your groupby operation and how the grouped summary informed your feature engineering or exploratory analysis.
- Merge & Join (intermediate): Walk through your merge or join logic: which keys or indices you used, why that join type (inner, left, outer) was appropriate, and how you verified the result had the expected shape and no data loss.
Data Cleaning & Preprocessing
- Missing Values (intermediate): Explain the missing value handling strategy chosen for the Iris dataset; justify why removal, imputation, or another approach was selected given the data characteristics.
- Outlier Detection (intermediate): Describe the outlier detection method implemented; discuss how the threshold or sensitivity was set and whether outliers were removed, flagged, or retained in the final dataset.
- Scaling & Normalization (intermediate): Explain why scaling or normalization was applied to the numeric features; discuss the choice of technique and its impact on downstream model training.
Exploratory Data Analysis
- Scaling & Normalization (intermediate): Explain why feature scaling matters for the Iris dataset and which features would benefit most; discuss when to apply scaling (before or after train-test split) and why that order matters for model fairness.
- Data Profiling (intermediate): Walk through the code that loads and profiles the dataset; explain what each summary statistic reveals about data quality and whether any rows or values require special handling.
- Correlation Analysis (intermediate): Interpret the correlation matrix or visualization; identify which feature pairs are most and least correlated, and explain how strong correlations might affect model interpretability or feature selection.
- Business Insights (intermediate): Summarize the top two or three insights from your EDA that would guide a colleague on feature engineering or model choice; explain how the data distribution or relationships support those recommendations.
Statistical Fundamentals
- Descriptive Statistics (intermediate): Explain which feature shows the highest variance and why that matters for classification; describe how you used summary statistics to detect or handle outliers.
- Probability (intermediate): Walk through the calculation of class priors from the iris data; reason about how imbalanced class proportions would affect model training and evaluation.
- Hypothesis Testing (intermediate): Interpret the p-value from your statistical test; explain what it tells you about feature importance and how you used that insight to validate or refine your feature selection.
Data Visualization
- Matplotlib (intermediate): Explain why you chose specific plot types (e.g., scatter vs. histogram) for your data and how you used Matplotlib parameters (e.g., figsize, color, alpha) to improve readability.
- Seaborn (intermediate): Describe how your Seaborn visualization reveals patterns in the Iris data (e.g., species separation, feature correlations) and justify your choice of plot type and aesthetic mappings (hue, style, size) over a raw Matplotlib alternative.
Feature Engineering
- Feature Selection (intermediate): Explain which features you selected and why; describe the trade-off between model complexity and predictive power, and how you would justify your selection to a team member who proposed a different subset.
- Feature Encoding (intermediate): Walk through your encoding choice for the species target; explain why that encoding is appropriate for your chosen classifier and what would happen if you used a different encoding scheme.
Machine Learning
- Linear Regression (intermediate): Explain why linear regression is unsuitable for multi-class classification and how logistic regression or tree-based methods address this limitation.
- Logistic Regression (intermediate): Describe the decision boundary and probability output of logistic regression; justify train-test split ratio and metric choice for this imbalanced or balanced dataset.
- Decision Trees (intermediate): Discuss how tree depth affects overfitting; trace a single prediction path through the tree and explain the split criteria used at each node.
- Random Forest (intermediate): Compare variance and bias trade-offs between a single deep tree and an ensemble; explain how feature importance aggregates across trees and why it differs from a single tree.
- K-Means Clustering (intermediate): Explain why unsupervised clustering may not perfectly match species labels; discuss how silhouette score or inertia guides cluster number selection and interpret results.
Model Evaluation
- Cross Validation (intermediate): Explain why k-fold cross-validation is preferable to a single train-test split for this dataset size; describe how the learner chose k and how they interpret the mean and standard deviation of cross-validated scores.
- Confusion Matrix (intermediate): Walk through one row or column of the confusion matrix generated by the model; explain what each cell represents and identify which species, if any, are most often misclassified and why.
- Precision Recall F1 (intermediate): Given the three-class iris problem, explain the trade-off between precision and recall for at least one species; discuss when macro-averaging versus weighted-averaging is more appropriate and which the learner chose and why.
How to submit
- Before you start, register on SahkaarX and connect your GitHub account.
- When the challenge begins, SahkaarX will create a private repository under your GitHub account and notify you in the app and via push notification.
- Clone the repository, implement your pipeline, write tests, and commit your work with clear commit messages.
- Push all changes to the repository and submit your solution in the app using the system-created repository link.
What happens after you submit
When the challenge window closes, SahkaarX runs an automated repository evaluation that checks code structure, test coverage, and output correctness. You will then be invited to a mandatory in-app conversation where you will explain your data cleaning decisions, feature engineering choices, model selection rationale, and how you validated your results. This conversation verifies your understanding of the work; it is not a quiz. If human judges are assigned, they review your repository score and conversation transcript before final results are published; otherwise results finalize automatically after the conversation.
Intellectual property
You retain full ownership of the code and analysis in your submission. SahkaarX may host, evaluate, display on leaderboards, and operate the challenge using your work. Your GitHub repository remains private under your account; you control access and can modify or delete it after the challenge ends.
Skills You’ll Put to Work
Version Control
- Repository SetupBeginnerFundamental
- Basic CommandsBeginnerFundamental
- CommitsBeginnerFundamental
- BranchingBeginnerFundamental
- MergingBeginnerFundamental
- Conflict ResolutionIntermediateFundamental
- Pull RequestsIntermediateFundamental
SQL
- SELECT QueriesBeginnerFundamental
- JOINsIntermediateFundamental
- GROUP BYIntermediateFundamental
- Basic SQL QueriesIntermediateFundamental
- SQL Join SIntermediateFundamental
- Aggregation & GroupingIntermediateFundamental
- Basic Subqueries & Cte SBeginnerFundamental
Python Programming
- Virtual EnvironmentsBeginnerFundamental
- Functions & ModulesIntermediateFundamental
- Object-Oriented ProgrammingIntermediateFundamental
- Type HintsIntermediateFundamental
- Python Syntax & Data StructuresIntermediateFundamental
- Basic OOP ConceptsBeginnerFundamental
- Error Handling & DebuggingIntermediateFundamental
Pandas
- GroupByIntermediateFundamental
- Merge & JoinIntermediateFundamental
Data Cleaning & Preprocessing
- Missing ValuesIntermediateFundamental
- Outlier DetectionIntermediateFundamental
- Scaling & NormalizationIntermediateFundamental
Exploratory Data Analysis
- Scaling & NormalizationIntermediateFundamental
- Data ProfilingIntermediateFundamental
- Correlation AnalysisIntermediateFundamental
- Business InsightsIntermediateFundamental
Statistical Fundamentals
- Descriptive StatisticsIntermediateFundamental
- ProbabilityIntermediateFundamental
- Hypothesis TestingIntermediateFundamental
Data Visualization
- MatplotlibIntermediateFundamental
- SeabornIntermediateFundamental
Feature Engineering
- Feature SelectionIntermediateFundamental
- Feature EncodingIntermediateFundamental
Machine Learning
- Linear RegressionIntermediateFundamental
- Logistic RegressionIntermediateFundamental
- Decision TreesIntermediateFundamental
- Random ForestIntermediateFundamental
- K-Means ClusteringIntermediateFundamental
Model Evaluation
- Cross ValidationIntermediateFundamental
- Confusion MatrixIntermediateFundamental
- Precision Recall F1IntermediateFundamental
Before You Register
- Prerequisites: review the target audience, skills covered, and challenge brief.
- Deadlines: check the key dates and complete required submissions before the challenge deadline.
- Participation: Solo only.
- Evaluation: review the brief and FAQs for scoring criteria and how your work will be assessed.
- AI assistance: check this challenge's rules before using AI tools. If the rules are unclear, ask support before submitting.
Questions? Contact SahkaarX support.
Intellectual property: participants retain
Frequently Asked Questions
Who can join this challenge?
Entry-level data scientists and anyone learning Python, machine learning, and data pipelines. Solo participation only; no teams.
Do I need to create my own GitHub repository?
No. SahkaarX creates a private repository for you when the challenge starts. You will clone that system-created repo, not create your own.
When does evaluation happen?
Automated repository evaluation runs after the challenge window closes, not immediately after you submit. You will then complete a mandatory in-app conversation to discuss your solution.
What is the mandatory conversation?
A discussion where you explain your data cleaning, feature engineering, model choice, and validation approach. It verifies you understand your own work; it is not a written quiz or timed test.
Skill feedback helps you decide what to practise next. Learning plans follow eligible evaluated results; additional plans are paid. No job guarantee.