Complete 2022 Data Science & Machine Learning Bootcamp

Explore how data science uses linear regression to predict movie revenue by formulating a precise question, identifying the target (revenue) and the feature (budget), and training and evaluating a model.

Gather budgets and revenue data from The Numbers and prepare it for analysis. Clean the data by removing zero revenues, stripping dollar formatting, and renaming headers to production_budget_usd and worldwide_gross_usd.

Learn data visualization and exploration in Python using Jupyter notebooks, pandas, and matplotlib to load CSV, create data frames, and build a scatter plot of production budgets versus worldwide gross.

Demonstrate how linear regression fits a line to budget and revenue data, using theta 0 and theta 1 to minimize residuals via the residual sum of squares.

Run and evaluate a linear regression in Python using scikit-learn within a Jupyter notebook, obtaining slope and intercept, plotting the regression line, and assessing model performance with R squared.

Install python and the Anaconda distribution on Windows, which includes Jupyter Notebook and many data science libraries; learn to verify Python version, launch notebooks, and shut down properly.

Mac users install Python 3 via Anaconda on Mac OS, which bundles Jupyter Notebook and libraries like pandas, matplotlib, and sklearn for a ready-to-use data science environment.

Explore python programming fundamentals—variables, data types, functions, methods, and objects—while learning Jupyter setup and data visualization and regression workflows in MLProjects.

Learn how Python uses variables to store and update data with assignment, and identify data types like int, float, and str using type().

Explore Python collections by learning lists and arrays, create and access items with zero-based indexing, and understand how arrays differ from lists for data science tasks.

Explore python modules and import statements, including aliasing with as and from imports. See life.py and life.theAnswer demonstrate dot notation, packages, and using math.

Learn how to define and call Python functions using def, name them clearly, and organize instructions with indentation, illustrated by the get_milk example.

Explore how Python functions take inputs with parameters and arguments, and learn to use positional and named arguments for clearer, error-free function calls.

Learn how functions return values with the return keyword and store results in variables, using examples like read_csv to illustrate efficient, modular code design in Python.

Discover how Python treats every data item as an object, access its attributes with dot notation, and invoke methods on modules and objects.

Learn to visualize data with Python by plotting time against LSD tissue concentration and applying a linear regression to analyze drug effects on math scores.

Fit a linear regression model with scikit-learn, inspect regr.coef_ and regr.intercept_, and evaluate with score and R-squared; then plot the data and regression line with matplotlib.

Adopt readable Python coding style by choosing and sticking to a style guide like PEP 8 or Google's, covering indentation with four spaces, and underscores separating words in naming conventions.

Explore how machine learning learns by building an optimization algorithm from scratch in Python using calculus, derivatives, and gradient descent. Apply it to diverse problems and examine strengths and limitations.

Explore how machine learning learns through a three-step process: predicting function coefficients, calculating error, and updating parameters to reduce error, using linear regression and gradient descent as a practical framework.

Learn how to quantify error with the residual sum of squares as a cost function and minimize it through optimization, while clarifying cost, loss, and objective functions.

Learn to build and document a data science notebook by using markdown with LaTeX for math, generate data with numpy linspace, and plot cost functions with matplotlib to visualize f(x)=x^2+x+1.

Apply the power rule to derive f(x)=x^2+x+1 and visualize the cost and its slope with side-by-side matplotlib plots, including grid, labels, and axis limits.

Explore gradient descent by implementing a Python loop-based optimizer that minimizes a convex cost function. Build intuition with for and while loops, learning rate, and gradient calculations, and visualize convergence.

Explore how initial guesses affect gradient descent on g(x) = x^4 - 4x^2 + 5 and learn Python techniques like passing functions as arguments and returning multiple values.

Explore how gradient descent can diverge and overflow, and learn Python concepts like tuples, tuple packing and unpacking, and controlling iterations with max_iter.

Explore the learning rate in gradient descent, learn how the multiplier controls step size, and see how choices impact convergence, overflow risks, and optimization strategies like learning-rate schedules.

Explore advanced data visualization by creating 3D charts in Python, building a 3D surface with Matplotlib, using meshgrid, 3D axes, labels, and color maps like coolwarm.

