Machine Learning Practical Workout | 8 Real-World Projects

Download and install the open source Anaconda distribution on Windows, Mac OS, or Linux, choose Python 3.7, and use the included Jupyter notebooks for data science and machine learning.

Discover how to use Jupyter Notebook, an open source web application for writing live code in cells with immediate results, supporting data cleaning, numerical simulation, and machine learning.

Learn to run Jupyter notebooks, create new notebooks, and distinguish code from markdown, using A, B, D shortcuts to insert or delete cells.

Predict dealership customers' purchasing power using age, annual salary, credit card debt, net worth. Build a neural network in keras, train with adam, load pandas csv, evaluate regression with scikit-learn.

Apply artificial neural networks to regression tasks predicting the car purchasing amount from customer features, using the regression line with slope and intercept and independent and dependent variables.

Learn the basics of artificial neural networks and how a multilayer perceptron learns in a feedforward network via inputs, weights, bias, activation, and training with ground truth and error signals.

Understand the single neuron model with inputs, weights, bias, and an activation function for binary classification, and explore training tiny neural networks in TensorFlow playground to see weight values.

Explore how neural networks train via forward propagation, back propagation, and gradient-based weight updates, using Adam and one-line Jupyter demonstrations to build intuition.

Build a multilayer perceptron by multiplying inputs by weights, adding biases, and applying activation functions to train a fully connected neural network with weight and bias matrices.

Build an artificial neural network to predict car purchase amount from customer features such as age, annual salary, debt, and net worth using synthetic data in a Jupyter notebook.

Import and explore the car purchasing dataset by loading a CSV with pandas, handle encoding, and visualize the data frame with numpy, matplotlib, and seaborn using head and tail.

Visualize and clean a dataset, use seaborn pairplot for visualization, create training and testing sets, drop irrelevant columns, and normalize inputs with min-max scaling to prepare for neural network training.

Train a fully connected neural network with scaled data using a train-test split to evaluate unseen data, then build with Keras sequential layers and a linear output.

Compile a neural network with the Adam optimizer and mean squared error, then fit on X_train and y_train, tuning epochs, batch size, and validation_split to reduce overfitting and improve generalization.

Explore model evaluation by visualizing training and validation loss over epochs with Matplotlib, interpret convergence, compare architectures, and generate predictions from a trained neural network.

Apply deep convolutional neural networks to classify cifar-10 images across ten categories. Learn 2d convolutions, pooling, augmentation, dropout, Keras, Adam optimizer, and evaluation with confusion matrices.

Train a deep neural network to classify cifar-10 images across ten classes. Split 60,000 colored 32 by 32 images into training and testing sets and explore convolutional networks.

Explore how convolutional neural networks apply relu activations, max pooling, and flattening to build feature maps, enabling generalization and classification with a fully connected network.

Boost convolutional neural network performance by adjusting feature detectors and using dropout, and interpret confusion matrices for true positives and false negatives with precision and recall.

Classify cifar-10 images with convolutional neural networks and use image augmentation, including rotation and brightness shifts, to improve training on 60,000 32×32 color images across 10 classes.

Learn to visualize image data by plotting a 15x15 grid of 32x32 color images with matplotlib, displaying each image alongside its corresponding label from the training data.

Convert images to float32 and normalize to 0-1, and one-hot encode labels into categories with to_categorical; prepare X_train, X_test, Y_train, Y_test for CNN training shape 32 by 32 by 3.

Train a CNN with a sequential Keras model, applying data normalization and one-hot encoding of labels, and monitor training with TensorBoard using the Adam optimizer.

Train a cnn model by compiling with categorical cross entropy, selecting an optimizer, and fitting on training data with batch size 32 and two epochs to monitor accuracy.

Evaluate the CNN model on testing data to report test accuracy, generate predictions, compare with ground truth, and visualize results with a confusion matrix.

