コード例 #1
0
ファイル: lstm.py プロジェクト: Vanova/minpy
    def outputs(inputs, forget_weights, change_weights, ingate_weights,
            outgate_weights, predict_weights):
        """Outputs normalized log-probabilities of each character, plus an
           extra one at the end."""
        num_sequences = inputs.shape[1]
        hiddens = np.repeat(parser.get(weights, 'init_hiddens'), num_sequences, axis=0)
        cells   = np.repeat(parser.get(weights, 'init_cells'),   num_sequences, axis=0)

        output = [hiddens_to_output_probs(predict_weights, hiddens)]
        for input in inputs:  # Iterate over time steps.
            hiddens, cells = update_lstm(input, hiddens, cells, forget_weights,
                                         change_weights, ingate_weights, outgate_weights)
            output.append(hiddens_to_output_probs(predict_weights, hiddens))
        return output
コード例 #2
0
def affine_forward(x, w, b):
  """
  Computes the forward pass for an affine (fully-connected) layer.

  The input x has shape (N, d_1, ..., d_k) and contains a minibatch of N
  examples, where each example x[i] has shape (d_1, ..., d_k). We will
  reshape each input into a vector of dimension D = d_1 * ... * d_k, and
  then transform it to an output vector of dimension M.

  Inputs:
  - x: A numpy array containing input data, of shape (N, d_1, ..., d_k)
  - w: A numpy array of weights, of shape (D, M)
  - b: A numpy array of biases, of shape (M,)
  
  Returns a tuple of:
  - out: output, of shape (N, M)
  - cache: (x, w, b)
  """

  x_plain = np.reshape(x, (x.shape[0], -1))

  # Note: GPU has no automatically broadcast feature?
  out = np.dot(x_plain, w) + np.repeat(np.expand_dims(b, axis=0), x_plain.shape[0], axis = 0)

  cache = (x, w, b) 
  
  return out, cache
コード例 #3
0
    def outputs(inputs, forget_weights, change_weights, ingate_weights,
                outgate_weights, predict_weights):
        """Outputs normalized log-probabilities of each character, plus an
           extra one at the end."""
        num_sequences = inputs.shape[1]
        hiddens = np.repeat(parser.get(weights, 'init_hiddens'),
                            num_sequences,
                            axis=0)
        cells = np.repeat(parser.get(weights, 'init_cells'),
                          num_sequences,
                          axis=0)

        output = [hiddens_to_output_probs(predict_weights, hiddens)]
        for input in inputs:  # Iterate over time steps.
            hiddens, cells = update_lstm(input, hiddens, cells, forget_weights,
                                         change_weights, ingate_weights,
                                         outgate_weights)
            output.append(hiddens_to_output_probs(predict_weights, hiddens))
        return output
コード例 #4
0
def test_sum_forward():

  np_x = py_np.zeros((2, 10))
  np_w = py_np.zeros((10, 3))
  np_b = py_np.zeros(3)

  x = NumpyVarToMinpy(np_x)
  w = NumpyVarToMinpy(np_w)
  b = NumpyVarToMinpy(np_b)

  x_plain = np.reshape(x, (x.shape[0], -1))
  out0 = np.dot(x_plain, w)
  out = out0 + np.repeat(np.expand_dims(b, axis=0), out0.shape[0], axis = 0)

  np_out = MinpyVarToNumpy(out)

  var = py_np.random.randn(2, 3)
  tmp = NumpyVarToMinpy(var)
  sum_tmp = np.sum(tmp, axis = 0)

  sum_py = MinpyVarToNumpy(sum_tmp)
