Python numpy 模块，vsplit() 实例源码

def rev(self, lng, lat, z=None, _type=np.int32):
        if z is None:
            z = self._default_z

        if all(isinstance(var, (int, float, tuple)) for var in [lng, lat]):
            lng, lat = (np.array([lng]), np.array([lat]))
        if not all(isinstance(var, np.ndarray) for var in [lng, lat]):
            raise ValueError("lng, lat inputs must be of type int, float, tuple or numpy.ndarray")
        if not isinstance(z, np.ndarray):
            z = np.zeros_like(lng) + z
        coord = np.dstack([lng, lat, z])
        offset, scale = np.vsplit(self._offscl, 2)
        normed = coord * scale + offset
        X = self._rpc(normed)
        result = np.rollaxis(np.inner(self._A, X) / np.inner(self._B, X), 0, 3)
        rev_offset, rev_scale = np.vsplit(self._px_offscl_rev, 2)
        # needs to return x/y
        return  np.rollaxis(result * rev_scale + rev_offset, 2).squeeze().astype(_type)[::-1]

def paint_latents( event ):
   global r, Z, output,painted_rects,MASK,USER_MASK,RECON 

   # Get extent of latent paintbrush
   x1, y1 = ( event.x - d.get() ), ( event.y - d.get() )
   x2, y2 = ( event.x + d.get() ), ( event.y + d.get() )

   selected_widget = event.widget

   # Paint in latent space and update Z
   painted_rects.append(event.widget.create_rectangle( x1, y1, x2, y2, fill = rb(color.get()),outline = rb(color.get()) ))
   r[max((y1-bd),0):min((y2-bd),r.shape[0]),max((x1-bd),0):min((x2-bd),r.shape[1])] = color.get()/255.0;
   Z = np.asarray([np.mean(o) for v in [np.hsplit(h,Z.shape[0])\
                                                         for h in np.vsplit((r),Z.shape[1])]\
                                                         for o in v]).reshape(Z.shape[0],Z.shape[1])
   if SAMPLE_FLAG:
        update_photo(None,output)
        update_canvas(w) # Remove this if you wish to see a more free-form paintbrush
   else:     
        DELTA = model.sample_at(np.float32([Z.flatten()]))[0]-to_tanh(np.float32(RECON))
        MASK=scipy.ndimage.filters.gaussian_filter(np.min([np.mean(np.abs(DELTA),axis=0),np.ones((64,64))],axis=0),0.7)
        # D = dampen(to_tanh(np.float32(RECON)),MASK*DELTA+(1-MASK)*ERROR)
        D = MASK*DELTA+(1-MASK)*ERROR
        IM = np.uint8(from_tanh(to_tanh(RECON)+D))
        update_canvas(w) # Remove this if you wish to see a more free-form paintbrush
        update_photo(IM,output)  

# Scroll to lighten or darken an image patch

def test_nested_model_void(self):
        from l1l2py import tools
        data, test_data = np.vsplit(self.X, 2)
        labels, test_labels = np.hsplit(self.Y, 2)

        tau_opt, lambda_opt = (50.0, 0.1)
        mu_range = np.linspace(0.1, 1.0, 10)

        assert_raises(
            ValueError, nested_models,
            data, labels, test_data, test_labels,
            mu_range, tau_opt, lambda_opt,
            error_function=tools.regression_error,
            data_normalizer=tools.standardize,
            labels_normalizer=tools.center)

def get_next_sample(self):
        if self.incomplete_samples_ is not None:
            assert self.incomplete_samples_.size > 0
            split = np.vsplit(self.incomplete_samples_, [1])
            assert len(split) == 2
            next_sample = split[0]
            if split[1].size == 0:
                self.incomplete_samples_ = None
            else:
                self.incomplete_samples_ = split[1]
            return next_sample.ravel()
        else:
            return None

def deleteRow(self, row_number, data):
        first, deleted, second = np.vsplit(data, [row_number, row_number + 1])

        return np.vstack((first, second))