Learn to save a trained CNN by creating or reusing a saved models directory, then export the model as an h5 file (keras cifar ten trained model) with its weights.

Explore applying data augmentation and image augmentation to retrain a cnn model with augmented data, using rotations, width shifts, flips, brightness changes, and a data generator for improved performance.

Forecast time series data with Facebook Prophet, modeling yearly, weekly, daily seasonality and holidays, using Seaborn visuals to study seasonality across years and months and plot future trends.

Predict Chicago crime rates using Facebook Prophet and a Chicago crime dataset from 2001 to 2017, through data import, exploration, visualization, and data preparation for forecasting.

Import data with pandas, numpy, seaborn, matplotlib, and facebook prophet, load three Chicago CSV files, handle bad lines, and concatenate into a single data frame for exploration and visualization.

Explore Chicago crime data through data cleaning, date-time conversion, and visualizations with seaborn. Analyze crime types, locations, and yearly, monthly, and quarterly trends to reveal seasonality.

Resample crime data monthly, reset the index, and rename columns to date and crime count, then convert to dz and y format to apply Facebook profit.

Apply Facebook Prophet to a crime rate dataset, fit the model, and forecast future values. Visualize the forecast with trend, seasonality, and bounds, exploring 365 days and 720-period projections.

Explore time series price prediction with Facebook Profit, focusing on seasonal data. Apply this to avocado prices, study yearly and monthly seasonality, and plot future trends.

Predict future avocado prices using time series from weekly 2018 retail data; load and prepare the data with pandas, numpy, and visualize with matplotlib and seaborn, then forecast with Prophet.

Explore an avocado dataset by loading, viewing head and tail, and sorting by date. Prepare data for time-series forecasting with Prophet using date and average price.

Prepare the avocado_profit_data_frame by renaming columns and train a forecasting model with fit to predict avocado prices. Generate a one-year forecast using make_future_dataframe, then predict and plot the results.

Select a region, subset avocado data by west, read csv, plot date versus average price, and train region-specific predictions to reveal price trends over time.

Make predictions for affogato prices in a specific region by renaming columns, fitting the model, forecasting 365 periods, and plotting forecast and its components to show the trend.

Explore Lenet convolutional neural networks to classify traffic signs for self-driving car decisions. Apply Keras to build deep networks, compare Sigmoid and Relu, and use cross-validation to prevent overfitting.

Explore how LeNet CNNs classify traffic signs into 43 classes using 32x32 images, convolutional layers, max pooling, and fully connected layers in Keras.

Load data for a 43-class traffic sign classifier using the Lynette network, create train, validation, and test splits, and examine shapes and overfitting with cross-validation.

Visualize images and their labels to verify image-label consistency across training, validation, and test sets. Use random samples with Matplotlib to inspect targets and prepare for data cleaning.

Learn to preprocess data by converting color images to grayscale, shuffling the training data, and normalizing pixel values to -1 to 1 for faster training.

Construct and train the Lynette network using convolution and pooling layers, flattening, and dense layers, achieving high accuracy on a 43-class classification task with Keras.

Evaluate a CNN model on a testing dataset never seen before, achieving 0.86 accuracy on 12,000 images and visualizing training and validation curves, a confusion matrix, and sample predictions.

Explore the intuition behind naive Bayes and apply it to build an SMS spam detector using NLP basics, tokenization, Countvectorizer, and a scikit-learn naive Bayes model.

Explore the intuition of the naive Bayes classifier, including prior, likelihood, and posterior probabilities, with a two-class retirement eligibility example using age and savings.

Review naive Bayes theory by deriving posterior probabilities from priors, likelihoods, and the marginal likelihood, using a blue-red example, and explain why features are treated as independent.

Train a naive bayes spam classifier to distinguish spam from ham using a real-world dataset, build training and testing splits, apply a count vectorizer, and evaluate model performance.

Visualize the email dataset by splitting into ham and spam, compare counts and percentages with seaborn, and outline training with a count vectorizer for sentiment analysis.

