# Python numpy.asfarray() 使用实例

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 _optimize_single(self, x0):
x0 = list(x0)

if x0[0] == None:
x0[0] = 0
dt_ok = np.asscalar(self.dispersion.dt_ok(x0))
if dt_ok < 0:
# Initial conditions violate constraints, reject
return x0, None, float('inf')

x0[0] = dt_ok
x0[0] = min(x0[0], self.dtmax)
x0[0] = max(x0[0], self.dtmin)

x0 = np.asfarray(x0)

stencil_ok = self.dispersion.stencil_ok(x0)
if stencil_ok < 0:
# Initial conditions violate constraints, reject
return x0, None, float('inf')

res = scop.minimize(self.dispersion.norm, x0, method='SLSQP', constraints = self.constraints, options = dict(disp=False, iprint = 2))
norm = self.dispersion_high.norm(res.x)

return x0, res, norm ```

Example 2

```def rotation_matrix(axis, angle):
"""
Calculate a three dimensional rotation matrix for a rotation around
the given angle and axis.

@type axis: (3,) numpy array
@type angle: float

@rtype: (3,3) numpy.array
"""
axis = numpy.asfarray(axis) / norm(axis)
assert axis.shape == (3,)

c = math.cos(angle)
s = math.sin(angle)

r = (1.0 - c) * numpy.outer(axis, axis)
r.flat[[0,4,8]] += c
r.flat[[5,6,1]] += s * axis
r.flat[[7,2,3]] -= s * axis

return r ```

Example 3

```def medianThreshold(img, threshold=0.1, size=3, condition='>', copy=True):
'''
set every the pixel value of the given [img] to the median filtered one
of a given kernel [size]
in case the relative [threshold] is exeeded
condition = '>' OR '<'
'''
from scipy.ndimage import median_filter

indices = None
if threshold > 0:
blur = np.asfarray(median_filter(img, size=size))
with np.errstate(divide='ignore', invalid='ignore', over='ignore'):

if condition == '>':
indices = abs((img - blur) / blur) > threshold
else:
indices = abs((img - blur) / blur) < threshold

if copy:
img = img.copy()

img[indices] = blur[indices]
return img, indices ```

Example 4

```def __init__(self, x, y):
if len(x) != len(y):
raise IndexError('x and y must be equally sized.')
self.x = np.asfarray(x)
self.y = np.asfarray(y)

# Closes the polygon if were open
x1, y1 = x[0], y[0]
xn, yn = x[-1], y[-1]
if x1 != xn or y1 != yn:
self.x = np.concatenate((self.x, [x1]))
self.y = np.concatenate((self.y, [y1]))

# Anti-clockwise coordinates
if _det(self.x, self.y) < 0:
self.x = self.x[::-1]
self.y = self.y[::-1] ```

Example 5

```def V_short(self,eta):
sum0 = np.zeros(7,dtype=float)
sum1 = np.zeros(7,dtype=float)
for n1,n2 in product(range(self.N1+1),range(self.N2+1)):
wdo = comb(self.N1,n1,exact=True)*comb(self.N2,n2,exact=True)
wdox10 = comb(self.N1-1,n1,exact=True)*comb(self.N2,n2,exact=True)
wdox11 = comb(self.N1-1,n1-1,exact=True)*comb(self.N2,n2,exact=True)
wdox20 = comb(self.N1,n1,exact=True)*comb(self.N2-1,n2,exact=True)
wdox21 = comb(self.N1,n1,exact=True)*comb(self.N2-1,n2-1,exact=True)
w = np.asarray([wdox10,wdox20,wdox11,wdox21,wdo,wdo,wdo])

pz0,pz1 = self.p_n_given_z(n1,n2)

counts = [self.N1-n1,self.N2-n2,n1,n2,1,1,1]
Q = (eta*pz0*counts*(1-self.pZgivenA)+eta*pz1*counts*self.pZgivenA).sum()

ratio = np.nan_to_num(np.true_divide(pz0*(1-self.pZgivenA)+pz1*self.pZgivenA,Q))

sum0 += np.asfarray(w*pz0*ratio)
sum1 += np.asfarray(w*pz1*ratio)
result = self.pZgivenA*sum1+(1-self.pZgivenA)*sum0
return result ```

Example 6

```def next_batch(self, batch_size=10):

