Data Preprocessing in Machine Learning: 7 Key Steps to Follow, Strategies, & Applications

Have you ever fed raw data into a machine learning model only to get inconsistent or inaccurate results? It’s frustrating, right? That’s because raw data is often messy, incomplete, and unreliable. Data preprocessing in machine learning is the secret to transforming that chaos into a clean, structured format your models can actually understand.

In fact, data scientists spend nearly 80% of their time cleaning and organizing data—because well-prepared data leads to reliable outcomes. Paired with feature engineering in machine learning, it allows you to create meaningful inputs that improve model performance.

This guide will walk you through practical steps for data preprocessing and feature engineering, helping you unlock the full potential of your machine-learning projects. Dive in!

What Exactly is Data Preprocessing in Machine Learning?

Data preprocessing in machine learning involves transforming raw, unorganized data into a structured format suitable for machine learning models. This step is essential because raw data often contains missing values, inconsistencies, redundancies, and noise. 

Preprocessing addresses these issues, ensuring that data is accurate, clean, and ready for analysis.

Unstructured data, such as text or sensor data, presents additional challenges compared to structured datasets. This process plays a key role in feature engineering in machine learning by preparing the data for further transformations and optimizations.

Challenges with Raw Data and Their Solutions

Working with raw data often presents challenges that can impact the accuracy and efficiency of machine learning models. Here’s how data preprocessing in machine learning tackles these issues:

• Missing Values:
  Missing data can lead to inaccurate or biased models.
  Solution: Techniques like mean/mode imputation or advanced methods such as k-nearest neighbors (KNN) imputation can fill in the gaps, ensuring a complete dataset.
• Inconsistent Formats:
  Varied scales (e.g., age in years vs. income in dollars) can distort model results.
  Solution: Standardization (e.g., z-scores) or normalization (e.g., min-max scaling) aligns data to consistent formats for fair comparisons.
• Redundant Information:
  Duplicate or irrelevant data adds noise and reduces model efficiency.
  Solution: Deduplication techniques and feature selection methods remove unnecessary data, improving processing speed and accuracy.
• Noisy Data:
  Irrelevant or erroneous information can obscure meaningful patterns.
  Solution: Noise removal techniques, such as filtering outliers or smoothing data, help retain essential information while eliminating distractions.

Want to learn machine learning and deep learning in advanced level? Begin with upGrad’s machine learning certification courses and learn from the expert.

Addressing these challenges ensures a strong foundation for machine learning models and supports effective feature engineering. This leads to the critical tasks involved in preprocessing.

Major Tasks Involved in Data Preprocessing in Machine Learning

Data preprocessing consists of multiple steps that prepare data for machine learning. Each task plays a distinct role in refining data and making it suitable for algorithms. Let’s explore them one by one. 

1. Data Cleaning

Data cleaning focuses on identifying and fixing inaccuracies or inconsistencies in raw data. This step ensures that your dataset is reliable and ready for analysis.

• Tasks: Correcting missing values, removing duplicates, and identifying outliers.
• Techniques: Imputation methods for missing data, removing duplicate entries, and outlier detection through statistical approaches.
• Purpose: Enhances the dataset’s reliability, improving the model’s ability to generate accurate predictions.

Properly cleaned data ensures that the next step, integrating various data sources, proceeds seamlessly.

2. Data Integration

Data integration combines information from different sources into a single, cohesive dataset. This is especially critical when working with data collected from multiple systems or platforms.

• Tasks: Resolving format differences, aligning schemas, and removing redundancies across datasets.
• Techniques: Schema matching to align fields, deduplication processes, and resolving conflicts between datasets.
• Purpose: Creates a unified dataset that eliminates inconsistencies across data sources.

Also Read: Talend Data Integration Architecture & Functional Blocks

Integrated data requires transformation into standardized formats for better compatibility with machine learning models.

3. Data Transformation

Data transformation prepares integrated data for machine learning by converting it into formats that models can interpret effectively.

• Tasks: Adjusting data scales, encoding categorical variables, and normalizing distributions.
• Techniques: Methods like normalization, standardization, and one-hot encoding.
• Purpose: Ensures uniformity across variables, making them comparable and improving model performance.

Similar Read: 11 Essential Data Transformation Methods in Data Mining (2025)

Once transformed, the data may still contain unnecessary details, which makes reduction a logical next step.

