blank

Critical Technical Practice for Responsible Medical Image Analysis

2026-07-13T10:00:00+00:00

Critical Technical Practice for Responsible Medical Image Analysis

By Weina Jin (weinaj@sfu.ca)

2026-07-13

TL;DR: Critical technical practice can safeguard our good intentions in medical image analysis against distortion and manipulation from unscientific and unethical assumptions and values, analogous to strengthening our technical immune systems.

1-min promotional video for this tutorial, recorded for MICCAI Educational Challenge 2026.

Abstract: In this article, I motivate the need for critical technical practice using my research experience in conducting AI technical research on explainable AI for medical image analysis. I summarize the different levels of approaches to conduct critical technical practice, and propose ways forward to collectively conduct critical technical practice to make our techniques more scientifically rigorous, ethical, and responsible.

Table of contents

Nested cross validation explained

2018-08-25T17:00:00+00:00

It is natural to come up with cross-validation (CV) when the dataset is relatively small. The basic idea of cross-validation is to train a new model on a subset of data, and validate the trained model on the remaining data. Repeat the process multiple times and average the validation error, we get an estimate of the generalization performance of the model. Since the test data is untouched during each training, we kind of use the whole dataset to estimate the generalization error, which will reduce the bias. However, since it will train multiple models instead of one, the drawback of CV is that quite computational expensive.

It is necessary to make it clear that, the aim of CV is not to get one or multiple trained models for inference, but to estimate an unbiased generalization performance. This may be quite confusing at the beginning, since the outcome of the common train/validate/test split approach are a trained model with tuned hyperparameter (on train/validate set), plus a generalization estimation of performance (on trainval/test set).

Why bother to have a validation set? Why not just use the test set for the two tasks of hyperparameter tuning(model selection) and estimation at once? The problem is, if we use the test set multiple times for different trained models, during our selection of the optimal model, the test set actually “leaks” information, and thus unpure. When we later apply the model to real-world data, the model will probably have a larger error than on the test set. That being said, when using the test set for both model selection and estimation, it tends to overfit the test data, and the estimation leads to an optimistic bias.

(A side note: if we match the test set in above to the test set of many benchmark datasets, we will find the machine learning community is actually overfitting the benchmark. Since now we are using the results on the benchmark test dataset to select the best model, we are again mixing the model selection and performance estimation together by using the two tasks on the same benchmark test set.)

When doing one round CV to evaluate the performance of different models, and select the best model based on the CV results, it is similar to the above case of using test set both for model selection and estimation. Thus, when we want to perform model selection and generalization error estimation, we have to separate the two tasks by using two test set for each task. That’s why we have the validation and test set, and the same version in CV is called nested or two-round cross validation.

The nested CV has an inner loop CV nested in an outer CV. The inner loop is responsible for model selection/hyperparameter tuning (similar to validation set), while the outer loop is for error estimation (test set).

Nested cross validation. Image source: Cross Validated

The algorithm is as follows (adapted from Hastie et. al [1] and this post):

The nested cross validation

Divide the dataset into \(K\) cross-validation folds at random.
For each fold \(k=1,2,...,K\): outer loop for evaluation of the model with selected hyperparameter

2.1 Let test be fold \(k\)

2.2 Let trainval be all the data except those in fold \(k\)

2.3 Randomly split trainval into \(L\) folds

2.4 For each fold \(l= 1,2,...L\): inner loop for hyperparameter tuning

2.4.1 Let val be fold \(l\)

2.4.2 Let train be all the data except those in test or val

2.4.3 Train with each hyperparameter on train, and evaluate it on val. Keep track of the performance metrics

2.5 For each hyperparameter setting, calculate the average metrics score over the \(L\) folds, and choose the best hyperparameter setting.

2.6 Train a model with the best hyperparameter on trainval. Evaluate its performance on test and save the score for fold \(k\).
Calculate the mean score over all \(K\) folds, and report as the generalization error.

As for the implementation, the scikit-learn documentation points out: the inner loop can call scikit-learn’s GridSearchCV to achieve grid search of hyperparameter evaluated on the inner loop val set, and the outer loop can call cross_val_score for generalization error.

Q&A

Can I apply the best hyperparameter selected in the first iteration of the outer fold, to build models for the remaining \(K-1\) outer loop? i.e. to save the search of the best hyperparameter in the next \(K-1 \times L \times M\) (where \(M\) is the number of hyperparameter combinations, if use grid search).