datas = np.empty((0, self._height, self._width, self._dimension), int)
labels = np.empty((0, self._class_len), int)

for idx in range(batch_size):
random.randint(0, len(self._datas)-1)
tmp_img = scipy.misc.imresize(tmp_img, (self._height, self._width))
tmp_img = tmp_img.reshape(1, self._height, self._width, self._dimension)

datas = np.append(datas, tmp_img, axis=0)
labels = np.append(labels, np.eye(self._class_len)[int(np.asfarray(self._labels[idx]))].reshape(1, self._class_len), axis=0)

return datas, labels ```

Example 7

```def main():
f = open('label.txt','w')
#target_names = np.array(args.names)
X, target_names, y = getXY(args.image_dir)
X = np.asfarray(X,dtype='float')
colors = cm.gnuplot2(np.linspace(0, 1, len(target_names)))

#X_pca = PCA(n_components=128).fit_transform(X)
X_pca = X
tsne = TSNE(n_components=2, init='random', random_state=0)
X_r = tsne.fit_transform(X_pca)

for c, i, target_name in zip(colors,
list(range(0, len(target_names))),
target_names):
plt.scatter(X_r[y[i], 0], X_r[y[i], 1],
c=c, label=str(i+1))
f.write(target_name+'\n')
plt.legend()
plt.savefig("{}/10crop1.png".format('./'))
f.close() ```

Example 8

```def dcg_at_k(r, k, method=1):
"""Score is discounted cumulative gain (dcg)
Relevance is positive real values.  Can use binary
as the previous methods.
Returns:
Discounted cumulative gain
"""
r = np.asfarray(r)[:k]
if r.size:
if method == 0:
return r[0] + np.sum(r[1:] / np.log2(np.arange(2, r.size + 1)))
elif method == 1:
return np.sum(r / np.log2(np.arange(2, r.size + 2)))
else:
raise ValueError('method must be 0 or 1.')
return 0. ```

Example 9

```def gl_convert(self):
array = numpy.asfarray(self,numpy.float32)

if self.component_type != gx.F32 and self.scale_exponent != 0:
array *= 2**(-self.scale_exponent)