4. Data Reduction

Data reduction simplifies the dataset by focusing only on the most relevant information while minimizing computational load.

• Tasks: Selecting essential features, reducing data dimensions, and sampling smaller subsets.
• Techniques: Feature selection methods, dimensionality reduction like PCA, and systematic data sampling.
• Purpose: Streamlines datasets for faster processing without losing critical insights.

After these tasks, the data is ready for feature engineering in machine learning, which significantly impacts the success of your models.

Why is Data Preprocessing Important in Machine Learning? Key Insights

Real-world data often contains irregularities, including missing values, outliers, and inconsistencies. Preprocessing transforms this chaotic raw data into a structured form that machine learning models can utilize effectively. 

For instance, studies suggest that 80% of a data scientist's time is spent preparing data rather than analyzing it, highlighting its importance.

The impact of data preprocessing in machine learning extends to improving data quality, boosting model efficiency, and enabling reliable insights. Below are some critical roles preprocessing plays.

Key Benefits of Preprocessing

Preprocessing transforms raw data into a structured and reliable format, making it essential for feature engineering in machine learning. Here’s how it refines data and enhances its utility:

• Enhancing Data Quality: Improves data integrity by refining, cleaning, and ensuring consistency.
• Handling Missing Data: Addresses incomplete entries using techniques like imputation or removal.
• Standardizing and Normalizing: Brings uniformity to scales and units, ensuring fair algorithm performance.
• Eliminating Duplicate Records: Removes redundant entries to maintain analysis accuracy.
• Handling Outliers: Detects and resolves extreme values using methods like trimming or transformation.
• Improving Model Performance: High-quality data leads to better predictions and reliable outcomes.

Similar Read: Steps in Data Preprocessing: What You Need to Know?

With a strong understanding of its importance, you can now proceed to learn the seven critical steps for effective data preprocessing in machine learning models.

7 Crucial Steps for Effective Data Preprocessing in Machine Learning Models

Data preprocessing in machine learning is a structured sequence of steps designed to prepare raw datasets for modeling. These steps clean, transform, and format data, ensuring optimal performance for feature engineering in machine learning. Following these steps systematically enhances data quality and ensures model compatibility.

Here’s a step-by-step walkthrough of the data preprocessing workflow, using Python to illustrate key actions. For this process, we’re using the Titanic dataset from Kaggle. 

Step 1: Import Necessary Libraries

Start by importing the libraries needed for handling and analyzing the dataset.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

Step 2: Load the Dataset

Load the dataset into a Pandas DataFrame. Make sure to download the Titanic dataset (train.csv) from Kaggle and place it in your working directory.

# Load Titanic dataset
dataset = pd.read_csv('train.csv')

# Display the first few rows of the dataset
print(dataset.head())

Output:

PassengerId  Survived  Pclass                                               Name     Sex   Age  SibSp  Parch            Ticket     Fare Cabin Embarked
0            1         0       3                            Braund, Mr. Owen Harris    male  22.0      1      0         A/5 21171   7.2500   NaN        S
1            2         1       1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1      0          PC 17599  71.2833   C85        C
2            3         1       3                             Heikkinen, Miss. Laina  female  26.0      0      0  STON/O2. 3101282   7.9250   NaN        S
3            4         1       1       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1      0            113803  53.1000  C123        S
4            5         0       3                           Allen, Mr. William Henry    male  35.0      0      0            373450   8.0500   NaN        S

Step 3: Understand the Dataset

Explore the dataset to understand its structure and identify missing or irrelevant data.

# Check the dimensions of the dataset
print(dataset.shape)

# Display summary statistics
print(dataset.describe())

# Check for missing values
print(dataset.isnull().sum())

Output:

Dimensions: (891, 12)

Summary Statistics:
       PassengerId    Survived      Pclass        Age       SibSp       Parch        Fare
count   891.000000  891.000000  891.000000  714.000000  891.000000  891.000000  891.000000
mean    446.000000    0.383838    2.308642   29.699118    0.523008    0.381594   32.204208
std     257.353842    0.486592    0.836071   14.526497    1.102743    0.806057   49.693429
min       1.000000    0.000000    1.000000    0.420000    0.000000    0.000000    0.000000
25%     223.500000    0.000000    2.000000   20.125000    0.000000    0.000000    7.910400
50%     446.000000    0.000000    3.000000   28.000000    0.000000    0.000000   14.454200
75%     668.500000    1.000000    3.000000   38.000000    1.000000    0.000000   31.000000
max     891.000000    1.000000    3.000000   80.000000    8.000000    6.000000  512.329200

