SENSOR DATA PROCESSING

Abstract

A method and apparatus for processing data, the data including: a set of one or more system inputs; and a set of one or more system outputs; wherein each system output corresponds to a respective system input; each system input includes a plurality of data points, a first data point in the plurality and a second data point in the plurality being from a same raw data source, and the first data point being pre-processed using a different pre-processing method relative to a pre-processing method used to pre-process the second data point, the method including: for each of the first and second data points, inferring a value indicative of a significance of the pre-processing method used to pre-process that data point; wherein the inferring includes performing a machine learning algorithm on a given system input from the data and a further system input.

Description

FIELD OF THE INVENTION

The present invention relates to methods and apparatus for processing data.

BACKGROUND

In many fields, (for example the fields of threat detection, object detection, and classification) there is a need for the extraction, fusion, analysis, and visualisation of large sets of data.

In many situations, such large sets of data may comprise data sets from multiple heterogeneous data sources, i.e. data sources that are independent and that produce dissimilar data sets. Heterogeneous data sources may, for example, use different terminology, units of measurement, domains, scopes, and provide different data types (e.g. binary, discrete, categorical, interval, probabilistic, and linguistic data types).

A Relevance Vector Machine (RVM) is a machine learning technique that can be used to process large data sets and provide inferences at relatively low computational cost.

However, with the conventional RVM, a number of basis functions needs to be provided a priori. Thus, conventional RVM techniques tend to have limited flexibility. Typically the RVM is trained using a set of training data comprising inputs and corresponding outputs of a system. However, the conventional RVM tends to fail to adequately model the uncertainty about an output corresponding to an input that is ‘far away’ from the inputs in the set of training data.

SUMMARY OF THE INVENTION

In a first aspect, the present invention provides a method of processing data, the data comprising: a set of one or more system inputs, and a set of one or more system outputs, wherein each system output corresponds to a respective system input, each system input comprises a plurality of data points, a first data point in the plurality and a second data point in the plurality being from a same raw data source, and the first data point being pre-processed using a pre-processing method different from a pre-processing method used to pre-process the second data point, the method comprising: for each of the first and second data points, inferring a value indicative of a significance of the pre-processing method used to pre-process that data point, wherein the step of inferring comprises performing a machine learning algorithm on a given system input from the data and a further system input.

A data point may be a data feature extracted from raw data using a pre-processing method. A pre-processing method may be a feature extraction process.

Performing the machine learning algorithm may comprise implementing a regression technique.

Implementing the regression technique may comprise implementing a Gaussian Process.

Performing the machine learning algorithm may comprise: performing a kernel function on a given system input from the data and a further system input to provide kernelised data; and applying the regression technique to the kernelised data.

The kernel function may be a sum of further functions, each further function being a function of a data point of the given system input and a data point of the further system input.

The kernel function may be a product of further functions, each further function being a function of a data point of the given system input and a data point of the further system input.

Each further function may be a kernel function.

The further function performed on the first data point may be a different function from the further function performed on the second data point.

A kernel function may be a Squared Exponential kernel, a Nominal kernel or a Rank kernel.

The method may further comprise measuring the further system input.

In a further aspect, the present invention provides apparatus for processing data, the data comprising: a set of one or more system inputs; and a set of one or more system outputs; wherein each system output corresponds to a respective system input; each system input comprises a plurality of data points, a first data point in the plurality and a second data point in the plurality being from a same raw data source, and the first data point being pre-processed using a pre-processing method different from a pre-processing method used to pre-process the second data point, the apparatus comprising: one or more processors arranged: for each of the first and second data points, to infer a value indicative of a significance of the pre-processing method used to pre-process that data point; wherein inferring a value indicative of a significance comprises performing a machine learning algorithm on a given system input from the data and a further system input.

A data point may be a data feature extracted from raw data using a pre-processing method. A pre-processing method may be a feature extraction process.

In a further aspect, the present invention provides a program or plurality of programs arranged such that when executed by a computer system or one or more processors it/they cause the computer system or the one or more processors to operate in accordance with the method of any of the above aspects.

In a further aspect, the present invention provides a machine readable storage medium storing a program or at least one of the plurality of programs according to the above aspect.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic illustration (not to scale) of an example of a scenario in which an embodiment of an information fusion method is implemented;

FIG. 2 is a schematic illustration of sensors and a base station used in the scenario of FIG. 1;

FIG. 3 is a process flow chart showing certain steps of a method training a data fusion processor using a set of training data;

FIG. 4 is a process flow chart showing certain steps of process of inferring a predictive distribution for a measured output of the data fusion processor;

FIG. 5 is a process flow chart showing certain steps of the process of performing step s34 of the process of FIG. 4; and

FIG. 6 is a process flow chart showing certain steps of a method of processing new sensor data and identifying a most significant pre-processor and data source depending on that new sensor data.

DETAILED DESCRIPTION

FIG. 1 is a schematic illustration (not to scale) of an example of a scenario in which an embodiment of an information fusion method (described in more detail later below) is implemented.

In this example, a vehicle 2 is travelling along a road 4. The vehicle 2 is a land-based, manned vehicle.

In this example, as the vehicle 2 travels along the road 4, at some point in time the vehicle 2 will pass a check-point 6. In this scenario, the check-point 6 is a particular point on the road 4.

In this example, a visible-light detecting camera, hereinafter referred to as “the camera 8”, an acoustic sensor 10, and a human observer, hereinafter referred to as “the human 12”, are arranged to detect the presence of the vehicle 2 as it passes the check-point 6. In this example, the sensors (i.e. the camera 8, the acoustic sensor 10, and the human 12) are heterogeneous data sources. The terminology “heterogeneous” is used herein to refer to two or more data sources that are independent and that produce data that is dissimilar to the other data sources. For example, heterogeneous data sources may provide different terminology, data types, units of measurement, domains, scopes, and so on. Examples of different heterogeneous data types are binary, discrete, categorical, interval, probabilistic and linguistic data types.

In this scenario, the camera 8 captures images of the check-point 6. In this scenario, the images are captured at regular time intervals. The captured images are sent from the camera 8 to a base station 14. The images received by the base station 14 from the camera 8 are processed at the base station 14, as described in more detail later below with reference to FIGS. 2 to 6.

In this scenario, the acoustic sensor 10 captures sound from the proximity of the check-point 6. In this scenario, the sound recording of the check-point 6 is taken substantially continuously. The sound recording is sent from the acoustic sensor 10 to the base station 14 where it is processed, as described in more detail later below with reference to FIGS. 2 to 6.

In this scenario, the human 12 makes audio and visual observations of the check-point 6. In this scenario, the observations of the human 12 are taken at regular intervals. The observations are sent as text from the human 12 to the base station 14 where they are processed, as described in more detail later below with reference to FIGS. 2 to 6.

FIG. 2 is a schematic illustration of the sensors (i.e. the camera 8, the acoustic sensor 10, and the human 12), and the base station 14 used in this embodiment to implement information fusion method.

In this embodiment, the base station 14 comprises a first pre-processor 16, a second pre-processor 18, a third pre-processor 20, a fourth pre-processor 22, a processor for performing a data fusion method (hereinafter referred to as the “data fusion processor 24”), and a display 26.

In this embodiment, the first pre-processor 16 is connected to the camera 8. Also, the first pre-processor 16 is connected to the data fusion processor 24.

In this embodiment, in operation the first pre-processor 16 receives images of the check-point 6 from the camera 8. The first pre-processor 16 processes the received images. In particular, in this embodiment the first pre-processor 16 performs a conventional edge detection process on the received images. The processed images are then sent from the first pre-processor 16 to the data fusion processor 24.

