← Back to all projects

LEARN DATASETS AND KAGGLE

Data is the fuel of the 21st century, and Kaggle is one of its most important racetracks. Understanding how to work with datasets is the most fundamental skill in data science, machine learning, and analytics. Kaggle provides the platform to practice this skill against real-world problems and measure yourself against the best in the world.

Learn Datasets and Kaggle: From Zero to Data Scientist

Goal: Develop a deep, practical understanding of data science by working with real-world datasets and competing on the Kaggle platform. Move from basic data exploration to building predictive models and participating in the global data science community.

Why Learn About Datasets and Kaggle?

Data is the fuel of the 21st century, and Kaggle is one of its most important racetracks. Understanding how to work with datasets is the most fundamental skill in data science, machine learning, and analytics. Kaggle provides the platform to practice this skill against real-world problems and measure yourself against the best in the world.

After completing these projects, you will:

  • Confidently explore, clean, and prepare any new dataset you encounter.
  • Perform powerful Exploratory Data Analysis (EDA) to uncover insights.
  • Engineer new features that improve model performance.
  • Build, train, and evaluate machine learning models for regression and classification.
  • Understand the complete end-to-end data science workflow.
  • Be an active participant in the Kaggle community, ready to tackle competitions.

Core Concept Analysis

The Data Science Workflow on Kaggle

┌──────────────────────────────────────────────────────────┐
│                      KAGGLE DATASET (.csv)                 │
│         (e.g., train.csv, test.csv, submission.csv)        │
└──────────────────────────────────────────────────────────┘
             │
             ▼
┌──────────────────────────────────────────────────────────┐
│           EXPLORATORY DATA ANALYSIS (EDA)                │
│                                                          │
│  • Summary Statistics (`.describe()`)                    │
│  • Data Visualization (Histograms, Scatter Plots)        │
│  • Correlation Analysis (Heatmaps)                       │
│  • Identifying Missing Values & Outliers                 │
└──────────────────────────────────────────────────────────┘
             │
             ▼
┌──────────────────────────────────────────────────────────┐
│             DATA CLEANING & FEATURE ENGINEERING          │
│                                                          │
│  • Imputing Missing Values (Mean, Median, Model)         │
│  • Encoding Categorical Variables (One-Hot, Label)       │
│  • Scaling Numerical Features (StandardScaler)           │
│  • Creating New Features (e.g., from dates or text)      │
└──────────────────────────────────────────────────────────┘
             │
             ▼
┌──────────────────────────────────────────────────────────┐
│                      MODEL TRAINING                      │
│                                                          │
│  • Split data into Training and Validation sets          │
│  • Choose a model (e.g., Logistic Regression, XGBoost)   │
│  • Train the model (`.fit()`) on the training data       │
└──────────────────────────────────────────────────────────┘
             │
             ▼
┌──────────────────────────────────────────────────────────┐
│                    MODEL EVALUATION                      │
│                                                          │
│  • Make predictions on the validation set (`.predict()`) │
│  • Compare predictions to true values using a metric     │
│    (Accuracy, RMSE, AUC)                                 │
│  • Cross-validation for robust results                   │
└──────────────────────────────────────────────────────────┘
             │
             ▼
┌──────────────────────────────────────────────────────────┐
│                      SUBMISSION                          │
│                                                          │
│  • Train final model on ALL training data                │
│  • Make predictions on the competition's `test.csv`      │
│  • Format predictions into `submission.csv`              │
│  • Upload to Kaggle and get leaderboard score!           │
└──────────────────────────────────────────────────────────┘

Key Concepts Explained

1. The Dataset

  • Structured Data: Highly organized data, typically in a tabular format (rows and columns). CSV files are the most common example.
  • Unstructured Data: Data without a pre-defined model, like text, images, or audio.
  • Training Set: The data used to train your model. It includes the features (input) and the target variable (what you want to predict).
  • Test Set: The data used by the competition to evaluate your model. It includes the features but not the target variable. Your goal is to predict it.
  • Features: The columns in your dataset used as inputs for your model (e.g., ‘Age’, ‘TicketClass’). Also called independent variables.
  • Target: The column you are trying to predict (e.g., ‘Survived’, ‘SalePrice’). Also called the dependent variable.

