jeffrey-hokanson / PSDR / 378

pending completion

Build # 378

Build Type

push

travis-ci

Committed by

jeffrey-hokanson

Commit Message

Fixed empty domain trouble

Run Details

1276 of 1716 branches covered (74.36%)

Branch coverage included in aggregate %.

13 of 13 new or added lines in 2 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

4736 of 5295 relevant lines covered (89.44%)

3.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.88

/psdr/sample/latin.py

""" Latin Hypercube sampling and variants"""
from __future__ import division, print_function

import numpy as np
from scipy.spatial.distance import squareform, pdist

def _score_maximin(X):
        D = squareform(pdist(X))
        D += np.max(D)*np.eye(D.shape[0])
        min_dist = np.min(D, axis = 0)
        return tuple(np.sort(min_dist))


def latin_hypercube_maximin(domain, N, maxiter = 1000):
        r""" Construct a maximin distance Latin hypercube design

        This function builds a Latin hypercube design on a specified domain, 
        choosing samples that both satisfy the Latin hypercube requirement
        of uniform projection onto the coordinate axes as well as 
        samples that maximize the minimum pairwise distance.  

        

        Parameters
        ----------
        domain: Domain
                Domain on which to construct the design
        N: int
                Number of samples to take
        maxiter: int, optional
                Number of iterations to perform trying to find the best design
        """
        if domain.is_box_domain:
                return _latin_hypercube_maximin_box(domain, N, maxiter = maxiter)
        else:
                from .projection import projection_sample 
                return projection_sample(domain, N, None, maxiter = maxiter, _lhs = True) 


def _latin_hypercube_maximin_box(domain, N, maxiter = 1000):
        r""" Construct a maximin distance Latin hypercube design

        Parameters
        ----------
        domain: Domain
                Domain on which to construct the design
        """

        assert domain.is_box_domain, "This only works on box domains"
        

        # Coordinates along each axis we'll be sampling at
        xs = []
        for i in range(len(domain)):
                xi = np.linspace(domain.norm_lb[i], domain.norm_ub[i], N + 1)
                xi = (xi[1:]+xi[0:-1])/2.
                xs.append(xi)
        
        score_best = tuple(np.zeros(N))
        X_best = None
        # Generate random initial permutations
        perms_best = np.vstack([np.random.permutation(N) for i in range(len(domain))])
        
        for it in range(maxiter):
                # Generate new permutation of the permutations
                i, j = np.random.permutation(N)[0:2]
        
                r = np.random.rand(len(domain))
                I = r >= min(max(r), 0.5)
                perms = np.copy(perms_best)
                perms[I,i] = perms_best[I,j]
                perms[I,j] = perms_best[I,i]

                # Generate samples 
                X = np.array([ [xs[i][j] for j in perms[i]] for i in range(len(domain))]).T

                score = _score_maximin(X)

                if score > score_best:
                        perms_best = perms
                        X_best = X
                        score_best = score

                
        return X_best        

# JMH: I am depreciating this version because it produces far worse designs than the other code

#def latin_hypercube_random(domain, N, metric = 'maximin', maxiter = 100, jiggle = False):
#        r""" Generate a Latin-Hypercube design
#
#        
#
#        This implementation is based on [PyDOE](https://github.com/tisimst/pyDOE/blob/master/pyDOE/doe_lhs.py). 
#
#
#        Parameters
#        ----------
#        N: int
#                Number of samples to take
#        metric: ['maximin', 'corr']
#                Metric to use when selecting among multiple Latin Hypercube designs. 
#                One of
#        
#                - 'maximin': Maximize the minimum distance between points, or 
#                - 'corr' : Minimize the correlation between points.
#
#        jiggle: bool, default False
#                If True, randomize the points within the grid specified by the 
#                Latin hypercube design.
#
#        maxiter: int, default: 100
#                Number of random designs to generate in attempting to find the optimal design 
#                with respect to the metric.
#        """        
#
#        N = int(N)
#        assert N > 0, "Number of samples must be positive"
#        assert metric in ['maximin', 'corr'], "Invalid metric specified"
#
#        xs = []
#        for i in range(len(domain)):
#                xi = np.linspace(domain.norm_lb[i], domain.norm_ub[i], N + 1)
#                xi = (xi[1:]+xi[0:-1])/2.
#                xs.append(xi)
#
#        # Higher score == better
#        score = -np.inf
#        X = None
#        for it in range(maxiter):
#                # Select which components of the hypercube
#                I = [np.random.permutation(N) for i in range(len(domain))]
#                # Generate actual points
#                X_new = np.array([ [xs[i][j] for j in I[i]] for i in range(len(domain))]).T
#
#                # Here we would jiggle points if so desired
#                if jiggle:
#                        for i in range(len(domain)):
#                                h = xs[i][1] - xs[i][0] # Grid spacing
#                                X_new[:,i] += np.random.uniform(-h/2, h/2, size = N)        
#
#                # Evaluate the metric
#                if metric == 'maximin':
#                        new_score = np.min(pdist(X_new))
#                elif metric == 'corr':
#                        new_score = -np.linalg.norm(np.eye(len(domain)) - np.corrcoef(X_new.T))
#
#                if new_score > score:
#                        score = new_score
#                        X = X_new
#
#        return X





