def __init__(self, samples: np.ndarray, centers: np.ndarray, labels: np.ndarray, calculate_params: typing.Dict[str, typing.Any]): tus.check(samples=(samples, np.ndarray), centers=(centers, np.ndarray), labels=(labels, np.ndarray), calculate_params=(calculate_params, dict)) tus.check_ndarrays( samples=(samples, ('n_samples', 'n_features'), (np.dtype('float32'), np.dtype('float64'))), centers=(centers, ('n_clusters', ('n_features', samples.shape[1] if len(samples.shape) > 1 else None)), samples.dtype), labels=(labels, (('n_samples', samples.shape[0] if bool(samples.shape) else None), ), (np.dtype('int32'), np.dtype('int64')))) self.samples = samples self.centers = centers self.labels = labels self.calculate_params = calculate_params self._bounds = None
def __init__(self, projection_vectors: np.ndarray, projected_samples: np.ndarray, projected_sample_labels: np.ndarray): tus.check_ndarrays( projection_vectors=( projection_vectors, ('og_size', 'proj_size'), ('float32', 'float64') ), projected_samples=( projected_samples, ('samples', ('proj_size', projection_vectors.shape[1])), projection_vectors.dtype ) ) tus.check(projected_sample_labels=( projected_sample_labels, np.ndarray)) if projected_sample_labels.shape[0] != projected_samples.shape[0]: raise ValueError( 'projected_sample_labels should have shape (samples, ...)' + f'where samples={projected_samples.shape[0]}' + '=projected_samples.shape[0], but has shape ' + str(projected_sample_labels.shape)) self.projection_vectors = projection_vectors self.projected_samples = projected_samples self.projected_sample_labels = projected_sample_labels
def __init__(self, frequency: float, indeps: np.ndarray): tus.check(frequency=(frequency, (int, float))) tus.check_ndarrays( indeps=(indeps, ('n_samples',), ('float32', 'float64')) ) self.frequency = frequency self.indeps = indeps
def __init__(self, snapshot_ind: int, mask: np.ndarray, alpha_start: float, alpha_end: float): tus.check_ndarrays(mask=(mask, ('samples', ), 'bool')) self.snapshot_ind = snapshot_ind self.mask = mask self.alpha_start = alpha_start self.alpha_end = alpha_end
def __init__(self, trajectory: ProjectedTrajectory, default_styling: typing.Tuple[typing.Tuple[np.ndarray, dict]], title: str = 'Projected Trajectory', zoom: np.ndarray = None, rotation: typing.Tuple[float, float] = (30, 45), visible_points: typing.Tuple[typing.Tuple[np.ndarray, np.ndarray, dict]] = None): if visible_points is None: visible_points = ((trajectory.snapshots[0].projected_samples, np.ones(trajectory.num_samples, dtype='bool'), dict()), ) if zoom is None: zoom = get_square_bounds_for_all(pts for (pts, mask, d) in visible_points) tus.check(trajectory=(trajectory, ProjectedTrajectory), default_styling=(default_styling, (list, tuple)), title=(title, str), rotation=(rotation, (list, tuple)), visible_points=(visible_points, (list, tuple))) tus.check_ndarrays(zoom=(zoom, (3, 2), ('float32', 'float64'))) tus.check_listlike(rotation=(rotation, (int, float), 2)) self.trajectory = trajectory self.default_styling = default_styling self.title = title self.zoom = zoom self.rotation = rotation self.visible_points = visible_points
def match(a: np.ndarray, b: np.ndarray) -> np.ndarray: """Finds the matrix R that minimizes the frobenius norm of RA - B, where R is orthonormal. Args: a (np.ndarray[samples, features]): the first matrix to match b (np.ndarray[samples, features]): the second matrix to match Returns: np.ndarray: the orthonormal matching matrix R """ tus.check_ndarrays(a=(a, ('samples', 'features'), ('float32', 'float64')), b=(b, (('samples', a.shape[0]), ('features', a.shape[1])), a.dtype)) m = b @ a.T u, _, vh = scipy.linalg.svd(m) return np.real(u @ vh)
def submask(pts: np.ndarray, mask: np.ndarray, mask2: np.ndarray): """Given that there exists some array arr where pts = arr[mask], this finds arr[mask2] where mask2 is some subset of mask. Args: pts (np.ndarray): arr[mask] mask (np.ndarray): some bool mask of the unknown array arr mask2 (np.ndarray): a subset of mask, i.e. a bool array that is false everywhere that mask is false but potentially false where mask is true Returns: arr[mask2] """ tus.check_ndarrays( mask=(mask, ('samples',), 'bool'), mask2=(mask2, (('samples', mask.shape[0]),), 'bool')) shape = [mask.shape[0]] shape.extend(pts.shape[1:]) arr = np.zeros(shape, dtype=pts.dtype) arr[mask] = pts return arr[mask2]
def project_with_matrix(samples: np.ndarray, labels: np.ndarray, mat: np.ndarray) -> ProjectedSnapshot: """Projects the given samples using the given projection matrix. Arguments: samples (np.ndarray[samples, features]): the samples to project labels (np.ndarray[samples, ...]): the labels for each sample mat (np.ndarray[features, proj_size]): Returns: snap (ProjectedSnapshot): the samples projected using the matrix """ tus.check_ndarrays( samples=(samples, ('samples', 'features'), ('float32', 'float64')), mat=( mat, (('features', samples.shape[1]), 'proj_size'), samples.dtype )) return ProjectedSnapshot(mat, samples @ mat, labels)
def test_checkndarrays_emptytensor_pass(self): tus.check_ndarrays(a=(np.ndarray(0), None, None))
def test_checkndarrays_exactnameddims_pass(self): tus.check_ndarrays(a=(_like((10, 4), 'float32'), (('dim1', 10), 4), None))
def test_checkndarrays_exactdims_pass(self): tus.check_ndarrays(a=(_like((10, 4), 'float32'), (10, 4), None))
def test_checkndarrays_namednumdims_fail(self): with self.assertRaises(ValueError): tus.check_ndarrays(a=(_like((10, 4, 2), 'float32'), ('dim1', 'dim2'), None))
def test_checkndarrays_namednumdims_pass(self): tus.check_ndarrays(a=(_like((10, 4), 'float32'), ('dim1', 'dim2'), None))
def test_checkndarrays_withnptype_fail(self): with self.assertRaises(ValueError): tus.check_ndarrays(a=(np.ndarray(0, dtype='float64'), None, np.float32))
def test_checkndarrays_withnptype_pass(self): tus.check_ndarrays(a=(np.ndarray(0, dtype='float64'), None, np.float64))
def generate(traj: pca3dvis.trajectory.ProjectedTrajectory, markers: typing.Tuple[typing.Tuple[np.ndarray, dict]], titles: typing.Tuple[str], outfolder: str, draft: bool = False, clusters: bool = True): """Generates a video and corresponding snapshots into the specified directory. If draft is true, this uses the draft settings. Otherwise, this uses high-quality production settings. For fine control over the settings it is recommended that you use the underlying pympanim functions. Args: traj (ProjectedTrajectory): the trajectory to plot markers (tuple[tuple[ndarray, dict]]): each titles (tuple[str]): one title per snapshot in the trajectory outfolder (str): where to save. must not already exist draft (bool): if true, lower quality settings are used clusters (bool): if clusters are detected and zoomed to """ tus.check(traj=(traj, pca3dvis.trajectory.ProjectedTrajectory), markers=(markers, (list, tuple)), titles=(titles, (list, tuple)), outfolder=(outfolder, str), draft=(draft, bool), clusters=(clusters, bool)) for i, marker in enumerate(markers): tus.check(**{f'marker[{i}]': (marker, (list, tuple))}) if len(marker) != 2: raise ValueError( f'expected marker[{i}] is (ndarray, dict), got {marker}') mask, kwargs = marker tus.check_ndarrays(**{ f'marker[{i}][0]': (mask, (('samples', traj.num_samples), ), 'bool') }) tus.check(**{f'marker[{i}][1]': (kwargs, dict)}) tus.check_listlike(titles=(titles, str, traj.num_snapshots)) os.makedirs(outfolder) os.makedirs(os.path.join(outfolder, 'snapshots')) state = pca3dvis.state.ProjectedState(traj, markers) rend = pca3dvis.renderer.ProjectedRenderer((19.2, 10.8) if not draft else (6.4, 4.8), 100) for i, title in enumerate(titles): filepath = os.path.join(outfolder, 'snapshots', f'snapshot_{i}') ext = '.png' if draft else '.pdf' transp = not draft state.set_snapshot_visible(i, True) state.title = title for rot in range(15, 375, 60 if draft else 30): state.rotation = (30, rot) fig = rend.render_mpl(state) fname = filepath + f'_rot{rot}' + ext fig.savefig(fname, transparent=transp, dpi=rend.dpi) plt.close(fig) pts = traj.snapshots[0].projected_samples zoom = pca3dvis.state.get_square_bounds_for(pts) my_scene = (acts.FluentScene(scenes.SnapshotScene(0)).join( scenes.FixedTitleScene(titles[0]), False).join(scenes.RotationScene((30, 45), (30, 45 + 360)), False).join(scenes.FixedZoomScene(zoom), False).dilate( pytweening.easeInOutSine).time_rescale_exact(12, 's')) if clusters: _cluster_scene(my_scene, traj, 0, titles[0], draft) for snap_ind in range(1, traj.num_snapshots): snap = traj.snapshots[snap_ind] npts = snap.projected_samples nzoom = pca3dvis.state.get_square_bounds_for(npts) mzoom = pca3dvis.state.get_square_bounds_for_all((pts, npts)) ntitle = titles[snap_ind] ititle = titles[snap_ind - 1] + ' -> ' + ntitle if not np.allclose(zoom, mzoom): (my_scene.push(scenes.ZoomScene(zoom, mzoom)).join( scenes.SnapshotScene(snap_ind - 1), False).join(scenes.FixedTitleScene(ititle), False).join( scenes.FixedRotationScene((30, 45)), False).dilate( pympanim.easing.smoothstep).time_rescale_exact( 2, 's').pop()) (my_scene.push(scenes.InterpScene( snap_ind - 1, snap_ind)).dilate(pytweening.easeInOutCirc).join( scenes.FixedZoomScene(mzoom), False).join(scenes.FixedTitleScene(ititle), False).push( scenes.RotationScene((30, 45), (30, 45 + 360))).dilate( pytweening.easeInOutSine).dilate( pympanim.easing.squeeze, { 'amt': 0.1 }).pop('join').time_rescale_exact(6, 's').pop()) if not np.allclose(mzoom, nzoom): (my_scene.push(scenes.ZoomScene(mzoom, nzoom)).join( scenes.SnapshotScene(snap_ind), False).join(scenes.FixedTitleScene(ititle), False).join( scenes.FixedRotationScene((30, 45)), False).dilate( pympanim.easing.smoothstep).time_rescale_exact( 2, 's').pop()) (my_scene.push(scenes.SnapshotScene(snap_ind)).join( scenes.FixedTitleScene(ntitle), False).join( scenes.RotationScene((30, 45), (30, 45 + 360)), False).join(scenes.FixedZoomScene(nzoom), False).dilate( pytweening.easeInOutSine).time_rescale_exact(10, 's').pop()) if clusters: _cluster_scene(my_scene, traj, snap_ind, ntitle, draft) pts = npts zoom = nzoom if draft: my_scene.time_rescale(5) pympanim.worker.produce( acts.Act(state, rend, [my_scene.build()]), 60 if not draft else 30, 100, -1, os.path.join(outfolder, 'video.mp4' if not draft else 'draft.mp4'))
def test_checkndarrays_exactnameddims_fail(self): with self.assertRaises(ValueError): tus.check_ndarrays(a=(_like((10, 4), 'float32'), (('dim1', 11), 4), None))
def __init__(self, snapshot_ind: int, mask: np.ndarray): tus.check_ndarrays(mask=(mask, ('samples', ), 'bool')) self.snapshot_ind = snapshot_ind self.mask = mask
def test_checkndarrays_noargs_pass(self): tus.check_ndarrays()