2. Exploratory Data Analysis (EDA)

This is the art of “getting to know” your data. Before you build any models, you must understand the data’s characteristics, find patterns, and spot anomalies.

  • Tools: pandas for statistics (.describe(), .info(), .value_counts()), matplotlib and seaborn for visualization.
  • Visualizations:
    • Histogram: Shows the distribution of a single numerical feature.
    • Bar Chart: Shows the frequency of categories in a categorical feature.
    • Scatter Plot: Shows the relationship between two numerical features.
    • Box Plot: Shows the distribution of a numerical feature across different categories.
    • Heatmap: Shows the correlation between all numerical features.

3. Feature Engineering & Preprocessing

This is often the most important step for winning competitions. It’s about transforming raw data into a format that a machine learning model can understand and learn from.

  • Handling Missing Data:
    • Deletion: Remove rows or columns with missing values (risky).
    • Imputation: Fill missing values with the mean, median, mode, or a predicted value.
  • Encoding Categorical Data: Models only understand numbers.
    • One-Hot Encoding: Converts a column with N categories into N-1 new columns of 0s and 1s.
    • Label Encoding: Converts each category into a unique integer (e.g., ‘S’, ‘C’, ‘Q’ -> 0, 1, 2).
  • Feature Scaling: Puts all numerical features on the same scale to prevent some features from dominating others.
    • StandardScaler: Rescales data to have a mean of 0 and a standard deviation of 1.
    • MinMaxScaler: Rescales data to be between 0 and 1.

4. Modeling & Evaluation

  • Model: The algorithm that learns patterns from the data (e.g., Linear Regression, Logistic Regression, Random Forest, XGBoost).
  • Training: The process of the model learning from the training data, done with the .fit() method in scikit-learn.
  • Prediction: Using the trained model to make predictions on new, unseen data with the .predict() method.
  • Evaluation Metric: The score used to measure the performance of your model. This is defined by the Kaggle competition.
    • Accuracy: For classification, the percentage of correct predictions.
    • LogLoss / AUC: For classification, measures the performance of a probabilistic classifier.
    • RMSE (Root Mean Squared Error): For regression, measures the average magnitude of the prediction errors.

Project List

These projects are designed to be completed within Kaggle’s free Notebook environment. They are ordered to build your skills progressively.

Project 1: Titanic - Your First Data Science Journey

  • File: LEARN_DATASETS_AND_KAGGLE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: R
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: Exploratory Data Analysis (EDA)
  • Software or Tool: Pandas, Matplotlib, Seaborn
  • Main Book: “Python for Data Analysis, 3rd Edition” by Wes McKinney

What you’ll build: A detailed exploratory data analysis of the famous Titanic dataset. You will investigate which factors contributed to a passenger’s survival.

Why it teaches datasets and Kaggle: This is the “Hello, World!” of Kaggle. It teaches the most fundamental skill: using Pandas and visualization libraries to inspect a dataset, form hypotheses, and communicate your findings.

Core challenges you’ll face:

  • Loading data with Pandas → maps to using pd.read_csv() and creating a DataFrame
  • Inspecting the DataFrame → maps to using .head(), .info(), and .describe() to get a first look
  • Analyzing single variables → maps to using .value_counts() for categorical data and histograms for numerical data
  • Analyzing relationships between variables → maps to using groupby() and crosstab() to see how features relate to the survival target

Key Concepts:

  • Pandas DataFrame: “Python for Data Analysis” - Chapter 5
  • Summary Statistics: “Python for Data Analysis” - Chapter 10
  • Plotting with Seaborn: Seaborn Official Tutorial

Difficulty: Beginner Time estimate: Weekend Prerequisites: Basic Python syntax.

Real world outcome: A Kaggle notebook filled with visualizations and markdown commentary that answers questions like:

  • Did women and children have a higher survival rate?
  • Did passengers in first class survive more often?
  • Is there a correlation between the port of embarkation and survival?

Example visualization in your notebook:

# (This is pseudo-code for your notebook)
import seaborn as sns
import matplotlib.pyplot as plt