array = array.view(GLArray)
array.attribute = self.attribute
array.component_type = GL_FLOAT
array.component_count = self.shape[1]
array.normalize = False
return array ```

Example 10

```def _det(xvert, yvert):
'''Compute twice the area of the triangle defined by points with using
determinant formula.

Input parameters:

xvert -- A vector of nodal x-coords (array-like).
yvert -- A vector of nodal y-coords (array-like).

Output parameters:

Twice the area of the triangle defined by the points.

Notes:

_det is positive if points define polygon in anticlockwise order.
_det is negative if points define polygon in clockwise order.
_det is zero if at least two of the points are concident or if
all points are collinear.

'''
xvert = np.asfarray(xvert)
yvert = np.asfarray(yvert)
x_prev = np.concatenate(([xvert[-1]], xvert[:-1]))
y_prev = np.concatenate(([yvert[-1]], yvert[:-1]))
return np.sum(yvert * x_prev - xvert * y_prev, axis=0) ```

Example 11

```def __init__(self, x, y):
if len(x) != len(y):
raise IndexError('x and y must be equally sized.')
self.x = np.asfarray(x)
self.y = np.asfarray(y)
# Closes the polygon if were open
x1, y1 = x[0], y[0]
xn, yn = x[-1], y[-1]
if x1 != xn or y1 != yn:
self.x = np.concatenate((self.x, [x1]))
self.y = np.concatenate((self.y, [y1]))
# Anti-clockwise coordinates
if _det(self.x, self.y) < 0:
self.x = self.x[::-1]
self.y = self.y[::-1] ```

Example 12

```def test_asfarray_none(self, level=rlevel):
# Test for changeset r5065
assert_array_equal(np.array([np.nan]), np.asfarray([None])) ```

Example 13

```def dcg_k(r,k,method = 0):
'''
Score is discounted cumulative gain (dcg)
Relevance is positive real values.  Can use binary
as the previous methods.
Example from
http://www.stanford.edu/class/cs276/handouts/EvaluationNew-handout-6-per.pdf
Parameters
----------
r: Relevance scores (list or numpy) in rank order
(first element is the first item)
k: Number of results to consider
method: 0 or 1

Returns
-------
Discounted cumulative gain
'''
r = np.asfarray(r)[:k]
if r.size:
if method == 0:
#standard definition
return r[0] + np.sum(r[1:] / np.log2(np.arange(2, r.size + 1)))
elif method == 1:
#used in Kaggle
return np.sum((np.power(2,r) - 1.0) / np.log2(np.arange(2, r.size + 2)))
else:
raise ValueError('method must be 0 or 1.')
return 0. ```

Example 14

```def dcg_at_k(r, k, method=0):
"""Score is discounted cumulative gain (dcg)

Relevance is positive real values.  Can use binary
as the previous methods.

Example from
http://www.stanford.edu/class/cs276/handouts/EvaluationNew-handout-6-per.pdf
>>> r = [3, 2, 3, 0, 0, 1, 2, 2, 3, 0]
>>> dcg_at_k(r, 1)
3.0
>>> dcg_at_k(r, 1, method=1)
3.0
>>> dcg_at_k(r, 2)
5.0
>>> dcg_at_k(r, 2, method=1)
4.2618595071429155
>>> dcg_at_k(r, 10)
9.6051177391888114
>>> dcg_at_k(r, 11)
9.6051177391888114

Args:
r: Relevance scores (list or numpy) in rank order
(first element is the first item)
k: Number of results to consider
method: If 0 then weights are [1.0, 1.0, 0.6309, 0.5, 0.4307, ...]
If 1 then weights are [1.0, 0.6309, 0.5, 0.4307, ...]

Returns:
Discounted cumulative gain
"""
r = np.asfarray(r)[:k]
if r.size:
if method == 0:
return r[0] + np.sum(r[1:] / np.log2(np.arange(2, r.size + 1)))
elif method == 1:
return np.sum(r / np.log2(np.arange(2, r.size + 2)))
else:
raise ValueError('method must be 0 or 1.')
return 0. ```

Example 15

```def test_asfarray_none(self, level=rlevel):
# Test for changeset r5065
assert_array_equal(np.array([np.nan]), np.asfarray([None])) ```

Example 16

```def SNR_IEC(i1, i2, ibg=0, allow_color_images=False):
'''
Calculate the averaged signal-to-noise ratio SNR50
as defined by IEC NP 60904-13

needs 2 reference EL images and one background image
'''
# ensure images are type float64 (double precision):
i1 = np.asfarray(i1)
i2 = np.asfarray(i2)
if ibg is not 0:
ibg = np.asfarray(ibg)
assert i1.shape == ibg.shape, 'all input images need to have the same resolution'

assert i1.shape == i2.shape, 'all input images need to have the same resolution'
if not allow_color_images:
assert i1.ndim == 2, 'Images need to be in grayscale according to the IEC standard'

# SNR calculation as defined in 'IEC TS 60904-13':
signal = 0.5 * (i1 + i2) - ibg
noise = 0.5**0.5 * np.abs(i1 - i2) * ((2 / np.pi)**-0.5)
if signal.ndim == 3:  # color
signal = np.average(signal, axis=2, weights=(0.114, 0.587, 0.299))
noise = np.average(noise, axis=2, weights=(0.114, 0.587, 0.299))
signal = signal.sum()
noise = noise.sum()
return signal / noise ```

Example 17

```def scaleSignal(img, fitParams=None,
backgroundToZero=False, reference=None):
'''
scale the image between...

backgroundToZero=True -> 0 (average background) and 1 (maximum signal)
backgroundToZero=False -> signal+-3std

reference -> reference image -- scale image to fit this one

returns:
scaled image
'''
if reference is not None:
#         def fn(ii, m,n):
#             return ii*m+n
#         curve_fit(fn, img[::10,::10], ref[::10,::10])

low, high = signalRange(img, fitParams)
low2, high2 = signalRange(reference)
img = np.asfarray(img)
ampl = (high2 - low2) / (high - low)
img -= low
img *= ampl
img += low2
return img
else:
offs, div = scaleParams(img, fitParams, backgroundToZero)
img = np.asfarray(img) - offs
img /= div
print('offset: %s, divident: %s' % (offs, div))
return img ```

Example 18

```def __init__(self, imgs):  # , z=None):
#         if z is None:
#             self.z = np.arange(len(imgs))
#         else:
#             self.z = np.asfarray(z)
self.imgs = np.asfarray(imgs) ```

Example 19

```def cdf(arr, pos=None):
'''
Return the cumulative density function of a given array or
its intensity at a given position (0-1)
'''

