SYSTEMS, DEVICES, AND METHODS FOR PARAMETER OPTIMIZATION

Abstract

A computerized method for optimizing parameters is described. A system can initialize a group of parameters to respective values within a set of allowable models and bound a partition function across a number of variable pairs to generate a plurality of bounds. The system can also determine new values for the group of parameters that minimize a sum of the plurality of bounds. The system can set the group of parameters to the new values and optimize the parameters by iteratively performing the bounding, determining and setting. The system can stop optimizing when a termination condition is reached.

Description

CROSS REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of U.S. Provisional Application No. 61/494,281, entitled “Data Learning Using Probability Models and Conditional Random Fields” filed on 7 Jun. 2011, which is hereby incorporated herein by reference in its entirety.

FIELD

Embodiments relate generally to parameter optimization, and, more particularly, to computer systems, devices, methods and computer readable media for optimizing model parameters using partition function bounding.

BACKGROUND

Estimating probability density functions over sets of random variables can be a central problem in machine learning. For some problems, such as conditional random fields (CRFs) and log-linear models, estimation often requires minimizing a partition function.

Conventional bound-majorization methods were once used to optimize parameters and train models, but were overtaken by faster first-order and then second order methods.

SUMMARY

An embodiment optimizes partition functions by computing a quadratic variational upper bound. Embodiments include methods for computing a bound of the partition function for structured prediction (e.g., conditional random fields), conditional likelihood problems, graphical models and latent likelihood problems. Structured prediction applications can include, but are not limited to, pattern recognition, shallow parsing, named entity recognition, gene finding, object recognition and image segmentation systems.

Embodiments can include methods for tuning parameters for deep belief networks, automated labeling of data, web page parsing, named entity recognition, logistic regression, machine translation and web page annotation.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a flow chart of an example method for parameter optimization using a partition function bound in accordance with at least one embodiment.

FIG. 2 is a flow chart of an example method for parameter optimization for a model conditioned on observed input in accordance with at least one embodiment.

FIG. 3 is a flow chart of an example method for parameter optimization for a graphical model in accordance with at least one embodiment.

FIG. 4 is a flow chart of an example method for parameter optimization for high dimensional models in accordance with at least one embodiment.

FIG. 5 is a diagram of an example parameter optimization system in accordance with at least one embodiment.

FIG. 6 is a diagram of an example unsupervised machine learning system in accordance with at least one embodiment.

FIG. 7 is a diagram of an example supervised machine learning system in accordance with at least one embodiment.

FIG. 8 is a diagram of an example junction tree of depth 2.

FIG. 9 is a diagram of an example junction tree of depth 3.

DETAILED DESCRIPTION

The partition function can play a key role in probabilistic modeling including conditional random fields (CRFs), maximum entropy methods, graphical models and maximum likelihood estimation. An embodiment can include upper bounding a partition function using a quadratic function and optimizing parameters using the bounding.

FIG. 1 is a flow chart of an example method for parameter optimization using a partition function bound in accordance with at least one embodiment. In particular, at 102, initial parameters are provided to a system. At 104, a feature function (e.g., ƒ(y)) is provided to the system and, at 106, an a priori probability function (e.g., h(y)) is provided to the system.

At 108, the system computes a quadratic upper bound on a partition function as described below.

At 110, the system tests a loop index. If the end of the index has been reached, processing continues to 112, otherwise processing continues to 108.

At 112, the quadratic parameters of the partition function bound are provided for downstream processing.

The mathematical basis for partition function bounding (e.g., as shown in FIG. 1) is set forth below:

Consider a log-linear density model over discrete yεΩ

$p\left(y|\theta \right)=\frac{1}{Z\left(\theta \right)}h\left(y\right)\exp \left({\theta }^Tf\left(y\right)\right)$

which is parameterized by a vector θε^d of dimensionality dεZ. Here, ƒ:Ω^d is any vector-valued function mapping an input y to some arbitrary vector. The prior h:Ω⁺ is a fixed non-negative measure. The partition function Z(θ) is a scalar that ensures that p(y|θ) normalizes, i.e. Z(θ)=Σ_yh(y)exp(θ^Tƒ(y)). Assume that the number of configurations of y is |Ω|=n and is finite. The partition function is clearly log-convex in θ and a linear lower-bound is given via Jensen's inequality. As mentioned above, an embodiment can include computing a quadratic upper-bound on the partition function. Algorithm 1, below, provides a mathematical computation for the bound's parameters. Theorem 1, below, shows the precise guarantee it provides.

Algorithm 1
Input {tilde over (θ)}, f(y), h(y) ∀y ε Ω
Init z → 0+, μ = 0, Σ = zI
For each y ε Ω {
α = h(y)exp({tilde over (θ)}Tf(y))
l = f(y) − μ
Σ +=    tan       h   (   1 2    ln   (  α   /   z  )    )     2   ln   (  α   /   z  )       ll T
μ +=   α  z + α    l
z += α }
Output z, μ, Σ

Theorem 1

Algorithm 1 finds z, μ, Σ such that zexp(½(θ−{tilde over (θ)})^TΣ(θ−{tilde over (θ)})+(θ−{tilde over (θ)})^Tμ) upper-bounds Z(θ)=Σ_yh(y)exp(θ^Tƒ(y)) for any θ, {tilde over (θ)}, ƒ(y)ε^d and h(y)ε⁺ for all yεΩ.

The bound can improve previous inequalities and its proof is in the Appendix. For example, the bound can be computed using Algorithm 1 by iterating over the y variables (“for each yΣΩ”) according to an arbitrary ordering via the bijective function π:Ω{1, . . . , n} which defines i=π(y). The order in which we enumerate over Ω slightly varies the Σ in the bound (but not the μ and z) when |Ω|>2. Recall that choosing Σ=Σ_yh(y)exp({tilde over (θ)}^Tƒ(y))(ƒ(y)−μ)(ƒ(y)−μ)^T with μ and z as in Algorithm 1 yields the second-order Taylor approximation (the Hessian) of the log-partition function. Algorithm 1 replaces a sum of log-linear models with a single log-quadratic model which makes monotonic majorization straightforward.

FIG. 2 is a flow chart of an example method for parameter optimization for a model conditioned on observed input in accordance with at least one embodiment.

At 202, initial parameters are provided to a system.

At 204, the system computes or updates partition functions bounds. For example, the partition function bounds can be computed according to Algorithm 1 discussed above.

At 206, parameters are selected that minimize the sum of the bounds.

At 208, the current parameters are updated based on the selected parameters.

At 210, the system determines if a termination condition has been reached. The termination condition can include one or more of a predetermined number of iterations, a predetermined amount of elapsed time, and a difference between current parameters and subsequent parameters of less than a predetermined threshold. If the termination condition has been reached, the parameters can be provided for use in a downstream process. Otherwise, if the termination condition has not been reached, processing can continue back to 204, where the bounding and minimizing can be performed again. In general, the bounding and minimizing can be repeated until the parameters converge.

Partition functions arise naturally in maximum entropy estimation or minimum relative entropy

$RE\left(p||h\right)=\sum _yp\left(y\right)\ln \frac{p\left(y\right)}{h\left(y\right)}$

estimation as follows

$\underset{p}{\min }\mathrm{RE}\left(p||h\right)s.t.{\sum }_yp\left(y\right)f\left(y\right)=0,{\sum }_yp\left(y\right)g\left(y\right)\ge 0.$

Therein, yεΩ, ƒ:Ω^d and g:Ω are arbitrary (non-constant) vector-valued functions over the sample space. The solution distribution p(y)=h(y)exp(θ^Tƒ(y)+θ^Tg(y))/Z(θ, θ) is recovered by the dual optimization

$\theta ,\vartheta =\underset{\vartheta \ge 0,\theta }{\stackrel{\arg }{\max }}-\ln \sum _yh\left(y\right)\exp \left({\theta }^Tf\left(y\right)+{\vartheta }^Tg\left(y\right)\right)$

where θε^d and θε^d′. These are obtained by minimizing Z(θ, θ) or equivalently by maximizing its negative logarithm. Algorithm 1 permits variational maximization of the dual via the quadratic program

$\underset{\vartheta \ge 0,\theta }{\min }\frac{1}{2}{\left(\beta -\tilde{\beta }\right)}^T\Sigma \left(\beta -\tilde{\beta }\right)+{\beta }^T\mu$

where β^T=[θ^Tθ^T]. In fact, any general convex hull of constraints βεΛ⊂^d+d′ could be imposed without loss of generality. In the case where there are no inequality constraints in the maximum entropy problem, only θε^d is to be recovered and a simple closed-form iterative update rule emerges: {tilde over (θ)}←{tilde over (θ)}−Σ⁻¹μ. This rule is interleaved with the bound computation to solve the dual optimization and obtain θ.

The partition function also arises in conditional extensions of the maximum entropy paradigm where the model is conditioned on an observed input. Such models are known as conditional random fields and have been useful for structured prediction problems. CRFs are given a data-set {(x₁, y₁), . . . , (x_t, y_t)} of independent identically-distributed (iid) input-output pairs where y_j is the observed sample in a (discrete) space Ω_j conditioned on the observed input x_j. A CRF defines a distribution over all yεΩ_j (of which y_j is a single element) as the log-linear model

