IBM Data Science

Reproducible work needs tools that record what you did. You use Jupyter notebooks for analysis, Git for history, and GitHub for sharing and review.

• Jupyter notebooks and their cells
• Markdown for explaining your work
• Git basics: commit, branch and merge
• GitHub repositories and pull requests
• Working with a shared repository
• Keeping a notebook reproducible

You build A GitHub repository holding a documented notebook with a clear history.

Projects fail when the steps are skipped. You learn the stages from business understanding through deployment and feedback, and apply them to a worked case before you touch real data.

• Business understanding and the analytic approach
• Data requirements and data collection
• Data understanding and preparation
• Modeling and evaluation
• Deployment and feedback
• Applying the stages to a case

You build A methodology walkthrough applied to a case of your choice.

Python is the working language of the field. You learn its types, control flow, functions and files, then use Pandas and NumPy to hold and calculate on tables and arrays, and call a REST API.

• Types, variables and expressions
• Lists, dictionaries and loops
• Functions and reading files
• NumPy arrays and calculations
• Pandas data frames
• Calling a REST API from Python

You build A script that reads a dataset, computes summaries and saves the result.

Put Python to work on messy sources. You gather data from the web and from APIs, clean it, and hand the results to the next stage in a form someone else can read.

• Planning the question and the sources
• Requesting data from APIs
• Scraping tables from web pages
• Cleaning and reshaping with Pandas
• Saving results to files
• Documenting the data’s origin

You build A dataset gathered from the web and an API, cleaned and documented.

Much data lives in relational databases. You write SQL to select, filter, aggregate and join tables, run queries from Python, and work with real public datasets.

• Relational databases and keys
• SELECT, WHERE and ordering
• Aggregates and GROUP BY
• Joins across tables
• Subqueries and views
• Running SQL from Python into Pandas

You build A set of SQL queries over a public dataset, run from a notebook.

Raw data needs shaping before it says anything. You handle missing values, fix formats, normalize and bin variables, group and summarize, and look for relationships between columns.

• Finding and handling missing values
• Correcting data types and formats
• Normalizing and binning
• Grouping and pivoting
• Correlation and its limits
• Exploratory analysis for insight

You build An exploratory analysis notebook that finds and explains three findings.

A chart is an argument. You build plots with Matplotlib and Seaborn, draw maps with Folium, and assemble an interactive dashboard in Plotly, choosing each chart for what it shows.

• Choosing the right chart for the question
• Line, bar and scatter plots in Matplotlib
• Statistical plots with Seaborn
• Maps with Folium
• Interactive charts in Plotly
• Assembling a dashboard

You build An interactive dashboard that answers a stated question from a dataset.

Models turn data into predictions. You train regression, classification and clustering models with scikit-learn, evaluate them properly, and decide which model deserves trust.

• Regression models
• Classification: logistic regression, nearest neighbors and trees
• Clustering with k-means
• Train and test splits and cross-validation
• Evaluation metrics
• Tuning and choosing between models

You build Several models trained and compared on one dataset, with a recommendation.

Complete one project across the whole methodology. You frame the question, gather and clean data, analyze, model and visualize, then write the report a stakeholder will read.

• Framing the question and success measure
• Collecting and preparing the data
• Analyzing and modeling
• Visualizing the findings
• Writing the stakeholder report

You build A finished data science project with analysis, models and a stakeholder report.

Generative AI speeds up routine work and introduces new errors. You use it to draft code, explain results and document projects, and learn how to check what it gives you before you rely on it.

• Where generative AI helps in data work
• Prompting for code and explanations
• Reviewing generated code for errors
• Using it to document and summarize
• Privacy when sharing data with a model
• Limits and responsibilities

You build A notebook where AI-assisted steps are each checked and annotated.

Good analysis is wasted if no one understands it. You turn a project into a clear, public piece of work and practice explaining your choices and results to specialists and non-specialists.

• Structuring a project repository for readers
• Writing a clear project summary
• Explaining a model’s choices to a non-specialist
• Describing your skills and projects concisely
• Answering technical questions about your own work
• Reviewing your work for gaps

You build A polished project write-up with a repository ready to be read by others.