MATLAB Machine Learning Recipes: A Problem-Solution Approach

Appendix A: A Brief History of Autonomous Learning

A.1 Introduction

In the first chapter of this book, you were introduced to autonomous learning. You saw that autonomous learning could be divided into the areas of machine learning, controls, and artificial intelligence (AI). In this appendix we will provide some background on how each area evolved. Automatic control predates artificial intelligence. However, we are interested in adaptive or learning control, which is a relatively new development and really began evolving around the time that artificial intelligence had its foundations. Machine learning is considered an offshoot of artificial intelligence. However, many of the methods used in machine learning came from different fields of study, such as statistics and optimization.

A.2 Artificial Intelligence

Artificial Intelligence research began shortly after World War II [ 22 ]. Early work was based on knowledge of the structure of the brain, propositional logic, and Turing’s theory of computation. Warren McCulloch and Walter Pitts created a mathematical formulation for neural networks based on threshold logic. This allowed neural network research to be split into two approaches. One centered on biological processes in the brain and the other on the application of neural networks to artificial intelligence. It was demonstrated that any function could be implemented through a set of such neurons and that a neural net could learn. In 1948, Weiner’s book, “Cybernetics,” was published, which described concepts in control, communications, and statistical signal processing. The next major step in neural networks was Hebb’s book in 1949, ”The Organization of Behavior,” connecting connectivity with learning in the brain. His book became a source of learning and adaptive systems. Marvin Minsky and Dean Edmonds built the first neural computer in 1950.

In 1956, Allen Newell and Herbert Simon designed a reasoning program, the Logic Theorist (LT), which worked non-numerically. The first version was hand simulated using index cards. It could prove mathematical theorems and even improve on human derivations. It solved 38 of the 52 theorems in Principia Mathematica. LT employed a search tree with heuristics to limit the search. LT was implemented on a computer using IPL, a programming language that led to Lisp, a programming language that is discussed below.

Blocks World was one of the first attempts to demonstrate general computer reasoning. The blocks world was a micro world. A set of blocks would sit on a table, some sitting on other blocks. The AI systems could rearrange blocks in certain ways. Blocks under other blocks could not be moved until the block on top was moved. This is not unlike the Towers of Hanoi problem. Blocks World was a spectacular advancement as it showed that a machine could reason at least in a limited environment. Blocks World was an early example of the use of machine vision. The computer had to process an image of Blocks World and determine what was a block and where they were located.

Blocks World and Newell’s and Simons’ LT was followed up by the General Problem Solver (GPS). It was designed to imitate human problem solving methods. Within its limited class of puzzles it could solve them much like a human. Although GPS solved simple problems such as the Towers of Hanoi, Figure A.1 , it could not solve real-world problems because the search was lost in a combinatorial explosion that represented the enumeration of all choices in a vast decision space.

Figure A.1

Towers of Hanoi. The disks must be moved from the first peg to the last without ever putting a bigger diameter disk on top of a smaller diameter disk.

In 1959, Herman Gelernter wrote the Geometry Theorem prover, which could prove theorems that were quite tricky. The first game-playing programs were written at this time. In 1958, John McCarthy invented the language Lisp (LISt Processing), which was to become the main AI language. It is now available as Scheme and Common Lisp. Lisp was introduced only one year after FORTRAN. A typical Lisp expression is:

(defun sqrt -iter (guess x)

( if (good-enough-p guess x)

guess

( sqrt -iter (improve guess x) x)))

This computes a square root through recursion. Eventually, dedicated Lisp machines were built, but they went out of favor when general purpose processors became faster.

Time sharing was invented at MIT to facilitate AI research. Professor McCarthy created a hypothetical computer program, Advice Taker, a complete AI system that could embody general world information. It would have used a formal language such as predicate calculus. For example, it could come up with a route to the airport from simple rules. Marvin Minsky arrived at MIT in 1958 and began working on micro-worlds. Within these limited domains AI could solve problems, such as closed-form integrals in calculus. Minsky wrote the book “Perceptrons” (with Seymour Papert), which was fundamental in the analysis of artificial neural networks. The book contributed to the movement toward symbolic processing in AI. The book noted that single neurons could not implement some logical functions such as exclusive-or and erroneously implied that multi-layer networks would have the same issue. It was later found that three-layer networks could implement such functions.

TIP

Three-layer networks are the minimum to solve most learning problems.

More challenging problems were tried in the 1960s. Limitations in the AI techniques became evident. The first language translation programs had mixed results. Trying to solve problems by working through massive numbers of possibilities (such as in chess) ran into computation problems. Human chess play has many forms. Some involve memorization of patterns, including openings where the board positions are well-defined and end games when the number of pieces is relatively low. Positional play involves seeing patterns on the board through the human brain’s ability to process patterns. Someone who is a good positional player will arrange her pieces on the board so that the other player’s options are restricted. Localized pattern recognition is seen in mate-in-n problems. Human approaches are not really used in computer chess. Computer chess programs have become very capable primarily because of faster processors and the ability to store openings and end games. Multi-layer neural networks were discovered in the 1960s, but not really studied until the 1980s.

In the 1970s, self-organizing maps using competitive learning were introduced [ 12 ]. A resurgence in neural networks happened in the 1980s. Knowledge-based systems were also introduced in the 1980s. From Jackson [ 14 ],

An expert system is a computer program that represents and reasons with knowledge of some specialized subject with a view to solving problems or giving advice.

This included expert systems that could store massive amounts of domain knowledge. These could also incorporate uncertainty in their processing. Expert systems are applied to medical diagnoses and other problems. Unlike AI techniques up to this time, expert systems could deal with problems of realistic complexity and attain high performance. They also explain their reasoning. This last feature is critical in their operational use. Sometimes these are called knowledge-based systems. A well-known open source expert system is CLIPS (C Language Integrated Production System).

Back propagation for neural networks was re-invented in the 1980s leading to renewed progress in this field. Studies began both of human neural networks (i.e., the human brain) and the creation of algorithms for effective computational neural networks. This eventually led to deep learning networks in machine learning applications.

Advances were made in the 1980s as AI researchers began to apply rigorous mathematical and statistical analysis to develop algorithms. Hidden Markov Models were applied to speech. A Hidden Markov Model is a model with unobserved (i.e., hidden) states. Combined with massive databases, they have resulted in vastly more robust speech recognition. Machine translation has also improved. Data mining, the first form of machine learning as it is known today, was developed. Chess programs improved initially through the use of specialized computers, such as IBM’s Deep Blue. With the increase in processing power, powerful chess programs that are better than most human players are now available on personal computers.

The Bayesian network formalism was invented to allow for the rigorous application of uncertainty in reasoning problems. In the late 1990s, intelligent agents were introduced. Search engines, bots, and web site aggregators are examples of intelligent agents used on the Internet. Figure A.2 gives a timeline of selected events in the history of autonomous systems.