$p\left(y|x_j,\theta \right)=\frac{1}{z_{x_j}\left(\theta \right)}h_{x_j}\left(y\right)\exp \left({\theta }^Tf_{x_j}\left(y\right)\right)$

where Z_xj(θ)=Σ_yεΩjh_xj(y)exp(θ^Tƒ_xj(y)). For the j'th training pair, we are given a non-negative function h_xj(y)ε⁺ and a vector-valued function ƒ_xj(y)ε^d defined over the domain yεΩ_j. In this section, for simplicity, assume n=max_j=1^t|Ω_yj|. Each partition function Z_xj(θ) is a function of θ. The parameter θ for CRFs is estimated by maximizing the regularized conditional log-likelihood or log-posterior:

$\sum _{j=1}^t\ln p\left(y_j|x_j,\theta \right)-\frac{t\lambda }{2}{\theta }^2$

where λε⁺ is a regularizer set using prior knowledge or cross-validation. Rewriting gives the objective of interest

$\begin{array}{cc}J\left(\theta \right)=\sum _{j=1}^t\ln \frac{h_{x_j}\left(y_j\right)}{z_{x_j}\left(\theta \right)}+{\theta }^Tf_{x_j}\left(y_j\right)-\frac{t\lambda }{2}{\theta }^2.& \left(1\right)\end{array}$

If prior knowledge (or constraints) restrict the solution vector to a convex hull A, the maximization problem becomes argmax_θεΛJ(θ). The maximization of Equation 1 thus subsumes the minimum relative entropy problem.

Algorithm 3 proposes a method for maximizing the regularized conditional likelihood J(θ) or, equivalently minimizing the partition function Z(θ). It solves the problem in Equation 1 subject to convex constraints by interleaving the quadratic bound with a quadratic programming procedure. Theorem 2 establishes the convergence of the algorithm and the proof is in the Supplement.

Algorithm 2
0: Input xj, yj and functions hxj, fxj for j = 1, ..., t
   Input regularizer λ ε   + and convex hull Λ ⊂   d
1: Initialize θ0 anywhere inside Λ and set {tilde over (θ)} = θ0
   While not converged
2: For j = 1, ..., t
   Get μj, Σj from hxj, fxj, {tilde over (θ)} via Algorithm 1
3: Set {tilde over (θ)} = arg minθεΛ Σj ½(θ − {tilde over (θ)})T (Σj + λI)(θ − {tilde over (θ)})
   + Σj θT (μj − fxj(yj) + λ{tilde over (θ)})
4: Output {circumflex over (θ)} = {tilde over (θ)}

Theorem 2

For any θ₀εΛ, all ∥ƒ_xj(y)∥²≦r and all |Ω_j|≦n, Algorithm 2 outputs a {circumflex over (θ)} such that

$J\left(\hat{\theta }\right)=J\left({\theta }_0\right)\ge \left(1-\varepsilon \right){\max }_{\mathrm{\theta \epsilon \Lambda }}\left(J\left(\theta \right)-J\left({\theta }_0\right)\right)\mathrm{within}$ $\lceil \ln \left(\frac{1}{\varepsilon }\right)/\ln \left(1+\frac{\lambda }{2r}{\left(\sum _{i=1}^{n-1}\frac{\tanh \left(\ln \left(i\right)/2\right)}{\ln \left(i\right)}\right)}^{-1}\right)\rceil \mathrm{steps}.$

The series

$\sum _{i=1}^{n-1}\frac{\tanh \left(\ln \left(i\right)/2\right)}{\ln \left(i\right)}=\sum _{i=1}^{n-1}\frac{i-1}{\left(i+1\right)\ln \left(i\right)}$

is the logarithmic integral which is

$O\left(\frac{n}{\ln n}\right)$

asymptotically.

Maximum conditional likelihood is extended to the setting where some variables are latent. We are given t iid samples x₁, . . . , x_t from some unknown distribution p(x) and t corresponding samples y₁, . . . , y_t drawn from identical conditional distributions p(y|x₁), . . . , p(y|x_t) respectively. Assume that the true generating distributions p(x) and p(y|x) are unknown. Therefore, we aim to estimate a conditional distribution p(y|x) from some set of hypotheses that achieves high conditional likelihood given the data-set D={(x₁, y₁), . . . , (x_t, y_t)}. We will select this conditional distribution by assuming it emerges from a conditioned joint distribution over x and y as well as a hidden variable m which is being marginalized as

$p\left(y|x,\Theta \right)=\frac{{\sum }_mp\left(x,y,m|\Theta \right)}{{\sum }_{y,m}p\left(x,y,m|\Theta \right)}.$

Here mεΩ_m represents a discrete hidden variable, xεΩ_x is an input and yεΩ_y is a discrete output variable. The parameter Θ contains all parameters that explore the function class of such conditional distributions. The latent likelihood of the data L(Θ)=p(D|Θ) subsumes Equation 1 and is the new objective of interest

$\begin{array}{cc}L\left(\Theta \right)=\prod _{j=1}^tp\left(y_j|x_j,\Theta \right)=\prod _{j=1}^t\frac{{\sum }_mp\left(x_j,y_j,m|\Theta \right)}{{\sum }_{y,m}p\left(x_j,y,m|\Theta \right)}.& \left(2\right)\end{array}$

A good choice of the parameters is one that achieves a large conditional likelihood value (or posterior) on the data set D. Next, assume that each p(x|y, m, Θ) is an exponential family distribution

p(x|y,m,Θ)=h_y,m(x)exp(θ_y,m^Tφ_y,m(x)−a_y,m(θ_y,m))

where each conditional is specified by a function h_y,m:Ω_x⁺ and a feature mapping φ_y,m:Ω_x^dy,m which are then used to derive the normalizer a_y,m^dy,m+. A parameter θ_y,mε^dy,m selects a specific distribution. Multiply each exponential family term by an unknown marginal distribution called the mixing proportions

$p\left(y,m|\pi \right)=\frac{{\pi }_{y,m}}{{\sum }_{y,m}{\pi }_{y,m}}.$

This is parametrized by an unknown parameter π={π_y,m}∀y,m where π_y,mε[0, ∞). Finally, the collection of all parameters is Θ={θ_y,m, π_y,m}∀y,m. Thus, we have the complete likelihood

$p\left(x,y,m|\Theta \right)=\frac{{\pi }_{y,m}h\left(x\right)}{{\sum }_{y,m}{\pi }_{y,m}}\exp \left({\theta }_{y,m}^T\phi \left(x\right)-a\left({\theta }_{y,m}\right)\right)$

where, without loss of generality, we dropped the index y, m indexing h(x), φ(x), and a(θ), making each conditional belong to the same exponential family form. Insert this expression into Equation 2 and remove constant factors that appear in both denominator and numerator. Apply the change of variables exp(v_y,m)=π_y,mexp(−a(θ_y,m)) and rewrite as

$L\left(\Theta \right)=\prod _{j=1}^t\frac{{\sum }_m\exp \left({\theta }_{y_j,m}^T\phi \left(x_j\right)+v_{y_j,m}\right)}{{\sum }_{y,m}\exp \left({\theta }_{y,m}^T\phi \left(x_j\right)+v_{y,m}\right)}.$

The objective as a function (it is now easy to regularize L(θ) by adding

$-\frac{t\lambda }{2}{\theta }^2)$

of a vector θ is simply

$L\left(\theta \right)=\prod _{j=1}^t\frac{{\sum }_m\exp \left({\theta }^Tf_{j,y_j,m}\right)}{{\sum }_{y,m}\exp \left({\theta }^Tf_{j,y,m}\right)}$

after arranging parameters Θ in θε^{|Ωy∥Ωm|(d+1)} as

[θ_1,1^Tv_1,1θ_1,2^Tv_1,2 . . . θ_|Ωy|,|Ωm|^Tv_|Ωy|,|Ωm|]^T.

Similarly, introduce vectors ƒ_{j,ŷ,{circumflex over (m)}}ε^{|Ωy∥Ωm|(d+1)} defined as

[[φ(x_j)^T1]δ[(ŷ,{circumflex over (m)})=(1,1)] . . . [φ(x_j)^T1]δ[(ŷ,{circumflex over (m)})=(|Ω_y|,|Ω_m|)]]^T.

In other words, the feature vector [φ(x_j)^T1]^T is positioned appropriately in the longer ƒ_{j,ŷ,{circumflex over (m)}} vector which is otherwise equal to zero. Consider finding a variational lower bound on L(θ)≧Q(θ, {tilde over (θ)}) which is tight when θ={tilde over (θ)} such that L({tilde over (θ)})=Q({tilde over (θ)}, {tilde over (θ)}). We proceed by bounding each numerator and each denominator in the product over j=1, . . . , t as follows. Apply Jensen's inequality to lower bound each numerator term as