Explains partial derivatives for a two-parameter cost function using python and sympy, differentiating with respect to x and y, evaluating costs with evalf and subs, and preparing for gradient descent.

Implement batch gradient descent with SymPy to optimize a two-parameter function f(a,b) using numpy arrays, gradients, and a learning rate of 0.1 with max_iter 200.

Learn to run gradient descent without SymPy to boost performance in Jupyter notebooks, while implementing fpx and fpy Python functions for partial derivatives and using natural log.

Visualize a gradient descent path on a 3d surface while learning advanced numpy nd arrays, including reshape, append, and slicing to select columns and manage shapes.

Demonstrate updating the values_array during gradient descent with np.append and np.concatenate, reshaping params for axis 0, and plotting the evolving cost surface as a 3D bowl with a scatter plot.

Explore how gradient descent minimizes the mean squared error for regression, linking the residual sum of squares to MSE and clarifying y hat and h_theta x_i.

Create sample data with x_5 and y_5, reshape to two dimensions for linear regression, fit the model, and plot the data with best-fit line, distinguishing data plots from cost functions.

Compute the mean squared error for a linear regression by forecasting y_hat with theta0 and theta1, then validate with manual mean squared error, numpy, and scikit-learn approaches.

Create a 3D surface plot of the mean squared error by generating theta0 and theta1 with linspace, forming a 5x5 meshgrid, and computing MSE with nested loops.

Iterate over theta values with nested loops to compute y_hat and update the MSE surface. Plot a 3d MSE surface across theta0 and theta1, and identify the minimum using unravel_index.

Explore gradient descent on the mean squared error for a one-variable linear regression, deriving partial derivatives for theta0 and theta1, then update thetas in Python.

visualize gradient descent progress by collecting theta values and mean squared error over iterations, then plot them on a 3d surface to reveal optimization dynamics.

Define the problem by formulating the goal and context for a real estate valuation tool. Show contribution of each factor to benchmark price and ensure a transparent, tractable model.

Learn to gather and prepare data for house price analysis by using scikit-learn's Boston dataset, exploring 506 samples with 13 features, and loading it into a Python notebook.

Explore the Boston housing dataset in a notebook, examining origin, description, size, and features. Learn to inspect attributes like descr, and view shape and data as a NumPy array.

Explore the Boston dataset to distinguish features from the target price, convert data into a pandas dataframe, and inspect for missing values with isnull and info.

Visualize data during exploration with histograms to reveal distributions and outliers in the Boston house prices dataset, using matplotlib in a Jupyter notebook and exploring seaborn as an alternative.

Visualize data with Seaborn's distplot, producing a histogram plus a probability density function with tunable bins and colors. Learn to examine the Boston RM feature and compute its mean, 6.28.

Explore the rad index for highway accessibility and plot a histogram with explicit bins. Compare this to a bar chart built from value_counts, illustrating dummy variables like CHAS.

Explore descriptive statistics with pandas to compare mean and median and to inspect min, max, and distribution in a data frame using describe, and spot outliers that affect central tendency.

Learn how correlation measures how variables move together, capture strength and direction, and identify positive, negative, or zero correlations to guide feature selection in data exploration.

Learn to compute Pearson correlation coefficients in a data frame, interpret positive and negative relationships like price versus rooms and price versus ptratio, and assess multicollinearity risks in regression.

Discover how to visualize correlations with a masked heatmap using NumPy, Seaborn, and Matplotlib, interpret strength and direction, and discuss data type limits and pitfalls.

Learn to visualize relationships with scatter plots using matplotlib and seaborn, compute and display correlations like DIS versus NOX, customize with labels, transparency, and styling templates for clear density insights.

Learn to interpret correlations with continuous data, detect outliers that distort relationships with seaborn pairplots and lmplot, benchmark code in Jupyter, and apply multivariable regression to Boston housing data.

Train a multivariable regression model with 13 features to estimate house prices, using theta coefficients in a linear framework, and explore the origins of regression and regression to the mean.

Shuffle and split the data with train_test_split into X_train, X_test, y_train, y_test for an 80/20 split, using PRICE as the target and features from the rest.

Run a multivariable regression with scikit-learn, fit the model on training data, and interpret coefficient signs to show how crime, pollution, rooms, and CHAS affect property prices.

