# Python numpy.Inf() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def _ncc_c(x, y):
"""
>>> _ncc_c([1,2,3,4], [1,2,3,4])
array([ 0.13333333,  0.36666667,  0.66666667,  1.        ,  0.66666667,
0.36666667,  0.13333333])
>>> _ncc_c([1,1,1], [1,1,1])
array([ 0.33333333,  0.66666667,  1.        ,  0.66666667,  0.33333333])
>>> _ncc_c([1,2,3], [-1,-1,-1])
array([-0.15430335, -0.46291005, -0.9258201 , -0.77151675, -0.46291005])
"""
den = np.array(norm(x) * norm(y))
den[den == 0] = np.Inf

x_len = len(x)
fft_size = 1<<(2*x_len-1).bit_length()
cc = ifft(fft(x, fft_size) * np.conj(fft(y, fft_size)))
cc = np.concatenate((cc[-(x_len-1):], cc[:x_len]))
return np.real(cc) / den 

Example 2

def initialize(self, length=None):
"""see __init__"""
if length is None:
length = len(self.bounds)
max_i = min((len(self.bounds) - 1, length - 1))
self._lb = array([self.bounds[min((i, max_i))][0]
if self.bounds[min((i, max_i))][0] is not None
else -np.Inf
for i in range(length)], copy=False)
self._ub = array([self.bounds[min((i, max_i))][1]
if self.bounds[min((i, max_i))][1] is not None
else np.Inf
for i in range(length)], copy=False)
lb = self._lb
ub = self._ub
# define added values for lower and upper bound
self._al = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(lb[i])) / 20])
if isfinite(lb[i]) else 1 for i in rglen(lb)], copy=False)
self._au = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(ub[i])) / 20])
if isfinite(ub[i]) else 1 for i in rglen(ub)], copy=False) 

Example 3

def SLcomputeSNR(X, Xnoisy):
"""
SLcomputeSNR Compute signal to noise ratio (SNR).

Usage:

SNR = SLcomputeSNR(X, Xnoisy)

Input:

X:      2D or 3D signal.
Xnoisy: 2D or 3D noisy signal.

Output:

SNR: The signal to noise ratio (in dB).
"""

if np.linalg.norm(X-Xnoisy) == 0:
return np.Inf
else:
return 10 * np.log10( np.sum(np.power(X,2)) / np.sum(np.power(X-Xnoisy,2)) ) 

Example 4

def initialize(self, length=None):
"""see __init__"""
if length is None:
length = len(self.bounds)
max_i = min((len(self.bounds) - 1, length - 1))
self._lb = array([self.bounds[min((i, max_i))][0]
if self.bounds[min((i, max_i))][0] is not None
else -np.Inf
for i in range(length)], copy=False)
self._ub = array([self.bounds[min((i, max_i))][1]
if self.bounds[min((i, max_i))][1] is not None
else np.Inf
for i in range(length)], copy=False)
lb = self._lb
ub = self._ub
# define added values for lower and upper bound
self._al = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(lb[i])) / 20])
if isfinite(lb[i]) else 1 for i in rglen(lb)], copy=False)
self._au = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(ub[i])) / 20])
if isfinite(ub[i]) else 1 for i in rglen(ub)], copy=False) 

Example 5

def __init__(self,shape,z0rep_axes=(0,), z1rep_axes=(0,), map_est=False):
Estim.__init__(self)
self.shape = shape
ndim = len(shape)
if z0rep_axes == 'all':
z0rep_axes = tuple(range(ndim))
if z1rep_axes == 'all':
z1rep_axes = tuple(range(ndim))
self.z0rep_axes = z0rep_axes
self.z1rep_axes = z1rep_axes
self.cost_avail = True
self.map_est = map_est

# Initial variances
self.zvar0_init= np.Inf
self.zvar1_init= np.Inf 

Example 6

def __init__(self,y,shape,zrep_axes=(0,),thresh=0,perr=1e-6,\
var_init=np.Inf):

Estim.__init__(self)
self.y = y
self.shape = shape
self.thresh = thresh
self.perr = perr
self.cost_avail = True
self.var_init = var_init

# Set the repetition axes
ndim = len(self.shape)
if zrep_axes == 'all':
zrep_axes = tuple(range(ndim))
self.zrep_axes = zrep_axes 

Example 7

def initialize(self, length=None):
"""see __init__"""
if length is None:
length = len(self.bounds)
max_i = min((len(self.bounds) - 1, length - 1))
self._lb = array([self.bounds[min((i, max_i))][0]
if self.bounds[min((i, max_i))][0] is not None
else -np.Inf
for i in range(length)], copy=False)
self._ub = array([self.bounds[min((i, max_i))][1]
if self.bounds[min((i, max_i))][1] is not None
else np.Inf
for i in range(length)], copy=False)
lb = self._lb
ub = self._ub
# define added values for lower and upper bound
self._al = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(lb[i])) / 20])
if isfinite(lb[i]) else 1 for i in rglen(lb)], copy=False)
self._au = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(ub[i])) / 20])
if isfinite(ub[i]) else 1 for i in rglen(ub)], copy=False) 

