Architectures / Computer Vision

🔗 ResNet Block

ResNet residual block with skip connections

Layers

Parameters

74.0K

Input

64 × 32 × 32

Output

64 × 32 × 32

Verifier

Clean

Every number on this page is computed from the graph by the same functions the app runs, not written by hand.

Open ResNet Block on the canvas Free, no account needed

When to pick it

Pick when you need a depth-friendly CV backbone. Stack 2–4 blocks for CIFAR, or use as the building block of ResNet-18/50 for ImageNet-scale.

Structure

9 layers. Output shapes are propagated from the input shape, batch dimension excluded.

	Layer	Type	Parameters	Output shape
1	Input	Input	shape=[64, 32, 32]	64 × 32 × 32
2	Conv2D_1	Conv2D	outChannels=64, kernelSize=3, stride=1	64 × 32 × 32
3	BatchNorm_1	BatchNorm		64 × 32 × 32
4	ReLU_1	ReLU		64 × 32 × 32
5	Conv2D_2	Conv2D	outChannels=64, kernelSize=3, stride=1	64 × 32 × 32
6	BatchNorm_2	BatchNorm		64 × 32 × 32
7	Add	Add		64 × 32 × 32
8	ReLU_2	ReLU		64 × 32 × 32
9	Output	Output		64 × 32 × 32

What the verifier says

The same 41 structural checks that run on every edit in the app, on this graph.

No finding. Shapes propagate end to end, every divisibility condition holds, and no advisory rule fires. See the checks.

The PyTorch it exports

Generated from the graph above.

# Architecture designed with Neurarch: https://neurarch.com
# PyTorch: compatible with Python 3.8+ and torch>=1.12
# Colab: pip install torch torchvision  (usually pre-installed)

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Tuple

class ResNetBlock(nn.Module):
    def __init__(self):
        super().__init__()

        self.conv2d_1 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
        self.batchNorm_1 = nn.BatchNorm2d(64)
        self.conv2d_2 = nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1)
        self.batchNorm_2 = nn.BatchNorm2d(64)

    def forward(self, x):
        # Input shape: [64,32,32]
        conv2d_nv2d_1 = self.conv2d_1(x)
        batch_norm_Norm_1 = self.batchNorm_1(conv2d_nv2d_1)
        relu_relu_1 = F.relu(batch_norm_Norm_1)
        conv2d_nv2d_2 = self.conv2d_2(relu_relu_1)
        batch_norm_Norm_2 = self.batchNorm_2(conv2d_nv2d_2)
        add_add_1 = batch_norm_Norm_2
        relu_relu_2 = F.relu(add_add_1)
        # Output
        return relu_relu_2


if __name__ == '__main__':
    model = ResNetBlock()
    model.eval()

    x = torch.randn(1, 64, 32, 32)  # (batch, channels, height, width)
    with torch.no_grad():
        output = model(x)

    print(f'Input  shape : {tuple(x.shape)}')
    print(f'Output shape : {tuple(output.shape)}')
    total = sum(p.numel() for p in model.parameters())
    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    print(f'Parameters   : {total:,} total, {trainable:,} trainable')

For agents

This architecture is machine-readable end to end. An agent can list the set, fetch this graph, edit it, and have the edit verified before any GPU time is spent.

Markdown twin Index JSON This graph as JSON MCP server POST /api/v1/check

Also in Computer Vision

🖼️ Simple CNN

Simple Convolutional Neural Network for image classification

9 layers · 804.6K

🩻 U-Net

Encoder-decoder with skip connections — Ronneberger et al

24 layers · 720.7K

👁️ ViT-B/16

Vision Transformer — patch embedding stem + 1 encoder block

13 layers · 8.45M

🪟 Swin-Tiny

Hierarchical vision transformer — shifted-window attention builds a feature pyramid for dense prediction

81 layers · 28.26M