Python and R for Machine Learning & Deep Learning

Install Python and Anaconda to get Python, Jupyter notebook, and data science libraries; use Python 3.7, choose Mac or Windows installers, and install VSCode for coding.

Learn to start a Jupyter notebook in Anaconda, create and run code cells, and switch between code, markdown, and raw formats using keyboard shortcuts to organize and document your work.

Master Python basics by practicing arithmetic operations—addition, subtraction, multiplication, division, modulus, and exponentiation—while learning operator precedence, parentheses, and variable assignment. Explore comparison operators to evaluate expressions.

Explore Python strings: define with quotes, assign to variables, and print with formatting. Learn length and replace, and master indexing and slicing with zero-based, negative indices, and steps.

Master Python basics with lists, including creation, indexing, slicing, stepping, range generation, and list operations like sort, append, insert, and remove, plus tuples and dictionaries.

Explore NumPy, pandas, and seaborn basics, including creating NumPy arrays and matrices, inspecting shapes and dtypes, indexing and slicing, and generating random data with arange and linspace.

Import pandas and load the customer data CSV to create a data frame, view the first rows with head, describe age statistics, and use iloc and loc with an index.

Master seaborn for data visualization by plotting histograms with distplot, adjusting kde, rug plots, and color, and exploring iris data with joint and pair plots.

Install R and R Studio, then follow a quick statistics crash course. Install R from r-project.org and R Studio from rstudio.com, using the four-window interface (script and console).

Master basics of R and R Studio by running commands, creating variables with the assignment operator, using vectors with c and 1:10, and managing the workspace with ls and rm.

Learn how to install and manage R packages, load and unload them with library and require, and access CRAN resources and package documentation for data science workflows.

Explore built-in data sets in R using the datasets package, view iris details (sepal length, sepal width, petal length, petal width, species), and load it into the workspace for analysis.

Learn manual data entry techniques in Python and R: assign values directly, build vectors with c(), create sequences with sequence(), and input values one by one with scan.

Import data from tab-separated text and comma-separated csv files into the workspace using read.table and read.csv, handling headers and delimiters.

Learn to create and customize bar plots in R to visualize region frequency distributions, including ordering, orientation, color, borders, titles, axis labels, and exporting plots.

Learn to create histograms in R using hist, adjust breaks to control buckets, and display frequencies for age categories with color and export options.

Identify data types and choose appropriate analyses by distinguishing qualitative (categorical) data into nominal and ordinal, and quantitative data into discrete and continuous.

Explore descriptive and inferential statistics, including mean, median, mode, range, standard deviation, bar charts, and histograms. Emphasize regression as the course's inferential focus.

Describe data distributions by creating frequency distribution tables for qualitative and quantitative data, then convert them into bar charts and histograms, highlighting relative frequency and the basics of normal distribution.

Learn mean (mu and x bar), median, mode, and mid-range as measures of center, and how symmetry and outliers affect their use.

Explore measures of dispersion by examining range, standard deviation, and variance. Learn how variance is the square of standard deviation, and how the range is affected by outliers.

Introduce machine learning as optimizing performance from past data, and distinguish supervised and unsupervised learning, with parametric and non-parametric models and key tasks like classification and regression.

Formulate the business problem as a statistical task, tidy and preprocess data, split into train and test sets, train and validate the model, and deploy a monitoring pipeline for predictions.

Gathering business knowledge in data pre-processing shows how understanding business context and stakeholders, via primary and secondary research, shapes variables, data quality, and model performance while addressing cart abandonment.

Identify data needed from research, request internal and external data, and perform quality checks. Integrate sources like marketing channels, cart abandonment data, and ratings to tidy data and define variables.

Explore a 506-observation, 19-variable house pricing dataset, where price is the dependent variable, and learn to join data from multiple sources with a data dictionary and primary keys.

Launch a Jupyter notebook via Anaconda, set working directory, and import the house price data with pandas read_csv, then inspect df.head and df.shape to confirm 506 observations and 19 variables.

Import the house pricing dataset from a CSV into the R workspace, assign it to df, then view and inspect its structure with str for 506 observations and 19 variables.

Examine univariate analysis by reviewing descriptive statistics for each variable, including mean, median, mode, and dispersion metrics like quartiles, and use the extended data dictionary to assess data quality.

Run df.describe to generate descriptive statistics and spot missing values and skew. Visualize relationships with seaborn joint plots and count plots for airport, water body, and bus terminal.

