semvec/pypi-packages huggingface dataset:
predictions-analyzer 0.0.55
A powerful tool for analyzing and ensembling predictions
Requires Python: >=3.7

# predictions_analyzer

Predictions Analyzer is a powerful tool to help discover which models perform best on the kinds of samples you have.  This allows you to create local models and ensemble models with precision, while also finding out which samples are the most challenging to classify.

# Documentation: 
https://predictions-analyzer.readthedocs.io/en/latest

# Notes
Currently in development.
Expected first release: Early Febuary 2021
DijkstraAlgorithm 0.0.1
To measure the shortest distance of any nodes or any particular points, we can use this package. By using this package, we will get the shortest path and also the distance.
Keywords: Shortest Path,Dijkstra Algorithm,Graph,Shortest Distance,Shortest Route,Dijkstra_2D,Dijkstra_3D

# DijsktraAlgorithm


Dijkstra's algorithm is an algorithm for finding the shortest paths between nodes in a graph. It was conceived by computer scientist **Edsger W. Dijkstra** in 1956 and published three years later.
Here, I used his method in python to find the shortest path and also the distance.

# Installing

Run the following code to install on your terminal:

```python
pip install DijkstraAlgorithm
```

# Using

Follow the given way to use it:

```python
'''First Import our module'''
from DijkstraAlgorithm import DijkstraAlgorithm as da

'''Initializing the Class Attributes'''
x = da.DijkstraAlgorithm()

'''Now pass the arguments through the following method'''
x.dijkstraWithPath(graph, source, destination)  #Here, this graph is about the distance between each nodes.

'''Lets define some methods'''
shortest_path = x.path()
distance = x.distance()
print(*shortest_path)   #It will print the path
print(distance)         #It will print the distance
```

### Plugins

Few useful links:

| Plugin | README |
| ------ | ------ |
| 2D Model | https://github.com/MizanMustakim/Dijkstra-s-Shortest-Path-Algorithm/tree/main/Shortest%20Path%20in%202D%20model |
| 3D Model | https://github.com/MizanMustakim/Dijkstra-s-Shortest-Path-Algorithm/tree/main/Shortest%20Path%20in%203D%20model |



License
----

MIT


**Free Software, Happy Coding!**
ir-metrics 0.1.6
The most common information retrieval (IR) metrics
Requires Python: >=3.6, <4

ir-metrics |tests| |docs| |downloads|
-------------------------------------
.. |tests| image:: https://github.com/kqf/ir-metrics/workflows/tests/badge.svg?branch=master
    :alt: Tests Status
    :scale: 100%
    :target: https://github.com/kqf/ir-metrics/workflows/tests/

.. |downloads| image:: https://img.shields.io/pypi/dm/ir-metrics
    :alt: PyPi downloads
    :scale: 100%
    :target: https://img.shields.io/pypi/dm/ir-metrics

.. |docs| image:: https://readthedocs.org/projects/ir-metrics/badge/?version=latest
    :alt: Documentation Status
    :scale: 100%
    :target: https://ir-metrics.readthedocs.io/?badge=latest

A set of the most common metrics in used in information retrieval.

============
Usage
============

The metrics are designed to work for array-like structures and integers:

.. code:: python

    >>> from irmetrics.topk import rr
    >>> y_true = "apple"
    >>> y_pred = ["banana", "apple", "grapes"]
    >>> rr(y_true, y_pred)
    0.5

The same function works also for the matrix-like structures:

.. code:: python

    >>> import numpy as np
    >>> from irmetrics.topk import rr
    >>> y_trues = np.repeat(y_true, 128)
    >>> y_preds = np.repeat([y_pred], 128, axis=0)
    >>> # Calculate the Mean Reciprocal Rank
    >>> rr(y_trues, y_preds).mean()
    0.5
    >>> # Calculate the standard deviation for Reciprocal Ranks
    >>> rr(y_trues, y_preds).std()
    0.0

Check the `docs <https://ir-metrics.readthedocs.io>`_ for more examples.

============
Installation
============

To install with pip, run:

.. code:: bash

    pip install ir-metrics
vanqc 0.1.0
Variant Annotator and QC Checker for Human Genome Sequencing
Requires Python: >=3.6

vanqc
=====

Variant Annotator and QC Checker for Human Genome Sequencing