${\sum }_m\exp \left({\theta }^Tf_{j,y_j,m}\right)\ge {}^{\theta T{\sum }_m{\eta }_{j,m}f_{j,m}f_{j,y_{j,}m}-{\sum }_m{\eta }_{j,m}ln{\eta }_{j,m}}$ $\mathrm{where}$ ${\eta }_{j,m}=\left({}^{{\tilde{\theta }}^Tf_{j,y_{j,}m}}\right)/\left({\sum }_{m^{\prime }}{}^{{\tilde{\theta }}^Tf_{j,y_j,m^{\prime }}}\right).$

Algorithm 1 then bounds the denominator

${\sum }_{y,m}\exp \left({\theta }^Tf_{j,y,m}\right)\le z_j{}^{\frac{1}{2}{\left(\theta -\tilde{\theta }\right)}^T{\sum }_j\left(\theta -\tilde{\theta }\right)+{\left(\theta -\tilde{\theta }\right)}^T{\mu }_j}.$

The overall lower bound on the likelihood is then

$Q\left(\theta ,\tilde{\theta }\right)=L\left(\tilde{\theta }\right){}^{-\frac{1}{2}{\left(\theta -\tilde{\theta }\right)}^T\tilde{\Sigma }\left(\theta -\tilde{\theta }\right)-{\left(\theta -\tilde{\theta }\right)}^T\tilde{\mu }}$

where {tilde over (Σ)}=Σ_j=1^tΣ_j and {tilde over (μ)}=Σ_j=1^tμ_j−Σ_mη_j,mƒ_j,yj,m. The right hand side is simply an exponentiated quadratic function in θ which is easy to maximize. In the unconstrained case, this yields the update rule θ={tilde over (θ)}−{tilde over (Σ)}⁻¹{tilde over (μ)}. Alternatively, if θ must satisfy linear (convex) constraints it is straightforward to compute an update by solving a quadratic (convex) program. This yields an iterative scheme similar to Algorithm 2 for monotonically maximizing latent conditional likelihood.

FIG. 3 is a flow chart of an example method for parameter optimization for a graphical model in accordance with at least one embodiment.

At 302, a graphical model is provided to a system. The graphical model can be in the form of a junction tree, for example, or converted from a first form into a junction tree.

At 304, the system can set indexes to begin at a leaf node level of the graphical model.

At 306, bounds at the current node level can be computed and/or updated. The bound computation includes collecting pre-computed bounds from child nodes, as described below with respect to Algorithm 3.

At 308, the system traverses up one level in the graphical model.

At 310, the system determines if it has reached a root node level (e.g., reached the node level associated with index m as discussed below). If the system has not reached the root node level, then processing continues to 306. If the system has reached the root node level, then processing continues to 312 where parameters of a quadratic partition function bound are provided as output.

The bounds discussed above (e.g., Algorithms 1 and 2) are straightforward to compute when Ω is small. However, for graphical models, enumerating over Ω can be daunting. The method described in FIG. 3 above and in Algorithm 3 below provides faster algorithms that recover the bound efficiently for graphical models of bounded tree-width. A graphical model represents the factorization of a probability density function. This example uses a factor graph notation of a graphical model. A factor graph is a bipartite graph G=(V, W, E) with variable vertices V={1, . . . , k}, factor vertices W={1, . . . , m} and a set of edges E between V and W. In addition, define a set of random variables Y={y₁, . . . , y_k} each associated with the elements of V and a set of non-negative scalar functions Ψ={ψ₁, . . . , ψ_m} each associated with the elements of W. The factor graph implies that p(Y) factorizes as

$p\left(y_1,\dots ,y_k\right)=\frac{1}{Z}\prod _{c\in W}^{}{\psi }_c\left(Y_c\right)$

where Z is a normalizing partition function (the dependence on parameters is suppressed here) and Y_c is a subset of the random variables that are associated with the neighbors of node c. In other words, Y_c={y_i|iεNe(c)} where Ne(c) is the set of vertices that are neighbors of c.

Inference in graphical models requires the evaluation and the optimization of Z. These computations can be NP-hard in general yet are efficient when G satisfies certain properties. Consider the function class p(Y|θ) indexed by a parameter θεΛ where Λ⊂^d is a convex hull. More specifically, consider the log-linear model

$p\left(Y|\theta \right)=\frac{1}{Z\left(\theta \right)}\prod _{c\in W}^{}h_c\left(Y_c\right)\exp \left({\theta }^Tf_c\left(Y_c\right)\right)$

where Z(θ)=Σ_YΠ_cεWh_c(Y_c)exp(θ^Tƒ_c(Y_c)). The model is defined by a set of vector-valued functions ƒ_c(Y_c)ε^d and scalar-valued functions h_c(Y_c)ε⁺. Choosing a function from the function class hinges on estimating θ by optimizing Z(θ). However, Algorithm 1 may be inapplicable due to the large number of configurations in Y. Instead, consider a more efficient surrogate algorithm which computes the same bound parameters by efficiently exploiting the factorization of the graphical model. This is possible since exponentiated quadratics are closed under multiplication and the required bound computations distribute nicely across decomposable graphical models.

Begin by assuming that the graphical model in question is a junction tree and satisfies the running intersection property. It is known that any graphical model can be converted into such a form at the expense of growing the cardinality of the factors cεW. Starting with a general graph G, convert it into a junction tree T as follows. First, triangulate it by adding as few edges as possible (this does not change p(Y|θ)). Once triangulated, form a junction tree T by connecting overlapping cliques to maximize the sum of the cardinalities of clique intersections. Then, using the junction tree T, compute the bound parameters via Algorithm 3. This algorithm only requires enumerating over each configuration of pairs of adjacent cliques which is clearly more efficient than enumerating over all configurations of Y. Algorithm 3 can be used interchangeably with Algorithm 1 when the partition function involves a graphical model.

In Algorithm 3, take ch(c) to be the set of children-cliques of clique c and pa(c) to be the parent of c. Note that the algorithm enumerates over uεY_pa(c)∩Y_c and vεY_c\Y_pa(c). The algorithm stores a quadratic bound for each configuration of u (where u is the set of variables in common across both clique c and its parent). It then forms the bound by summing over vεY_c\Y_pa(c), each configuration of each variable a clique c has that is not shared with its parent clique. The algorithm also collects precomputed bounds from children of c. Also define w=uvεY_c as the conjunction of both indexing variables u and v. Thus, the two inner for loops enumerate over all configurations wεY_c of each clique. Note that w is used to query the children bεch(c) of a clique c to report their bound parameters z_b|w, μ_b|w, Σ_b|w. This is done for each configuration w of the clique c. Note, however, that not every variable in clique c is present in each child b so only the variables in w that intersect Y_b are relevant in indexing the parameters z_b|w, μ_b|w, Σ_b|w, and the remaining variables do not change the values of z_b|w, μ_b|w, Σ_b|w.

Algorithm 3
Input {tilde over (θ)} ∈  d and reverse-topological tree T with
c=1, . . .,m factors hc(Yc)exp({tilde over (θ)}T fc(Yc))
for c=1, . . . ,m
if (c<m) {Yboth = Yc ∩ Ypa(c), Ysolo = Yc\Ypa(c)}
else {Yboth = {}, Ysolo = Yc}
for each u ∈ Yboth
initialize zc|x ← 0+, μc|x = 0, Σc|x = zc|xI
for each v ∈ Ysolo
{  w = u   v
αw = hc(w) Πb∈ch(c) zb|w
lw = fc(w) − μc|u + Σb∈ch(c) μb|w
∑  c     |     u     +=   ∑  b     ∈      ch   ( c )        ∑  b     |     w      +   tanh   (   1 2        ln   (   α w   z  c     |     u    )    )    2   ln   (   α w   z  c     |     u    )        l w    l w T
μ  c | u   +=    α w    z  c | u   +  α w      l w
zc|u+= αw              }
Output    Bound as z = zm, μ = μm, Σ = Σm

Algorithm 3 is efficient in the sense that computations involve enumerating over all configurations of each clique in the junction tree rather than over all configurations of Y. This shows that the computation involved is O(Σ_c|Y_c|) rather than O(|Ω|) as in Algorithm 1. Thus, for estimating the computational efficiency of various algorithms in this article, take n=Σ_c|Y_c| for the graphical model case rather than n=|Ω|. Algorithm 3 is a simple extension of the known recursions that are used to compute the partition function and its gradient vector. Thus, in addition to the Σ matrix which represents the curvature of the bound, Algorithm 3 is recovering the partition function value z and the gradient since

${\mu =\frac{\partial \ln Z\left(\theta \right)}{\partial \theta }}_{\theta =\tilde{\theta }}.$

FIG. 4 is a flow chart of an example method for parameter optimization for high dimensional models in accordance with at least one embodiment.

At 402 a system is provided with initial parameters and/or data having one or more large dimensions.

At 404, the quadratic bound of the partition function is updated by representing the curvature of the quadratic with a group of matrices of relatively low rank compared to a dimension of one or more of the inputs.

At 406, the system finds parameters that minimize a sum of the bounds.

At 408, the system updates stored parameters.

At 410, the system test for a termination condition. The termination condition can include one or more of the conditions described above with respect to 210 of FIG. 2.

At 412, the system provides parameters as output.