r = (arr.min(), arr.max())
hist, bin_edges = np.histogram(arr, bins=2 * int(r[1] - r[0]), range=r)
hist = np.asfarray(hist) / hist.sum()
cdf = np.cumsum(hist)
if pos is None:
return cdf
i = np.argmax(cdf > pos)
return bin_edges[i] ```

Example 20

```def correct(self, img):
'''
...from perspective distortion:
--> perspective transformation
--> apply tilt factor (view factor) correction
'''
print("CORRECT PERSPECTIVE ...")

if not self._homography_is_fixed:
self._homography = None
h = self.homography

if self.opts['do_correctIntensity']:
tf = self.tiltFactor()
self.img = np.asfarray(self.img)
if self.img.ndim == 3:
for col in range(self.img.shape[2]):
self.img[..., col] /= tf
else:
self.img = self.img / tf
warped = cv2.warpPerspective(self.img,
h,
self._newBorders[::-1],
flags=cv2.INTER_LANCZOS4,
**self.opts['cv2_opts'])
return warped ```

Example 21

```def averageSameExpTimes(imgs_path):
'''
average background images with same exposure time
'''
firsts = imgs_path[:2]
imgs = imgs_path[2:]
for n, i in enumerate(firsts):
d = DarkCurrentMap(firsts)
for i in imgs:
return d.map() ```

Example 22

```def __init__(self, pos=[20, 20], size=[20, 20], grid=[4, 5],
shape='Rect', gap=[0, 0], subgrid=([], []),
subgrid_width=0.05, pen='w', **kwargs):
'''
shape = ['Rect', 'Square', 'Circular', 'Pseudosquare']
'''
self.opts = {'shape': shape,
'grid': np.asarray(grid),
'gap': np.asfarray(gap),
'subgrid': subgrid,
'subgrid_width': subgrid_width
}
# TODO: limit max cell size while rescale
self.maxCellSize = size / self.opts['grid']

self.cells = []
self._createCells()
self._createSubgrid()

# cannot set brush at the moment, so:
if 'brush' in kwargs:
kwargs.pop('brush')

pg.ROI.__init__(self, pos, size, pen=pen, **kwargs)

self.translatable = False
self.mouseHovering = False

self._setCellSize(self.state['size'])
self._setCellPos(pos)

self.layout_rescaling = False

Example 23

```def dcg_at_k(r, k):
"""
Args:
r: Relevance scores (list or numpy) in rank order
(first element is the first item)
k: Number of results to consider
Returns:
Discounted cumulative gain
"""
r = np.asfarray(r)[:k]
if r.size:
return np.sum(r / np.log2(np.arange(2, r.size + 2)))
return 0. ```

Example 24

```def test_asfarray_none(self, level=rlevel):
# Test for changeset r5065
assert_array_equal(np.array([np.nan]), np.asfarray([None])) ```

Example 25

```def success(self, x, tol=1.e-5):
"""
Tests if a candidate solution at the global minimum.
The default test is

Parameters
----------
x : sequence
The candidate vector for testing if the global minimum has been
reached. Must have ``len(x) == self.N``
tol : float
The evaluated function and known global minimum must differ by less
than this amount to be at a global minimum.

Returns
-------
bool : is the candidate vector at the global minimum?
"""
val = self.fun(asarray(x))
if abs(val - self.fglob) < tol:
return True

# the solution should still be in bounds, otherwise immediate fail.
if np.any(x > np.asfarray(self.bounds)[:, 1]):
return False
if np.any(x < np.asfarray(self.bounds)[:, 0]):
return False

# you found a lower global minimum.  This shouldn't happen.
if val < self.fglob:
raise ValueError("Found a lower global minimum",
x,
val,
self.fglob)

return False ```

Example 26

```def __call__(self, args):
"""Convert a list or an array into  a :class:`numpy.recarray`

:param args: List or Array to be converted
:type args: iterable"""

#print(self._fields, args)
return np.asfarray(args).view(dtype = self.dtype).view(np.recarray) ```

Example 27

```def test_asfarray_none(self, level=rlevel):
# Test for changeset r5065
assert_array_equal(np.array([np.nan]), np.asfarray([None])) ```

Example 28

