semvec/pypi-packages huggingface dataset:
CityAD 0.1.2
CityAD, an Automatic Differentiation package
Requires Python: >=3.6

# cs107-FinalProject

Group 12, CS 107 Fall 2020
Group Members: Isha Puri, Paul Kramer, Jim Zhang, David Assaraf, Eleonora Shantsila
 

[![Build tatus](https://travis-ci.com/cityscape-107/cs107-FinalProject.svg?token=teRcJtzAha2XHvJyHUuV&branch=master)](https://travis-ci.com/cityscape-107/cs107-FinalProject.svg?token=xYsv5q7x2gpMtwWCxi9Q&branch=master)


[![codecov](https://codecov.io/gh/cityscape-107/cs107-FinalProject/branch/master/graph/badge.svg?token=N45TQOIGSJ)](https://codecov.io/gh/cityscape-107/cs107-FinalProject)
gitfighters 1.1.0
Automatic Differentiation Library

[![Build Status](https://travis-ci.com/Git-fighters/cs107-FinalProject.svg?token=un3y85ex3jSbm3Fhz45K&branch=master)](https://travis-ci.com/Git-fighters/cs107-FinalProject)

[![codecov](https://codecov.io/gh/Git-fighters/cs107-FinalProject/branch/master/graph/badge.svg?token=OHXBN0F2TM)](undefined)

# cs107-FinalProject
CS107 final project

Group Number: 10

Members:
- Manana Hakobyan
- Tale Lokvenec
- Hugo Fernandez-Montenegro
- Golo Feige (since Milestone 1)

## Broader Impact and Inclusivity Statement

### Broader Impact
This automatic differentiation package can be used in machine learning, numerical analysis, or economic optimization applications. Machine learning is a highly controversial field of science. Alan Turing already discussed consequences of machine learning in 1950, and Norbert Wiener draw an analogy between learning machines and intelligent slaves to warn against it ten years later. Wiener (1960) asked how "often in ancient times the clever Greek philosopher slave of less intelligent Roman slaveholder must have dominated the actions of his master rather than obeyed his wishes" to illustrate how powerful learning machines might become. Differentiation is also used in fields like ballistics or economic optimization. The latter often aims to reduce input costs such as human labor. These cost reductions can disrupt the careers of people. Nevertheless, automatic differentiation is a well-researched field and this package is unlikely to have a broader impact. 


### Inclusivity 
GitFighters shares the commitment to "Diversity Inclusion & Belonging" defined by Harvard University as embracing "individuals from varied backgrounds, cultures, races, identities, life experiences, perspectives, beliefs, and values". As a group uniting different nationalities, backgrounds, and genders, GitFighters reflects inclusive diversity. As part of the effort towards building a more inclusive library the GitFighters team implemented an input string parser aimed at improving the user experience and broadening the inclusivity of the library towards less tech savvy and math oriented users. GitFighters also make an effort to limit implicit exclusion in the development of this package. Contributing to this package requires programming knowledge and experience. This requirement excludes a large group of people. Therefore, GitFighters agreed on considering input from a broader audience and to implement changes together. Users, for instance, might have good ideas on how to improve the string-parsing or on how to import the package, but will not necessarily be able to implement these improvements. GitFighters are happy to consider suggestions and to implement them, if possible.


Sources:

Harvard University. About Diversity Inclusion & Belonging. https://dib.harvard.edu/about. Accessed 30 November 2020.

Turing, A. M. (1950). Computing Machinery and Intelligence. Mind, 59(236), 433-460.

Wiener, N. (1960). Some Moral and Technical Consequences of Automation. Science (American Association for the Advancement of Science), 131(3410), 1355-1358.
DreamDiff 1.0.1
A Python package for automatic differentiation, root-finding, optimization, and interpolation
Requires Python: >=3.6

# cs107-FinalProject

## Group #32
Aditya Kumar, Carlos Robles, Blake Bullwinkel

Travis Build Badge:
[![Build Status](https://travis-ci.org/autodiffdreamteam/cs107-FinalProject.svg?branch=master)](https://travis-ci.org/autodiffdreamteam/cs107-FinalProject)

Codecoverage Badge:
[![codecov](https://codecov.io/gh/autodiffdreamteam/cs107-FinalProject/branch/master/graph/badge.svg?token=7VF8CR2OBS)](https://codecov.io/gh/autodiffdreamteam/cs107-FinalProject)

DreamDiff is a Python package for automatic differentiation, root-finding, optimization, and interpolation.

Our goal for DreamDiff is for it to live well beyond the confines of a computer science course, as all good software should. While we believe it has potential to be used in a wide range of exciting applications, it is important to also consider the broader implications of our software.

Our package implements forward-mode automatic differentiation, gradient descent, Nesterov's accelerated gradient descent, Newton’s method and quadratic splines. All these tools have distinct usages, but we hope the convenience of a centralized optimization package provides some extra utility to users working on various optimization tasks in machine learning, minimization and maximization problems, and interpolation using quadratic splines.

Further, we hope that the visualization and animation functionality built into our optimization functions serve as a useful educational tool, providing a more intuitive understanding of how these methods work and encouraging math and computer science education more broadly. Perhaps most importantly, we hope that by open-sourcing our software, it will be accessible to as many people as possible. We believe that open-source platforms like GitHub have inherent advantages for inclusivity, providing open access to people around the world who may want to utilize or build upon its core functionality. Nonetheless, it is important to address the more subtle yet persistent inequities in software development and the broader field of computer science.

For example, open source still requires an internet connection, which automatically excludes the 3.6 billion people across the globe (around 47% of the world's population) who do not use the internet, let alone have a computer or access to the educational resources required to learn basic STEM skills. But even in regions of the world where internet access is not an issue, historical gender imbalances have created barriers for women and people of color in computer science. Regardless of your own background, we ask that you keep these inequities in mind and consider how your own work environment can be made more inclusive, particularly for groups that face historical barriers in STEM fields.
asyncode 1.0.0
Emulating Python's interactive interpreter in asynchronous contexts
Requires Python: >=3.5

# asyncode
[![PyPI](https://img.shields.io/pypi/v/asyncode)](https://pypi.org/project/asyncode)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/asyncode)](https://pypi.org/project/asyncode)
[![PyPI - Wheel](https://img.shields.io/pypi/wheel/asyncode)](https://pypi.org/project/asyncode)
[![Read the Docs](https://img.shields.io/readthedocs/asyncode)](https://asyncode.readthedocs.io)
[![Travis CI](https://img.shields.io/travis/loic-simon/asyncode)](https://travis-ci.org/github/loic-simon/asyncode)

Python package for emulating Python's interactive interpreter in asynchronous contexts.


## Installation

Use the package manager [pip](https://pypi.org/project/pip) to install asyncode:
```bash
pip install asyncode
```

### Dependencies

* Python **≥ 3.5** *(no CI for Python < 3.8)*



## Usage

This package's external API consists in two classes, **`AsyncInteractiveInterpreter`** and **`AsyncInteractiveConsole`**, which subclass respectively [`code.InteractiveInterpreter`](https://docs.python.org/3/library/code.html#interactive-interpreter-objects) and [`code.InteractiveConsole`](https://docs.python.org/3/library/code.html#interactive-console-objects).

These classes are meant to be used in **already running asynchronous contexts**. Minimal useful code will need to subclass provided classes to implement specific functions:

```py
import asyncode

class MyAsyncConsole(asyncode.AsyncInteractiveConsole):
    """AsyncInteractiveConsole adapted to running environment"""

    async def write(self, data):
        """Use specific function"""
        await some_output_coroutine(data)

    async def raw_input(self, prompt=""):
        """Use specific functions"""
        if prompt:
            await some_output_coroutine(prompt)

        data = await some_input_coroutine()
        return data


async def run_interpreter():
    """Run an interactive Python interpreter"""
    console = MyAsyncConsole()
    try:
        await console.interact()
    except SystemExit:
        # Do not exit the whole program when sending "exit()" or "quit()"
        await some_output_coroutine("Bye!")
```

Read [the docs](https://asyncode.readthedocs.io) for more informations.



## Contributing

Pull requests are welcome. Do not hesitate to get in touch with me (see below) for any question or suggestion about this project!



## License

This work is shared under [the MIT license](LICENSE).

© 2020 Loïc Simon ([loic.simon@espci.org](mailto:loic.simon@espci.org))
slackpm 0.0.2
This is a simple script to send push message to Slack channels using Webhooks URL with Slack Apps.
Requires Python: >=3.6

This is a simple script to send push message to Slack channels using Webhooks URL with Slack Apps.


0.0.1 (12/12/2020)
------------------

- First Release


0.0.2 (12/12/2020)
------------------

- Added Subject to Messages.
- Resolved exception handling.
sparse-uls 6.2
optimize norm with underdetermined system equality constraint

# sparsest-solution-underdetermined-linear-system
optimize norm with underdetermined system equality constraint

## problem statement

```
Minimize ||x||_p
Given Ax=b
where   x \in R^n
        A \in R^{m \times n}
        b \in R^m
        p \in R_+
```

## algorithm

### unconstrained optimization (L_p norm, p >= 1)

```
Minimize ||Ax-b||_2^2 + ||x||_p^p
```

```
Let z \in R^{n-m} be an arbitrary vector.
Represent the solution of Ax=b by x = A* z + b* // see boyd convex optimization
The problem becomes minimizing ||A*z + b*||_p
```


### linear programming (L_1 norm)

```
# idea
Let y \in R^{n} with 2 additional constraints
y \geq x and y \geq -x (element-wise)
Let u = [x, y] \in R^{2n}, the feasible set is a polyhedron.
Minimize sum of y, get x

# explanation
y \geq x and y \geq -x constraint y \geq |x|
Let u1 = [x1, y1] be the minimizer.
It is easy to prove that minimal y, y1 = |x1|
Hence, the LP formulation yeilds the same solution as the original problem.
```

## results (m = 400, n = 2000, random A b)

### L2 norm sparsity

![norm2](https://raw.githubusercontent.com/khanhhhh/sparse-uls/main/assets/norm2.png)

### L1.001 norm sparsity

![norm1001](https://raw.githubusercontent.com/khanhhhh/sparse-uls/main/assets/norm1001.png)

### L1 norm sparsity

![norm1](https://raw.githubusercontent.com/khanhhhh/sparse-uls/main/assets/norm1.png)

## Packaging

```bash
rm -rf dist/*
python setup.py sdist bdist_wheel
twine upload dist/*

```


## Useful links

- https://pypi.org/project/sparse-uls/

- https://web.stanford.edu/~boyd/cvxbook/bv_cvxbook.pdf (page 682)

- https://packaging.python.org/tutorials/packaging-projects/

- https://dzone.com/articles/executable-package-pip-install