Figure A.2

Artificial intelligence timeline.

Today, the state of the art in AI includes autonomous cars, speech recognition, planning and scheduling, game playing, robotics, and machine translation. All of these are based on AI technology. They are in constant use today. You can take a PDF document and translate it into any language using Google translate. The translations are not perfect. One certainly would not use them to translate literature.

Recent advances in AI include IBM’s Watson. Watson is a question-answering computing system with advanced natural language processing and information retrieval from massive databases. It defeated champion Jeopardy players in 2011. It is currently being applied to medical problems and many other complex problems.

A.3 Learning Control

Adaptive or intelligent control was motivated in the 1950s [ 2 ] by the problems of aircraft control. Control systems of that time worked very well for linear systems. Aircraft dynamics could be linearized about a particular speed. For example, a simple equation for total velocity in level flight is:

$\displaystyle \begin{aligned} m\frac{dv}{dt} = T - \frac{1}{2}\rho C_D S v^2 \end{aligned}$

(A.1)

This says the mass m times the change in velocity per time, $\frac {dv}{dt}$ , equals the thrust T , the force from the aircraft engine, minus the drag. C _D is the aerodynamic drag coefficient and S is the wetted area (i.e., the area that causes drag such as the wings and fuselage). The thrust is used for control. This is a nonlinear equation in velocity v because of the v ² term. We can linearize it around a particular velocity v _s so that v = v _δ + v _s and get:

$\displaystyle \begin{aligned} m\frac{dv_\delta }{dt} = T - \rho C_D S v_sv_\delta \end{aligned}$

(A.2)

This equation is linear in v _δ . We can control velocity with a simple thrust control law:

$\displaystyle \begin{aligned} T = T_s - c v_\delta \end{aligned}$

(A.3)

where $T_s = \frac {1}{2}\rho C_D S v_s^2$ . c is the damping coefficient. ρ is the atmospheric density and is a nonlinear function of altitude. For the linear control to work the control must be adaptive. If we want to guarantee a certain damping value, which is the quantity in parentheses:

$\displaystyle \begin{aligned} m\frac{dv_\delta }{dt} = - \left(c + \rho C_D S v_s\right)v_\delta \end{aligned}$

(A.4)

we need to know ρ , C _D , S , and v _s . This approach leads to a gain scheduling control system where we measure the flight condition – altitude, velocity – and schedule the linear gains based on the where the aircraft is in the gain schedule.

In the 1960s, progress was made on adaptive control. State Space theory was developed, which made it easier to design multi-loop control systems, that is, control systems that controlled more than one state at a time with different control loops. The general space controller is:

$\displaystyle \begin{aligned} \begin{array}{rcl} \dot{x} &\displaystyle =&\displaystyle Ax + Bu \end{array} \end{aligned}$

(A.5)

$\displaystyle \begin{aligned} \begin{array}{rcl} y &\displaystyle =&\displaystyle Cx + Du \end{array} \end{aligned}$

(A.6)

$\displaystyle \begin{aligned} \begin{array}{rcl} u &\displaystyle =&\displaystyle - Ky \end{array} \end{aligned}$

(A.7)

where A , B , C , and D are matrices, x is the state, y is the measurement, and u is the control input. A state is a quantity that changes with time that is needed to define what the system is doing. For a point mass that can only move in one direction, the position and velocity make up the two states. If A completely models the system and y contains all of the information about the state vector x , then this system is stable. Full state feedback would be x = − Kx , where K can be computed to have guaranteed phase and gain margins (that is, tolerance to delays and tolerance to amplification errors). This was a major advance in control theory. Before this, multi-loop systems had to be designed separately and combined very carefully.

Learning control and adaptive control were found to be realizable from a common framework. The Kalman Filter, also known as linear quadratic estimation, was introduced.

Spacecraft required autonomous control, since they were often out of contact with the ground or the time delays were too long for effective ground supervision. The first digital autopilots were on the Apollo spacecraft, which first flew in 1968 on Apollo 7. Don Eyles book [ 9 ] gives the history of the Lunar Module Digital Autopilot. Geosynchronous communications satellites were automated to the point where one operator could fly a dozen satellites.

Advances in system identification, the process of just determining parameters of a system (such as the drag coefficient above) were made. Adaptive control was applied to real problems. Autopilots have progressed from fairly simple mechanical pilot augmentation systems to sophisticated control systems than can takeoff, cruise, and land under computer control.

In the 1970s, proof of adaptive control stability was made. Stability of linear control systems was well established, but adaptive systems are inherently nonlinear. Universally stabilizing controllers were studied. Progress was made in the robustness of adaptive control. Robustness is the ability of a system to deal with changes in parameters that were assumed to be known, sometimes due to failures in the systems. It was in the 1970s that digital control became widespread, replacing traditional analog circuits composed of transistors and operational amplifiers.

Adaptive controllers started to appear commercially in the 1980s. Most modern single-loop controllers have some form of adaptation. Adaptive techniques were also found to be useful for tuning controllers.

More recently, there has been a melding of artificial intelligence and control. Expert systems have been proposed that determine what algorithms (not just parameters) to use depending on the environment. For example, during a winged reentry of a glider, the control system would use one system in orbit, a second at high altitudes, a third during high Mach (Mach is the ratio of the velocity to the speed of sound) flight, and a fourth at low Mach numbers and during landing. An F3D Skynight used the Automatic Carrier Landing System on 12 August 1957. This was the first shipboard test of the landing system designed to land aircraft on board autonomously. Naira Hovakimyan (U of IL U-C), and also Nahn Nguyen (NASA) were pioneers in this area. Adaptive control was demonstrated on sub-scale F-18s, which controlled and landed the aircraft after most of one wing was lost!

A.4 Machine Learning

Machine learning started as a branch of artificial intelligence. However, many techniques are much older. Thomas Bayes created Bayes theorem in 1763. Bayes theorem is:

$\displaystyle \begin{aligned} \begin{array}{rcl} P(A_i|B) = \frac{P(B|A_i)P(A_i)}{\sum P(B|A_i)} \\ P(A_i|B)= \frac{P(B|A_i)P(A_i)}{P(B)} \end{array} \end{aligned}$

(A.8)

which is just the probability of A _i given B . This assumes that P ( B )≠0. In the Bayesian interpretation, the theorem introduces the effect of evidence on belief. One technique, regression, was discovered by Legendre in 1805 and Gauss in 1809.

As noted in the section on artificial intelligence, modern machine learning began with data mining, which is the process of getting new insights from data. In the early days of AI, there was considerable work on machines learning from data. However, this lost favor and in the 1990s it was reinvented as the field of machine learning. The goal was to solve practical problems of pattern recognition using statistics. This was greatly aided by the massive amounts of data available online along with the tremendous increase in processing power available to developers. Machine learning is closely related to statistics.