Consider the situation where d is large and Algorithm 2 cannot store and invert the matrix Σ=tλI+Σ_j=1^tΣ_j. Each loop of the algorithm requires O(tnd²+d³) time since step 2 requires computes each Σ_jε^d×d and step 3 performs inversion. Algorithm 4 provides a low-rank version of the bound which majorizes the log-partition function but requires only O^˜(tnd) complexity (on par with LBFGS). Below is a description of the mathematical algorithm changes to Algorithm 3 in order to efficiently handle high dimension inputs.

We first replace step 3 in Algorithm 2 with {tilde over (θ)}={tilde over (θ)}−Mu with M=Σ⁻¹ and u=tλ{tilde over (θ)}+Σ_j=1^tμ_j−ƒ_xj(y_j). Clearly, we can recover u by only computing μ_→j for j=1, . . . , t and skipping all steps involving matrices. This merely requires O(tnd) work. Second, instead of Σ, we initialize

$M=\frac{1}{t\lambda }I$

and use Sherman-Morrison to incrementally invert it via

$M_i=M_{i-1}-\frac{M_{i-1}q_iq_i^TM_{i-1}}{1+q_i^TM_{i-1}q_i}\mathrm{where}$ $q_i=\sqrt{\frac{\tanh \left(\frac{1}{2}\ln \left(\alpha /z\right)\right)}{2\ln \left(\alpha /z\right)}}\left(f_i-{\mu }_i\right).$

Here, the index i ranges over all rank 1 updates to the matrix Σ for all elements of Ω as well as j=1, . . . , t. Third, we store M using a low-rank representation VSV̂T+D where VεR̂(k×d) is orthonormal, SεR̂(k×k) is non-positive diagonal and DεR̂(n×n) is non-negative diagonal. To decrement the matrix by a rank one update of the form M_i=M_i−1−r_ir_i^T, simply project r_i onto each eigenvector in V and update the appropriate singular value in S. After k such projections, the remaining residual from r_i is a new candidate eigenvector e_(k+1) and its magnitude is a candidate singular value. The resulting rank (k+1) system is orthonormal with (k+1) singular values. We discard the smallest singular value and its corresponding eigenvector to revert back to an order k eigensystem. However, instead of discarding it we absorb the smallest singular value and eigenvector into the D component by bounding the remaining outer-product with a diagonal term. This provides a guaranteed overall upper bound in O^˜(tnd) (k is set be logarithmic with dimension d).

Algorithm 4
Input {tilde over (θ)}, ft(y) ∈  d and λ, ht(y) ∈  + with k ∈
S =  diag   ( 0 )    ,  V = orthonormal  ,  D =   1    t    λ     diag   ( I )
For each t {
Set z → 0+; μ = 0;
For each y {
α =    h t    ( y )     e    θ ~  T     f t    ( y )       ;  q =     tanh   (   1 2    ln   (  α z  )    )      2   ln   (  α z  )        (    f t    ( y )   - μ  )    ;
r =   V   (  S   (   V T   q  )   )   + Dq   ;  r =   1   1 +   r T   q      r   ;  r = r  ;
For j=1, . . . ,k
ρ = rTV(j,•); S(j, j) = S(j, j) − ρ2;
r = r − ρV(j,•); s = [S(1,1), . . . ,S(k,k), − ∥ r ∥2]T
{tilde over (k)} = argmaxi=1,...,k+1s(i);
if ({tilde over (k)} ≦ k) { {
D = D + S({tilde over (k)}, {tilde over (k)})|1TV(j,•)|diag(|V(k,•)|);
S({tilde over (k)}, {tilde over (k)})=−∥r∥{circumflex over ( )}2; r=∥r∥{circumflex over ( )}(−1) r; V(k,•)=r }
else { D = D − |1Tr|diag(|r|) } }
μ +=   α  z + α     (    f t    ( y )   - μ  )    ;  z += α  ;      }      }
Output S ∈ diag(  k×k),V ∈  d×k, D ∈ diag(  d×d)

FIG. 5 is a diagram of an example parameter optimization system 500 that can be used to optimize parameters in accordance with at least one embodiment. The system 500 includes a processor 502, an operating system 504, memory 506 and an I/O interface 508. The memory 506 can include a parameter optimizer 510 and a section for parameter data 512 and data used to optimize parameters by computing a quadratic bound on a partition function.

In operation, the processor 502 may execute the parameter optimizer 510 stored in the memory 506. The parameter optimizer 510 can include software instructions that, when executed by the processor, cause the processor to perform operations for optimizing parameters in accordance with the present disclosure (e.g., performing one or more of steps 102-112, 202-212, steps 302-312 and/or steps 402-412 described above).

The parameter optimizer 510 can operate in conjunction with the operating system 504 and utilize the parameter data 512 as described above.

FIG. 6 is a diagram of an example unsupervised machine learning environment 600. The environment 600 includes a machine learning system 602 and a prediction system 604.

In operation, the machine learning system 602 receives feature vectors 608 derived from input data (e.g., image data, audio data, text files, web pages or the like). The machine learning system can determine an optimized parameter set based on the input feature vectors. The parameters can be learned or tuned using one or more of the partition function bounding techniques described above.

The tuned or optimized parameters can be supplied by the machine learning system 602 to the prediction system 604. The prediction system 604 can receive a feature vector 612 derived from new input data 610. Using the parameters received from the machine learning system 602, the prediction system 604 can make a prediction about the feature vector 612 and produce an output 614. The output can include a likelihood, an expected label, a predicted result or the like.

FIG. 7 is a diagram of an example supervised machine learning environment 700. The environment 700 includes a machine learning system 702 and a prediction system 704.

In operation, the machine learning system 702 receives feature vectors 708 derived from input data (e.g., image data, audio data, text files, web pages or the like). As part of supervised learning, the machine learning system 702 can also receive information (e.g., labels 716) corresponding to the feature vectors 708. The machine learning system can determine an optimized parameter set based on the input feature vectors 708 and the labels 716. The parameters can be learned or tuned using one or more of the partition function bounding techniques described above.

The tuned or optimized parameters can be supplied by the machine learning system 702 to the prediction system 704. The prediction system 704 can receive a feature vector 712 derived from new input data 710. Using the parameters received from the machine learning system 602, the prediction system 604 can make a prediction about the feature vector 612 and produce an output 614. The output can include an expected label 714, for example.

Any system described above can include, but is not limited to, a single processor system, a multi-processor system (co-located or distributed), a cloud computing system, or a combination of the above.

Any client device described above can include, but is not limited to, a desktop computer, a laptop computer, a portable computer, a tablet computing device, a smartphone, a feature phone, a personal digital assistant, a media player, an electronic book reader, an entertainment system of a vehicle or the like.

Networks described herein can be wired or wireless networks, and can include, but are not limited to, WiFi networks, local area networks, wide area networks, the Internet, or a combination of the above.

Data storage, memory and/or computer readable media can include a nontransitory storage device such as a magnetic storage device (hard disk drive or the like), optical storage device (CD, DVD or the like), electronic storage device (RAM, ROM, flash, or the like). The software instructions can also be contained in, and provided as, an electronic signal.

Moreover, embodiments of the disclosed method, system, and computer readable media can be implemented in software executed on a programmed general purpose computer, a special purpose computer, a microprocessor, or the like.

It is, therefore, apparent that there is provided in accordance with the presently disclosed subject matter, a method, system, a computer program product and a computer readable media with software for parameter optimization. While this disclosed subject matter has been described in conjunction with a number of embodiments, it is evident that many alternatives, modifications and variations would be or are apparent to those of ordinary skill in the applicable arts. Accordingly, applicants intend to embrace all such alternatives, modifications, equivalents and variations that are within the spirit and scope of the disclosed subject matter.

APPENDIX TO THE SPECIFICATION

Maximum Entropy Problem

Partition functions arise naturally in maximum entropy estimation or minimum relative entropy

$\mathrm{RE}\left(p\parallel h\right)={\sum }_yp\left(y\right)\ln \frac{p\left(y\right)}{h\left(y\right)}$

estimation as follows

minRE(p∥h)s.t.Σ_yp(y)ƒ(y)=0, Σ_yp(y)g(y)≧0.

Therein, yεΩ, ƒ:Ω^d and g:Ω^d′ are arbitrary (non-constant) vector-valued functions over the sample space. The solution distribution p(y)=h(y)exp(θ^Tƒ(y)+θ^Tg(y))/Z(θ, θ) is recovered by the dual optimization

$\theta ,\vartheta =\underset{\vartheta \ge 0,\theta }{\stackrel{\arg }{\max }}-\ln {\sum }_yh\left(y\right)\exp \left({\theta }^Tf\left(y\right)+{\vartheta }^Tg\left(y\right)\right)$

where θε^d and θε^d′. These are obtained by minimizing Z(θ, θ) or equivalently by maximizing its negative logarithm. Algorithm 1 permits variational maximization of the dual via the quadratic program

$\underset{\vartheta \ge 0,\theta }{\min }\frac{1}{2}{\left(\beta -\tilde{\beta }\right)}^T\sum \left(\beta -\tilde{\beta }\right)+{\beta }^T\mu$