In this embodiment, the second pre-processor 18 is connected to the camera 8. Also, the second pre-processor 18 is connected to the data fusion processor 24.

In this embodiment, in operation the second pre-processor 18 receives images of the check-point 6 from the camera 8. The second pre-processor 18 processes the received images. In particular, in this embodiment the second pre-processor 18 performs a conventional template matching process on the received images. The processed images are then sent from the second pre-processor 18 to the data fusion processor 24.

In this embodiment, the third pre-processor 20 is connected to the acoustic sensor 10. Also, the third pre-processor 20 is connected to the data fusion processor 24.

In this embodiment, in operation the third pre-processor 20 receives a sound recording of the check-point 6 from the acoustic sensor 10. The third pre-processor 20 processes the received sound recording. In particular, in this embodiment the third pre-processor 20 performs a conventional Fourier analysis of the sound waveform, e.g. to determine Fourier coefficients. The processed sound waveform is then sent from the third pre-processor 20 to the data fusion processor 24.

In this embodiment, the fourth pre-processor 22 receives an input from the human 12. Also, the fourth pre-processor 18 is connected to the data fusion processor 24.

In this embodiment, in operation the fourth pre-processor 22 receives the intelligence report (in the form of text) about the check-point 6 from the human 12. The fourth pre-processor 22 processes the received images. In particular, in this embodiment the fourth pre-processor 18 performs a conventional fixed field extraction process on the received text. The processed intelligence report is then sent from the fourth pre-processor 18 to the data fusion processor 24.

In this embodiment, in operation the data fusion processor 24 performs a data fusion process on the data received from the pre-processors 16, 18, 20, 22 as described in more detail later below with reference to FIGS. 4 to 6. The data received from by the data fusion processor 24 may be considered to be from a plurality of heterogeneous sources (i.e. the pre-processors 16, 18, 20, 22 may be considered to be heterogeneous data sources).

In this embodiment, prior to processing the data received from the sensors 8, 10, 12, the data fusion processor 24 is trained using a set of training data as described below with reference to FIG. 3. After the data fusion processor 24 has been trained using the training data, data received from the sensors 8, 10, 12 may be processed by the data fusion processor 24. The trained data fusion processor 24 processes received data by performing the data fusion process described in more detail later below with reference to FIGS. 4 to 6.

The data fusion processor 24 is connected to a display 26. An output from the data fusion processor 24 is sent from the data fusion processor 24 to the display 26 where it is displayed to an operator (not shown in the Figures).

The following information is useful for understanding the process of training the data fusion processor 24 (described in more detail later below with reference to FIG. 3), and a data fusion process (described in more detail later below with reference to FIGS. 4 to 6). These methods will be described in greater detail after the following information. Further information regarding Relevance Vector Machines (RVM) can be found in “Sparse Bayesian learning and the Relevance Vector Machine”, M. E. Tipping, Journal of Machine Research 1, pages 211-244, June 2001, which is incorporated herein by reference.

In this embodiment, a set of possible input vectors (i.e. vectors comprising input data points) for the data fusion processor is:

X={x ₁ , . . . , x _Q}

where: x₁, . . . , x_Q are input vectors for the data fusion processor 24.

In this embodiment, an input vector is a heterogeneous feature vector that that describes a scenario, e.g. the scenario of FIG. 1. Also, in this embodiment, an input vector is a concatenation of feature vectors from each of the data sources in the scenario.

In this embodiment, each input vector contains the same sequence of data types. This advantageously tends to facilitate the comparison of individual features of different input vectors, e.g. using distance measures tailored to the specific types of data

In this embodiment, each feature vector is complete and does not contain missing values.

In this embodiment, an input vector comprises inputs for the data fusion processor 24 corresponding to each of the pre-processors 16, 18, 20, 22.

Also, in this embodiment, each input vector has dimension M.

In this embodiment, a set of training input data X_tr⊂X is:

X _tr ={x _i}_i=1^N

where: N is the number of input vectors in the training dataset X_tr.

In this embodiment, each of the input vectors x_i in the training data X_tr corresponds to a measured (noisy) output t_i of the data fusion processor 24.

In this embodiment, the measured outputs t_i are Gaussian distributed with zero mean. In this embodiment, the measured outputs t_i are samples of the following non-linear model:

t _i =y(x_i)+ε_i

where: y is a function of x (i.e. y is an output function); and

ε is a noise component of the measurement (assumed to be Normally distributed with mean zero and standard deviation σ² in this embodiment).

In this embodiment, the output function t_i is a regressor over arbitrary functions of the input. However, in other embodiments the output function t_i is a different function. For example, the output can be mapped to a value in the range [0,1] via the sigmoid function. This tends to facilitate binary classification. In such an embodiment, the regressor function (i.e. the output function y) may be mapped onto, f, onto tε[0, 1] via the sigmoid function, g(y(x)):

$g\left(y\left(x\right)\right)=\frac{1}{1+\exp \left(-\mathrm{sy}\left(x\right)\right)}$

where s>0 is a sigmoid sensitivity. Also, the latent function may be defined so that it has a direct probabilistic interpretation, e.g. P(t=1|x)=g(y(x))

An advantage provided by the use of the sigmoid function in classification processes is that it tends to facilitate near stepwise changes in probability across class boundaries whilst implementing only smoothly varying functions in the latent space. Thus, relatively simple kernels (i.e. covariance functions) such as the squared-exponential function may be used (as described in more detail later below), without defining change-points or declaring kernel non-stationarities at the class boundaries.

Further information on the sigmoid function, its uses, and the extension of Gaussian Process regressors in classification processes can be found in “Gaussian Processes for Machine Learning”, C. E. Rasmussen and C. K. I. Williams, The MIT Press, 2006, which is incorporated herein by reference.

In this embodiment, the process of training the data processor 24 comprises learning, or inferring, parameters of the output function y(x).

In this embodiment, the output function y(x) is modelled as a Gaussian Process. Also, a covariance of the output function is a kernel value.

Gaussian Processes advantageously tend to provide a principled Bayesian approach to uncertainty. Furthermore, an intuitive interpretation on the kernel (i.e. the covariance of the output function) is provided.

A Gaussian Process is described by its mean and covariance function (kernel).

In this embodiment, the Gaussian process is for inferring/predicting an output distribution for new data samples. Also, the Gaussian Process is performed to infer a relevance indication for the data from the different pre-processors. In other embodiments, a different machine learning technique (e.g. a different regression technique such as a least-squares regression technique) is used instead of or in addition a Gaussian Process.

In this embodiment, the following equation holds:

$y\left(X_{\mathrm{tr}}\right)=N\left(0,\sum _{j=1}^Nw_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)\right)$

where:

$w={\left(w_1,\dots w_M\right)}^T$

is a vector of adjustable parameters, hereinafter referred to as “weights”. In this embodiment, the weights appear linearly. Also, in this embodiment, an objective of the training process, described in more detail later below with reference to FIG. 3, is to estimate “good” values of these weights; and

K_j is a kernel function. The set of kernel functions, in effect, provide a basis for the output function. The matrix K(X_tr,X_tr) denotes the joint prior distribution covariance of the function at inputs X_tr. In this embodiment, this covariance matrix has elements:

K(x_i,x_j)=Cov(y(x_i),y(x_j))