コード例 #5
0
def predict(models, img, t=0):
    img = np.clip(img, 0, 1) * 255
    img = extend_data(config['permutation'], np.array([img]))
    scores = np.hstack([m.predict(img) for m in models])[0]
    #print(scores.shape)

    nat_labels = np.zeros(scores.shape).astype(np.float32)
    nat_labels[scores >= 0.5] = 1.
    rep = rep_labels[:len(scores)].T
    tmp = np.repeat([nat_labels], rep.shape[0], axis=0)
    dists = np.sum(np.absolute(tmp - rep), axis=-1)
    min_dist = np.min(dists)
    pred_labels = np.arange(len(dists))[dists == min_dist]
    pred_scores = [
        np.sum([
            scores[k] if rep[j][k] == 1 else 1 - scores[k]
            for k in np.arange(len(scores))
        ]) for j in pred_labels
    ]
    pred_label = pred_labels[np.argmax(pred_scores)]
    if min_dist <= 0:
        return pred_label
    else:
        return -1
コード例 #6
0
def test_fromnumeric():
    # Functions
    # 'alen', 'all', 'alltrue', 'amax', 'amin', 'any', 'argmax',
    # 'argmin', 'argpartition', 'argsort', 'around', 'choose', 'clip',
    # 'compress', 'cumprod', 'cumproduct', 'cumsum', 'diagonal', 'mean',
    # 'ndim', 'nonzero', 'partition', 'prod', 'product', 'ptp', 'put',
    # 'rank', 'ravel', 'repeat', 'reshape', 'resize', 'round_',
    # 'searchsorted', 'shape', 'size', 'sometrue', 'sort', 'squeeze',
    # 'std', 'sum', 'swapaxes', 'take', 'trace', 'transpose', 'var',
    a = [4, 3, 5, 7, 6, 8]
    indices = [0, 1, 4]
    np.take(a, indices)
    a = np.array(a)
    # a[indices]
    np.take(a, [[0, 1], [2, 3]])
    a = np.zeros((10, 2))
    b = a.T
    a = np.arange(6).reshape((3, 2))
    np.reshape(a, (2, 3))  # C-like index ordering
    np.reshape(np.ravel(a), (2, 3))  # equivalent to C ravel then C reshape
    np.reshape(a, (2, 3), order='F')  # Fortran-like index ordering
    np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
    a = np.array([[1, 2, 3], [4, 5, 6]])
    np.reshape(a, 6)
    np.reshape(a, 6, order='F')
    np.reshape(a, (3, -1))  # the unspecified value is inferred to be 2
    choices = [[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23],
               [30, 31, 32, 33]]
    np.choose([2, 3, 1, 0], choices)
    np.choose([2, 4, 1, 0], choices, mode='clip')  # 4 goes to 3 (4-1)
    np.choose([2, 4, 1, 0], choices, mode='wrap')  # 4 goes to (4 mod 4)
    a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
    choices = [-10, 10]
    np.choose(a, choices)
    a = np.array([0, 1]).reshape((2, 1, 1))
    c1 = np.array([1, 2, 3]).reshape((1, 3, 1))
    c2 = np.array([-1, -2, -3, -4, -5]).reshape((1, 1, 5))
    np.choose(a, (c1, c2))  # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
    np.repeat(3, 4)
    x = np.array([[1, 2], [3, 4]])
    np.repeat(x, 2)
    np.repeat(x, 3, axis=1)
    np.repeat(x, [1, 2], axis=0)
    a = np.arange(5)
    np.put(a, [0, 2], [-44, -55])
    a = np.arange(5)
    np.put(a, 22, -5, mode='clip')
    x = np.array([[1, 2, 3]])
    np.swapaxes(x, 0, 1)
    x = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
    np.swapaxes(x, 0, 2)
    x = np.arange(4).reshape((2, 2))
    np.transpose(x)
    x = np.ones((1, 2, 3))
    np.transpose(x, (1, 0, 2)).shape
    a = np.array([3, 4, 2, 1])
    np.partition(a, 3)
    np.partition(a, (1, 3))
    x = np.array([3, 4, 2, 1])
    x[np.argpartition(x, 3)]
    x[np.argpartition(x, (1, 3))]
    x = [3, 4, 2, 1]
    np.array(x)[np.argpartition(x, 3)]
    a = np.array([[1, 4], [3, 1]])
    np.sort(a)  # sort along the last axis
    np.sort(a, axis=None)  # sort the flattened array
    np.sort(a, axis=0)  # sort along the first axis
    dtype = [('name', 'S10'), ('height', float), ('age', int)]
    values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38), ('Galahad', 1.7, 38)]
    a = np.array(values, dtype=dtype)  # create a structured array
    np.sort(a, order='height')  # doctest: +SKIP
    np.sort(a, order=['age', 'height'])  # doctest: +SKIP
    x = np.array([3, 1, 2])
    np.argsort(x)
    x = np.array([[0, 3], [2, 2]])
    np.argsort(x, axis=0)
    np.argsort(x, axis=1)
    x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
    np.argsort(x, order=('x', 'y'))
    np.argsort(x, order=('y', 'x'))
    a = np.arange(6).reshape(2, 3)
    np.argmax(a)
    np.argmax(a, axis=0)
    np.argmax(a, axis=1)
    b = np.arange(6)
    b[1] = 5
    np.argmax(b)  # Only the first occurrence is returned.
    a = np.arange(6).reshape(2, 3)
    np.argmin(a)
    np.argmin(a, axis=0)
    np.argmin(a, axis=1)
    b = np.arange(6)
    b[4] = 0
    np.argmin(b)  # Only the first occurrence is returned.
    np.searchsorted([1, 2, 3, 4, 5], 3)
    np.searchsorted([1, 2, 3, 4, 5], 3, side='right')
    np.searchsorted([1, 2, 3, 4, 5], [-10, 10, 2, 3])
    a = np.array([[0, 1], [2, 3]])
    np.resize(a, (2, 3))
    np.resize(a, (1, 4))
    np.resize(a, (2, 4))
    x = np.array([[[0], [1], [2]]])
    x.shape
    np.squeeze(x).shape
    np.squeeze(x, axis=(2, )).shape
    a = np.arange(4).reshape(2, 2)
    a = np.arange(8).reshape(2, 2, 2)
    a
    a[:, :, 0]  # main diagonal is [0 6]
    a[:, :, 1]  # main diagonal is [1 7]
    np.trace(np.eye(3))
    a = np.arange(8).reshape((2, 2, 2))
    np.trace(a)
    a = np.arange(24).reshape((2, 2, 2, 3))
    np.trace(a).shape
    x = np.array([[1, 2, 3], [4, 5, 6]])
    np.ravel(x)
    x.reshape(-1)
    np.ravel(x, order='F')
    np.ravel(x.T)
    np.ravel(x.T, order='A')
    a = np.arange(3)[::-1]
    a
    # a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    x = np.eye(3)
    np.nonzero(x)
    x[np.nonzero(x)]
    np.transpose(np.nonzero(x))
    a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    a > 3
    np.nonzero(a > 3)
    np.shape(np.eye(3))
    np.shape([[1, 2]])
    np.shape([0])
    np.shape(0)
    a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
    np.shape(a)
    a.shape
    a = np.array([[1, 2], [3, 4], [5, 6]])
    np.compress([0, 1], a, axis=0)
    np.compress([False, True, True], a, axis=0)
    np.compress([False, True], a, axis=1)
    np.compress([False, True], a)
    a = np.arange(10)
    np.clip(a, 1, 8)
    np.clip(a, 3, 6, out=a)
    a = np.arange(10)
    np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
    np.sum([])
    np.sum([0.5, 1.5])
    np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
    np.sum([[0, 1], [0, 5]])
    np.sum([[0, 1], [0, 5]], axis=0)
    np.sum([[0, 1], [0, 5]], axis=1)
    # np.ones(128, dtype=np.int8).sum(dtype=np.int8)
    # np.any([[True, False], [True, True]])
    # np.any([[True, False], [False, False]], axis=0)
    # np.any([-1, 0, 5])
    # np.any(np.nan)
    # np.all([[True,False],[True,True]])
    # np.all([[True,False],[True,True]], axis=0)
    # np.all([-1, 4, 5])
    # np.all([1.0, np.nan])
    a = np.array([[1, 2, 3], [4, 5, 6]])
    np.cumsum(a)
    np.cumsum(a, dtype=float)  # specifies type of output value(s)
    np.cumsum(a, axis=0)  # sum over rows for each of the 3 columns
    np.cumsum(a, axis=1)  # sum over columns for each of the 2 rows
    x = np.arange(4).reshape((2, 2))
    np.ptp(x, axis=0)
    np.ptp(x, axis=1)
    a = np.arange(4).reshape((2, 2))
    np.amax(a)  # Maximum of the flattened array
    np.amax(a, axis=0)  # Maxima along the first axis
    np.amax(a, axis=1)  # Maxima along the second axis
    b = np.arange(5, dtype=np.float)
    # b[2] = np.NaN
    np.amax(b)
    np.nanmax(b)
    a = np.arange(4).reshape((2, 2))
    np.amin(a)  # Minimum of the flattened array
    np.amin(a, axis=0)  # Minima along the first axis
    np.amin(a, axis=1)  # Minima along the second axis
    b = np.arange(5, dtype=np.float)
    # b[2] = np.NaN
    np.amin(b)
    np.nanmin(b)
    a = np.zeros((7, 4, 5))
    a.shape[0]
    np.alen(a)
    x = np.array([536870910, 536870910, 536870910, 536870910])
    np.prod(x)  #random
    np.prod([])
    np.prod([1., 2.])
    np.prod([[1., 2.], [3., 4.]])
    np.prod([[1., 2.], [3., 4.]], axis=1)
    x = np.array([1, 2, 3], dtype=np.uint8)
    # np.prod(x).dtype == np.uint
    x = np.array([1, 2, 3], dtype=np.int8)
    # np.prod(x).dtype == np.int
    a = np.array([1, 2, 3])
    np.cumprod(a)  # intermediate results 1, 1*2
    a = np.array([[1, 2, 3], [4, 5, 6]])
    np.cumprod(a, dtype=float)  # specify type of output
    np.cumprod(a, axis=0)
    np.cumprod(a, axis=1)
    np.ndim([[1, 2, 3], [4, 5, 6]])
    np.ndim(np.array([[1, 2, 3], [4, 5, 6]]))
    np.ndim(1)
    a = np.array([[1, 2, 3], [4, 5, 6]])
    np.size(a)
    np.size(a, 1)
    np.size(a, 0)
    np.around([0.37, 1.64])
    np.around([0.37, 1.64], decimals=1)
    np.around([.5, 1.5, 2.5, 3.5, 4.5])  # rounds to nearest even value
    np.around([1, 2, 3, 11], decimals=1)  # ndarray of ints is returned
    np.around([1, 2, 3, 11], decimals=-1)
    a = np.array([[1, 2], [3, 4]])
    np.mean(a)
    np.mean(a, axis=0)
    np.mean(a, axis=1)
    a = np.zeros((2, 512 * 512), dtype=np.float32)
    a[0, :] = 1.0
    a[1, :] = 0.1
    np.mean(a)
    np.mean(a, dtype=np.float64)
    a = np.array([[1, 2], [3, 4]])
    np.std(a)
    np.std(a, axis=0)
    np.std(a, axis=1)
    a = np.zeros((2, 512 * 512), dtype=np.float32)
    a[0, :] = 1.0
    a[1, :] = 0.1
    np.std(a)
    np.std(a, dtype=np.float64)
    a = np.array([[1, 2], [3, 4]])
    np.var(a)
    np.var(a, axis=0)
    np.var(a, axis=1)
    a = np.zeros((2, 512 * 512), dtype=np.float32)
    a[0, :] = 1.0
    a[1, :] = 0.1
    np.var(a)
    np.var(a, dtype=np.float64)