where β^T=[θ^Tθ^T]. Note that any general convex hull of constraints βεΛ⊂^d+d′ could be imposed without loss of generality.

Proof 1

Rewrite the partition function as a sum over the integer index j=1, . . . , n under the random ordering π:Ω{1, . . . , n}. This defines j=π(y) and associates h and ƒ with h_j=h(π⁻¹(j)) and ƒ_j=ƒ(π⁻¹(j)). Next, write Z(θ)=Σ_j=1ⁿα_jexp(λ^Tƒ_j) by introducing λ=θ−{tilde over (θ)} and α_j=h_jexp(θ^Tƒ_j). Define the partition function over only the first i components as Z_i(θ)=Σ_j=1ⁱα_jexp(λ^Tƒ_j). When i=0, a trivial quadratic upper bound holds

Z₀(θ)≦z₀exp(½λ^TΣ₀λ+λ^Tμ₀)

with the parameters z₀→0⁺, μ₀=0, and Σ₀=z₀I. Next, add one term to the current partition function Z₁(θ)=Z₀(θ)+α₁exp(λ^Tƒ₁). Apply the current bound Z₀(θ) to obtain

Z₁(θ)≦z₀exp(½λ^TΣ₀λ+λ^Tμ₀)+α₁exp(λ^Tƒ₁).

Consider the following change of variables

$u={\sum }_0^{1/2}\lambda -{\sum }_0^{-1/2}\left(f_1-{\mu }_0\right))\gamma =\frac{{\alpha }_1}{z_0}\exp \left(\frac{1}{2}{\left(f_1-{\mu }_0\right)}^T{\sum }_0^{-1}\left(f_1-{\mu }_0\right)\right)$

and rewrite the logarithm of the bound as

ln Z₁(θ)≦ln z₀−½(ƒ₁−μ₀)^TΣ₀⁻¹(ƒ₁−μ₀)+λ^Tƒ₁+ln(exp(½∥u∥²)+γ).

Apply the technique described in (T. Jebara, “Multitask sparsity via maximum entropy discrimination,” JMLR, 12:75-110, 2011) to the last term to get

$\ln Z_1\left(\theta \right)\le \ln z_0-\frac{1}{2}{\left(f_1-{\mu }_0\right)}^T{\sum }_0^{-1}\left(f_1-{\mu }_0\right)+{\lambda }^Tf_1+\ln \left(\exp \left(\frac{1}{2}{v}^2\right)+\gamma \right)+\frac{v^T\left(u-v\right)}{1+\mathrm{\gamma exp}\left(-\frac{1}{2}{v}^2\right)}+\frac{1}{2}{\left(u-v\right)}^T\left(I+\Gamma {\mathrm{vv}}^T\right)\left(u-v\right).$

Note that

$\Gamma =\frac{\tanh \left(\frac{1}{2}\ln \left(\gamma \exp \left(-\frac{1}{2}{v}^2\right)\right)\right)}{2\ln \left(\mathrm{\gamma exp}\left(-\frac{1}{2}{v}^2\right)\right)}.$

The bound is tight when u=v. To achieve tightness when θ={tilde over (θ)} or, equivalently, λ=0, choose v=E₀^−1/2(μ₀−ƒ₁) yielding

Z₁(θ)≦z₁exp(½λ^TΣ₁λ+λ^Tμ₁)

where we have

$z_1=z_0+{\alpha }_1{\mu }_1=\frac{z_0}{z_0+{\alpha }_1}{\mu }_0+\frac{{\alpha }_1}{z_0+{\alpha }_1}f_1{\sum }_1={\sum }_0+\frac{\tanh \left(\frac{1}{2}\ln \left({\alpha }_1/z_0\right)\right)}{2\ln \left({\alpha }_1/z_0\right)}\left({\mu }_0-f_1\right){\left({\mu }_0-f_1\right)}^T.$

This rule updates the bound parameters z₀, μ₀, Σ₀ to incorporate an extra term in the sum over i in Z(θ). The process is iterated n times (replacing 1 with i and 0 with i−1) to produce an overall bound on all terms.

Proof 2

Begin by upper-bounding (in the Loewner ordering sense) the matrices Σ_j in Algorithm 3. Since ∥ƒ_xj(y)∥²≦r for all yεΩ_j and since μ_j in Algorithm 1 is a convex combination of ƒ_xj(y), the outer-product terms in the update for Σ_j satisfy

(ƒ_xj(y)−μ)(ƒ_xj(y)−μ)^T°4rI.

Thus, Σ_j°F(α₁, . . . , α_n)4rI holds where

$F\left({\alpha }_1,\dots ,{\alpha }_n\right)={\sum }_{i=2}^n\frac{\tanh \left(\frac{1}{2}\ln \left(\frac{{\alpha }_i}{{\sum }_{k=1}^{i-1}{\alpha }_k}\right)\right)}{2\ln \left(\frac{{\alpha }_i}{{\sum }_{k=1}^{i-1}{\alpha }_k}\right)}$

using the definition of α₁, . . . , α_n in the proof of Theorem 1. The formula for F starts at i=2 since z₀→0⁺. Assume permutation π is sampled uniformly at random. The expected value of F is then

$E_{\pi }\left[F\left({\alpha }_1,\dots ,{\alpha }_n\right)\right]=\frac{1}{n!}{\sum }_{\pi }{\sum }_{i=2}^n\frac{\tanh \left(\frac{1}{2}\ln \left(\frac{{\alpha }_{\pi \left(i\right)}}{{\sum }_{k=1}^{i-1}{\alpha }_{\pi \left(k\right)}}\right)\right)}{2\ln \left(\frac{{\alpha }_{\pi \left(i\right)}}{{\sum }_{k=1}^{i-1}{\alpha }_{\pi \left(k\right)}}\right)}.$

We claim that the expectation is maximized when all α_i=1 or any positive constant. Also, F is invariant under uniform scaling of its arguments. Write the expected value of F as E for short. Next, consider

$\frac{\partial E}{\partial {\alpha }_l}$

at the setting α_i=1, ∀i. Due to the expectation over π, we have

$\frac{\partial E}{\partial {\alpha }_l}=\frac{\partial E}{\partial {\alpha }_o}$

for any l, o. Therefore, the gradient vector is constant when all α_i=1. Since F(α₁, . . . , α_n) is invariant to scaling, the gradient vector must therefore be the all zeros vector. Thus, the point when all α_i=1 is an extremum or a saddle. Next, consider

$\frac{\partial }{\partial {\alpha }_o}\frac{\partial E}{\partial {\alpha }_l}$

for any l, o. At the setting

${\alpha }_i=1,\frac{{\partial }^2E}{\partial {\alpha }_l^2}=-c\left(n\right)\mathrm{and},\frac{\partial }{\partial {\alpha }_o}\frac{\partial E}{\partial {\alpha }_l}=c\left(n\right)/\left(n-1\right)$

for some non-negative constant function c(n). Thus, the α_i=1 extremum is locally concave and is a maximum. This establishes that E_π[F(α₁, . . . , α_n)]≦E_π[F(1, . . . , 1)] and yields the Loewner bound

${\sum }_j^o\left(2r{\sum }_{i=1}^{n-1}\frac{\tanh \left(\ln \left(i\right)/2\right)}{\ln \left(i\right)}\right)I=\omega I.$

Apply this bound to each Σ_j in the lower bound on J(θ) and also note a corresponding upper bound

$J\left(\theta \right)\ge J\left(\tilde{\theta }\right)-\frac{t\omega +t\lambda }{2}{\theta -\tilde{\theta }}^2-{\sum }_j{\left(\theta -\tilde{\theta }\right)}^T\left({\mu }_j-f_{x_j}\left(y_j\right)\right)J\left(\theta \right)\le J\left(\tilde{\theta }\right)-\frac{t\lambda }{2}{\theta -\tilde{\theta }}^2-{\sum }_j{\left(\theta -\tilde{\theta }\right)}^T\left({\mu }_j-f_{x_j}\left(y_j\right)\right)$

which follows from Jensen's inequality. Define the current {tilde over (θ)} at time τ as θ_τ, and denote by L_τ(θ) the above lower bound and by U_τ(θ) the above upper bound at time τ. Clearly, L_τ(θ)≦J(θ)≦U_τ(θ) with equality when θ=θ_τ. Algorithm 3 maximizes J(θ) after initializing at θ₀ and performing an update by maximizing a lower bound based on Σ_j. Since L_τ(θ) replaces the definition of Σ_j with ωI±Σ_j, L_τ(θ) is a looser bound than the one used by Algorithm 3. Thus, performing θ_τ+1=arg max_θεΛL_τ(θ) makes less progress than a step of Algorithm 1. Consider computing the slower update at each iteration τ and returning θ_τ+1=arg max_θεΛL_τ(θ). Setting Φ=(tω+tλ)I, Ψ=tλI and

$\kappa =\frac{\omega +\lambda }{\lambda }$

allows us to apply Theorem 3 as follows