Example 8

def _reset(self):
"""Resets wait counter and cooldown counter.
"""
if self.mode not in ['auto', 'min', 'max']:
warnings.warn('Learning Rate Plateau Reducing mode %s is unknown, '
'fallback to auto mode.' % (self.mode),
RuntimeWarning)
self.mode = 'auto'
if (self.mode == 'min' or
(self.mode == 'auto' and 'acc' not in self.monitor)):
self.monitor_op = lambda a, b: np.less(a, b - self.epsilon)
self.best = np.Inf
else:
self.monitor_op = lambda a, b: np.greater(a, b + self.epsilon)
self.best = -np.Inf
self.cooldown_counter = 0
self.wait = 0
self.lr_epsilon = self.min_lr * 1e-4 

Example 9

def test_invalid_nbins():
with raises(ValueError):
ew = graynet.extract(subject_id_list, fs_dir, num_bins=np.NaN)

with raises(ValueError):
ew = graynet.extract(subject_id_list, fs_dir, num_bins=np.Inf)

with raises(ValueError):
ew = graynet.extract(subject_id_list, fs_dir, num_bins=2)

# test_multi_edge()
# test_multi_edge_CLI()
# test_empty_subject_list()
# test_run_no_IO()
# test_run_roi_stats_via_API()
# test_run_roi_stats_via_CLI()
# test_CLI_only_weight_or_stats() 

Example 10

def initialize(self, length=None):
"""see __init__"""
if length is None:
length = len(self.bounds)
max_i = min((len(self.bounds) - 1, length - 1))
self._lb = array([self.bounds[min((i, max_i))][0]
if self.bounds[min((i, max_i))][0] is not None
else -np.Inf
for i in xrange(length)], copy=False)
self._ub = array([self.bounds[min((i, max_i))][1]
if self.bounds[min((i, max_i))][1] is not None
else np.Inf
for i in xrange(length)], copy=False)
lb = self._lb
ub = self._ub
# define added values for lower and upper bound
self._al = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(lb[i])) / 20])
if isfinite(lb[i]) else 1 for i in rglen(lb)], copy=False)
self._au = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(ub[i])) / 20])
if isfinite(ub[i]) else 1 for i in rglen(ub)], copy=False) 

Example 11

def update(self, decision):

for context in self.contexts:
if decision in self.contexts[context]:
self.contexts_scores[context] += eta + np.random.randn()*1e-5

# special condition for names:
if decision in women_names:
self.women_names_score = np.Inf
self.men_names_score = 0.
self.robots_names_score = -1.
if decision in men_names:
self.women_names_score = 0.
self.men_names_score = np.Inf
self.robots_names_score = -1.
if decision in robots_names:
self.women_names_score = np.random.randn()*1e-5
self.men_names_score = np.random.randn()*1e-5
self.robots_names_score = np.Inf

self.most_likely_context = max(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0]
self.less_likely_context = min(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0] 

Example 12

def update(self, decision):

for context in self.contexts:
if decision in self.contexts[context]:
self.contexts_scores[context] += eta + np.random.randn()*1e-5

# special condition for names:
if decision in women_names:
self.women_names_score = np.Inf
self.men_names_score = 0.
self.robots_names_score = -1.
if decision in men_names:
self.women_names_score = 0.
self.men_names_score = np.Inf
self.robots_names_score = -1.
if decision in robots_names:
self.women_names_score = np.random.randn()*1e-5
self.men_names_score = np.random.randn()*1e-5
self.robots_names_score = np.Inf

self.most_likely_context = max(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0]
self.less_likely_context = min(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0] 

Example 13

def update(self, decision, weight):

for context in CONTEXTS:
if decision in CONTEXTS[context]:
self.contexts_scores[context] += weight + np.random.randn()*1e-5

# special condition for names:
if decision in women_names:
self.women_names_score = np.Inf
self.men_names_score = 0.
self.robots_names_score = -1.
if decision in men_names:
self.women_names_score = 0.
self.men_names_score = np.Inf
self.robots_names_score = -1.
if decision in robots_names:
self.women_names_score = np.random.randn()*1e-5
self.men_names_score = np.random.randn()*1e-5
self.robots_names_score = np.Inf

self.most_likely_context = max(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0]
self.less_likely_context = min(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0] 

Example 14

def update(self, decision):

for context in self.contexts:
if decision in self.contexts[context]:
self.contexts_scores[context] += eta + np.random.randn()*1e-5

# special condition for names:
if decision in women_names:
self.women_names_score = np.Inf
self.men_names_score = 0.
self.robots_names_score = -1.
if decision in men_names:
self.women_names_score = 0.
self.men_names_score = np.Inf
self.robots_names_score = -1.
if decision in robots_names:
self.women_names_score = np.random.randn()*1e-5
self.men_names_score = np.random.randn()*1e-5
self.robots_names_score = np.Inf

