semvec/pypi-packages huggingface dataset:
neuralx 1.0.6
a user-friendly Python package for neural networks.
Requires Python: >=3.11

# NeuralX

NeuralX is a Python package for creating neural networks with a wide range of features, including gradient checks, regularization, dropout, mini batch, and various optimization methods. This package is designed to be beginner-friendly, making it easy for users to understand neural network structures and build powerful models.

## Features

- **Gradient Checks:** Ensure the correctness of your neural network's gradients with built-in gradient check tools.
- **Regularization:** Apply L1 and L2 regularization to prevent overfitting and improve model robustness.
- **Dropout:** Implement dropout layers for more effective regularization and enhanced generalization.
- **Optimization Methods:** Choose from different optimization methods, including the popular Adam optimizer, to train your models efficiently.

## Installation

You can install NeuralX using `pip`:

```bash
pip install neuralx
```

## Usage

To get started with NeuralX, follow these steps:

1. Import the necessary modules from NeuralX.
2. Build your neural network architecture, specifying layers, activation functions, and other parameters.
3. Train your model on your dataset using the chosen optimization method.
4. Evaluate the model's performance using the provided tools, including the confusion matrix implementation.

Here's a simple example of how to use NeuralX to create a basic neural network:

```python
import neuralx as nx

# create layers description
layers = [
        (training_set.shape[0], None, None, None),
        (5, 'he', 'relu', 1),  # no_of_units, normalization_method, activation_function, dropout_keeping_probability
        (2, 'he', 'relu', 1),
        (1, 'he', 'sigmoid', 1)
    ]

# Create a neural network
model = nx.NeuralNetwork(layers)

# Train the model
model.train(
    training_set,
    training_set_labels,
    no_of_epochs=1000,
    optimization={'name': 'momentum', 'beta': 0.9},
    is_mini_batch=True,
    learning_rate=0.001
)

# Evaluate the model using the confusion matrix
cm = nx.ConfusionMatrix(model, test_set, test_set_labels)
print(cm)
print(cm.statistics())
```

## Contributing

We welcome contributions from the community. Feel free to submit bug reports, feature requests, or even pull requests. Together, we can make NeuralX even better!

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
load-simulator 0.1.1
A package to simulate operations load.
Requires Python: >=3.11,<4.0

# Load Simulator

## Overview

The Load Simulator is designed to simulate a variety of mathematical operations. It offers different levels of complexities and maintains an operation rate limiting feature. 

## Update

The Load Simulator package is now available on PyPI. You can easily install it using pip:

```bash
pip install load-simulator==0.1.1
```

## Modules

### `constants.py`

Contains constants and enumerations.

### `models.py`

Defines data models for operation details, a list of operations, and simulator configuration.

### `operation_executor.py`

Contains the `OperationExecutor` class to execute mathematical operations.

### `utilities.py`

Utility functions and context managers for logging and other functionalities.

### `load_simulator.py`

Contains the `LoadSimulator` class and `run_simulator` function for simulating the load for mathematical operations.

## Installation

### PyPI Method

1. **Install the package**

    ```bash
    pip install load-simulator==0.1.1
    ```

### Manual Method

1. **Clone the repository**

    ```bash
    git clone https://github.com/yourkin/load-simulator.git
    ```

2. **Navigate to the project directory**

    ```bash
    cd load_simulator
    ```

3. **Install dependencies using Poetry**

    ```bash
    poetry install
    ```

4. **Activate the virtual environment**

    ```bash
    poetry shell
    ```

---

## Usage

The `run_simulator` function can be imported to run the simulation:

```python
from load_simulator.load_simulator import run_simulator

run_simulator(
    seconds_to_run=10, 
    complexity="medium", 
    max_ops_per_sec=5
)
```

### Parameters for `run_simulator`

- `seconds_to_run`: Number of seconds to run the simulation.
- `complexity`: Complexity level for operations. Options are "easy", "medium", and "complicated".
- `max_ops_per_sec`: Maximum number of operations per second.

---

## Testing

Run the following command to execute the tests:

```bash
pytest
```

---

## Contributing

Fork the repository and make changes as you'd like. Pull requests are warmly welcome. 

For commit messages, conform to [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).

---

## License

Distributed under the MIT License. See `LICENSE` for more information.

---