$\underset{\theta \in \Lambda }{\sup }L_{\tau }\left(\theta \right)-L_{\tau }\left({\theta }_{\tau }\right)=\frac{1}{\kappa }\underset{\theta \in \Lambda }{\sup }U_{\tau }\left(\theta \right)-U_{\tau }\left({\theta }_{\tau }\right).$

Since L_τ(θ_τ)=J(θ_τ)=U_τ(θ_τ), J(θ_τ+1)≧sup_θεΛL_τ(θ) and sup_θεΛU_τ(θ)≧J(θ*), we obtain

$J\left({\theta }_{\tau +1}\right)-J\left({\theta }^{*}\right)\ge \left(1-\frac{1}{\kappa }\right)\left(J\left({\theta }_{\tau }\right)-J\left({\theta }^{*}\right)\right).$

Iterate the above inequality starting at t=0 to obtain

$J\left({\theta }_{\tau }\right)-J\left({\theta }^{*}\right)\ge {\left(1-\frac{1}{\kappa }\right)}^{\tau }\left(J\left({\theta }_0\right)-J\left({\theta }^{*}\right)\right).$

A solution within a multiplicative factor of ε implies that

$\varepsilon ={\left(1-\frac{1}{\kappa }\right)}^{\tau }\mathrm{or}\ln \left(1/\varepsilon \right)=\tau \ln \frac{\kappa }{\kappa -1}.$

Inserting the definition for κ shows that the number of iterations τ is at most

$\lceil \frac{\ln \left(1/\varepsilon \right)}{\ln \frac{\kappa }{\kappa -1}}\rceil \mathrm{or}\lceil \frac{\ln \left(1/\varepsilon \right)}{\ln \left(1+\lambda /\omega \right)}\rceil .$

Inserting the definition for ω gives the bound.

Theorem 3

If κΨ±Φ>0 for Φ, Ψε^d×d, then

L(θ)=−½(θ−{tilde over (θ)})^TΦ(θ−{tilde over (θ)})−(θ−{tilde over (θ)})^TμU(θ)=−½(θ−{tilde over (θ)})^TΨ(θ−{tilde over (θ)})−(θ−{tilde over (θ)})^Tμ

satisfy

${\sup }_{\theta \in \Lambda }L\left(\theta \right)\ge \frac{1}{\kappa }{\sup }_{\theta \in \Lambda }U\left(\theta \right)$

for any convex Λ⊂^d, {tilde over (θ)}εΛ, με^d and κε⁺.

Proof 3

Define the primal problems of interest as P_L=sup_θεΛL(θ) and P_U=sup_θεΛU(θ). The constraints θεΛ can be summarized by a set of linear inequalities Aθ≦b where Aε^kd and bε^k for some (possibly infinite) kε. Apply the change of variables z=θ−{tilde over (θ)}. The constraint A(z+{tilde over (θ)})≦b simplifies into Az≦b where b=b−A{tilde over (θ)}. Since {tilde over (θ)}εΛ, it is easy to show that b≧0. We obtain the equivalent primal problems P_L=sup_Az≦b−½z^TΦz−z^Tμ and P_U=sup_Az≦b−½z^TΨz−z^Tμ. The corresponding dual problems are

$\begin{array}{c}{D}_L=\underset{y\ge 0}{\inf }\frac{y^TA{\Phi }^{-1}A^Ty}{2}+y^TA{\Phi }^{-1}\mu +y^Tb+\frac{{\mu }^T{\Phi }^{-1}\mu }{2}\\ D_U=\underset{y\ge 0}{\inf }\frac{y^TA{\Psi }^{-1}A^Ty}{2}+y^TA{\Psi }^{-1}\mu +y^Tb+\frac{{\mu }^T{\Psi }^{-1}\mu }{2}.\end{array}$

Due to strong duality, P_L=D_L and P_U=D_U. Apply the inequalities Φ°κΨ and y^Tb>0 as

$P_L\ge \underset{\mathrm{Az}\le b}{\sup }-\frac{\kappa }{2}z^T\Psi z-z^T\mu =\underset{y\ge 0}{\inf }\frac{y^TA{\Psi }^{-1}A^Ty}{2\kappa }+\frac{y^TA{\Psi }^{-1}\mu }{\kappa }+y{\hspace{0.17em}}^Tb+\frac{{\mu }^T{\Psi }^{-1}\mu }{2\kappa }\ge \frac{1}{\kappa }D_U=\frac{1}{\kappa }P_U.$

This proves that

$P_L\ge \frac{1}{\kappa }P_U.$

Theorem 4

For all uε^d, ln

$\left(\exp \left(\frac{1}{2}{u}^2\right)+\gamma \right)\le \ln \left(\exp \left(\frac{1}{2}{v}^2\right)+\gamma \right)+\frac{v^T\left(u-v\right)}{1+\gamma \exp \left(-\frac{1}{2}{v}^2\right)}+\frac{1}{2}{\left(u-v\right)}^T\left(I+\Gamma {\mathrm{vv}}^T\right)\left(u-v\right)$

when the scalar term

$\Gamma =\frac{\tanh \left(\frac{1}{2}\ln \left(\gamma \exp \left(-{v}^2/2\right)\right)\right)}{2\ln \left(\gamma \exp \left(-{v}^2/2\right)\right)}.$

The bound holds for any γ≧0 and vε^d. Strict equality is achieved when u=v.

Algorithm 5
Input {tilde over (θ)}, h12,0, f12,0 and zc1,1, Σc1,1, μc1,1 ∀c1,1 = 1, . . . , m1,1
Init z → 0+, μ = 0, Σ = zI
For each configuration Y120 {
α =h12,0 (Πc1,1=1m1,1zc1,1 exp(−{tilde over (θ)}T μc1,1))(−{tilde over (θ)}T (f12,0 + Σc1,1=1m1,1 μc1,1))
=   h 1  2 , 0     exp   (    θ ~  T    f 1  2 , 0    )      ∏   c  1 , 1   = 1   m  1 , 1          z  c  1 , 1
l =f12,0 + Σc1,1=1m1,1 μc1,1 − μ
∑  +=   ∑   c  1 , 1   = 1   m  1 , 1       ∑  c  1 , 1       +   tanh   (   1 2    (  α / z  )   )    2   ln   (  α / z  )        ll T
μ +=   α  z + α    l
z += α  }
Output z, μ, Σ

Proof of Correctness of Algorithm 3

Consider a simple junction tree of depth 2 (see, e.g., FIG. 8). The notation Y_c^a,b refers to the c^th tree node located on depth a, which has a parent b (for the root b=0). Note we assume the depth level of the tree increases moving from the leaves to the root.

$\sum _{Y_{c_1}^{a_1,b_1}}$

refers to the sum over all configurations of variables in

$Y_{c_1}^{a_1,b_1}\mathrm{and}\sum _{Y_{c_1}^{a_1,b_1}\setminus Y_{c_2}^{a_2,b_2}}$

refers to the sum over all configurations of variables that are in Y_c1^a1,b1 but not in Y_c2^a2,b2. The notation seems to be too complex for such small tree, but is should be clear that it can be directly applied to larger trees therefore we will further use it. To simplify the notation a little let: h_c1^a1,b1=h_c1^a1,b1(Y_c1^a1,b1), ƒ_c1^a1,b1=ƒ_c1^a1,b1(Y_c1^a1,b1) and ψ_c1^a1,b1=ψ_c1^a1,b1(Y_c1^a1,b1)=h_c1^a1,b1(Y_c1^a1,b1)exp(θ^Tƒ_c1^a1,b1(Y_c1^a1,b1)). The partition function can be expressed as:

$Z\left(\theta \right)=\sum _{Y_1^{2,0}}\left[{\psi }_1^{2,0}{\Pi }_{c^{1,1}=1}^{m_{1,1}}\left(\sum _{Y_{c^{1,1}}^{1,1}\setminus Y_1^{2,0}}{\psi }_{c^{1,1}}^{1,1}\right)\right]\le \hspace{1em}\sum _{Y_1^{2,0}}\left[{\psi }_1^{2,0}{\Pi }_{c^{1,1}=1}^{m_{1,1}}z_{c^{1,1}}\exp \left(\frac{1}{2}{\left(\theta -\tilde{\theta }\right)}^T\sum _{c^{1,1}}\left(\theta -\tilde{\theta }\right)+{\left(\theta -\tilde{\theta }\right)}^T{\mu }_{c^{1,1}}\right)\right]=\sum _{Y_1^{2,0}}\left[h_1^{2,0}\exp \left({\theta }^Tf_1^{2,0}\right){\Pi }_{c^{1,1}=1}^{m_{1,1}}z_{c^{1,1}}\exp \left(\frac{1}{2}{\left(\theta -\tilde{\theta }\right)}^T\sum _{c^{1,1}}\left(\theta -\tilde{\theta }\right)+{\left(\theta -\tilde{\theta }\right)}^T{\mu }_{c^{1,1}}\right)\right]$

where the upperbound comes from applying Theorem 1 to each of the terms:

$\sum _{Y_{c^{1,1}}^{1,1}\setminus Y_1^{2,0}}{\psi }_{c^{1,1}}^{1,1}.$

To explain the notation that will be further used, m_a,b denotes the number of children of b^th node situated on depth a+1.

