sgtsnepi 0.5.0__cp313-cp313-win_amd64.whl

sgtsnepi/__init__.py

@@ -0,0 +1,2 @@
+from . import sgtsne
+from .sgtsne import sgtsnepi

sgtsnepi/sgtsne.py

@@ -0,0 +1,92 @@
+from math import inf
+
+import numpy
+from scipy.sparse import csc_matrix
+
+from nextprod import nextprod
+
+from . import _sgtsnepi
+
+def sgtsnepi(
+    input_graph, y0=None, d=2, max_iter=1000, early_exag=250,
+    lambda_par=1, h=1.0, bb=-1.0, eta=200.0, run_exact=False,
+    fftw_single=False, alpha=12, drop_leaf=False,
+    grid_threshold=None, silent=False
+):
+
+    # Import input_graph as CSC matrix
+    try:
+        input_graph = csc_matrix(input_graph)
+    except ValueError as e:
+        raise TypeError("input_graph must be an adjacency matrix") from e
+
+    if not input_graph.shape[0] == input_graph.shape[1]:
+        raise ValueError("input_graph must be square")
+
+    n = input_graph.shape[0]
+
+    # Eliminate self-loops for input_matrix
+    if any(input_graph.diagonal() != 0):
+        print("Warning: input_graph has self-loops; setting distances to 0")
+
+    input_graph.setdiag(numpy.zeros(n))
+    input_graph.eliminate_zeros()
+
+    nnz = input_graph.nnz
+
+    if input_graph.data.size > 0 and numpy.min(input_graph.data) < 0:
+        raise ValueError("Negative edge weights are not supported")
+
+    if y0 is not None:
+        try:
+            y0 = numpy.array(y0)
+        except Exception as e:
+            raise TypeError("y0 must be array-like or None.") from e
+
+        if y0.shape != (d, n):
+            raise ValueError("y0 must be of shape (d, n)")
+
+        y0 = numpy.transpose(y0)
+
+    # Setting parameters correctly
+    list_grid_sizes = [nextprod((2, 3, 5), x) for x in range(16, 512)]
+
+    if grid_threshold is None:
+        grid_threshold = 1e6 ** (1/d)
+
+    grid_threshold = int(grid_threshold)
+
+    bb = inf if run_exact else bb
+    bb = h * (n ** (1/d)) / 2 if bb <= 0 else bb
+
+    h = 1.0 if h == 0 else h
+    h = [max_iter + 1, h]
+
+    y = _sgtsnepi.sgtsnepi_c(
+        numpy.array(input_graph.indices, dtype=numpy.uint32),
+        numpy.array(input_graph.indptr, dtype=numpy.uint32),
+        numpy.array(input_graph.data, dtype=numpy.float64),
+        y0,
+        nnz,
+        d,
+        lambda_par,
+        max_iter,
+        early_exag,
+        alpha,
+        fftw_single,
+        numpy.array(h, dtype=numpy.float64),
+        bb,
+        eta,
+        numpy.array(list_grid_sizes, dtype=numpy.int32),
+        len(list_grid_sizes),
+        n,
+        drop_leaf,
+        run_exact,
+        grid_threshold,
+        silent
+    )
+
+    # permute y to (d, n)
+    y = numpy.transpose(y)
+
+    return y

sgtsnepi-0.5.0.data/headers/sgtsne.hpp

@@ -0,0 +1,98 @@
+/*!
+  \file   sgtsne.hpp
+  \brief  SG-t-SNE-Pi header with structure and function definitions.
+
+  The main procedure definition, responsible for parsing the data
+  and the parameters, preprocessing the input, running the
+  gradient descent iterations and returning.
+
+  \author Dimitris Floros
+  \date   2019-06-21
+*/
+
+
+#ifndef SGTSNE_HPP
+#define SGTSNE_HPP
+
+#include "types.hpp"
+#include <iostream>             // NULL
+
+//! List of SG-t-SNE-Pi parameters
+/*! 
+  A list of parameters available in SG-t-SNE-Pi, with default values
+  specified.
+*/
+typedef struct {
+
+  int     d         = 2;         //!< Number of embedding dimensions
+  double  lambda    = 1;         //!< λ rescaling parameter
+  double  alpha     = 12;        //!< Early exaggeration multiplier
+  int     maxIter   = 1000;      //!< Maximum number of iterations
+  int     earlyIter = 250;       //!< Number of early exaggeration iterations
+  int     n         = 0;         //!< Number of vertices
+  double *h         = NULL;      //!< Grid side length (accuracy control)
+  bool    dropLeaf  = false;     //!< Drop edges originating from leaf nodes?
+  int     np        = 0;         //!< Number of CILK workers (processes)
+  double  bound_box = 1e64;      //!< Bounding box (default infinite)
+  double  eta       = 200.0;     //!< learning rate
+  bool    run_exact = false;     //!< exact qq
+  int     fftw_single = 0;       //!< run FFTW single precision? (default false)
+} tsneparams; 
+
+
+//! Sparse matrix structure in CSC format
+/*!
+  Custom structure to hold the elements of a CSC sparse matrix format.
+*/
+typedef struct {
+
+  int m;        //!< Number of rows
+  int n;        //!< Number of columns
+  int nnz;      //!< Number of nonzero elements
+  
+  matidx * row; //!< Rows indices (NNZ length)
+  matidx * col; //!< Columns offset (N+1 length)
+  matval * val; //!< Values (NNZ length)
+  
+} sparse_matrix;
+
+// include utility functions
+#include "utils.hpp"
+
+
+//! Embed the sparse stochastic graph P
+/*!
+  Compute the embedding of the input stochastic graph P. 
+  A list of parameters are defined in the tsneparams structure.
+  
+
+  \return [d-by-N] The embedding coordinates
+*/
+coord* sgtsne(sparse_matrix P,            //!< The sparse stochastic graph P in CSC storage
+              tsneparams params,          //!< A struct with the SG-t-SNE parameters
+              coord *y_in = nullptr,      //!< [Optional] The embedding coordinates
+              double **timeInfo = nullptr //!< [Optional] Returns timing information
+              );
+
+
+//! Perplexity equalization
+/*!
+
+  The input as the kNN graph of a dataset, of size [(k+1)-by-N]. The
+  (k+1) input must contain the self-loop as the first element. Both
+  the indices and the distances are needed.
+
+
+  \return The CSC sparse column-stochastic all-kNN, after perplexity equalization.
+*/
+extern "C" {
+sparse_matrix perplexityEqualization( int *I,    //!< [(k+1)-by-N] array with the neighbor IDs
+                                      double *D, //!< [(k+1)-by-N] array with the neighbor distances
+                                      int n,     //!< [scalar] Number of data points N
+                                      int nn,    //!< [scalar] Number of neighbors k
+                                      double u   //!< [scalar] Perplexity u
+                                      );
+
+}
+
+#endif /* _SGTSNE_H_ */