self.most_likely_context = max(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0]
self.less_likely_context = min(self.contexts_scores.iteritems(), key=operator.itemgetter(1))[0] 

Example 15

def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)

# define required options
if not 'pBins' in self.opt:
self.opt['pBins']=10
if not 'inertia' in self.opt:
self.opt['inertia']=0.5
if not 'c1' in self.opt:
self.opt['c1']=0.6
if not 'c2' in self.opt:
self.opt['c2']=0.3
if not 'c3' in self.opt:
self.opt['c3']=0.001

if self.opt['c3']==0:
self.opt['c3']=1E-5

# define required variables
self.pBestIdxs=np.arange(self.opt['population'], dtype=np.int32)
self.gBestIdxs=np.arange(self.opt['population'], dtype=np.int32)
self.velocities=np.zeros((self.opt['population'],self.opt['nVars']))
tmp=np.hstack((-np.Inf, np.linspace(0,1, num=self.opt['pBins'])))
self.pBins=np.vstack((tmp[0:-1],tmp[1:])) 

Example 16

def _reset(self):
"""Resets wait counter and cooldown counter.
"""
if self.mode not in ['auto', 'min', 'max']:
logging.warning('Learning Rate Plateau Reducing mode %s is unknown, '
'fallback to auto mode.' % (self.mode))
self.mode = 'auto'
if (self.mode == 'min' or
(self.mode == 'auto' and 'acc' not in self.monitor)):
self.monitor_op = lambda a, b: np.less(a, b - self.epsilon)
self.best = np.Inf
else:
self.monitor_op = lambda a, b: np.greater(a, b + self.epsilon)
self.best = -np.Inf
self.cooldown_counter = 0
self.wait = 0
self.lr_epsilon = self.min_lr * 1e-4 

Example 17

def _get_best_trial(filename, cut=None):
try:
fh = open(filename, "r")
fh.close()

current_best = numpy.Inf
best_idx = 0
if cut is None:
cut = len(trials['trials'])
print filename, "#Trials", len(trials['trials'])
for i, trial in enumerate(trials['trials'][:cut]):
result = trial['result']
if result < current_best:
best_idx = i
current_best = result
if current_best == numpy.Inf:
raise Exception("%s does not contain any results" % filename)
return current_best, best_idx
except Exception as e:
print "Problem with ", filename, e
sys.stdout.flush()
return None, None

# TODO: Don't know whether this is longer needed 

Example 18

def plot_all_times_to_correct_decision(self,thr=0.5,stay_above=True,unit="spikes",spikemeasure="growing_spikecount", do_title=True):
times = np.array([self.time_to_correct_decision(e,thr,stay_above,unit,spikemeasure) for e in self.experiments]).flatten()
# times[30:50] = np.Inf
maximum = int(np.ceil(max(times[times!=np.Inf])))
plt_inf = maximum+2 # for unsuccessful trials (time=Inf), set time to some value distinct from any actual decision time.
times[times==np.Inf] = plt_inf

fig = plt.figure(figsize=(hcPlotting.fig_width,hcPlotting.fig_height/3))

bins = np.hstack([np.arange(0.25,maximum+1,0.5),[plt_inf,plt_inf+1]])
n,_,_ = plt.hist(times,bins,color='k',edgecolor='w')

ax = plt.gca()
ax.set_xlim((0,plt_inf+1))
ax.set_ylim(ax.get_ylim()[0],ax.get_ylim()[1]+1)
plt.plot((plt_inf,plt_inf),(0,ax.get_ylim()[1]),'r')

ax.set_xticks(range(maximum+1)+[plt_inf+0.5])
ax.set_xticklabels([str(i) for i in range(maximum+1)]+[r'$\infty$'])

ax.set_ylabel("nr. of trials")
ax.set_xlabel("spikes observed before classification")
if do_title:
plt.title("thr = "+str(thr)+", stay_above = "+str(stay_above)+", classes: " +" vs. ".join(self.classes)) 

Example 19

def __init__(self, monitor='val_loss', patience=0, verbose=0, mode='auto'):
super(Callback, self).__init__()

self.monitor = monitor
self.patience = patience
self.verbose = verbose
self.wait = 0
self.best_epoch = 0

if mode == 'min':
self.monitor_op = np.less
self.best = np.Inf
elif mode == 'max':
self.monitor_op = np.greater
self.best = -np.Inf
else:
if 'acc' in self.monitor:
self.monitor_op = np.greater
self.best = -np.Inf
else:
self.monitor_op = np.less
self.best = np.Inf 

Example 20