In edd in R, perform univariate analysis using summary, histograms, and bar plots to assess distribution, skewness, and outliers, then use scatter plots to inspect missing values and relationships.

Identify and treat outliers in data using box plots, scatter plots, and histograms; impute values with methods like capping at 99th percentile, extrapolation, or sigma-based replacement to improve prediction accuracy.

Identify and treat outliers in Python using percentile-based capping for n hot rooms and rainfall. Transform crime rate with log or square root to improve linearity.

Apply outlier treatment in r by capping n hot rooms at three times the 99th percentile and flooring rainfall at 0.3 times the first percentile, using quantile.

Learn how to handle missing data with imputation strategies including mean, median, and mode, segment-based means, or zero when appropriate, and when to remove rows, guided by business knowledge.

Identify missing values with df.info, then impute the n host beds column using fillna with its mean, updating the dataframe; apply column-wise fillna with mean for all columns if needed.

Impute missing values in R by replacing NA with the mean, computed with na.rm = TRUE, then assign the mean to the NA positions using is.na.

Explore seasonality in time-based data and how recurring patterns affect sales. Apply a multiplication correction factor, mean year divided by mean month, to normalize seasonal effects before modeling.

Examine bivariate analysis with scatter plots and correlation matrices to assess relationships between two variables, identify linear or non-linear patterns, and apply transformations to achieve linearity for regression.

Apply a log transform to crime rate after adding one to linearize its relation to price; create a feature from four distance variables and drop those columns and bus terminal.

Transform crime rate with log (1+crime rate) for a more linear relationship with price, and create an average distance from four distances while deleting individual distance variables and bus terminal.

Identify and remove non-informative variables such as single-value or heavily missing features, and decide when to impute or delete. Emphasize regulatory and business knowledge to keep only meaningful, refined variables.

Learn how to handle categorical variables in regression by creating dummy variables, using n minus one dummies with 0/1 coding to represent nominal categories.

Convert categorical variables into numerical features by creating dummy variables with pandas get_dummies, then drop airport_no and water_body_none to keep a single representation for each category.

Learn to convert categorical data to numeric in R using the dummies package, creating dummy variables for airport and water body categories, with one fewer dummy than categories for regression.

Explore correlation analysis with scatter plots and a correlation matrix, identify positive, negative, and zero relations, and understand the correlation coefficient (ranging -1 to 1) and multicollinearity without claiming causation.

Compute and read a correlation matrix in Python with df.corr, identify strong and weak relationships, and address multicollinearity by removing one of highly correlated pairs, like parks and air quality.

Compute a correlation matrix in R, round results to two decimals for readability, identify highly correlated variables to avoid multicollinearity, and remove parks in favor of air quality.

Explore linear regression as a foundational supervised learning approach, apply the least squares method to fit a linear model, and answer prediction and inferential questions on house prices.

Learn simple linear regression with one predictor, estimate beta zero and beta one via least squares, interpret residuals and RSS, and understand data preparation and model interpretation.

Assess the accuracy of sample regression coefficients using residual standard error, confidence intervals, and t tests to infer the population regression line and the relationship between house price and rooms.

Evaluate model accuracy using residual standard error and r square to quantify fit and variability. Use adjusted r square to account for predictors and compare explained variance.

learn to build a simple linear regression model in Python using Statsmodels and sklearn, including adding a constant, fitting, interpreting intercept and slope, and visualizing with Seaborn.

Learn to run a simple linear regression in R using lm, predicting house price from room num, interpret beta coefficients, p-values, and R-squared, and visualize with scatter plot and abline.

Extend linear regression to multiple linear regression with 16 predictors in house prices, interpreting each beta as the effect of a predictor while holding others fixed; report R-squared and p-values.

Explore how the F statistic tests whether all predictors jointly relate to the response, and why adjusting for multiple p-values matters in regression.

Interpret categorical variables in linear models by converting to dummy variables and inspecting betas and p-values, illustrated with airport and water body effects on house price.

Build a multiple linear regression model in Python using statsmodels and sklearn, select x variables excluding price, add a constant, and interpret coefficients, p-values, and R-squared to assess impact.

Master running a multiple linear regression in R with lm across all predictors, and interpret coefficients, p-values, R-squared, adjusted R-squared, and the F-statistic for model significance.

Understand how to split data into training and test sets, evaluate predictions with test mean squared error, and compare models using validation set, leave-one-out, and k-fold cross-validation.

