semvec/pypi-packages huggingface dataset:
pdf-fp 1.1
Gaussian and Binomial Distributions

# A brief description of the package:

_The package consists of **two parts:**_

## First: Gaussian Probability Distribution Function:

**Gaussian Class** is dealing with probability for periods

All it need as attributes **the Mean** and **Standard Deviation _respictively_** and it will show all the information you want to know about the probability distribution function for more information you can use _**help**_ function for Gaussian class

## Second: Binomial Probability:

All it needs **the probability** and **the number of succeed trials** and it will also show all the other information like _the mean and Standard Deviation and etc.._

That was a quick and brief description for the package content, more information is provided in the dosstring of the classes.
illumidesk-theia-proxy 0.1.5
hello@illumidesk.com
Keywords: jupyter,theia,jupyterhub

# IllumiDesk Theia IDE

[Theia](https://www.theia-ide.org/) is a configurable web-based IDE
that supports [Visual Studio Code](https://code.visualstudio.com/) compatible extensions. This package was built using the [`jupyter-server-proxy` cookiecutter template](https://github.com/jupyterhub/jupyter-server-proxy/tree/master/contrib/template).

## Installation

```bash
pip install illumidesk-theia-proxy
```

## Requirements

#### Install THEIA IDE

This package's executes the standard `theia start --hostname=0.0.0.0 --port=3000` command. This command assumes the `theia` executable and `package.json` file required to start the application are globally available.

We recommend building a [docker image based on this example](https://github.com/theia-ide/theia-apps/tree/master/theia-deb-build-docker) to avoid configuration conflicts, particularly when mounting the user's home directory with a volume on a local host.

### Install Jupyter Notebook

This extension relies on the Jupyter Notebook to run. [Refer to Jupyter's official documentaion](https://jupyter.org/install) for installation instructions.

### Install illumidesk-theia-proxy

Install the package with pip:

```
pip install illumidesk-theia-proxy
```

### Running with jupyter/docker-stacks based image

The `THEIA IDE` requires `node v10x` for compilation. Therefore the version of node that runs `theia` should also equate to v10x. The jupyter/docker-stacks based images install more recent versions of node. To run `theia` with a container based on a `jupyter/docker-stacks` image install `NVM` and a version `10x` of `node`.

## Notes

- This package is tested with an image based on one of the [Jupyter docker-stacks](https://jupyter-docker-stacks.readthedocs.io/en/latest/) running with JupyterHub.
- `THEIA` requires Node 10x. The base `jupyter docker-stacks` images need some tweaking to make them work with `nvm` and the correct version of `node`. Refer to [this Dockerfile](https://github.com/IllumiDesk/illumidesk/src/illumidesk/workspaces/theia/templates/Dockerfile.theia.j2) for an example.

## Why?

IllumiDesk's setup requires `docker volume` mounts with the local host instance. Files copied to the `jovyan` home directory during the docker build stage are overriden by the files located on the host directories when running a container based on the image. Therefore `theia` is installed with a `debian package (*.deb)` with a docker multi-stage build.

This package assumes the `theia` command is globally available and that the user's settings are defined in the `package.json` installed with the *.deb package, which by default is placed in the `/usr/share/theia-example/app/package.json` directory.

## Attributions

- [`jupyter-theia-proxy`](https://github.com/jupyterhub/jupyter-server-proxy/tree/master/contrib/theia)
- [`theia docker apps`](https://github.com/theia-ide/theia-apps)
- [`jupyter-server-proxy`](https://github.com/jupyterhub/jupyter-server-proxy)

## License

BSD 3-Clause
pyonly 0.1
Create interactive web UIs with Python instead of JavaScript!
Requires Python: >=3.5

# PyOnly
PyOnly lets you build interactive web UIs using Python instead of JavaScript. It enables you to deploy machine learning applications because existing libraries such as TensorFlow can be used. PyOnly works without plugins or code transpilation in all modern web browsers, including mobile browsers. The client logic runs on the server and the required UI changes are sent to the client. Consequently, you don't have to jump between client and server code since both are in the same script. On top of that, you can integrate PyOnly into your existing projects because JavaScript functions, APIs and libraries can be accessed.

## Install
```
$ pip install pyonly
```

## Documentation
Documentation is available at http://pyonly.com/docs/overview.php
hoplite2 0.3.0
A Sparsity Analysis Tool and Library

# hoplite2
[![PyPI version](https://badge.fury.io/py/hoplite2.svg)](https://badge.fury.io/py/hoplite2)
> a sparsity analysis tool for neural networks

## Installation
`pip install hoplite2`


## Usage
There are 2 main classes that are useful in Hoplite2: Spartan and Hoplite.

The Hoplite Class is the main way to use Hoplite2.
```Python
from hoplite2 import Hoplite
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input
import numpy as np

# keras model to analyze
model = VGG16(
    include_top=True,
    weights="imagenet",
    input_tensor=None,
    input_shape=None,
    pooling=None,
    classes=1000,
    classifier_activation="softmax",
)

# preprocess function
def vgg16_preprocess(path):
    img = image.load_img(path, target_size=(224, 224))
    return preprocess_input(np.expand_dims(image.img_to_array(img), axis=0))

hop = Hoplite(model, vgg16_preprocess, layers=[
    "block1_conv2",
    "block2_conv2",
    "block3_conv3",
    "block4_conv3",
    "block5_conv3"
])

hop.analyze_file("test.png") # analyzes test.png

hop.output("output.csv") # saves output to file
```


Spartan implements several useful functions to analyze sparsity of arrays.
These functions include:
```
 - compute_average_sparsity(output,equals_zero=lambda x: x == 0)
 - consec_1d(arr, hist, equals_zero=lambda x: x == 0)
 - consec_row(output, equals_zero=lambda x: x == 0)
 - consec_col(output, equals_zero=lambda x: x == 0)
 - consec_chan(output, equals_zero=lambda x: x == 0)
 - vec_1d(arr, vec_size, hist, equals_zero=lambda x: x == 0):
 - vec_3d_row(output, vec_size, equals_zero=lambda x: x == 0):
 - vec_3d_col(output, vec_size, equals_zero=lambda x: x == 0):
 - vec_3d_chan(output, vec_size, equals_zero=lambda x: x == 0):
```

equals_zero is a function that takes in a number and returns True if the number is considered zero. This is useful if you wish to look for values that are also close to zero and allows for additional customizablity.
gwr-inversion 1.0.1
GWR Algorithm Numerical Laplace Inversion
Requires Python: >=3.7
Keywords: laplace,inversion,transform,gwr

Gaver-Wynn-Rho Algorithm
------------------------

This is a Python reproduction of the Mathematica package that provides the GWR
function, ``NumericalLaplaceInversion.m``.

https://library.wolfram.com/infocenter/MathSource/4738/

This package provides only one function: ``gwr``. The function calculates the
value of the inverse of a Laplace transform at a specified time value,
``Sequence`` of time values, or numpy array of time values.

The Laplace transform should be provided as a function that uses the ``mpmath``
library for a scalar value of the Laplace parameter.  The ``math`` library and
``numpy`` functions do not support multiprecision math and will return invalid
results if they are used.

Simple Example
--------------

.. code-block:: python

    >>> import math
    >>> from gwr_inversion import gwr
    >>> from mpmath import mp

    >>> def lap_ln_fn(s: float):
    ...     # log function
    ...     return -mp.log(s) / s - 0.577216 / s

    >>> gwr(lap_log_fn, time=5.0, M=32)
        mpf('1.6094375773356333')

    >>> math.log(5.0)
    1.6094379124341003


See the notebooks in ``test\`` for other use examples.

The method is described in: ValkÃ³, P.P., and Abate J. 2002. Comparison of
Sequence Accelerators for the Gaver Method of Numerical Laplace Transform
Inversion. *Computers and Mathematics with Application* **48** (3): 629â€“636.
https://doi.org/10.1016/j.camwa.2002.10.017.

More information on multi-precision inversion can be found in: ValkÃ³, P.P.and
Vajda, S. 2002. Inversion of Noise-Free Laplace Transforms: Towards a
Standardized Set of Test Problems. *Inverse Problems in Engineering* **10** (5):
467-483. https://doi.org/10.1080/10682760290004294.
mlduct 0.0.0.6
A personal framework for Machine Learning Pipelines.
Requires Python: >=3.7

[include badges]
<img style="float: right;" src="mlduct/utils/_images/logo.png" width="170" height="120" align="right">
# ML - Duct : A pipeline Framework
<ins>A personal package for Machine Learning Pipelines</ins>
****

## <ins>Usage</ins>

A machine learning framework, to incorporate from data processing to modelling.
PS: Inspired from Keras

```py
# Imports


```