Count Parameters in Conv Layer

easyPROConvolutional Neural Networks (CNNs)Deep LearningDeep Learning 1

Problem Statement

Calculate the number of learnable parameters in a Conv2d layer.

Background

A convolutional layer's parameters consist of weights and biases:

For $K$ filters of size $F \times F$ applied to an input with $C_{in}$ channels
Weight parameters: $F \times F \times C_{in} \times K$
Bias parameters: $K$ (one per filter)

Your Task

Write a function count_conv_params(filter_size, in_channels, out_channels) returning the total parameter count (weights + biases).

Output Format

Return an integer representing the total number of learnable parameters.

Example

Input

filter_size=3, in_channels=1, out_channels=10

Output

Reasoning

Inputs: filter_size $F = 3$ means each filter is a $3 \times 3$ window; in_channels $C_{in} = 1$ means the input has a single channel; out_channels $K = 10$ means the layer learns 10 separate filters.
Weights per filter: a filter must cover the whole $F \times F$ window in every input channel, so it holds $3 \times 3 \times 1 = 9$ weights.
All weights: 10 independent filters give $9 \times 10 = 90$ weights.
Biases: each filter adds one scalar offset to its output map, so there are $K = 10$ biases, independent of $F$ and $C_{in}$ .
Output: $90 + 10 =$ 100, a single integer.
Notice that the weight count grows with the square of the filter size and linearly in both channel counts: with $C_{in} = 3$ and $K = 64$ the same $3 \times 3$ filters already need $27 \times 64 + 64 = 1792$ parameters. The image's height and width never enter the count.

Constraints

1 <= filter_size <= 11
1 <= in_channels <= 512
1 <= out_channels <= 512

Learn this in

Vision EncodersVLM Study Plan

More from Deep Learning 1

Early Stopping Checkeasy L2 Regularization Penaltyeasy Inverted Dropout Forwardmedium Binary Cross-Entropy Losseasy Momentum Update Stepmedium

Concept primerPREVIEW

Convolutional Layer Parameter Counting: Complete Guide

1. Background Knowledge

What is a Convolutional Layer?

A Conv2d layer is a fundamental building block in convolutional neural networks (CNNs) that applies learned filters to input feature maps to extract spatial features. The layer performs a sliding window operation where each filter computes element-wise products with local regions of the input.

Parameter Components

A Conv2d layer contains two types of learnable parameters:

Weight Parameters (Kernels):

Each filter has dimensions $F \times F \times C_{in}$ , where:
$F$ = filter/kernel size (height and width)
$C_{in}$ = number of input channels
With $K$ output filters (also called out_channels), total weights = $F \times F \times C_{in} \times K$

Bias Parameters:

One bias term per output filter
Total biases = $K$

Why Count Parameters?

Understanding parameter counts helps you:

Estimate model memory requirements
Compare model complexity
Identify computational bottlenecks
Optimize network architecture

2. Algorithm Approach

The solution is straightforward arithmetic—no complex algorithms needed. The parameter count formula is:

\text{Total Parameters} = (F^2 \times C_{in} \times K) + K

This can be factored as:

\text{Total Parameters} = K \times (F^2 \times C_{in} + 1)

The factored form shows that each of the $K$ filters contributes $(F^2 \times C_{in} + 1)$ parameters (weights plus its associated bias).

3. Step-by-Step Strategy

Step 1: Calculate weight parameters

Multiply filter dimensions: $F \times F$
Multiply by input channels: $F \times F \times C_{in}$
Multiply by number of filters: $F \times F \times C_{in} \times K$

Step 2: Calculate bias parameters

Count one bias per output filter: $K$

Step 3: Sum both components

Total = weights + biases

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results