def initialize(self, length=None):
"""see __init__"""
if length is None:
length = len(self.bounds)
max_i = min((len(self.bounds) - 1, length - 1))
self._lb = array([self.bounds[min((i, max_i))][0]
if self.bounds[min((i, max_i))][0] is not None
else -np.Inf
for i in range(length)], copy=False)
self._ub = array([self.bounds[min((i, max_i))][1]
if self.bounds[min((i, max_i))][1] is not None
else np.Inf
for i in range(length)], copy=False)
lb = self._lb
ub = self._ub
# define added values for lower and upper bound
self._al = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(lb[i])) / 20])
if isfinite(lb[i]) else 1 for i in rglen(lb)], copy=False)
self._au = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(ub[i])) / 20])
if isfinite(ub[i]) else 1 for i in rglen(ub)], copy=False) 

Example 21

def __init__(self, monitor='val_loss', mode='auto', verbose=0):
super(BestWeight, self).__init__()
self.monitor = monitor
self.mode = mode
self.best_weights = None
self.verbose = verbose
if mode == 'min':
self.monitor_op = np.less
self.best = np.Inf
elif mode == 'max':
self.monitor_op = np.greater
self.best = -np.Inf
else:
if 'acc' in self.monitor:
self.monitor_op = np.greater
self.best = -np.Inf
else:
self.monitor_op = np.less
self.best = np.Inf 

Example 22

def _reset(self):
"""Resets wait counter and cooldown counter.
"""
if self.mode not in ['auto', 'min', 'max']:
warnings.warn('Learning Rate Plateau Reducing mode %s is unknown, '
'fallback to auto mode.' % (self.mode),
RuntimeWarning)
self.mode = 'auto'
if (self.mode == 'min' or
(self.mode == 'auto' and 'acc' not in self.monitor)):
self.monitor_op = lambda a, b: np.less(a, b - self.epsilon)
self.best = np.Inf
else:
self.monitor_op = lambda a, b: np.greater(a, b + self.epsilon)
self.best = -np.Inf
self.cooldown_counter = 0
self.wait = 0
self.lr_epsilon = self.min_lr * 1e-4 

Example 23

def process_questions(C, all_words, n):
scores = dist_function[0](C[:, all_words], W[all_words, :], W2)
worst = -dist_function[1]*numpy.Inf
for i in range(C.shape[0]):
scores[i, C[i, :].nonzero()[1]] = worst
if dist_function[1] > 0:
hits = scores.argpartition(-n, axis=1)[:, -n:]
answers = [sorted(hits[i], key=lambda hit: scores[i, hit], reverse=True) for i in range(len(hits))]
else:
hits = scores.argpartition(n, axis=1)[:, :n]
answers = [sorted(hits[i], key=lambda hit: scores[i, hit], reverse=False) for i in range(len(hits))]
if args.log_level > 1:
small_scores = [scores[i, answers[i]] for i in xrange(hits.shape[0])]
else:
small_scores = None
return answers, small_scores 

Example 24

def _reset(self):
"""Resets wait counter and cooldown counter.
"""
if self.mode not in ['auto', 'min', 'max']:
warnings.warn('Learning Rate Plateau Reducing mode %s is unknown, '
'fallback to auto mode.' % (self.mode),
RuntimeWarning)
self.mode = 'auto'
if (self.mode == 'min' or
(self.mode == 'auto' and 'acc' not in self.monitor)):
self.monitor_op = lambda a, b: np.less(a, b - self.epsilon)
self.best = np.Inf
else:
self.monitor_op = lambda a, b: np.greater(a, b + self.epsilon)
self.best = -np.Inf
self.cooldown_counter = 0
self.wait = 0
self.lr_epsilon = self.min_lr * 1e-4 

Example 25

def __init__(self, filepath, monitor='val_loss', verbose=0, save_best_only=False, mode='auto'):

super(Callback, self).__init__()
self.monitor = monitor
self.verbose = verbose
self.filepath = filepath
self.save_best_only = save_best_only

if mode not in ['auto', 'min', 'max']:
warnings.warn("ModelCheckpoint mode %s is unknown, fallback to auto mode" % (self.mode), RuntimeWarning)
mode = 'auto'

if mode == "min":
self.monitor_op = np.less
self.best = np.Inf
elif mode == "max":
self.monitor_op = np.greater
self.best = -np.Inf
else:
if "acc" in self.monitor:
self.monitor_op = np.greater
self.best = -np.Inf
else:
self.monitor_op = np.less
self.best = np.Inf 

Example 26

def _reset(self):
"""Resets wait counter and cooldown counter.
"""
if self.mode not in ['auto', 'min', 'max']:
warnings.warn('Learning Rate Plateau Reducing mode %s is unknown, '
'fallback to auto mode.' % (self.mode),
RuntimeWarning)
self.mode = 'auto'
if (self.mode == 'min' or
(self.mode == 'auto' and 'acc' not in self.monitor)):
self.monitor_op = lambda a, b: np.less(a, b - self.epsilon)
self.best = np.Inf
else:
self.monitor_op = lambda a, b: np.greater(a, b + self.epsilon)
self.best = -np.Inf
self.cooldown_counter = 0
self.wait = 0
self.lr_epsilon = self.min_lr * 1e-4 

