semvec/pypi-packages huggingface dataset:
mlx-micrograd 0.1.0
An mlx port of Karpathy's micrograd - a tiny scalar-valued autograd engine with a small PyTorch-like neural network library on top.
Requires Python: >=3.6


# mlx-micrograd

An mlx port of Karpathy's [micrograd](https://github.com/karpathy/micrograd) - a tiny scalar-valued autograd engine with a small PyTorch-like neural network library on top.

### Installation

```bash
pip install mlx_micrograd
```

### Example usage

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}') # prints array(24.7041, dtype=float32), the outcome of this forward pass
g.backward()
print(f'{a.grad}') # prints array(138.834, dtype=float32), i.e. the numerical value of dg/da
print(f'{b.grad}') # prints array(645.577, dtype=float32), i.e. the numerical value of dg/db
```

### Training a neural net

`demo.ipynb` provides a full demo of training an 2-layer neural network (MLP) binary classifier. 

### Running tests

To run the unit tests you will have to install [PyTorch](https://pytorch.org/), which the tests use as a reference for verifying the correctness of the calculated gradients. Then simply:

```bash
python -m pytest
```

### License

MIT
cycling-nestedls 1.2.2
A tool to resovle the cycling_nested list.
Keywords: cycle, nested, list


# cycling_nestedls

**readme.md文件** .

## Installation

```
pip install cycling_nestedls
```

## Usage

example:

```python
import cycling_nestedls

a=['wangzha','meiye',['zhuxiaomin','runtu','chengxiang',['qiuqiu','mixian']]]

example=cycling_nestedls()

test_copy=example.cycling_nestedls(a,True)

#def cycling_nestedls(self,the_list,tab_switch=False,tab_levels=0)

```

## Update log
`1.2.2`修改了long_description
`1.2.1`更新了setup.py文件

`1.2.0`添加了tab缩进功能，且可导出为csv

`1.0.2`修改了readme.md文件

`1.0.1`第一次上传，但是代码不健全

`1.0.0` first release(但是没有真正上传到PYPI，因为第一次！。)

## how to upload a new version (for me)

>pypi: https://packaging.python.org/tutorials/packaging-projects/
>pypi: https://python-packaging-zh.readthedocs.io/zh_CN/latest/minimal.html#id2

![png](https://raw.githubusercontent.com/cornradio/imgs/main/20230218220613.png)

> make sure have twine and setuptools installed first⭐⭐⭐
1. change `setup.py`
2. testing `python3 setup.py develop`
3. `python3 setup.py sdist`
4. `twine upload dist/*`
![png](E:\ForDocument\Code_items\ForPython\cut_up_04-21_21-14-26.png)

## 最后：Get help

Github地址（还没写好）
Get help ➡️ [Github issue](https://github.com/sgys22/picture_url)

---------------------------------------------
 编译readme.md
>> 一级标题#，二级##
>>是高亮块(`xxx`)
>> 一级注释>
>> 多级注释>>
>>代码'''python'''
pydbconnect 1.0.0
A private database service library.
Keywords: python, database, server

# PyDBConnect
this is simply an API implementation (wrapper) for my WebAPI [PyDBConnect](https://github.com/nexus-novelist/PyDBConnect)

## How to use
Clone the PyDBConnect server repo on your server and follow the instructions
Use the Pypi package to use the API implementation

## Installation

```
pip install PyDBConnect
```

## Documentation

Import the library
```python
>>> from pydbconnect import connection
```

Establish a connection to the PyDBConnect server
```python
>>> db = connection("localhost:7575", "project", "password")
```
Replace the hostname with your own hostname/ip (making sure to include the port).
replace "project" with your PyDBConnect project name, and the password with your pyDBConnect password.

Check server availability
```python
>>> db.ping_db().status_code
```
ping_db() method returns a Response object which you can get the status code out of.
if the status code returned is 200 then the server responded properly!

Get list of collections in project
```python
>>> db.get_collections()
```
Should return a list of strings representing collections in the project

Get collection data
```python
>>> db.get_collection("collection")
```
Should return the documents present in the collection

Get document contents
```python
>>> db.get_document("collection", "document_id")
```
Returns the contents of the document

Create document
```python
>>> db.create_document("collection", "document_id", {"key": "value", "key2": "value3"})
```
Creates a new document with the specified document_id in the collection
(Oh no! i messed up the value2. Let's fix that!)

Update document
```python
>>> db.update_document("collection", "document_id", {"key": "value", "key2": "value2"})
```
Updates the document with the specified document_id in the collection

Delete document
```python
>>> db.delete_document("collection", "document_id")
```
Note: This returns a Response object

Create new collection
```python
>>> db.create_collection("new_collection")
```
Creates a new collection with the given name

Delete a collection
```python
>>> db.delete_collection("new_collection")
```
DawgsML 0.0.3
A simple library for machine learning without a requirements.txt
Requires Python: >=3.9
Keywords: machine learning, data processing, custom data structures, pandas-like, data analysis, ml, data science, statistics, numpy, deep learning, preprocessing, pandas simulation

# DawgsML
A machine learning package for models and utilities.  
This project initially started as a simple assignment for an undergraduate course in AI at Butler University, and that  
is why is named Dawgs.  
For this assignment we had to build a simple perceptron to be used for a binary classification of a non-linearly  
separable problem, without using any packages other than the Python standard library.  

Here there is a data structure for tabular data representation that it kind of simulates pandas, with file I/O and tons  
of methods to be used for data preprocessing like remove/add columns or rows, shuffling, column type conversion,  
but also operations on data structure itself like iterations, indexing, etc.  
This data structure is used in all the machine learning algorithms and utilities, and is meant to give to user a package  
that do not rely on any other dependencies.  

Still you can access the data as list by calling the proper .data property on the columns so that is still possible to  
use graphic libraries such as matplotlib or seaborn.  
The purpose of this project was not to build an efficient tabular data structure. In fact, this is nowhere even close  
to pandas efficiency, and literally any efforts was made to optimize any of the methods of the Dataframe data structure.  
However, contributors, are very welcome to have their hand dirty by using this as a playground.

AS of now, there is only one ML algorithm, a Perceptron, and a bunch of ML utilities like splitting, k-Fold, and a  
grid-search, but more will be added soon.