cognixis 0.1.9
A PyTorch training loop utility
Requires Python: >=3.6

# Cognixis

**Cognixis** is a Python package that provides a set of utilities for building and training regression models using PyTorch. It includes functionality for creating a regression model using a Transformer Encoder, preparing data, and training the model on provided datasets. This package aims to streamline the process of implementing regression tasks with neural networks, focusing on ease of use and flexibility.

## Installation

To install **Cognixis**, use,

```
pip install cognixis
```
## Usage
Once installed, you can use the package to import the Regression class, its components (Encoder, DataGenerator, Trainer), and various utilities for model training and evaluation.
### Importing the Package
```
from cognixis import regression
```
### Creating a Regression Model
You can create a regression model by initializing the Encoder class:


##### Initialize Encoder for regression task
```
input_dim = 10  # Number of input features
output_dim = 1  # Number of output dimensions (single value)
model = regression.Encoder(input_dim, output_dim, d_model:int=32, nhead:int=2, num_layers:int=2, dim_feedforward:int=64, dropout:int=0.1)

```
##### Preparing the Data
You can prepare your dataset using the DataGenerator class, which will split the data into training and testing sets and load it into PyTorch DataLoader objects:

```
# Example numpy arrays for X (features) and y (targets)
import numpy as np

X = np.random.randn(1000, 10)  # 1000 samples, 10 features
y = np.random.randn(1000)      # 1000 target values

# Initialize DataGenerator
data_generator = regression.DataGenerator(X, y, test_size:int=0.2, shuffle:bool=True)

# Access DataLoaders for training and testing
train_loader = data_generator.train_loader
test_loader = data_generator.test_loader

```
### Training the Model
You can use the Trainer class to train your model on the dataset:

```
import torch.optim as optim
import torch.nn as nn

# Define loss function and optimizer
criterion = nn.MSELoss()  # Mean Squared Error Loss for regression
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Initialize the Trainer
trainer = regression.Trainer(model, optimizer, criterion, device="cpu")

# Train the model
train_losses = trainer.train(train_loader, num_epochs=50)

```
### Evaluating the Model
Once the model is trained, you can evaluate it on the test dataset:

```
# Evaluate the model
test_loss = trainer.evaluate(test_loader)
```
### Example: Full Workflow
Here is a complete example that shows how to train and evaluate a model:

```
from cognixis import regression
import numpy as np
import torch.optim as optim
import torch.nn as nn

# Generate random dataset
X = np.random.randn(1000, 10)
y = np.random.randn(1000)

# Initialize DataGenerator
data_generator = regression.DataGenerator(X, y)

# Create a model instance
input_dim = 10
output_dim = 1
model = regression.Encoder(input_dim, output_dim)

# Define loss function and optimizer
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Initialize Trainer
trainer = regression.Trainer(model, optimizer, criterion, device="cpu")

# Train the model
train_losses = trainer.train(data_generator.train_loader, num_epochs=50)

# Evaluate the model
test_loss = trainer.evaluate(data_generator.test_loader)
```
# Utilities
### Model Summary
You can get a summary of your model using the summary function:

```
from cognixis import summary

# Get model summary
model_summary = summary(model, input_shape=(1, 10), depth=2)  # Example input shape
print(model_summary)
```

Displaying the Source Code of the Train Function
You can also view the source code of the train function:

```
from cognixis import train_code

# Display the train function source code
train_code()

```
License
This project is licensed under the MIT License