In this embodiment, there is one basis function (kernel function) corresponding to inputs from each of the pre-processors 16, 18, 20, 22. In this embodiment, these kernel functions are distinct (i.e. different from one another). In other words, a first kernel K₁ is applied to input vector features from the first pre-processor 16, a second kernel K₂ is applied to input vector features from the second pre-processor 18, a third kernel K₃ is applied to input vector features from the third pre-processor 20, and a fourth kernel K₄ is applied to input vector features from the fourth pre-processor 22. Also, the first second, third and fourth kernels are different from each other.

In this embodiment, each of the kernels K₁-K₄ is selected such that its type (e.g. categorical, semantic etc.) is dependent upon the type of features generated by the relevant respective pre-processor and the characteristics of space of those features (e.g. smooth, continuous etc.).

For example, X={x₁, . . . , x_Q} is a set of Q input vectors x_i for the data fusion processor 24. ρ_j(x_k) is the nth data point (or feature) of the kth input vector. Also, y(x_k) is a real valued output for the kth input vector. Then K_j is a kernel function for the nth feature. For example, a common kernel is the Squared-Exponential kernel:

$K_{\mathrm{SE}j}\left(x_s,x_t\right)={\mu }_j\exp \left(-\frac{{\left({\rho }_j\left(x_s\right)-{\rho }_j\left(x_t\right)\right)}^2}{L_j}\right)$

where L≧0 and μ≧0 are hyperparameters. These are called the input scale and the output scale respectively. They govern how correlated the output values are over neighbouring inputs. In this embodiment, the input scale L is learned from training data.

A further example of a kernel is the Nominal Kernel:

$K_{N_j}\left(x_s,x_t\right)={\mu }_j\exp \left(-\frac{I\left({\rho }_j\left(x_s\right),{\rho }_j\left(x_t\right)\right)}{L_j}\right)$

where I is an indicator function, i.e. I(A,B)=1 if A and B are the same, and I=0 otherwise.

A further example of a kernel is the Rank Kernel:

$K_{R_j}\left(x_s,x_t\right)={\mu }_j\exp \left(-\frac{M\left({\rho }_j\left(x_s\right),{\rho }_j\left(x_t\right)\right)}{L_j}\right)$

where, M is a rank distance (i.e. an absolute difference between the input rankings). In other words, for any ranked input A, R(A) indicates the rank of A within the rank order, and the rank distance is M(A, B)=|R(B)−R(A)|.

In this example, the kernel function is a nonlinear mapping from an input vector to the output function. In this example, L_j moderates the similarity between the features of the input vectors.

In general, if D_j(β_j(x_s),ρ_j(x_t)) is a measure of the dissimilarity between the input vectors x_s and x_t in feature space j then:

K _j(x_s,x_t)=G(D_j(ρ_j(x_s),ρ_j(x_t)))

given some conventional kernel G. Typically, K is a valid kernel provided that it induces a positive definite matrix over all x_s and x_t.

Examples of valid kernels are included in the paper “A survey of kernels for structured data”, T. Gärtner, 5(1):49-58, 2003, which is incorporated herein by reference. An example of a valid kernel is the squared exponential kernel.

As mentioned above, in this embodiment a kernel value is interpreted as a covariance. Also, an output function value is interpreted as a Gaussian Process. Thus, when an output function is generated from multiple features then:

$y\left(X_{\mathrm{tr}}\right)=N\left(0,\sum _{j=1}^Mw_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)\right)$

where w_j are the mixing coefficients or weights of a mixture of covariance matrices:

$K\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)=\sum _{j=1}^Mw_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right).$

In this embodiment, Kernels can be combined by addition (e.g. as in the above equation). However, in other embodiments, kernels may be combined in a different way. For example, in other embodiments kernels are combined by multiplication, i.e.:

$K\left(X_1,X_2\right)=\prod _{j=1}^M{K_j\left(X_1,X_2\right)}^{w_j^2}$

In general, a kernel sum tends to be particularly appropriate for combining disjunctive inputs for which different outputs are correlated if any element/features of the input features vectors, e.g. positional features, are close.

A kernel product tends to be more appropriate when outputs are correlated only if the entire input vectors, i.e. “scenarios” are close.

Kernels may also be combined to form kernels over entire feature vectors. For example, a feature kernel, K_x(x₁, x₂), measures the closeness of two feature vectors, x₁ and x₂. Firstly, appropriate kernels, K_i, are selected for each feature, ρ_i(x). Secondly, the individual kernels are combined, for example, using the product rule into a single feature vector kernel:

$K_x\left(x_1,x_2\right)=\prod _i^{}K_i\left({\rho }_i\left(x_1\right),{\rho }_i\left(x_2\right)\right)$

As mentioned above, in this embodiment the measured outputs t_i are samples of the linear model t_i(x_i)=y(x_i)+ε_i.

Thus, when the training data X_tr (i.e. a subset of all possible data X) are observed, the mean of the output function y over all data X is:

$\hat{y}\left(X\right)=\frac{\sum _{j=1}^Mw_j^2K_j\left(X,X_{\mathrm{tr}}\right)}{\sum _{j=1}^Mw_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)+{\sigma }^2I}t\left(X_{\mathrm{tr}}\right)$

Thus, writing the contribution to the output function from feature j as the basis function:

$\begin{array}{cc}{\hat{\phi }}_j\left(X\right)=\frac{w_jK_j\left(X,X_{\mathrm{tr}}\right)}{\sum _{j=1}^Mw_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)+{\sigma }^2I}t\left(X_{\mathrm{tr}}\right)\mathrm{Thus}\text{:}\hat{y}\left(X\right)=\sum _{j=1}^Mw_j{\hat{\phi }}_j\left(X\right)& \mathrm{Equation}1\end{array}$

As described in more detail later below, in this embodiment, the weights w_j can be set using an Expectation Maximisation (EM) algorithm, such as that described in “Sparse Bayesian learning and the Relevance Vector Machine”, M. E. Tipping, Journal of Machine Research 1, pages 211-244, June 2001.

In this embodiment, the weights w_j are Gaussian distributed,

$w_j~N\left(0,\frac{1}{{\alpha }_j}\right).$

Also, in this embodiment, an EM algorithm is implemented to find the most likely values for α given the measured data t(X_tr).

In this embodiment, the basis functions {circumflex over (φ)}_j are learned from the training data using the process described in more detail later below with reference to FIG. 3.

In this process, {circumflex over (φ)}_j is a function of the weights w_j. To accommodate this, the term {circumflex over (φ)}_j in Equation 1 above is evaluated using the following approximation (that uses the mean of the weights):

$\begin{array}{cc}{\hat{\phi }}_j\left(X\right)=\frac{{\mu }_jK_j\left(X,X_{\mathrm{tr}}\right)}{\sum _{j=1}^M{\mu }_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)+{\sigma }^2I}t\left(X_{\mathrm{tr}}\right)& \mathrm{Equation}2\end{array}$

In this embodiment, the posterior covariance of the weights tends to be advantageously small.

FIG. 3 is a process flow chart showing certain steps of a method training the data fusion processor 24 using a set of training data.

At step s2, a set of training data for the data fusion processor 24 is formed.

In this embodiment, the set of training data comprises the set of input vectors X_tr={x_i}_i=1^N and corresponding measured outputs {t_i}_i=1^N (which are used as labels for the input vectors in the training data). In this embodiment, each of the input vectors x_i has dimension M. Moreover, in this embodiment each input vector x_i comprises distinct inputs for the data fusion processor 24 corresponding to each of the pre-processors 16, 18, 20, 22.

At step s4, in the data fusion processor 24, each of the means of the weights w_j, i.e. each value of μ_j, for j=1, . . . , M, is initialised to a non-zero value.

At step s6, in the data fusion processor 24, each of the mixture weight precisions α_j for j=1, . . . , M, is initialised to small values.