Compare training and test r-squared values to assess model fit, using the regression object's score method to show training data explains about 75% of variance in house prices.

Evaluate regression model results by examining statistics beyond r-squared, including p-values, the variance inflation factor, and the Bayesian information criterion, then refine, retrain, and deploy.

Transform price data with a log transformation to reduce skew and improve regression fit, and reverse the transformation to interpret coefficients in dollars.

Learn how to interpret regression coefficients and p-values to assess statistical significance using statsmodels and compare with scikit-learn, including feature significance and multicolinearity prep.

Learn how to test multicollinearity in regression with the variance inflation factor (VIF), interpret its results, and assess coefficient stability using thresholds around 10 (and 5) for decision making.

Explore how to simplify a regression model using Baysian information criterion to compare feature sets. Evaluate p-values, r-squared, and multicollinearity to keep significant features while reducing model complexity.

Analyze regression residuals to diagnose model assumptions by identifying patterns, outliers, or missing features, and aim for a random, zero-centered, symmetric residual cloud for reliable predictions.

Analyze residuals and actual vs predicted log prices using a transformed log prices model with Statsmodels, visualize residual plots, and assess correlation and outliers to refine predictions.

Link mean squared error, r-squared, and residuals in a multivariable regression with 11 features to predict house prices and compare models, illustrated with Zoopla and Zillow estimate ranges.

Compute the estimated price (y_hat) and a 95 percent prediction interval using RMSE and the standard deviation of residuals under a normal distribution.

Build a quick Boston property valuation tool as a Python module using regression theta and pandas and numpy ndarrays to predict prices from mean feature values into a 1x11 vector.

Build a Python-based valuation tool using scikit-learn's linear regression to estimate log prices, compute mean squared error and root mean squared error, and apply conditional feature configuration with prediction intervals.

This lecture teaches converting 1970s price estimates to today’s dollars with a scale factor from Zillow medians, and creating a Python module with docstrings and input validation.

Learn how to translate a business problem into a machine learning task by framing a spam filter as a text classification problem, preprocessing emails, training a classifier, and evaluating performance.

Source email data from the SpamAssassin public corpus, download archives, extract tar.bz2 or zip files on Mac or Windows, and view emails in a text editor like Atom or Notepad.

Organize and import lesson resources, including spam data, images, and fonts, by extracting archives correctly, verifying the folder structure in Jupyter, and avoiding nested directories for processing, training, and testing.

Discover the naive Bayes classifier for spam detection, driven by fast, simple probabilities of spam vs not spam, and visualize the decision boundary that classifies emails—built in Python.

Examine how basic probability underpins Naive Bayes decisions, deriving spam probability from observed frequencies of spam versus total emails.

Learn joint and conditional probability through coin flips, dice rolls, and independence concepts, then apply Bayes' theorem and Naive Bayes to classify email spam.

Apply Bayes theorem to reverse conditional probabilities and use the Naive Bayes classifier on text data, highlighting word frequencies, the bag of words approach, and independence assumptions for spam detection.

Master absolute and relative paths in Python, including file names and extensions. Navigate macOS and Windows paths, use forward slashes, and handle string escapes when reading files.

Learn to read files in Python using a stream, manage file paths with constants, and extract the email body by understanding headers and encoding.

Learn to extract the email body from a structured text file by iterating over lines, switching to body mode after a blank line, and joining lines into a readable body.

Learn to implement Python generator functions with yield to produce values one at a time, using os.walk and join to extract email bodies and build a dataframe.

Load all email bodies from spam and non-spam folders into a single dataframe, then concatenate to produce a 5800-row, 2-column dataset with filenames as the index and message bodies.

Clean data by checking for empty emails and null entries in the email dataframe, using isnull, length checks, and index lookup to locate and prepare clean data.

Learn to clean a dataframe by dropping unwanted rows with the drop function and reindexing with sequential document IDs. Add a DOC_ID column and preserve file names for email data.

Save your cleaned dataframe to a json file with pandas to_json, explore the json structure (category, message, file_name), and recognize json’s role in web data exchange.

Learn to create and customize pie charts and doughnut charts with matplotlib, using value_counts to compare spam vs ham, tune colors, explode wedges, and display percentages.

