This chapter considers a set of algorithms for statistic pattern classification, including two simple classifiers based on nearest neighbors and minimum distances, and two more powerful methods of naïve Bayes and adaptive boosting (AdaBoost). The Bayes classifier is a typical generative method based on the assumption that in the training set all data points of the same class are samples from the same Gaussian distribution, and, it classifies any unlabeled data samples into one of the classes with the highest posterior probability of the class given the sample, proportional to the product of the likelihood and prior probability. Differently, the AdaBoost classifier is a typical boosting algorithm (ensemble learning) that iteratively improves a set of weak classifiers.

This chapter explores how logic programs can exploit linear logic. It provides several examples of specifying computations using linear logic, such as computing on collections of natural numbers and organizing simple theorem provers. It also illustrates how conventional program tasks, such as reversing a list or generating all permutations of a list, can be achieved in novel ways using linear logic programs. The chapter also demonstrates an alternative approach to specifying sequent calculus proof systems as logic programs. Bibliographic notes offer further references to the specification of logic programs.

This chapter discusses a two-layer competitive learning network for unsupervised clustering based on a competitive learning rule. The weights of each node of the output layer are treated as a vector, in the same space for the input vectors. Given an input, all nodes compete to become the sole winner (winner-take-all) with the highest output value, so that its weights can be modified in such a way that it will be more likely to win when the same input is presented to the input layer next time. By the end of this iterative learning process, each weight vector is gradually moved toward the center of one of the clusters in the space, thereby representing the cluster. The chapter further considers the self organizing map (SOM), a network based on the same competitive learning rule, but modified in such a way that nodes in the neighborhood of the winner learn along with the winner by modifying their weights as well but to a lesser extent. Once fully trained, the SOM achieves the effect that neighboring nodes learn to respond to similar inputs, mimicking a typical behavior of certain visual and auditory cortex in the brain.

This chapter first introduces a simple two-layer perceptron network based on some straight forward learning rule. This perceptron network can be used as a linear classifier capable of multiclass classification if the classes are linearly separable, which can be further generalized for nonlinear classification when the kernel method is introduced into the algorithm. The main algorithm discussed in this chapter is the multi-layer (3 or more) back propagation network which is a supervised method most widely used for classification, and also serves as one of the building blocks of the much more powerful deep learning method and other artificial intelligence methods. Based on the labeled sample in the training set, the weights of the back propagation network are sequentially modified in the training process in such a way that the error, the difference between the actual out and the desired outputs, the ground truth labeling of its input, is reduced by the gradient descent method. Based on the same training process, this network can be modified to serve as an autoencoder for dimensionality reduction, similar to what the PCA can do.

This chapter discusses the basic methods for solving unconstrained optimization problems, which plays an important role in ML, as many learning problems are solved by either maximizing or minimizing some objective function. The solution of an optimization problem, the point at which the given function is minimized, can be typically found by either gradient descent or Newton’s method. The gradient descent method approaches the solution iteratively from an initial guess by moving in the opposite direction of the gradient, while Newton’s method finds the solution based on the second order derivative as well as the first order, the gradient. It is therefore a more effective method than the gradient method due to the extra piece of information, with a higher computational cost for calculating the second order derivatives. In fact, Newton’s method for minimizing a function is essentially solving an equation resulting from setting the derivative of the function to zero, i.e., it is essentially the same method used for solving equations considered previously. The chapter also considers some variants of Newton’s method, including the quasi-Newton methods and the conjugate gradient method requiring fewer iteration steps.

This chapter considers some basic concepts of essentail importance in supervised learning, of which the fundamental task is to model the given dataset (training set) so that the model prediction matches the given data optimally in certain sense. As typically the form of the model is predetermined, the task of supervised learning is essentially to find the optimal parameters of the model in either of two ways: (a) the least squares estimation (LSE) method that minimizes the squared error between the model prediction and observed data, or (b) the maximum A posteriori (MAP) method that maximizes the posterior probability of the model parameters given the data is maximized. The chapter further considers some important issues including overfitting, underfitting, and bias-variance tradeoff, faced by all supervised learning methods based on noisy data, and then some specific methods to address such issues, including cross-validation, regularization, and ensemble learning.

This chapter focuses on using logic programming to formalize the operational semantics of programming languages. It illustrates this with examples such as the call-by-value lambda calculus and the pi-calculus. The chapter discusses how to encode transition systems in sequent calculus and abstract machines as binary logic programs. It explores using linear logic to add side-effects to evaluation and specify concurrency primitives. Bibliographic notes direct the reader to relevant literature on formal semantics and logic-based approaches to language specification.