Example 27

def initialize(self, length=None):
"""see __init__"""
if length is None:
length = len(self.bounds)
max_i = min((len(self.bounds) - 1, length - 1))
self._lb = array([self.bounds[min((i, max_i))][0]
if self.bounds[min((i, max_i))][0] is not None
else -np.Inf
for i in range(length)], copy=False)
self._ub = array([self.bounds[min((i, max_i))][1]
if self.bounds[min((i, max_i))][1] is not None
else np.Inf
for i in range(length)], copy=False)
lb = self._lb
ub = self._ub
# define added values for lower and upper bound
self._al = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(lb[i])) / 20])
if isfinite(lb[i]) else 1 for i in rglen(lb)], copy=False)
self._au = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(ub[i])) / 20])
if isfinite(ub[i]) else 1 for i in rglen(ub)], copy=False) 

Example 28

def parse_location_string(loc_string):
"""
Parse a UCSC format location string (e.g. "chr2:1000-1100") and return
an interval tuple in the format ('chr2', 1000, 1100).

:param loc_string: Input location string
:type loc_string: :ref:location string <location_string>
:returns: (chromosome name, start coordinate, stop coordinate)
"""

chrom_fields = loc_string.split(':')

chrom = chrom_fields[0]

if len(chrom_fields) == 1:

start, stop = 0, np.Inf

else:

pos_fields = chrom_fields[1].split('-')

start, stop = (int(pos.replace(",", "")) for pos in pos_fields)

return chrom, start, stop 

Example 29

def initialize(self, length=None):
"""see __init__"""
if length is None:
length = len(self.bounds)
max_i = min((len(self.bounds) - 1, length - 1))
self._lb = array([self.bounds[min((i, max_i))][0]
if self.bounds[min((i, max_i))][0] is not None
else -np.Inf
for i in range(length)], copy=False)
self._ub = array([self.bounds[min((i, max_i))][1]
if self.bounds[min((i, max_i))][1] is not None
else np.Inf
for i in range(length)], copy=False)
lb = self._lb
ub = self._ub
# define added values for lower and upper bound
self._al = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(lb[i])) / 20])
if isfinite(lb[i]) else 1 for i in rglen(lb)], copy=False)
self._au = array([min([(ub[i] - lb[i]) / 2, (1 + np.abs(ub[i])) / 20])
if isfinite(ub[i]) else 1 for i in rglen(ub)], copy=False) 

Example 30

def __init__(self, monitor='val_loss', cut_ratio=0.5, patience=2, scheduled_start_epoch=1, scheduled_cut_ratio=1.):
"""
Args:
monitor: quantity to be monitored.
cut_ratio: cut the learning rate by this percent.
patience: number of epochs with no improvement
after which training will be stopped.
scheduled_start_epoch: from which epoch to do scheduled learning rate discount
scheduled_cut_ratio: learning rate discount ratio.
"""
super(Callback, self).__init__()
self.monitor = monitor
self.patience = patience
self.best = np.Inf
self.wait = 0
self.cut_ratio = cut_ratio
self.monitor_decrease = False
self.scheduled_start_epoch = scheduled_start_epoch
self.scheduled_cut_ratio = scheduled_cut_ratio 

Example 31

def _get_bounds(self, ib, dimension):
"""ib == 0/1 means lower/upper bound, return a vector of length
dimension """
sign_ = 2 * ib - 1
assert sign_**2 == 1
if self.bounds is None or self.bounds[ib] is None:
return np.array(dimension * [sign_ * np.Inf])
res = []
for i in range(dimension):
res.append(self.bounds[ib][min([i, len(self.bounds[ib]) - 1])])
if res[-1] is None:
res[-1] = sign_ * np.Inf
return np.array(res) 

Example 32

def solve_static(self, F, up_, Dirichlet_bcs_up):
# Solve stationary Navier-Stokes problem with Picard method
# other methods may be more acurate and faster

iter_ = 0
max_iter = 50
eps = 1.0
tol = 1E-3
under_relax_ratio = 0.7
up_temp = Function(self.function_space)  # a temporal to save value in the Picard loop

timer_solver = Timer("TimerSolveStatic")
timer_solver.start()
while (iter_ < max_iter and eps > tol):
# solve the linear stokes flow to avoid up_s = 0

up_temp.assign(up_)
# other solving methods
up_ = self.solve_linear_problem(F, up_, Dirichlet_bcs_up)
#up_s = self.solve_amg(F, Dirichlet_bcs_up, up_s)  #  AMG is not working with mixed function space

diff_up = up_.vector().array() - up_temp.vector().array()
eps = np.linalg.norm(diff_up, ord=np.Inf)