I think the answer is no. The reason is that in this way, the test sets in the following loop are not “untouched” by the hyperparameter selection process. For example, in the outer loop # \(2\), the test set for evaluating the model performance was actually used in the outer loop # \(1\) for selecting the hyperparameter, then some data were used both for hyperparameter tuning and performance evaluation. This will cause overfitting.
What if the \(K\) outer loop has distinct hyperparameter? How can I use the nested CV to build the best model?

As I state in the beginning, CV is not a method to get one or multiple trained models for inference, but only a tool to estimate an unbiased generalization performance. CV will generate multiple models in each outer loop, but we can hardly estimate the performance of each individual model, since the number of the test set in each outer loop is small. However, if the model is stable (do not change much if the training data is perturbed), the hyperparameter found in each outer loop may be the same (using grid search) or similar to each other (using random search). A more in-depth explanation can be found here.

That’s all for what I would like to share of nested CV. This post reflects my current understanding of the cross validation. Please correct me if you identify any problems. Thanks!

References

[1] T. Hastie, J. Friedman, and R. Tibshirani, “Model Assessment and Selection,” in The Elements of Statistical Learning: Data Mining, Inference, and Prediction, T. Hastie, J. Friedman, and R. Tibshirani, Eds. New York, NY: Springer New York, 2001, pp. 193–224.

[2] G. C. Cawley and N. L. C. Talbot, “On Over-fitting in Model Selection and Subsequent Selection Bias in Performance Evaluation,” Journal of Machine Learning Research, vol. 11, no. Jul, pp. 2079–2107, 2010.

A friendly introduction to Convolutional in CNN

2018-08-05T10:00:00+00:00

Notebook version

A friendly introduction to convolution in CNN

“Convolution” is one of the most mysterious words for a novice deep learner. The first time when I opened wikipedia on convolution and tried to make sense, I just got dizzy and lost. After a long time mingling with CNN and a bit with signal processing, I finally figure it out a little better. In my current understanding,

the convolution is just a fancy operation of the weighted sum.

And here is the whole story:

1. A very simple version of weighted sum

To see what is a weighted sum, Let’s begin with the following expression, which may remind you of algebra in high school:

\[y = w_1 \times x_1 + w_2 \times x_2\]

Pretty easy, right? We give \(x_1\) and \(x_2\) different weights of \(w_1\) and \(w_2\), because in our mind, we value \(x_1\) and \(x_2\) differently. For example, if you want to calculate the final course score from the midterm and final exam, the weights reflect how important you think each exam is.

Weights reflect how important we think a variable is numerically, in a numerical perspective. Here, by injecting our thoughts, we are bringing in new perspectives into the original flat world (since the original weights are : \(w_1 = 1\), \(w_2 = 1\)).

And sum is just an operation that condenses our deliberate thoughts on each variable into one final value (like the final course score).

2. The weighted sum with more \(x\)

If we have more than two, say \(n\) number of \(x\), then the above formula can be written as:

\[y = w_1 \times x_1 + w_2 \times x_2 + w_3 \times x_3 + ... + w_n \times x_n\]

Or, a more condensed version:

\[y = \sum^n\_{i=1} w_i \times x_i\]

This works totally well when the number of \(x_i\) is small. But what if the number of \(x_i\) becomes large, say \(1,000,000\), or even infinite, how do we assign each \(x_i\) a weight wisely?

Here is the trick:

Instead of using a single number \(y\) to describe \(x\) sequence, now we use a group of numbers \(\vec{y}\). That’s because a single number compresses the information of \(x\) too much, so that it could not reflect its character very well.

Now since we are dealing with a whole bunch of \(x\)s and \(y\)s, we will use \(\vec{x}\) and \(\vec{y}\) instead. Don’t be intimidated by the fancy new notation. They are called “vector”, which is merely a sequence of numbers grouped together.

To generate a sequence of numbers \(\vec{y}\) out of \(\vec{x}\), there are some different approaches. Let’s explore one by one.

2.1 Same weight for all \(x_i\)

The easiest approach is to assign a signal weight \(w\) to all \(x_i\). It is equal to \(\vec{y} = w \times \vec{x}\), where \(w\) is a single number.

We will evaluate this approach from the following two aspects:

	Same weight for all \(x_i\)
\(w\) is simple and compact	Yes
\(w\) adds information on how we value different value in \(\vec{x}\)	No

\(w\) is quite simple: it is just a number. However, it adds little information from “our perspective”. It only scales the original \(\vec{x}\), and could not differentiate the fine details inside \(\vec{x}\).