Learn to create a donut chart by adding a center circle with matplotlib, set radius and color (fc), adjust percent distance, and explode categories for four-category visuals.

Explore natural language processing (NLP) and prepare text for the naive bayes classifier by pre-processing emails: lowercase, tokenize, remove stop words, strip HTML, apply stemming, and remove punctuation using nltk.

Tokenize text with nltk's word_tokenize and convert to lowercase, then remove stop words using a Python set to boost naive Bayes and bag-of-words performance.

Explore word stems and stemming to unify inflected forms, using the porter stemmer (and snowball variants) and remove punctuation with isalpha for clean text preprocessing.

Remove html tags from emails using BeautifulSoup, parse with html.parser, and extract clean text for text analysis, preparing data for a bag-of-words classifier.

Create a Python text processing function for emails that lowers case, tokenizes, removes stopwords and punctuation, and stems words, with optional stemmer and HTML removal using BeautifulSoup, tested on sample emails.

Learn how to subset dataframes and series with at, iat, and iloc, then apply a cleaning function to all messages using pandas apply, with examples and performance notes.

Learn to slice dataframes with boolean conditions to create subsets, such as spam vs. ham by category, use loc for index-based subsetting, and explore word counts and top words.

Install third-party Python packages with conda using the conda-forge channel, then create word clouds to visualize word frequency in text data.

Create a word cloud from text data using the wordcloud package, fetch novels from NLTK Gutenberg resources, preprocess to a single string, and render with matplotlib, adjusting interpolation and axes.

Style a word cloud using a whale icon as a mask with Pillow, convert the mask to an rgb array, and tune background color, colormap, and max_words.

Generate a skull-shaped word cloud from Shakespeare Hamlet text using nltk and wordcloud, with an image mask and matplotlib display, and adjust max_words to reveal detail.

Style word clouds for ham and spam messages using thumbs up and thumbs down masks, with custom fonts and color maps, noting stemming effects before a Bayes' classifier.

Build a spam classifier vocabulary by selecting the 2500 most frequent stemmed words from cleaned emails, assign word IDs, and save as a CSV.

Convert the vocabulary of 2500 words to a set and use the in keyword for membership checks. Compare this with the inefficient any-based dataframe approach and test machine, data, app.

Identify the longest email by cleaning, stemming, and counting words, then locate its position and extract the original message from the dataframe.

Learn to prepare text data for a bayes classifier by creating a sparse feature matrix and splitting data into training and testing sets with 30% test size and seed 42.

Learn to build a sparse matrix from X_train and y_train using a vocab index, word IDs, and nested loops for data munging.

Convert X_test into a sparse matrix with make_sparse_matrix using word_index and y_test, then group into test_grouped by doc_id, word_id, and label, and save as test-data.txt with numpy savetxt.

Check preprocessing by comparing train and test doc IDs with Python sets; reveal missing emails due to encoding and HTML issues, and confirm data cleaned to token IDs.

Set up the notebook and load training and test data with NumPy loadtxt, explore delimiters, and inspect shapes and unique emails before transforming to a pandas dataframe.

Convert a sparse matrix into a full matrix by building an empty DataFrame, defining column and index names, and implementing a make_full_matrix function to populate occurrences.

Train the naive Bayes model by calculating token probabilities with Bayes' theorem, using total spam probability and token counts. Compute total tokens, spam and ham token counts, and email lengths.

Subset the training features to spam messages and sum token counts across columns, applying Laplace smoothing. Prepare ham totals and later compute the conditional probability of tokens in spam.

Calculate token probabilities for spam and non-spam emails with Laplace smoothing, generate all-token probabilities, and save the trained model to text files as checkpoints.

Prepare the test data by converting sparse test data into a full matrix using Make Full Matrix function, then save test features and target files and time the function call.

Set up the testing notebook to evaluate a Bayes classifier by loading test data, computing token and class probabilities, and visualizing results with matplotlib and seaborn.

Multiply conditional probabilities to obtain joint probability under independence, apply Bayes theorem to spam classifier, and use the dot product with x_test to handle many tokens.

Explore the prior in Bayesian statistics, expressing a belief about the spam rate and converting to log probabilities to simplify joint spam and non-spam calculations.