```def _compute_gradient(x,
x_shape,
dx,
y,
y_shape,
dy,
x_init_value=None,
delta=1e-3,
feed_dict=None,
prep_fn=None,
limit=0):
"""Computes the theoretical and numerical jacobian."""
t = dtypes.as_dtype(x.dtype)
allowed_types = [dtypes.float16, dtypes.float32, dtypes.float64,
dtypes.complex64, dtypes.complex128]
assert t.base_dtype in allowed_types, "Don't support type %s for x" % t.name
t2 = dtypes.as_dtype(y.dtype)
assert t2.base_dtype in allowed_types, "Don't support type %s for y" % t2.name

if x_init_value is not None:
i_shape = list(x_init_value.shape)
assert(list(x_shape) == i_shape), "x_shape = %s, init_data shape = %s" % (
x_shape, i_shape)
x_data = x_init_value
else:
if t == dtypes.float16:
dtype = np.float16
elif t == dtypes.float32:
dtype = np.float32
else:
dtype = np.float64
x_data = np.asfarray(np.random.random_sample(x_shape), dtype=dtype)

print("\ttheoretical jacobian..")
jacob_t = _compute_theoretical_jacobian(x, x_shape, x_data, dy, y_shape, dx, feed_dict, prep_fn=prep_fn)

print("\tnumeric jacobian..")
jacob_n = _compute_numeric_jacobian(x, x_shape, x_data, y, y_shape, delta, feed_dict, prep_fn=prep_fn, limit=limit)
return jacob_t, jacob_n ```

Example 29

```def __init__(self, center, width, height, angle, points=None):
"""Creates a new RotatedBox.

:param points: This parameter may be used to indicate the set of points used to create the box.
"""
self.center = np.asfarray(center)
self.width = width
self.height = height
self.angle = angle
self.points = points ```

Example 30

```def rotated(self, rotation_center, angle):
"""Returns a RotatedBox that is obtained by rotating this box around a given center by a given angle.

>>> assert RotatedBox([2, 2], 2, 1, 0.1).rotated([1, 1], np.pi/2).approx_equal([0, 2], 2, 1, np.pi/2+0.1)
"""
rot = np.array([[np.cos(angle), np.sin(angle)], [-np.sin(angle), np.cos(angle)]])
t = np.asfarray(rotation_center)
new_c = np.dot(rot.T, (self.center - t)) + t
return RotatedBox(new_c, self.width, self.height, (self.angle+angle) % (np.pi*2)) ```

Example 31

```def dcg_at_k(r, k):
r = np.asfarray(r)[:k]
return np.sum(r / np.log2(np.arange(2, r.size + 2))) ```

Example 32

```def test_asfarray_none(self, level=rlevel):
# Test for changeset r5065
assert_array_equal(np.array([np.nan]), np.asfarray([None])) ```

Example 33

```def next_batch(self, batch_size=10, start=-1, end=-1, nth=-1):
data = np.empty((0, self._data_len), float)
label = np.empty((0, self._class_len), int)

with open(PACK_PATH+"/dataset/"+str(self._who_am_i)+".csv") as f:

if(nth == -1):
if((start == -1) and (end == -1)):
datas = random.sample(lines, batch_size)
else:
datas = lines[start:end]
else:
datas = []
datas.append(lines[nth])

for d in datas:
sv_data = d.split(',')
tmp_label = sv_data[0]
tmp_data = sv_data[1:len(sv_data)-1]

tmp_data = np.asarray(tmp_data).reshape((1, len(tmp_data)))

label = np.append(label, np.eye(self._class_len)[int(np.asfarray(tmp_label))].reshape(1, self._class_len), axis=0)
data = np.append(data, tmp_data, axis=0)

return data, label ```

Example 34

```def main1():
#target_names = np.array(args.names)
X, Y = getFeatureAndPath(args.image_dir)
X = np.asfarray(X,dtype='float')
#X_pca = PCA(n_components=128).fit_transform(X)
X_pca = X
tsne = TSNE(n_components=2, init='random', random_state=0)
X_r = tsne.fit_transform(X_pca)
imgPlot(X_r,Y) ```

Example 35

```def dcg_at_k(r, k):
r = np.asfarray(r)[:k]
return np.sum(r / np.log2(np.arange(2, r.size + 2))) ```

Example 36

```def dcg_at_k(r, k):
r = np.asfarray(r)[:k]
return np.sum(r / np.log2(np.arange(2, r.size + 2))) ```