At step s8, the training data {x_i,t_i}_i=1^N is input into the data fusion processor 24.

At step s10, using the input training data, the data fusion processor 24 determines the mixture kernel, i.e. the mixture of covariance matrices:

$K\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)=\sum _{j=1}^M{\mu }_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)$

where M is the number of features in the N input vectors (i.e. the dimension of each input vector).

In this embodiment, each of the features in an input vector for the data fusion processor 24 correspond to (i.e. are an output of) one of the pre-processors 16, 18, 20, 22.

Also, in this embodiment there is one kernel function for each of the pre-processors 16, 18, 20, 22.

In this embodiment, the kernel function corresponding to a particular pre-processor 16, 18, 20, 22 is applied to the input features of the input vector that correspond to that pre-processor.

For example, each input vector x_i comprises features from each of the pre-processors 16, 18, 20, 22, i.e.:

x _i=(a_i,b_i,c_i,d_i)

where:

• • a_i is the component of the input vector x_i from the first pre-processor 16;
  • b_i is the component of the input vector x_i from the second pre-processor 18;
  • c_i is the component of the input vector x_i from the third pre-processor 20; and
  • d_i is the component of the input vector x_i from the fourth pre-processor 22.

Then, in this example:

$\begin{array}{c}K\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)=\sum _{j=1}^a{\mu }_j^2K_1\left(a,a\right)+\sum _{j=a+1}^{a+b}{\mu }_j^2K_2\left(b,b\right)+\\ \sum _{j=a+b+1}^{a+b+c}{\mu }_j^2K_3\left(c,c\right)+\sum _{j=a+b+c+1}^{a+b+c+d=M}{\mu }_j^2K_4\left(d,d\right)\end{array}$

where:

• • K₁ is a kernel for applying to features of the input vector from the first pre-processor 16;
  • K₂ is a kernel for applying to features of the input vector from the second pre-processor 18;
  • K₃ is a kernel for applying to features of the input vector from the third pre-processor 20;
  • K₄ is a kernel for applying to features of the input vector from the fourth pre-processor 22;
  • a is a set of vectors a={a_i}_i=1^N, where a_i is a component of the input vector x_i from the first pre-processor 16. Each vector a_i has dimension a;
  • b is a set of vectors b={b_i}_i=1^N, where b_i is a component of the input vector x_i from the second pre-processor 18. Each vector b_i has dimension b;
  • c is a set of vectors c={c_i}_i=1^N, where c_i is a component of the input vector x_i from the third pre-processor 20. Each vector c_i has dimension c; and
  • d is a set of vectors d={d_i}_i=1^N, where d_i is a component of the input vector x_i from the fourth pre-processor 22. Each vector d_i has dimension d.

In this embodiment, the kernel functions K₁, K₂, K₃, and K₄ are each different and distinct from one another. However, in other embodiments two or more of these kernels are the same kernel function.

At step s12, using the input training data and the mixture kernel determined at step s10 above, the data fusion processor 24 determines the mixture means:

${\hat{\phi }}_j\left(X_{\mathrm{tr}}\right)=\frac{{\mu }_jK_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)}{\sum _{j=1}^M{\mu }_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)+{\sigma }^2I}t\left(X_{\mathrm{tr}}\right)$

At step s14, an N×M matrix Φ_tr is constructed from the determined mixture means:

Φ_tr=[{circumflex over (φ)}₁(X_tr), . . . , {circumflex over (φ)}_M(X_tr)]

At step s16, an M×M matrix A is constructed from mixture weight precisions α_j for j=1, . . . , M:

A=diag(α₁, . . . , α_M)

At step s18, using the matrix Φ constructed at step s14 above and the matrix A constructed at step s16 above, an M×M “weight covariance” matrix Σ is calculated. In this embodiment,

Σ=[Φ_tr^TΦ_tr/σ²+A]⁻¹

At step s20, using the matrix Φ_tr constructed at step s14 above and the matrix Σ constructed at step s18 above, a vector of weight means μ is calculated. In this embodiment,

μ=ΣΦ_tr^Tt(X_tr)/σ²

step s22, using the matrix Σ constructed at step s18 above and the mixture weight precisions α_j for j=1, . . . , M, defined at step s6 above, a vector γ is calculated. In this embodiment,

γ_j=1−α_jΣ_jj for j=1, . . . , M

At step s24, new values for the mixture weight precisions α_j for j=1, . . . , M are determined. The notation α_j^new will be used to denote the new values for the mixture weight precisions. In this embodiment,

α_j^new=γ_j/μ_j²

At step s24, it is determined whether the values for the mixture weight precision values have converged.

In this embodiment, if the difference between the new values for the mixture weight precisions and the previous values for the mixture weight precisions is below a pre-determined threshold, then it is determined that the mixture weight precisions have converged. Otherwise, it is determined that the mixture weight precisions have not converged

If, at step s24, it is determined that the mixture weight precisions have converged, the method of training the data fusion processor 24 using a set of training data ends. In this case, values for the mixture weight precisions α_j, and therefore distributions for the mixture weights w_j, have been determined.

However, if, at step s24, it is determined that the mixture weight precisions have not converged, the method proceeds to step s28.

At step s28, the values the mixture weight precisions are updated to be the new values for the mixture weight precisions α_j^new (determined at step s24).

After step s24, the method proceeds back to step s10, where the data fusion processor 24 determines the mixture kernel (using the vector of weight means calculated at step s20 above).

Thus, in this embodiment steps s10 to s28 are iterated (updating values for the mixture weight precisions and the weight means at each iteration) until the mixture weight precisions have converged.

Thus, a method training the data fusion processor 24 using a set of training data is provided.

The above described method training the data fusion processor 24 advantageously provides learned kernel parameters to be used by the data fusion processor 24 when processing actual test data from the sensors 8, 10, 12. Furthermore, relevant combinations of weights (i.e. which combinations of basis functions are relevant) for the training data set are also learnt. Furthermore, a mapping between the feature space (i.e. the space of the input vectors) and the target space (i.e. the space of the measured outputs of the data fusion processor 24) is learnt.

Once the data fusion processor 24 has been trained one or more data fusion processes may be performed.

In this embodiment, a data fusion process of inferring a predictive distribution for a measured output t_i from the data fusion processor 24 is performed. Also, in this embodiment, a data fusion process comprising processing new sensor data and identifying the most significant pre-processor and data source with respect to the measured output corresponding to the new data is performed.

The terminology “significant/relevant feature” is used herein to refer to the feature or features in an input vector that lead to the most accurate prediction of the output function. Also, the terminology “significant/relevant pre-processor” is used herein to refer to the pre-processor or pre-processors from which a significant/relevant feature is received by the data fusion processor 24. Also, the terminology “significant/relevant data source” is used herein to refer to a data source that is an input to a significant/relevant pre-processor or pre-processors.

The process of inferring a predictive distribution for a measured output of the data fusion processor 24 is described in more detail later below with reference to FIGS. 4 and 5.

The process of processing new sensor data and identifying a most significant pre-processor and data source is described in more detail later below with reference to FIG. 6.

FIG. 4 is a process flow chart showing certain steps of process of inferring a predictive distribution for a measured output t_i.

In this embodiment, the process of FIG. 4 comprises inferring the posterior output function y(X) over the set of all possible input data X.

At step s30, a posterior mean for the output function (i.e. a mean for the output function over all possible input data) is determined.

In this embodiment, the posterior mean of the output function (denoted ŷ(X)) is determined using Equation 1 and 2 above. In this embodiment the posterior mean for the output function is:

$\hat{y}\left(X\right)=\sum _{j=1}^Mw_j{\hat{\phi }}_j\left(X\right)$ $\mathrm{where}\text{:}$ ${\hat{\phi }}_j\left(X\right)=\frac{{\mu }_jK_j\left(X,X_{\mathrm{tr}}\right)}{\sum _{j=1}^M{\mu }_j^2K_j\left(X_{\mathrm{tr}},X_{\mathrm{tr}}\right)+{\sigma }^2I}t\left(X_{\mathrm{tr}}\right)$

At step s32, a posterior covariance for the output function (i.e. a covariance for the output function over all possible input data) is determined.

In this embodiment, the posterior covariance of the output function (denoted Cov(y(X))) is determined using a process described in more detail later below with reference to FIG. 5.

At step s34, a predictive distribution for a measured output corresponding to the new data is determined using the posterior mean and the posterior covariance for the output function determined at step s32 and s34 respectively.

In this embodiment, the predictive distribution for the measured output is:

t(X)˜N(ŷ(X),Cov(y(X)))

Thus, predictions about the output of the data fusion 24 that would be measured if the new data were to be measured (by the sensors 8, 10, 12) may be made.

FIG. 5 is a process flow chart showing certain steps of the process of determining the posterior covariance of the output function performed at step s34 above.

At step s40, a vector of stacked basis functions F is constructed.

In this embodiment, the vector F is:

$F=\left(\begin{array}{c}{\phi }_1\left(X\right)\\ ⋮\\ {\phi }_M\left(X\right)\end{array}\right)$

At step s42, an “observation matrix” H is constructed.

In this embodiment, the observation matrix H is:

H=[w ₁ C, . . . , w _M C]

Where w₁, . . . , w_M are the weights, and C is an N×M indicator matrix (i.e. C_ij=1 only if the ith observed/training input vector is identical to the nth inferred input vector, and is zero elsewhere).

At step s44, a prior covariance for the vector F is determined.

In this embodiment, the prior covariance (denoted Σ_I) is determined using the following formula:

${\sum }_I=\left(\begin{array}{ccc}{K}_1\left(X,X\right)& 0& \dots \\ ⋮& ⋮& ⋮\\ \dots & \dots & K_M\left(X,X\right)\end{array}\right)$

At step s46, using the Kalman Filter equations, a posterior mean for the vector F is determined. Further information on the Kalman Filter equations can be found in “Stochastic Models, Estimation, and Control”, Maybeck, P. S. (1979). Mathematics in Science and Engineering. 141-1. New York: Academic Press, which is incorporated herein by reference.

In this embodiment, the posterior mean (denoted {circumflex over (F)}) is determined using the following formula:

{circumflex over (F)}=Kt(X)

where K is a Kalman gain:

K=Σ _I H ^T [HΣ _I H ^T+σ²I]⁻¹

where I is an identity matrix.

At step s48, using the Kalman Filter equations, a posterior covariance for the vector F is determined.

In this embodiment, the posterior covariance (denoted P) is determined using the following formula:

P=(I−KH)Σ_I

At step s50, a matrix Φ=[{circumflex over (φ)}₁(X), . . . , {circumflex over (φ)}_M (X)] is constructed.

At step s52, a matrix Ω=[w₁I, . . . , w_MI] is constructed.

At step s54, the posterior covariance of the output function is approximated as:

Cov(y(X))=ΩPΩ^T+ΦΣ_IΦ^T

Thus, the process of determining the posterior covariance of the output function (step s34 of the process of FIG. 4) is provided.

FIG. 6 is a process flow chart showing certain steps of a method of processing new sensor data. In this embodiment, this method comprises identifying the most significant/relevant features in the input vector, identifying a most significant/relevant pre-processor, and identifying a most significant/relevant data source depending on that new sensor data.

At step s60, after the data fusion processor has been trained as described above with reference to FIG. 3, further data (from the camera 8, the acoustic sensor 10, and/or the human 12 that has been received at the base station 14 and processed by the relevant pre-processor 16, 18, 20, 22) is input into the data fusion processor 24. This data may be conveniently referred to as “new data” and denoted X_new. This new data is a vector in the set of possible input vectors X={x₁, . . . , x_Q}. Moreover, in this embodiment this new data is not a vector in the set of training input data X_tr.

A set comprising the new data and the training data is:

X*={X _new ,X _tr}

In this embodiment, the process of FIG. 6 comprises iteratively updating the values of the mixture weight precisions α_j using the new data X_new and making a decision regarding a most significant pre-processor and data source based on the updated values. The process of iteratively updating the mixture weight precisions in the method of FIG. 6 is similar to process of iteratively updating the mixture weight precisions in the method of FIG. 3. Thus, steps s62 to s80 of FIG. 6 are similar to steps s10 to s28 of FIG. 3.

At step s62, using the data set X*, the data fusion processor 24 determines the mixture kernel, i.e. the mixture of covariance matrices:

$K\left(X^{*},X^{*}\right)=\sum _{j=1}^M{\mu }_j^2K_j\left(X^{*},X^{*}\right)$

where M is the number of features in the N input vectors (i.e. the dimension of each input vector).

At step s64, using the data set X*and the mixture kernel determined at step s62 above, the data fusion processor 24 determines the mixture means:

${\hat{\phi }}_j\left(X^{*}\right)=\frac{{\mu }_jK_j\left(X^{*},X^{*}\right)}{\sum _{j=1}^M{\mu }_j^2K_j\left(X^{*},X^{*}\right)+{\sigma }^2I}t\left(X^{*}\right)$

In this embodiment, mixture mean parameters are learned during training.

At step s66, an N×M matrix Φ* is constructed from the determined mixture means:

Φ*=[{circumflex over (φ)}₁(X*), . . . , {circumflex over (φ)}_M(X*)]

At step s68, an M×M matrix A is constructed from the mixture weight precisions α_j for j=1, . . . , M, that result from performing the training process of FIG. 3 (i.e. the mixture weight precision values that the process of FIG. 3 converges to):

A=diag(α₁, . . . , α_M)

At step s70, using the matrix Φ* constructed at step s66 above and the matrix A constructed at step s68 above, an M×M “weight covariance” matrix Σ* is calculated. In this embodiment,

Σ*=[(Φ*)^TΦ*/σ²+A]⁻¹

At step s72, using the matrix Φ* constructed at step s66 above and the matrix Σ* constructed at step s70 above, a vector of weight means μ is calculated. In this embodiment,

μ=Σ*(Φ*)^Tt(X*)/σ²

At step s74, using the matrix Σ* constructed at step s70 above and the mixture weight precisions α_j for j=1, . . . , M, a vector γ is calculated. In this embodiment,

γ_j=1−α_jΣ*_jj for j=1, . . . , M

At step s76, new values for the mixture weight precisions α_j for j=1, . . . , M are determined. As described above, the notation αj^new is used to denote the new values for the mixture weight precisions. In this embodiment,

α_j^new=γ_j/μ_j²

At step s78, it is determined whether the values for the mixture weight precision values have converged.

In this embodiment, if the difference between the new values for the mixture weight precisions and the previous values for the mixture weight precisions is below a pre-determined threshold, then it is determined that the mixture weight precisions have converged. Otherwise, it is determined that the mixture weight precisions have not converged

If, at step s78, it is determined that the mixture weight precisions have not converged, the method of processing new sensor data and identifying a most significant pre-processor and data source proceeds to step s80.

However If, at step s78, it is determined that the mixture weight precisions have converged, the method proceeds to step s82.

At step s80, the values the mixture weight precisions are updated to be the new values for the mixture weight precisions α_j^new (determined at step s76).