Here is an example:

import numpy as np
import matplotlib.pyplot as plt
x = np.sin(np.linspace(-2* np.pi, 2*np.pi, 200))
plt.plot(x)
plt.ylim(-2.5, 2.5)
plt.xlabel("The sequence of x")
plt.ylabel("The value of x")
plt.show()

We draw \(\vec{x}\) as a sequence of numbers. Now if we multiply each \(x_i\) with a weight, say \(2\), then the output \(\vec{y}\) will look like this:

plt.plot(x)
#plt.plot(2*np.ones(x.shape))
plt.plot(2 * x)
plt.plot(np.convolve(x, 2))
plt.ylim(-2.5, 2.5)
plt.legend(['x', 'w * x', 'convolve with 2'], bbox_to_anchor=(1.05, 1), loc=2)
plt.xlabel("Sequence")
plt.ylabel("Value")
plt.show()

As you can see, the green line \(\vec{y}\) has exactly the same “pattern”, i.e.: it has peaks and valleys in the same position as in \(\vec{x}\). It stretched \(\vec{x}\) but that’s it.

You may notice I actually draw 3 lines. The graph only shows two lines because the lines of “multiply by 2” and “convolve with 2” are overlapped. I’ll talk about it later. But now you see we begin to touch convolution a little bit after a long reading!

2.2 Distinct weight for each \(x_i\)

Another extreme is to assign each \(x_i\) with a distinct weight. For every resulting point \(y_i\), it is the product of \(w_i\) and \(x_i\).

\[y_i = w_i \times x_i\]

Now \(\vec{w}\) becomes a sequence of numbers with the same length as \(\vec{x}\). The weight \(\vec{w}\) reflects our thoughts on each \(x_i\) in much finer details. This is similar to what we do in the first example of calculating the final score of a course, but here we didn’t apply the summation.

To take another example, here we assign the weight as a sequence of numbers on a straight line, as the orange line shown in the picture. When we multiply each \(w_i\) with \(x_i\), we get the resulting \(\vec{y}\) as the green line. Even with a very simple form of \(\vec{w}\), the resulting \(\vec{y}\) can do a very good job in incorporating the information from both \(\vec{w}\) and \(\vec{x}\).

x = np.sin(np.linspace(0, 20*np.pi, 400))
w = np.arange(400)/400
plt.plot(x)
plt.plot(w)
plt.plot(np.multiply(x, w))
plt.legend(['x', 'w', 'y'], bbox_to_anchor=(1.05, 1), loc=2)
plt.xlabel("Sequence")
plt.ylabel("Value")
plt.show()

This approach has some real-world applications, such as Amplitude modulation. Depending on the specific problems, if we want to apply this approach to identifying peaks and valleys, it will become unpractical, since we will need to deliberately design all the weight sequence according to all the domain of \(\vec{x}\). It is also redundant and costly to express and store \(\vec{w}\).

	Same weight for all \(x_i\)	Distinct weight for each \(x_i\)
\(w\) is simple and compact	Yes	No
\(w\) adds information on how we value different value in \(\vec{x}\)	No	Yes

2.3 Repetitive weight

An improvement to the above approach, is to express \(\vec{w}\) in a repetitive manner, i.e.: to repeat a short sequence \(\vec{w}\) over \(\vec{x}\).

In this way, the \(\vec{w}\) is expressed by a short sequence of numbers, meanwhile still carry out our thoughts over the raw data \(\vec{x}\).

	Same weight for all \(x_i\)	Distinct weight for each \(x_i\)	Repetitive weight
\(w\) is simple and compact	Yes	No	Yes
\(w\) adds information on how we value different value in \(\vec{x}\)	No	Yes	Yes

n = 50
x = np.sin(np.linspace(0, 20*np.pi, 400))
w = np.tile(np.concatenate((np.arange(n), np.flip(np.arange(n), axis = 0)), axis = 0), int(200/n))/n/2
plt.plot(x)
plt.plot(w)
plt.plot(np.multiply(x, w))
plt.legend(['x', 'w', 'y'], bbox_to_anchor=(1.05, 1), loc=2)
plt.xlabel("Sequence")
plt.ylabel("Value")
plt.show()

In this example, we repeat \(\vec{w}\) four times. We notice that \(\vec{y}\) (in green) has the largest peaks when the peaks of \(\vec{w}\) overlap with the one of \(\vec{x}\).