Example 37

```def recall_at_k(r, k, all_pos_num):
r = np.asfarray(r)[:k]
return np.sum(r) / all_pos_num ```

Example 38

```def __init__(self, ci, cn, transf):

Layer.__init__(self, ci, cn, cn, {'w': (cn, ci), 'b': cn})

self.transf = transf
if not hasattr(transf, 'out_minmax'):
test = np.asfarry([-1e100, -100, -10, -1, 0, 1, 10, 100, 1e100])
val = self.transf(test)
self.out_minmax = np.array([val.min(), val.max()] * self.co)
else:
self.out_minmax = np.asfarray([transf.out_minmax] * self.co)
# default init function
self.initf = init.initwb_reg
#self.initf = init.initwb_nw
self.s = np.zeros(self.cn) ```

Example 39

```def __init__(self, ci, cn, transf, max_iter, delta):
Layer.__init__(self, ci, cn, cn, {'w': (cn, ci), 'b': cn})
self.max_iter = max_iter
self.delta = delta
self.transf = transf
self.outs = []
if not hasattr(transf, 'out_minmax'):
test = np.asfarry([-1e100, -100, -10, -1, 0, 1, 10, 100, 1e100])
val = self.transf(test)
self.out_minmax = np.array([val.min(), val.max()] * self.co)
else:
self.out_minmax = np.asfarray([transf.out_minmax] * self.co)
self.initf = None
self.s = np.zeros(self.cn) ```

Example 40

```def newlvq(minmax, cn0, pc):
"""
Create a learning vector quantization (LVQ) network

:Parameters:
minmax: list of list, the outer list is the number of input neurons,
inner lists must contain 2 elements: min and max
Range of input value
cn0: int
Number of neurons in input layer
pc: list
List of percent, sum(pc) == 1
:Returns:
net: Net
:Example:
>>> # create network with 2 inputs,
>>> # 2 layers and 10 neurons in each layer
>>> net = newlvq([[-1, 1], [-1, 1]], 10, [0.6, 0.4])

"""
pc = np.asfarray(pc)
assert sum(pc) == 1
ci = len(minmax)
cn1 = len(pc)
assert cn0 > cn1

layer_inp = layer.Competitive(ci, cn0)
layer_out = layer.Perceptron(cn0, cn1, trans.PureLin())
layer_out.initf = None
layer_out.np['b'].fill(0.0)
layer_out.np['w'].fill(0.0)
inx = np.floor(cn0 * pc.cumsum())
for n, i in enumerate(inx):
st = 0 if n == 0 else inx[n - 1]
layer_out.np['w'][n][st:i].fill(1.0)
net = Net(minmax, cn1, [layer_inp, layer_out],
[[-1], [0], [1]], train.train_lvq, error.MSE())

return net ```

Example 41

```def __init__(self, x):

x = np.asfarray(x)
if x.ndim != 2:
raise ValueError('x mast have 2 dimensions')
min = np.min(x, axis=0)
dist = np.max(x, axis=0) - min

min.shape = 1, min.size
dist.shape = 1, dist.size

self.min = min
self.dist = dist ```

Example 42

```def __call__(self, x):
x = np.asfarray(x)
res = (x - self.min) / self.dist

return res ```

Example 43

```def renorm(self, x):
x = np.asfarray(x)

res = x * self.dist + self.min
return res

#------------------------------------------------------------ ```

Example 44

```def step(self, inp):
"""
Simulated step

:Parameters:
inp: array like
Input vector
:Returns:
out: array
Output vector

"""
#TODO: self.inp=np.asfarray(inp)?

self.inp = inp
for nl, nums in enumerate(self.connect):
if len(nums) > 1:
signal = []
for ns in nums:
s = self.layers[ns].out if ns != -1 else inp
signal.append(s)
signal = np.concatenate(signal)
else:
ns = nums[0]
signal = self.layers[ns].out if ns != -1 else inp
if nl != len(self.layers):
self.layers[nl].step(signal)
self.out = signal
return self.out ```

Example 45

```def test_asfarray_none(self, level=rlevel):
# Test for changeset r5065
assert_array_equal(np.array([np.nan]), np.asfarray([None])) ```

Example 46