Learn how to perform a test train split in Python using sklearn, train a linear regression model on 80/20 data, predict and compare r-squared scores for test and train.

Split data into training and test sets in R using CA tools, set a seed for reproducibility, train a linear model, and compare mean squared error on the two sets.

Explore regression models beyond ordinary least squares, using subset selection and shrinkage (regularization) to improve prediction accuracy and interpretability by excluding irrelevant variables.

Explore subset selection techniques for machine learning: best subset, forward and backward stepwise selection, compare M0–M3 models using adjusted r square or test set error, noting computation versus optimality.

Explore ridge and lasso shrinkage methods to regularize all predictors and reduce variance. Learn how the tuning parameter lambda balances bias and variance and improves model interpretability.

Learn to standardize data, apply ridge and lasso in Python with sklearn, and tune alpha via validation curves to improve r-squared on training and test sets.

Identify heteroscedasticity by plotting residuals against fitted values to detect non-constant error variance, then stabilize variance with log y or sqrt y transformations.

Train a ridge and lasso model in R using glmnet, select lambda via a cross-validated grid, and compare r squared to assess prediction accuracy.

Launch Jupyter Notebook, set the working directory, import numpy, pandas, and seaborn, and load the house price data from a csv using pandas read_csv, handling Windows paths.

Import the house pricing data from a CSV into R workspace using read.csv, assign it to df, and inspect with view df and str(df) showing 506 observations and 19 variables.

Explore three classifiers for predicting categorical outcomes, implement them in software, and evaluate model quality while distinguishing between prediction and inferential questions with a house sale example.

Explain why linear regression cannot handle classification with more than two levels, the need for dummy variables, and its unbounded predictions and outlier sensitivity, and why logistic regression overcomes them.

Learn how logistic regression models probabilities using the sigmoid function to classify credit defaults. Discover maximum likelihood estimation and how it handles outliers and boundary decisions for predicting defaults.

Learn to build a logistic regression model in Python using sklearn and statsmodels, with price as the predictor and sold as the target, and compare coefficients and summaries.

Train a logistic regression model with multiple predictors in R using the dot notation to include all independent variables and the sold variable, interpret coefficients, and evaluate p-values.

Shows a simple logistic regression with one predictor, estimating beta zero and beta one to compute p(y=1) and using p value to confirm price's non-zero effect.

Apply logistic regression with multiple predictors using maximum likelihood to estimate beta coefficients and predict probabilities, and explore multiclass extensions with linear discriminant analysis using R or Python.

Learn to train a logistic regression with multiple predictors in Python using sklearn and statsmodel, using x as all columns except sold and interpreting coefficients, intercept, and logit results.

Run logistic regression in R with multiple predictors using the dot notation to include all variables except the dependent, here sold, and interpret coefficients and p-values to identify significant predictors.

Learn how a confusion matrix compares model predictions to true values, distinguishing false positive (type one error) and false negative (type two error), and adjust thresholds for error costs.

Apply a threshold to logistic regression predictions to classify outcomes. Use a confusion matrix to measure true positives, false positives, true negatives, and false negatives.

Learn to interpret a confusion matrix and key performance metrics—precision, sensitivity, specificity, false positive rate, and ROC AUC—for evaluating classifier performance.

Learn to compute predicted probabilities with predict on a glm in R, convert them to class labels using a 0.5 threshold, and evaluate predictions with a confusion matrix.

Explore linear discriminant analysis and Bayes classifiers, learn how conditional probabilities with continuous predictors drive LDA decisions, and compare with logistic regression using confusion matrices.

Learn to train an LDA model in Python with sklearn, fit data, predict outcomes, and evaluate performance using a confusion matrix across four classes.

Learn to run a linear discriminant analysis in R using mass, build an LDA classifier, generate predictions, posterior probabilities, and confusion matrices, and compare with quadratic discriminant analysis.

Split data into training and test sets to evaluate accuracy on unseen data, using confusion matrices and validation set approach, leave one out cross validation, and k fold cross validation.

Split the data into train and test sets using train_test_split, train a logistic regression model on the training data, and evaluate accuracy and the confusion matrix on the test set.

Explore test-train split in R using the Ctools package, set.seed, and 80/20 sampling; train a logistic regression on the training set and evaluate with confusion matrix on the test set.

