Metadata-Version: 2.1
Name: sparsebm
Version: 0.2
Summary: An implementation of Stochastic Bloc model and Latent Block model efficient with sparse matrices.
Home-page: https://github.com/gfrisch/sparsebm
Author: Gabriel Frisch
Author-email: gabriel.frisch@hds.utc.fr
License: UNKNOWN
Keywords: datamining graph LBM SBM variationnal sparse
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Science/Research
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3 :: Only
Requires-Python: >=3.5
Description-Content-Type: text/markdown
Requires-Dist: progressbar2
Requires-Dist: scipy
Requires-Dist: numpy
Provides-Extra: gpu
Requires-Dist: cupy ; extra == 'gpu'
Provides-Extra: test
Requires-Dist: pytest ; extra == 'test'

# sparsebm: a python implementation for the Latent Bloc Model (LBM) and Stochastic Bloc Model (SBM) for an efficient analysis of large graphs.

## Installing

From pypi:

```
pip3 install sparsebm
```

To use GPU acceleration:

```
pip3 install sparsebm[gpu]
```

Or
```
pip3 install sparsebm
pip3 install cupy
```

## Example
### Generate SBM Synthetic graph
- Generate a synthetic graph to analyse with SBM:
```python
import numpy as np
from sparsebm import generate_bernouilli_SBM
#
# Define the properties of your graph
#
number_of_nodes = 10 ** 3
number_of_clusters = 4
cluster_proportions = np.ones(number_of_clusters) / number_of_clusters
connection_probabilities = np.array([[0.05, 0.018, 0.006, 0.0307], [0.018, 0.037, 0, 0], [0.006, 0, 0.055, 0.012], [0.0307, 0, 0.012, 0.043]])
#
# The graph is generated
#
data = generate_bernouilli_SBM(number_of_nodes, number_of_clusters, connection_probabilities, cluster_proportions, symetric=True)
graph, cluster_indicator, = (data["X"], data["Y"])
```

### Infere with sparsebm SBM_bernouilli:
 - Use the bernouilli Stochastic Bloc Model:
```python
    from sparsebm import SBM_bernouilli

    model = SBM_bernouilli(
        number_of_clusters,
        gpu_number=None, # Or give the desired GPU index.
        symetric=True,
    )

    model.fit(graph)

    print("Labels:")
    print(model.labels)
```
To use GPU acceleration, CUPY needs to be installed and replace gpu_number to the desired GPU index.



### Generate LBM Synthetic graph
- Generate a synthetic graph to analyse with LBM:
``` python
    from sparsebm import generate_bernouilli_LBM
    import numpy as np
    #
    # Define the properties of your graph
    #
    number_of_rows = 10 ** 3
    number_of_columns = 2* number_of_rows
    nb_row_clusters, nb_column_clusters = 3, 4
    row_cluster_proportions = np.ones(nb_row_clusters) / nb_row_clusters
    column_cluster_proportions = np.ones(nb_column_clusters) / nb_column_clusters
    connection_probabilities = np.array([[0.1, 0.0125, 0.0125, 0.05], [0.0125, 0.1, 0.0125, 0.05], [0, 0.0125, 0.1, 0]])
    #
    # The graph is generated
    #
    data = generate_bernouilli_LBM(
            number_of_rows,
            number_of_columns,
            nb_row_clusters,
            nb_column_clusters,
            connection_probabilities,
            row_cluster_proportions,
            column_cluster_proportions
        )
    graph, row_cluster_indicator, column_cluster_indicator, = (data["X"], data["Y1"], data["Y2"])
```

### Infere with sparsebm LBM_bernouilli:
 - Use the bernouilli Latent Bloc Model:

``` python
    from sparsebm import LBM_bernouilli

    model = LBM_bernouilli(
        nb_row_clusters,
        nb_column_clusters,
        gpu_number=None, # Or give the desired GPU index.
    )
    model.fit(graph)

    print("Row labels:")
    print(model.row_labels)

    print("Column labels:")
    print(model.column_labels)
```
To use GPU acceleration, CUPY needs to be installed and set gpu_number the desired GPU index.