Missing Values:
PassengerId      0
Survived         0
Pclass           0
Name             0
Sex              0
Age            177
SibSp            0
Parch            0
Ticket           0
Fare             0
Cabin          687
Embarked         2
dtype: int64

Step 4: Handle Missing Data

The Titanic dataset contains missing values in columns such as Age, Cabin, and Embarked. Handle these issues appropriately:

# Impute missing 'Age' values with the median
dataset['Age'].fillna(dataset['Age'].median(), inplace=True)

# Drop the 'Cabin' column due to excessive missing values
dataset.drop(columns=['Cabin'], inplace=True)

# Fill missing 'Embarked' values with the mode
dataset['Embarked'].fillna(dataset['Embarked'].mode()[0], inplace=True)

Updated missing values:

PassengerId    0
Survived       0
Pclass         0
Name           0
Sex            0
Age            0
SibSp          0
Parch          0
Ticket         0
Fare           0
Embarked       0
dtype: int64

Step 5: Encode Categorical Variables

Convert categorical data (e.g., Sex and Embarked) into numerical formats for machine learning models.

from sklearn.preprocessing import LabelEncoder

# Encode 'Sex' column
labelencoder = LabelEncoder()
dataset['Sex'] = labelencoder.fit_transform(dataset['Sex'])

# Encode 'Embarked' column
dataset = pd.get_dummies(dataset, columns=['Embarked'], drop_first=True)

Encoded dataset preview:

   Sex  Age  SibSp  Parch     Fare  Embarked_Q  Embarked_S
0    1 -0.558  1.0   0.0 -0.502445           0           1
1    0  0.613  1.0   0.0  0.788947           0           0
2    0 -0.257  0.0   0.0 -0.488854           0           1
3    0  0.416  1.0   0.0  0.420730           0           1
4    1  0.416  0.0   0.0 -0.486337           0           1

Step 6: Feature Scaling

Standardize numerical features such as Age and Fare to ensure uniform scaling across variables.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
dataset[['Age', 'Fare']] = scaler.fit_transform(dataset[['Age', 'Fare']])

Step 7: Split the Dataset

Divide the dataset into training and testing sets for model evaluation. Separate the features (X) and target (y).

from sklearn.model_selection import train_test_split

# Define features and target variable
X = dataset.drop(columns=['PassengerId', 'Name', 'Ticket', 'Survived'])
y = dataset['Survived']

# Split into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f"Training set shape: {X_train.shape}")
print(f"Testing set shape: {X_test.shape}")

Output:

Training set shape: (712, 7)
Testing set shape: (179, 7)

Implementing these steps ensures your data is well-prepared for machine learning models, leading to more accurate and reliable predictions.

Acquiring the Dataset

The first step in data preprocessing involves gathering a dataset that matches your analysis goals. The dataset should contain all the variables needed for effective feature engineering in machine learning.

Below are key points to consider when acquiring datasets:

• Data Sources: Use platforms like Kaggle, UCI Machine Learning Repository, or APIs to find reliable datasets.
• File Formats: Datasets may come in formats such as CSV, XLSX, or JSON. Choose a format compatible with your tools.
• Examples: Business datasets often include sales or customer data, while medical datasets focus on patient records or diagnostics.

Master deep learning fundamentals with fundamentals of deep learning and neural networks – a free course by upGrad!

Popular tools like Python APIs and data repositories simplify the dataset acquisition process. Once you have the data, you can proceed to import the libraries necessary for preprocessing.

Importing Essential Libraries for Data Preprocessing

Using appropriate Python libraries ensures that data preprocessing in machine learning is both efficient and reliable. These libraries provide functions to clean, manipulate, and analyze data effectively.

Example Code for Importing Libraries

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Learn more about Python libraries in upGrad’s free Python libraries certification course. 

Each library serves a specific purpose. NumPy handles numerical data, Pandas enables data organization, and Matplotlib provides insights through visualizations. Once these libraries are imported, you can focus on loading your dataset into the environment.

Loading the Dataset into Your Workspace

