semvec/pypi-packages huggingface dataset:
pydrew 0.1.0
A set of utilities for Python
Requires Python: >=3.8

# pydrew
A set of tool for python projects

## Custom List Implementation

This repository contains a custom generic list implementation called `List`, which provides additional functionality beyond the built-in Python list. This class is designed using Python's type hinting capabilities to support type safety and offers various utility methods for list manipulation.

## Features

- Generic list implementation capable of handling any type `T`.
- Additional methods for enhanced list operations such as `concat`, `removeAt`, `where`, `group_by`, and more.
- Magic methods to support intuitive Pythonic operations like indexing, iteration, and concatenation.
- Ability to convert the list to different formats such as Python's native list or a dictionary.
- Includes methods to sort, filter, map, and group list elements based on conditions or properties.

## Usage

### Initialization

You can initialize a `List` in a few different ways:
```python
from your_module import List

# Initialize an empty list
my_list = List()

# Initialize from a Python list
my_list = List([1, 2, 3])

# Initialize from an iterator
my_list = List(iter([1, 2, 3]))
```

### Basic Operations
```python
my_list.add(4)          # Add 4 to the list
my_list.add(5, index=1) # Add 5 at index 1

my_list.remove(4)       # Remove the first occurrence of 4
my_list.remove_at(1)    # Remove element at index 1

first_item = my_list.first()  # Get the first element
last_item = my_list.last()    # Get the last element
item = my_list.at_index(2)    # Get element at index 2
```

### Advanced Operations
```python
even_numbers = my_list.where(lambda x: x % 2 == 0) # Filter even numbers
squares = my_list.select(lambda x: x ** 2)         # Square each element

sorted_list = my_list.sort(lambda x: x)            # Sort ascending
grouped = my_list.group_by('attribute')            # Group by object attribute

my_list.reverse()      # Reverse the list
my_list.clear()        # Clear all elements from the list
length = my_list.count() # Get the number of elements
python_list = my_list.to_list() # Convert to Python list

### Magic Methods
```python
another_list = List([6, 7, 8])
combined_list = my_list + another_list
difference_list = my_list - List([3, 4])
````


This README provides a comprehensive overview of the class, including initialization, basic and advanced operations, usage examples, and contribution guidelines. If the code is part of a larger module, you should replace `your_module` with the actual module name when importing.
metapal 0.0.0
Experiments regarding LLM components
Requires Python: >=3.9

## PAL: Predictive Analysis & Laws for Neural Networks

Dismantling large language models parts to understand them better, with the hope to build better models.

#### Requirements
The code back-end is made with:
```text
numpy
torch
```
The visualization are made with:
```text
matplotlib
networkx
```

#### Research papers
- Vivien Cabannes, Charles Arnal, Wassim Bouaziz, Alice Yang, Francois Charton, Julia Kempe. *Iteration Head: A Mechanistic Study of Chain-of-Thought*, 2024. The codebase is in the folder `projects/cot`.

- Vivien Cabannes, Elvis Dohmatob, Alberto Bietti. *Scaling laws for associative memories*, in International Conference on Learning Representations (ICLR), 2024. The codebase is in the folder `projects/scaling_laws`.

- Vivien Cabannes, Berfin Simsek, Alberto Bietti. *Learning Associative Memories with Gradient Descent* in International Conference on Machine Learning (ICML), 2024. The codebase is in the folder `projects/gradient_descent`.

- In preparation. Codebase in `pruning`.
Show that learning appear by pruning circuits.

- In preparation. Codebase in `factorization`.
Empirical study of memorization capacity of MLPs and their abilities to leverage hidden factorization.

## Organization
The main resuable code is in the `src` folder.
The code for our different research streams is in the `projects` folder.
Other folders may include:
- `data`: contains data used in the experiments.
- `models`: saves models' weights.
- `launchers`: contains bash scripts to launch experiments.
- `notebooks`: used for exploration and visualization.
- `scripts`: contains python scripts to run experiments.
- `tests`: contains tests for the code.
- `tutorial`: contains tutorial notebooks to get started with LLMs' training.
FileNet 1.1.5
A Python package for creating 2D, 3D vizulization of directory and files with their hierarchical relations.

# FileNet
FileNet is a library to visulaize your directories and files with their hierarchical relation in 2D or 3D.
## Installation

Use ```Python >= 3.12```

```bash
pip install FileNet
```
or
```bash
pip3 install FileNet
```

## Usage

### Using 2D visualization :

- <b><mark>draw2D</mark></b> take two arguments, ```'start_path'``` and ```'theme'```. ```'start_path'``` is mandatory argument and ```'theme'``` has a default value of ```'4'``` which can be changed between ```1``` to ```4```.

```python
import FileNet

FileNet.draw2D(start_path = "Replace with complete Root Directory Path", theme = 4)
```

### Using 3D visualization :

- <b><mark>draw3D</mark></b> takes only one argument ```start_path```.

```python
import FileNet

FileNet.draw3D(start_path = "Replace with complete Root Directory Path")
```

## Upcoming Improvements

- Saving 3D Images.
- Enhanced Customization.