semvec/pypi-packages huggingface dataset:
pypostmodern 0.2.0
Prepare your Python code to the postmodernism era!
Requires Python: >=3.6

# pypostmodern
Prepare your Python code to the **postmodernism era**!

>Postmodernist philosophers in general argue that truth is always contingent on historical and social context rather than being absolute and universal and that **truth is always partial and "at issue" rather than being complete and certain**. [Wikipedia](https://en.wikipedia.org/wiki/Postmodernism)

So let's turn your Python to **a Postmodern Python, where there is no truth...**
## Example
Running this code with `pypostmodern`:
```python
if False:
    print('It's the postmodernism era!')
```
the output will be:

`It's the postmodernism time!`

## Usage
Clone code with:
`git clone https://github.com/zvibazak/pypostmodern.git`

Edit you code on `script.py`, your code should start with `# coding: my_truth`

Set your truths at `run.py`:
```py
truths = ["1+1==3","False"] #add here more truths... 
```

Run `run.py`
bcg-shanest 0.0.1
Basic computation graph, for pedagogical purposes

# basic-computational-graph
 
This is a library intended for pedagogical purposes illustrating a very minimal implementation of dynamic computational graphs with reverse-mode differentiation (backpropagation) for computing gradients.  Three guidelines motivate design choices made in the implementation:
* Mimicking PyTorch's API as closely as possible.
* Simple `forward`/`backward` for operations (operating on numpy arrays).
* Dynamic computation graphs, built as operations are run.

The library has been inspired by several other similar projects.  Specific acknowledgments are in the source where appropriate.
* [`micrograd`](https://github.com/karpathy/micrograd) by Karpathy
* [`autodidact`](https://github.com/mattjj/autodidact): a pedagogical implementation of `autograd`
* [`joelnet`](https://github.com/joelgrus/joelnet)

## Usage

`main.py` exhibits a basic use case of defining a feed-forward neural network (multi-layer perceptron) to learn a basic function (in this case, `y = sum(x)/2` where `x` is a binary vector).  You can run it by using `python main.py` from an environment with the packages from `requirements.txt`.

## Basics

There are a few important data structures:
* `Tensor`: this is a wrapper around a numpy array (stored in `.value`), which corresponds to a node in a computation graph, storing information like its parents (if any) and a backward method.
* `Operator`: an operator implements the `forward`/`backward` API and operates directly on numpy arrays.  A decorator `@tensor_op` converts an `Operator` into a method that can be directly called on `Tensor` arguments, which will build the graph dynamically.
* `nn.Module`: as in PyTorch, these are wrappers for graphs that keep track of parameters, sub-modules, etc.

## TODO

* Document the code properly!
* Split training out of `main` into a separate trainer?
* Remove `networkx` dependency altogether?