print("iter = {:d}; eps_up = {:e}; time elapsed = {}\n".format(iter_, eps, timer_solver.elapsed()))

## underreleax should be defined here, Courant number,
up_.vector()[:] = up_temp.vector().array() + diff_up * under_relax_ratio

iter_ += 1
## end of Picard loop
timer_solver.stop()
print("*" * 10 + " end of Navier-Stokes equation iteration" + "*" * 10)

return up_ 

Example 33

def gen(N, df, thinning=1):
log_den = log_normal
if df < np.Inf:

return metropolis_hastings(log_den, chain_size=N, thinning=thinning, x_prev=np.random.randn(), step=0.5)

# estimate size of thinning 

Example 34

def get_thinning(X, nlags=50):
autocorrelation = acf(X, nlags=nlags, fft=True)
thinning = np.argmin(np.abs(autocorrelation - 0.95)) + 1
return thinning, autocorrelation

#
# X = gen(TEST_CHAIN_SIZE, np.Inf)
# thinning, autocorr = get_thinning(X)
# print('thinning for AR normal simulation ', thinning, autocorr[thinning]) 

Example 35

def __init__(self, custom_model, filepath, monitor='val_loss', verbose=0,
save_best_only=False, save_weights_only=False,
mode='auto', period=1):
super(CustomModelCheckpoint, self).__init__()
self.custom_model = custom_model
self.monitor = monitor
self.verbose = verbose
self.filepath = filepath
self.save_best_only = save_best_only
self.save_weights_only = save_weights_only
self.period = period
self.epochs_since_last_save = 0

if mode not in ['auto', 'min', 'max']:
warnings.warn('CustomModelCheckpoint mode %s is unknown, '
'fallback to auto mode.' % (mode),
RuntimeWarning)
mode = 'auto'

if mode == 'min':
self.monitor_op = np.less
self.best = np.Inf
elif mode == 'max':
self.monitor_op = np.greater
self.best = -np.Inf
else:
if 'acc' in self.monitor or self.monitor.startswith('fmeasure'):
self.monitor_op = np.greater
self.best = -np.Inf
else:
self.monitor_op = np.less
self.best = np.Inf 

Example 36

def test_axis(self):
# Vector norms.
# Compare the use of axis with computing the norm of each row
# or column separately.
A = array([[1, 2, 3], [4, 5, 6]], dtype=self.dt)
for order in [None, -1, 0, 1, 2, 3, np.Inf, -np.Inf]:
expected0 = [norm(A[:, k], ord=order) for k in range(A.shape[1])]
assert_almost_equal(norm(A, ord=order, axis=0), expected0)
expected1 = [norm(A[k, :], ord=order) for k in range(A.shape[0])]
assert_almost_equal(norm(A, ord=order, axis=1), expected1)

# Matrix norms.
B = np.arange(1, 25, dtype=self.dt).reshape(2, 3, 4)
nd = B.ndim
for order in [None, -2, 2, -1, 1, np.Inf, -np.Inf, 'fro']:
for axis in itertools.combinations(range(-nd, nd), 2):
row_axis, col_axis = axis
if row_axis < 0:
row_axis += nd
if col_axis < 0:
col_axis += nd
if row_axis == col_axis:
assert_raises(ValueError, norm, B, ord=order, axis=axis)
else:
n = norm(B, ord=order, axis=axis)

# The logic using k_index only works for nd = 3.
# This has to be changed if nd is increased.
k_index = nd - (row_axis + col_axis)
if row_axis < col_axis:
expected = [norm(B[:].take(k, axis=k_index), ord=order)
for k in range(B.shape[k_index])]
else:
expected = [norm(B[:].take(k, axis=k_index).T, ord=order)
for k in range(B.shape[k_index])]
assert_almost_equal(n, expected) 

Example 37

def test_keepdims(self):
A = np.arange(1, 25, dtype=self.dt).reshape(2, 3, 4)

allclose_err = 'order {0}, axis = {1}'
shape_err = 'Shape mismatch found {0}, expected {1}, order={2}, axis={3}'

# check the order=None, axis=None case
expected = norm(A, ord=None, axis=None)
found = norm(A, ord=None, axis=None, keepdims=True)
assert_allclose(np.squeeze(found), expected,
err_msg=allclose_err.format(None, None))
expected_shape = (1, 1, 1)
assert_(found.shape == expected_shape,
shape_err.format(found.shape, expected_shape, None, None))

# Vector norms.
for order in [None, -1, 0, 1, 2, 3, np.Inf, -np.Inf]:
for k in range(A.ndim):
expected = norm(A, ord=order, axis=k)
found = norm(A, ord=order, axis=k, keepdims=True)
assert_allclose(np.squeeze(found), expected,
err_msg=allclose_err.format(order, k))
expected_shape = list(A.shape)
expected_shape[k] = 1
expected_shape = tuple(expected_shape)
assert_(found.shape == expected_shape,
shape_err.format(found.shape, expected_shape, order, k))