[![wercker status](https://app.wercker.com/status/97b0f087b3e5a0a6409aa399611a07bc/s/main "wercker status")](https://app.wercker.com/project/byKey/97b0f087b3e5a0a6409aa399611a07bc)
![Upload Python Package](https://github.com/dceoy/vanqc/workflows/Upload%20Python%20Package/badge.svg)

Installation
------------

```sh
$ pip install -U https://github.com/dceoy/vanqc/archive/main.tar.gz
```

Dependent commands:

- `pigz`
- `bgzip`
- `tabix`
- `bcftools` (and `plot-vcfstats`)
- `java`
- `snpEff` (`java -jar snpEff.jar`)
- `gatk`
- `vep`

Docker image
------------

Pull the image from [Docker Hub](https://hub.docker.com/r/dceoy/vanqc/).

```sh
$ docker image pull dceoy/vanqc
```

Usage
-----

- Normalize VCF files using Bcftools

  ```sh
  $ vanqc normalize /path/to/reference.fa /path/to/variants.vcf.gz
  ```

- Annotate variants using SnpEff

  ```sh
  $ vanqc download --snpeff --dest-dir=/path/to/resource
  $ vanqc snpeff \
      /path/to/resource/snpeff_data/GRCh38.86
      /path/to/reference.fa \
      /path/to/variants.vcf.gz
  ```

- Annotate variants using GATK Funcotator

  ```sh
  $ vanqc download --funcotator --dest-dir=/path/to/resource
  $ vanqc funcotator \
      /path/to/resource/funcotator_dataSources.v1.7.20200521 \
      /path/to/reference.fa \
      /path/to/variants.vcf.gz
  ```

- Annotate variants using Ensembl VEP

  ```sh
  $ vanqc download --vep --dest-dir=/path/to/resource
  $ vanqc vep \
      /path/to/resource/vep_cache/homo_sapiens \
      /path/to/reference.fa \
      /path/to/variants.vcf.gz
  ```

- Collect VCF stats using Bcftools

  ```sh
  $ vanqc stats /path/to/reference.fa /path/to/variants.vcf.gz
  ```

- Collect variant calling metrics using GATK (Picard)

  ```sh
  $ vanqc metrics \
      /path/to/reference.fa \
      /path/to/dbsnp.vcf.gz \
      /path/to/variants.vcf.gz
  ```

Run `vanqc --help` for more information.
cg-flatland 0.0.1
Easier development of polymer structure prediction tools.
Requires Python: >=3.6

# Flatland

#### Easier development of polymer structure prediction tools

The development and debugging of modern neural network approaches for protein structure prediction has the potential to be a somewhat complicated task. Here we provide a framework, Flatland, for simulating training datasets of the form used by current state-of-the-art systems. The central task performed is to evolve a population of polymer sequences, predict their folded structure, produce distance matrix and bond angle tensors, and calculate spectra of per-polymer compound or other polymer interaction likelihoods (emulating protein-protein and compound-protein interaction datasets). This framework intentionally performs such simulations in a highly simplified manner that does not accurately model the real biological processes. Relatedly, it provides the means to simplify the problem to an arbitrary extent - including permitting the reduction from three to two dimensions, reducing the amino acid alphabet from twenty-one to three, and simplifying characteristics of the evolutionary optimization. We provide the framework together with a collection of starting-point notebooks for training neural network models to learn from such data by way of an open source repository to kick-start the development efforts of those interested in contributing to solving this vitally important problem.

## Installation

You can install the last released version of Flatland via pip

```bash

pip install cg-flatland

```

Or install the most recent development version of Flatland using git

```bash

git clone https://github.com/cayley-group/flatland
pip install -e flatland

```

## Demonstrations

We're putting together various demonstration notebooks which you'll be able to access via the following:

* [Data Generation](https://colab.research.google.com/github/cayley-group/flatland/blob/master/nb/data-generation.ipynb)
* [Structure Solver Example](https://colab.research.google.com/github/cayley-group/flatland/blob/master/nb/structure-solver.ipynb)
kohonen-som 0.0.1
PyTorch implementation of Kohonen's Self-Organizing Map.
Requires Python: >=3.6

# Kohonen's Self-Organizing Map (SOM)

![gif](https://github.com/nicomignoni/SOM/blob/master/animation/animation.gif)

## Background

The original [paper](https://sci2s.ugr.es/keel/pdf/algorithm/articulo/1990-Kohonen-PIEEE.pdf) written by Teuvo Kohonen in 1990 was one of the first neural network model capable of unsupervised learning.

Out of the different implementations of the algorithm, this one follows almost entirely the original paper. The update function is defined as


<div align="center"><img src="https://latex.codecogs.com/gif.latex?w_%7Bij%7D%28t%29%20%3D%20w_%7Bij%7D%28t%29%20&plus;%20%5Calpha%28t%29%20%5Ccdot%20h%28t%29%20%5Ccdot%20%7C%7Cx_%7Bci%7D%20-%20w_%7Bij%7D%28t%29%7C%7C"></div>

where

<div align="center"><img src=https://latex.codecogs.com/gif.latex?%5Cinline%20%5Cbegin%7Balign*%7D%20%5Cdisplaystyle%20%5Calpha%28t%29%20%3D%20%5Calpha_0%20%5Ccdot%20%5Ctext%7Bexp%7D%5Cleft%28%20-%5Cfrac%7Bt%7D%7B%5Ctau_%7B%5Calpha%7D%7D%20%5Cright%29%2C%20%5C%20h%28t%29%20%3D%20%5Ctext%7Bexp%7D%5Cleft%28-%5Cfrac%7B%7C%7Cw_%7Bc%7D%20-%20w_%7Bi%7D%7C%7C%5E2%7D%7B2%5Csigma%28t%29%5E2%7D%20%5Cright%29%2C%20%5C%20%5Csigma%28t%29%20%3D%20%5Csigma_0%20%5Ccdot%5Ctext%7Bexp%7D%20%5Cleft%28%20-%5Cfrac%7Bt%7D%7B%5Ctau_%7B%5Csigma%7D%7D%20%5Cright%29%20%5Cend%7Balign*%7D></div>

and ![equation](https://latex.codecogs.com/gif.latex?%5Cinline%20t) is the current epoch.

Also, each neuron is connected to all the other ones, hence the map is a ![equation](https://latex.codecogs.com/gif.latex?K_p) complete graph, where ![equation](https://latex.codecogs.com/gif.latex?p) is the number of neurons. 

## Example