# Creates a bar chart showing survival rate by passenger class
sns.barplot(x='Pclass', y='Survived', data=train_data)
plt.title('Survival Rate by Passenger Class')
plt.show()
# The plot will visually confirm that 1st class passengers had a much higher survival rate.

Learning milestones:

  1. You can load the data and describe its basic properties → You understand DataFrames.
  2. You can create plots for single variables → You can visualize distributions.
  3. You can create plots that show the relationship between two or more variables → You can perform bivariate analysis.
  4. You can write a clear, narrative-driven notebook explaining your findings → You can communicate insights from data.

Project 2: Housing Prices - Cleaning and Feature Engineering

  • File: LEARN_DATASETS_AND_KAGGLE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: R
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Data Cleaning / Feature Engineering
  • Software or Tool: Pandas, Scikit-learn
  • Main Book: “Hands-On Machine Learning with Scikit-Learn, Keras & TensorFlow, 3rd Edition” by Aurélien Géron

What you’ll build: A data cleaning and feature engineering pipeline for the Ames Housing dataset, a classic regression problem. You will prepare this messy, real-world dataset for machine learning.

Why it teaches datasets and Kaggle: Real data is messy. This project moves beyond simple exploration and forces you to confront the most common and critical data preparation tasks: handling missing values and converting data into a model-friendly format.

Core challenges you’ll face:

  • Handling many missing values → maps to developing a strategy for imputation (e.g., filling missing LotFrontage with the median of the neighborhood)
  • Dealing with categorical features → maps to using One-Hot Encoding for nominal categories and Label Encoding for ordinal ones
  • Transforming skewed numerical features → maps to using a log transform on SalePrice to make its distribution more normal
  • Creating new features from existing ones → maps to combining features (e.g., TotalSF = TotalBsmtSF + 1stFlrSF + 2ndFlrSF) or extracting information (e.g., Age = YrSold - YearBuilt)

Key Concepts:

  • Data Cleaning: “Hands-On Machine Learning” - Chapter 2
  • Handling Categorical Attributes: “Hands-On Machine Learning” - Chapter 2
  • Feature Scaling: Scikit-learn documentation on StandardScaler.

Difficulty: Intermediate Time estimate: 1-2 weeks Prerequisites: Project 1.

Real world outcome: A clean, processed dataset where all columns are numerical and there are no missing values. This dataset is ready to be fed into a machine learning model. You will also have a list of engineered features that are more predictive than the raw data.

Implementation Hints:

  1. First, visualize the missing data. seaborn.heatmap(df.isnull(), cbar=False) is a great way to see patterns.
  2. Read the data_description.txt file that comes with the dataset. Some “missing” values are not missing; they mean “None” (e.g., NA in PoolQC means “No Pool”). You should fill these with the string “None”.
  3. For true missing numerical data, consider filling with the median, as it’s less sensitive to outliers than the mean.
  4. For categorical data, pandas.get_dummies() is a simple way to perform One-Hot Encoding.
  5. Look at the distribution of the target variable, SalePrice. You’ll notice it’s right-skewed. Plot a histogram of np.log1p(df['SalePrice']) to see how a log transform helps.

Learning milestones:

  1. You have a clear strategy for every column with missing data → You can handle incomplete data.
  2. All categorical columns are converted to numerical format → You can prepare data for modeling.
  3. You have created at least three new, meaningful features → You understand the creative aspect of feature engineering.
  4. The final processed dataset is ready for a machine learning model → You can build a data pipeline.

Project 3: Housing Prices - Your First Predictive Model

  • File: LEARN_DATASETS_AND_KAGGLE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: R
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Machine Learning / Regression
  • Software or Tool: Scikit-learn
  • Main Book: “Introduction to Machine Learning with Python” by Andreas C. Müller & Sarah Guido

What you’ll build: Using your cleaned data from Project 2, you will train your first machine learning model (e.g., Ridge Regression, RandomForestRegressor) to predict housing prices and make your first submission to a Kaggle competition.

Why it teaches datasets and Kaggle: This project closes the loop. You’ll take your prepared data and finally use it to make predictions, experiencing the core fit/predict workflow of scikit-learn and the thrill of seeing your name on the Kaggle leaderboard.