# Matrix norms.
for order in [None, -2, 2, -1, 1, np.Inf, -np.Inf, 'fro', 'nuc']:
for k in itertools.permutations(range(A.ndim), 2):
expected = norm(A, ord=order, axis=k)
found = norm(A, ord=order, axis=k, keepdims=True)
assert_allclose(np.squeeze(found), expected,
err_msg=allclose_err.format(order, k))
expected_shape = list(A.shape)
expected_shape[k[0]] = 1
expected_shape[k[1]] = 1
expected_shape = tuple(expected_shape)
assert_(found.shape == expected_shape,
shape_err.format(found.shape, expected_shape, order, k)) 

Example 38

def power_plot(data, sfreq, toffset, log_scale, zscale, title):
"""Plot the computed power of the iq data."""
print("power")

t_axis = numpy.arange(0, len(data)) / sfreq + toffset

if log_scale:
lrxpwr = 10 * numpy.log10(data + 1E-12)
else:
lrxpwr = data

zscale_low, zscale_high = zscale

if zscale_low == 0 and zscale_high == 0:
if log_scale:
zscale_low = numpy.min(
lrxpwr[numpy.where(lrxpwr.real != -numpy.Inf)])
zscale_high = numpy.max(lrxpwr) + 3.0
else:
zscale_low = numpy.min(lrxpwr)
zscale_high = numpy.max(lrxpwr)

fig = plt.figure()
ax.plot(t_axis, lrxpwr.real)
ax.grid(True)
ax.axis([toffset, t_axis[len(t_axis) - 1], zscale_low, zscale_high])

ax.set_xlabel('time (seconds)')
if log_scale:
ax.set_ylabel('power (dB)')
else:
ax.set_ylabel('power')
ax.set_title(title)

return fig 

Example 39

def spectrum_plot(data, freq, cfreq, toffset, log_scale, zscale, title, clr):
"""Plot a spectrum from the data for a given fft bin size."""
print("spectrum")
tail_str = ''
if log_scale:
#        pss = 10.0*numpy.log10(data / numpy.max(data))
pss = 10.0 * numpy.log10(data + 1E-12)
tail_str = ' (dB)'
else:
pss = data

print freq
freq_s = freq / 1.0E6 + cfreq / 1.0E6
print freq_s
zscale_low, zscale_high = zscale

if zscale_low == 0 and zscale_high == 0:
if log_scale:
zscale_low = numpy.median(
numpy.min(pss[numpy.where(pss.real != -numpy.Inf)])) - 3.0
zscale_high = numpy.median(numpy.max(pss)) + 3.0
else:
zscale_low = numpy.median(numpy.min(pss))
zscale_high = numpy.median(numpy.max(pss))

fig = plt.figure()
ax.plot(freq_s, pss, clr)
print freq_s[0], freq_s[-1], zscale_low, zscale_high
ax.axis([freq_s[0], freq_s[-1], zscale_low, zscale_high])
ax.grid(True)
ax.set_xlabel('frequency (MHz)')
ax.set_ylabel('power spectral density' + tail_str, fontsize=12)
ax.set_title(title)

return fig 

Example 40

def rti_plot(data, extent, tick_locs, tick_labels, log_scale, zscale, title):

# set to log scaling
if log_scale:
RTId = 10.0 * numpy.log10(data)
else:
RTId = data

zscale_low, zscale_high = zscale
if zscale_low == 0 and zscale_high == 0:
if log_scale:
zscale_low = numpy.median(
numpy.min(RTId[numpy.where(RTId.real != -numpy.Inf)])) - 3.0
zscale_high = numpy.median(numpy.max(RTId)) + 10.0
else:
zscale_low = numpy.median(numpy.min(RTId))
zscale_high = numpy.median(numpy.max(RTId))

vmin = zscale_low
vmax = zscale_high

fig = plt.figure()
img = ax.imshow(RTId, origin='lower',
extent=extent, interpolation='none', vmin=vmin, vmax=vmax, aspect='auto')

# plot dates

ax.set_xticks(tick_locs)
ax.set_xticklabels(tick_labels, rotation=-45, fontsize=10)
cb = fig.colorbar(img, ax=ax)
ax.set_xlabel('time (seconds)', fontsize=12)
ax.set_ylabel('range (km)', fontsize=12)
ax.set_title(title)

return fig 

Example 41

def __init__(self, filepath, monitor='val_loss', verbose=0,
save_best_only=False, save_weights_only=False,
mode='auto'):
super(ModelCheckpoint, self).__init__()
self.monitor = monitor
self.verbose = verbose
self.filepath = filepath
self.save_best_only = save_best_only
self.save_weights_only = save_weights_only

if mode not in ['auto', 'min', 'max']:
warnings.warn('ModelCheckpoint mode %s is unknown, '
'fallback to auto mode.' % (mode),
RuntimeWarning)
mode = 'auto'

