CNN - Convolutional Neural Networks

# CNN Model for Gauge Classification
import tensorflow as tf
from tensorflow.keras.applications import EfficientNetB4
from tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout

def create_gauge_classifier(num_classes=50, img_size=380):
    # Load pre-trained EfficientNet-B4
    base_model = EfficientNetB4(
        input_shape=(img_size, img_size, 3),
        include_top=False,
        weights='imagenet'
    )
    
    # Freeze base model initially
    base_model.trainable = False
    
    # Add custom classification head
    model = tf.keras.Sequential([
        base_model,
        GlobalAveragePooling2D(),
        Dropout(0.3),
        Dense(512, activation='relu'),
        Dropout(0.2),
        Dense(num_classes, activation='softmax', name='classification'),
        
        # Regression head for value prediction
        Dense(256, activation='relu'),
        Dense(1, activation='sigmoid', name='value_regression')
    ])
    
    return model

# Training configuration
model = create_gauge_classifier()
model.compile(
    optimizer=tf.keras.optimizers.AdamW(learning_rate=1e-3),
    loss={
        'classification': 'sparse_categorical_crossentropy',
        'value_regression': 'mse'
    },
    metrics={
        'classification': 'accuracy',
        'value_regression': 'mae'
    }
)

# Data augmentation
augment = tf.keras.Sequential([
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.RandomBrightness(0.2),
    tf.keras.layers.RandomContrast(0.1),
    tf.keras.layers.RandomFlip("horizontal")
])

print("Model ready for training!")

# PyTorch CNN for Gauge Reading
import torch
import torch.nn as nn
from torchvision.models import efficientnet_b4

class GaugeReader(nn.Module):
    def __init__(self, num_classes=50, dropout_rate=0.3):
        super(GaugeReader, self).__init__()
        
        # Load pre-trained EfficientNet
        self.backbone = efficientnet_b4(pretrained=True)
        
        # Replace classifier
        in_features = self.backbone.classifier[1].in_features
        self.backbone.classifier = nn.Identity()
        
        # Custom heads
        self.classifier = nn.Sequential(
            nn.Dropout(dropout_rate),
            nn.Linear(in_features, 512),
            nn.ReLU(),
            nn.Dropout(dropout_rate/2),
            nn.Linear(512, num_classes)
        )
        
        self.regressor = nn.Sequential(
            nn.Dropout(dropout_rate),
            nn.Linear(in_features, 256),
            nn.ReLU(),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        features = self.backbone(x)
        classification = self.classifier(features)
        value = self.regressor(features)
        return classification, value

# Usage example
model = GaugeReader(num_classes=50)
criterion_cls = nn.CrossEntropyLoss()
criterion_reg = nn.MSELoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)

# Move to GPU if available
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)

print(f"Model on {device}, ready for training!")