How mic-dkfz/dynamic-network-architectures works
Project type and purpose
• This is an open-source Python library (“dynamic_network_architectures”) providing dynamically configurable PyTorch model architectures (ResNet, VGG, U-Net, Primus) that adapt to 1D/2D/3D inputs and variable channel counts.
File structure
• Top-level package:
• dynamic_network_architectures/
– architectures/
· abstract_arch.py (base class)
· resnet.py, vgg.py, unet.py, primus.py (concrete model classes)
– building_blocks/
· helper modules (eva.py, helper.py, patch_encode_decode.py…)
· core building blocks (plain_conv_encoder.py, residual.py, unet_decoder.py, etc.)
– initialization/
· weight_init.py (weight‐initialization strategies)
• setup.py drives installation.
• imgs/Logos holds documentation assets.
README for additional insights
• Supported architectures: ResNet (including bottleneck & CIFAR variants), VGG variants, U-Net (plain and residual).
• Regularization options: Stochastic Depth, Squeeze & Excitation, Final Layer Dropout.
• Target use: research/deployment in varying dimensionalities.
a. Main components:
– Client code / downstream application (training scripts, inference pipelines)
– dynamic_network_architectures package
• API layer (constructor/factory functions)
• Architectures module (abstract base + concrete models)
• Building blocks module (reusable layers & utilities)
• Initialization module (weight_init)
– External dependencies: PyTorch (torch.nn, torch.functional), NumPy, etc.
– Data sources (datasets, data loaders) and training loop (optimizers, schedulers) can be shown as external.
b. Relationships and interactions:
– Client code → imports API classes/factories → creates an instance of AbstractArch subclass (e.g., ResNet3D)
– Model constructor calls building_blocks submodules to assemble layers
– After construction, initialization.weight_init is applied
– The resulting torch.nn.Module flows into training/inference, leveraging PyTorch’s engine, optimizers, and data loaders
c. Architectural patterns & design principles:
– Modular layering: clear separation between “architecture definitions” and “building blocks”
– Inheritance/polymorphism: abstract_arch defines common interface, concrete classes extend it
– Configuration-driven: number of dimensions, channels, depth, regularization toggles
– Single Responsibility: weight initialization lives in its own subpackage
d. Key technologies/frameworks:
– Python package structure, setuptools (setup.py)
– PyTorch (torch.nn.Module, layers, dropout, etc.)
– Custom regularization techniques (Stochastic Depth, SE blocks)
Elements
– Clear, descriptive labels for each package/subpackage and major class (e.g., AbstractArch, ResNet, UnetDecoder)
• import/call relationships (API → architectures → building_blocks → initialization)
• data flow (input data → model → output predictions)
• Modules (blue rectangles)
• External dependencies (green clouds)
Detailed capture of architectural elements
• API/factory layer
• Abstract architecture interface
• Concrete models (ResNet, VGG, U-Net, Primus)
• Building blocks (plain conv, residual, patch encoder/decoder, regularization helpers)
• Initialization routines
• External PyTorch engine
• User application/entry point