Learn to convert text to numeric features with CountVectorizer, using fit_transform and feature names to prepare spam/ham data for a Naive Bayes classifier.

Train a spam detector on 5700 samples with countvectorizer and multinomial naive bayes, transforming text into 37,000 features and evaluating predictions on testing data.

Train a naive Bayes classifier on spam and ham data using an 80/20 training-testing split. Prepare X and Y from a count vectorizer and fit the model with sklearn.

Evaluate a trained naive bayes classifier using confusion matrices and classification reports on training and testing data, then deploy this model to detect spam versus ham messages.

Explore the basics of natural language processing using Yelp reviews, applying nltk tokenization, CountVectorizer feature extraction, and a naive Bayes classifier with scikit-learn, while exploring likelihood and prior concepts.

Explore natural language processing on Yelp reviews, tokenize text and extract features with countvectorizer. Build a naive Bayes classifier in Python using scikit-learn, handling unbalanced data.

Learn the basics of natural language processing and build a text classifier to predict whether Yelp reviews indicate happiness, using countvectorizer and tf-idf, with data cleaning and model evaluation.

Import libraries and load the Yelp dataset, exploring a 10,000-row dataframe of text reviews and ratings. Use describe and info to assess quality before training in the next lecture.

Visualize the dataset by computing review length, plotting histograms, and analyzing star-based distributions to prepare for building training and testing data.

Visualize and compare review data by creating one-star and five-star data frames, computing length, mean, counts, and histograms, then merge for an unbalanced view and prep for NLP.

Explore the foundations of natural language processing and practice cleaning text by removing punctuation with string.punctuation, filtering characters, and joining them for later NLP steps like countvectorizer.

Remove stop words and punctuations using nltk and list comprehension to clean text. Lowercase words and retain key terms for analyzing English language data.

Learn how countvectorizer transforms text into a word-frequency matrix for feature extraction, illustrated with sample data and a manual versus code verification of the resulting sparse matrix.

Apply natural language processing to real-world data by cleaning Yelp reviews and converting them into a numeric matrix with CountVectorizer through a punctuation and stop words removal pipeline.

Apply count vectorizer to Yelp reviews via a cleaning pipeline that removes stop words and produces a text feature matrix for model training.

Train a multinomial Naive Bayes classifier on cleaned text using a count vectorizer; apply fit, transform, and predict, and discuss training versus testing data.

Divide the data into training and testing sets using an 80/20 split. Train a multinomial naive Bayes classifier on the training data and validate shapes.

Evaluate a naive bayes classifier using the classification report and confusion matrix, visualize results with Seaborn heatmaps, compare training and testing predictions, and report accuracy, precision, recall, and F1 score.

Explore tf-idf as an optional feature extraction technique for text data, understand term frequency and inverse document frequency, and assess its impact on model performance in real-world NLP projects.

Learn the basics of recommender systems and build a movie recommender from scratch using Python, focusing on item-based collaborative filtering theory and intuition, with practical data from pandas dataframes.

Build a practical movie recommender system from scratch. Compare user-based and item-based collaborative filtering to predict ratings and recommend similar items.

Explore a movie recommender system using item-based collaborative filtering on the Movie Lens dataset, from importing libraries and visualizing data to building recommendations for one movie sample and entire dataset.

Import pandas, numpy, seaborn, and matplotlib; load movie id titles and user ratings, merge them, drop the timestamp, and verify a dataset of 100,000 entries across columns including movie titles.

Visualize and analyze a movie ratings dataset by grouping data into title-based groups, applying describe to compute mean and count, and plotting histograms to reveal rating distributions.

Build an item-based collaborative filtering workflow by creating a user-movie rating matrix with a pivot table, computing correlations to Titanic (and Star Wars), and ranking recommendations by movie counts.

Build an item-based collaborative filter over the full dataset, compute movie correlations with Pearson, and develop a simple movie recommender system from user ratings.