Core challenges you’ll face:

  • Splitting data for validation → maps to using train_test_split to create a local validation set to test your model before submitting
  • Training a model → maps to instantiating a scikit-learn model and calling the .fit(X_train, y_train) method
  • Evaluating model performance → maps to making predictions with .predict() and comparing them to the true values using the competition’s metric (Root Mean Squared Error)
  • Creating a submission file → maps to training your model on the full training set, predicting on the competition’s test set, and formatting the output into a submission.csv file

Key Concepts:

  • Supervised Learning: “Introduction to Machine Learning with Python” - Chapter 2
  • Cross-Validation: “Hands-On Machine Learning” - Chapter 2
  • Regression Models: “Introduction to Machine Learning with Python” - Chapter 2

Difficulty: Intermediate Time estimate: Weekend Prerequisites: Project 2.

Real world outcome: A submission.csv file that you can upload to the “House Prices - Advanced Regression Techniques” competition on Kaggle. You will get a score and a rank on the public leaderboard.

Submission File Format (submission.csv):

Id,SalePrice
1461,120000.0
1462,155000.0
...

Implementation Hints:

  1. The competition metric is Root Mean Squared Logarithmic Error (RMSLE). Since you log-transformed the SalePrice in Project 2, you can simply calculate the Root Mean Squared Error (RMSE) on your transformed predictions, which is equivalent. Use np.sqrt(mean_squared_error(y_true, y_pred)).
  2. Don’t forget to apply the same cleaning and feature engineering steps to the competition’s test.csv as you did to train.csv. A good way to do this is to combine them, process them, and then split them apart again.
  3. When you make your final predictions for submission, remember that your model is predicting the log-transformed price. You must convert it back to the original scale using np.expm1() before saving it to the submission file.
  4. Start with a simple model like Ridge or Lasso before moving to more complex ones like RandomForestRegressor or XGBoost.

Learning milestones:

  1. You can locally validate your model’s performance → You understand the importance of not relying on the public leaderboard.
  2. You can train a model and make predictions → You understand the scikit-learn API.
  3. You successfully create a submission file in the correct format → You can navigate the mechanics of a Kaggle competition.
  4. You appear on the Kaggle leaderboard → You have completed the full, end-to-end data science workflow.

Project 4: Digit Recognizer with a Simple Neural Network

  • File: LEARN_DATASETS_AND_KAGGLE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Computer Vision / Deep Learning
  • Software or Tool: TensorFlow/Keras, NumPy
  • Main Book: “Deep Learning with Python, Second Edition” by François Chollet

What you’ll build: A neural network to classify handwritten digits from the famous MNIST dataset. This is the “Hello, World” of computer vision.

Why it teaches datasets and Kaggle: This project introduces you to a new type of data: images. You’ll learn how to represent image data numerically and how to use a deep learning framework like Keras to build a model that can “see.”

Core challenges you’ll face:

  • Representing image data → maps to understanding that an image is just a 2D array of pixel values (0-255)
  • Preparing images for a neural network → maps to reshaping the 2D image arrays into 1D vectors and normalizing the pixel values to be between 0 and 1
  • Building a sequential model in Keras → maps to stacking Dense layers with activation functions (relu, softmax)
  • Understanding classification metrics → maps to using categorical_crossentropy as a loss function and accuracy as a performance metric

Key Concepts:

  • Neural Networks: “Deep Learning with Python” - Chapter 2
  • Image Data Representation: “Hands-On Machine Learning” - Chapter 14
  • Convolutional Neural Networks (CNNs): “Deep Learning with Python” - Chapter 8 (as an extension)

Difficulty: Intermediate Time estimate: 1-2 weeks Prerequisites: Project 1, basic understanding of what a neural network is.

Real world outcome: A trained model that can look at an image of a handwritten digit and correctly classify it. You will submit your predictions to the Digit Recognizer competition on Kaggle.