Once you have acquired the dataset and imported the necessary libraries, the next step is to load the data into your workspace. This step ensures your data is ready for processing and analysis.

Below are the steps to load your dataset:

• Set the Working Directory: Define the folder path where your dataset is stored. Use tools like Spyder IDE or Jupyter Notebook to simplify this process.
• Import the Dataset: Use Pandas to read the dataset into a DataFrame for easy manipulation.
• Separate Variables:
  • Independent variables (features): Inputs to the model.
  • Dependent variable (target): The output to predict.

Example Code for Loading the Dataset

# Load the dataset
dataset = pd.read_csv('Dataset.csv')

# Extract independent and dependent variables
X = dataset.iloc[:, :-1].values  # Features
y = dataset.iloc[:, -1].values   # Target

Example output:

Once the data is loaded, the next step is to identify and address missing values to ensure completeness.

Identifying and Addressing Missing Data

Detecting and addressing missing data is a critical step in data preprocessing in machine learning. Missing data, if left untreated, can lead to incorrect conclusions and flawed models. Ensuring data completeness improves the reliability of feature engineering in machine learning.

The following methods are commonly used to handle missing data.

• Delete Rows: Remove rows with missing values, especially if they contain more than 75% missing data. This approach works well when the dataset is large and missing data is minimal.
• Calculate the Mean: Replace missing numeric values with the mean, median, or mode. This is a simple yet effective method for filling gaps in numerical features.
• Advanced Methods: Approximate missing values based on neighboring data points. Linear interpolation or other statistical techniques can help when data follows a predictable trend.

Similar Read: Data Preprocessing In Data Mining: Steps, Missing Value Imputation, Data Standardization

Once missing data is addressed, the dataset is ready for further transformations like encoding categorical variables for machine learning models.

Encoding Categorical Variables

Machine learning algorithms require numerical inputs. Encoding categorical data into numerical form is an essential step in data preprocessing. It transforms categories into formats that algorithms can interpret effectively.

Below are the most commonly used techniques for encoding categorical variables.

Also Read: Label Encoder vs One Hot Encoder in Machine Learning

Code Examples for Label Encoding:

from sklearn.preprocessing import LabelEncoder

labelencoder = LabelEncoder()
dataset['Sex'] = labelencoder.fit_transform(dataset['Sex'])

Code Examples for Dummy Encoding:

dataset = pd.get_dummies(dataset, columns=['Embarked'], drop_first=True)

After encoding categorical variables, the dataset becomes entirely numerical and ready for outlier management.

Managing Outliers in Data Preprocessing

Outliers can significantly impact model predictions and skew results. Detecting and managing them ensures that your data is consistent and reliable for analysis.

The following techniques are widely used for outlier detection and handling.

• Outlier Detection:
  • Z-Score Method: Identify outliers based on standard deviations from the mean.
  • Boxplot: Use visualizations to detect extreme values.
• Handling Outliers:
  • Removal: Eliminate rows containing outliers.
  • Transformation: Apply transformations like logarithmic scaling to reduce their impact.
  • Imputation: Replace outliers with representative values such as the mean or median.

Code Example for Outlier Detection and Handling

# Z-Score Method
from scipy.stats import zscore
z_scores = zscore(dataset['Fare'])
dataset = dataset[(z_scores < 3).all(axis=1)]  # Remove rows where z-score exceeds 3

Example Output: 

Also Read: Types of Machine Learning Algorithms with Use Cases Examples

Addressing outliers paves the way for splitting the dataset and scaling features for optimal performance.

Splitting the Dataset and Scaling Features for Optimal Performance

Splitting the dataset ensures a fair evaluation of model performance. Scaling features standardizes values, ensuring each feature contributes equally during training.

Splitting the Dataset

• Training Set: Used to train the model.
• Test Set: Used to evaluate the model’s accuracy.

Typical split ratios are 70:30 or 80:20. The train_test_split() function in Python simplifies this process.