After step s80, the method proceeds back to step s62, where the data fusion processor 24 determines the mixture kernel (using the vector of weight means μ calculated at step s72 above).

At step s82, after the values for the for the mixture weight precisions have converged, the one or more weights that have values larger than a pre-determined threshold value are identified.

For example, after updating the values of the for the mixture weight precisions using the new data X_new, a single weight w_p is identified as being above a pre-determined threshold value.

In embodiments, in which products of kernels are used, as the input/length scale of a kernel in the product increases (i.e. tends towards infinity), that kernel tends to become increasingly irrelevant. Thus, in these embodiments, length scales below a certain threshold are identified.

At step s84, the feature(s) in the input vectors that correspond to the one or more weights (or length scales) identified at step s82 above are identified. For example, the pth feature corresponds to the weight w_p. Thus, in this example, the pth feature is identified.

At step s86, the pre-processor(s) that generate identified feature(s) of the input vector (i.e. the pre-processor that provides the identified feature(s) to the data fusion processor 24) is identified.

At step s88, the data source(s) (i.e. one or more of the sensors 8, 10, 12) that provides data to the pre-processor identified at step s42 is identified.

For example, in this embodiment, if the first pre-processor 16 or the second pre-processor 18 is identified at step s86 above, the camera 8 is identified at step s88. Also, if the third pre-processor 20, the acoustic sensor 10 is identified at step s88. Also, if the fourth pre-processor 22, the human 12 is identified at step s88.

Thus, a method by which new sensor data is processed and the one or more pre-processors and data sources that is most significant with respect to the output of the data fusion processor is provided.

Thus, the method by which new sensor data is processed, described above with reference to FIG. 6, tends to provide that a one or more significant/relevant pre-processors and/or corresponding data sources can be identified. Data from these identified pre-processor and data sources tends to produce the most accurate predictions of the output function.

This automatic identification of significant/relevant pre-processors and/or data sources tends to facilitate the detection irrelevant data. Such irrelevant data may be excluded so as to increase the accuracy of the predictions of the output function.

The identification of relevant, or irrelevant, input features tends to be particularly important when performing a classification process (e.g. when classifying a state for a scenario using heterogeneous data measured for that scenario). Uncertainty tends to be increased if irrelevant features are included in an input feature vector. For example, different feature values for irrelevant features may increase the distance between, otherwise close, feature vectors.

Also, excluding relevant features tends to increase uncertainty. For example, subtle distinctions between classes may be lost if relevant data is excluded.

The identification of relevant features in an input/feature vector is a result of the method by which new sensor data is processed by the data fusion processor 24, which is described above with reference to FIG. 6.

As described in more detail in “Bayesian Learning for Neural Networks”, R. M. Neal, ser. Lecture Notes in Statistics 118, New York: Springer, 1996, which is incorporated herein by reference, an irrelevant feature tends to have a relatively large input scale L. For relatively large input scales, the covariance will be independent of that input, effectively removing it from the feature vector (i.e. if a feature has a relatively large input scale, its kernel function will tend to be relatively flat, and so this kernel will have little or no impact of the product of kernels).

An advantage provided by the above described system and methods is that it tends to be possible to process and compare data from a plurality of heterogeneous sources. The combination, analysis and visualisation of data from a plurality of heterogeneous sources tend to be facilitated. A combination of heterogeneous data into a single coherent view tends to be advantageously provided.

A further advantage is that an indication of the most significant and reliable data source and/or pre-processing method for that data source, dependant on the measured sensor data, tends to be provided. In other words, several algorithms may claim to pre-process data in the “best” way. The above described method tends to provide an automatic and unbiased way of determining the most relevant pre-processor.

A further advantage provided by the implementation of Gaussian Processes is the need to specify a priori the basis functions for the classical Relevance Vector Machine tends to be advantageously eliminated.

Moreover, the use of Gaussian Processes tends to provide that, when training the data fusion processor (as described in more detail above with reference to FIG. 3), uncertainty in the output function y(X) is accounted for far away from the training input vectors X_tr. This is in contrast to the classical Relevance Vector Machine approach.

An advantage provided by the method of training the data fusion process using the training data (as described in more detail above with reference to FIG. 3) is that relevant combinations of data features are automatically learnt. This advantageously tends to reduce the workload on a (human) data analyst.

An advantage provided by the above described system and methods is that training of the data fusion process may be carried out “off-line”, i.e. in advance of the system and method being implemented on actual test data. The system and method may advantageously be implemented in situ on actual test data to provide real-time analysis of data from heterogeneous sources.

A further advantage provided by the above described system and method is that an Automatic Relevance Detection facility tends to be provided.

The above described system and method tends to be advantageous flexible, and robust.

Apparatus, including the data fusion processor 24, for implementing the above arrangement, and performing the method steps to be described later below, may be provided by configuring or adapting any suitable apparatus, for example one or more computers or other processing apparatus or processors, and/or providing additional modules. The apparatus may comprise a computer, a network of computers, or one or more processors, for implementing instructions and using data, including instructions and data in the form of a computer program or plurality of computer programs stored in or on a machine readable storage medium such as computer memory, a computer disk, ROM, PROM etc., or any combination of these or other storage media.

It should be noted that certain of the process steps depicted in the flowcharts of FIGS. 3 to 6 and described above may be omitted or such process steps may be performed in differing order to that presented above and shown in the Figures. Furthermore, although all the process steps have, for convenience and ease of understanding, been depicted as discrete temporally-sequential steps, nevertheless some of the process steps may in fact be performed simultaneously or at least overlapping to some extent temporally.

In the above embodiments, the information fusion method is implemented in the scenario of FIG. 1. In particular, specific activity in the vicinity of a check-point and in an urban environment is measured. However, in other embodiments the information fusion method is implemented in a different scenario. In other embodiment, different activities or patterns are observed and these patterns are labelled according to their type (e.g. normal/abnormal, benign/hostile etc.) Example scenarios include activity in a town or activity on a computer network.

In the above embodiments, the vehicle is a land-based, manned vehicle that travels along a road. At some point in time the vehicle passes the check-point (a particular point on the road). However, in other embodiments, the vehicle is a different type of entity, for example a different type of vehicle (e.g. a manned or unmanned air-vehicle). Also, in other embodiments there is a different number of vehicles.

In the above embodiments, the sources of the data being processed are the camera, the acoustic sensor, and the human. These data sources are heterogeneous data sources. However, in other embodiments there are a different number of data sources. Also, in other embodiments, any of the data sources may be different type of data sources, e.g. a satellite capturing images of a scene. Also, in other embodiments some of the data sources may not be heterogeneous data sources (they may be “homogeneous, i.e. they may be the same type of sensor etc.) Homogeneous data sources may, for example, be pre-processed differently be different pre-processors.

In the above embodiments, data is passed to, and processed at, a single base station, i.e. at a central processor. However, in other embodiments the data may be processed by a different number of processors that are remote from one another.

In the above embodiments, the base station comprises four pre-processors. The first and second pre-processors process data from the camera, the third pre-processor processes data from the acoustic sensor, and the fourth pre-processor processes data from the human. However, in other embodiments the base station comprises a different number of pre-processors. Furthermore, in other embodiments any number of pre-processors may process data a particular data source. Furthermore, in other embodiments a pre-processor may process data from any number of data sources.

In the above embodiments, the pre-processors process the data they receive as described in more detail above with reference to FIG. 2 (e.g. the first pre-processor performs a conventional edge detection process on images received from the camera). However, in other embodiments one or more of the pre-processors performs a different data processing process.