Explore the k nearest neighbors classifier, a non-parametric method that uses k to shape the decision boundary. Learn how standardizing variables and selecting an optimal k reduce test error.

Learn to standardize features with standard scaler, train a k-nearest neighbors model in Python, evaluate with confusion matrix and accuracy for k=1 and k=3.

Apply grid search to optimize KNN n_neighbors across 1 to 10, identify the best k (7) with GridSearchCV, then train and evaluate using accuracy and a confusion matrix.

learn to build a k nearest neighbors classifier in r using the class package, including preparing train and test predictors, standardizing with scale, and evaluating with a confusion matrix.

Explain how to interpret model results using p values and beta coefficients, compare logistic, LDA, and KNN classifiers, and assess accuracy via test-set confusion matrices.

Develop a classification workflow from data collection and preprocessing to training with logistic regression, LDA, and KNN, compare models with confusion matrices to select the best for prediction or interpretation.

Discover how decision trees split data into interpretable regions, learn regression and classification trees, and identify terms like root node, decision node, leaf, subtree, and parent-child relationships.

Explore how a regression tree uses top-down greedy recursive binary splitting to choose splits that minimize the residual sum of squares, creating regions with mean predictions.

Explore three stopping criteria to control decision tree growth and prevent overfitting: minimum observations to split a node, minimum observations per leaf, and maximum tree depth.

Import a movie dataset into Python using pandas read_csv, inspect with head and info, and prepare for missing values and dummy encoding of categorical variables.

Import a data set into R using read.csv, assign it to a data frame, and perform missing value imputation by replacing NA values with the mean before modeling.

Impute missing values in the time taken variable by replacing them with its mean, calculated from the data, using fillna with inplace to update the dataframe.

Learn to convert categorical variables to numeric by creating dummy variables in Python using pandas get_dummies for 3d_available and genre, with drop_first to yield n-1 columns.

Divide a dataframe into x (independent variables) and y (dependent collection) using df.loc to select all rows and all columns except collection, preview with head, and prepare for train-test split.

Learn how to perform a test-train split in Python using sklearn, reserve 20% of data for testing, 80% for training, and evaluate model performance on unseen data.

Split data into train and test in R using an 80/20 ratio with the CA tools package, and set a seed for reproducibility.

Import tree from sklearn and set a decision tree regressor with max_depth=3. Fit on Xtrain and Ytrain, then predict on Xtrain and Xtest to obtain y_train_pred and y_test_pred.

Learn to build and plot a regression tree in R with rpart and rpart.plot, train on movie data, predict box office on test set, and evaluate with mean squared error.

Calculate mean squared error and R square from predicted versus actual values, and compare train versus test data to interpret the 111 million MSE and 0.65 R square.

Plot a regression decision tree in Python by exporting the graph with export_graphviz. Install pi dot plus, convert the dot file to an image, and visualize leaf node averages.

Explore how pruning large decision trees reduces overfitting and improves test performance by using cost complexity pruning with an alpha parameter and cross validation to select the optimal subtree.

Learn how to prune a decision tree in Python using max_depth, min_samples_split, and min_samples_leaf, with sklearn's regressor, visualize with dot data, and assess with MSE and R-squared.

Grow a full regression tree in R using the R part library, then prune with the CP tuning parameter based on cross-validated error to improve test-set MSE and interpretability.

Explore ensemble methods, including bagging, random forest, and boosting, to reduce variance in regression and classification trees by averaging predictions from multiple bootstrapped training sets.

Learn bagging in Python with sklearn using a decision tree base estimator and 1000 bootstrap samples to improve accuracy, and evaluate results with a confusion matrix and accuracy score.

Explore bagging in R with the random forest package, using all predictors and bootstrapped data, and compare MSE to pruning and full trees to balance accuracy and interpretability.

Explore random forests, an ensemble method that decorrelates trees by random predictor subsets, with bagging as a special case and m guidelines: p/3 for regression, sqrt(p) for classification.

Learn to build a random forest classifier in Python with 1000 trees, max_features auto (sqrt(n)), train on Xtrain and Ytrain, evaluate with confusion matrix and accuracy, and compare to bagging.

Explore how to use grid search in Python to optimize a random forest classifier, automatically testing hyperparameters with GridSearchCV to find the best estimator based on accuracy.

Install and load the random forest package in R, build a random forest model with mtry derived from p/3, compare its MSE to bagging, and note its extension to classification.

