def _extract_zero_and_first_stats(X, sad, indices, gmm, z_path, f_path,
name_path):
n_samples = X.shape[0]
# indices is None, every row is single sample (utterance or image ...)
if indices is None:
if os.path.exists(z_path):
os.remove(z_path)
if os.path.exists(f_path):
os.remove(f_path)
Z = MmapArrayWriter(path=z_path,
dtype='float32',
shape=(n_samples, gmm.nmix),
remove_exist=True)
F = MmapArrayWriter(path=f_path,
dtype='float32',
shape=(n_samples, gmm.feat_dim * gmm.nmix),
remove_exist=True)
jobs, _ = _split_jobs(n_samples,
ncpu=mpi.cpu_count(),
device='cpu',
gpu_factor=1)
def map_transform(start_end):
start, end = start_end
for i in range(start, end):
# removed by SAD
if sad is not None and not bool(sad[i]):
yield None, None, None
else:
z, f = gmm.transform(X[i][np.newaxis, :],
zero=True,
first=True,
device='cpu')
yield i, z, f
prog = Progbar(target=n_samples,
print_report=True,
print_summary=False,
name="Extracting zero and first order statistics")
for i, z, f in mpi.MPI(jobs, map_transform, ncpu=None, batch=1):
if i is not None: # i None means removed by SAD
Z[i] = z
F[i] = f
prog.add(1)
Z.flush()
F.flush()
Z.close()
F.close()
# use directly the transform_to_disk function
else:
gmm.transform_to_disk(X,
indices=indices,
sad=sad,
pathZ=z_path,
pathF=f_path,
name_path=name_path,
dtype='float32',
device=None,
ncpu=None,
override=True)
def _extract_zero_and_first_stats(X, sad, indices, gmm, z_path, f_path, name_path):
n_samples = X.shape[0]
# indices is None, every row is single sample (utterance or image ...)
if indices is None:
if os.path.exists(z_path):
os.remove(z_path)
if os.path.exists(f_path):
os.remove(f_path)
Z = MmapData(path=z_path, dtype='float32',
shape=(n_samples, gmm.nmix), read_only=False)
F = MmapData(path=f_path, dtype='float32',
shape=(n_samples, gmm.feat_dim * gmm.nmix),
read_only=False)
jobs, _ = _split_jobs(n_samples, ncpu=mpi.cpu_count(),
device='cpu', gpu_factor=1)
def map_transform(start_end):
start, end = start_end
for i in range(start, end):
# removed by SAD
if sad is not None and not bool(sad[i]):
yield None, None, None
else:
z, f = gmm.transform(X[i][np.newaxis, :],
zero=True, first=True, device='cpu')
yield i, z, f
prog = Progbar(target=n_samples,
print_report=True, print_summary=False,
name="Extracting zero and first order statistics")
for i, z, f in mpi.MPI(jobs, map_transform,
ncpu=None, batch=1):
if i is not None: # i None means removed by SAD
Z[i] = z
F[i] = f
prog.add(1)
Z.flush(); Z.close()
F.flush(); F.close()
# use directly the transform_to_disk function
else:
gmm.transform_to_disk(X, indices=indices, sad=sad,
pathZ=z_path,
pathF=f_path,
name_path=name_path,
dtype='float32', device=None, ncpu=None,
override=True)
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore')
for path, name in SAMPLED_WAV_FILE:
feat = recipe.transform(path)
assert feat['bnf'].shape[0] == feat['mspec'].shape[0]
V.plot_multiple_features(feat, title=feat['name'])
V.plot_save(os.path.join(PATH_EXP, 'features_%s.pdf' % args.recipe))
exit()
# ===========================================================================
# Prepare the processor
# ===========================================================================
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore')
jobs = list(WAV_FILES.keys())
processor = pp.FeatureProcessor(
jobs=jobs,
path=os.path.join(PATH_ACOUSTIC_FEAT, args.recipe),
extractor=recipe,
n_cache=1200,
ncpu=min(18,
cpu_count() - 2),
override=True,
identifier='name',
log_path=os.path.join(PATH_EXP, 'processor_%s.log' % args.recipe),
stop_on_failure=False)
processor.run()
pp.validate_features(processor,
nb_samples=12,
path=os.path.join(PATH_EXP, args.recipe),
override=True)
# ====== debugging ====== #
if DEBUG:
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore')
for path, name in SAMPLED_WAV_FILE:
feat = recipe.transform(path)
assert feat['bnf'].shape[0] == feat['mspec'].shape[0]
V.plot_multiple_features(feat, title=feat['name'])
V.plot_save(os.path.join(PATH_EXP, 'features_%s.pdf' % args.recipe))
exit()
# ===========================================================================
# Prepare the processor
# ===========================================================================
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore')
jobs = list(WAV_FILES.keys())
processor = pp.FeatureProcessor(jobs=jobs,
path=os.path.join(PATH_ACOUSTIC_FEAT, args.recipe),
extractor=recipe,
n_cache=1200,
ncpu=min(18, cpu_count() - 2),
override=True,
identifier='name',
log_path=os.path.join(PATH_EXP, 'processor_%s.log' % args.recipe),
stop_on_failure=False)
processor.run()
pp.validate_features(processor,
nb_samples=12,
path=os.path.join(PATH_EXP, args.recipe),
override=True)
def fast_tsne(*X,
n_components=2,
n_samples=None,
perplexity=30.0,
early_exaggeration=8.0,
learning_rate=200.0,
n_iter=1000,
n_iter_without_progress=300,
min_grad_norm=1e-7,
metric="euclidean",
init="random",
verbose=0,
random_state=1234,
method='barnes_hut',
angle=0.5,
n_jobs=4):
"""
Parameters
----------
n_components : int, optional (default: 2)
Dimension of the embedded space.
n_samples : {int, None}
if given, downsampling the data to given number of sample
perplexity : float, optional (default: 30)
The perplexity is related to the number of nearest neighbors that
is used in other manifold learning algorithms. Larger datasets
usually require a larger perplexity. Consider selecting a value
between 5 and 50. The choice is not extremely critical since t-SNE
is quite insensitive to this parameter.
early_exaggeration : float, optional (default: 8.0)
Controls how tight natural clusters in the original space are in
the embedded space and how much space will be between them. For
larger values, the space between natural clusters will be larger
in the embedded space. Again, the choice of this parameter is not
very critical. If the cost function increases during initial
optimization, the early exaggeration factor or the learning rate
might be too high.
learning_rate : float, optional (default: 200.0)
The learning rate for t-SNE is usually in the range [10.0, 1000.0]. If
the learning rate is too high, the data may look like a 'ball' with any
point approximately equidistant from its nearest neighbours. If the
learning rate is too low, most points may look compressed in a dense
cloud with few outliers. If the cost function gets stuck in a bad local
minimum increasing the learning rate may help.
n_iter : int, optional (default: 1000)
Maximum number of iterations for the optimization. Should be at
least 250.
n_iter_without_progress : int, optional (default: 300)
Maximum number of iterations without progress before we abort the
optimization, used after 250 initial iterations with early
exaggeration. Note that progress is only checked every 50 iterations so
this value is rounded to the next multiple of 50.
min_grad_norm : float, optional (default: 1e-7)
If the gradient norm is below this threshold, the optimization will
be stopped.
metric : string or callable, optional
The metric to use when calculating distance between instances in a
feature array. If metric is a string, it must be one of the options
allowed by scipy.spatial.distance.pdist for its metric parameter, or
a metric listed in pairwise.PAIRWISE_DISTANCE_FUNCTIONS.
If metric is "precomputed", X is assumed to be a distance matrix.
Alternatively, if metric is a callable function, it is called on each
pair of instances (rows) and the resulting value recorded. The callable
should take two arrays from X as input and return a value indicating
the distance between them. The default is "euclidean" which is
interpreted as squared euclidean distance.
init : string or numpy array, optional (default: "random")
Initialization of embedding. Possible options are 'random', 'pca',
and a numpy array of shape (n_samples, n_components).
PCA initialization cannot be used with precomputed distances and is
usually more globally stable than random initialization.
verbose : int, optional (default: 0)
Verbosity level.
random_state : int, RandomState instance or None, optional (default: None)
If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random`. Note that different initializations might result in
different local minima of the cost function.
method : string (default: 'barnes_hut')
By default the gradient calculation algorithm uses Barnes-Hut
approximation running in O(NlogN) time. method='exact'
will run on the slower, but exact, algorithm in O(N^2) time. The
exact algorithm should be used when nearest-neighbor errors need
to be better than 3%. However, the exact method cannot scale to
millions of examples.
angle : float (default: 0.5)
Only used if method='barnes_hut'
This is the trade-off between speed and accuracy for Barnes-Hut T-SNE.
'angle' is the angular size (referred to as theta in [3]) of a distant
node as measured from a point. If this size is below 'angle' then it is
used as a summary node of all points contained within it.
This method is not very sensitive to changes in this parameter
in the range of 0.2 - 0.8. Angle less than 0.2 has quickly increasing
computation time and angle greater 0.8 has quickly increasing error.
"""
assert len(X) > 0, "No input is given!"
if isinstance(X[0], (tuple, list)):
X = X[0]
if not all(isinstance(x, np.ndarray) for x in X):
raise ValueError(
"`X` can only be list of numpy.ndarray or numpy.ndarray")
# ====== kwarg for creating T-SNE class ====== #
kwargs = dict(locals())
del kwargs['X']
n_samples = kwargs.pop('n_samples', None)
# ====== downsampling ====== #
if n_samples is not None:
n_samples = int(n_samples)
assert n_samples > 0
new_X = []
rand = random_state if isinstance(random_state, np.random.RandomState) else \
np.random.RandomState(seed=random_state)
for x in X:
if x.shape[0] > n_samples:
ids = rand.permutation(x.shape[0])[:n_samples]
x = x[ids]
new_X.append(x)
X = new_X
# ====== import proper T-SNE ====== #
tsne_version = None
try:
from tsnecuda import TSNE
from tsnecuda.NaiveTSNE import NaiveTSNE as _exact_TSNE
tsne_version = 'cuda'
except ImportError:
# wprint("Install CUDA-TSNE from `https://github.com/CannyLab/tsne-cuda` "
# "for significant speed up.")
try:
from MulticoreTSNE import MulticoreTSNE as TSNE
tsne_version = 'multicore'
except ImportError:
wprint(
"Install MulticoreTSNE from `pip install git+https://github.com/DmitryUlyanov/Multicore-TSNE.git`"
' to accelerate the T-SNE on multiple CPU cores.')
try:
from sklearn.manifold import TSNE
tsne_version = 'sklearn'
except Exception as e:
raise e
# ====== modify kwargs ====== #
if tsne_version == 'cuda':
kwargs['random_seed'] = kwargs['random_state']
kwargs['theta'] = angle
if method == 'exact':
TSNE = _exact_TSNE
del kwargs['theta']
del kwargs['random_state']
del kwargs['n_jobs']
del kwargs['angle']
del kwargs['method']
elif tsne_version == 'multicore':
pass
else:
del kwargs['n_jobs']
# ====== getting cached values ====== #
results = []
X_new = []
for i, x in enumerate(X):
md5 = md5_checksum(x)
key = _create_key(kwargs, md5)
if key in _cached_values:
results.append((i, _cached_values[key]))
else:
X_new.append((i, md5, x))
# ====== perform T-SNE ====== #
def apply_tsne(j):
idx, md5, x = j
tsne = TSNE(**kwargs)
return (idx, md5, tsne.fit_transform(x))
# only 1 X, no need for MPI
if len(X_new) == 1:
idx, md5, x = apply_tsne(X_new[0])
results.append((idx, x))
_cached_values[_create_key(kwargs, md5)] = x
else:
mpi = MPI(jobs=X_new,
func=apply_tsne,
batch=1,
ncpu=min(len(X_new),
cpu_count() - 1))
for idx, md5, x in mpi:
results.append((idx, x))
_cached_values[_create_key(kwargs, md5)] = x
# ====== return and clean ====== #
results = sorted(results, key=lambda a: a[0])
results = [r[1] for r in results]
return results[0] if len(results) == 1 else results
]
# ====== DNN ====== #
BATCH_SIZE = int(_args.batch)
EPOCH = int(_args.epoch)
LEARNING_RATE = float(_args.lr)
GRADIENT_CLIPPING = float(_args.clip)
# ====== searching for the appropriate system ====== #
SCORE_SYSTEM_NAME = _args.sys
SCORE_SYSTEM_ID = int(_args.sysid)
N_LDA = int(_args.lda)
N_PLDA = int(_args.plda)
assert N_PLDA > 0, "Number of PLDA components must > 0, but given: %d" % N_PLDA
PLDA_MAXIMUM_LIKELIHOOD = bool(_args.mll)
PLDA_SHOW_LLK = bool(_args.showllk)
# ====== system ====== #
NCPU = min(18, mpi.cpu_count() - 2) if _args.ncpu <= 0 else int(_args.ncpu)
# ====== helper for checking the requirement ====== #
def _check_feature_extraction_requirement():
# check requirement for feature extraction
from shutil import which
if which('sox') is None:
raise RuntimeError("`sox` was not installed")
if which('sph2pipe') is None:
raise RuntimeError("`sph2pipe` was not installed")
if which('ffmpeg') is None:
raise RuntimeError("`ffmpeg` was not installed")
def _check_recipe_name_for_extraction():
print(tmp)
exit()
else:
V.plot_multiple_features(tmp, title=name)
V.plot_save(os.path.join(PATH_EXP, 'feature_debug.pdf'))
exit()
# ===========================================================================
# Processor
# ===========================================================================
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore')
processor = pp.FeatureProcessor(jobs=all_files,
path=PATH_ACOUSTIC,
extractor=extractors,
n_cache=0.12,
ncpu =min(18, cpu_count() - 2) if args.ncpu <= 0 else int(args.ncpu),
override=True,
identifier='name',
log_path=os.path.join(PATH_EXP, 'processor.log'),
stop_on_failure=True # small dataset, enable stop on failure
)
with UnitTimer():
processor.run()
n_error = len(processor.error_log)
print(processor)
# ====== copy readme and check the preprocessed dataset ====== #
if n_error == 0:
readme_path = os.path.join(audio.path, [i for i in os.listdir(audio.path)
if 'README' in i][0])
shutil.copy(readme_path,
os.path.join(PATH_ACOUSTIC, 'README.md'))
else:
V.plot_multiple_features(tmp, title=name)
V.plot_save(os.path.join(PATH_EXP, 'feature_debug.pdf'))
exit()
# ===========================================================================
# Processor
# ===========================================================================
with np.warnings.catch_warnings():
np.warnings.filterwarnings('ignore')
processor = pp.FeatureProcessor(
jobs=all_files,
path=PATH_ACOUSTIC,
extractor=extractors,
n_cache=0.12,
ncpu=min(18,
cpu_count() - 2) if args.ncpu <= 0 else int(args.ncpu),
override=True,
identifier='name',
log_path=os.path.join(PATH_EXP, 'processor.log'),
stop_on_failure=True # small dataset, enable stop on failure
)
with UnitTimer():
processor.run()
n_error = len(processor.error_log)
print(processor)
# ====== copy readme and check the preprocessed dataset ====== #
if n_error == 0:
readme_path = os.path.join(
audio.path, [i for i in os.listdir(audio.path) if 'README' in i][0])
shutil.copy(readme_path, os.path.join(PATH_ACOUSTIC, 'README.md'))
def fast_tsne(*X, n_components=2, n_samples=None, perplexity=30.0,
early_exaggeration=8.0, learning_rate=200.0, n_iter=1000,
n_iter_without_progress=300, min_grad_norm=1e-7,
metric="euclidean", init="random", verbose=0,
random_state=5218, method='barnes_hut', angle=0.5,
n_jobs=4):
"""
Parameters
----------
n_components : int, optional (default: 2)
Dimension of the embedded space.
n_samples : {int, None}
if given, downsampling the data to given number of sample
perplexity : float, optional (default: 30)
The perplexity is related to the number of nearest neighbors that
is used in other manifold learning algorithms. Larger datasets
usually require a larger perplexity. Consider selecting a value
between 5 and 50. The choice is not extremely critical since t-SNE
is quite insensitive to this parameter.
early_exaggeration : float, optional (default: 8.0)
Controls how tight natural clusters in the original space are in
the embedded space and how much space will be between them. For
larger values, the space between natural clusters will be larger
in the embedded space. Again, the choice of this parameter is not
very critical. If the cost function increases during initial
optimization, the early exaggeration factor or the learning rate
might be too high.
learning_rate : float, optional (default: 200.0)
The learning rate for t-SNE is usually in the range [10.0, 1000.0]. If
the learning rate is too high, the data may look like a 'ball' with any
point approximately equidistant from its nearest neighbours. If the
learning rate is too low, most points may look compressed in a dense
cloud with few outliers. If the cost function gets stuck in a bad local
minimum increasing the learning rate may help.
n_iter : int, optional (default: 1000)
Maximum number of iterations for the optimization. Should be at
least 250.
n_iter_without_progress : int, optional (default: 300)
Maximum number of iterations without progress before we abort the
optimization, used after 250 initial iterations with early
exaggeration. Note that progress is only checked every 50 iterations so
this value is rounded to the next multiple of 50.
min_grad_norm : float, optional (default: 1e-7)
If the gradient norm is below this threshold, the optimization will
be stopped.
metric : string or callable, optional
The metric to use when calculating distance between instances in a
feature array. If metric is a string, it must be one of the options
allowed by scipy.spatial.distance.pdist for its metric parameter, or
a metric listed in pairwise.PAIRWISE_DISTANCE_FUNCTIONS.
If metric is "precomputed", X is assumed to be a distance matrix.
Alternatively, if metric is a callable function, it is called on each
pair of instances (rows) and the resulting value recorded. The callable
should take two arrays from X as input and return a value indicating
the distance between them. The default is "euclidean" which is
interpreted as squared euclidean distance.
init : string or numpy array, optional (default: "random")
Initialization of embedding. Possible options are 'random', 'pca',
and a numpy array of shape (n_samples, n_components).
PCA initialization cannot be used with precomputed distances and is
usually more globally stable than random initialization.
verbose : int, optional (default: 0)
Verbosity level.
random_state : int, RandomState instance or None, optional (default: None)
If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random`. Note that different initializations might result in
different local minima of the cost function.
method : string (default: 'barnes_hut')
By default the gradient calculation algorithm uses Barnes-Hut
approximation running in O(NlogN) time. method='exact'
will run on the slower, but exact, algorithm in O(N^2) time. The
exact algorithm should be used when nearest-neighbor errors need
to be better than 3%. However, the exact method cannot scale to
millions of examples.
angle : float (default: 0.5)
Only used if method='barnes_hut'
This is the trade-off between speed and accuracy for Barnes-Hut T-SNE.
'angle' is the angular size (referred to as theta in [3]) of a distant
node as measured from a point. If this size is below 'angle' then it is
used as a summary node of all points contained within it.
This method is not very sensitive to changes in this parameter
in the range of 0.2 - 0.8. Angle less than 0.2 has quickly increasing
computation time and angle greater 0.8 has quickly increasing error.
"""
assert len(X) > 0, "No input is given!"
if isinstance(X[0], (tuple, list)):
X = X[0]
if not all(isinstance(x, np.ndarray) for x in X):
raise ValueError("`X` can only be list of numpy.ndarray or numpy.ndarray")
# ====== kwarg for creating T-SNE class ====== #
kwargs = dict(locals())
del kwargs['X']
n_samples = kwargs.pop('n_samples', None)
# ====== downsampling ====== #
if n_samples is not None:
n_samples = int(n_samples)
assert n_samples > 0
new_X = []
rand = random_state if isinstance(random_state, np.random.RandomState) else \
np.random.RandomState(seed=random_state)
for x in X:
if x.shape[0] > n_samples:
ids = rand.permutation(x.shape[0])[:n_samples]
x = x[ids]
new_X.append(x)
X = new_X
# ====== import proper T-SNE ====== #
tsne_version = None
try:
from tsnecuda import TSNE
from tsnecuda.NaiveTSNE import NaiveTSNE as _exact_TSNE
tsne_version = 'cuda'
except ImportError:
# wprint("Install CUDA-TSNE from `https://github.com/CannyLab/tsne-cuda` "
# "for significant speed up.")
try:
from MulticoreTSNE import MulticoreTSNE as TSNE
tsne_version = 'multicore'
except ImportError:
wprint("Install MulticoreTSNE from `pip install git+https://github.com/DmitryUlyanov/Multicore-TSNE.git`"
' to accelerate the T-SNE on multiple CPU cores.')
try:
from sklearn.manifold import TSNE
tsne_version = 'sklearn'
except Exception as e:
raise e
# ====== modify kwargs ====== #
if tsne_version == 'cuda':
kwargs['random_seed'] = kwargs['random_state']
kwargs['theta'] = angle
if method == 'exact':
TSNE = _exact_TSNE
del kwargs['theta']
del kwargs['random_state']
del kwargs['n_jobs']
del kwargs['angle']
del kwargs['method']
elif tsne_version == 'multicore':
pass
else:
del kwargs['n_jobs']
# ====== getting cached values ====== #
results = []
X_new = []
for i, x in enumerate(X):
md5 = md5_checksum(x)
key = _create_key(kwargs, md5)
if key in _cached_values:
results.append((i, _cached_values[key]))
else:
X_new.append((i, md5, x))
# ====== perform T-SNE ====== #
def apply_tsne(j):
idx, md5, x = j
tsne = TSNE(**kwargs)
return (idx, md5, tsne.fit_transform(x))
# only 1 X, no need for MPI
if len(X_new) == 1:
idx, md5, x = apply_tsne(X_new[0])
results.append((idx, x))
_cached_values[_create_key(kwargs, md5)] = x
else:
mpi = MPI(jobs=X_new, func=apply_tsne, batch=1,
ncpu=min(len(X_new), cpu_count() - 1))
for idx, md5, x in mpi:
results.append((idx, x))
_cached_values[_create_key(kwargs, md5)] = x
# ====== return and clean ====== #
results = sorted(results, key=lambda a: a[0])
results = [r[1] for r in results]
return results[0] if len(results) == 1 else results
'sre04', 'sre05', 'sre06', 'sre08', 'sre10']
# ====== DNN ====== #
BATCH_SIZE = int(_args.batch)
EPOCH = int(_args.epoch)
LEARNING_RATE = float(_args.lr)
GRADIENT_CLIPPING = float(_args.clip)
# ====== searching for the appropriate system ====== #
SCORE_SYSTEM_NAME = _args.sys
SCORE_SYSTEM_ID = int(_args.sysid)
N_LDA = int(_args.lda)
N_PLDA = int(_args.plda)
assert N_PLDA > 0, "Number of PLDA components must > 0, but given: %d" % N_PLDA
PLDA_MAXIMUM_LIKELIHOOD = bool(_args.mll)
PLDA_SHOW_LLK = bool(_args.showllk)
# ====== system ====== #
NCPU = min(18, mpi.cpu_count() - 2) if _args.ncpu <= 0 else int(_args.ncpu)
# ====== helper for checking the requirement ====== #
def _check_feature_extraction_requirement():
# check requirement for feature extraction
from shutil import which
if which('sox') is None:
raise RuntimeError("`sox` was not installed")
if which('sph2pipe') is None:
raise RuntimeError("`sph2pipe` was not installed")
if which('ffmpeg') is None:
raise RuntimeError("`ffmpeg` was not installed")
def _check_recipe_name_for_extraction():
# check the requirement of recipe name for feature extraction
if '_' in FEATURE_RECIPE:
raise ValueError("'_' can appear in recipe name which is: '%s'" % FEATURE_RECIPE)
def fast_tsne(
*X,
n_components: int = 2,
max_samples: Optional[int] = None,
perplexity: float = 30.0,
early_exaggeration: float = 12.0,
learning_rate: float = 200.0,
n_iter: int = 1000,
n_iter_without_progress: int = 300,
exaggeration_iter: int = 250,
perplexity_max_iter: int = 100,
min_grad_norm: float = 1e-7,
method: str = 'barnes_hut',
metric: str = "euclidean",
init: str = "random",
angle: float = 0.5,
n_jobs: Optional[int] = 4,
merge_inputs: bool = True,
pca_preprocessing: bool = True,
return_model: bool = False,
random_state: int = 1,
verbose: int = 0,
framework: Literal['auto', 'sklearn', 'cuml'] = 'auto',
):
""" t-Stochastic Nearest Neighbors.
If the algorithm take unexpected long time for running, lower the
`exaggeration_iter`, or reduce the amount of samples by downsampling
the dataset.
Parameters
----------
n_components : int, optional (default: 2)
Dimension of the embedded space.
max_samples : {int, None}
if given, downsampling the data to given number of sample
perplexity : float, optional (default: 30)
The perplexity is related to the number of nearest neighbors that
is used in other manifold learning algorithms. Larger datasets
usually require a larger perplexity. Consider selecting a value
between 5 and 50. The choice is not extremely critical since t-SNE
is quite insensitive to this parameter.
early_exaggeration : float, optional (default: 8.0)
Controls how tight natural clusters in the original space are in
the embedded space and how much space will be between them. For
larger values, the space between natural clusters will be larger
in the embedded space. Again, the choice of this parameter is not
very critical. If the cost function increases during initial
optimization, the early exaggeration factor or the learning rate
might be too high.
learning_rate : float, optional (default: 200.0)
The learning rate for t-SNE is usually in the range [10.0, 1000.0]. If
the learning rate is too high, the data may look like a 'ball' with any
point approximately equidistant from its nearest neighbours. If the
learning rate is too low, most points may look compressed in a dense
cloud with few outliers. If the cost function gets stuck in a bad local
minimum increasing the learning rate may help.
n_iter : int, optional (default: 1000)
Maximum number of iterations for the optimization. Should be at
least 250.
n_iter_without_progress : int, optional (default: 300)
Maximum number of iterations without progress before we abort the
optimization, used after 250 initial iterations with early
exaggeration. Note that progress is only checked every 50 iterations so
this value is rounded to the next multiple of 50.
perplexity_max_iter : int, (default 100)
The number of epochs the best gaussian bands are found for.
exaggeration_iter : int, (default 250)
To promote the growth of clusters, set this higher.
min_grad_norm : float, optional (default: 1e-7)
If the gradient norm is below this threshold, the optimization will
be stopped.
metric : string or callable, optional
The metric to use when calculating distance between instances in a
feature array. If metric is a string, it must be one of the options
allowed by scipy.spatial.distance.pdist for its metric parameter, or
a metric listed in pairwise.PAIRWISE_DISTANCE_FUNCTIONS.
If metric is "precomputed", X is assumed to be a distance matrix.
Alternatively, if metric is a callable function, it is called on each
pair of instances (rows) and the resulting value recorded. The callable
should take two arrays from X as input and return a value indicating
the distance between them. The default is "euclidean" which is
interpreted as squared euclidean distance.
init : string or numpy array, optional (default: "random")
Initialization of embedding. Possible options are 'random', 'pca',
and a numpy array of shape (n_samples, n_components).
PCA initialization cannot be used with precomputed distances and is
usually more globally stable than random initialization.
verbose : int, optional (default: 0)
Verbosity level, a number from 0 to 6.
random_state : int, RandomState instance or None, optional (default: None)
If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random`. Note that different initializations might result in
different local minima of the cost function.
method : string (default: 'barnes_hut')
By default the gradient calculation algorithm uses Barnes-Hut
approximation running in O(NlogN) time. method='exact'
will run on the slower, but exact, algorithm in O(N^2) time. The
exact algorithm should be used when nearest-neighbor errors need
to be better than 3%. However, the exact method cannot scale to
millions of examples.
angle : float (default: 0.5)
Only used if method='barnes_hut'
This is the trade-off between speed and accuracy for Barnes-Hut T-SNE.
'angle' is the angular size (referred to as theta in [3]) of a distant
node as measured from a point. If this size is below 'angle' then it is
used as a summary node of all points contained within it.
This method is not very sensitive to changes in this parameter
in the range of 0.2 - 0.8. Angle less than 0.2 has quickly increasing
computation time and angle greater 0.8 has quickly increasing error.
return_model : a Boolean, if `True`,
return the trained t-SNE model
merge_inputs : a Boolean, if `True`,
merge all arrays into a single array
for training t-SNE.
"""
assert len(X) > 0, "No input is given!"
if isinstance(X[0], (tuple, list)):
X = X[0]
if not all(isinstance(x, np.ndarray) for x in X):
raise ValueError(
"`X` can only be list of numpy.ndarray or numpy.ndarray")
# ====== kwarg for creating T-SNE class ====== #
kwargs = dict(locals())
del kwargs['X']
kwargs.pop('merge_inputs')
kwargs.pop('return_model')
kwargs.pop('max_samples')
kwargs.pop('framework')
kwargs.pop('pca_preprocessing')
# ====== downsampling ====== #
if max_samples is not None:
max_samples = int(max_samples)
assert max_samples > 0
new_X = []
rand = random_state if isinstance(random_state, np.random.RandomState) else \
np.random.RandomState(seed=random_state)
for x in X:
if x.shape[0] > max_samples:
ids = rand.permutation(x.shape[0])[:max_samples]
x = x[ids]
new_X.append(x)
X = new_X
# ====== import proper T-SNE ====== #
tsne_version = None
if framework != 'sklearn':
try:
from cuml.manifold import TSNE
tsne_version = 'cuda'
except ImportError:
warnings.warn("Install RAPIDSAI cuML GPUs-accelerated t-SNE")
try:
from MulticoreTSNE import MulticoreTSNE as TSNE
tsne_version = 'multicore'
except ImportError:
warnings.warn(
"pip install "
"git+https://github.com/DmitryUlyanov/Multicore-TSNE.git")
if tsne_version is None:
from sklearn.manifold import TSNE
tsne_version = 'sklearn'
# ====== modify kwargs ====== #
if tsne_version == 'cuda':
del kwargs['n_jobs']
elif tsne_version == 'multicore':
del kwargs['perplexity_max_iter']
del kwargs['exaggeration_iter']
else:
del kwargs['n_jobs']
del kwargs['perplexity_max_iter']
del kwargs['exaggeration_iter']
# ====== getting cached values ====== #
results = []
X_new = []
X_size = []
if merge_inputs:
X_size = [x.shape[0] for x in X]
x = np.vstack(X) if len(X) > 1 else X[0]
md5 = md5_checksum(x)
key = _create_key(tsne_version, kwargs, md5)
if key in _cached_values:
results.append((0, _cached_values[key]))
else:
X_new.append((0, md5, x))
else:
for i, x in enumerate(X):
md5 = md5_checksum(x)
key = _create_key(tsne_version, kwargs, md5)
if key in _cached_values:
results.append((i, _cached_values[key]))
else:
X_new.append((i, md5, x))
# ====== perform T-SNE ====== #
def apply_tsne(j):
idx, md5, x = j
if pca_preprocessing:
x = PCA(n_components=None,
random_state=random_state).fit_transform(x)
tsne = TSNE(**kwargs)
return (idx, md5, tsne.fit_transform(x),
tsne if return_model else None)
# only 1 X, no need for MPI
if len(X_new) == 1 or tsne_version in ('cuda', 'multicore'):
for x in X_new:
idx, md5, x, model = apply_tsne(x)
results.append((idx, x))
_cached_values[_create_key(tsne_version, kwargs, md5)] = x
else:
mpi = MPI(jobs=X_new,
func=apply_tsne,
batch=1,
ncpu=min(len(X_new),
cpu_count() - 1))
model = []
for idx, md5, x, m in mpi:
results.append((idx, x))
_cached_values[_create_key(tsne_version, kwargs, md5)] = x
model.append(m)
# ====== return and clean ====== #
if merge_inputs and len(X_size) > 1:
indices = [0] + np.cumsum(X_size).tolist()
results = [results[0][1][s:e] for s, e in zip(indices, indices[1:])]
else:
results = sorted(results, key=lambda a: a[0])
results = [r[1] for r in results]
results = results[0] if len(results) == 1 else results
if return_model:
return results, model
del model
return results