from sklearn.model_selection import train_test_split
X = dataset.drop(columns=['Survived'])
y = dataset['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Example Output:

Scaling Features

Feature scaling ensures uniformity in data range. This step is vital for algorithms that depend on distance metrics.

• Standardization (Z-Score): Centers data by removing the mean and scaling to unit variance.
• Normalization (Min-Max): Rescales data to a specific range, typically [0, 1].

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

Example Output: 

Now the dataset is fully preprocessed and ready for training machine learning models. This sets the stage for understanding how to handle imbalanced datasets effectively.

Effective Approaches to Handling Imbalanced Datasets in Machine Learning

Imbalanced datasets are common in real-world machine-learning tasks. These occur when one class significantly outweighs the other in representation, as seen in fraud detection or rare disease diagnosis. 

Such disparities often lead to biased models that favor the majority class, compromising predictions for the minority class.

Below are some of the most effective methods for managing imbalanced datasets.

• Resampling
  • Involves adjusting the dataset's balance by altering class distributions.
  • Oversampling: Increases the representation of the minority class by duplicating or generating new samples.
  • Undersampling: Reduces the size of the majority class by randomly removing samples.
  • Risks: Oversampling can lead to overfitting, while undersampling may result in information loss.
• Synthetic Data Generation
  • Creates artificial data points to balance the dataset.
  • SMOTE (Synthetic Minority Over-sampling Technique): Generates synthetic samples by interpolating between existing points in the minority class.
  • This method reduces the risk of overfitting while ensuring diversity in the minority class.
• Cost-Sensitive Learning
  • Adjusts the learning process to penalize misclassifications differently for each class.
  • Assigns higher misclassification costs to the minority class, encouraging the model to prioritize its accurate prediction.
  • Commonly used in decision trees, logistic regression, and support vector machines.
• Ensemble Methods
  • Combines multiple models to achieve better performance on imbalanced datasets.
  • Random Forest: Builds decision trees that handle both majority and minority classes effectively.
  • Gradient Boosting: Iteratively improves weak learners by focusing on reducing misclassification errors.

Aslo Read: Top Python Libraries for Machine Learning for Efficient Model Development in 2025

Imbalanced datasets pose significant challenges, but these approaches ensure fair representation and improved model performance. The next section explores how data preprocessing and feature engineering drive model performance in machine learning.

How Data Preprocessing and Feature Engineering Drive Model Performance in Machine Learning

Let’s explore the critical role of data preprocessing and feature engineering in optimizing machine learning model performance.

Here are the popular techniques in feature engineering. 

• Feature Scaling: Scaling ensures uniformity across features, which is crucial for algorithms sensitive to input variable scales, such as SVM and k-NN. Without scaling, features with larger ranges dominate, leading to biased results. Standardization and normalization are widely used scaling techniques.
• Feature Extraction: Dimensionality reduction techniques like Principal Component Analysis (PCA) extract significant information from high-dimensional data. PCA reduces complexity while retaining essential patterns, making datasets manageable and improving model speed.
• One-Hot Encoding: One-hot encoding converts categorical variables into binary indicators, ensuring compatibility with machine learning models. It avoids unintended ordinal relationships that might mislead algorithms like linear regression.
• Polynomial Features: Generating higher-degree features helps capture non-linear relationships between variables. Polynomial features often enhance model performance for datasets where linear models underperform.
• Domain-Specific Features: Using domain knowledge to create meaningful features tailored to the specific problem boosts model accuracy. For example, in a financial dataset, combining income and expenses into a new feature like "savings rate" can provide deeper insights.
• Effective Feature Engineering: Understanding your dataset and iteratively experimenting with engineered features significantly enhances model performance. Focus on identifying features that improve predictive power without overcomplicating the model.

With these techniques, feature engineering becomes an integral part of data preprocessing in machine learning, enabling more accurate and reliable predictions. 

Moving forward, the next section examines the role of data preprocessing in various machine-learning applications.

Exploring the Role of Data Preprocessing in Machine Learning Applications

Data preprocessing in machine learning forms the backbone of AI and ML workflows. Its purpose goes beyond cleaning data to enabling efficient feature engineering in machine learning, connecting individual preprocessing steps to broader AI goals like automation, prediction accuracy, and scalability.

Below are examples illustrating how data preprocessing contributes to practical applications in machine learning and AI.

Interested in advancing your skills in AI and ML? Enroll in upGrad’s PGD program in AI & ML and learn directly from IIT-B professionals.

The next section will discuss key professionals in feature engineering and data preprocessing and explore their salary trends.

Key Professionals in Feature Engineering and Data Preprocessing and Their Salaries

Professionals specializing in data preprocessing in machine learning and feature engineering play pivotal roles in preparing and optimizing data for advanced analytics. Their expertise ensures that raw data is transformed into actionable inputs for machine learning models, directly impacting innovation and decision-making.

Below are the primary roles involved in this domain, along with their responsibilities and average annual salaries.

Source: Glassdoor

Next, let’s explore top strategies for effective data preprocessing and feature engineering in machine learning.

Top Strategies for Effective Data Preprocessing and Feature Engineering in Machine Learning

Effective data preprocessing and feature engineering in machine learning are essential for transforming raw data into valuable insights. These strategies streamline the preparation process, enhance model accuracy, and ensure robust predictive capabilities across diverse applications.

• Explore and Analyze Your Dataset: Start by understanding your dataset’s structure, variables, and challenges. Use exploratory data analysis (EDA) techniques to detect anomalies, correlations, and trends that can influence feature engineering outcomes.
• Address Duplicates, Missing Values, and Outliers: Identify and resolve duplicates to maintain data integrity. Handle missing values through imputation or removal and manage outliers using statistical techniques like z-scores or transformations to ensure consistent data quality.
• Use Dimensionality Reduction to Manage Large Datasets: Techniques like Principal Component Analysis (PCA) simplify large datasets by retaining only the most significant features. This reduces computational overhead while preserving essential patterns.
• Perform Feature Selection to Identify Impactful Attributes: Leverage methods such as correlation analysis, mutual information, or recursive feature elimination to select attributes that contribute most to model performance. Removing irrelevant features improves model efficiency and reduces overfitting.
• Apply Feature Engineering Iteratively: Continuously experiment with new features to test their impact on model performance. Use domain knowledge to create meaningful features and monitor how they improve metrics like accuracy, precision, and recall.

The next section delves into transformative applications of data processing in machine learning and its role in driving business outcomes.

Transformative Applications of Data Processing in Machine Learning and Business

Data preprocessing in machine learning and feature engineering in machine learning are driving innovations across industries. They enable businesses to derive actionable insights, enhance decision-making, and deliver personalized customer experiences. 

The applications span various domains, showcasing how effective data handling impacts both operational efficiency and strategic growth.

Next, the focus shifts to how upGrad can enhance your data processing and machine learning expertise to advance your career and technical skills.

How upGrad Can Enhance Your Data Processing and Machine Learning Expertise

upGrad is a premier online learning platform designed to help you stay ahead in your career. With over 10 million learners, 200+ courses, and 1400+ hiring partners, upGrad is committed to providing industry-relevant education. 

We empower you to excel in cutting-edge domains like data preprocessing in machine learning and feature engineering in machine learning. Below are some of the courses you can explore to strengthen your expertise in these fields.

• PG Program in Machine Learning and AI
• Advanced Certificate in Data Science and AI
• Master of Science in Machine Learning
• Post Graduate Certificate in Machine Learning and Deep Learning (Executive)
• Post Graduate Certificate in Machine Learning & NLP (Executive)
• Fundamentals of Deep Learning and Neural Networks Free Course
• Introduction to Generative AI Free Course

Expand your expertise with the best resources available. Browse the programs below to find your ideal fit in Best Machine Learning and AI Courses Online.

Discover in-demand Machine Learning skills to expand your expertise. Explore the programs below to find the perfect fit for your goals.

Discover popular AI and ML blogs and free courses to deepen your expertise. Explore the programs below to find your perfect fit.

Dataset:
Titanic: https://www.kaggle.com/c/titanic/data 
Reference:
https://www.dataversity.net/survey-shows-data-scientists-spend-time-cleaning-data 
https://www.glassdoor.co.in/Salaries/data-scientist-salary-SRCH_KO0,14.htm 
https://www.glassdoor.co.in/Salaries/data-engineer-salary-SRCH_KO0,13.htm
https://www.glassdoor.co.in/Salaries/machine-learning-engineer-salary-SRCH_KO0,25.htm
https://www.glassdoor.co.in/Salaries/business-analyst-salary-SRCH_KO0,16.htm
https://www.glassdoor.co.in/Salaries/data-analyst-salary-SRCH_KO0,12.htm
https://www.glassdoor.co.in/Salaries/data-processing-specialist-salary-SRCH_KO0,26.htm
https://www.glassdoor.co.in/Salaries/data-manager-salary-SRCH_KO0,12.htm