PyCNN Framework

# Core framework
pip install git+https://github.com/77AXEL/PyCNN.git

# Optional: For CUDA support
pip install cupy-cuda11x  # or cupy-cuda12x for CUDA 12

# Optional: For Hugging Face datasets
pip install datasets

git clone git+https://github.com/77AXEL/PyCNN.git
cd pycnn.pycnn
pip install -e .

from pycnn.pycnn import PyCNN

# Create instance and check backend
model = PyCNN()
print(f"Backend: {'CUDA' if model.use_cuda else 'CPU'}")

import os
from pycnn.pycnn import PyCNN

# Create dataset directory structure
# dataset/
#   ├── cats/
#   ├── dogs/
#   └── birds/

def train_animal_classifier():
    model = PyCNN()
    
    # Configure for multi-class classification
    model.init(
        batch_size=16,
        layers=[512, 256, 128],
        learning_rate=0.0001,
        epochs=75
    )
    
    # Load local dataset
    model.dataset.local(
        path="./animal_dataset",
        max_image=500,
        image_size=128
    )
    
    # Train with visualization
    model.train_model(visualize=True, early_stop=15)
    
    # Save the model
    model.save_model("animal_classifier.bin")
    
    return model

if __name__ == "__main__":
    model = train_animal_classifier()

from pycnn.pycnn import PyCNN

def fine_tune_model(base_model_path, new_dataset_path):
    # Load pre-trained model
    model = PyCNN()
    model.load_model(base_model_path)
    
    # Reduce learning rate for fine-tuning
    model.learning_rate = 0.00001
    
    # Load new dataset
    model.dataset.local(
        path=new_dataset_path,
        max_image=200,
        image_size=model.image_size
    )
    
    # Fine-tune with fewer epochs
    model.epochs = 20
    model.train_model(visualize=True)
    
    return model

# Usage
fine_tuned_model = fine_tune_model(
    "base_model.bin",
    "./specialized_dataset"
)

import os
from collections import defaultdict
from pycnn.pycnn import PyCNN

def evaluate_model(model_path, test_directory):
    model = PyCNN()
    model.load_model(model_path)
    
    results = defaultdict(list)
    total_correct = 0
    total_images = 0
    
    # Process each class directory
    for class_name in os.listdir(test_directory):
        class_path = os.path.join(test_directory, class_name)
        if not os.path.isdir(class_path):
            continue
        
        class_correct = 0
        class_total = 0
        
        for image_file in os.listdir(class_path):
            if image_file.lower().endswith(('.jpg', '.png', '.jpeg')):
                image_path = os.path.join(class_path, image_file)
                
                predicted_class, confidence = model.predict(image_path)
                
                results[class_name].append({
                    'predicted': predicted_class,
                    'confidence': confidence,
                    'correct': predicted_class == class_name
                })
                
                if predicted_class == class_name:
                    class_correct += 1
                    total_correct += 1
                
                class_total += 1
                total_images += 1
        
        # Print class-specific accuracy
        class_accuracy = class_correct / class_total if class_total > 0 else 0
        print(f"{class_name}: {class_accuracy:.4f} ({class_correct}/{class_total})")
    
    # Overall accuracy
    overall_accuracy = total_correct / total_images
    print(f"Overall Accuracy: {overall_accuracy:.4f} ({total_correct}/{total_images})")
    
    return results, overall_accuracy

# Usage
results, accuracy = evaluate_model("my_model.bin", "./test_dataset")

from pycnn.pycnn import PyCNN

def train_on_cifar10():
    model = PyCNN()
    
    # Enable CUDA if available
    model.cuda(True)
    
    # Configure Adam optimizer
    model.adam(beta1=0.9, beta2=0.999)
    
    # Initialize with appropriate architecture for CIFAR-10
    model.init(
        batch_size=64,
        layers=[1024, 512, 256],
        learning_rate=0.001,
        epochs=100
    )
    
    # Load CIFAR-10 dataset
    model.dataset.hf(
        name="cifar10",
        max_image=2000,  # Limit for demo
        split="train",
        cached=True
    )
    
    # Train with early stopping
    model.train_model(visualize=True, early_stop=10)
    
    # Save the model
    model.save_model("cifar10_model.bin")
    
    return model

def train_on_custom_hf_dataset():
    model = PyCNN()
    
    # Try different popular datasets
    datasets_to_try = [
        "food101",
        "oxford-iiit-pet",
        "imagenet-1k"
    ]
    
    for dataset_name in datasets_to_try:
        try:
            print(f"Trying to load {dataset_name}...")
            model.dataset.hf(
                name=dataset_name,
                max_image=100,  # Small sample
                split="train"
            )
            print(f"Successfully loaded {dataset_name}")
            break
        except Exception as e:
            print(f"Failed to load {dataset_name}: {e}")
    
    return model

if __name__ == "__main__":
    # Train on CIFAR-10
    cifar_model = train_on_cifar10()

# CPU Requirements
Python: 3.7+
RAM: 4GB minimum, 8GB recommended
CPU: Multi-core processor (Intel/AMD)

# GPU Requirements (Optional)
NVIDIA GPU: GTX 1060 or better
CUDA: 11.0+ or 12.0+
VRAM: 4GB minimum, 8GB+ recommended

# Storage
Disk Space: 2GB for framework + dataset storage