semvec/pypi-packages huggingface dataset:
kerdosai 0.1.1
Universal LLM Training Agent
Requires Python: >=3.8

# KerdosAI - Universal LLM Training Agent

KerdosAI is a versatile AI agent designed to be seamlessly integrated with any Large Language Model (LLM). It provides a comprehensive solution for companies to train, customize, and deploy LLMs with their proprietary data while maintaining full control over their infrastructure.

## Key Features

- **Universal LLM Integration**: Compatible with any existing LLM architecture
- **Custom Training Pipeline**: Streamlined process for training with company-specific data
- **Infrastructure Agnostic**: Can be deployed in any cloud or on-premise environment
- **Data Privacy**: Built-in mechanisms to ensure data security and privacy
- **Scalable Architecture**: Designed for enterprise-scale deployments

## Installation

```bash
pip install kerdosai
```

## Quick Start

```python
from kerdosai import KerdosAgent

# Initialize the agent
agent = KerdosAgent(
    base_model="your-llm-model",
    training_data="path/to/your/data"
)

# Train the model
agent.train()

# Deploy the model
agent.deploy()
```

## Requirements

- Python 3.8+
- PyTorch 2.0+
- Transformers 4.30+
- CUDA-compatible GPU (recommended for training)

## Features

### Training
- Data preprocessing and validation
- Model adaptation
- Fine-tuning
- Evaluation and validation

### Deployment
- REST API support
- Docker container support
- Kubernetes cluster support
- Cloud platform integration (AWS, Azure, Google Cloud)

## Performance

- Training time varies based on dataset size and hardware
- Inference latency: < 100ms on standard GPU
- Memory requirements: 8GB minimum, 16GB recommended

## Limitations

- Requires significant computational resources for training
- Training time increases with dataset size
- May require fine-tuning for specific use cases

## Documentation

For detailed documentation, please visit our [documentation page](https://kerdos.in/docs).

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Support

For support, please email support@kerdos.in or visit our [support page](https://kerdos.in/contact).
litecnn 1.0.3
LiteCNN: Intuitive Python library for creating, training and visualizing convolutional neural networks. Features simplified CNN layer definition, automated training workflows, model visualization, and seamless Keras-to-ONNX conversion. Includes 15 pre-configured popular models for immediate use.
Keywords: deep-learning, cnn, neural-networks, tensorflow, keras, machine-learning, ai, computer-vision, image-processing, model-training, visualization, easy-to-use, python, convolutional-networks


# LiteCNN - Easy Creating and Visualizing CNN Model

LiteCNN is a Python library designed to simplify the creation, training, and visualization of convolutional neural networks (CNNs). It provides an intuitive interface for deep learning enthusiasts and developers who want to work with CNN models without the complexity often associated with neural network frameworks.


## Features

- Straightforward definition of CNN layers with intuitive syntax
- Streamlined training and model evolution capabilities
- Visual representation of model architecture
- 15 pre-configured popular Keras application models ready for immediate use
- Seamless conversion of Keras models to ONNX format



## Documentation

[Documentation](https://github.com/Gabrli/LiteCNN--docs)



## Authors

- [@Gabrli](https://github.com/Gabrli)


## Tech Stack

**Languages:** Python
  
**Libraries:** Tensorflow, Matplotlib, Numpy, OpenCv

## License

[MIT](https://choosealicense.com/licenses/mit/)


## FAQ

#### what are the advantages ?

- Very easy and comfortable syntax
- Full control for developer
- Automatic data preparation and visualization processes
- Compatibility of model: option to convert to onnx type file.

#### What functionalities are under construction?

- Presets for popular models
- Exporter and Converter for files with models
- Special Visualizer to display training process


## Contributing

Contributions are always welcome!

See `contributing.md` for ways to get started.

Please adhere to this project's `code of conduct`.


## Basic Usage/Example

```python
from litecnn.core import LiteCNN
from litecnn.visualizer import TrainingVisualizer
import os
from tensorflow.keras.datasets import cifar10

class_names = ['car', 'plane', 'cat', 'dog', 'bird', 'deer', 'horse', 'frog', 'ship', 'truck']

(x_train, y_train), (x_test, y_test) = cifar10.load_data()

my_file = os.path.join(os.path.dirname(__file__), 'car.jpg')

x_train = x_train[:2000]
y_train = y_train[:2000]
x_test = x_test[:400]
y_test = y_test[:400]
x_train = x_train / 255
x_test = x_test / 255

model = LiteCNN()
model.add_conv(32, 3)
model.add_max_pool(2)
model.add_conv(64, 3)
model.add_max_pool(2)
model.add_conv(128, 3)
model.add_max_pool(2)
model.add_flatten()
model.add_dense(10, activation='softmax')
model.compile()
history = model.train(x_train, y_train, x_test, y_test, epochs=5)
prediction = model.predict(my_file)

visualizer = TrainingVisualizer()
visualizer.plot_training(history)
```