Finally, by simply rearranging terms we get:

$Z\left(\theta \right)\le {\sum }_{Y_1^{2,0}}\left[\begin{array}{c}\begin{array}{c}{h}_1^{2,0}\left(\prod _{c^{1,1}=1}^{m_{1,1}}z_{c^{1,1}}\exp \left(-{\tilde{\theta }}^T{\mu }_{c^{1,1}}\right)\right)\\ \exp \left({\theta }^T\left(f_1^{2,0}+\sum _{c^{1,1}=1}^{m_{1,1}}{\mu }_{c^{1,1}}\right)\right)\end{array}\\ \exp (\frac{1}{2}{\left(\theta -\tilde{\theta }\right)}^T\left({\sum }_{c^{1,1}=1}^{m_{1,1}}{\sum }_{c^{1,1}}\right)\left(\theta -\tilde{\theta }\right)\end{array}\right]$

One can prove that this expression can be upperbounded by the expression of the form: zexp(½(θ−{circumflex over (θ)})^TΣ(θ−{circumflex over (θ)})+(θ−{circumflex over (θ)})^Tμ) where z, Σ and μ can be computed using Algorithm 5 (notice it is nothing more than just Algorithm 3 for this simple junction tree that we consider). We will call this result Lemma 1. The proof is a mirror analogy of Proof 1 and so we do not provide it.

Consider enlarging the previously discussed example tree to a tree of depth 3 (See, e.g., FIG. 9). The partition function can now be expressed as:

$Z\left(\theta \right)=\sum _{Y_1^{3,0}}\left[{\psi }_1^{3,0}{\Pi }_{c^{2,1}=1}^{m_{2,1}}\left(\sum _{Y_{c^{2,1}}^{2,1}\setminus Y_1^{3,0}}\left({\psi }_{c^{2,1}}^{2,1}{\Pi }_{c^{1,c^{2,1}}=1}^{m_{1,c^{2,1}}}\left(\sum _{Y_{c^{1,c^{2,1}}}^{1,c^{2,1}}\setminus Y_{c^{2,1}}^{2,1}}{\psi }_{c^{1,c^{2,1}}}^{1,c^{2,1}}\right)\right)\right)\right]$

By Lemma 1 we can upper bound each of the terms of the form:

${\sum }_{\begin{array}{c}{Y}^{2,1}\\ c^{2,1}\end{array}\backslash Y_1^{3,0}}\left({\psi }_{c^{2,1}}^{2,1}\prod _{c^{1,c^{2,1}}=1}^{m_{1,c^{2,1}}}\left({\sum }_{\begin{array}{c}{Y}^{1,c^{2,1}}\\ c^{1,c^{2,1}}\end{array}\backslash Y_{c^{2,1}}^{2,1}}{\psi }_{c^{1,c^{2,1}}}^{1,c^{2,1}}\right)\right)$

by the expressions of the form: z_c2,1exp (½(θ−{circumflex over (θ)})^TΣ_c2,1(θ−{circumflex over (θ)})+(θ−{circumflex over (θ)})^Tμ_c2,1) yielding:

Z(θ)≦Σ_Y13,0[ψ₁^3,0Π_c2,1=1^m2,1z_c2,1exp(½(θ−{tilde over (θ)})^TΣ_c2,1(θ−{tilde over (θ)})+(θ−{tilde over (θ)})^Tμ_c2,1)]

This process can be viewed as collapsing the subtrees S₁^2,1, S₂^2,1, . . . , S_m2,1^2,1 to supernodes that are represented by bound parameters: z_c2,1, Σ_c2,1 and μ_c2,1. Notice that the obtained expression can be further upper bounded using again Lemma 1 (induction) yielding the bound of the form: zexp(½(θ−{circumflex over (θ)})^TΣ(θ−{circumflex over (θ)})+(θ−{circumflex over (θ)})^Tμ). Also, notice this procedure yields nothing more than just Algorithm 5 for this junction tree that we consider.

The partition function of a general junction tree of depth p can be expressed as:

$Z\left(\theta \right)={\sum }_{Y_1^{p,0}}\left[{\psi }_1^{p,0}{\prod }_{c^{p-1,1}=1}^{m_{p-1,1}}\left(\begin{array}{c}{\sum }_{\begin{array}{c}{Y}^{{}^{p-1,1}}\\ c^{{}^{p-1,1}}\end{array}\backslash Y_1^{p,0}}{\psi }_{c^{p-1,1}}^{p-1,1}{\prod }_{c^{p-2,c^{p-1,1}}}^{m_{p-2,c^{p-1,1}}}\\ \left({\sum }_{\begin{array}{c}{Y}^{p-2,c^{p-1,1}}\\ c^{p-2,c^{p-1,1}}\end{array}\backslash Y_{c^{p-1,1}}^{p-1,1}}\left({\psi }_{c^{p-2,c^{p-1,1}}}^{p-2,c^{p-1,1}}\dots \right)\right)\end{array}\right)\right]$

It should now be clear that for this ‘general’ tree, one can follow exactly the same steps as described before, start from leaves and collapse nodes to supernodes, each represented by bound parameters. It yields Algorithm 5. We do not provide a formal induction proof to avoid using complex notation.

Proof of Correctness of Algorithm 4

We begin by proving a theorem that will be useful later.

Theorem 5

For all xε^d and for all lε^d:

$\sum _{i=1}^d{x\left(i\right)}^2{l\left(i\right)}^2\ge {\left(\sum _{i=1}^dx\left(i\right)\frac{{l\left(i\right)}^2}{\sqrt{\sum _{j=1}^d{l\left(j\right)}^2}}\right)}^2$

Proof 5

By Jensen's inequality:

$\sum _{i=1}^d{x\left(i\right)}^2\frac{l{\left(i\right)}^2}{\sum _{j=1}^d{l\left(j\right)}^2}\ge {\left(\sum _{i=1}^dx\left(i\right)\frac{{l\left(j\right)}^2}{\sum _{j=1}^d{l\left(j\right)}^2}\right)}^2\Leftarrow \stackrel{d}{\sum _{i=1}}{x\left(i\right)}^2{l\left(i\right)}^2\ge {\left(\sum _{i=1}^dx\left(i\right)\frac{l{\left(i\right)}^2}{\sqrt{\sum _{j=1}^d{l\left(j\right)}^2}}\right)}^2$

At i^th iteration we store M_i using a low-rank representation V_i^TS_iV_i+D_i where V_iε^k×d is orthonormal, S_iε^k×k is non-positive diagonal and D_iε^d×d is non-negative diagonal (each diagonal term of D₁ (initialization) is set to 1/tλ where λ is the regularization term). We consider decrementing the matrix by a rank one update of the form M_i=M_i−1−r_ir_i^T. By projecting r_i onto each eigenvector in V, we can decompose r_i as: r_i=Σ_j=1^kV_i−1(j,•)r_iV_i−1(j,•)^T+res=V_i−1^TV_i−1r_i+res. Thus the update rule can be rewritten as:

$\begin{array}{cc}\begin{array}{c}{M}_i=M_{i-1}-r_ir_i^T\\ =V_{i-1}^TS_{i-1}V_{i-1}+D_{i-1}-\left(V_{i-1}^TV_{i-1}r_i+\mathrm{res}\right)\\ {\left(V_{i-1}^TV_{i-1}r_i+\mathrm{res}\right)}^T\\ =V_{i-1}^T\left(S_{i-1}-V_{i-1}r_ir_i^TV_{i-1}^T\right)V_{i-1}+D_{i-1}-{\mathrm{resres}}^T\\ =V_{i-1}^TS_{i-1}^{\prime }V_{i-1}+D_{i-1}-{\mathrm{resres}}^T\end{array}& \\ \mathrm{where}S_{i-1}^{\prime }=S_{i-1}-V_{i-1}r_ir_i^TV_{i-1}^T& \end{array}$

• • Notice that S_i−1′ can only have nonpositive entrances since S is initialized by a matrix of all zeros and then it is updated by subtracting nonnegative values from its diagonal.

By discarding the smallest singular value and its corresponding eigenvector, one ends up with matrix M_i′ of one of the following form:

1) If res was discarded:

M_i′=V_i−1^TS_i−1′V_i−1+D_i−1=M_i+resres^T=M_i+cvv^T

where c=1 and v=res

2) Otherwise, if m^th eigenvector was discarded:

$\begin{array}{c}{M}_i^{\prime }=V_{i-1}^TS_{i-1}^{\prime }V_{i-1}+D_{i-1}-{\mathrm{resres}}^T-S^{\prime }\left(m,m\right){V\left(m,·\right)}^TV\left(m,·\right)\\ =M_i-S^{\prime }\left(m,m\right){V\left(m,·\right)}^TV\left(m,·\right)\\ =M_i+{\mathrm{cvv}}^T\end{array}$

where c=−S′(m, m) and v=V(m,•)

Notice that both cases can be combined using the notation: M_i′=M_i+cvv^T where c≧0 (since c=−S′(m, m) can only be nonnegative).