コード例 #7
0
def test_fromnumeric():
    # Functions
    # 'alen', 'all', 'alltrue', 'amax', 'amin', 'any', 'argmax',
    # 'argmin', 'argpartition', 'argsort', 'around', 'choose', 'clip',
    # 'compress', 'cumprod', 'cumproduct', 'cumsum', 'diagonal', 'mean',
    # 'ndim', 'nonzero', 'partition', 'prod', 'product', 'ptp', 'put',
    # 'rank', 'ravel', 'repeat', 'reshape', 'resize', 'round_',
    # 'searchsorted', 'shape', 'size', 'sometrue', 'sort', 'squeeze',
    # 'std', 'sum', 'swapaxes', 'take', 'trace', 'transpose', 'var',
    a = [4, 3, 5, 7, 6, 8]
    indices = [0, 1, 4]
    np.take(a, indices)
    a = np.array(a)
    # a[indices]
    np.take(a, [[0, 1], [2, 3]])
    a = np.zeros((10, 2))
    b = a.T
    a = np.arange(6).reshape((3, 2))
    np.reshape(a, (2, 3)) # C-like index ordering
    np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
    np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
    np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
    a = np.array([[1,2,3], [4,5,6]])
    np.reshape(a, 6)
    np.reshape(a, 6, order='F')
    np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
    choices = [[0, 1, 2, 3], [10, 11, 12, 13],
               [20, 21, 22, 23], [30, 31, 32, 33]]
    np.choose([2, 3, 1, 0], choices)
    np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
    np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
    a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
    choices = [-10, 10]
    np.choose(a, choices)
    a = np.array([0, 1]).reshape((2,1,1))
    c1 = np.array([1, 2, 3]).reshape((1,3,1))
    c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
    np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
    np.repeat(3, 4)
    x = np.array([[1,2],[3,4]])
    np.repeat(x, 2)
    np.repeat(x, 3, axis=1)
    np.repeat(x, [1, 2], axis=0)
    a = np.arange(5)
    np.put(a, [0, 2], [-44, -55])
    a = np.arange(5)
    np.put(a, 22, -5, mode='clip')
    x = np.array([[1,2,3]])
    np.swapaxes(x,0,1)
    x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
    np.swapaxes(x,0,2)
    x = np.arange(4).reshape((2,2))
    np.transpose(x)
    x = np.ones((1, 2, 3))
    np.transpose(x, (1, 0, 2)).shape
    a = np.array([3, 4, 2, 1])
    np.partition(a, 3)
    np.partition(a, (1, 3))
    x = np.array([3, 4, 2, 1])
    x[np.argpartition(x, 3)]
    x[np.argpartition(x, (1, 3))]
    x = [3, 4, 2, 1]
    np.array(x)[np.argpartition(x, 3)]
    a = np.array([[1,4],[3,1]])
    np.sort(a)                # sort along the last axis
    np.sort(a, axis=None)     # sort the flattened array
    np.sort(a, axis=0)        # sort along the first axis
    dtype = [('name', 'S10'), ('height', float), ('age', int)]
    values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
              ('Galahad', 1.7, 38)]
    a = np.array(values, dtype=dtype)       # create a structured array
    np.sort(a, order='height')                        # doctest: +SKIP
    np.sort(a, order=['age', 'height'])               # doctest: +SKIP
    x = np.array([3, 1, 2])
    np.argsort(x)
    x = np.array([[0, 3], [2, 2]])
    np.argsort(x, axis=0)
    np.argsort(x, axis=1)
    x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
    np.argsort(x, order=('x','y'))
    np.argsort(x, order=('y','x'))
    a = np.arange(6).reshape(2,3)
    np.argmax(a)
    np.argmax(a, axis=0)
    np.argmax(a, axis=1)
    b = np.arange(6)
    b[1] = 5
    np.argmax(b) # Only the first occurrence is returned.
    a = np.arange(6).reshape(2,3)
    np.argmin(a)
    np.argmin(a, axis=0)
    np.argmin(a, axis=1)
    b = np.arange(6)
    b[4] = 0
    np.argmin(b) # Only the first occurrence is returned.
    np.searchsorted([1,2,3,4,5], 3)
    np.searchsorted([1,2,3,4,5], 3, side='right')
    np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
    a=np.array([[0,1],[2,3]])
    np.resize(a,(2,3))
    np.resize(a,(1,4))
    np.resize(a,(2,4))
    x = np.array([[[0], [1], [2]]])
    x.shape
    np.squeeze(x).shape
    np.squeeze(x, axis=(2,)).shape
    a = np.arange(4).reshape(2,2)
    a = np.arange(8).reshape(2,2,2); a
    a[:,:,0] # main diagonal is [0 6]
    a[:,:,1] # main diagonal is [1 7]
    np.trace(np.eye(3))
    a = np.arange(8).reshape((2,2,2))
    np.trace(a)
    a = np.arange(24).reshape((2,2,2,3))
    np.trace(a).shape
    x = np.array([[1, 2, 3], [4, 5, 6]])
    np.ravel(x)
    x.reshape(-1)
    np.ravel(x, order='F')
    np.ravel(x.T)
    np.ravel(x.T, order='A')
    a = np.arange(3)[::-1]; a
    # a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
    x = np.eye(3)
    np.nonzero(x)
    x[np.nonzero(x)]
    np.transpose(np.nonzero(x))
    a = np.array([[1,2,3],[4,5,6],[7,8,9]])
    a > 3
    np.nonzero(a > 3)
    np.shape(np.eye(3))
    np.shape([[1, 2]])
    np.shape([0])
    np.shape(0)
    a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
    np.shape(a)
    a.shape
    a = np.array([[1, 2], [3, 4], [5, 6]])
    np.compress([0, 1], a, axis=0)
    np.compress([False, True, True], a, axis=0)
    np.compress([False, True], a, axis=1)
    np.compress([False, True], a)
    a = np.arange(10)
    np.clip(a, 1, 8)
    np.clip(a, 3, 6, out=a)
    a = np.arange(10)
    np.clip(a, [3,4,1,1,1,4,4,4,4,4], 8)
    np.sum([])
    np.sum([0.5, 1.5])
    np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
    np.sum([[0, 1], [0, 5]])
    np.sum([[0, 1], [0, 5]], axis=0)
    np.sum([[0, 1], [0, 5]], axis=1)
    # np.ones(128, dtype=np.int8).sum(dtype=np.int8)
    # np.any([[True, False], [True, True]])
    # np.any([[True, False], [False, False]], axis=0)
    # np.any([-1, 0, 5])
    # np.any(np.nan)
    # np.all([[True,False],[True,True]])
    # np.all([[True,False],[True,True]], axis=0)
    # np.all([-1, 4, 5])
    # np.all([1.0, np.nan])
    a = np.array([[1,2,3], [4,5,6]])
    np.cumsum(a)
    np.cumsum(a, dtype=float)     # specifies type of output value(s)
    np.cumsum(a,axis=0)      # sum over rows for each of the 3 columns
    np.cumsum(a,axis=1)      # sum over columns for each of the 2 rows
    x = np.arange(4).reshape((2,2))
    np.ptp(x, axis=0)
    np.ptp(x, axis=1)
    a = np.arange(4).reshape((2,2))
    np.amax(a)           # Maximum of the flattened array
    np.amax(a, axis=0)   # Maxima along the first axis
    np.amax(a, axis=1)   # Maxima along the second axis
    b = np.arange(5, dtype=np.float)
    # b[2] = np.NaN
    np.amax(b)
    np.nanmax(b)
    a = np.arange(4).reshape((2,2))
    np.amin(a)           # Minimum of the flattened array
    np.amin(a, axis=0)   # Minima along the first axis
    np.amin(a, axis=1)   # Minima along the second axis
    b = np.arange(5, dtype=np.float)
    # b[2] = np.NaN
    np.amin(b)
    np.nanmin(b)
    a = np.zeros((7,4,5))
    a.shape[0]
    np.alen(a)
    x = np.array([536870910, 536870910, 536870910, 536870910])
    np.prod(x) #random
    np.prod([])
    np.prod([1.,2.])
    np.prod([[1.,2.],[3.,4.]])
    np.prod([[1.,2.],[3.,4.]], axis=1)
    x = np.array([1, 2, 3], dtype=np.uint8)
    # np.prod(x).dtype == np.uint
    x = np.array([1, 2, 3], dtype=np.int8)
    # np.prod(x).dtype == np.int
    a = np.array([1,2,3])
    np.cumprod(a) # intermediate results 1, 1*2
    a = np.array([[1, 2, 3], [4, 5, 6]])
    np.cumprod(a, dtype=float) # specify type of output
    np.cumprod(a, axis=0)
    np.cumprod(a,axis=1)
    np.ndim([[1,2,3],[4,5,6]])
    np.ndim(np.array([[1,2,3],[4,5,6]]))
    np.ndim(1)
    a = np.array([[1,2,3],[4,5,6]])
    np.size(a)
    np.size(a,1)
    np.size(a,0)
    np.around([0.37, 1.64])
    np.around([0.37, 1.64], decimals=1)
    np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
    np.around([1,2,3,11], decimals=1) # ndarray of ints is returned
    np.around([1,2,3,11], decimals=-1)
    a = np.array([[1, 2], [3, 4]])
    np.mean(a)
    np.mean(a, axis=0)
    np.mean(a, axis=1)
    a = np.zeros((2, 512*512), dtype=np.float32)
    a[0, :] = 1.0
    a[1, :] = 0.1
    np.mean(a)
    np.mean(a, dtype=np.float64)
    a = np.array([[1, 2], [3, 4]])
    np.std(a)
    np.std(a, axis=0)
    np.std(a, axis=1)
    a = np.zeros((2, 512*512), dtype=np.float32)
    a[0, :] = 1.0
    a[1, :] = 0.1
    np.std(a)
    np.std(a, dtype=np.float64)
    a = np.array([[1, 2], [3, 4]])
    np.var(a)
    np.var(a, axis=0)
    np.var(a, axis=1)
    a = np.zeros((2, 512*512), dtype=np.float32)
    a[0, :] = 1.0
    a[1, :] = 0.1
    np.var(a)
    np.var(a, dtype=np.float64)