Explore boosting techniques—gradient boosting, AdaBoost, and XGBoost—where trees grow sequentially to fit residuals, controlled by shrinkage, depth, and regularization to prevent overfitting.

Apply gradient boosting classifier in sklearn to train on Xtrain and Ytrain, predict Ytest, and assess accuracy, while tuning hyperparameters like estimator, max depth, subsample, maximum feature, and learning rate.

learn gradient boosting in r with the gbm package, set seed, configure distribution gaussian or bernoulli, and tune entries, interaction depth, and shrinkage; evaluate with mean squared error.

Learn AdaBoost in Python by configuring base estimators (default decision tree depth one or random forest), adjusting n_estimators and learning rate, training on Xtrain/Ytrain, and comparing accuracy scores.

Apply AdaBoosting in R with the Adabag package to train classification trees, convert the response to a factor, predict on test data, and assess accuracy via a confusion matrix.

Build an XGBoost classifier in Python and optimize hyperparameters with grid search and cross validation. Inspect feature importance and compare accuracy across models.

Develop an XGBoost model in R by preparing data as a d matrix and converting categoricals to dummy variables; tune nrounds, eta, and max_depth and assess with a confusion matrix.

Explore the evolution of support vector machines from the maximal margin classifier to the support vector classifier and SVM, including linear separability, non-linear boundaries, and multi-class extensions.

Understand the hyperplane as a separator in p-dimensional space for the maximal marginal classifier, using a line or plane to distinguish two classes with two predictors.

Identify the maximal margin hyperplane that separates a two-dimensional predictor space, using support vectors to determine the margin and classify observations into two classes.

Explore why the maximal margin classifier fails in real-world data due to non separable classes and sensitivity to new points, motivating a shift to the support vector classifier.

Explore how a soft margin support vector classifier maximizes the hyperplane with tolerable misclassifications within a budget, and how the cost parameter C, linked to cross-validation, balances margins and accuracy.

Explain how support vector classifiers address linear separability limits by using a cost parameter and some misclassification, then introduce kernel methods for non-linear boundaries via support vector machines.

Learn kernel based support vector machines with linear, polynomial, and radial kernels to form non-linear decision boundaries, and tune C and gamma via cross-validation.

Develop SVM models in Python by building regression and classification models, including radial and polynomial kernels, and optimize hyperparameters with grid search for best results.

Import and preprocess data in python by loading numpy, pandas, seaborn, and matplotlib, reading a csv with headers, and inspecting with head and info to address missing values and dummy variables.

Standardize the data with a standard scaler (or min max scaler) to transform X_train and X_test to mean zero and variance one, ensuring SVM distance calculations are scale-invariant.

Build an SVM regression model in Python using sklearn, selecting kernels and training with SVR. Evaluate performance with mean squared error and R square, and tune C for improvement.

Build a Python classification tree for binary outcomes like Star Trek Oscar: impute time taken with the mean, encode categoricals with get_dummies, and use an 80/20 train-test split.

Standardize the classification data with sklearn's standard scaler by fitting on X_train and transforming X_train and X_test, yielding X_train_standard and X_test_standard with zero mean and unit variance.

Train an SVM classification model with sklearn's SVC linear kernel after standardizing data; evaluate with accuracy and confusion matrix, inspect support vectors, and prep for grid search on C.

Explore hyperparameter tuning for a linear SVM with grid search in sklearn, testing C values, using GridSearchCV with cross-validation, and selecting the best model via best_params and best_estimator.

Train an SVM classifier with a polynomial kernel, tuning degree and the cost parameter C, fit on Xtrain and ytrain, predict on test data, and evaluate accuracy with grid search.

Train an SVM with an RBF kernel and set gamma and C, then evaluate on train and test data. Use grid search to optimize these parameters and report the accuracy.

Import and preview data in R with read_csv, using forward slashes and header = true, then impute missing values with the mean as part of data preprocessing.

Train a linear kernel SVM for classification in R, converting the dependent variable to a factor, scaling features, and evaluating with a confusion matrix and accuracy.

Tune the SVM hyperparameter C for a linear kernel using the tune function in e1071, evaluate with tenfold cross-validation, identify the best model, and validate predictions.

Train a support vector machine with a polynomial kernel, tune cost and degree via grid search and cross-validation, and compare results to a linear model using a confusion matrix.

Train a radial kernel SVM, tune its gamma and cost with cross-validated grid search, select the best model, and assess classification performance versus linear and polynomial kernels.