In the above embodiments, the output from the data fusion processor is sent from the data fusion processor to the display where it is displayed to an operator. However, in other embodiments an output of the data fusion processer (i.e. an output of a data fusion process) is sent from the data fusion processor for use by a different system.

In the above embodiments, a particular kernel is used to process data from a particular pre-processor (and thus from a particular data source). This tends to provide that data from a particular data source (or pre-processor) is processed using a unique combination of kernels with respect to data from the other data sources (or pre-processors). This tends to facilitate the identification of relevant/significant data-sources (or pre-processor). However, in other embodiments a particular kernel may be used to process data from more than one pre-processors (and thus from more than one data source) such that the data from a particular data source (or pre-processor) is processed using a unique combination of kernels with respect to data from the other data sources (or pre-processors).

In the above embodiments, data is represented as a linear combination of kernels. These kernels are then interpreted as covariances of Gaussian Processes. However, in other embodiments, the kernelised data is interpreted or processed differently, e.g. not using Gaussian Process. For example, in other embodiments the kernelised data may be used to infer relevance (e.g. of a data source or pre-processing method) by implementing a Linear Basis Model (LBM) approach, or Radial Basis Function (RBF) approach. Advantageously, using an LBM approach to process the kernelised data tends not to require the inversion of covariance matrices. Thus, it tends to be possible to use efficient Variational Bayes techniques to marginalise over kernel weights and/or input scales.

The use of LBM to process kernelised data advantageously tends to provide that large datasets may be processed in a more computationally efficient manner compared to if Gaussian Processes were used. This tends to be due to the LBM approach not involving the inversion of (large) covariance matrices. However, the above described Gaussian Processes approach tends to produce more accurate results than the LBM approach.

A function may be written as:

$f\left(x\right)=\sum _i^{}w_iK\left(x_i\right)+{\varepsilon }_x$

Where:

• • ε_x is normal independent and identically distributed, ε_x˜N(0,τ);
  • w₁ are weights; and
  • x₁ are inputs (or features).

The form of the basis kernel, K(•), allows for domain knowledge to be incorporated and for non-linear decision boundaries to be formed. A linear regressor may be expressed as:

$\hat{f}\left(x\right)=\sum _i^{}w_{i}x_i$

The weights w_i may be inferred using standard Bayesian inference. The latent function ƒ may be mapped through a sigmoid function to form a logistic regressor to result in posterior class probabilities:

$\hat{p}\left(\mathrm{class}=c\text{}x\right)=\sigma \left(\sum _i^{}w_i^cx_i\right)$

Fitting training data class labels to the linear regressor tends to yield accurate weights for use within the logistic regressor. Learning the weights using the LBM as opposed to the logistic model this way tends to speed up the learning process. This increase in speed tends to be due to the model being linear in free parameters. Thus, rapid fixed-point solutions may be obtained. In contrast other logistic models tend to require non-linear optimisation which tends to result in considerable extra computational cost. Furthermore, any degeneration in predictor performance tends to be insignificant.

An input variable may be deemed to be “irrelevant” if it provides no value in regression onto the target variable. When using generic linear models, the relevance of a (kernel) variable may be determined from the magnitudes of the inferred weights. If the weight is close to zero, then the variable (or kernel) may be deemed to be irrelevant. However, inferring the weights using standard regression algorithms may result in non-zero weights being assigned to irrelevant variables. To account for this, explicit shrinkage priors may be placed over the weights, for example as will now be described.

A linear model may be expressed as:

ƒ(x)=w^Tx+ε

In this example, both x and ƒ(x) have zero mean. In other example, either or both of x and ƒ(x) may have a different mean. If a particular input, e.g. x₁ is uncorrelated with ƒ(x), then E[ƒ(x)x₁]=0. Also,

$\sum _i^{}w_iE\left[x_ix_1\right]=0$

If x₁ is uncorrelated with all other inputs then E[x_ix₁]=0 for all i≠1. Thus, w₁=0. All linear regression algorithms will infer w₁=0 with high certainty in this case and conclude that Shrinkage prior w₁ is irrelevant. However, if the input variables are themselves correlated then w₁ may be far from zero. Groups of variables which are themselves correlated but irrelevant may be deemed to be relevant. To remove truly irrelevant variables shrinkage priors are placed over the weights.

The posterior evidence of the data given the model may be written in terms of the data likelihood and the model prior. Thus, minimising the negative log likelihood is equivalent to minimising an equivalent error functional of the form

U=U _data−log p(w)

Where: U_data is the data error (i.e. the difference between the regression value and the target value); and

−log p(w) is the negative log of the prior distribution over the weights. Maximum entropy arguments point to a factored zero mean multivariate Normal as this distribution:

$-\log p\left(w\right)=-\frac{1}{2}w^T\alpha w+\mathrm{const}$

in which α is a diagonal matrix of hyper-parameters with elements α_i.

The negative gradient of the error equation (i.e. the direction of gradient descent), with respect to the parameters yields

$-\frac{U}{w}=-\frac{U_{\mathrm{data}}}{w}-\alpha w$

For some weight, e.g. w₁, which has little impact on the error of a solution, the term

$\frac{U}{w}$

tends to be relatively small. Thus, changes in the weight tend to be dominated by:

δw₁∝α₁w₁

This may represents a decay of w₁ to zero with a rate give by α₁. The Bayesian formulation advantageously tends to allow for the simultaneous inference of the distributions over the weights along with the shrinkage parameters α₁.

Advantageously, it tends to be possible to use the kernels that may be used for the above described Gaussian Process approach within the LBM approach.

An example of a variational approach to kernel modelling of data which can determine relevant features within a feature vector as well as determine the weights λ of the bases will now be described. In this example, variational Bayes steps for the kernel-based LBM for products of kernels are implemented. In other examples, summed kernels may be used instead of products of kernels. In this example, the application of shrinkage priors over the bases is not implemented. However, in other examples the application of shrinkage priors over the bases is implemented. Placing shrinkage priors on the basis weights would identify the most important bases in a manner similar to the Support Vector Machine.

In this example, a model has a non-linear relation between D-dimensional inputs x and outputs y and constant-variance Gaussian noise, such that the data likelihood may be given by:

$p\left(y\text{}K\left(x\right),w,\lambda ,\tau \right)={\left(\frac{\tau }{2\pi }\right)}^{\frac{1}{2}}\exp \left(-\frac{\tau }{2}{\left(y-{K\left(x\right)}^T\lambda \right)}^2\right)$

where the compound vector kernel K is composed of a product of κ kernels, {k₁, . . . , k_κ}, one for each feature, κ.

$K\left(x\right)=\prod _{\kappa }^{}{k_{\kappa }\left(x\right)}^{w_{\kappa }}$

All available data may be expressed as D={X,Y} where X={x₁, . . . , x_N} and Y={y₁, . . . , y_N}. The data likelihood may be expressed as:

$p\left(y\text{}K\left(x\right),w,\lambda ,\tau \right)=\prod _n^{}p\left(y_n\text{}K\left(x_n\right),w,\lambda ,\tau \right)$

The prior on w and τ may be conjugate normal inverse-gamma, i.e.

$\begin{array}{c}p\left(w,\tau \alpha \right)=N\left(wo,{\left(\mathrm{\tau A}\right)}^{-1}I\right)\mathrm{Gam}\left(\tau a_0,b_0\right)\\ ={\left(\frac{{A}^{1/2}}{\sqrt{2{\pi }^D}}\right)}^{D/2}\frac{b_0^{a_0}}{\Gamma \left(a_0\right)}{\tau }^{\frac{D}{2}+a_0-1}\exp \left(-\frac{\tau }{2}\left(w^T\mathrm{Aw}+2b_0\right)\right)\end{array}$

