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
    @param angle: angle in radians
    @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.imread(self._datas[idx])
            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
    '''
    img = imread(img)
    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 ...")
        self.img = imread(img)

        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):
        firsts[n] = np.asfarray(imread(i))
    d = DarkCurrentMap(firsts)
    for i in imgs:
        i = imread(i)
        d.addImg(i)
    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

        self.addScaleHandle([1, 1], [0, 0])
        self.addScaleHandle([0, 0], [1, 1])
        self.addScaleHandle([1, 0], [0, 1])
        self.addScaleHandle([0, 1], [1, 0])

        self.addRotateHandle([0.5, 1], [0.5, 0.5]) 

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:
            lines = f.readlines()

        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
            noise = np.mean(np.abs(d)) * F_RMS2AAD
    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.
                    origin_image = cv2.imread(image_path)
                    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 
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注