Make predictions by comparing the two joint probabilities for spam and ham with a Naive Bayes classifier, then apply a log-probability simplification that cancels p(x).

Assess spam email classification performance by computing accuracy, counting correct versus incorrect predictions, and interpreting the accuracy and fraction wrong in the metrics and evaluation of a naive Bayes model.

Visualize the classifier results by plotting the joint conditional probabilities for spam and non-spam, show the decision boundary, and compare matplotlib and seaborn visuals.

Assess why accuracy alone can mislead, and evaluate models with false positives and false negatives using a spam classifier example, highlighting true positives and the decision boundary.

Learn the recall score, or sensitivity, defined as true positives over true positives plus false negatives. See recall illustrated with spam detection, and note weaknesses in a Jupyter Notebook.

Learn precision, the true positives over true positives plus false positives, and how it complements recall, with emphasis on false positives, trade-offs, and its use in a naive Bayes model.

Compute and interpret the F1 score to balance precision and recall, using the harmonic mean to evaluate classifiers like spam filters and Naive Bayes.

Learn to implement a naive Bayes classifier with scikit-learn on a spam dataset, building a vocabulary with a count vectorizer, splitting data, training, and evaluating with precision, recall, and F1.

Explore how artificial neural networks draw inspiration from the human brain, where neurons fire by threshold and learning strengthens connections by adjusting weights, enabling tasks like image recognition.

Discover how neural networks learn by stacking layers that generate features, adjust weights through backpropagation, and transform simple patterns into high-level representations for both linear and nonlinear problems.

Examine the costs and disadvantages of neural networks, including data and compute demands, and promote using simpler models and free resources like Google Colab and pre-trained models.

Preprocess images in Google Colab using TensorFlow and Keras, convert images to 256 by 256 arrays with load_img and img_to_array, and understand red, green, and blue channels for neural networks.

Explore loading the inception resnet v2 model from keras applications with pre-trained ImageNet weights, and understand how TensorFlow graphs organize computations for classification tasks.

Use the Inception ResNet v2 model in Keras to make predictions, including expanding input with an extra dimension, resizing to 299x299, preprocessing the image, and decoding predictions.

Learn to use pretrained Keras models like VGG19 with proper preprocessing and decoding predictions, compare results with Inception ResNet and NasNet, and understand input data formats for image classification.

Build a from-scratch image classifier with Keras, training a multi-layer perceptron on your data to classify ten classes, from data collection to evaluation, inspired by a cucumber sorting story.

Install and run TensorFlow and Keras locally using conda, with Tensorboard support to monitor training, while optionally using Google Colab for GPUs, then launch Jupyter notebooks.

Learn to set up a Jupyter notebook, verify TensorFlow and Keras installations, and gather the CIFAR-10 dataset with keras.datasets, including reproducible seeds and loading train and test data.

Explore the cifar data by inspecting training images, labels, and class names; display images using ipython display and matplotlib, then begin preprocessing for neural networks with a 50k/10k split.

Scale image pixel values to 0–1 by dividing by 255, flatten images into 2D vectors, and create a validation set from training data to protect the test set.

Define a model in Keras, compile it with loss and optimization, then train it with data; this lesson covers a multi-layer perceptron with dense layers, relu activations, and softmax outputs.

Learn to compile a keras model by selecting Adam optimizer and a suitable loss such as sparse categorical cross entropy, monitor accuracy, and inspect model parameters with summary.

Set up tensorboard locally to visualize learning, track training progress, and compare keras model performance, while creating folders programmatically and building a reusable get_tensorboard function.

Train neural networks with Keras by using fit, callbacks, and TensorBoard to monitor training time, batch size, and epochs, while evaluating performance with validation data to prevent overfitting.

Learn how overfitting and underfitting affect model generalization, and how regularization, dropout, early stopping, and larger data help improve validation loss and accuracy.

Learn to generate image predictions with Keras, format inputs with NumPy, and evaluate model performance using probabilities, softmax, and metrics like accuracy, precision, recall, F-score, and confusion matrix.

Evaluate neural networks by comparing models using accuracy, recall, precision, and the F score through a detailed confusion matrix, with hands-on Tensorboard and Keras guidance.