if mode == 'min':
self.monitor_op = np.less
self.best = np.Inf
elif mode == 'max':
self.monitor_op = np.greater
self.best = -np.Inf
else:
if 'acc' in self.monitor:
self.monitor_op = np.greater
self.best = -np.Inf
else:
self.monitor_op = np.less
self.best = np.Inf 

Example 42

def on_train_begin(self, logs={}):
self.wait = 0       # Allow instances to be re-used
self.best = np.Inf if self.monitor_op == np.less else -np.Inf 

Example 43

def reset(self):
if self.mode not in ['auto', 'min', 'max']:
warnings.warn('Learning Rate Plateau Reducing mode %s is unknown, '
'fallback to auto mode.' % (self.mode), RuntimeWarning)
self.mode = 'auto'
if self.mode == 'min' or (self.mode == 'auto' and 'acc' not in self.monitor):
self.monitor_op = lambda a, b: np.less(a, b - self.epsilon)
self.best = np.Inf
else:
self.monitor_op = lambda a, b: np.greater(a, b + self.epsilon)
self.best = -np.Inf
self.cooldown_counter = 0
self.wait = 0
self.lr_epsilon = self.min_lr * 1e-4 

Example 44

def _get_bounds(self, ib, dimension):
"""ib == 0/1 means lower/upper bound, return a vector of length
dimension """
sign_ = 2 * ib - 1
assert sign_**2 == 1
if self.bounds is None or self.bounds[ib] is None:
return array(dimension * [sign_ * np.Inf])
res = []
for i in range(dimension):
res.append(self.bounds[ib][min([i, len(self.bounds[ib]) - 1])])
if res[-1] is None:
res[-1] = sign_ * np.Inf
return array(res) 

Example 45

def __init__(self, asedb, kvp={}, data={}, batch_size=1,
selection=None, shuffle=True, prefetch=False,
block_size=150000,
capacity=5000, num_epochs=np.Inf, floatX=np.float32):
super(ASEDataProvider, self).__init__(batch_size)

self.asedb = asedb
self.prefetch = prefetch
self.selection = selection
self.block_size = block_size
self.shuffle = shuffle
self.kvp = kvp
self.data = data
self.floatX = floatX
self.feat_names = ['numbers', 'positions', 'cell',
'pbc'] + list(kvp.keys()) + list(data.keys())
self.shapes = [(None,), (None, 3), (3, 3),
(3,)] + list(kvp.values()) + list(data.values())

self.epoch = 0
self.num_epochs = num_epochs
self.n_rows = 0

# initialize queue
with connect(self.asedb) as con:
row = list(con.select(self.selection, limit=1))[0]

feats = self.convert_atoms(row)
dtypes = [np.array(feat).dtype for feat in feats]
self.queue = tf.FIFOQueue(capacity, dtypes)

self.placeholders = [
tf.placeholder(dt, name=name)
for dt, name in zip(dtypes, self.feat_names)
]
self.enqueue_op = self.queue.enqueue(self.placeholders)
self.dequeue_op = self.queue.dequeue()

self.preprocs = [] 

Example 46

def read(self):
retval = self.func()
if isinstance(retval,numbers.Number) and retval != np.Inf:self.value.setText('%s'%(self.applySIPrefix(retval,self.units) ))
else: self.value.setText(str(retval)) 

Example 47

def read(self):
retval = self.func()
try:
if isinstance(retval,numbers.Number) and retval != np.Inf:self.value.setText('%s'%(self.applySIPrefix(retval,self.units) ))
else: self.value.setText(retval)
except:self.value.setText(str(retval)) 

Example 48

def read(self):
retval = self.func(self.optionBox.currentText())
#if abs(retval)<1e4 and abs(retval)>.01:self.value.setText('%.3f %s '%(retval,self.units))
#else: self.value.setText('%.3e %s '%(retval,self.units))
if isinstance(retval,numbers.Number) and retval != np.Inf:self.value.setText('%s'%(self.applySIPrefix(retval,self.units) ))
else: self.value.setText(str(retval))
self.linkFunc(retval) 

Example 49

def _safe_db(num, den):
"""Properly handle the potential +Inf db SIR, instead of raising a
RuntimeWarning. Only denominator is checked because the numerator can never
be 0.
"""
if den == 0:
return np.Inf
return 10 * np.log10(num / den) 

Example 50

def _get_bounds(self, ib, dimension):
"""ib == 0/1 means lower/upper bound, return a vector of length
dimension """
sign_ = 2 * ib - 1
assert sign_**2 == 1
if self.bounds is None or self.bounds[ib] is None:
return array(dimension * [sign_ * np.Inf])
res = []
for i in range(dimension):
res.append(self.bounds[ib][min([i, len(self.bounds[ib]) - 1])])
if res[-1] is None:
res[-1] = sign_ * np.Inf
return array(res)