sgtsnepi-0.5.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: sgtsnepi
+Version: 0.5.0
+Summary: SG-t-SNE-Π wrapper for Python
+Author-Email: Alexandros Athanasiadis <athanasiadisalex2@gmail.com>
+License: GPLv3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: C
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Project-URL: Homepage, https://github.com/alex-unofficial/sgtsnepi-python
+Requires-Dist: numpy>=1.19.5
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: nextprod>=1.0
+Provides-Extra: dev
+Requires-Dist: matplotlib>=3.5; extra == "dev"
+Requires-Dist: pylint>=2.17; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+Description-Content-Type: text/markdown
+
+# SG-t-SNE-Π wrapper for Python
+
+This repository aims to provide a `Python` interface to 
+[SG-t-SNE-Π](http://t-sne-pi.cs.duke.edu), which is a high-performance 
+software for swift embedding of a large, sparse graph into
+a d-dimensional space (d=1,2,3) on a shared-memory computer.
+
+> :warning: **Warning!** This package is still a work in progress.
+
+## Installation
+
+### Prerequisites
+
+`sgtsnepi` supports Linux, macOS, and Windows.
+
+Installation requires `Python 3.9` or higher.
+
+Wheels are not built for all architectures as of now.
+If your architecture is not supported please open a relevant issue on the GitHub page.
+
+### Installing the Module
+
+To install the package run
+```sh
+pip install sgtsnepi
+```
+
+Then in your Python code run the following to import the library:
+```python
+import sgtsnepi
+
+# [ ... ]
+
+sgtsnepi.sgtsnepi(sparse_matrix, args)
+```
+
+Or to import the `sgtsnepi` function directly:
+```python
+from sgtsnepi import sgtsnepi
+
+# [ ... ]
+
+sgtsnepi(sparse_matrix, args)
+```
+
+## Running the Demo
+
+To use the demo you should install [matplotlib](https://matplotlib.org/) by running
+```sh
+pip install scipy matplotlib
+```
+
+Then from the source directory run
+```
+python tests/demo.py mm_file.mtx ndim
+```
+where `mm_file.mtx` is a file containing the input matrix which is in the
+[Matrix Market](https://math.nist.gov/MatrixMarket/index.html) file format,
+and `ndim` is the number of embedding dimensions.
+
+You can find some compressed `MatrixMarket` files in the `data/` subdirectory.
+
+## Citation
+
+If you use this software, pleace cite the following paper:
+
+```bibtex
+@inproceedings{pitsianis2019sgtsnepi,
+    author = {Pitsianis, Nikos and Iliopoulos, Alexandros-Stavros and Floros, Dimitris and Sun,        Xiaobai},
+    doi = {10.1109/HPEC.2019.8916505},
+    booktitle = {IEEE High Performance Extreme Computing Conference},
+    month = {11},
+    title = {{Spaceland Embedding of Sparse Stochastic Graphs}},
+    year = {2019}
+}
+```

sgtsnepi-0.5.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+sgtsnepi-0.5.0.dist-info/METADATA,sha256=NWKwHs0aa2g-WPIXE4dS40e5MbAWcKSeGmYTDigkzrc,2989
+sgtsnepi-0.5.0.dist-info/WHEEL,sha256=suq8ARrxbiI7iLH3BgK-82uzxQ-4Hm-m8w01oCokrtA,85
+sgtsnepi/_sgtsnepi.cp313-win_amd64.pyd,sha256=5N9TTLTV-ieuULaNS_KpdHTjf6M_qK_2Yw2q8lNQZaQ,509394
+sgtsnepi/_sgtsnepi.cp313-win_amd64.dll.a,sha256=DxszU6rXncgYCnfqi81QLk7feVjJZRg6rzJyRKSAI5E,1752
+sgtsnepi/sgtsne.py,sha256=xMzqg2hyG8lyr72Ok2cOrUTdXldCnVnnDpjCkHlvLtc,2510
+sgtsnepi/__init__.py,sha256=32ArB_7Y5qWi8FfciG2CnPWyeZPj019XzP0aJi3nuC8,52
+sgtsnepi-0.5.0.data/headers/sgtsne.hpp,sha256=WT6XG3EgH2fT0j6_JOndbbd91bQTGuN50HoGcImDbkU,3340
+sgtsnepi-0.5.0.dist-info/RECORD,,

sgtsnepi-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64