Implementation Hints:

  1. The data for each image is a 784-element row, which represents a flattened 28x28 pixel image.
  2. Normalize the pixel data by dividing all values by 255.0. This helps the neural network train faster and more reliably.
  3. The target variable (the digit 0-9) needs to be one-hot encoded. Keras provides a utility for this: to_categorical.
  4. A simple Keras model for this task would look like this:
    • InputLayer with shape (784,).
    • A Dense layer with 128 neurons and relu activation.
    • A Dropout layer (e.g., 0.2) to prevent overfitting.
    • A final Dense layer with 10 neurons (one for each digit) and softmax activation to output probabilities.
  5. Compile the model with an optimizer like adam and the categorical_crossentropy loss function.
  6. Train the model using the .fit() method, and be sure to use a validation split to monitor for overfitting.

Learning milestones:

  1. You can load and correctly reshape the image data → You understand how to handle image datasets.
  2. You can build and compile a simple Keras model → You understand the basics of a deep learning framework.
  3. Your model trains and its accuracy on the validation set improves over epochs → You can train a neural network.
  4. You achieve over 98% accuracy on the Kaggle leaderboard → You have built a competent image classifier.

Project 5: Natural Language Processing with Movie Reviews

  • File: LEARN_DATASETS_AND_KAGGLE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: N/A
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: NLP / Text Classification
  • Software or Tool: Scikit-learn, NLTK
  • Main Book: “Natural Language Processing with Transformers” by Lewis Tunstall, et al. (for advanced concepts)

What you’ll build: A sentiment analysis model that can determine whether a movie review is positive or negative. You’ll use a classic NLP dataset like the “Bag of Words Meets Bags of Popcorn” competition.

Why it teaches datasets and Kaggle: This project introduces you to unstructured text data. You’ll learn the fundamental techniques for converting raw text into numerical features that a machine learning model can process.

Core challenges you’ll face:

  • Text Cleaning → maps to removing HTML tags, punctuation, and “stopwords” (common words like ‘and’, ‘the’, ‘a’)
  • Text Vectorization → maps to converting sentences into numerical vectors using techniques like CountVectorizer (Bag-of-Words) or TfidfVectorizer
  • Building a text classification pipeline → maps to using scikit-learn’s Pipeline object to chain together the vectorizer and a classifier (e.g., LogisticRegression)

Key Concepts:

  • Bag-of-Words: “Hands-On Machine Learning” - Chapter 16
  • TF-IDF: “Introduction to Information Retrieval” by Manning, Raghavan, Schütze
  • Text Preprocessing: NLTK documentation on stopwords and tokenization.

Difficulty: Intermediate Time estimate: 1-2 weeks Prerequisites: Project 1, basic understanding of classification.

Real world outcome: A model that can take a sentence like “This movie was a fantastic and beautiful masterpiece” and predict a “positive” sentiment. You will submit your predictions to the relevant Kaggle competition.

Implementation Hints:

  1. Start with text cleaning. Regular expressions are very useful here for removing non-alphabetic characters.
  2. Use CountVectorizer from scikit-learn as your first vectorization technique. It’s simple and effective. It builds a vocabulary of all words in the training data and counts the occurrences of each word in each document.
  3. TfidfVectorizer is a more advanced technique that gives higher weight to words that are important to a document, not just frequent across all documents. It often performs better.
  4. Use a simple, fast, and interpretable model like LogisticRegression or MultinomialNB as your classifier.
  5. A Pipeline is your best friend. It allows you to define a sequence of steps (e.g., (vectorizer, classifier)) that behaves like a single scikit-learn estimator, preventing you from accidentally leaking data from your test set during the vectorization step.

Learning milestones:

  1. You can clean and tokenize a corpus of text → You understand basic text preprocessing.
  2. You can convert text into a numerical matrix using TF-IDF → You understand text vectorization.
  3. You can train a classifier on the vectorized text to predict sentiment → You can build a text classification model.
  4. You can explain what the most important features (words) are for your model → You can interpret your NLP model’s results.

Project 6: Enter Your First Live Competition

  • File: LEARN_DATASETS_AND_KAGGLE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: R
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Machine Learning / Competitive Data Science
  • Software or Tool: Kaggle, XGBoost, LightGBM
  • Main Book: N/A, rely on Kaggle notebooks and discussion forums.

What you’ll build: A complete, end-to-end solution for an active Kaggle competition. You will go through the full workflow: understanding the problem, EDA, feature engineering, modeling, validation, and submission, all under the pressure of a live leaderboard.