def load_csv(self):
    file_name = "data/jra_race_resultNN.csv"
    df = pd.read_csv(file_name)
    ## ???????
    labelEncoder = preprocessing.LabelEncoder()
    df['area_name'] = labelEncoder.fit_transform(df['area_name'])
    df['race_name'] = labelEncoder.fit_transform(df['race_name'])
    df['track'] = labelEncoder.fit_transform(df['track'])
    df['run_direction'] = labelEncoder.fit_transform(df['run_direction'])
    df['track_condition'] = labelEncoder.fit_transform(df['track_condition'])
    df['horse_name'] = labelEncoder.fit_transform(df['horse_name'])
    df['horse_sex'] = labelEncoder.fit_transform(df['horse_sex'])
    df['jockey_name'] = labelEncoder.fit_transform(df['jockey_name'])
    df['margin'] = labelEncoder.fit_transform(df['margin'])
    df['is_blinkers'] = labelEncoder.fit_transform(df['is_blinkers'])
    df['trainer_name'] = labelEncoder.fit_transform(df['trainer_name'])
    df['comments_by_trainer'] = labelEncoder.fit_transform(df['comments_by_trainer'])
    df['evaluation_by_trainer'] = labelEncoder.fit_transform(df['evaluation_by_trainer'])
    df['dhorse_weight'] = labelEncoder.fit_transform(df['dhorse_weight'])
    x_np = np.array(df[['area_name', 'race_number', 'race_name', 'track', 'run_direction',
                       'distance', 'track_condition', 'purse', 'heads_count', 
                       'post_position', 'horse_number', 'horse_name', 'horse_sex', 'horse_age', 
                       'jockey_name', 'time', 'margin', 'time3F', 
                       'load_weight', 'horse_weight', 'dhorse_weight', 'odds_order', 
                       'odds', 'is_blinkers', 'trainer_name', 'comments_by_trainer', 
                        'evaluation_by_trainer'
    ]].fillna(0))
    # ??
    d = df[['finish_order']].to_dict('record')
    self.vectorizer = DictVectorizer(sparse=False)
    y_np = self.vectorizer.fit_transform(d)
    self.n_classes = len(self.vectorizer.get_feature_names())
    self.train_size =   int(len(df[['finish_order']]) / 5)
    self.batch_size = self.train_size

    # ????????????????????
    [self.x_train, self.x_test] = np.vsplit(x_np, [self.train_size]) 
    [self.y_train, self.y_test] = np.vsplit(y_np, [self.train_size])

  # Create model

def omega_output(self, fname, parameters):
        """This method writes the dispersion relation to the file fname.

        :param fname: Filename
        :type fname: string
        :param parameters: Array containing the parameters.
        :type parameters: numpy.ndarray
        """

        omega = self.omega(parameters)
        kappa = self.kappamesh
        kmesh = self.kmesh
        k = self.k
        #print(omega, self.dks)
        vgs = np.gradient(omega, *self.dks, edge_order=2)
        vg = np.sqrt(sum(vgc**2 for vgc in vgs))
        if self.dim==2:
            vg[:3,:3] = 1
        elif self.dim==3:
            vg[:3,:3,:3] = 1
        vph = omega/k
        vph.ravel()[0] = 1.
        data = [*np.broadcast_arrays(*kappa), k, omega, vph, vg, *vgs]

        data = np.broadcast_arrays(*data)
        blocks = zip(*map(lambda x: np.vsplit(x, x.shape[0]), data))
        with open(fname, 'wb') as f:
            kappanames = ' '.join(['kx', 'ky', 'kz'][:len(kappa)])
            vgsnames = ' '.join(['vgx', 'vgy', 'vgz'][:len(vgs)])
            f.write(('#' + kappanames + ' k omega vph vg ' + vgsnames + '\n').encode('us-ascii'))

            for block_columns in blocks:
                np.savetxt(f, np.vstack(map(np.ravel, block_columns)).T)
                f.write(b'\n')

def gen_task_mbs(self, style, test_fold_id):
        num_task_iterations = int(''.join([c for c in self.regime if c.isdigit()]))
        # make blocks
        if style == 'train':
            task_lines = list(chain(*[fold for n, fold in enumerate(self.task_folds)
                                      if n != test_fold_id]))
            windows_x, windows_y = self.make_windows(task_lines)
            block_x = np.tile(windows_x, [num_task_iterations, 1])
            block_y = np.tile(windows_y, [num_task_iterations, 1])
        elif style == 'test':
            task_lines = list(chain(*[fold for n, fold in enumerate(self.task_folds)
                                      if n == test_fold_id]))
            windows_x, windows_y = self.make_windows(task_lines)
            block_x = windows_x
            block_y = windows_y
        elif style == 'train1':
            task_lines = list(chain(*[fold for n, fold in enumerate(self.task_folds)
                                      if n != test_fold_id]))
            windows_x, windows_y = self.make_windows(task_lines)
            block_x = windows_x
            block_y = windows_y
        else:
            raise AttributeError('rnnlab: Invalid arg to "style"')
        # split to mbs
        if not gcd(self.mb_size, len(block_x)) == self.mb_size:
            raise Exception(
                'rnnlab: Number of task_lines must be divisible by mb_size')
        num_splits = len(block_x) // self.mb_size
        # generate
        for x, y in zip(np.vsplit(block_x, num_splits),
                        np.vsplit(block_y, num_splits)):
            yield x, y

def batch_gen(self,
                  num_iterations=None):
        if not num_iterations:
            num_iterations = self.num_iterations
        # batch
        for n, term_id_doc in enumerate(self.docs):
            windows_mat = self.make_windows_mat(term_id_doc)
            windows_mat_x, windows_mat_y = np.split(windows_mat, [self.bptt_steps], axis=1)
            for _ in range(num_iterations):
                for x, y in zip(np.vsplit(windows_mat_x, self.num_mbs_in_doc),
                                np.vsplit(windows_mat_y, self.num_mbs_in_doc)):
                    yield x, y

def _split_array(image):
    """Splits an image into 16x16 sized tiles.

    Returns a list of arrays.
    """

    tiles = []
    dims = image.shape
    split_image = np.vsplit(image, int(dims[0]/16))
    for tile in split_image:
        tiles.extend(np.hsplit(tile, int(dims[1]/16)))
    return tiles

#Currently for 16x16 tiles only

def _least_square_evoked(data, events, event_id, tmin, tmax, sfreq):
    """Least square estimation of evoked response from data.

    Parameters
    ----------
    data : ndarray, shape (n_channels, n_times)
        The data to estimates evoked
    events : ndarray, shape (n_events, 3)
        The events typically returned by the read_events function.
        If some events don't match the events of interest as specified
        by event_id, they will be ignored.
    event_id : dict
        The id of the events to consider
    tmin : float
        Start time before event.
    tmax : float
        End time after event.
    sfreq : float
        Sampling frequency.

    Returns
    -------
    evokeds_data : dict of ndarray
        A dict of evoked data for each event type in event_id.
    toeplitz : dict of ndarray
        A dict of toeplitz matrix for each event type in event_id.
    """
    nmin = int(tmin * sfreq)
    nmax = int(tmax * sfreq)

    window = nmax - nmin
    n_samples = data.shape[1]
    toeplitz_mat = dict()
    full_toep = list()
    for eid in event_id:
        # select events by type
        ix_ev = events[:, -1] == event_id[eid]

        # build toeplitz matrix
        trig = np.zeros((n_samples, 1))
        ix_trig = (events[ix_ev, 0]) + nmin
        trig[ix_trig] = 1
        toep_mat = linalg.toeplitz(trig[0:window], trig)
        toeplitz_mat[eid] = toep_mat
        full_toep.append(toep_mat)

    # Concatenate toeplitz
    full_toep = np.concatenate(full_toep)

    # least square estimation
    predictor = np.dot(linalg.pinv(np.dot(full_toep, full_toep.T)), full_toep)
    all_evokeds = np.dot(predictor, data.T)
    all_evokeds = np.vsplit(all_evokeds, len(event_id))

    # parse evoked response
    evoked_data = dict()
    for idx, eid in enumerate(event_id):
        evoked_data[eid] = all_evokeds[idx].T

    return evoked_data, toeplitz_mat