예제 #1
0
// QuasiNewtonMin uses the Quasi-Newton method to carry out multi-dimensional minimisation
func QuasiNewtonMin(x0 matrix.Matrix, N int, f func(matrix.Matrix, int) float64) (x1 matrix.Matrix) {
	// Create G matrix, initially identity matrix
	G, _ := matrix.Identity(x0.Size().Y)

	// Central difference scheme to calculate gradient
	CDS := func(in matrix.Matrix) matrix.Matrix {
		res, _ := matrix.New(in.Size())
		var p, m float64
		res.Foreach(func(r, c int) {
			in[r][c] += 1e-8
			p = f(in, N)
			in[r][c] -= 2e-8
			m = f(in, N)
			in[r][c] += 1e-8
			res[r][c] = (p - m) / 2e-8
		})
		return res
	}

	a := 1.0
	r0 := CDS(x0)
	x1, _ = matrix.New(x0)
	var cond int
	var dx, ddx, tmp, tmp1, tmp2, r1, dr matrix.Matrix

	// Main minimisation loop
	for i := 0; i < 1000; i++ {

		// Determine a using Wolfe Conditions
		a, cond = 1.0, 0
		for {
			// tmp = p_k
			tmp, _ = G.Multiply(r0)
			tmp, _ = tmp.Multiply(-1)

			tmp1, _ = tmp.Multiply(a)
			tmp1, _ = x0.Add(tmp1)

			// Check last term only if condition not yet met
			if cond == 0 {
				tmp2, _ = tmp.Transpose().Multiply(r0)

				// Sufficient Decrease Condition
				if f(tmp1, N) <= f(x0, N)+a*1e-4*tmp2[0][0] {
					cond++
				}
			}

			// If first condition met, try second condition
			if cond > 0 {
				tmp1, _ = tmp.Transpose().Multiply(CDS(tmp1))
				tmp2, _ = tmp.Transpose().Multiply(r0)

				// Curvature Condition
				// fmt.Println(tmp1[0][0], 0.9*tmp2[0][0])
				if math.Abs(tmp1[0][0]) >= 0.9*math.Abs(tmp2[0][0]) {
					break
				}
			}

			// Backtracking line search
			a *= 0.5
			cond = 0 // Reset checked cond count
		}

		// Find next x
		tmp, _ = G.Multiply(a)
		tmp, _ = tmp.Multiply(r0)
		x1, _ = x0.Subtract(tmp)
		// fmt.Println(i, "x1:", x1)

		// Calculate change in x and grad
		r1 = CDS(x1)
		// fmt.Println(i, "r1:", r1)

		// Convergence condition:
		// when gradient no longer changes
		if r0[0][0] == r1[0][0] && r0[1][0] == r1[1][0] {
			break
		}

		dx, _ = x1.Subtract(x0)
		dr, _ = r1.Subtract(r0)

		// First term in increment of G
		tmp, _ = dr.Transpose().Multiply(dx)
		ddx, _ = dx.OuterProduct(dx)
		tmp1, _ = ddx.Multiply(1 / tmp[0][0])
		// fmt.Println(i, "G:", G)

		// Second term in increment of G
		tmp, _ = dr.Transpose().Multiply(G)
		tmp, _ = tmp.Multiply(dr)
		tmp2, _ = G.Multiply(dr)
		tmp2, _ = tmp2.OuterProduct(dr)
		tmp2, _ = tmp2.OuterProduct(G)
		tmp2, _ = tmp2.Multiply(1 / tmp[0][0])

		// Update G for next x
		G, _ = G.Add(tmp1)
		// fmt.Println(i, "Add -> G:", G)
		G, _ = G.Subtract(tmp2)
		// fmt.Println(i, "Subtract -> G:", G)

		// Update old x and grad for later dx and dgrad
		x0 = x1
		r0 = r1
	}
	return
}
예제 #2
0
파일: main.go 프로젝트: swook/go.iccp
func main() {
	/*
		Plot histograms of sigma with varying bin widths
	*/
	createHistogram(data[0], 50)
	createHistogram(data[0], 100)
	createHistogram(data[0], 500)
	createHistogram(data[0], 1000)
	createHistogram(data[0], 5000)
	fmt.Println("Plotted histogram of source data")

	/*
		Plot fit function graphs
	*/
	var x, y []float64
	N := len(data[0])
	tau := 0.1
	sigma := 0.1

	// vary sigma
	xs := make([][]float64, 5)
	ys := make([][]float64, 5)
	yls := make([]string, 5)
	for i := 0; i < 5; i++ {
		xs[i], ys[i] = calcFitFunc(0.0, 0.01, tau, sigma)
		yls[i] = fmt.Sprintf("sigma = %.1f", sigma)
		sigma += 0.2
	}
	createLine(xs, ys, yls, fmt.Sprintf("Fit Function (tau = %.1f)", tau))

	// vary tau
	tau, sigma = 0.1, 0.1
	for i := 0; i < 5; i++ {
		xs[i], ys[i] = calcFitFunc(0.0, 0.01, tau, sigma)
		yls[i] = fmt.Sprintf("tau = %.1f", tau)
		tau += 0.2
	}
	createLine(xs, ys, yls, fmt.Sprintf("Fit Function (sigma = %.1f)", sigma))
	fmt.Println("Plotted fit function with varying variables")

	/*
		Plot NLL vs tau for idea of what we're minimising
	*/
	tau = 0.1
	x = make([]float64, 0, 100)
	y = make([]float64, 0, 100)
	for i := 0; i < 100; i++ {
		x = append(x, tau)
		y = append(y, NLLFunc(tau, N))
		tau += 0.01
	}
	createScatter(x, y, "NLL vs tau")
	fmt.Println("Plotted NLL against tau")

	/*
		Parabolic Minimisation
	*/
	tau = parabolicMin(0.5, N, NLLFunc)
	fmt.Println("Minimum of NLL (no Background) found using parabolic method: tau =", tau, "NLL =", NLLFunc(tau, N))

	/*
		Plot std dev of 1-d fit result
	*/
	var min, tau_p, tau_m float64
	x = make([]float64, 0, 100)
	y = make([]float64, 0, 100)
	mins := make([]float64, 0, 100)
	for i := 0; i < 100; i++ {
		N = len(data[0]) - i*50
		tau_p, min, tau_m = tauFromNLL(0.5, N)
		x = append(x, float64(N))
		mins = append(mins, min)
		y = append(y, tau_p-tau_m)
	}
	createScatter(x, y, "Standard Deviation vs Sample Size")
	fmt.Println("Plotted graph of standard dev vs sample size")
	saveFile("stddev v samp size.txt", [][]float64{x, y})

	createScatter(x, mins, "Determined Minimum vs Sample Size")
	fmt.Println("Plotted graph of minimum found through parabolic minimisation vs sample size")
	saveFile("parabolic min v samp size.txt", [][]float64{x, mins})
	N = len(data[0])

	/*
		Find minimum tau and a for NLLFuncWithBG
	*/
	x0, _ := matrix.New("0.4;0.1")
	x0 = QuasiNewtonMin(x0, N, NLLFuncWithBG)
	fmt.Println("Minimum of NLL (w Background) found using Quasi-Newton DFP method: tau =",
		x0[0][0], "a =", x0[1][0], "NLL =", NLLFuncWithBG(x0, N))

	/*
		Plot of NLLFuncWithBG against tau to confirm minimum found in previous step
	*/
	tau = 0.1
	var mat matrix.Matrix
	x = make([]float64, 0, 100)
	y = make([]float64, 0, 100)
	for i := 0; i < 100; i++ {
		x = append(x, tau)
		mat, _ = matrix.New(fmt.Sprintf("%f;0.983684", tau))
		y = append(y, NLLFuncWithBG(mat, N))
		tau += 0.01
	}
	createScatter(x, y, fmt.Sprintf("NLL with BG, a = %f", x0[1][0]))

	/*
		Find error of NLLBG fit
	*/
	tau_p, tau_m = tauFromNLLBG(x0, 0.5, N)
	fmt.Println("Error of calculated NLL (w BG) is: ", tau_p-tau_m)
}