stouputils 1.14.0__py3-none-any.whl

stouputils/data_science/models/keras/all.py

@@ -0,0 +1,38 @@
+
+# Imports
+from .convnext import ConvNeXtBase, ConvNeXtLarge, ConvNeXtSmall, ConvNeXtTiny, ConvNeXtXLarge
+from .densenet import DenseNet121, DenseNet169, DenseNet201
+from .efficientnet import EfficientNetB0, EfficientNetV2B0, EfficientNetV2L, EfficientNetV2M, EfficientNetV2S
+from .mobilenet import MobileNet, MobileNetV2, MobileNetV3Large, MobileNetV3Small
+from .resnet import ResNet50V2, ResNet101V2, ResNet152V2
+from .squeezenet import SqueezeNet
+from .vgg import VGG16, VGG19
+from .xception import Xception
+
+__all__ = [
+    "VGG16",
+    "VGG19",
+    "ConvNeXtBase",
+    "ConvNeXtLarge",
+    "ConvNeXtSmall",
+    "ConvNeXtTiny",
+    "ConvNeXtXLarge",
+    "DenseNet121",
+    "DenseNet169",
+    "DenseNet201",
+    "EfficientNetB0",
+    "EfficientNetV2B0",
+    "EfficientNetV2L",
+    "EfficientNetV2M",
+    "EfficientNetV2S",
+    "MobileNet",
+    "MobileNetV2",
+    "MobileNetV3Large",
+    "MobileNetV3Small",
+    "ResNet50V2",
+    "ResNet101V2",
+    "ResNet152V2",
+    "SqueezeNet",
+    "Xception",
+]
+

stouputils/data_science/models/keras/convnext.py