```def SNR(img1, img2=None, bg=None,
noise_level_function=None,
constant_noise_level=False,
imgs_to_be_averaged=False):
'''
Returns a signal-to-noise-map
uses algorithm as described in BEDRICH 2016 JPV (not jet published)

:param constant_noise_level: True, to assume noise to be constant
:param imgs_to_be_averaged: True, if SNR is for average(img1, img2)
'''
# dark current subtraction:
img1 = np.asfarray(img1)
if bg is not None:
img1 = img1 - bg

# SIGNAL:
if img2 is not None:
img2_exists = True
img2 = np.asfarray(img2) - bg
# signal as average on both images
signal = 0.5 * (img1 + img2)
else:
img2_exists = False
signal = img1
# denoise:
signal = median_filter(signal, 3)

# NOISE
if constant_noise_level:
# CONSTANT NOISE
if img2_exists:
d = img1 - img2
# 0.5**0.5 because of sum of variances
noise = 0.5**0.5 * np.mean(np.abs((d))) * F_RMS2AAD
else:
d = (img1 - signal) * F_NOISE_WITH_MEDIAN
else:
# NOISE LEVEL FUNCTION
if noise_level_function is None:
noise_level_function, _ = oneImageNLF(img1, img2, signal)
noise = noise_level_function(signal)
noise[noise < 1] = 1  # otherwise SNR could be higher than image value

if imgs_to_be_averaged:
# SNR will be higher if both given images are supposed to be averaged:
# factor of noise reduction if SNR if for average(img1, img2):
noise *= 0.5**0.5

# BACKGROUND estimation and removal if background not given:
if bg is None:
bg = getBackgroundLevel(img1)
signal -= bg
snr = signal / noise

# limit to 1, saying at these points signal=noise:
snr[snr < 1] = 1
return snr ```

Example 47

```def SNRaverage(snr, method='average', excludeBackground=True,
checkBackground=True,
backgroundLevel=None):
'''
average a signal-to-noise map
:param method:  ['average','X75', 'RMS', 'median'] - X75: this SNR will be exceeded by 75% of the signal
:type method: str
:param checkBackground:  check whether there is actually a background level to exclude
:type  checkBackground: bool
:returns: averaged SNR as float
'''
if excludeBackground:
# get background level
if backgroundLevel is None:
try:
f = FitHistogramPeaks(snr).fitParams
if checkBackground:
if not hasBackground(f):
excludeBackground = False
if excludeBackground:
backgroundLevel = getSignalMinimum(f)
except (ValueError, AssertionError):
backgroundLevel = snr.min()
if excludeBackground:
snr = snr[snr >= backgroundLevel]

if method == 'RMS':
avg = (snr**2).mean()**0.5

elif method == 'average':
avg = snr.mean()
#         if np.isnan(avg):
#             avg = np.nanmean(snr)
elif method == 'median':
avg = np.median(snr)
#         if np.isnan(avg):
#             avg = np.nanmedian(snr)

elif method == 'X75':
r = (snr.min(), snr.max())
hist, bin_edges = np.histogram(snr, bins=2 * int(r[1] - r[0]), range=r)
hist = np.asfarray(hist) / hist.sum()
cdf = np.cumsum(hist)
i = np.argmax(cdf > 0.25)
avg = bin_edges[i]
else:
raise NotImplemented("given SNR average doesn't exist")

return avg ```

Example 48