コード例 #8
0
 def qz_mjk_k(self, mj, k):
     m = np.tile(np.transpose(self._theta_m_k[:, k]), self._vocab_n)
     j = np.repeat(self._psi_k_j[k, :], self._n_docs)
     tmj = np.multiply(m, j).reshape(self._vocab_n, self._n_docs)
     tmj = np.transpose(tmj)
     return tmj / mj
コード例 #9
0
moleculeNum = 100

pA = np.float(sys.argv[11])
pB = np.float(sys.argv[12])

AmoleculeNum = int(moleculeNum * pA)
BmoleculeNum = int(moleculeNum * pB)
CmoleculeNum = moleculeNum - AmoleculeNum - BmoleculeNum

Adiffcoef = 2e-5 * 1125 / np.int(
    sys.argv[7])  #component A diffusion coefficient (um^2/us), ~10ms
Bdiffcoef = 2e-5 * 1125 / np.int(
    sys.argv[7])  #compent B diffusion coefficient (um^2/us)
Cdiffcoef = 2e-5 * 1125 / np.int(
    sys.argv[7])  #compent B diffusion coefficient (um^2/us)
diffCoef = np.repeat([Adiffcoef, Bdiffcoef, Cdiffcoef],
                     [AmoleculeNum, BmoleculeNum, CmoleculeNum])

#fluor quantum yield
Qfluor = 1
QA = np.float(sys.argv[8])
QB = np.float(sys.argv[9])
QC = np.float(sys.argv[10])
QacceptorA = 0
QdonorB = 0
QacceptorB = 0

#reaction detail
#Input: k01 k10 k12 k21 k20 k02
k_Matrix = np.zeros((3, 3))
k_Matrix[0][1] = np.int(sys.argv[1]) / 1e6  #us-1
k_Matrix[1][0] = np.int(sys.argv[2]) / 1e6  #us-1