However, in the above example, I set the length of \(\vec{w}\) deliberately to match the shape of \(\vec{x}\). Thus the interesting pattern of the \(\vec{w}\) can only fall on the specific segment of \(\vec{x}\). The real-world data are way more complex than the sinusoid. How to make \(\vec{w}\) cover the whole sequence of \(\vec{x}\) without missing any potential interesting combination of \(w \times x\)?

2.4 Repetitive weight with smaller stepsize

The problem with the previous approach is that its step size is too large. It equals the length of \(\vec{w}\). We can solve the problem by shortening the stepsize. Let’s push the stepsize to another extreme, say \(1\) in case that \(x\) is discrete.

Concretely, we iteratively use each number in \(\vec{w}\) as the start point, and periodically repeat \(\vec{w}\) to get the same length as \(\vec{x}\), then we multiply the two sequence element-wise.

Wait a minute, in this way, since we repeat the process many times, we will get many \(\vec{y}\), how do we summarize the multiplied information.

So far, we only discussed different scenarios of the weight, we still didn’t talk much about the sum. Now it’s time to let the sum shine!

I thought about adding all the resulting \(\vec{y}\) element-wise, but then I realized the result equals to add all the elements of \(\vec{w}\) together, then multiply the number with \(\vec{x}\). It becomes the case in Section 2.1, which destroyed the information we extracted by shifting the start point of \(\vec{w}\).

The real trick of convolution is:

we sum over the sequence of \(\vec{w}\), right after multiplying \(\vec{w}\) with the corresponding \(x\) segment.

The resulting output from the sum will be a single number \(y_n\):

\[y*n = \sum*{i=0}^{|w|} w*i \times x*{n + i}\]

where \(n\) is the start position of \(\vec{w}\) on \(\vec{x}\).

After calculating all the \(y_n\) along the sequence of \(\vec{x}\), we just complete the convolution operation.

\[y(n) = (x \* w)(n) = \sum*{i=0}^{|w|} w_i \times x*{n + i}\]

where the \(\*\) symbol denotes the convolution operation, and \(y\) is denoted as a function of the sequence \(n\).

Remember in the beginning, I mentioned sum is an operation that condenses our deliberate thoughts on each variable into one final value. Instead of summing over the whole sequence as above, the convolution sum over the area covered by the weight size. In this way, the sum operation won’t lose much information, and concisely represents the combined information from \(w\) and \(x\) patch. Moreover, since the weighted sum is actually the dot product of \(w\) and the local \(x\) patch, it is a similarity measure of the two, where a larger weighted sum represents a detected pattern on \(\vec{x}\) that corresponding to the pattern of \(\vec{w}\). Thus, we can design weights with the patterns we want and use them to detect if similar patterns exist on the target data \(\vec{x}\).

The formula is similar to the one in Discrete convolution in Wikipedia. Except for that in the wikipedia’s formula, it is \(x_{n - i}\) instead of \(x_{n + i}\). The minus sign used to confused me a lot, until I found out when we talk about convolution in CNN, we actually talk about cross-correlation, where it uses \(x_{n + i}\). The convolution in math uses \(x_{n - i}\), where the weight is flipped. The difference only matters when writing proofs, but as regarded to CNN implementation, people just use \(x_{n + i}\) and call it convolution. (Ref: Deep Learning book p. 324)

That’s almost the whole story of convolution.

But what does it to do with convolution and image, you may ask. The above story tells us how to calculate convolution with 1-dimensional data. The convolution in CNN for images is calculated exactly in the same way, we just extend the data and weights to 2 dimensions.

\[Y(m, n) = (X \* W)(m, n) = \sum*{i} \sum*{j} W*{i , j} \times X*{m + i, n + j}\]

That’s it!

The convolution is really a smart, simple and powerful operation. It uses a small size of weight, which is easy to express. I’d like to think the weight as a searchlight that focuses on one small patch of \(X\) at a time. While the “light” shines on one image patch, it synthesizes the information of the image data with our values on different spatial location, by using the weighted sum operation. The convolved output is a group of such weighted sum aligned with the shape of input data \(X\). This is my intuition on the strength of convolution. More advantages of convolution include sparse interactions, parameter sharing, and equivariant representations. These contents are described in much details in Ch 9.2 of Deep Learning book.

My next notebook will introduce the implementation and a variety of convolutions in CNN. See you later!

This article reflects my current understanding of convolution in CNN. Please let me know if you identified any errors or have any questions: @weina_jin or by creating an issue. Thanks for your reading 😎