By discarding the smallest singular value and its corresponding eigenvector we violate the bound. Alternatively, instead of discarding, we can absorb those terms into a diagonal component, satisfying the bound. Formally, we look for diagonal matrix F such that M_i″=M_i′−F and for all xε^d: x^TΣ_i″x≧x^TΣ_ix where Σ_i=M_i⁻¹ and Σ_i″=M_i″⁻¹. Thus, we want to satisfy:

x^TΣ_i″x≧x^TΣ_ixx^TM_i″⁻¹x≧x^TM_i⁻¹xx^T(M_i′−F)⁻¹x≧x^TM_i⁻¹x

x^T(M_i+cvv^T−F)⁻¹x≧x^TM_i⁻¹x

From positive definiteness (throughout all iterations positive definiteness can be satisfied by the proper choice of λ while initializing D₁, notice that to break positive definiteness in any iteration one would have to set λ to a very large value in the initialization, i.e. 1e23, which obviously is unreasonable in practice) it is equivalent to satisfy:

x^T(M_i+cvv^T−F)x≧x^TM_ixx^Tcvv^Tx≧x^TFxc(Σ_i=1^dx(i)v(i))²≦Σ_i=1^dx(i)²F(i)

where for the ease of notation F(i)=F(i, i).

Let

${\forall }_{i=1,\dots ,d}{v\left(i\right)}^{\prime }=\frac{v\left(i\right)}{w}\mathrm{where}W=\sum _{j=1}^dv\left(j\right).$

Let also for now assume that ∀_{i=1, . . . , d}v(i)≧0. We will very soon get rid of this assumption. Thus we look for F such that: Σ_i=1^dx(i)²F(i)≧c(Σ_i=1^dx(i)Wv(i)′)²Σ_i=1^dx(i)²F(i)≧cW²(Σ_i=1^dx(i)v(i)′)²

$\sum _{i=1}^d{x\left(i\right)}^2\frac{F\left(i\right)}{{\mathrm{cW}}^2}\ge {\left(\sum _{i=1}^dx\left(i\right){v\left(i\right)}^{\prime }\right)}^2.$

Let

${\forall }_{i=1,\dots ,d}{F\left(i\right)}^{\prime }=\frac{F\left(i\right)}{{\mathrm{cW}}^2}.$

Thus we look for F′ such that: Σ_i=1^dx(i)²F(i)′≧(Σ_i=1^dx(i)v(i)′)². By Theorem 5 one can easily show that the solution is F′=v(i)′ (simply substitute l(i)=sqrt(v(i)′) and keep in mind Σ_j=1^dv(j)′=1). Thus:

${F\left(i\right)}^{\prime }={v\left(i\right)}^{\prime }=\frac{v\left(i\right)}{W}.$

Finally,

$F\left(i\right)={\mathrm{cW}}^2{F\left(i\right)}^{\prime }={\mathrm{cW}}^2\frac{v\left(i\right)}{W}=\mathrm{cWv}\left(i\right)=\mathrm{cv}\left(i\right)\sum _{j=1}^dv\left(j\right).$

Thus for all xε^d and for all xε^d such that ∀i=1, . . . , d:v(i)≧0 and for F(i)=cv(i)Σ_j=1^dv(j) the following inequality holds:

Σ_i=1^dx(i)²F(i)≧c(Σ_i=1^dx(i)v(i))²  (3)

To generalize the inequality to hold for all vectors vε^d (also with negative entrances), it is sufficient to set F(i)=c|v(i)|Σ_j=1^d|v(j)|. To see it consider flipping the sign of any v(i), the left side of the Inequality 3 does not change. For the right side of this inequality, flipping the sign of v(i) is equivalent to flipping the sign of x(i) and not changing the sign of v(i), but in this case the inequality holds as proven before (it holds for any xε^d). Thus for all xε^d and for all vε^d and for F(i)=c|v(i)|Σ_j=1^d|v(j)|, Inequality 3 holds.

Claims

1. A system for optimizing parameters of a structured prediction model, the system comprising:

a computer-readable medium;

a parameter optimization processor coupled to the computer-readable medium; and

a communication interface coupled to the parameter optimization processor and adapted to receive and transmit electronic representations of structured prediction models to and from the parameter optimization processor, respectively,

the computer-readable medium having stored thereon software instructions that, when executed by the parameter optimization processor, cause the parameter optimization processor to perform operations including:

initializing a group of parameters to respective values corresponding to a state within a set of allowable structured prediction models;

bounding a partition function across a number of variable pairs to generate a plurality of bounds each being a quadratic upper bound on a partition function;

determining new values for the group of parameters that minimize a sum of the plurality of bounds;

setting the group of parameters to the new values;

optimizing the parameters by iteratively performing the bounding, determining and setting; and

stopping the optimizing when a termination condition is reached.

2. The system of claim 1, wherein the bounding includes updating a partition function value, a gradient and a curvature of the quadratic upper bound.

3. The system of claim 1, wherein the termination condition includes determining that a difference between a conditional likelihood based on the current parameters and a previous conditional likelihood based on previous parameters is less than a predetermined value.

4. The system of claim 1, wherein the termination condition includes determining that a difference between a current set of parameters and a previous set of parameters is less than a predetermined threshold value.

5. The system of claim 1, wherein the termination condition includes performing a predetermined number of iterations.

6. The system of claim 1, wherein the termination condition includes performing the bounding, determining and setting for a predetermined period of time.

7. The system of claim 1, wherein the set of allowable models forms a convex hull.

8. The system of claim 1, wherein each variable pair includes an observed input value and an observed output value.

9. The system of claim 1, wherein each variable pair includes a first sample and a second sample from an unknown distribution.

10. The system of claim 1, wherein the structured prediction model includes one of a deep belief network, a machine learning model, a pattern recognition model, a shallow parsing model, a named entity recognition model, a gene finding model, an object recognition model and an image segmentation model.

11. A computerized method for optimizing parameters for a structured prediction system, the method comprising:

initializing a group of parameters to respective values corresponding to a state within a set of allowable models;

bounding a partition function across a number of variable pairs to generate a plurality of bounds, wherein the bounding includes computing a quadratic upper bound on the partition function;

determining new values for the group of parameters that minimize a sum of the plurality of bounds;

setting the group of parameters to the new values;

optimizing the parameters by iteratively performing the bounding, determining and setting; and

stopping the optimizing when a termination condition is reached.

12. The method of claim 11, wherein the bounding includes updating a partition function value, a gradient and a curvature of the quadratic upper bound.

13. The method of claim 11, wherein the termination condition includes determining that a difference between a conditional likelihood based on the current parameters and a previous conditional likelihood based on previous parameters is less than a predetermined value.

14. The method of claim 11, wherein the termination condition includes determining that a difference between a current set of parameters and a previous set of parameters is less than a predetermined threshold value.

15. The method of claim 11, wherein the termination condition includes performing a predetermined number of iterations.

16. The method of claim 11, wherein the termination condition includes performing the bounding, determining and setting for a predetermined period of time.

17. The method of claim 11, wherein the set of allowable models forms a convex hull.

18. The method of claim 11, wherein each variable pair includes an observed input value and an observed output value.

19. The method of claim 11, wherein each variable pair includes a first sample and a second sample from an unknown distribution.

20. The method of claim 11, wherein the structured prediction system includes one of a machine learning system, a pattern recognition system, a shallow parsing system, a named entity recognition system, a gene finding system, an object recognition system and an image segmentation system.

21. The method of claim 11, wherein the bounding includes:

providing a graphical model arranged as a junction tree;

computing bounds for a set of variables that a clique of the junction tree has in common with a parent clique of the clique;

collecting pre-computed bounds from child cliques of the clique;

updating quadratic bound variables for the clique based on the computed bounds and the collected pre-computed bounds;

terminating the updating when a root clique is reached; and

outputting a curvature of a partition function bound, a partition function value and a gradient,

wherein the computing, collecting and updating are performed recursively beginning with leaf cliques of the junction tree and progressing toward root cliques.

22. The method of claim 11, wherein the bounding includes:

computing a partition function value;

computing a gradient vector for a number of indices; and

computing a curvature of a bound, wherein the curvature is stored as a group of low rank matrices including a first matrix having singular values, a second matrix having eigenvectors and a third matrix being a diagonal matrix.

23-62. (canceled)

63. A computerized method for optimizing parameters for a structured prediction system, the method comprising:

initializing a group of parameters to respective values corresponding to a state within a set of allowable models;

bounding a partition function, wherein the bounding includes one or more of:

a) computing a quadratic upper bound on the partition function;

b) iteratively computing upper bounds on the partition function and selecting parameters to minimize a sum of the bounds;

c) computing a partition function bound for a latent likelihood model;

d) computing a partition function bound for a graphical model; and

e) computing a partition function bound for a high dimensional model using a plurality of matrices to represent a curvature of the partition function bound;

determining new values for the group of parameters based on the bounding;

setting the group of parameters to the new values;

optimizing the parameters by iteratively performing the bounding, determining and setting; and

stopping the optimizing when a termination condition is reached.

64. The method of claim 63, wherein the optimizing converges monotonically.

65. The method of claim 63, wherein the optimizing converges monotonically when the bounding includes computing a partition function bound for a latent likelihood model.