def glmnetSet(opts = None):
import scipy
# default options
options = {
"weights" : scipy.empty([0]),
"offset" : scipy.empty([0]),
"alpha" : scipy.float64(1.0),
"nlambda" : scipy.int32(100),
"lambda_min" : scipy.empty([0]),
"lambdau" : scipy.empty([0]),
"standardize" : True,
"intr" : True,
"thresh" : scipy.float64(1e-7),
"dfmax" : scipy.empty([0]),
"pmax" : scipy.empty([0]),
"exclude" : scipy.empty([0], dtype = scipy.integer),
"penalty_factor" : scipy.empty([0]),
"cl" : scipy.array([[scipy.float64(-scipy.inf)], [scipy.float64(scipy.inf)]]),
"maxit" : scipy.int32(1e5),
"gtype" : [],
"ltype" : 'Newton',
"standardize_resp" : False,
"mtype" : 'ungrouped'
}
# quick return if no user opts
if opts == None:
print('pdco default options:')
print(options)
return options
# if options are passed in by user, update options with values from opts
optsInOptions = set(opts.keys()) - set(options.keys());
if len(optsInOptions) > 0: # assert 'opts' keys are subsets of 'options' keys
print(optsInOptions, ' : unknown option for glmnetSet')
raise ValueError('attempting to set glmnet options that are not known to glmnetSet')
else:
options = merge_dicts(options, opts)
return options
python类inf()的实例源码
def glmnetSet(opts = None):
import scipy
# default options
options = {
"weights" : scipy.empty([0]),
"offset" : scipy.empty([0]),
"alpha" : scipy.float64(1.0),
"nlambda" : scipy.int32(100),
"lambda_min" : scipy.empty([0]),
"lambdau" : scipy.empty([0]),
"standardize" : True,
"intr" : True,
"thresh" : scipy.float64(1e-7),
"dfmax" : scipy.empty([0]),
"pmax" : scipy.empty([0]),
"exclude" : scipy.empty([0], dtype = scipy.integer),
"penalty_factor" : scipy.empty([0]),
"cl" : scipy.array([[scipy.float64(-scipy.inf)], [scipy.float64(scipy.inf)]]),
"maxit" : scipy.int32(1e5),
"gtype" : [],
"ltype" : 'Newton',
"standardize_resp" : False,
"mtype" : 'ungrouped'
}
# quick return if no user opts
if opts == None:
print('pdco default options:')
print(options)
return options
# if options are passed in by user, update options with values from opts
optsInOptions = set(opts.keys()) - set(options.keys());
if len(optsInOptions) > 0: # assert 'opts' keys are subsets of 'options' keys
print(optsInOptions, ' : unknown option for glmnetSet')
raise ValueError('attempting to set glmnet options that are not known to glmnetSet')
else:
options = merge_dicts(options, opts)
return options
def with_walking(time_arr, mins_per_square=1.3, transfer_constant=5):
arr = time_arr.copy()
cross_footprint = sp.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]]).astype(bool)
diag_footprint = sp.array([[1, 0, 1],[0, 1, 0], [1, 0, 1]]).astype(bool)
arr[sp.isnan(arr)] = sp.inf
for i in range(60):
cross_arr = sp.ndimage.minimum_filter(arr, footprint=cross_footprint)
cross_arr[sp.isnan(cross_arr)] = sp.inf
cross_changes = (cross_arr != arr)
cross_arr[cross_changes] += 1*mins_per_square
diag_arr = sp.ndimage.minimum_filter(arr, footprint=diag_footprint)
diag_arr[sp.isnan(diag_arr)] = sp.inf
diag_changes = (diag_arr != arr)
diag_arr[diag_changes] += 1.4*mins_per_square
arr = sp.minimum(cross_arr, diag_arr)
arr[sp.isinf(arr)] = sp.nan
return arr + transfer_constant
def open_file(maindir):
"""
Creates the digital RF reading object.
Args:
maindir (:obj:'str'): The directory where the data is located.
Returns:
drfObj (obj:"DigitalRFReader"): Digital RF Reader object.
chandict (obj:"dict"): Dictionary that holds info for the channels.
start_indx (obj:'long'): Start index in samples.
end_indx (obj:'long'): End index in samples.
"""
mainpath = os.path.expanduser(maindir)
drfObj = drf.DigitalRFReader(mainpath)
chans = drfObj.get_channels()
chandict={}
start_indx, end_indx=[0, sp.inf]
# Get channel info
for ichan in chans:
curdict = {}
curdict['sind'], curdict['eind'] = drfObj.get_bounds(ichan)
# determine the read boundrys assuming the sampling is the same.
start_indx = sp.maximum(curdict['sind'], start_indx)
end_indx = sp.minimum(curdict['eind'], end_indx)
dmetadict = drfObj.read_metadata(start_indx, end_indx, ichan)
dmetakeys = dmetadict.keys()
curdict['sps'] = dmetadict[dmetakeys[0]]['samples_per_second']
curdict['fo'] = dmetadict[dmetakeys[0]]['center_frequencies'].ravel()[0]
chandict[ichan] = curdict
return (drfObj, chandict, start_indx, end_indx)
def glmnetSet(opts = None):
import scipy
# default options
options = {
"weights" : scipy.empty([0]),
"offset" : scipy.empty([0]),
"alpha" : scipy.float64(1.0),
"nlambda" : scipy.int32(100),
"lambda_min" : scipy.empty([0]),
"lambdau" : scipy.empty([0]),
"standardize" : True,
"intr" : True,
"thresh" : scipy.float64(1e-7),
"dfmax" : scipy.empty([0]),
"pmax" : scipy.empty([0]),
"exclude" : scipy.empty([0], dtype = scipy.integer),
"penalty_factor" : scipy.empty([0]),
"cl" : scipy.array([[scipy.float64(-scipy.inf)], [scipy.float64(scipy.inf)]]),
"maxit" : scipy.int32(1e5),
"gtype" : [],
"ltype" : 'Newton',
"standardize_resp" : False,
"mtype" : 'ungrouped'
}
# quick return if no user opts
if opts == None:
print('pdco default options:')
print(options)
return options
# if options are passed in by user, update options with values from opts
optsInOptions = set(opts.keys()) - set(options.keys());
if len(optsInOptions) > 0: # assert 'opts' keys are subsets of 'options' keys
print(optsInOptions, ' : unknown option for glmnetSet')
raise ValueError('attempting to set glmnet options that are not known to glmnetSet')
else:
options = merge_dicts(options, opts)
return options
def glmnetSet(opts = None):
import scipy
# default options
options = {
"weights" : scipy.empty([0]),
"offset" : scipy.empty([0]),
"alpha" : scipy.float64(1.0),
"nlambda" : scipy.int32(100),
"lambda_min" : scipy.empty([0]),
"lambdau" : scipy.empty([0]),
"standardize" : True,
"intr" : True,
"thresh" : scipy.float64(1e-7),
"dfmax" : scipy.empty([0]),
"pmax" : scipy.empty([0]),
"exclude" : scipy.empty([0], dtype = scipy.integer),
"penalty_factor" : scipy.empty([0]),
"cl" : scipy.array([[scipy.float64(-scipy.inf)], [scipy.float64(scipy.inf)]]),
"maxit" : scipy.int32(1e5),
"gtype" : [],
"ltype" : 'Newton',
"standardize_resp" : False,
"mtype" : 'ungrouped'
}
# quick return if no user opts
if opts == None:
print('pdco default options:')
print(options)
return options
# if options are passed in by user, update options with values from opts
optsInOptions = set(opts.keys()) - set(options.keys());
if len(optsInOptions) > 0: # assert 'opts' keys are subsets of 'options' keys
print(optsInOptions, ' : unknown option for glmnetSet')
raise ValueError('attempting to set glmnet options that are not known to glmnetSet')
else:
options = merge_dicts(options, opts)
return options
def empty_mask(s1, s2):
l1 = s1.shape[0]
l2 = s2.shape[0]
mask = sp.zeros((l1 + 1, l2 + 1))
mask[1:, 0] = sp.inf
mask[0, 1:] = sp.inf
return mask
def dtw_path(s1, s2):
l1 = s1.shape[0]
l2 = s2.shape[0]
cum_sum = sp.zeros((l1 + 1, l2 + 1))
cum_sum[1:, 0] = sp.inf
cum_sum[0, 1:] = sp.inf
predecessors = [([None] * l2) for i in range(l1)]
for i in range(l1):
for j in range(l2):
if sp.isfinite(cum_sum[i + 1, j + 1]):
dij = sp.linalg.norm(s1[i] - s2[j]) ** 2
pred_list = [cum_sum[i, j + 1], cum_sum[i + 1, j], cum_sum[i, j]]
argmin_pred = sp.argmin(pred_list)
cum_sum[i + 1, j + 1] = pred_list[argmin_pred] + dij
if i + j > 0:
if argmin_pred == 0:
predecessors[i][j] = (i - 1, j)
elif argmin_pred == 1:
predecessors[i][j] = (i, j - 1)
else:
predecessors[i][j] = (i - 1, j - 1)
i = l1 - 1
j = l2 - 1
best_path = [(i, j)]
while predecessors[i][j] is not None:
i, j = predecessors[i][j]
best_path.insert(0, (i, j))
return best_path
def __call__(self, x, y):
return sum(abs((x[key]-y[key])/y[key]) if y[key] != 0 else
(0 if x[key] == 0 else sp.inf)
for key in self.measures_to_use) / len(self.measures_to_use)
def Tu( self, s=False, yr=False, myr=False, gyr=False ):
return self.Th() * integrate.quad(self.Tfunc, 0, inf)[0] * self.timeConversion(s=s, yr=yr, myr=myr, gyr=gyr)
# added 12/16/11 - Conor Mancone
# returns conversion from arcseconds to physical angular size
def binHisto(data, verbose=False):
"""
Calculates bin width and number of bins for histogram using Freedman-Diaconis rule, if rule fails, defaults to square-root method
The Freedman-Diaconis method is detailed in:
Freedman, D., and P. Diaconis (1981), On the histogram as a density estimator: L2 theory, Z. Wahrscheinlichkeitstheor. Verw. Geb., 57, 453–476
and is also described by:
Wilks, D. S. (2006), Statistical Methods in the Atmospheric Sciences, 2nd ed.
Parameters
==========
data : array_like
list/array of data values
verbose : boolean (optional)
print out some more information
Returns
=======
out : tuple
calculated width of bins using F-D rule, number of bins (nearest integer) to use for histogram
Examples
========
>>> import numpy, spacepy
>>> import matplotlib.pyplot as plt
>>> numpy.random.seed(8675301)
>>> data = numpy.random.randn(1000)
>>> binw, nbins = spacepy.toolbox.binHisto(data)
>>> print(nbins)
19.0
>>> p = plt.hist(data, bins=nbins, histtype='step', normed=True)
See Also
========
matplotlib.pyplot.hist
"""
from matplotlib.mlab import prctile
pul = prctile(data, p=(25,75)) #get confidence interval
ql, qu = pul[0], pul[1]
iqr = qu-ql
binw = 2.*iqr/(len(data)**(1./3.))
if binw != 0:
nbins = round((max(data)-min(data))/binw)
# if nbins is 0, NaN or inf don't use the F-D rule just use sqrt(num) rule
if binw == 0 or nbins == 0 or not np.isfinite(nbins):
nbins = round(np.sqrt(len(data)))
binw = len(data)/nbins
if verbose:
print("Used sqrt rule")
else:
if verbose:
print("Used F-D rule")
return (binw, nbins)
def dist_to_list(func, length, min=None, max=None):
"""
Convert a probability distribution function to a list of values
This is a deterministic way to produce a known-length list of values
matching a certain probability distribution. It is likely to be a closer
match to the distribution function than a random sampling from the
distribution.
Parameters
==========
func : callable
function to call for each possible value, returning
probability density at that value (does not need to be
normalized.)
length : int
number of elements to return
min : float
minimum value to possibly include
max : float
maximum value to possibly include
Examples
========
>>> import matplotlib
>>> import numpy
>>> import spacepy.toolbox as tb
>>> gauss = lambda x: math.exp(-(x ** 2) / (2 * 5 ** 2)) / (5 * math.sqrt(2 * math.pi))
>>> vals = tb.dist_to_list(gauss, 1000, -numpy.inf, numpy.inf)
>>> print vals[0]
-16.45263...
>>> p1 = matplotlib.pyplot.hist(vals, bins=[i - 10 for i in range(21)], facecolor='green')
>>> matplotlib.pyplot.hold(True)
>>> x = [i / 100.0 - 10.0 for i in range(2001)]
>>> p2 = matplotlib.pyplot.plot(x, [gauss(i) * 1000 for i in x], 'red')
>>> matplotlib.pyplot.draw()
"""
from scipy import inf
from scipy.integrate import quad
if min is None:
min = -inf
if max is None:
max = inf
total = quad(func, min, max)[0]
step = float(total) / length
return [intsolve(func, (0.5 + i) * step, min, max) for i in range(length)]
