# Spectral Clustering
[](https://github.com/wq2012/SpectralCluster/actions) [](https://pypi.python.org/pypi/spectralcluster) [](https://pypi.org/project/spectralcluster) [](https://pepy.tech/project/spectralcluster) [](https://codecov.io/gh/wq2012/SpectralCluster) [](https://wq2012.github.io/SpectralCluster)
## Overview
This is a Python re-implementation of the spectral clustering and
constrained spectral clustering algorithms presented in these papers:
* [Speaker Diarization with LSTM](https://google.github.io/speaker-id/publications/LstmDiarization/)
* [Turn-to-Diarize: Online Speaker Diarization Constrained by Transformer Transducer Speaker Turn Detection](https://arxiv.org/abs/2109.11641)
* [Highly Efficient Real-Time Streaming and Fully On-Device Speaker Diarization with Multi-Stage Clustering](https://arxiv.org/abs/2210.13690)
## Notice
We recently added new functionalities to this library to include
algorithms in a [new paper](https://arxiv.org/abs/2109.11641). We updated the APIs as well.
If you depend on our old API, please use an **older version** of this library:
```
pip3 install spectralcluster==0.1.0
```
## Disclaimer
**This is not a Google product.**
**This is not the original C++ implementation used by the papers.**
Please consider this repo as a "demonstration" of the algorithms,
instead of a "reproduction" of what we use at Google. Some features
might be missing or incomplete.
## Installation
Install the [package](https://pypi.org/project/spectralcluster/) by:
```bash
pip3 install spectralcluster
```
or
```bash
python3 -m pip install spectralcluster
```
## Tutorial
Simply use the `predict()` method of class `SpectralClusterer` to perform
spectral clustering. The example below should be closest to the original C++
implemention used by our
[ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/).
```python
from spectralcluster import configs
labels = configs.icassp2018_clusterer.predict(X)
```
The input `X` is a numpy array of shape `(n_samples, n_features)`,
and the returned `labels` is a numpy array of shape `(n_samples,)`.
You can also create your own clusterer like this:
```
from spectralcluster import SpectralClusterer
clusterer = SpectralClusterer(
min_clusters=2,
max_clusters=7,
autotune=None,
laplacian_type=None,
refinement_options=None,
custom_dist="cosine")
labels = clusterer.predict(X)
```
For the complete list of parameters of `SpectralClusterer`, see
`spectralcluster/spectral_clusterer.py`.
[](https://youtu.be/pjxGPZQeeO4)
[](https://youtu.be/U79Aw1ky7ag)
## Advanced features
### Refinement operations
In our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/), we apply a sequence of refinment operations on the affinity matrix, which is critical to the performance on the speaker diarization results.
You can specify your refinement operations like this:
```
from spectralcluster import RefinementOptions
from spectralcluster import ThresholdType
from spectralcluster import ICASSP2018_REFINEMENT_SEQUENCE
refinement_options = RefinementOptions(
gaussian_blur_sigma=1,
p_percentile=0.95,
thresholding_soft_multiplier=0.01,
thresholding_type=ThresholdType.RowMax,
refinement_sequence=ICASSP2018_REFINEMENT_SEQUENCE)
```
Then you can pass the `refinement_options` as an argument when initializing your
`SpectralClusterer` object.
For the complete list of `RefinementOptions`, see
`spectralcluster/refinement.py`.
### Laplacian matrix
In our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/),
we apply a refinement operation `CropDiagonal` on the affinity matrix, which replaces each diagonal element of the affinity matrix by the max non-diagonal value of the row. After this operation, the matrix has similar properties to a standard Laplacian matrix, and it is also less sensitive (thus more robust) to the Gaussian blur operation than a standard Laplacian matrix.
In the new version of this library, we support different types of Laplacian matrix now, including:
* None Laplacian (affinity matrix): `W`
* Unnormalized Laplacian: `L = D - W`
* Graph cut Laplacian: `L' = D^{-1/2} * L * D^{-1/2}`
* Random walk Laplacian: `L' = D^{-1} * L`
You can specify the Laplacian matrix type with the `laplacian_type` argument of the `SpectralClusterer` class.
Note: Refinement operations are applied to the affinity matrix **before** computing the Laplacian matrix.
### Distance for K-Means
In our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/),
the K-Means is based on Cosine distance.
You can set `custom_dist="cosine"` when initializing your `SpectralClusterer` object.
You can also use other distances supported by [scipy.spatial.distance](https://docs.scipy.org/doc/scipy/reference/spatial.distance.html), such as `"euclidean"` or `"mahalanobis"`.
### Affinity matrix
In our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/),
the affinity between two embeddings is defined as `(cos(x,y)+1)/2`.
You can also use other affinity functions by setting `affinity_function` when initializing your `SpectralClusterer` object.
### Auto-tune
We also support auto-tuning the `p_percentile` parameter of the `RowWiseThreshold` refinement operation, which was original proposed in [this paper](https://arxiv.org/abs/2003.02405).
You can enable this by passing in an `AutoTune` object to the `autotune` argument when initializing your `SpectralClusterer` object.
Example:
```python
from spectralcluster import AutoTune, AutoTuneProxy
autotune = AutoTune(
p_percentile_min=0.60,
p_percentile_max=0.95,
init_search_step=0.01,
search_level=3,
proxy=AutoTuneProxy.PercentileSqrtOverNME)
```
For the complete list of parameters of `AutoTune`, see
`spectralcluster/autotune.py`.
### Fallback clusterer
Spectral clustering exploits the global structure of the data. But there are
cases where spectral clustering does not work as well as some other simpler
clustering methods, such as when the number of embeddings is too small.
When initializing the `SpectralClusterer` object, you can pass in a `FallbackOptions` object to the `fallback_options` argument, to use a fallback clusterer under certain conditions.
Also, spectral clustering and eigen-gap may not work well at making single-vs-multi cluster decisions. When `min_clusters=1`, we can also specify `FallbackOptions.single_cluster_condition` and `FallbackOptions.single_cluster_affinity_threshold` to help determine single cluster cases by thresdholding the affinity matrix.
For the complete list of parameters of `FallbackOptions`, see `spectralcluster/fallback_clusterer.py`.
### Speed up the clustering
Spectral clustering can become slow when the number of input embeddings is large. This is due to the high costs of steps such as computing the Laplacian matrix, and eigen decomposition of the Laplacian matrix. One trick to speed up the spectral clustering when the input size is large is to use hierarchical clustering as a pre-clustering step.
To use this feature, you can specify the `max_spectral_size` argument when constructing the `SpectralClusterer` object. For example, if you set `max_spectral_size=200`, then the Laplacian matrix can be at most `200 * 200`.
But please note that setting `max_spectral_size` may cause degradations of the final clustering quality. So please use this feature wisely.
### Constrained spectral clustering
In the [Turn-to-Diarize paper](https://arxiv.org/abs/2109.11641),
the spectral clustering is constrained by speaker turns.
We implemented two constrained spectral clustering methods:
* Affinity integration.
* Constraint propagation (see paper [[1](https://link.springer.com/chapter/10.1007/978-3-642-15567-3_1)] and [[2](https://arxiv.org/abs/1109.4684)]).
If you pass in a `ConstraintOptions` object when initializing your `SpectralClusterer` object, you can call the `predict` function with a `constraint_matrix`.
Example usage:
```python
from spectralcluster import constraint
ConstraintName = constraint.ConstraintName
constraint_options = constraint.ConstraintOptions(
constraint_name=ConstraintName.ConstraintPropagation,
apply_before_refinement=True,
constraint_propagation_alpha=0.6)
clusterer = spectral_clusterer.SpectralClusterer(
max_clusters=2,
refinement_options=refinement_options,
constraint_options=constraint_options,
laplacian_type=LaplacianType.GraphCut,
row_wise_renorm=True)
labels = clusterer.predict(matrix, constraint_matrix)
```
The constraint matrix can be constructed from a `speaker_turn_scores` list:
```python
from spectralcluster import constraint
constraint_matrix = constraint.ConstraintMatrix(
speaker_turn_scores, threshold=1).compute_diagonals()
```
### Multi-stage clustering
In the [multi-stage clustering paper](https://arxiv.org/abs/2210.13690),
we introduced a highly efficient **streaming** clustering approach. This is
implemented as the `MultiStageClusterer` class in
`spectralcluster/multi_stage_clusterer.py`.
> Note: We did NOT implement speaker turn detection in this open source library.
We only implemented fallback, main, pre-clusterer and dynamic compression here.
The `MultiStageClusterer` class has a method named `streaming_predict`.
In streaming clustering, every time we feed a **single** new embedding to the
`streaming_predict` function, it will return the sequence of cluster labels
for **all** inputs, including corrections for the predictions on previous
embeddings.
Example usage:
```python
from spectralcluster import Deflicker
from spectralcluster import MultiStageClusterer
from spectralcluster import SpectralClusterer
main_clusterer = SpectralClusterer()
multi_stage = MultiStageClusterer(
main_clusterer=main_clusterer,
fallback_threshold=0.5,
L=50,
U1=200,
U2=400,
deflicker=Deflicker.Hungarian)
for embedding in embeddings:
labels = multi_stage.streaming_predict(embedding)
```
## Citations
Our papers are cited as:
```
@inproceedings{wang2018speaker,
title={{Speaker Diarization with LSTM}},
author={Wang, Quan and Downey, Carlton and Wan, Li and Mansfield, Philip Andrew and Moreno, Ignacio Lopz},
booktitle={2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
pages={5239--5243},
year={2018},
organization={IEEE}
}
@inproceedings{xia2022turn,
title={{Turn-to-Diarize: Online Speaker Diarization Constrained by Transformer Transducer Speaker Turn Detection}},
author={Wei Xia and Han Lu and Quan Wang and Anshuman Tripathi and Yiling Huang and Ignacio Lopez Moreno and Hasim Sak},
booktitle={2022 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
pages={8077--8081},
year={2022},
organization={IEEE}
}
@article{wang2022highly,
title={Highly Efficient Real-Time Streaming and Fully On-Device Speaker Diarization with Multi-Stage Clustering},
author={Quan Wang and Yiling Huang and Han Lu and Guanlong Zhao and Ignacio Lopez Moreno},
journal={arXiv:2210.13690},
year={2022}
}
```
## Star History
[](https://star-history.com/#wq2012/SpectralCluster&Date)
## Misc
We also have fully supervised speaker diarization systems, powered by
[uis-rnn](https://github.com/google/uis-rnn).
Check this [Google AI Blog](https://ai.googleblog.com/2018/11/accurate-online-speaker-diarization.html).
To learn more about speaker diarization, you can check out:
* A curated list of resources:
[awesome-diarization](https://github.com/wq2012/awesome-diarization)
* An online course on Udemy: [A Tutorial on Speaker Diarization](https://www.udemy.com/course/diarization/?referralCode=21D7CC0AEABB7FE3680F)
Raw data
{
"_id": null,
"home_page": "https://github.com/wq2012/SpectralCluster",
"name": "spectralcluster",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "",
"author": "Quan Wang",
"author_email": "quanw@google.com",
"download_url": "https://files.pythonhosted.org/packages/37/01/c94ada73cd9d32f2fb4a160b6615834fcf7d4809610fc27dc516e2b09fbe/spectralcluster-0.2.21.tar.gz",
"platform": null,
"description": "# Spectral Clustering\n[](https://github.com/wq2012/SpectralCluster/actions) [](https://pypi.python.org/pypi/spectralcluster) [](https://pypi.org/project/spectralcluster) [](https://pepy.tech/project/spectralcluster) [](https://codecov.io/gh/wq2012/SpectralCluster) [](https://wq2012.github.io/SpectralCluster)\n\n## Overview\n\nThis is a Python re-implementation of the spectral clustering and\nconstrained spectral clustering algorithms presented in these papers:\n\n* [Speaker Diarization with LSTM](https://google.github.io/speaker-id/publications/LstmDiarization/)\n* [Turn-to-Diarize: Online Speaker Diarization Constrained by Transformer Transducer Speaker Turn Detection](https://arxiv.org/abs/2109.11641)\n* [Highly Efficient Real-Time Streaming and Fully On-Device Speaker Diarization with Multi-Stage Clustering](https://arxiv.org/abs/2210.13690)\n\n\n\n## Notice\n\nWe recently added new functionalities to this library to include\n algorithms in a [new paper](https://arxiv.org/abs/2109.11641). We updated the APIs as well.\n\nIf you depend on our old API, please use an **older version** of this library:\n```\npip3 install spectralcluster==0.1.0\n```\n\n## Disclaimer\n\n**This is not a Google product.**\n\n**This is not the original C++ implementation used by the papers.**\n\nPlease consider this repo as a \"demonstration\" of the algorithms,\ninstead of a \"reproduction\" of what we use at Google. Some features\nmight be missing or incomplete.\n\n## Installation\n\nInstall the [package](https://pypi.org/project/spectralcluster/) by:\n\n```bash\npip3 install spectralcluster\n```\n\nor\n\n```bash\npython3 -m pip install spectralcluster\n```\n\n## Tutorial\n\nSimply use the `predict()` method of class `SpectralClusterer` to perform\nspectral clustering. The example below should be closest to the original C++\nimplemention used by our\n[ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/).\n\n```python\nfrom spectralcluster import configs\n\nlabels = configs.icassp2018_clusterer.predict(X)\n```\n\nThe input `X` is a numpy array of shape `(n_samples, n_features)`,\nand the returned `labels` is a numpy array of shape `(n_samples,)`.\n\nYou can also create your own clusterer like this:\n\n```\nfrom spectralcluster import SpectralClusterer\n\nclusterer = SpectralClusterer(\n min_clusters=2,\n max_clusters=7,\n autotune=None,\n laplacian_type=None,\n refinement_options=None,\n custom_dist=\"cosine\")\n\nlabels = clusterer.predict(X)\n```\n\nFor the complete list of parameters of `SpectralClusterer`, see\n`spectralcluster/spectral_clusterer.py`.\n\n[](https://youtu.be/pjxGPZQeeO4)\n[](https://youtu.be/U79Aw1ky7ag)\n\n## Advanced features\n\n### Refinement operations\n\nIn our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/), we apply a sequence of refinment operations on the affinity matrix, which is critical to the performance on the speaker diarization results.\n\nYou can specify your refinement operations like this:\n\n```\nfrom spectralcluster import RefinementOptions\nfrom spectralcluster import ThresholdType\nfrom spectralcluster import ICASSP2018_REFINEMENT_SEQUENCE\n\nrefinement_options = RefinementOptions(\n gaussian_blur_sigma=1,\n p_percentile=0.95,\n thresholding_soft_multiplier=0.01,\n thresholding_type=ThresholdType.RowMax,\n refinement_sequence=ICASSP2018_REFINEMENT_SEQUENCE)\n```\n\nThen you can pass the `refinement_options` as an argument when initializing your\n`SpectralClusterer` object.\n\nFor the complete list of `RefinementOptions`, see\n`spectralcluster/refinement.py`.\n\n### Laplacian matrix\n\nIn our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/),\nwe apply a refinement operation `CropDiagonal` on the affinity matrix, which replaces each diagonal element of the affinity matrix by the max non-diagonal value of the row. After this operation, the matrix has similar properties to a standard Laplacian matrix, and it is also less sensitive (thus more robust) to the Gaussian blur operation than a standard Laplacian matrix.\n\nIn the new version of this library, we support different types of Laplacian matrix now, including:\n\n* None Laplacian (affinity matrix): `W`\n* Unnormalized Laplacian: `L = D - W`\n* Graph cut Laplacian: `L' = D^{-1/2} * L * D^{-1/2}`\n* Random walk Laplacian: `L' = D^{-1} * L`\n\nYou can specify the Laplacian matrix type with the `laplacian_type` argument of the `SpectralClusterer` class.\n\nNote: Refinement operations are applied to the affinity matrix **before** computing the Laplacian matrix.\n\n### Distance for K-Means\n\nIn our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/),\nthe K-Means is based on Cosine distance.\n\nYou can set `custom_dist=\"cosine\"` when initializing your `SpectralClusterer` object.\n\nYou can also use other distances supported by [scipy.spatial.distance](https://docs.scipy.org/doc/scipy/reference/spatial.distance.html), such as `\"euclidean\"` or `\"mahalanobis\"`.\n\n### Affinity matrix\n\nIn our [ICASSP 2018 paper](https://google.github.io/speaker-id/publications/LstmDiarization/),\nthe affinity between two embeddings is defined as `(cos(x,y)+1)/2`.\n\nYou can also use other affinity functions by setting `affinity_function` when initializing your `SpectralClusterer` object.\n\n### Auto-tune\n\nWe also support auto-tuning the `p_percentile` parameter of the `RowWiseThreshold` refinement operation, which was original proposed in [this paper](https://arxiv.org/abs/2003.02405).\n\nYou can enable this by passing in an `AutoTune` object to the `autotune` argument when initializing your `SpectralClusterer` object.\n\nExample:\n\n```python\nfrom spectralcluster import AutoTune, AutoTuneProxy\n\nautotune = AutoTune(\n p_percentile_min=0.60,\n p_percentile_max=0.95,\n init_search_step=0.01,\n search_level=3,\n proxy=AutoTuneProxy.PercentileSqrtOverNME)\n```\n\nFor the complete list of parameters of `AutoTune`, see\n`spectralcluster/autotune.py`.\n\n### Fallback clusterer\n\nSpectral clustering exploits the global structure of the data. But there are\ncases where spectral clustering does not work as well as some other simpler\nclustering methods, such as when the number of embeddings is too small.\n\nWhen initializing the `SpectralClusterer` object, you can pass in a `FallbackOptions` object to the `fallback_options` argument, to use a fallback clusterer under certain conditions.\n\nAlso, spectral clustering and eigen-gap may not work well at making single-vs-multi cluster decisions. When `min_clusters=1`, we can also specify `FallbackOptions.single_cluster_condition` and `FallbackOptions.single_cluster_affinity_threshold` to help determine single cluster cases by thresdholding the affinity matrix.\n\nFor the complete list of parameters of `FallbackOptions`, see `spectralcluster/fallback_clusterer.py`.\n\n### Speed up the clustering\n\nSpectral clustering can become slow when the number of input embeddings is large. This is due to the high costs of steps such as computing the Laplacian matrix, and eigen decomposition of the Laplacian matrix. One trick to speed up the spectral clustering when the input size is large is to use hierarchical clustering as a pre-clustering step.\n\nTo use this feature, you can specify the `max_spectral_size` argument when constructing the `SpectralClusterer` object. For example, if you set `max_spectral_size=200`, then the Laplacian matrix can be at most `200 * 200`.\n\nBut please note that setting `max_spectral_size` may cause degradations of the final clustering quality. So please use this feature wisely.\n\n### Constrained spectral clustering\n\n\n\nIn the [Turn-to-Diarize paper](https://arxiv.org/abs/2109.11641),\nthe spectral clustering is constrained by speaker turns.\nWe implemented two constrained spectral clustering methods:\n\n* Affinity integration.\n* Constraint propagation (see paper [[1](https://link.springer.com/chapter/10.1007/978-3-642-15567-3_1)] and [[2](https://arxiv.org/abs/1109.4684)]).\n\nIf you pass in a `ConstraintOptions` object when initializing your `SpectralClusterer` object, you can call the `predict` function with a `constraint_matrix`.\n\nExample usage:\n\n```python\nfrom spectralcluster import constraint\n\nConstraintName = constraint.ConstraintName\n\nconstraint_options = constraint.ConstraintOptions(\n constraint_name=ConstraintName.ConstraintPropagation,\n apply_before_refinement=True,\n constraint_propagation_alpha=0.6)\n\nclusterer = spectral_clusterer.SpectralClusterer(\n max_clusters=2,\n refinement_options=refinement_options,\n constraint_options=constraint_options,\n laplacian_type=LaplacianType.GraphCut,\n row_wise_renorm=True)\n\nlabels = clusterer.predict(matrix, constraint_matrix)\n```\n\nThe constraint matrix can be constructed from a `speaker_turn_scores` list:\n\n```python\nfrom spectralcluster import constraint\n\nconstraint_matrix = constraint.ConstraintMatrix(\n speaker_turn_scores, threshold=1).compute_diagonals()\n```\n\n### Multi-stage clustering\n\n\n\n\nIn the [multi-stage clustering paper](https://arxiv.org/abs/2210.13690),\nwe introduced a highly efficient **streaming** clustering approach. This is\nimplemented as the `MultiStageClusterer` class in\n`spectralcluster/multi_stage_clusterer.py`.\n\n> Note: We did NOT implement speaker turn detection in this open source library.\nWe only implemented fallback, main, pre-clusterer and dynamic compression here.\n\nThe `MultiStageClusterer` class has a method named `streaming_predict`.\nIn streaming clustering, every time we feed a **single** new embedding to the\n`streaming_predict` function, it will return the sequence of cluster labels\nfor **all** inputs, including corrections for the predictions on previous\nembeddings.\n\nExample usage:\n\n```python\nfrom spectralcluster import Deflicker\nfrom spectralcluster import MultiStageClusterer\nfrom spectralcluster import SpectralClusterer\n\nmain_clusterer = SpectralClusterer()\n\nmulti_stage = MultiStageClusterer(\n main_clusterer=main_clusterer,\n fallback_threshold=0.5,\n L=50,\n U1=200,\n U2=400,\n deflicker=Deflicker.Hungarian)\n\nfor embedding in embeddings:\n labels = multi_stage.streaming_predict(embedding)\n```\n\n## Citations\n\nOur papers are cited as:\n\n```\n@inproceedings{wang2018speaker,\n title={{Speaker Diarization with LSTM}},\n author={Wang, Quan and Downey, Carlton and Wan, Li and Mansfield, Philip Andrew and Moreno, Ignacio Lopz},\n booktitle={2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},\n pages={5239--5243},\n year={2018},\n organization={IEEE}\n}\n\n@inproceedings{xia2022turn,\n title={{Turn-to-Diarize: Online Speaker Diarization Constrained by Transformer Transducer Speaker Turn Detection}},\n author={Wei Xia and Han Lu and Quan Wang and Anshuman Tripathi and Yiling Huang and Ignacio Lopez Moreno and Hasim Sak},\n booktitle={2022 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},\n pages={8077--8081},\n year={2022},\n organization={IEEE}\n}\n\n@article{wang2022highly,\n title={Highly Efficient Real-Time Streaming and Fully On-Device Speaker Diarization with Multi-Stage Clustering},\n author={Quan Wang and Yiling Huang and Han Lu and Guanlong Zhao and Ignacio Lopez Moreno},\n journal={arXiv:2210.13690},\n year={2022}\n}\n```\n\n## Star History\n\n[](https://star-history.com/#wq2012/SpectralCluster&Date)\n\n## Misc\n\nWe also have fully supervised speaker diarization systems, powered by\n[uis-rnn](https://github.com/google/uis-rnn).\nCheck this [Google AI Blog](https://ai.googleblog.com/2018/11/accurate-online-speaker-diarization.html).\n\nTo learn more about speaker diarization, you can check out:\n* A curated list of resources:\n[awesome-diarization](https://github.com/wq2012/awesome-diarization)\n* An online course on Udemy: [A Tutorial on Speaker Diarization](https://www.udemy.com/course/diarization/?referralCode=21D7CC0AEABB7FE3680F)\n",
"bugtrack_url": null,
"license": "",
"summary": "Spectral Clustering",
"version": "0.2.21",
"project_urls": {
"Homepage": "https://github.com/wq2012/SpectralCluster"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "3b026e235fad0d9ea5277fc1b2d967ba9c6fe66a7169a00561e10134a8507b18",
"md5": "d9f1562138c340f8e2d393c988c6d745",
"sha256": "8935f235460b27942ba7d2e43ec8daf27a23589f4d7ad85ce1d91b06d0efa54e"
},
"downloads": -1,
"filename": "spectralcluster-0.2.21-py3-none-any.whl",
"has_sig": false,
"md5_digest": "d9f1562138c340f8e2d393c988c6d745",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 31754,
"upload_time": "2023-08-24T14:46:47",
"upload_time_iso_8601": "2023-08-24T14:46:47.053904Z",
"url": "https://files.pythonhosted.org/packages/3b/02/6e235fad0d9ea5277fc1b2d967ba9c6fe66a7169a00561e10134a8507b18/spectralcluster-0.2.21-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "3701c94ada73cd9d32f2fb4a160b6615834fcf7d4809610fc27dc516e2b09fbe",
"md5": "aeeae704d47cd9d69c862edf9bbc67ef",
"sha256": "53a62b85b92900e02ba9196b895be57922750b72f273c7b28e77869cc0c7cbe6"
},
"downloads": -1,
"filename": "spectralcluster-0.2.21.tar.gz",
"has_sig": false,
"md5_digest": "aeeae704d47cd9d69c862edf9bbc67ef",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 30126,
"upload_time": "2023-08-24T14:46:48",
"upload_time_iso_8601": "2023-08-24T14:46:48.792041Z",
"url": "https://files.pythonhosted.org/packages/37/01/c94ada73cd9d32f2fb4a160b6615834fcf7d4809610fc27dc516e2b09fbe/spectralcluster-0.2.21.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-08-24 14:46:48",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "wq2012",
"github_project": "SpectralCluster",
"travis_ci": false,
"coveralls": true,
"github_actions": true,
"requirements": [],
"lcname": "spectralcluster"
}
JSON
