Machine Learning For Engineering : A-Z

Explore optimization by framing global minima and maxima, distinguishing local minima, and comparing direct and indirect search methods with CMA-ES, greedy algorithms, and metaheuristic approaches like GRASP.

Apply the greedy randomized adaptive search procedure (grasp) to optimization problems by blending greedy and randomization, using seed, cost, neighborhood, and restricted candidate list components to avoid local minima.

Rename the notebook, import libraries, and build a dataset in x. Convert the data to a numpy array for use with machine learning libraries, and compare list versus array.

Build a ranking function for the grasp method by creating a rank array, filling it with data values and sequence locations, and sorting to produce a ranked order.

Apply local search to iteratively reverse subsequences of a candidate, evaluate each neighborhood with a cost function, and update the proposed sequence with the best seed solution.

Build the restricted candidate list for the grasp algorithm by seeding a random start, then extending the sequence greedily or randomly with a greediness value and ranking.

Explore restricted candidate list (RCL) methods in metaheuristics by ranking solutions, using an e-threshold to filter out poor options, then balance greediness and randomness to select top candidates.

Learn to implement the grasp main loop: build a restricted candidate list of 25, pick a random candidate, run local search, and update the best and unique good solutions.

Explore the job shop problem as an optimization task to schedule three jobs on three machines and minimize the total duration using Google OR-Tools and cp-sat.

Explore integer linear programming by maximizing an objective with integer decision variables under linear constraints, including mixed integer cases, solved graphically for production scheduling and planning.

Build a job shop optimization in a Jupyter notebook by defining data and variables, applying constraints, and using or-tools cp-sat to minimize total duration.

Define optimization variables with a CP model, using Python data structures (named tuples, dictionaries) to model tasks, start, end, and interval, and assign machines and jobs with enumerated IDs.

Define constraints for a job shop schedule by enforcing no overlapping on machines and ensuring each task starts after the previous task ends, using task and job IDs.

Define end-time variables for each job and task, compute the makespan as the maximum end time, and minimize this objective to solve the scheduling optimization.

Learn to solve a cp-sat scheduling model with two lines of code, check statuses, and print a machine-wide task schedule with start times and durations.

Explain the difference between supervised and unsupervised machine learning, show how labeled data enables classification and regression, and illustrate clustering, anomaly detection, and association mining.

Explore k-means clustering as an unsupervised method, apply it to time series using mean square error as the distance, and compare euclidean distance with dynamic time wrapping for accuracy.

Set up a k-means clustering workflow in a Jupyter notebook, import time, dynamic time wrapping, numpy, pandas, and matplotlib, and compute the dynamic time wrapping distance with time-series visualizations.

Import a csv time-series dataset with pandas, convert it to a numpy array of signals, inspect shape, and normalize by max to scale values from 0 to 1 for preprocessing.

Develop a component distance function to measure distance between two time series using mean squared error and dynamic time warping, testing first against second.

Seed centroids for k-means are chosen by randomly selecting time-series samples as initial centroids, via a centroids(data, clusters) function that returns these seeds.

implement a k-means function that iterates over data to assign elements to two clusters based on distance to centroids, update centroids by averaging assigned time series, and observe convergence.

Experiment with k-means clustering to measure runtime, plot centroids, and compare mean squared error versus dtw distance methods, fixing a centroid bug and noting speed differences.

Explore how to import and preprocess engine sensor data, analyze features, and predict the remaining useful life using train and test CSVs, with pandas and numpy workflows.

Analyze remaining useful life with histogram and distribution plots in seaborn. Describe mean, standard deviation, and percentiles with pandas; drop constant columns to prepare train and test features.

Calculate each engine's remaining useful life by finding the engine-specific maximum cycle, merging life data into the training set, and visualizing correlations with Seaborn and Pearson correlations.

Prepare data for machine learning by selecting input features from life in cycles to lrpt coolant bleed, define remaining useful life as the target, and normalize via min max scaler.

Explains k nearest neighbors regression, training with features like height and age, predicting weight, and evaluating with rmse and mean squared error.

Explore how a support vector machine classifies and regresses data by fitting a hyperplane, using a radial bias function kernel with gamma and C to optimize mean squared error.

Explore how random forest ensembles multiple decision trees to classify or predict outcomes from data features. Learn tuning hyperparameters such as estimators, max features, and depth in scikit-learn.

Train an agent to take actions in an environment to maximize rewards using reinforcement learning, covering state, action, transition, reward, Markov decision process, policy, Q-table, Bellman equation, and deep Q-networks.

Develop a reinforcement learning environment in a Jupyter notebook using OpenAI Gym interfaces to train a Q-table controller that keeps a room temperature between 24 and 26 with three actions.

Define q-table settings with a learning rate of 0.1, gamma discount, and 35000 episodes; use epsilon-greedy with starting epsilon 1, decaying after 5000 steps, and a 100x3 random q-table.

Build and update a q-table within a main loop using epsilon-greedy action selection, environment resets, and Parlman equation updates with learning rate and discount, while decaying epsilon over episodes.

Compare deep q-learning with proximity policy optimization for reinforcement learning, highlighting baselines, numpy array states, and 50,000-step training. Observe that proximity policy optimization outperforms deep q-learning in this setup.

Learn to transition from a Q-table to a deep Q-learning network by building a neural network in Keras, training with an epsilon-greedy policy on an OpenAI Gym environment.

Understand how deep learning builds neural networks with weights, biases, and activation functions. See how loss, gradient descent, and backpropagation tune these networks to extract patterns from data.

Learn how convolutional neural networks extract image features through convolution, padding, and max pooling, flattening, then classify with a fully connected network and softmax.

Preprocess data for a cnn by loading grayscale crack images, labeling them as negative or positive, resizing to a uniform size, and normalizing pixel values.

Build and train a cnn in keras using sequential, conv2d, max pooling, flatten, dense, dropout, and batch normalization; train with adam, 18 epochs, 0.25 validation, then save the trained model.

Load the trained model and run inference on grayscale images by resizing to the input shape and predicting crack versus no crack.

Leverage u-net for crack detection and segmentation by building an encoder-decoder with skip connections, preprocessing images and masks, and organizing training and test data in numpy arrays.

Demonstrates preprocessing for u-net segmentation, loading train and mask images, resizing and normalizing to 0–1, binarizing masks, and organizing x and y data for training and testing.

Declare a U-Net by copying a network, adjust input channels, implement contraction and expansion paths, then train with Keras using patch-based batches and a sigmoid output.

Analyze model results by predicting the test data, converting probabilities to binary predictions with a 0.5 threshold, and visually comparing predicted cracks against actual images.