@@ -0,0 +1,62 @@
+""" ConvNeXt models implementation.
+
+This module provides wrapper classes for the ConvNeXt family of models from the Keras applications.
+ConvNeXt models are a family of pure convolutional networks that match or outperform
+Vision Transformers (ViTs) while maintaining the simplicity and efficiency of CNNs.
+
+Available models:
+
+- ConvNeXtTiny: Smallest variant with fewer parameters for resource-constrained environments
+- ConvNeXtSmall: Compact model balancing performance and size
+- ConvNeXtBase: Standard model with good performance for general use cases
+- ConvNeXtLarge: Larger model with higher capacity for complex tasks
+- ConvNeXtXLarge: Largest variant with maximum capacity for demanding applications
+
+All models support transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from keras.models import Model
+from keras.src.applications.convnext import ConvNeXtBase as ConvNeXtBase_keras
+from keras.src.applications.convnext import ConvNeXtLarge as ConvNeXtLarge_keras
+from keras.src.applications.convnext import ConvNeXtSmall as ConvNeXtSmall_keras
+from keras.src.applications.convnext import ConvNeXtTiny as ConvNeXtTiny_keras
+from keras.src.applications.convnext import ConvNeXtXLarge as ConvNeXtXLarge_keras
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+
+# Classes
+class ConvNeXtTiny(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ConvNeXtTiny_keras(include_top=False, classes=self.num_classes)
+
+class ConvNeXtSmall(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ConvNeXtSmall_keras(include_top=False, classes=self.num_classes)
+
+class ConvNeXtBase(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ConvNeXtBase_keras(include_top=False, classes=self.num_classes)
+
+class ConvNeXtLarge(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ConvNeXtLarge_keras(include_top=False, classes=self.num_classes)
+
+class ConvNeXtXLarge(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ConvNeXtXLarge_keras(include_top=False, classes=self.num_classes)
+
+
+# Docstrings
+for model in [ConvNeXtTiny, ConvNeXtSmall, ConvNeXtBase, ConvNeXtLarge, ConvNeXtXLarge]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras/densenet.py

@@ -0,0 +1,50 @@
+""" DenseNet models implementation.
+
+This module provides wrapper classes for the DenseNet family of models from the Keras applications.
+DenseNet models utilize dense connections between layers, where each layer obtains additional inputs
+from all preceding layers and passes on its feature-maps to all subsequent layers.
+
+Available models:
+
+- DenseNet121: Smallest variant with 121 layers
+- DenseNet169: Medium-sized variant with 169 layers
+- DenseNet201: Largest variant with 201 layers
+
+All models support transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from keras.models import Model
+from keras.src.applications.densenet import DenseNet121 as DenseNet121_keras
+from keras.src.applications.densenet import DenseNet169 as DenseNet169_keras
+from keras.src.applications.densenet import DenseNet201 as DenseNet201_keras
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+
+# Classes
+class DenseNet121(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return DenseNet121_keras(include_top=False, classes=self.num_classes)
+
+class DenseNet169(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return DenseNet169_keras(include_top=False, classes=self.num_classes)
+
+class DenseNet201(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return DenseNet201_keras(include_top=False, classes=self.num_classes)
+
+
+# Docstrings
+for model in [DenseNet121, DenseNet169, DenseNet201]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras/efficientnet.py

@@ -0,0 +1,60 @@
+""" EfficientNetV2 models implementation.
+
+This module provides wrapper classes for the EfficientNetV2 family of models from the Keras applications.
+EfficientNetV2 models are a family of convolutional neural networks that achieve better
+parameter efficiency and faster training speed compared to prior models.
+
+Available models:
+
+- EfficientNetV2M: Medium-sized variant balancing performance and computational cost
+- EfficientNetV2L: Large variant with higher capacity for complex tasks
+
+All models support transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from keras.models import Model
+from keras.src.applications.efficientnet import EfficientNetB0 as EfficientNetB0_keras
+from keras.src.applications.efficientnet_v2 import EfficientNetV2B0 as EfficientNetV2B0_keras
+from keras.src.applications.efficientnet_v2 import EfficientNetV2L as EfficientNetV2L_keras
+from keras.src.applications.efficientnet_v2 import EfficientNetV2M as EfficientNetV2M_keras
+from keras.src.applications.efficientnet_v2 import EfficientNetV2S as EfficientNetV2S_keras
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+
+# Classes
+class EfficientNetV2M(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return EfficientNetV2M_keras(include_top=False, classes=self.num_classes)
+
+class EfficientNetV2L(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return EfficientNetV2L_keras(include_top=False, classes=self.num_classes)
+
+class EfficientNetV2B0(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return EfficientNetV2B0_keras(include_top=False, classes=self.num_classes)
+
+class EfficientNetV2S(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return EfficientNetV2S_keras(include_top=False, classes=self.num_classes)
+
+# Classes for original EfficientNet models
+class EfficientNetB0(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return EfficientNetB0_keras(include_top=False, classes=self.num_classes)
+
+
+# Docstrings
+for model in [EfficientNetV2M, EfficientNetV2L, EfficientNetV2B0, EfficientNetV2S, EfficientNetB0]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras/mobilenet.py

@@ -0,0 +1,56 @@
+""" MobileNet models implementation.
+
+This module provides wrapper classes for the MobileNet family of models from the Keras applications.
+MobileNet models are designed for mobile and embedded vision applications,
+offering efficient architectures that deliver high accuracy with low computational requirements.
+
+Available models:
+
+- MobileNet: Original MobileNet architecture using depthwise separable convolutions
+- MobileNetV2: Lightweight architecture using inverted residuals and linear bottlenecks
+- MobileNetV3Small: Compact variant of MobileNetV3 optimized for mobile devices
+- MobileNetV3Large: Larger variant of MobileNetV3 with higher capacity
+
+All models support transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from keras.models import Model
+from keras.src.applications.mobilenet import MobileNet as MobileNet_keras
+from keras.src.applications.mobilenet_v2 import MobileNetV2 as MobileNetV2_keras
+from keras.src.applications.mobilenet_v3 import MobileNetV3Large as MobileNetV3Large_keras
+from keras.src.applications.mobilenet_v3 import MobileNetV3Small as MobileNetV3Small_keras
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+
+# Classes
+class MobileNet(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return MobileNet_keras(include_top=False, classes=self.num_classes)
+
+class MobileNetV2(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return MobileNetV2_keras(include_top=False, classes=self.num_classes)
+
+class MobileNetV3Small(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return MobileNetV3Small_keras(include_top=False, classes=self.num_classes)
+
+class MobileNetV3Large(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return MobileNetV3Large_keras(include_top=False, classes=self.num_classes)
+
+
+# Docstrings
+for model in [MobileNet, MobileNetV2, MobileNetV3Small, MobileNetV3Large]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras/resnet.py

@@ -0,0 +1,52 @@
+""" ResNet models implementation.
+
+This module provides wrapper classes for the ResNet family of models from the Keras applications.
+It includes both ResNetV2 models with pre-activation residual blocks and ResNetRS
+(ResNet with Revisited Scaling) models that offer improved performance
+through various scaling techniques.
+
+Available models:
+
+- ResNetV2 family: Improved ResNet architectures with pre-activation blocks
+    - ResNet50V2
+    - ResNet101V2
+    - ResNet152V2
+
+All models support transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from keras.models import Model
+from keras.src.applications.resnet_v2 import ResNet50V2 as ResNet50V2_keras
+from keras.src.applications.resnet_v2 import ResNet101V2 as ResNet101V2_keras
+from keras.src.applications.resnet_v2 import ResNet152V2 as ResNet152V2_keras
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+
+# Classes
+class ResNet50V2(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ResNet50V2_keras(include_top=False, classes=self.num_classes)
+
+class ResNet101V2(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ResNet101V2_keras(include_top=False, classes=self.num_classes)
+
+class ResNet152V2(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return ResNet152V2_keras(include_top=False, classes=self.num_classes)
+
+
+# Docstrings
+for model in [ResNet50V2, ResNet101V2, ResNet152V2]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras/squeezenet.py

@@ -0,0 +1,233 @@
+""" SqueezeNet model implementation.
+
+This module provides a wrapper class for the SqueezeNet model, a lightweight CNN architecture
+that achieves AlexNet-level accuracy with 50x fewer parameters and a model size of less than 0.5MB.
+SqueezeNet uses "fire modules" consisting of a squeeze layer with 1x1 filters followed by an
+expand layer with a mix of 1x1 and 3x3 convolution filters.
+
+Available models:
+- SqueezeNet: Compact model with excellent performance-to-parameter ratio
+
+The model supports transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownArgumentType=false
+# pyright: reportUnknownMemberType=false
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from typing import Any
+
+from keras import backend
+from keras.layers import (
+	Activation,
+	Convolution2D,
+	Dropout,
+	GlobalAveragePooling2D,
+	GlobalMaxPooling2D,
+	Input,
+	MaxPooling2D,
+	concatenate,
+)
+from keras.models import Model
+from keras.utils import get_file, get_source_inputs
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+# Constants
+SQ1X1: str = "squeeze1x1"
+
+WEIGHTS_PATH = "https://github.com/rcmalli/keras-squeezenet/releases/download/v1.0/squeezenet_weights_tf_dim_ordering_tf_kernels.h5"
+WEIGHTS_PATH_NO_TOP = "https://github.com/rcmalli/keras-squeezenet/releases/download/v1.0/squeezenet_weights_tf_dim_ordering_tf_kernels_notop.h5"
+
+
+# Modular function for Fire Node
+def fire_module(x: Any, fire_id: int, squeeze: int = 16, expand: int = 64):
+	""" Create a fire module with specified parameters.
+
+	Args:
+		x           (Tensor):         Input tensor
+		fire_id     (int):            ID for the fire module
+		squeeze     (int):            Number of filters for squeeze layer
+		expand      (int):            Number of filters for expand layers
+
+	Returns:
+		Tensor:                Output tensor from the fire module
+	"""
+	s_id: str = f"fire{fire_id}"
+
+	if backend.image_data_format() == "channels_first":
+		channel_axis: int = 1
+	else:
+		channel_axis: int = 3
+
+	x = Convolution2D(squeeze, (1, 1), padding="valid", name=f"{s_id}/squeeze1x1")(x)
+	x = Activation("relu", name=f"{s_id}/relu_squeeze1x1")(x)
+
+	left = Convolution2D(expand, (1, 1), padding="valid", name=f"{s_id}/expand1x1")(x)
+	left = Activation("relu", name=f"{s_id}/relu_expand1x1")(left)
+
+	right = Convolution2D(expand, (3, 3), padding="same", name=f"{s_id}/expand3x3")(x)
+	right = Activation("relu", name=f"{s_id}/relu_expand3x3")(right)
+
+	x = concatenate([left, right], axis=channel_axis, name=f"{s_id}/concat")
+	return x
+
+
+# Original SqueezeNet from paper
+def SqueezeNet_keras(  # noqa: N802
+	include_top: bool = True,
+	weights: str = "imagenet",
+	input_tensor: Any = None,
+	input_shape: tuple[Any, ...] | None = None,
+	pooling: str | None = None,
+	classes: int = 1000
+) -> Model:
+	""" Instantiates the SqueezeNet architecture.
+
+	Args:
+		include_top            (bool):           Whether to include the fully-connected layer at the top
+		weights                (str):            One of `None` or 'imagenet'
+		input_tensor           (Tensor):         Optional Keras tensor as input
+		input_shape            (tuple):          Optional shape tuple
+		pooling                (str):            Optional pooling mode for feature extraction
+		classes                (int):            Number of classes to classify images into
+
+	Returns:
+		Model:                 A Keras model instance
+	"""
+
+	if weights not in {'imagenet', None}:
+		raise ValueError(
+			"The `weights` argument should be either `None` (random initialization) "
+			"or `imagenet` (pre-training on ImageNet)."
+		)
+
+	if include_top and weights == 'imagenet' and classes != 1000:
+		raise ValueError(
+			"If using `weights` as imagenet with `include_top` as true, `classes` should be 1000"
+		)
+
+	# Manually handle input shape logic instead of _obtain_input_shape
+	default_size: int = 227
+	min_size: int = 48
+	if backend.image_data_format() == 'channels_first':
+		default_shape: tuple[int, int, int] = (3, default_size, default_size)
+		if weights == 'imagenet' and include_top and input_shape is not None and input_shape[0] != 3:
+			raise ValueError(
+				"When specifying `input_shape` and loading 'imagenet' weights, 'channels_first' input_shape "
+				"should be (3, H, W)."
+			)
+	else: # channels_last
+		default_shape = (default_size, default_size, 3)
+		if weights == 'imagenet' and include_top and input_shape is not None and input_shape[2] != 3:
+			raise ValueError(
+				"When specifying `input_shape` and loading 'imagenet' weights, 'channels_last' input_shape "
+				"should be (H, W, 3)."
+			)
+
+	if input_shape is None:
+		input_shape = default_shape
+	else:
+		# Basic validation
+		if len(input_shape) != 3:
+			raise ValueError("`input_shape` must be a tuple of three integers.")
+		if backend.image_data_format() == 'channels_first':
+			if input_shape[1] is not None and input_shape[1] < min_size:
+				raise ValueError(f"Input size must be at least {min_size}x{min_size}, got `input_shape=`{input_shape}")
+			if input_shape[2] is not None and input_shape[2] < min_size:
+				raise ValueError(f"Input size must be at least {min_size}x{min_size}, got `input_shape=`{input_shape}")
+		else: # channels_last
+			if input_shape[0] is not None and input_shape[0] < min_size:
+				raise ValueError(f"Input size must be at least {min_size}x{min_size}, got `input_shape=`{input_shape}")
+			if input_shape[1] is not None and input_shape[1] < min_size:
+				raise ValueError(f"Input size must be at least {min_size}x{min_size}, got `input_shape=`{input_shape}")
+
+	# Handle input tensor
+	if input_tensor is None:
+		img_input = Input(shape=input_shape)
+	else:
+		if not backend.is_keras_tensor(input_tensor):
+			img_input = Input(tensor=input_tensor, shape=input_shape)
+		else:
+			img_input = input_tensor
+
+	x = Convolution2D(64, (3, 3), strides=(2, 2), padding='valid', name='conv1')(img_input)
+	x = Activation('relu', name='relu_conv1')(x)
+	x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool1')(x)
+
+	x = fire_module(x, fire_id=2, squeeze=16, expand=64)
+	x = fire_module(x, fire_id=3, squeeze=16, expand=64)
+	x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool3')(x)
+
+	x = fire_module(x, fire_id=4, squeeze=32, expand=128)
+	x = fire_module(x, fire_id=5, squeeze=32, expand=128)
+	x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x)
+
+	x = fire_module(x, fire_id=6, squeeze=48, expand=192)
+	x = fire_module(x, fire_id=7, squeeze=48, expand=192)
+	x = fire_module(x, fire_id=8, squeeze=64, expand=256)
+	x = fire_module(x, fire_id=9, squeeze=64, expand=256)
+
+	if include_top:
+		# It's not obvious where to cut the network...
+		# Could do the 8th or 9th layer... some work recommends cutting earlier layers.
+
+		x = Dropout(0.5, name='drop9')(x)
+
+		x = Convolution2D(classes, (1, 1), padding='valid', name='conv10')(x)
+		x = Activation('relu', name='relu_conv10')(x)
+		x = GlobalAveragePooling2D()(x)
+		x = Activation('softmax', name='loss')(x)
+	else:
+		if pooling == 'avg':
+			x = GlobalAveragePooling2D()(x)
+		elif pooling == 'max':
+			x = GlobalMaxPooling2D()(x)
+		elif pooling is None:
+			pass
+		else:
+			raise ValueError("Unknown argument for 'pooling'=" + pooling)
+
+	# Ensure that the model takes into account
+	# any potential predecessors of `input_tensor`.
+	if input_tensor is not None:
+		inputs = get_source_inputs(input_tensor)
+	else:
+		inputs = img_input
+
+	model = Model(inputs, x, name='squeezenet')
+
+	# load weights
+	if weights == 'imagenet':
+		if include_top:
+			weights_path = get_file('squeezenet_weights_tf_dim_ordering_tf_kernels.h5',
+									WEIGHTS_PATH,
+									cache_subdir='models')
+		else:
+			weights_path = get_file('squeezenet_weights_tf_dim_ordering_tf_kernels_notop.h5',
+									WEIGHTS_PATH_NO_TOP,
+									cache_subdir='models')
+
+		model.load_weights(weights_path)
+	return model
+
+
+# Classes
+class SqueezeNet(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return SqueezeNet_keras(
+			include_top=False, classes=self.num_classes, input_shape=(224, 224, 3)
+		)
+
+
+# Docstrings
+for model in [SqueezeNet]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras/vgg.py

@@ -0,0 +1,42 @@
+""" VGG models implementation.
+
+This module provides wrapper classes for the VGG family of models from the Keras applications.
+VGG models are characterized by their simplicity, using only 3x3 convolutional layers
+stacked on top of each other with increasing depth.
+
+Available models:
+- VGG16: 16-layer model with 13 convolutional layers and 3 fully connected layers
+- VGG19: 19-layer model with 16 convolutional layers and 3 fully connected layers
+
+Both models support transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from keras.models import Model
+from keras.src.applications.vgg16 import VGG16 as VGG16_keras  # noqa: N811
+from keras.src.applications.vgg19 import VGG19 as VGG19_keras  # noqa: N811
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+
+# Base class
+class VGG19(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return VGG19_keras(include_top=False, classes=self.num_classes)
+class VGG16(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return VGG16_keras(include_top=False, classes=self.num_classes)
+
+
+# Docstrings
+for model in [VGG19, VGG16]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras/xception.py

@@ -0,0 +1,38 @@
+""" Xception model implementation.
+
+This module provides a wrapper class for the Xception model, a deep convolutional neural network
+designed for efficient image classification. Xception uses depthwise separable convolutions,
+which significantly reduce the number of parameters and computational complexity compared to
+standard convolutional layers.
+
+Available models:
+- Xception: The standard Xception model
+
+The model supports transfer learning from ImageNet pre-trained weights.
+"""
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+from __future__ import annotations
+
+from keras.models import Model
+from keras.src.applications.xception import Xception as Xception_keras
+
+from ....decorators import simple_cache
+from ..base_keras import BaseKeras
+from ..model_interface import CLASS_ROUTINE_DOCSTRING, MODEL_DOCSTRING
+
+
+# Base class
+class Xception(BaseKeras):
+	def _get_base_model(self) -> Model:
+		return Xception_keras(include_top=False, classes=self.num_classes)
+
+
+# Docstrings
+for model in [Xception]:
+	model.__doc__ = MODEL_DOCSTRING.format(model=model.__name__)
+	model.class_routine = simple_cache(model.class_routine)
+	model.class_routine.__doc__ = CLASS_ROUTINE_DOCSTRING.format(model=model.__name__)
+

stouputils/data_science/models/keras_utils/callbacks/__init__.py

@@ -0,0 +1,20 @@
+""" Custom callbacks for Keras models.
+
+Features:
+
+- Learning rate finder callback for finding the optimal learning rate
+- Warmup scheduler callback for warmup training
+- Progressive unfreezing callback for unfreezing layers during training (incompatible with model.fit(), need a custom training loop)
+- Tqdm progress bar callback for better training visualization
+- Model checkpoint callback that only starts checkpointing after a given number of epochs
+"""
+
+# Imports
+from .colored_progress_bar import ColoredProgressBar
+from .learning_rate_finder import LearningRateFinder
+from .model_checkpoint_v2 import ModelCheckpointV2
+from .progressive_unfreezing import ProgressiveUnfreezing
+from .warmup_scheduler import WarmupScheduler
+
+__all__ = ["ColoredProgressBar", "LearningRateFinder", "ModelCheckpointV2", "ProgressiveUnfreezing", "WarmupScheduler"]
+