Train a regression SVM in R on a movie dataset, handling missing values, performing an 80/20 train-test split, and evaluating using mean squared error to compare linear and radial kernels.

Learn how neural networks infer rules from training data, building a multi-layer perceptron with perceptrons and sigmoid neurons, using forward and backward propagation and stochastic gradient descent in Python.

Explore the perceptron, the earliest artificial neuron, as it combines binary inputs with weights and a threshold to produce a binary output, illustrated by a shirt decision example.

Extend the perceptron to real-valued inputs and replace the step with a sigmoid activation, forming a logistic neuron that outputs between 0 and 1.

Create a simple perceptron classifier in Python using sklearn to distinguish iris setosa with petal length and width, train and evaluate accuracy; later, explore multi-layer perceptron with Keras.

Gradient descent shows how neural networks learn by adjusting weights and biases using forward and backward propagation and sigmoid activation to minimize prediction error.

Explore how gradient descent uses cross-entropy loss to minimize error by updating weights and biases through forward and backward propagation, guided by a learning rate.

Examine activation functions, including sigmoid, tanh, and ReLU, and their roles in boundaries and non-linearity; cover multiclass classification with softmax and compare gradient descent, stochastic vs mini-batch, epochs and iterations.

Explore common neural network hyperparameters for classification and regression, including input neurons, hidden layers, ReLU activation, and output layer activations (sigmoid, softmax) with cross-entropy and mean squared error.

Discover how Keras, a deep learning framework, defines and trains models with TensorFlow as the primary backend, while supporting CNTK and Theano, and enabling CPU or GPU processing.

Learn to build an image classifier in Python by installing and importing TensorFlow and Keras, importing and normalizing a dataset, and creating a neural network with Keras.

Build an image classifier using the fashion mnist dataset in keras, loading 70,000 28×28 grayscale images (60k train, 10k test), with 10 labeled categories and class name mappings.

Normalize 28x28 pixel intensities by dividing by 255.0 to scale to 0–1 for training, validation, and test sets. Split the data into 5,000 validation, 55,000 training, and 10,000 test observations.

Explore two methods to create and train neural networks in Keras: the sequential API for straightforward dense networks, and the functional API for complex architectures.

Build a Keras neural network with the sequential API to classify 28 by 28 images into ten categories, using 784 input features, two hidden ReLU layers, and a softmax output.

Compile the neural network with sparse categorical cross entropy, SGD, and accuracy, then fit on train and validation data, monitoring training and validation performance across epochs and history.

Evaluate the trained model on test data to obtain loss and accuracy, then predict class probabilities and labels for new samples using predict and predict_classes.

Build and train a regression neural network in Keras to predict house prices using the California housing dataset, featuring a two-hidden-layer architecture, standardization, and evaluation with MSE and MAE.

Explore using the functional API to build complex neural architectures, combining wide and deep paths with input, dense, and concat layers for flexible topologies.

Learn how to save and load Keras models in h5 format, and use callbacks like model checkpoint for epoch-by-epoch saving while applying early stopping to keep the best model.

Parse neural network hyperparameters, from hidden layers, neurons per layer, and activation function to learning rate, batch size, and epochs. Use early stopping and transfer learning to prevent overfitting.

Install and activate the Keras R package and the core Keras library with a TensorFlow backend. Learn CPU-based setup, optional GPU support, and how to prepare to build models.

Prepare the fashion mnist dataset, already split into train and test, normalize pixel values by 255, train a model on 60,000 train images, and evaluate accuracy on 10,000 test images.

Build and train a Keras v3 model with a validation set and partial training set, using a sequential 784-128-10 network and softmax, with SGD or RMSprop and sparse cross-entropy.

Evaluate model performance on training and test sets, compare 87% training accuracy to 85% test accuracy, discuss loss trends. Predict on the 10,000 test images with softmax predictions.

Learn to build a neural network in R without Keras, using the neural nets package with two hidden layers (3 and 2 neurons), and predict pass/fail from test data.

Learn to build a regression neural network using functional API for complex models, normalize data from the Boston housing dataset, and evaluate with train/test data.

Explore building complex neural networks with the functional api by concatenating input with hidden-layer outputs to form a deep and wide architecture in Keras for regression.

Save and restore neural networks by storing architecture, configuration, and weights in h5/hdf5 files, then load to recreate exact models; use callbacks including early stopping to save the best model.