In the early 1990s, Vapnik and co-workers invented a computationally powerful class of supervised learning networks known as support vector machines (SVMs). These networks could solve problems of pattern recognition, regression, and other machine learning problems.

A growing application of machine learning is autonomous driving. Autonomous driving makes use of all aspects of autonomous learning, including controls, artificial intelligence and machine learning. Machine vision is used in most systems as cameras are inexpensive and provide more information than lidar, radar or sonar (which are also useful). It isn’t possible to build really safe autonomous driving systems without learning through experience. Thus, designers of such systems put their cars on the roads and collect experiences that are used to fine tune the system.

Other applications include high-speed stock trading and algorithms to guide investments. These are under rapid development and are now available to the consumer. Data mining and machine learning are in use to predict events, both human and natural. Searches on the internet have been used to track disease outbreaks. If there are a lot of data, and the internet makes gathering massive data easy, then you can be sure that machine learning techniques are being applied to mine the data.

A.5 The Future

Autonomous learning in all its branches is undergoing rapid development today. Many of the technologies are used operationally even in low-cost consumer technology. Virtually every automobile company in the world, and many non-automotive companies, are working to perfect autonomous driving. Military organizations are extremely interested in artificial intelligence and machine learning. Combat aircraft today have systems to take over from the pilot to prevent planes from crashing to the ground.

Although completely autonomous systems are the goal in many areas, the meshing of human and machine intelligence is also an area of active research. Much AI research has been to study how the human mind works. In addition to improving performance by tapping into the extraordinary power of the brain, this work will also enable machine learning systems to mesh more seamlessly with human beings. This is critical for autonomous control involving people, but may also allow people to augment their own abilities.

This is an exciting time for machine learning! We hope that this book helps you to bring your own advances to machine learning!

Appendix B: Software for Machine Learning

B.1 Autonomous Learning Software

There are many sources for machine learning software. Machine learning encompasses both software to help the user learn from data and software that helps machines learn and adapt to their environment. This book gives you a sampling of software that you can use immediately. However, the software is not designed for industrial applications. This chapter describes software that is available for the MATLAB environment. Both professional and open source MATLAB software is discussed. The book may not cover every available package as new packages are continually becoming available and older packages may become obsolete.

The packages you select for your project depend on your goal and your level of software expertise. Many of the packages in this chapter are research tools that can be used to design, analyze, and improve various types of machine learning systems, but to turn them into deployable, production quality systems would require compiling, integrating and testing software that is custom developed for each application. Other packages, such as commercial expert system shells, can be deployed as your application. You’ll look for packages that are most compatible with your deployment environment. For example, if your goal is an embedded system, you will need development tools for the embedded processors and packages that are most compatible with that development environment.

This chapter includes software for what is conventionally called “machine learning.” These are the statistics functions that help to give us an insight into data. These are often used in the context of “big data.” It also includes descriptions of packages for other branches of autonomous learning systems, such as system identification. System identification is a branch of automatic control that learns about the systems under control, allowing for better and more precise control.

The chapter, for completeness, also covers popular software that is MATLAB-compatible, but requires extra steps to use it from within MATLAB. Examples include R, Python, and SNOPT. In all cases, it is straightforward to write MATLAB interfaces to these packages. Using MATLAB as a front end can be very helpful and allow you to create integrated packages that include MATLAB, Simulink, and the machine learning package of your choice.

You will note that we include optimization software. Optimization is a tool used as part of machine learning to find the best or “optimal” parameters. We use it in this book in our decision tree chapter.

Don’t be upset if we didn’t include your favorite package, or your package! We apologize in advance.

B.2 Commercial MATLAB Software

B.2.1 MathWorks Products

The MathWorks sells several packages for machine learning. These are in the Machine Learning branch of our taxonomy shown in Figure 1.3 . The MathWorks products provide high-quality algorithms for data analysis along with graphics tools to visualize the data. Visualization tools are a critical part of any machine learning system. They can be used for data acquisition, for example, for image recognition or as part of systems for autonomous control of vehicles, or for diagnosis and debugging during development. All of these packages can be integrated with each other and with other MATLAB functions to produce powerful systems for machine learning. The most applicable toolboxes that we will discuss are:

Statistics and Machine Learning Toolbox
Neural Network Toolbox
Computer Vision System Toolbox
System Identification Toolbox
MATLAB for Deep Learning
Fuzzy Logic Toolbox

B.2.1.1 Statistics and Machine Learning Toolbox

The Statistics and Machine Learning Toolbox provides data analytics methods for gathering trends and patterns from massive amounts of data. These methods do not require a model for analyzing the data. The toolbox functions can be broadly divided into Classification Tools, Regression Tools, and Clustering Tools.

Classification methods are used to place data into different categories. For example, data, in the form of an image, might be used to classify an image of an organ as having a tumor. Classification is used for handwriting recognition, credit scoring, and face identification. Classification methods include support vector machines (SVMs), decision trees and neural networks.

Regression methods let you build models from current data to predict future data. The models can then be updated as new data become available. If the data are only used once to create the model, then it is a batch method. A regression method that incorporates data as it becomes available is a recursive method. Clustering finds natural groupings in data. Object recognition is an application of clustering methods. For example, if you want to find a car in an image you look for data that are associated with the part of an image that is a car. Although cars are of different shapes and sizes, they have many features in common.

The toolbox has many functions to support these areas and many that do not fit neatly into these categories. The Statistics and Machine Learning Toolbox is an excellent place to start for professional tools that are seamlessly integrated into the MATLAB environment.

B.2.1.2 Neural Network Toolbox

The MATLAB Neural Network Toolbox is a comprehensive neural net toolbox that seamlessly integrates with MATLAB. The toolbox provides functions to create, train, and simulate neural networks. The toolbox includes convolutional neural networks and deep learning networks. Neural networks can be computationally intensive owing to the large numbers of nodes and associated weights, especially during training. The Neural Network Toolbox allows you to distribute computation across multicore processors and graphical processing units (GPUs) if you have the Parallel Computing Toolbox, another MATLAB add-on. You can extend this even further to a network cluster of computers using the MATLAB Distributed Computing Server™. As with all MATLAB products, the Neural Network Toolbox provides extensive graphics and visualization capabilities that make it easier to understand your results.

The Neural Network Toolbox is capable of handling large data sets. This could be gigabytes or terabytes of data. This makes it suitable for industrial strength problems and complex research. MATLAB also provides videos, webinars, and tutorials, including a full suite of resources for applying deep learning.

B.2.1.3 Computer Vision System Toolbox

The MATLAB Computer Vision System Toolbox provides functions for developing computer vision systems. The toolbox provides extensive support for video processing, but also includes functions for feature detection and extraction. It also supports 3D vision and can process information from stereo cameras. 3D motion detection is supported. This is particularly helpful if your inputs are from cameras.