where the vector α=(α₁, . . . , α_D)^T forms the diagonal of A. The values α_i are independent, such that the hyper-prior is given by

$\begin{array}{c}p\left(\alpha \right)=\prod _i^{}\mathrm{Gam}\left({\alpha }_i\text{}c_0,d_0\right)\\ =\prod _i^{}\frac{1}{\Gamma \left(c_0\right)}d_0^{c_0}{\alpha }_i^{c_0-1}\exp \left(-d_0{\alpha }_i\right)\end{array}$

The hyper-prior of the weights A of the bases may be given by:

p(λ)=N(λ/λ₀,P₀)

Variational posteriors may be calculated using and appropriate method. For example, the method described in W. Penny and S. Roberts “Bayesian methods for autoregressive models”, Proceedings of Neural Networks for Signal Processing, Sydney, Australia, December 2000 (which is incorporated herein by reference) may be used. Also for example, the method described in S. Roberts and W. Penny, “Variational Bayes for Generalised Autoregressive Models”, IEEE Transactions on Signal Processing, 50(9):2245-2257, 2002 (which is incorporated herein by reference) may be used. Also for example, the method described in W. Penny and S. Roberts, “Bayesian Multivariate Autoregressive Models with Structured Priors”, IEE Proceedings on Vision, Signal & Image Processing, 149(1):33-41, 2002 (which is incorporated herein by reference) may be used. Also for example, the method described in J. Drugowitsch, “Bayesian Linear Regression”. Technical report, Laboratoire de Neurosciences, Cognitives: http://www.Inc.ens.fr/˜jdrugowi, 2010 (which is incorporated herein by reference) may be used.

In some examples, an exponential distribution over k_i^wi may be identified. In other examples, a compound kernel may be approximated via a Taylor expansion about the mean of w. Thus, the variational posterior expression for α may be identical to that for linear regression. To aid convergence of the Taylor Expansion algorithm, the mean of w may be smoothed by combining the value of the mean of w calculated during a current iteration with the value of the mean of w carried over from the previous iteration. If convergence is not achieved after a predetermined number of iterations (e.g. 500) the algorithm may be stopped. A warning indicating non-convergence may be displayed.

The predictive density may be evaluated by approximating the posterior distributions p(w,τ|D) and p(λ) by their variational counterparts q(w,τ) and q(λ) respectively. The target class probability may be given by:

E[σ(ƒ(x))]=∫_w∫_τ∫λσ(K(x,w)^Tλ)q(w,τ)q(λ)dwdτdλ

A solution to this integral may be approximated as:

E[σ(∫(x))]≈σ(K(x,E_w[w])TE_λ[λ])

Thus, as an alternative to a Gaussian Process approach, a number of algorithms based on the linear basis model (LBM) are provided. The LBM advantageously supports kernel-based methods for non-linear classification. Furthermore, the same kernels to those used in the Gaussian Process approach may be used.

Either a non-linear or linear learning algorithm may be implemented. Both non-linear and linear algorithms may use the same pre-processing steps and multiple class extension.

Examples of pre-processing techniques include normalisation, balancing and individual relevance determination.

Normalisation pre-processing may comprise normalising the scale variation in each element of a vector of observed features x. This tends to allow for the magnitude of each of the elements in a set of regression coefficients w (or weights) to be indicative of the relevance of an element of x,

Balancing pre-processing may comprise re-sampling with replacement of under-represented classes, or sub-sampling from over-represented classes, during the training procedure. This tends to compensate for biasing in posterior beliefs.

Individual relevance determination pre-processing may comprise evaluating the performance of sets of univariate linear regressors of the form

{circumflex over (ƒ)}(x_i)=w_ix_i

The performance on the training data may be evaluated and features x_i which show performance better than random may be retained. These retained features may be used to form a subset x* of the original vector set x. Full Bayesian regression may then be performed using this subset. This, in effect, allows the weights of those features in x not in x* to be equal to zero.

The pre-processing steps advantageously tend to improve an algorithm's efficiency and performance.

In the Gaussian Process approach, a kernel may be interpreted as a prior covariance over state variables. Thus, background information may be encoded within the Gaussian Process approach.

Claims

1. A method of processing data, the data comprising: a set of one or more system inputs; anda set of one or more system outputs; whereineach system output corresponds to a respective system input;each system input includes a plurality of data points, a first data point in the plurality and a second data point in the plurality being from a same raw data source (8, 10, 12), and the first data point being pre-processed using a pre-processing method different from a pre-processing method used to pre-process the second data point, the method comprising:for each of the first and second data points, inferring a value indicative of a significance of the pre-processing method used to pre-process that data point; whereinthe step of inferring includes performing a machine learning algorithm on a given system input from the data and a further system input.

2. A method according to claim 1, wherein a data point is a data feature extracted from raw data using a pre-processing method, and a pre-processing method is a feature extraction process.

3. A method according to claim 1, wherein performing the machine learning algorithm comprises: implementing a regression technique.

4. A method according to claim 3, wherein implementing the regression technique comprises: implementing a Gaussian Process.

5. A method according to claim 3, wherein performing the machine learning algorithm comprises: performing a kernel function on a given system input from the data and a further system input to provide kernelised data; andapplying a regression technique to the kernelised data.

6. A method according to claim 5, wherein the kernel function is a sum of further functions, each further function being a function of a data point of the given system input and a data point of the further system input.

7. A method according to claim 5, wherein the kernel function is a product of further functions, each further function being a function of a data point of the given system input and a data point of the further system input.

8. A method according to claim 6, wherein each further function is a kernel function.

9. A method according to claim 7, wherein each further function kernel function.

10-15. (canceled)

16. A method according to claim 6, wherein a further function performed on the first data point is a different function from a further function performed on the second data point.

17. A method according to claim 7, wherein a further function performed on the first data point is a different function from a further function performed on the second data point.

18. A method according claim 5, wherein the kernel function is one of a Squared Exponential kernel, a Nominal kernel and a Rank kernel.

19. A method according to claim 1, comprising: measuring the further system input.

20. Apparatus for processing data, the data which includes: a set of one or more system inputs; anda set of one or more system outputs; wherein:each system output corresponds to a respective system input; andeach system input includes a plurality of data points, a first data point in the plurality and a second data point in the plurality being from a same raw data source, the first data point being pre-processed using a pre-processing method different from a pre-processing method used to pre-process the second data point, the apparatus comprising:one or more processors being programmed to perform the following functions:for each of the first and second data points, to infer a value indicative of a significance of the pre-processing method used to pre-process that data point; whereinthe inferring of a value indicative of a significance includes performing a machine learning algorithm on a given system input from the data and a further system input.

21. Apparatus according to claim 20, comprising: a processor for extracting a data point as a data feature from raw data using a pre-processing method which is a feature extraction process.

22. A program or plurality of programs stored in a non-transitory computer readable medium such that when executed by a computer system or one or more processors it/they cause the computer system or the one or more processors to operate in accordance with the method of claim 1.

23. A computer system in combination with a machine readable storage medium storing a program or at least one of the plurality of programs according to claim 22.

24. A method according to claim 4, wherein performing the machine learning algorithm comprises: performing a kernel function on a given system input from the data and a further system input to provide kernelised data; andapplying a regression technique to the kernelised data.

25. A method according claim 24, wherein the kernel function is one of a Squared Exponential kernel, a Nominal kernel and a Rank kernel.

26. A method according to claim 25, comprising: measuring the further system input.