Why it teaches datasets and Kaggle: This is the final exam. It synthesizes all the skills you’ve learned into a single, focused effort. You’ll learn how to work independently, read other people’s code from public notebooks, and iterate on your solution based on leaderboard feedback.

Core challenges you’ll face:

  • Understanding a new, unfamiliar dataset and problem → maps to quickly developing domain knowledge and identifying the core challenge
  • Creating a robust cross-validation strategy → maps to building a reliable local validation system so you don’t have to rely on your limited public leaderboard submissions
  • Model selection and tuning → maps to using more advanced models like LightGBM or XGBoost and tuning their hyperparameters
  • Learning from the community → maps to reading discussion forums and public notebooks to get ideas and avoid common pitfalls

Key Concepts:

  • Cross-Validation: Scikit-learn documentation on KFold and StratifiedKFold.
  • Gradient Boosting Models: “The 100 Page Machine Learning Book” by Andriy Burkov
  • Ensembling/Stacking: Kaggle-specific blogs and tutorials.

Difficulty: Advanced Time estimate: 1 month (the duration of a competition) Prerequisites: All previous projects.

Real world outcome: You will have one or more submissions to a live Kaggle competition, a final rank on the leaderboard, and a Kaggle notebook that represents your best work. You might even win a medal (Top 10% for Bronze)!

Implementation Hints:

  1. Pick the right competition: Don’t start with a “Featured” competition with a huge prize. Look for “Getting Started” or “Playground” competitions. The “Tabular Playground Series” that runs monthly is perfect.
  2. FORK, DON’T COPY: Find a popular public notebook for the competition and fork it. This creates your own copy. Run it yourself, cell by cell, to understand what it’s doing. This is your baseline.
  3. The Golden Rule: Your first goal is to improve on your local cross-validation (CV) score. If a change improves your CV score, it will probably improve your leaderboard (LB) score. Trust your CV.
  4. Start simple: Your first submission should be from a simple, well-understood baseline model. Don’t try complex ensembling right away.
  5. Read the forums: The competition discussion forum is your most valuable resource. Top Kagglers often share insights and discoveries.

Learning milestones:

  1. You make your first submission and get a leaderboard score → You are officially a Kaggler.
  2. You create a reliable local cross-validation framework → You can iterate and test ideas offline.
  3. You improve upon a public baseline notebook → You are contributing your own ideas.
  4. You finish the competition and see your final rank on the private leaderboard → You have completed the full competitive data science experience.

Project Comparison Table

Project Difficulty Time Core Concept Fun Factor
1. Titanic EDA Beginner Weekend Data Exploration ★★★☆☆
2. Housing Prices - Cleaning Intermediate 1-2 weeks Feature Engineering ★★☆☆☆
3. Housing Prices - Modeling Intermediate Weekend Regression ★★★★☆
4. Digit Recognizer (CV) Intermediate 1-2 weeks Deep Learning ★★★★☆
5. Movie Reviews (NLP) Intermediate 1-2 weeks Text Vectorization ★★★☆☆
6. Live Kaggle Competition Advanced 1 month+ Full Workflow ★★★★★

Recommendation

Without a doubt, start with Project 1: Titanic - Your First Data Science Journey. It is a rite of passage for every data scientist. The dataset is small, the problem is easy to understand, and there are thousands of public notebooks on Kaggle for you to learn from. It perfectly introduces you to the core tools (pandas, seaborn) and the EDA mindset without the pressure of complex modeling.

After you’ve thoroughly explored the Titanic dataset, move on to Project 2 and 3 (Housing Prices). This two-part project will give you the full, end-to-end experience of cleaning messy data, engineering features, and making your first leaderboard submission. Completing these first three projects will give you a very strong and practical foundation for all your future data science work.

Summary

  • Project 1: Titanic - Your First Data Science Journey: Python
  • Project 2: Housing Prices - Cleaning and Feature Engineering: Python
  • Project 3: Housing Prices - Your First Predictive Model: Python
  • Project 4: Digit Recognizer with a Simple Neural Network: Python
  • Project 5: Natural Language Processing with Movie Reviews: Python
  • Project 6: Enter Your First Live Competition: Python