B.2.1.4 System Identification Toolbox

The System Identification Toolbox provides MATLAB functions and Simulink blocks for constructing mathematical models of systems. You can identify transfer functions from input/output data and perform parameter identification for models. Both linear and nonlinear system identification is supported. This could be used as part of a control system. It is often helpful to divide your system into parts that can have equations as models and parts that can’t be modeled with equations. Your system can learn the parameters of the former part with the System Identification Toolbox.

B.2.1.5 MATLAB for Deep Learning

MATLAB for Deep Learning allows you to design, build, and visualize convolutional neural networks. You can easily implement models such as GoogLENet, VGG-16, VGG_19, AlexNet, and ResNet-59. It has extensive capabilities for visualization and debugging of neural networks. This is important to ensure that your system is behaving properly. It includes a number of pre-trained models. Deep Learning is a type of neural net. You can use this when the Neural Net Toolbox functions aren’t sufficient for your system. You can use both toolboxes together, along with all the other MATLAB toolboxes.

B.2.2 Princeton Satellite Systems Products

Several of our own commercial packages provide tools within the purview of autonomous learning.

B.2.2.1 Core Control Toolbox

The Core Control Toolbox provides the control and estimation functions of our Spacecraft Control Toolbox with general industrial dynamics examples, including robotics and chemical processing. The suite of Kalman Filter routines includes conventional filters, Extended Kalman Filters, and Unscented Kalman Filters. The Unscented Filters have a fast sigma point calculation algorithm. All of the Kalman Filters use a common code format with separate prediction and update functions. This allows the two steps to be used independently. The filters can handle multiple measurement sources that can be changed dynamically, with measurements arriving at different times.

Add-ons for the Core Control Toolbox include Imaging and Target Tracking modules. Imaging includes lens models, image processing, ray tracing, and image analysis tools.

B.2.2.2 Target Tracking

The Target Tracking module employs track-oriented multiple hypothesis testing. Track-oriented multiple hypothesis testing is a powerful technique for assigning measurements to tracks of objects when the number of objects is unknown or changing. It is absolutely essential for accurate tracking of multiple objects.

In many situations a sensor system must track multiple targets, like in rush hour traffic. This leads to the problem of associating measurements with objects, or tracks. This is a crucial element of any practical tracking system.

The track-oriented approach recomputes the hypotheses using the newly updated tracks after each scan of data is received. Rather than maintaining, and expanding, hypotheses from scan to scan, the track-oriented approach discards the hypotheses formed on scan k − 1. The tracks that survive pruning are propagated to the next scan k , where new tracks are formed, using the new observations, and reformed into hypotheses. The hypothesis formation step is formulated as a mixed integer linear program (MILP) and solved using a GLPK (GNU Linear Programming Kit). Except for the necessity to delete some tracks based upon low probability, no information is lost because the track scores that are maintained contain all the relevant statistical data. The MHT Module uses a powerful track-pruning algorithm that does the pruning in one step. Because of its speed, ad-hoc pruning methods are not required, leading to more robust and reliable results. The track management software is, as a consequence, quite simple.

All three Kalman Filters in the Core Toolbox, including Extended and Unscented, can be used independently or as part of the MHT system. The Unscented Kalman Filter automatically uses sigma points and does not require derivatives to be taken of the measurement functions or linearized versions of the measurement models.

Interactive multiple model systems (IMMs) can also be used as part of the MHT system. IMMs employ multiple dynamic models to facilitate tracking maneuvering objects. One model might involve maneuvering while another models constant motion. Measurements are assigned to all of the models. The IMMs are based on Jump Markovian Systems.

B.3 MATLAB Open Source Resources

MATLAB open source tools are a great resource for implementing state-of-the-art machine learning. Machine learning and convex optimization packages are available.

B.3.1 DeepLearnToolbox

The Deep Learn Toolbox by Rasmus Berg Palm is a MATLAB toolbox for Deep Learning. It includes Deep Belief Nets, Stacked Autoencoders, Convolutional Neural Nets, and other neural net functions. It is available through the MathWorks File Exchange.

B.3.2 Deep Neural Network

The Deep Neural Network by Masayuki Tanaka provides deep learning tools of deep belief networks of stacked restricted Boltzmann machines. It has functionality for both unsupervised and supervised learning. It is available through the MathWorks File Exchange.

B.3.3 MatConvNet

MatConvNet implements Convolutional Neural Networks for image processing. It includes a range of pre-trained networks for image processing functions. You can find it by searching on the name, or at the time of printing at http://www.vlfeat.org/matconvnet/ . This package is open source and is open to contributors.

B.4 Non- MATLAB Products for Machine Learning

There are many products, both open source and commercial, for machine learning. We cover some of the more popular open-source products. Both machine learning and convex optimization packages are discussed.

B.4.1 R

R is open-source software for statistical computing. It compiles on MacOS, UNIX, and Windows. It is similar to the Bell Labs S language developed by John Chambers and colleagues. It includes many statistical functions and graphics techniques.

You can use R in batch mode from MATLAB using the system command. Write

system( ’R␣CMD␣BATCH␣inputfile␣outputfile’);

This runs the code in inputfile and puts it into outputfile . You can then read the outputfile into MATLAB.

B.4.2 scikit-learn

scikit-learn is a machine learning library for use in Python. It includes a wide variety of tools including:

1.
Classification
2.
Regression
3.
Clustering
4.
Dimensionality reduction
5.
Model selection
6.
Preprocessing

scikit-learn is well suited to a wide variety of data mining and data analysis problems.

MATLAB supports the reference implementation of Python, CPython. Mac users and Linux users already have Python installed. Windows users need to install a distribution.

B.4.3 LIBSVM

LIBSVM [ 6 ] is a library for SVMs. It has an extensive collection of tools for SVMs, including extensions by many users of LIBSVM. LIBSVM Tools include distributed processing and multi-core extensions. The authors are Chih-Chung Chang and Chih-Jen Lin. You can find it at https://www.csie.ntu.edu.tw/~cjlin/libsvm/ .

B.5 Products for Optimization

Optimization tools often are used as part of machine learning systems. Optimizers minimize a cost given a set of constraints on the variables that are optimized. The maximum or minimum value for a variable is one type of constraint. Constraints and costs may be linear or nonlinear.

B.5.1 LOQO

LOQO [ 27 ] is a system for solving smooth constrained optimization problems, available from Princeton University. The problems can be linear or nonlinear, convex or nonconvex, constrained or unconstrained. The only real restriction is that the functions defining the problem be smooth (at the points evaluated by the algorithm). If the problem is convex, LOQO finds a globally optimal solution. Otherwise, it finds a locally optimal solution near to a given starting point.

Once you compile the mex-file interface to LOQO, you must pass it an initial guess and sparse matrices for the problem definition variables. You may also pass in a function handle to provide animation of the algorithm at each iteration of the solution.

