Brain tumour detection using CNN I have a fairly basic mathematical and implementational understanding of ML algorithms and CNNs, and I am trying to think of an approach for this task: https://www.kaggle.com/c/rsna-miccai-brain-tumor-radiogenomic-classification/data?select=test.
The "data" section explains the task and also gives a preview of the dataset.
1) Doubts on general Implementation approach.
From what I understand, we have 4 input parameters: FLAIR , T1W, T1Gd, and T2W. (call them $x_{1}$,$x_{2}$,$x_{3}$ and $x_{4}$). Based on these 4 parameters, we have to compute the "MGMT status"(Presence of MGMT), which is binary, i,e takes on values ($0/1$).
We can then use a CNN architecture that has $1,x1,x2,x3,x4$ in it's input layer, and uses a sigmoid activation function (to get the output in $(0,1)$).
However, this approach works if the $x_{i}$s were numeric values. However, in my case, the parameters FLAIR , T1Gd etc are in the form of images.
Now, I am aware that images are fed to neural networks as inputs, eg. in object detection programs, however in those examples a single image is fed as an input, and features are subsequently extracted by the network.
How should I approach my particular case, where I have multiple images as input parameters?
 A: 
How should I approach my particular case, where I have multiple images as input parameters?

One option is to use a CNN for each image, and the flatten and concatenate the results to make predictions. The CNNs can be the same or different, depending on what your goals are.
A: You'd concatenate the images together in different channels and the neural network would interpret it the same way it would an RGB image. This can even be done if the images were 3D, using the Conv3D and MaxPooling3D layers. Convert the DICOMs to NIFTIs using dcm2niix (a terminal program), read them in using nibabel, convert them to numpy arrays, and concatenate the individual files together using np.concatenate((im1,im2,im3),axis=-1).
Some untested code for how to do this in the two-channel case. You'd probably need GPUs handy for it to be effective:
import nibabel as nib
import numpy as np
from scipy.ndimage import zoom
from tensorflow.keras.layers import *
from tensorflow.keras import Model
 
filelist_flair = ["file1_flair.nii.gz","file2_flair.nii.gz"]
filelist_dwi   = ["file1_dwi.nii.gz",  "file2_dwi.nii.gz"]
label_filename = "has_tumors.txt"

imsize = (64,64,64)
X = np.zeros((len(filelist_flair),imsize[0],imsize[1],imsize[2],2))
Y = np.zeros((len(filelist_flair),))
# Reads in image files, converts to numpy, resizes to standard size
for i in range(len(filelist_flair)):
    flair_file = filelist_flair[i]
    dwi_file   = filelist_dwi[i]
    flair_im   = np.squeeze(nib.load(flair_file).get_fdata())
    dwi_im     = np.squeeze(nib.load(dwi_file).get_fdata())
    assert(len(dwi_im.shape) == 3 and len(flair_im.shape) == 3)
    zp_flair   = [imsize[i]/flair_im.shape[i] for i in range(len(imsize))]
    zp_dwi     = [imsize[i]/dwi_im.shape[i] for i in range(len(imsize))]
    flair_im   = zoom(flair_im,zp_flair)
    dwi_im     = zoom(dwi_im,zp_zoom)
    X[i,:,:,:,0] = flair_im
    X[i,:,:,:,1] = dwi_im

# Read in labels for Y here

# Add more layers and stuff
inputs = Input(shape=(imsize[0],imsize[1],imsize[2],2))
x = Conv3D(32,(2,2,2),activation="relu")(inputs)
x = MaxPool3D(pool_size = 2)(x)
x = BatchNormalization()(x)
x = Flatten()(x)
x = Dense(64,activation="relu")(x)
x = BatchNormalization()(x)
x = Dense(1,activation="sigmoid")(x) # or Dense(2,activation="softmax")(x)

m = Model(inputs,x)
m.compile(loss="binary_crossentropy",optimizer="adam")
m.fit(X,Y) # Separate into training and test sets before you do this