1	""" Latin Hypercube sampling and variants"""
2	from __future__ import division, print_function	4✔
3
4	import numpy as np	4✔
5	from scipy.spatial.distance import squareform, pdist	4✔
6
7	def _score_maximin(X):	4✔
8	D = squareform(pdist(X))	4✔
9	D += np.max(D)*np.eye(D.shape[0])	4✔
10	min_dist = np.min(D, axis = 0)	4✔
11	return tuple(np.sort(min_dist))	4✔
12
13
14	def latin_hypercube_maximin(domain, N, maxiter = 1000):	4✔
15	r""" Construct a maximin distance Latin hypercube design
16
17	This function builds a Latin hypercube design on a specified domain,
18	choosing samples that both satisfy the Latin hypercube requirement
19	of uniform projection onto the coordinate axes as well as
20	samples that maximize the minimum pairwise distance.
21
22
23
24	Parameters
25	----------
26	domain: Domain
27	Domain on which to construct the design
28	N: int
29	Number of samples to take
30	maxiter: int, optional
31	Number of iterations to perform trying to find the best design
32	"""
33	if domain.is_box_domain:	4!
34	return _latin_hypercube_maximin_box(domain, N, maxiter = maxiter)	4✔
35	else:
UNCOV 36	from .projection import projection_sample	×
UNCOV 37	return projection_sample(domain, N, None, maxiter = maxiter, _lhs = True)	×
38
39
40	def _latin_hypercube_maximin_box(domain, N, maxiter = 1000):	4✔
41	r""" Construct a maximin distance Latin hypercube design
42
43	Parameters
44	----------
45	domain: Domain
46	Domain on which to construct the design
47	"""
48
49	assert domain.is_box_domain, "This only works on box domains"	4✔
50
51
52	# Coordinates along each axis we'll be sampling at
53	xs = []	4✔
54	for i in range(len(domain)):	4✔
55	xi = np.linspace(domain.norm_lb[i], domain.norm_ub[i], N + 1)	4✔
56	xi = (xi[1:]+xi[0:-1])/2.	4✔
57	xs.append(xi)	4✔
58
59	score_best = tuple(np.zeros(N))	4✔
60	X_best = None	4✔
61	# Generate random initial permutations
62	perms_best = np.vstack([np.random.permutation(N) for i in range(len(domain))])	4✔
63
64	for it in range(maxiter):	4✔
65	# Generate new permutation of the permutations
66	i, j = np.random.permutation(N)[0:2]	4✔
67
68	r = np.random.rand(len(domain))	4✔
69	I = r >= min(max(r), 0.5)	4✔
70	perms = np.copy(perms_best)	4✔
71	perms[I,i] = perms_best[I,j]	4✔
72	perms[I,j] = perms_best[I,i]	4✔
73
74	# Generate samples
75	X = np.array([ [xs[i][j] for j in perms[i]] for i in range(len(domain))]).T	4✔
76
77	score = _score_maximin(X)	4✔
78
79	if score > score_best:	4✔
80	perms_best = perms	4✔
81	X_best = X	4✔
82	score_best = score	4✔
83
84
85	return X_best	4✔
86
87	# JMH: I am depreciating this version because it produces far worse designs than the other code
88
89	#def latin_hypercube_random(domain, N, metric = 'maximin', maxiter = 100, jiggle = False):
90	# r""" Generate a Latin-Hypercube design
91	#
92	#
93	#
94	# This implementation is based on [PyDOE](https://github.com/tisimst/pyDOE/blob/master/pyDOE/doe_lhs.py).
95	#
96	#
97	# Parameters
98	# ----------
99	# N: int
100	# Number of samples to take
101	# metric: ['maximin', 'corr']
102	# Metric to use when selecting among multiple Latin Hypercube designs.
103	# One of
104	#
105	# - 'maximin': Maximize the minimum distance between points, or
106	# - 'corr' : Minimize the correlation between points.
107	#
108	# jiggle: bool, default False
109	# If True, randomize the points within the grid specified by the
110	# Latin hypercube design.
111	#
112	# maxiter: int, default: 100
113	# Number of random designs to generate in attempting to find the optimal design
114	# with respect to the metric.
115	# """
116	#
117	# N = int(N)
118	# assert N > 0, "Number of samples must be positive"
119	# assert metric in ['maximin', 'corr'], "Invalid metric specified"
120	#
121	# xs = []
122	# for i in range(len(domain)):
123	# xi = np.linspace(domain.norm_lb[i], domain.norm_ub[i], N + 1)
124	# xi = (xi[1:]+xi[0:-1])/2.
125	# xs.append(xi)
126	#
127	# # Higher score == better
128	# score = -np.inf
129	# X = None
130	# for it in range(maxiter):
131	# # Select which components of the hypercube
132	# I = [np.random.permutation(N) for i in range(len(domain))]
133	# # Generate actual points
134	# X_new = np.array([ [xs[i][j] for j in I[i]] for i in range(len(domain))]).T
135	#
136	# # Here we would jiggle points if so desired
137	# if jiggle:
138	# for i in range(len(domain)):
139	# h = xs[i][1] - xs[i][0] # Grid spacing
140	# X_new[:,i] += np.random.uniform(-h/2, h/2, size = N)
141	#
142	# # Evaluate the metric
143	# if metric == 'maximin':
144	# new_score = np.min(pdist(X_new))
145	# elif metric == 'corr':
146	# new_score = -np.linalg.norm(np.eye(len(domain)) - np.corrcoef(X_new.T))
147	#
148	# if new_score > score:
149	# score = new_score
150	# X = X_new
151	#
152	# return X
153
154
155
156

jeffrey-hokanson / PSDR / 378

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous