semvec/pypi-packages huggingface dataset:
seq-dove 0.3.6
Set of tools for downstream vcf analysis
Keywords: genomics next generation sequencing variant discovery human genetics

# Dove
Variant analysis tool kit written in python3 for downstream vcf analysis.

## Online Variant Anotation
Annotates given vcf file using Ensembl VEP API.

## Multi Genome Analysis
Filters index sample's variants with parents and siblings based on given inheritance pattern.

## Variant Filter
Filters annotation file by given parameters.

## Quick Install
* Linux&Mac  
> sudo pip3 install --index-url https://test.pypi.org/simple/ dove
* Windows
> pip install --index-url https://test.pypi.org/simple/ dove

## Example Uses

* OVA examples  
>  dove OVA -i input.vcf -o output.csv

* MGA examples  
>  dove MGA -i index.csv -m mother.csv -f father.csv -a trio -p AR -o output.csv
>  dove MGA -d pedigree.csv -a siblings -o output.csv

* VF generic filter examples
>  dove VF -i index.csv -z 1/1 -f 0.01 -r 20 -b protein_coding -o output.csv

* VF Specific filter examples
>  dove VF -t filterfile.txt

* dove examplefile
>  dove examplefile --help
>  dove examplefile -e both

* dove updateomim
>  dove updateomim --help
>  dove updateomim -k apikey
pyrus-nn 0.2.1
Micro Neural Network framework implemented in Rust w/ Python bindings

# pyrus-nn

[![Build Status](https://milesgranger.visualstudio.com/builds/_apis/build/status/pyrus-nn?branchName=master)](https://milesgranger.visualstudio.com/builds/_build/latest?definitionId=1&branchName=master)
[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=milesgranger/black-jack)](https://dependabot.com)
[![crates.io](http://meritbadge.herokuapp.com/pyrus-nn)](https://crates.io/crates/pyrus-nn)

[Rust API Documentation](https://docs.rs/pyrus-nn)

Lightweight neural network framework written in Rust, with _thin_ python bindings.

- Features:
    - Serialize networks into/from YAML & JSON!
        - Rust -> serde compatible
        - Python -> `network.to_dict()` & `Sequential.from_dict()`
    - Python install requires _zero_ dependencies
    - No external system libs to install 

- Draw backs:
    - Only supports generic gradient descent. 
    - Fully connected (Dense) layers only so far
    - Activation functions limited to linear, tanh, sigmoid and softmax
    - Cost functions limited to MSE, MAE, Cross Entropy and Accuracy

### Install:

Python:
```
pip install pyrus-nn  # Has ZERO dependencies!
```

Rust:
```toml
[dependencies]
pyrus-nn = "0.2.1"
```



### From Python
```python
from pyrus_nn.models import Sequential
from pyrus_nn.layers import Dense

model = Sequential(lr=0.001, n_epochs=10)
model.add(Dense(n_input=12, n_output=24, activation='sigmoid'))
model.add(Dense(n_input=24, n_output=1, activation='sigmoid'))

# Create some X and y, each of which must be 2d
X = [list(range(12)) for _ in range(10)]
y = [[i] for i in range(10)]  

model.fit(X, y)
out = model.predict(X)

```

---

### From Rust
```rust
use ndarray::Array2;
use pyrus_nn::{network::Sequential, layers::Dense};


// Network with 4 inputs and 1 output.
fn main() {
    let mut network = Sequential::new(0.001, 100, 32, CostFunc::CrossEntropy);
    assert!(
        network.add(Dense::new(4, 5)).is_ok()
    );
    assert!(
        network.add(Dense::new(5, 6)).is_ok()
    );
    assert!(
        network.add(Dense::new(6, 4)).is_ok()
    );
    assert!(
        network.add(Dense::new(4, 1)).is_ok()
    );

    let X: Array2<f32> = ...
    let y: Array2<f32> = ...

    network.fit(X.view(), y.view());

    let yhat: Array2<f32> = network.predict(another_x.view());
}

```