Explore convolutional neural networks and their use in image recognition, focusing on groups of pixels, convolutional layers, and receptive fields to extract features.

Explore how stride shifts the convolutional window across pixels, shaping receptive fields, overlap, and the number of neurons in the upper layer, with stride two versus four.

Explain how stride and padding shape the receptive field and output in convolutional layers, contrasting valid padding with same (zero) padding and border handling.

Learn how convolutional filters transform image patches into feature maps by multiplying pixel values with filter weights, enabling multi-channel feature extraction and higher-level representations.

Explore how images use red, green, and blue channels with 0–255 pixel values to form color, while grayscale relies on a single channel.

Discover pooling layers in cnn architectures, learn how max and average pooling with no weights reduce computations, memory usage, and parameters by summarizing small receptive fields with stride two.

Build a CNN model in Python using fashion MNIST data, focusing on preprocessing: reshape 28x28 images to 28x28x1, normalize by 255, and split into training and validation sets.

Construct a cnn for 28x28x1 input with a 3x3 conv, valid padding and 32 filters, followed by 2x2 pooling, flatten, dense layers (300, 100), and a 10-class softmax output.

Train a CNN in Python with xtrain and ytrain, 30 epochs, 64 batch size, evaluate on test data achieving about 88% accuracy, compared to an ANN without any conv layer.

Compare pooling versus no pooling in CNN; pooling reduces parameters and execution time, with only slight accuracy loss.

build a convolutional neural network for fashion MNIST images by adding a convolutional layer with 32 filters and a pooling layer, feeding into the prior dense network.

Activate Keras, load Fashion MNIST, and split 60k training and 10k test grayscale 28 by 28 images with 0–9 labels, normalize by 255, and reshape for a single-channel CNN.

Create a sequential model with a 2d convolutional layer (32 filters, 3x3, input 28x28x1) followed by 2x2 max pooling, flatten, and dense layers to 10-class softmax with 1.6 million parameters.

Compile the model with SGD optimizer and sparse categorical cross entropy loss, then train with fit using 64-sized batches, 30 epochs, validation data, and early stopping to monitor accuracy.

Achieve near 92% training accuracy and 90% test accuracy after 30 epochs, with convolutional and pooling layers boosting convolutional neural network performance and suggesting gains from more training.

Compare pooling versus no pooling in a convolutional network: removing max pooling dramatically increases parameters and training time, showing how pooling keeps computational load under control in deeper networks.

Lead an end-to-end project to classify cats versus dogs with CNN. Use a 4000-image Kaggle subset with train/validation/test splits, data augmentation, and pre-trained architectures for binary classification accuracy above 90%.

Construct a cnn for cats and dogs by preprocessing images with keras image data generator, resizing to 150 by 150, and streaming from train and validation folders using directory flow.

Build and train a four-layer cnn for binary classification with increasing filters (32, 64, 128, 128), max pooling, and a 512-neuron dense layer on a 150x150 RGB input.

Train across 20 epochs and observe overfitting, as training accuracy climbs to 93% while validation remains around 73–74%, then plan data augmentation and retraining in the next lecture.

Launch an end-to-end cnn project by preprocessing cat and dog images, resizing to 150 by 150, normalizing to 0–1, and feeding 20-image batches via flow from directory for binary classification.

Build a four convolutional and four pooling layer cnn in R, with increasing filters up to 128 and a 512-neuron hidden layer, then compile with binary cross entropy and rmsprop.

Train the model using fit generator with a 20-image batch from train generator, set steps per epoch to 100 and epochs to 20, and validate with validation generator.

Run 20 epochs to achieve 93% training accuracy and 73.6% validation accuracy, highlighting overfitting after epoch 10–15. Save model in hdf5 and prepare to augment data to boost validation accuracy.

Augment training data with an image data generator applying rotation, shift, shear, zoom, and horizontal flip, using fill mode to handle new pixels.

Train a CNN in R with data augmentation using image data generator and callbacks, reaching 83–84% validation accuracy after 100 epochs, then apply pre-trained Keras models to cats versus dogs.

Apply image data generator-based pre-processing and a dropout layer to fight overfitting, generating augmented data with rotation, width/height shifts, shear, zoom, and horizontal flips from the training directory.

Develop a sequential Keras CNN with four conv layers, pooling, ReLU, and 50% dropout; apply data augmentation (shear, rotation, shifts, flips) and train with binary cross entropy and RMSprop.