semvec/pypi-packages huggingface dataset:
revgraph 0.0.1
A toy deep learning library built using numpy as its only dependency.
Requires Python: >=3.6

# revgraph

A toy deep learning library built using `numpy` as its only dependency (and 
`dill` for pickling the computational graph).

![](https://travis-ci.org/shhoalex/revgraph.svg?branch=master)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)


### Motivation

I hacked together this project just to deepen my own understanding of how deep
learning frameworks work under the hood. **It is probably the most inefficient 
implementation you could have ever found (lol), so please don't use it for 
anything real.** It's simply a hackable toy computational graph / deep 
learning library that tries to replicate some of tensorflow and kera's 
interfaces.


### Installation

The package has been uploaded to PyPi.
Make sure your python version is at least 3.6.

```text
$ python3 -m pip install revgraph
```

### Key Features

* Gradient Descent Based Optimization Methods
* Regressions
* Deep Learning


### Packages

The project is divided into 2 main parts:

1. `revgraph.core`: A simple computational graph library that supports reverse 
   mode AD.
2. `revgraph.dl`: A high-level deep learning library built entirely on top of 
   `revgraph.core`.


### Usage

#### Finding a function's local minima using gradient descent:

```python
import revgraph.core as rc

x = rc.variable(0.0)
y = 4*x*x - 32*x - 10
optimization = rc.sgd(lr=0.1).minimize(y)

for _ in range(50): 
    rc.run(optimization)

required_y = rc.run(y)
required_x = rc.run(x)

print(f'minimum y = {required_y} when x = {required_x}')
```

##### Output

```text
minimum y = -74.0 when x = 4.0
```

#### Deep Learning

```python
import revgraph.dl as dl

layers = dl.sequential(
    dl.inputs(784),
    dl.dense(
        units=100,
        activation='tanh',
        kernel_initializer='glorot_normal',
        kernel_regularizer=dl.l1(0.01)
    ),
    dl.dense(10, activation='softmax')
)

model = dl.Model(
    model=layers,
    loss=dl.categorical_cross_entropy(),
    optimizer=dl.adam(lr=0.005)
)

...
```


### Credits

The structure/implementation of this library draws heavily on the following 
projects, please don't forget to check them out!

+ `tensorflow`: The computational graph's API is modelled after this.
+ `keras`: The high level API is modelled after kera's API and the 
  implementation of the optimizers is more or less copied from keras.
+ [`autograd`](https://github.com/HIPS/autograd): The computational graph 
  library's `unbroadcast` function is basically how the tensor's able to 
  broadcast its gradient to different shapes.
+ [`conv2d`](https://github.com/renmengye/np-conv2d/tree/master): the implementation
  of the operation Conv2D is based on this implementation.

### Documentation

Read the full documentation [here](https://shhoalex.github.io/revgraph/).
socket.engine 1.0.0
A universal communication engine

# socket.engine

## Installation

Python:
```
pip install socket.engine
```

This library requires Python3. It was tested extensively on Python 3.7.5 with Ubuntu 19.04.

## Documentation and Examples

[Hub Connections](https://github.com/0xJeremy/socket.engine/blob/master/python/docs/Hub_Documentation.md)

[Host / Client Connections](https://github.com/0xJeremy/socket.engine/blob/master/python/docs/HostClient_Documentation.md)
colorgrab 0.0.1
gets a pixel from your screen and spits out the hex value (e.g #0A0EFE)
Requires Python: >=3.6

# colorgrab
gets a pixel from your screen and spits out the hex value (e.g #0A0EFE)

# Examples:
![ejemplo1](https://github.com/julianPescobar/colorgrab/blob/master/example1.png)


![ejemplo2](https://github.com/julianPescobar/colorgrab/blob/master/example2.png)
psankey 1.0.1
Package for plotting Sankey diagrams with Python

<img src="https://github.com/mandalsubhajit/psankey/blob/master/pSankey.png" width="100">


# psankey - A module for plotting Sankey flow diagrams in Python

Inspired by **d3-sankey** package for d3js (https://github.com/d3/d3-sankey)

## Brief description

In data science, we often require to visualize flows in the form of a Sankey diagram. This module helps with that. Usage is very straightforward and customizable.

**Note:** Does not work for cyclical graphs.

## Getting started

### Installation

Directly from the source - clone this repo on local machine, open the shell, navigate to this directory and run:
```
python setup.py install
```
or through pip:
```
pip install psankey
```

### Documentation

Please visit [https://github.com/mandalsubhajit/psankey]
pyecsim 0.2.3.post2
PyECsim: fast and general voltammetry simulation

PyECsim is a fast and general simulator of voltammetry experiments. Using the latest state-of-the-art algorithms, it simulates

- any number of electrode processes, using Butler-Volmer charge transfer kinetics, coupled to
- any number of homogeneous reactions (first or second order), using
- user-defined voltammetry waveforms.

A typical simulation, even with very large reaction rate constants (10e9 /s), takes around 10 ms to run. Because the simulations are fast, you can use them inside the target function of an optimization routine.

In-depth documentation can be found on `read the docs <https://pyecsim.readthedocs.io/>`_.

# Install
---------

Installing PyECsim is easy:

.. code-block::

    pip install --user pyecsim

# Quick-start
-------------

The below example is a minimal piece of code that simulates a charge transfer step (ox + e <-> red) coupled to a chemical reaction (ox <-> prod).

Import PyECsim into your Python code (and matplotlib to plot the voltammogram):

.. code-block:: python

    import pyecsim as ecs
    import matplotlib.pyplot as plt

Then create a simulator and species, a charge transfer step and a chemical reaction:

.. code-block:: python

    sim = ecs.Simulation(True) # or False to suppress output

    red = ecs.Species('reduced species', 1.0, 1.0e-9) # name, concentration [mol/m3], diffusion coefficient [m2/s]
    ox = ecs.Species('oxidized species', 0.0, 1.0e-9)
    prod = ecs.Species('reaction product', 0.0, 1.0e-9)

    rdx1 = ecs.Redox(ox, red, 1, 0.0, 10.0, 0.5).enable() # ox, red, n, E_0 [V], k_e [m/s], alpha
    sim.sys.addRedox( rdx1 )

    rxn1 = ecs.Reaction(ox, None, prod, None, 5.0, 0.0).enable() # reactant1, reactant2, product1, product2, k_f, k_b
    sim.sys.addReaction( rxn1 )

Lastly, we set the electrode type and radius, the voltammograms initial/vertex/final potentials and the scan rate:

.. code-block:: python

    sim.el.disk(1.0e-3) # radius [m]
    sim.exper.setScanPotentials(-0.5, [0.5], -0.5) # potentials [V]: initial, [0 or more vertices], final 
    sim.exper.setScanRate(1.0) # scan rate [V/s]

And then we can run the simulation and plot the results:

.. code-block:: python

    [potential, current] = sim.run()
    plt.plot(potential, current)

Which gives:

.. image:: http://limhes.net/upload/images_ecsim/cv_readme.png