```def imagelist_to_dataset(image_dir, image_lists, imsize=28):
master_key, sub_key = key_from_dictionary(image_lists)

print("\n***** Make image list *****")
result_dir = "dataset/"
if not os.path.exists(result_dir):
os.makedirs(result_dir)
else:
shutil.rmtree(result_dir)
os.makedirs(result_dir)

x_train = []
t_train = np.empty((0), int)
x_test = []
t_test = np.empty((0), int)
x_valid = []
t_valid = np.empty((0), int)
for key_i in [0, 1, 3]:
if key_i == 0:
result_name = "train"
elif key_i == 1:
result_name = "test"
else:
result_name = "valid"
sys.stdout.write(" Make \'"+result_name+" list\'...")
# m: class
for m in master_key:

for i in range(len(image_lists[m][sub_key[key_i]])):
# m: category
# image_lists[m][sub_key[key_i]][i]: image name
image_path = "./"+image_dir+"/"+m+"/"+image_lists[m][sub_key[key_i]][i]
# Read jpg images and resizing it.
resized_image = cv2.resize(origin_image, (imsize, imsize))
grayscale_image = cv2.cvtColor(resized_image, cv2.COLOR_BGR2GRAY)

image_save(result_dir+"origin/"+result_name+"/", image_lists[m][sub_key[key_i]][i], origin_image)
image_save(result_dir+"resize/"+result_name+"/", image_lists[m][sub_key[key_i]][i], resized_image)
image_save(result_dir+"gray/"+result_name+"/", image_lists[m][sub_key[key_i]][i], grayscale_image)

if key_i == 0:
x_train.append(resized_image)
t_train = np.append(t_train, np.array([int(np.asfarray(m))]), axis=0)
elif key_i == 1:
x_test.append(resized_image)
t_test = np.append(t_test, np.array([int(np.asfarray(m))]), axis=0)
else:
x_valid.append(resized_image)
t_valid = np.append(t_valid, np.array([int(np.asfarray(m))]), axis=0)

print(" complete.")
#print(" x_train shape: " + str(np.array(x_train).shape))
#print(" t_train shape: " + str(np.array(t_train).shape))
#print(" x_test shape: " + str(np.array(x_test).shape))
#print(" t_test shape: " + str(np.array(t_test).shape))
x_train = np.asarray(x_train)
t_train = np.asarray(t_train)
x_test = np.asarray(x_test)
t_test = np.asarray(t_test)
return (x_train, t_train), (x_test, t_test), len(master_key) ```

Example 49

```def newhop(target, transf=None, max_init=10, delta=0):
"""
Create a Hopfield recurrent network

:Parameters:
target: array like (l x net.co)
train target patterns
transf: func (default HardLims)
Activation function
max_init: int (default 10)
Maximum of recurrent iterations
delta: float (default 0)
Minimum difference between 2 outputs for stop recurrent cycle
:Returns:
net: Net
:Example:
>>> net = newhem([[-1, -1, -1], [1, -1, 1]])
>>> output = net.sim([[-1, 1, -1], [1, -1, 1]])

"""

target = np.asfarray(target)
assert target.ndim == 2

ci = len(target[0])
if transf is None:
transf = trans.HardLims()
l = layer.Reccurent(ci, ci, transf, max_init, delta)
w = l.np['w']
b = l.np['b']

# init weight
for i in range(ci):
for j in range(ci):
if i == j:
w[i, j] = 0.0
else:
w[i, j] = np.sum(target[:, i] * target[:, j]) / ci
b[i] = 0.0
l.initf = None

minmax = transf.out_minmax if hasattr(transf, 'out_minmax') else [-1, 1]

net = Net([minmax] * ci, ci, [l], [[-1], [0]], None, None)
return net ```

Example 50

```def newhem(target, transf=None, max_iter=10, delta=0):
"""
Create a Hemming recurrent network with 2 layers

:Parameters:
target: array like (l x net.co)
train target patterns
transf: func (default SatLinPrm(0.1, 0, 10))
Activation function of input layer
max_init: int (default 10)
Maximum of recurrent iterations
delta: float (default 0)
Minimum dereference between 2 outputs for stop recurrent cycle
:Returns:
net: Net
:Example:
>>> net = newhop([[-1, -1, -1], [1, -1, 1]])
>>> output = net.sim([[-1, 1, -1], [1, -1, 1]])

"""

target = np.asfarray(target)
assert target.ndim == 2

cn = target.shape[0]
ci = target.shape[1]

if transf is None:
transf = trans.SatLinPrm(0.1, 0, 10)
layer_inp = layer.Perceptron(ci, cn, transf)

# init input layer
layer_inp.initf = None
layer_inp.np['b'][:] = float(ci) / 2
for i, tar in enumerate(target):
layer_inp.np['w'][i][:] = tar / 2

layer_out = layer.Reccurent(cn, cn, trans.SatLinPrm(1, 0, 1e6), max_iter, delta)
# init output layer
layer_out.initf = None
layer_out.np['b'][:] = 0
eps = - 1.0 / cn
for i in range(cn):
layer_out.np['w'][i][:] = [eps] * cn
layer_out.np['w'][i][i] = 1
# create network
minmax = [[-1, 1]] * ci
layers = [layer_inp, layer_out]
connect = [[-1], [0], [1]]
net = Net(minmax, cn, layers, connect, None, None)
return net ```