semvec/pypi-packages huggingface dataset:
grn-SIGRN 1.0.1
GRN inference
Requires Python: >=3.7

# SIGRN
SIGRN: Inferring Gene Regulatory Network with Soft Introspective Variational Autoencoders

# Architecture

![MDWGANGP2](/images/SIGRN_arc.png)

# Dependencies
- python =3.8
- torch==2.1.0
- scanpy==1.9.1
- other detailed installation packages can be found in requirements.txt
- CUDA toolkit 11.0 or later.

# Installation

1. Clone the SIGRN repository from GitHub:
```
git clone https://github.com/lryup/SIGRN.git
```
2. Create a new environment:
```
conda create -n your_env_name python=3.8.0
  ```
3. Activate the environment:
```
conda activate your_env_name
 ```
4. Install the required packages:
 ```
pip install -r requirements.txt# It is recommended to install only the missing packages
 ```

# Data Preparation
In our study, we trained our model using data from [BEENLINE](https://bcb.cs.tufts.edu/DAZZLE/BEELINE.zip).
You can download the datasets from the provided link. 
# Runing
The training command we used is as follows:
```
python run.py
```
# Example tutorial

We provide an example tutorial  in **Tutorial.ipynb**
Check out the [this tutorial](https://github.com/lryup/SIGRN/blob/main/Tutorial.ipynb) for a quick overview  of how to use SIGRN for your research!

# Usage

SIGRN accepts input data in CSV, TSV format, or H5AD format as provided by Scanpy (genes in rows and cells in columns for TSV and CSV). The output of the  GRN inference task includes an adjacency matrix and various evaluation metrics, such as AUC, EPR, and AUPRR.

# Baseline methods
- Beeline https://github.com/Murali-group/Beeline/tree/master
- DeepSEM https://github.com/HantaoShu/DeepSEM
- GRN-VAE/DAZZLE https://github.com/TuftsBCB/dazzle/tree/main

# References

- Thanks to the following authors for their papers and codes.

  [1] Pratapa, A., Jalihal, A.P., Law, J.N., Bharadwaj, A., Murali, T.: Benchmarking algorithms for gene regulatory network inference from single-cell transcriptomic data. Nature methods 17(2), 147–154 (2020)

  [2] Shu, H., Zhou, J., Lian, Q., Li, H., Zhao, D., Zeng, J., Ma, J.: Modeling gene regulatory networks using neural network architectures. Nature Computational Science 1(7), 491–501 (2021)

  [3] Zhu, H., Slonim, D.: Grn-vae: A simplified and stabilized sem model for gene regulatory network inference. bioRxiv pp. 2023–01 (2023)
vzn 0.1
A module for data visualization.
Requires Python: >=3.6


# vzn

  

`vzn` is a Python package designed to extend the capabilities of existing visualization libraries like Matplotlib, Seaborn and Plotly. It provides customizable templates, interactive plots, and makes visualization simple & quick.


## Features

  

-  **Bar Plots**: Create customizable bar plots with dark or default themes.

-  **Scatter Plots**: Generate both static and interactive scatter plots using `seaborn` or `plotly`.

-  **Heatmaps**: Visualize data with annotated heatmaps and various color maps.

-  **Histograms**: Easily generate histograms for data distribution analysis.

  

## Installation
  

You can install `vzn` using pip:

  

```bash

pip  install  vzn

```

## Usage

  
### Bar Plot
```python
v = vzn()
v.b_plot(data, x='Category', y='Values', title='Bar Plot Example', theme='dark')
```

  
### Scatter Plot
```python
# Static Scatter Plot
v.s_plot(data, x='Category', y='Values', title='Static Scatter Plot')

# Interactive Scatter Plot
v.s_plot(data, x='Category', y='Values', title='Interactive Scatter Plot', interactive=True)
```

  
### Heatmap
```python
v.hmap(data.corr(), title='Heatmap Example')
```
### Histogram
```python
v.hist(data['Values'], title='Histogram Example')
```
sdpchainpy 1.0.1
SDPCHAIN provenance system
Requires Python: >=3.8
Keywords: provencance, data, metadata

SDPCHAIN
===========

Seismology Data Preparation Module

Routines and classes providing a consistent interface for Python programs using
the SDPCHAIN protocol, which includes:

- Create or append to a process-steps.json file at each step
    - the process-steps file is read from the input directory and written
      to the output directory.  If both directories are the same the new step
      is appended to the existing file
- command-line arguments:
    - -d (base_dir)
    - -i (in_dir), can be relative to base directory
    - -o (out_dir), can be relative to base directory
    - optional (input_file) or (input_files), will have input directory pre-pended
    - optional -of (output_file) or -ofs (output_files), will have output dir pre-pended
    - optional -f, forces writing of output file if it already exists

- For now, these parameters must have exactly the above names in the files that
  use SDPCHAIN, so that setup_paths and ProcessStep process them correctly.
  The new ArgParser subclass should eliminate this need, but pre-populating
  the argparser with base_dir, in_dir and out_dir, as well as optionally 
  input_file or input_files, output_file or output_files, and/or -f
  
Classes
---------------------

`ProcessSteps` object to hold information for a process-steps file

Command-line Routines
---------------------

These routines perform common functions while following the
SDPCHAIN rules (process-steps file, -i, -o, -d)

`sdpstep`: run a standard command-line program 

`sdpcat`: concatenate binary files

ToDo
----
Add `sdpcode`: change net and station codes?