semvec/pypi-packages huggingface dataset:
micrograd 0.1.0
A tiny scalar-valued autograd engine with a small PyTorch-like neural network library on top.
Requires Python: >=3.6


# micrograd

![awww](puppy.jpg)

A tiny Autograd engine (with a bite! :)). Implements backpropagation (reverse-mode autodiff) over a dynamically built DAG and a small neural networks library on top of it with a PyTorch-like API. Both are tiny, with about 100 and 50 lines of code respectively. The DAG only operates over scalar values, so e.g. we chop up each neuron into all of its individual tiny adds and multiplies. However, this is enough to build up entire deep neural nets doing binary classification, as the demo notebook shows. Potentially useful for educational purposes.

### Example usage

Below is a slightly contrived example showing a number of possible supported operations:

```python
from micrograd.engine import Value

a = Value(-4.0)
b = Value(2.0)
c = a + b
d = a * b + b**3
c += c + 1
c += 1 + c + (-a)
d += d * 2 + (b + a).relu()
d += 3 * d + (b - a).relu()
e = c - d
f = e**2
g = f / 2.0
g += 10.0 / f
print(f'{g.data:.4f}') # prints 24.7041, the outcome of this forward pass
g.backward()
print(f'{a.grad:.4f}') # prints 138.8338, i.e. the numerical value of dg/da
print(f'{b.grad:.4f}') # prints 645.5773, i.e. the numerical value of dg/db
```

### Training a neural net

The notebook `demo.ipynb` provides a full demo of training an 2-layer neural network (MLP) binary classifier. This is achieved by initializing a neural net from `micrograd.nn` module, implementing a simple svm "max-margin" binary classification loss and using SGD for optimization. As shown in the notebook, using a 2-layer neural net with two 16-node hidden layers we achieve the following decision boundary on the moon dataset:

![2d neuron](moon_mlp.png)

### Tracing / visualization

For added convenience, the notebook `trace_graph.ipynb` produces graphviz visualizations. E.g. this one below is of a simple 2D neuron, arrived at by calling `draw_dot` on the code below, and it shows both the data (left number in each node) and the gradient (right number in each node).

```python
from micrograd import nn
n = nn.Neuron(2)
x = [Value(1.0), Value(-2.0)]
y = n(x)
dot = draw_dot(y)
```

![2d neuron](gout.svg)
PygamePhysics 0.0.1
Help with physics in Pygame
Requires Python: >=3.5

This project is to help with creating physics with Pygame
Knowledge of Pygame is still required

This package contains 2 modules: Collisions and Physics, you only need to worry about the physics module

__init__ function:
    • This function is for creating the object. You can not use this package if you create your own Pygame rect object
    • Args- x of object, y of object, width, height, color, the window object that you would like the object to be placed on, velocity of object (Cannot be changed later on)

setDimensions function:
    • Args- windowWidth, windowHeight

move function:
    • Moves the object in the direction specified (up, down, left, right)
    • Args- velocity, direction

setGravity function:
    • Sets the gravity for the different axis
    • Args- x gravity, y gravity

keepInBounds function:
    • Keeps the object in the bounds of the screen (Called in the update function)

update function:
    • Updates all of the objects' gravity and does collision resolution
    • Args- A list of all of the objects

processCollisions functions:
    • Handles collision resolution
    • Args- A list of all of the objects

draw function:
    • Draws the object on the window specified in the init function

jump function:
    • Makes the object jump
    • Args- jump power, object_list (This can be left with a None value, it is not used