B.5.2 SNOPT

SNOPT [ 10 ] is a software package for solving large-scale optimization problems (linear and nonlinear programs) hosted at the University of California, San Diego. It is especially effective for nonlinear problems whose functions and gradients are expensive to evaluate. The functions should be smooth but need not be convex. SNOPT is designed to take advantage of the sparsity of the Jacobian matrix, effectively reducing the size of the problem being solved. For optimal control problems, the Jacobian is very sparse because you have a matrix with rows and columns that span a large number of time points, but only adjacent time points can have nonzero entries.

SNOPT makes use of nonlinear function and gradient values. The solution obtained will be a local optimum (which may or may not be a global optimum). If some of the gradients are unknown, they will be estimated by finite differences. Infeasible problems are treated methodically via elastic bounds. SNOPT allows the nonlinear constraints to be violated and minimizes the sum of such violations. Efficiency is improved in large problems if only some of the variables are nonlinear, or if the number of active constraints is nearly equal to the number of variables.

B.5.3 GLPK

GLPK (GNU Linear Programming Kit) solves a variety of linear programming problems. It is part of the GNU project ( https://www.gnu.org/software/glpk/ ). The most well-known one is solving the linear program:

$\displaystyle \begin{aligned} \begin{array}{rcl} Ax = b \end{array} \end{aligned}$

(B.1)

$\displaystyle \begin{aligned} \begin{array}{rcl} y = cx \end{array} \end{aligned}$

(B.2)

where it is desired to find x , which, when it is multiplied by A , equals b . c is the cost vector, which, when multiplied by x , gives the scalar cost of applying x . If x is the same length as b the solution is:

$\displaystyle \begin{aligned} x = A^{-1}b \end{aligned}$

(B.3)

Otherwise, we can use GLPK to solve for x , which minimizes y . GLPK can solve this problem and others where one or more elements of x has to be an integer or even just 0 or 1.

B.5.4 CVX

CVX [ 4 ] is a MATLAB-based modeling system for convex optimization. CVX turns MATLAB into a modeling language, allowing constraints and objectives to be specified using standard MATLAB expression syntax.

In its default mode, CVX supports a particular approach to convex optimization that we call disciplined convex programming. Under this approach, convex functions and sets are built up from a small set of rules from convex analysis, starting from a base library of convex functions and sets. Constraints and objectives that are expressed using these rules are automatically transformed to a canonical form and solved. CVX can be used for free with solvers such as SeDuMi or with commercial solvers if a license is obtained from CVX Research.

B.5.5 SeDuMi

SeDuMi [ 25 ] is MATLAB software for optimization over second-order cones, currently hosted at Lehigh University. It can handle quadratic constraints. SeDuMi was used in Acikmese [ 1 ]. SeDuMi stands for Self-Dual-Minimization. It implements the self-dual embedding technique over self-dual homogeneous cones. This makes it possible to solve certain optimization problems in one phase. SeDuMi is available as part of YALMIP and as a standalone package.

B.5.6 YALMIP

YALMIP is free MATLAB software by Johan Lofberg that provides an easy-to-use interface to other solvers. It interprets constraints and can select the solver based on the constraints. SeDuMi and MATLAB’s fmincon from the Optimization Toolbox are available solvers.

B.6 Products for Expert Systems

There are dozens, if not hundreds, of expert system shells. For MATLAB users, the most useful shells are ones for which the C or C++ code is available. It is straightforward to write an interface in C using a .mex file. CLIPS is an expert system shell https://www.clipsrules.net/?q=AboutCLIPS . It stands for ’C’ Language Integrated Production System. It is a rule-based language for creating expert systems. It allows users to implement heuristic solutions easily. It has been used for many applications including:

An intelligent training system for space shuttle flight controllers
Applications of artificial intelligence to space shuttle mission control
PI-in-a-Box: A knowledge-based system for space science experimentation
The DRAIR Advisor: A knowledge-based system for materiel deficiency analysis
The Multi-mission VICAR Planner: Image processing for scientific data
IMPACT: Development and deployment experience of network event correlation applications
The NASA personnel security processing expert system
Expert system technology for nondestructive waste assay
Hybrid knowledge-based system for automatic classification of B-scan images from ultrasonic rail inspection
An expert system for recognition of facial actions and their intensity
Development of a hybrid knowledge-based system for multi-objective optimization of power distribution system operations

CLIPS is currently maintained by Gary Riley who has written the book, “Expert Systems: Principles and Programming,” now in its fourth edition. In the next section we will learn about .mex files to interface CLIPS, and other software, with MATLAB.

B.7 MATLAB MEX files

B.7.1 Problem

CLIPS needs to be connected to MATLAB.

B.7.2 Solution

The solution is to create a .mex file to interface MATLAB and CLIPS.

B.7.3 How It Works

Look at the file MEXTest.c. This is a C file with the accompanying header, .h, file.

// MEXTest.c

#include "MEXTest.h"

#include "mex.h"

void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )

{

// Check the arguments

if ( nrhs != 2 )

{

mexErrMsgTxt ("Two inputs required.");

}

if ( nlhs != 1 )

{

mexErrMsgTxt ("One output required.");

}

and MEXTest.h

// MEXTest.h

#ifndef MEXTest_h

#define MEXTest_h

#include <stdio.h>

#endif /* MEXTest_h */

You can edit these files in MATLAB or in any text editor.

Now type in the command line

>> mex MEXTest.c

Building with ’Xcode␣Clang++’.

MEX completed successfully.

mex just calls your development system’s compiler and linker. “XCode” is the MacOS development environment. “Clang” is a C/C++ compiler. You end up with the file MEXTest. mexmaci64 if you are using MacOS. Typing help MEXTest in the command window does not return anything. If you want help, add a file MEXTest.m such as:

function CLIPS

%% Help for the CLIPS.cpp file

If you try and run the function you will get:

>> MEXTest

Error using MEXTest

Two inputs required.

The CLIPS .mex file isn’t much more complicated. The CLIPS .mex file reads in a rules file and then takes inputs to which the rule is applied. The rule file is Rules.CLP and is:

(defrule troubleshoot-car

(wheel-turning no) (power yes) (torque-command yes)

(cbkFunction))

defrule defines a rule. cbkFunction is the call back function. It is called (also known as fired) if the rule troubleshoot-car is true. If all conditions are true it fires cbkFunction . You can write the rules file using any text editor. To run the .mex file you need to type:

>> mex CLIPS.c -lCLIPS

Building with ’Xcode␣Clang++’.

MEX completed successfully.

“-lCLIPS” loads the dynamics library libCLIPS.dylib . This dynamics library was built using XCode on the MacOS from CLIPS source code, which is a set of C files. Now you are ready to run the function. Type the facts into the command window:

>> facts = ’(wheel-turning␣no)␣(power␣yes)␣(torque-command␣yes)’

facts =

’(wheel-turning␣no)␣(power␣yes)␣(torque-command␣yes)’

To run the function, call CLIPS with this facts variable,

>> CLIPS(facts)

ans =

’Wheel␣failed’

Now see if it knows when the wheel is working. Change the first fact to “yes.”

>> facts = ’(wheel-turning␣yes)␣(power␣yes)␣(torque-command␣yes)’;

>> CLIPS(facts)

ans =

’Wheel␣working’

You can use this function to create any expert system by making a more elaborate rule base.

Bibliography

[1]
Behcet Acikmese and Scott R. Ploen. Convex Programming Approach to Powered Descent Guidance for Mars Landing. Journal of Guidance, Control, and Dynamics , 30(5):1353–1366, 2007. Crossref
[2]
K. J. Åström and B. Wittenmark. Adaptive Control, Second Edition . Addison-Wesley, 1995.
[3]
S.S. Blackman and R.F. Popoli. Design and Analysis of Modern Tracking Systems . Artech House, 1999.
[4]
S. Boyd. CVX: Matlab Software for Disciplined Convex Programming. http://cvxr.com/cvx/ , 2015.
[5]
A. E. Bryson Jr. Control of Spacecraft and Aircraft . Princeton, 1994. Crossref
[6]
Chih-Chung Chang and Chih-Jen Lin. LIBSVM – A Library for Support Vector Machines. https://www.csie.ntu.edu.tw/~cjlin/libsvm/ , 2015.
[7]
Ka Cheok et al. Fuzzy Logic-Based Smart Automatic Windshield Wiper. IEEE Control Systems , December 1996.
[8]
Corinna Cortes and Vladimir Vapnik. Support-Vector Networks. Machine Learning , 20:273–297, 1995. zbMATH
[9]
Don Eyles. Sunburst and Luminary: An Apollo Memoir . Fort Point Press, 2018.
[10]
Philip Gill, Walter Murray, and Michael Saunders. SNOPT 6.0 Description. http://www.sbsi-sol-optimize.com/asp/sol_products_snopt_desc.htm , 2013.
[11]
J. Grus. Data Science from Scratch . O’Reilly, 2015.
[12]
S. Haykin. Neural Networks . Prentice-Hall, 1999. zbMATH
[13]
Matthijs Hollemans. Convolutional Neural Networks on the iPhone with VGGNet. http://matthijshollemans.com/2016/08/30/vggnet-convolutional-neural-network-iphone/ , 2016.
[14]
P. Jackson. Introduction to Expert Systems, Third Edition . Addison-Wesley, 1999.
[15]
Byoung S. Kim and Anthony J. Calise. Nonlinear Flight Control Using Neural Networks. Journal of Guidance, Control, and Dynamics , 20(1):26–33, 1997. Crossref
[16]
J. B. Mueller. Design and Analysis of Optimal Ascent Trajectories for Stratospheric Airships . PhD thesis, University of Minnesota, 2013.
[17]
J. B. Mueller and G. J. Balas. Implementation and Testing of LPV Controllers for the F/A-18 System Research Aircraft. In Proceedings , number AIAA-2000- 4446. AIAA, August 2000.
[18]
Andrew Ng, Jiquan Ngiam, Chuan Yu Foo, Yifan Mai, Caroline Suen, Adam Coates, Andrew Maas, Awni Hannun, Brody Huval, Tao Wang, and Sameep Tandon. UFDL Tutorial. http://ufldl.stanford.edu/tutorial/ , 2016.
[19]
Nils J. Nilsson. Artificial Intelligence: A New Synthesis . Morgran Kaufmann Publishers, 1998. zbMATH
[20]
Sebastian Raschka. Python Machine Learning . [PACKT], 2015.
[21]
D. B. Reid. An Algorithm for Tracking Multiple Targets. IEEE Transactions on Automatic Control , AC=24(6):843–854, December 1979.
[22]
S. Russell and P. Norvig. Artificial Intelligence: A Modern Approach, Third Edition . Prentice-Hall, 2010. zbMATH
[23]
S. Sarkka. Lecture 3: Bayesian Optimal Filtering Equations and the Kalman Filter. Technical Report, Department of Biomedical Engineering and Computational Science, Aalto University School of Science, February 2011.
[24]
L. D. Stone, C. A. Barlow, and T. L. Corwin. Bayesian Multiple Target Tracking . Artech House, 1999.
[25]
Jos F. Sturm. Using SeDuMi 1.02, a MATLAB Toolbox for Optimization Over Symmetric Cones. http://sedumi.ie.lehigh.edu/wp-content/sedumi-downloads/usrguide.ps , 1998.
[26]
K Terano, Asai T., and M. Sugeno. Fuzzy Systems Theory and Its Applications . Academic Press, 1992.
[27]
R. J. Vanderbei. LOQO USERS MANUAL VERSION 4.05. http://www.princeton.edu/~rvdb/tex/loqo/loqo405.pdf , September 2013.
[28]
M. C. VanDyke, J. L. Schwartz, and C. D. Hall. Unscented Kalman Filtering for Spacecraft Attitude State and Parameter Estimation. Advances in Astronautical Sciences , 2005.
[29]
Matthew G. Villella. Nonlinear Modeling and Control of Automobiles with Dynamic Wheel-Road Friction and Wheel Torque Inputs . PhD thesis, Georgia Institute of Technology, April 2004.
[30]
Peggy S. Williams-Hayes. Flight Test Implementation of a Second Generation Intelligent Flight Control System. Technical Report NASA/TM-2005-213669, NASA Dryden Flight Research Center, November 2005.

Index

A

Adaptive control, 9

MRAC ( see Model Reference Adaptive Control (MRAC))

self tuning

modeling an oscillator, 110–111

tuning an oscillator, 112–116

ship steering, 126–130

spacecraft pointing, 130–133

square wave, 121–122

Artificial intelligence (AI)

back propagation, 319

Bayesian network, 320

Blocks World, 318

chess programs, 319, 320

Cybernetics, 317

definition of, 16

expert systems, 17

Google translate, 320

GPS, 318

Hidden Markov Models, 319–320

intelligent cars, 16–17

knowledge-based systems, 319

limitations, 319

Lisp, 318

LT, 317–318

military organizations, 323

neural networks, 317

timeline of, 320

time sharing, 318–319

Towers of Hanoi, 318

Automobile animation, 299–302

Automobile demo

car trajectories, 307

final tree, 309

radar measurement, 308

Automobile dynamics

planar model, 293–294

RungeKutta, 292

vehicle states, 292

wheel force and torque, 294–295

AutomobilePassing, 297–299

Automobile radar, 295–297

Automobile simulation

Kalman Filter, 303–306

snap shots, 302

Automobile target tracking, 306–309

Automobile 3D model, 300

Autonomous driving, 323

automobile animation, 299–302

automobile dynamics, 292–295

AutomobilePassing, 297–299

automobile radar, 295–297

automobile simulation and Kalman Filter, 303–306

technology, 16

Autonomous learning

AI, 317–320

categories of, 7–8

learning control, 320–322

machine learning, 322–323

software, 325–326

AutoRadar function, 296

B

Bayesian network, 17, 320

Bayes theorem, 322

Billiard ball Kalman filter, 274–279

Binary decision trees

autonomous learning taxonomy, 147

box data structure fields, 162

child boxes, 161

classification error, 156

ClassifierSet, 148–151

distinct values, 158

entropy, 156

FindOptimalAction, 159

fminbnd, 159

Gini impurity, 155, 156

homogeneity measure, 156–158

IG, 155

MATLAB function patch, 150

parent/child nodes, 159

PointInPolygon, 149

testing data, 148, 165–168

training, 160–162, 167–168

Blocks World, 318

C

Case-based expert systems

autonomous learning taxonomy, 311

building, 312–313

functions and scripts, 316

running

BuildExpertSystem, 314–316

CBREngine, 313

ExpertSystemDemo, 314

fprintf, 316

strcmpi, 313–314

catColorReducer, 34

Cat images

grayscale photographs, 211

ImageArray, 212–213

ScaleImage, 214–215

64x64 pixel, 213

Cell arrays, 20–21

Chapman–Kolmogorov equation, 83

Cholesky factorization, 102

C Language Integrated Production System (CLIPS), 319, 332–333

Classification tree, 13

Comma-Separated Lists, 20–21

Commercial software

MathWorks products, 326–328

PSS products, 328–329

Computer Vision System Toolbox, 327

ConnectNode, 51

Convolution process, 216

deep learning, 210

layers, 210

stages, 225

Core Control Toolbox, 328

CVX, 332

Cybernetics, 317

D

Damped oscillator, 114

Data mining, 323

Datastores

functions, 26

properties, 25

Data structures, 21–22

parameters, 30–33

Daylight detector, 171–173

Decision trees, 13–14

Deep learning, 14, 328

convolutional neural net, 210

neural net, 209

Deep Learn Toolbox, 329

Deep Neural Network, 329

Digits

CreateDigitImage function, 188–190

DigitTrainingData, 190–192

feed-forward neural network, 195

grayscale, conversion, 189

GUI, 192

MLFF neural network function, 193

multiple outputs

MAT-file, 206

multiple-digit neural net, 205–207

training data, 204

NeuralNetDeveloper tool, 192

NeuralNetMLFF, 196–197

NeuralNetTraining, 196

Neuron activation functions, 192–195

Poisson or shot noise, 188

SaveTS function, 190

single output node

default parula map, 200

Digit0FontsTS, 197–198

NeuralNetTrainer, 200

node weights, 202

RMSE, 198, 200

sigmoid function, 197

single digit training error, 200

testing, 202–203

DrawBinaryTree

cell array, 152

data structure, 151

DefaultDataStructure, 154

demo, 155

DrawBox, 152

lines, 153

patch function, 152

resize rows, 152–153

RGB numbers, 152

sprintf, 154

text function, 152

DrawNode, 51

dynamicExpression, 22

E

Euler integration, 94

Extended Kalman Filter (EKF), 92–97

F

Fact-gathering, 311–312

Fast Fourier Transform (FFT), 9, 35, 110

FFTEnergy, 112

Filter covariances, 278

Filter errors, 279, 287

Flexible Image Transport System (FITS), 23

F-16 model, aircraft, 237–238

FORTRAN, XVII, 318

Frequency spectrum, 114

without noise, 115

Function PlotSet, XVIII–XIX

Fuzzy logic

AND and OR, 141

BuildFuzzySystem, 137–138

Defuzzify, 142

description, 135

Fire, 141

Fuzzify, 140–141

MATLAB data structure, 136

membership functions, 138–139

set structure, 137

smart wipers

rain wetness and intensity, 144, 145

wiper speed and interval, 144

wiper speed and interval vs. droplet frequency and wetness, 145

G

Gaussian membership function, 138

General bell function, 138

General Problem Solver (GPS), 318

GNU Linear Programming Kit (GLPK), XIX, 328, 331

Google translate, 320

Graphical user interface (GUI), 45, 280

blank, 60

inspector, 61

snapshot

editing window, 62

simulation, 63, 64

GraphicConverter application, 214

Graphics

animation, bar chart, 63–67

building GUI, 58–63

custom two-dimensional diagrams, 50–51

general 2D, 48–49

three-dimensional box, 51–54

3D graphics, 56–58

3D object with texture, 54–56

2D line plots, 45–47

H

Hidden Markov Models (HMM), 82, 319–320

I, J

Images

display options, 24

formats, 23

functions, 25

information, 23–24

Inclined plane, 2

Information gain (IG), 155

Interactive multiple model systems (IMMs), 329

K

Kalman Filters, 8

automobile simulation, 303–306

Chapman–Kolmogorov equation, 83

Cholesky factorization, 102

derivation, 80

Euler integration, 94

extended, angle measurement, 97

family tree, 81

HMM, 82

implementation, 87

linear, 74–92

Monte Carlo methods, 80–81

noise matrix, 91, 92

normal/Gaussian random variable, 82

OscillatorDamping RatioSim, 76

OscillatorSim, 78

parameter estimation, UKF, 104–107

RHSOscillator, 78

Spring-mass-damper system, 75, 77, 79

state estimation

EKF, 92–97

linear, 74–92

UKF, 97–103

undamped natural frequency, 76

Kernel function, 15

Knowledge-based systems, 17, 319

L

Large MAT-files, 29

Learning control, aircraft, 320–322

dynamic pressure, 245

Kalman Filter, 247

least squares solution, 245

longitudinal dynamics, 261–264

neural net, 243

PID controller, 244

pinv function, 245

recursive learning algorithm, 246, 247

sigma-pi neural net, 243, 244

LIBSVM, 330

Linear Kalman Filter, 74–92

Linear regression, 12

Lisp, 318

Logic Theorist (LT), 317–318

Log-likelihood ratio, 269–270

Longitudinal control, aircraft, 231

differential equations, 235

drag polar, 233

dynamics symbols, 233–234

F-16 model, 237–238

learning approach, 232

longitudinal dynamics, 232, 233

Oswald efficiency factor, 234

RHSAircraft, 235–236

sigma-pi type network, 232–233

training algorithm, 233

LOQO, 331

M

Machine learning

AI, 322

autonomous driving, 323

Bayes theorem, 322

concept of learning, 4–6

data mining, 323

definition of, 2

elements

data, 2

models, 3

training, 3

examples, XVII

feedback control, 8–9

FORTRAN, XVII

SVMs, 323

taxonomy, 6–8

Mapreduce

datastore, 33–35

framework, 26

progress, 35

valueIterator class, 34

MatConvNet, 329

MAT-file function, 29

MathWorks products

Computer Vision System Toolbox, 327

Deep Learning, 328

Neural Network Toolbox, 327

Statistics and Machine Learning Toolbox, 326–327

System Identification Toolbox, 327

MATLAB toolbox

functions, XVIII

html help, XVIII

scripts, XVIII

Matrices, 19–20

Membership functions, fuzzy logic

Gaussian, 138

general bell, 138

sigmoidal, 138

trapezoid, 138

triangular, 138

MEX files, 333–335

Mixed integer linear program (MILP), 272

Model Reference Adaptive Control (MRAC)

implementation, 117–121

rotor, 123–125

Monte Carlo methods, 80–81

Multi-layer feed-forward (MLFF), 14, 193

Multiple hypothesis testing (MHT), 269

estimated states, 289

GUI, 283, 308

information window, 284

measurement and gates, 271

object states, 287, 289

testing parameters, 282

tree, 284

N

Nelder–Meade simplex, 229

Neural aircraft control

activation function, 242–243

Combination function, 248–249

equilibrium state, 238–240

learning control ( see Learning control, aircraft)

longitudinal dynamics simulation, 232

nonlinear simulation, 261–264

numerical simulation, 240–242

pitch angle, PID controller, 256–258

sigma-pi net neural function, 249–251

Neural networks/nets, 14–15

convolution layer, 217–218

daylight detector, 171–173

description, 171

fully connected layer, 220–222

image processing, 224

image recognition, 228–230

matrix convolution, 215–217

number recognition, 225–228

pendulum ( see Pendulum)

pitch dynamics, 258–261

pooling to outputs, 218–220

probability determination, 222–223

single neuron angle estimator, 177–181

testing, 223–225

training image generation, 211–215

Neural Network Toolbox, 327

New track measurements, 268

Nonlinear simulation, aircraft control, 261–264

Non-MATLAB products

LIBSVM, 330

R, 330

scikit-learn, 330

Normal/Gaussian random variable, 82

Numerics, 23

O

One-dimensional motion, MHT, 285–287

track association, 287–289

Online learning, 4

Open source resources

Deep Learn Toolbox, 329

Deep Neural Network, 329

MatConvNet, 329

Optimization tools

CVX, 332

GLPK, 331

LOQO, 331

SeDuMi, 332

SNOPT, 331

YALMIP, 332

OscillatorDamping RatioSim, 76–77

OscillatorSim, 78

P, Q

Parallel Computing Toolbox, 26, 33, 327

patch function, 50, 52, 54

Pattern recognition, 187

Pendulum

activation function, 183

dynamics, 173

linear equations, 175, 177

magnitude oscillation, 185–186

NeuralNetMLFF, 182–184

NeuralNetTraining, 182

NNPendulumDemo, 182

nonlinear equations, 177

PendulumSim, 176

RungeKutta integration, 174, 175

Taylor’s series expansion, 175

torque, 174

xDot, 176

Perceptrons, 319

Pitch angle, PID controller, 256–258

Pitch dynamics, 231

neural net, 258–261

Planar automobile dynamical model, 293

PlotSet function, 46, 47

plotXY function, 47

Pluto, 3D globe, 55

Princeton Satellite Systems (PSS) products

Core Control Toolbox, 328

Target Tracking, 328–329

Processing table data, 37–41

Proportional integral derivative (PID) controller

closed loop transfer function, 253

coding, 254–255

derivative operator, 253

design, 254

double integrator equations, 255

feedback controller, 252

nonlinear inversion controller, 258

pitch angle, 251, 256–258

recursive training, 252

R

R, 330

Recursive learning algorithm, 246, 247

Regression, 10–13

RHSAircraft, 240

RHSOscillator, 78

Riccati equation, 128

Root mean square error (RMSE), 198, 200, 205

Rotor, MRAC

gain convergence, 125

RungeKutta, 123–124

speed control, 117

SquareWave, 123

Rule-based expert systems, 311, 312

RungeKutta, 240

S

SCARA robot, 69, 70

scikit-learn, 330

Second-order system, 58, 59

SeDuMi, 332

Semi-supervised learning, 4

Ship steering

gains and rudder angle, 129

Gaussian white noise, 130

heading control, 126

parameters, 127

Riccati equation, 128–129

ShipSim, 127

Sigma-pi neural net function, 243, 244, 248–251

Sigmoidal membership function, 138

Sigmoid function, 242

Simple binary tree, 147–148

Simple machines, 2

Single neuron angle estimator

activation functions, 178–179

linear estimator, 177

OneNeuron, 180

tanh neuron output, 181

SNOPT, 331

Softmax function, 222

Software

autonomous learning, 325–326

commercial MATLAB, 326–329

expert systems, 332–333

MATLAB MEX files, 333–335

MATLAB open source resources, 329

non-MATLAB products, 329–330

optimization tools, 330–332

Solar flux, 172

Spacecraft model, 131

Spacecraft simulation, 133

Sparse matrices, 27, 28

sphere function, 55

Spring-mass-damper system, 75, 77, 79, 111

Spurious measurement, tracking, 267

Square wave, 122

Statistics and Machine Learning Toolbox, 326–327

Strings

arrays of, 41

concatenation, 41

substrings, 42

Supervised learning, 3

Support vector machines (SVMs), 15, 323

Synonym set, 211

System Identification Toolbox, 327

T

Table creation, FFTs, 35–37

Tables and categoricals, 27–28

TabularTextDatastore, 38–41

Tall arrays, 26–27

Target Tracking, 328–329

Towers of Hanoi, 318

Tracking

algorithm, 269–270

definition of, 265

hypothesis formation, 271–272

measurements, 269

assignment, 270–271

new track, 268

spurious, 267

valid, 268

problem, 268

track pruning, 272–273

Track-oriented multiple hypothesis testing (MHT), 17, 265, 266, 328

Trapezoid membership function, 138

Tree diagrams, graphics functions, 50

Triangular membership function, 138

Two by three bar chart, 65, 67

2D plot types, 48–49

U

Undamped natural frequency, 76

Unscented Kalman Filter (UKF), 8, 303

non-augmented Kalman Filter, 97–103

parameter estimation, 104–107

true and estimated states, 305

Unsupervised learning, 4

V, W, X

Valid measurements, tracking, 268

varargin, 30–32, 46

Y, Z

YALMIP, 332

Previous Chapter

14. Case-Based Expert Systems

Table of Contents for MATLAB Machine Learning Recipes: A Problem-Solution Approach

Index

A

B

C

D

E

F

G

H

I, J

K

L

M

N

O

P, Q

R

S

T

U

V, W, X

Y, Z

Table of Contents for
MATLAB Machine Learning Recipes: A Problem-Solution Approach