### PyTorch Model Setup and Training

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Defines a sequential model, moves it to the CUDA device, and starts the training process. Ensure a CUDA-enabled GPU is available for device placement.

```python
model = nn.Sequential(backbone, classifier)
        device = torch.device("cuda")
        model = model.to(device)
        best_model = train_model(model, criterion,optimizer, fold_num = f)
```

--------------------------------

### PyTorch Backbone and Classifier Setup

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Imports necessary PyTorch libraries for building a two-module architecture (Backbone and Classifier) for tasks like ACL and Meniscus classification. Includes data handling and model components.

```python
import torch
from torch import nn
from torchvision.models import resnet50
from torchvision import transforms
from torch.utils.data import Dataset, DataLoader
import pandas as pd
import numpy as np
import cv2
```

--------------------------------

### Load Training, Validation, and Test DataFrames

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Loads data splits from CSV files into pandas DataFrames. It assumes CSV files are organized by fold number, allowing for cross-validation setups.

```python
df_train = pd.read_csv('dataframe/train_fold'+str(i+1)+'.csv')
df_val = pd.read_csv('dataframe/val_fold'+str(i+1)+'.csv')
df_test= pd.read_csv('dataframe/test_fold'+str(i+1)+'.csv')
```

--------------------------------

### Initialize ImageDataGenerator for Data Augmentation

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Initializes Keras `ImageDataGenerator` for image augmentation and preprocessing. This setup is typically used for streaming images from CSV dataframes in TensorFlow applications.

```python
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications.imagenet_utils import preprocess_input
import pandas as pd

image_size = 256
batch_size = 256

df_train = pd.read_csv("thyroid/dataframe/thyroid_train_fold1.csv")
```

--------------------------------

### Instantiate Backbone and Classifier

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Creates instances of the `Backbone` and `Classifier` models. The `Classifier` is initialized with the determined number of classes.

```python
backbone = Backbone()
classifier = Classifier(num_class=num_class)
```

--------------------------------

### Create DataLoaders for Training, Validation, and Testing

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Initializes `DataLoader` instances for the training, validation, and test datasets. These loaders provide batches of data during the training process and handle shuffling and multiprocessing.

```python
train_dataset = createDataset(df_train)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=20)
val_dataset = createDataset(df_val)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True, num_workers=20)

test_dataset = createDataset(df_test)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=20)
```

--------------------------------

### Configure Multi-GPU Training with MirroredStrategy

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Sets up TensorFlow for synchronous data-parallel training across multiple GPUs on a single machine. Ensure CUDA_VISIBLE_DEVICES is set appropriately to control GPU usage.

```python
import os
import tensorflow as tf

os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"   # use 4 GPUs; set to "0" for single GPU

strategy = tf.distribute.MirroredStrategy()
print(f"Number of devices: {strategy.num_replicas_in_sync}")
# Output: Number of devices: 4

with strategy.scope():
    model = get_compiled_model()   # all variable creation must occur inside scope
    # model.compile() is also called inside get_compiled_model()

# Effective global batch size = per_replica_batch_size × num_replicas
per_replica_batch = 256
global_batch_size = per_replica_batch * strategy.num_replicas_in_sync
print(f"Effective global batch size: {global_batch_size}")
```

--------------------------------

### Import Core PyTorch Libraries

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Imports essential libraries for PyTorch model building, including pandas for data manipulation, torch for tensor operations, nn for neural network modules, and torchvision for pre-trained models.

```python
import pandas as pd
import torch
from torch import nn
from torchsummary import summary
from collections import OrderedDict
from torchvision.models import resnet50, densenet121, inception_v3
from tqdm import tqdm
```

--------------------------------

### Import Data Handling and Image Processing Libraries

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Imports libraries for image loading, manipulation, and data handling, including scikit-image for image processing, numpy for numerical operations, Pillow for image format handling, and OpenCV for image reading and resizing.

```python
from skimage.io import imread
import numpy as np
from skimage.transform import resize
from torch.utils.data import DataLoader
from torch.utils.data import Dataset
from PIL import Image
from torchvision import models, transforms
import os
import cv2
```

--------------------------------

### Create Custom PyTorch Dataset

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Implements a PyTorch `Dataset` for loading images and labels from a pandas DataFrame. It handles image reading, normalization, resizing, and label conversion. Ensure images are preprocessed to [-1, 1] range and resized to 224x224.

```python
class createDataset(Dataset):
    def __init__(self, dataframe):
        self.dataframe = dataframe
        self.transform = transforms.Compose([transforms.ToTensor()])

    def __len__(self):
        return len(self.dataframe)

    def __getitem__(self, index):
        row   = self.dataframe.iloc[index]
        image = cv2.imread(row["img_dir"])
        image = (image - 127.5) * 2 / 255          # normalize to [-1, 1]
        image = cv2.resize(image, (224, 224))
        image = self.transform(image)
        label = torch.tensor(row["label"], dtype=torch.long)
        return {"image": image, "label": label}
```

--------------------------------

### 5-Fold Cross-Validation Training Loop

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Sets up and executes a 5-fold cross-validation training loop using PyTorch. Loads pre-trained weights, defines the model, criterion, and optimizer, and iterates through epochs for training and validation. Best models are saved based on validation loss.

```python
backbone   = Backbone()
backbone.load_state_dict(torch.load("resnet50_torch.pt"))   # RadImageNet weights
device     = torch.device("cuda" if torch.cuda.is_available() else "cpu")

for fold in range(5):
    df_train = pd.read_csv(f"acl/dataframe/train_fold{fold+1}.csv")
    df_val   = pd.read_csv(f"acl/dataframe/val_fold{fold+1}.csv")

    # Binary label mapping: 'yes' → 1, else → 0
    df_train['label'] = df_train['label'].apply(lambda x: 1 if x == 'yes' else 0)
    df_val['label']   = df_val['label'].apply(lambda x: 1 if x == 'yes' else 0)

    num_class    = len(df_train['label'].unique())
    classifier   = Classifier(num_class=num_class)
    model        = nn.Sequential(backbone, classifier).to(device)

    criterion  = nn.CrossEntropyLoss()
    optimizer  = torch.optim.Adam(model.parameters(), lr=0.001)
    train_loader = DataLoader(createDataset(df_train), batch_size=8, shuffle=True, num_workers=4)
    val_loader   = DataLoader(createDataset(df_val),   batch_size=8, shuffle=False, num_workers=4)

    best_val_loss = float('inf')
    for epoch in range(30):
        model.train()
        train_loss = 0.0
        for batch in train_loader:
            images, labels = batch['image'].to(device, dtype=torch.float), batch['label'].to(device)
            optimizer.zero_grad()
            loss = criterion(model(images), labels)
            loss.backward()
            optimizer.step()
            train_loss += loss.item()

        model.eval()
        val_loss = 0.0
        with torch.no_grad():
            for batch in val_loader:
                images, labels = batch['image'].to(device, dtype=torch.float), batch['label'].to(device)
                val_loss += criterion(model(images), labels).item() * images.size(0)

        print(f"Fold {fold+1} Epoch {epoch+1}: train_loss={train_loss/len(train_loader):.4f}  val_loss={val_loss/len(val_loader):.4f}")
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            torch.save(model.state_dict(), f"acl_fold{fold+1}_best_model.pth")
            print(f"  → Saved best model (val_loss decreased to {best_val_loss:.4f})")
```

--------------------------------

### Build and Compile Pretrained CNN for Transfer Learning (Python)

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Constructs a Keras model using a specified CNN backbone with RadImageNet or ImageNet weights. Supports layer-freezing strategies and compiles the model for binary classification.

```python
# Example: Load RadImageNet-pretrained ResNet50, freeze all but top 10 layers
# Run from any application directory, e.g. acl/, breast/, thyroid/, etc.
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import BinaryCrossentropy

image_size = 256
database = "RadImageNet"   # or "ImageNet"
model_name = "ResNet50"    # IRV2 | ResNet50 | DenseNet121 | InceptionV3
structure = "unfreezetop10"  # unfreezeall | freezeall | unfreezetop10
lr = 0.001
num_classes = 2

model_dir = "../RadImageNet_models/RadImageNet-ResNet50-notop.h5"
base_model = ResNet50(
    weights=model_dir,
    input_shape=(image_size, image_size, 3),
    include_top=False,
    pooling='avg'
)

# Freeze all layers except the top 10
for layer in base_model.layers[:-10]:
    layer.trainable = False

y = base_model.output
y = Dropout(0.5)(y)
predictions = Dense(num_classes, activation='softmax')(y)
model = Model(inputs=base_model.input, outputs=predictions)
model.compile(
    optimizer=Adam(lr=lr),
    loss=BinaryCrossentropy(),
    metrics=[keras.metrics.AUC(name='auc')]
)
print(model.summary())
# Output: Model with ResNet50 backbone + Dropout + Dense(2, softmax)
# Non-trainable params: all layers except last 10 of base_model
```

--------------------------------

### Prepare DataFrames for Image Training

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Sets up ImageDataGenerator for training and validation, including data augmentation and preprocessing. Use this to create generators for feeding data into Keras models.

```python
train_data_generator = ImageDataGenerator(
    rescale=1./255,
    preprocessing_function=preprocess_input,
    rotation_range=10,
    width_shift_range=0.1,
    height_shift_range=0.1,
    shear_range=0.1,
    zoom_range=0.1,
    horizontal_flip=True,
    fill_mode='nearest'
)
val_data_generator = ImageDataGenerator(
    rescale=1./255,
    preprocessing_function=preprocess_input
)

train_generator = train_data_generator.flow_from_dataframe(
    dataframe=df_train,
    x_col='img_dir',        # column with image file paths
    y_col='label',          # column with class labels
    target_size=(image_size, image_size),
    batch_size=batch_size,
    shuffle=True,
    seed=726,
    class_mode='categorical'
)
print(train_generator.class_indices)
# Output: {'benign': 0, 'malignant': 1}
print(f"Training samples: {len(train_generator.labels)}")
# Output: Training samples: <N>

df_val = pd.read_csv("thyroid/dataframe/thyroid_val_fold1.csv")
val_generator = val_data_generator.flow_from_dataframe(
    dataframe=df_val,
    x_col='img_dir',
    y_col='label',
    target_size=(image_size, image_size),
    batch_size=batch_size,
    shuffle=False,
    seed=726,
    class_mode='categorical'
)
```

--------------------------------

### Load Pre-trained Backbone Weights

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Loads the state dictionary for the backbone model from a saved file ('resnet50_torch.pt'). This allows using pre-trained weights to initialize the feature extractor.

```python
backbone.load_state_dict(torch.load("resnet50_torch.pt"))
```

--------------------------------

### Breast Lesion Classification Training Script CLI

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Command-line interface for training the breast lesion classification model. Configurable parameters include GPU, database, model, batch size, image size, epochs, structure, and learning rate.

```bash
# Breast lesion classification using ImageNet weights, freeze all layers
python breast/breast_train.py \
  --gpu_node 1 \
  --database ImageNet \
  --model_name DenseNet121 \
  --batch_size 128 \
  --image_size 256 \
  --epoch 50 \
  --structure freezeall \
  --lr 0.0001
```

--------------------------------

### Training Progress Output

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

This output logs the training and validation loss for each epoch, indicating when the model's performance improves and when the best model is saved.

```text
Epoch 1 		 Training Loss: 0.4457762529561808 		 Validation Loss: 0.31227233193137427
Validation Loss Decreased(inf--->3.434996) 	 Saving The Model
Epoch 2 		 Training Loss: 0.14679992552027926 		 Validation Loss: 0.09849888628179376
Validation Loss Decreased(3.434996--->1.083488) 	 Saving The Model
Epoch 3 		 Training Loss: 0.08154763455744475 		 Validation Loss: 0.12573414499109442
Epoch 4 		 Training Loss: 0.062108178586560904 		 Validation Loss: 0.25889845327897504
Epoch 5 		 Training Loss: 0.06391522991675679 		 Validation Loss: 0.017163275317712265
Validation Loss Decreased(1.083488--->0.188796) 	 Saving The Model
Epoch 6 		 Training Loss: 0.07031963857658051 		 Validation Loss: 0.03573957085609436
Epoch 7 		 Training Loss: 0.06533189754890582 		 Validation Loss: 0.18448266116055576
Epoch 8 		 Training Loss: 0.018094773113741643 		 Validation Loss: 0.0021281332116235385
Validation Loss Decreased(0.188796--->0.023409) 	 Saving The Model
Epoch 9 		 Training Loss: 0.014920052743616328 		 Validation Loss: 0.002436336637897925
Epoch 10 		 Training Loss: 0.006788608369298834 		 Validation Loss: 0.007084378464655442
Epoch 11 		 Training Loss: 0.0015907104557100155 		 Validation Loss: 0.24107835509560324
Epoch 12 		 Training Loss: 0.0032665943758079913 		 Validation Loss: 0.0003260832533917644
Validation Loss Decreased(0.023409--->0.003587) 	 Saving The Model
Epoch 13 		 Training Loss: 0.0016831970993675047 		 Validation Loss: 0.7905788421630859
Epoch 14 		 Training Loss: 0.0017326752802416326 		 Validation Loss: 0.008139228278940374
Epoch 15 		 Training Loss: 0.00318281331147863 		 Validation Loss: 0.28556355563077057
Epoch 16 		 Training Loss: 0.007273598028962294 		 Validation Loss: 0.4322407895868475
Epoch 17 		 Training Loss: 0.0029323149308586103 		 Validation Loss: 0.6556116884404962
Epoch 18 		 Training Loss: 0.08122620849541648 		 Validation Loss: 0.08495957201177423
Epoch 19 		 Training Loss: 0.04737511703969686 		 Validation Loss: 0.18606922843239523
Epoch 20 		 Training Loss: 0.0035187961037501316 		 Validation Loss: 0.1872019334272905
Epoch 21 		 Training Loss: 0.0008831469497874752 		 Validation Loss: 0.0005289917303757234
Epoch 22 		 Training Loss: 0.0006706713745106154 		 Validation Loss: 0.016736537218093872
Epoch 23 		 Training Loss: 0.013629328110075402 		 Validation Loss: 0.6344210451299493
Epoch 24 		 Training Loss: 0.023848454354840093 		 Validation Loss: 0.444000244140625
Epoch 25 		 Training Loss: 0.004152694679510455 		 Validation Loss: 0.02475080977786671
Epoch 26 		 Training Loss: 0.00046661380891082146 		 Validation Loss: 0.038509940559213814
Epoch 27 		 Training Loss: 0.11307178725020434 		 Validation Loss: 0.7771469463001598
Epoch 28 		 Training Loss: 0.012336848162074322 		 Validation Loss: 0.2670136581767689
Epoch 29 		 Training Loss: 0.0023676027523314197 		 Validation Loss: 0.33774974129416724
Epoch 30 		 Training Loss: 0.003787129033608525 		 Validation Loss: 0.6296653747558594
```

--------------------------------

### Define Loss Function and Optimizer

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Initializes the CrossEntropyLoss function for classification tasks and the Adam optimizer with a learning rate of 0.001 to update model parameters.

```python
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr = 0.001)
```

--------------------------------

### Define Custom Image Dataset

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Creates a custom PyTorch `Dataset` class for loading images and their corresponding labels from a DataFrame. It handles image reading, resizing, normalization, and transformation.

```python
class createDataset(Dataset):
    def __init__(self, dataframe, transform=None):
        self.dataframe = dataframe
        self.transform = transforms.Compose([transforms.ToTensor()])

    def __len__(self):
        return self.dataframe.shape[0]
        
    def __getitem__(self, index):
        image = self.dataframe.iloc[index]["img_dir"]
        image = cv2.imread(image)
        image = (image-127.5)*2 / 255
        image = cv2.resize(image,(224,224))
        #image = np.transpose(image,(2,0,1))   
        if self.transform is not None:
            image = self.transform(image)
        label = self.dataframe.iloc[index]["label"]
        return {"image": image , "label": torch.tensor(label, dtype=torch.long)}
```

--------------------------------

### CLI Argument Validation

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Lists valid values for model names, databases, and training structures used in the command-line training scripts.

```bash
# Valid --model_name values:  IRV2 | ResNet50 | DenseNet121 | InceptionV3
# Valid --database values:    RadImageNet | ImageNet
# Valid --structure values:   unfreezeall | freezeall | unfreezetop10
```

--------------------------------

### Hemorrhage Detection Training Script CLI

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Command-line interface for training the hemorrhage detection model for head CT scans. Supports multi-GPU configuration and allows customization of database, model, batch size, image size, epochs, structure, and learning rate.

```bash
# Hemorrhage detection (head CT, large-scale dataset)
python hemorrhage/hemorrhage_train.py \
  --gpu_node 0,1,2,3 \
  --database RadImageNet \
  --model_name ResNet50 \
  --batch_size 512 \
  --image_size 256 \
  --epoch 30 \
  --structure unfreezeall \
  --lr 0.001
```

--------------------------------

### Save Best Model Checkpoint and Export Training History

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Configures ModelCheckpoint to save the epoch with the lowest validation loss and exports training metrics (AUC, loss) to a CSV file for offline analysis. Ensure the 'models' and 'loss' directories exist before running.

```python
from tensorflow.keras.callbacks import ModelCheckpoint
import pandas as pd
import os

# Checkpoint filename convention:
# <task>-<structure>-[fold<N>-]<database>-<model>-<img_size>-<batch_size>-<lr>.h5
os.makedirs('./models', exist_ok=True)
os.makedirs('./loss',   exist_ok=True)

task      = "thyroid"
structure = "unfreezetop10"
fold      = 1
database  = "RadImageNet"
model_name= "ResNet50"
image_size, batch_size, lr = 256, 256, 0.001

filepath = f"models/{task}-{structure}-fold{fold}-{database}-{model_name}-{image_size}-{batch_size}-{lr}.h5"
checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')

# After model.fit_generator(..., callbacks=[checkpoint]):
# history.history keys: ['auc', 'val_auc', 'loss', 'val_loss']
# (pneumonia uses 'accuracy'/'val_accuracy' instead of AUC)

history = model.fit_generator(
    train_generator,
    epochs=30,
    steps_per_epoch=len(train_generator.labels) / batch_size,
    validation_data=val_generator,
    validation_steps=len(val_generator.labels) / batch_size,
    use_multiprocessing=True,
    workers=10,
    callbacks=[checkpoint]
)

pd.DataFrame({
    'train_auc':  history.history['auc'],
    'val_auc':    history.history['val_auc'],
    'train_loss': history.history['loss'],
    'val_loss':   history.history['val_loss']
}).to_csv(
    f"loss/{task}-{structure}-fold{fold}-{database}-{model_name}-{image_size}-{batch_size}-{lr}.csv",
    index=False
)
# Saved file example: loss/thyroid-unfreezetop10-fold1-RadImageNet-ResNet50-256-256-0.001.csv
# Columns: train_auc, val_auc, train_loss, val_loss  (30 rows, one per epoch)
```

--------------------------------

### ACL Tear Detection Training Script CLI

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Command-line interface for training the ACL tear detection model. Allows configuration of GPU, database, model, batch size, image size, epochs, structure, and learning rate.

```bash
# ACL tear detection with RadImageNet-IRV2, unfreeze all layers
python acl/acl_train.py \
  --gpu_node 0 \
  --database RadImageNet \
  --model_name IRV2 \
  --batch_size 256 \
  --image_size 256 \
  --epoch 30 \
  --structure unfreezeall \
  --lr 0.001
```

--------------------------------

### get_compiled_model()

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Builds and compiles a Keras model using a specified CNN backbone (ResNet50, DenseNet121, InceptionResNetV2, or InceptionV3) with either RadImageNet or ImageNet pretrained weights. It appends a Dropout layer and a Dense softmax classification head, then compiles the model. Supports three layer-freezing strategies: 'unfreezeall', 'freezeall', and 'unfreezetop10'.

```APIDOC
## `get_compiled_model()` — Build and compile a pretrained CNN for transfer learning

Constructs a Keras model by loading a chosen CNN backbone (IRV2, ResNet50, DenseNet121, or InceptionV3) with either RadImageNet or ImageNet pretrained weights, appending a Dropout(0.5) layer and a Dense softmax classification head, then compiling with Adam and BinaryCrossentropy. Supports three layer-freezing strategies: `unfreezeall`, `freezeall`, and `unfreezetop10`.

```python
# Example: Load RadImageNet-pretrained ResNet50, freeze all but top 10 layers
# Run from any application directory, e.g. acl/, breast/, thyroid/, etc.
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import BinaryCrossentropy

image_size = 256
database = "RadImageNet"   # or "ImageNet"
model_name = "ResNet50"    # IRV2 | ResNet50 | DenseNet121 | InceptionV3
structure = "unfreezetop10"  # unfreezeall | freezeall | unfreezetop10
lr = 0.001
num_classes = 2

model_dir = "../RadImageNet_models/RadImageNet-ResNet50-notop.h5"
base_model = ResNet50(
    weights=model_dir,
    input_shape=(image_size, image_size, 3),
    include_top=False,
    pooling='avg'
)

# Freeze all layers except the top 10
for layer in base_model.layers[:-10]:
    layer.trainable = False

y = base_model.output
y = Dropout(0.5)(y)
predictions = Dense(num_classes, activation='softmax')(y)
model = Model(inputs=base_model.input, outputs=predictions)
model.compile(
    optimizer=Adam(lr=lr),
    loss=BinaryCrossentropy(),
    metrics=[keras.metrics.AUC(name='auc')]
)
print(model.summary())
# Output: Model with ResNet50 backbone + Dropout + Dense(2, softmax)
# Non-trainable params: all layers except last 10 of base_model
```
```

--------------------------------

### run_model()

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Executes 5-fold cross-validated training with checkpointing using TensorFlow. This function iterates over pre-split folds, sets up `ImageDataGenerator` pipelines for training and validation, fits the compiled model for a specified number of epochs, saves the best checkpoint per fold, and logs per-fold history to CSV. It is utilized by training scripts for various applications like ACL, breast, and thyroid analysis.

```APIDOC
## `run_model()` — Execute 5-fold cross-validated training with checkpointing (TensorFlow)

Iterates over 5 pre-split folds, creates `ImageDataGenerator` pipelines with augmentation for training and plain rescaling for validation, fits the compiled model for `num_epochs` epochs, saves the best checkpoint per fold (lowest `val_loss`) as an `.h5` file, and writes per-fold AUC/loss history to CSV. Used by ACL, breast, meniscus, and thyroid training scripts.

```python
# Equivalent to running: python acl/acl_train.py \
#   --gpu_node 0 --database RadImageNet --model_name ResNet50 \
#   --batch_size 256 --image_size 256 --epoch 30 \

```

--------------------------------

### TensorFlow Training Loop for RadImageNet

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

This script demonstrates a 5-fold cross-validation training loop using TensorFlow and Keras for the RadImageNet dataset. It includes data augmentation, model checkpointing, and saving training history.

```python
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications.imagenet_utils import preprocess_input
from tensorflow.keras.callbacks import ModelCheckpoint
import os

image_size, batch_size, num_epoches = 256, 256, 30
database, structure, lr = "RadImageNet", "unfreezetop10", 0.001
model_name = "ResNet50"

strategy = tf.distribute.MirroredStrategy()

for i in range(5):
    df_train = pd.read_csv(f"acl/dataframe/train_fold{i+1}.csv")
    df_val   = pd.read_csv(f"acl/dataframe/val_fold{i+1}.csv")

    train_gen = ImageDataGenerator(
        rescale=1./255,
        preprocessing_function=preprocess_input,
        rotation_range=10,
        width_shift_range=0.1,
        height_shift_range=0.1,
        shear_range=0.1,
        zoom_range=0.1,
        horizontal_flip=True,
        fill_mode='nearest'
    ).flow_from_dataframe(
        df_train, x_col='filename', y_col='acl_label',
        target_size=(image_size, image_size), batch_size=batch_size,
        shuffle=True, seed=726, class_mode='categorical'
    )
    val_gen = ImageDataGenerator(
        rescale=1./255, preprocessing_function=preprocess_input
    ).flow_from_dataframe(
        df_val, x_col='filename', y_col='acl_label',
        target_size=(image_size, image_size), batch_size=batch_size,
        shuffle=True, seed=726, class_mode='categorical'
    )

    os.makedirs('./models', exist_ok=True)
    filepath = f"models/acl-{structure}-fold{i+1}-{database}-{model_name}-{image_size}-{batch_size}-{lr}.h5"

    with strategy.scope():
        model = get_compiled_model()   # defined above

    history = model.fit_generator(
        train_gen,
        epochs=num_epoches,
        steps_per_epoch=len(train_gen.labels) / batch_size,
        validation_data=val_gen,
        validation_steps=len(val_gen.labels) / batch_size,
        use_multiprocessing=True,
        workers=10,
        callbacks=[ModelCheckpoint(filepath, monitor='val_loss', save_best_only=True, mode='min')]
    )

    pd.DataFrame({
        'train_auc': history.history['auc'],
        'val_auc':   history.history['val_auc'],
        'train_loss': history.history['loss'],
        'val_loss':  history.history['val_loss']
    }).to_csv(f"loss/acl-{structure}-fold{i+1}-{database}-{model_name}-{image_size}-{batch_size}-{lr}.csv", index=False)

# Expected output per fold:
# Epoch 1/30 - loss: 0.45 - auc: 0.81 - val_loss: 0.31 - val_auc: 0.88
# Validation Loss Decreased(inf--->X.XX)  Saving The Model
```

--------------------------------

### Execute 5-Fold Cross-Validated Training (TensorFlow)

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Iterates over pre-split folds, creates data augmentation pipelines, fits the model, saves checkpoints, and logs history. This function is used by various application training scripts.

```python
# Equivalent to running: python acl/acl_train.py \
#   --gpu_node 0 --database RadImageNet --model_name ResNet50 \
#   --batch_size 256 --image_size 256 --epoch 30 \

```

--------------------------------

### Set CUDA Visible Devices

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Configures which GPU(s) are visible to the current process. This is useful for multi-GPU systems to specify the device for computation.

```python
#os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"  
os.environ["CUDA_VISIBLE_DEVICES"]="5"
```

--------------------------------

### Cross-Validation Loop

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Sets up a loop for cross-validation, iterating 5 times. This structure is intended to train and evaluate the model on different data folds.

```python
for f in range(5):
        ###use pretrain RIN-ResNet50 weights
```

--------------------------------

### Label Encoding Function

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

A helper function to convert categorical labels ('yes'/'no') into numerical format (1/0). This is a common preprocessing step for classification tasks.

```python
def get_label(x):
    if x == 'yes':
        return 1
    else:
        return 0
```

--------------------------------

### Define Model Training Function

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Implements a function to train the PyTorch model. It includes a training loop, validation loop, loss calculation, backpropagation, and model saving based on validation loss.

```python
def train_model(model, criterion, optimizer,  num_epochs=30, fold_num):
    min_valid_loss = np.inf

    for e in range(num_epochs):
        train_loss = 0.0
        model.train()     # Optional when not using Model Specific layer
        for i_batch, info_batch in enumerate(train_loader):
            if torch.cuda.is_available():
                data, labels = info_batch['image'].to(device, dtype=torch.float), info_batch['label'].to(device)
            
            optimizer.zero_grad()
            target = model(data)
            loss = criterion(target,labels)
            loss.backward()
            optimizer.step()
            train_loss += loss.item()
        
        valid_loss = 0.0
        model.eval()     # Optional when not using Model Specific layer
        for i_batch, info_batch in enumerate(val_loader):
            if torch.cuda.is_available():
                data, labels = info_batch['image'].to(device, dtype=torch.float), info_batch['label'].to(device)
            
            target = model(data)
            loss = criterion(target,labels)
            valid_loss = loss.item() * data.size(0)

        print(f'Epoch {e+1} 		 Training Loss: {train_loss / len(train_loader)} 		 Validation Loss: {valid_loss / len(val_loader)}')
        if min_valid_loss > valid_loss:
            print(f'Validation Loss Decreased({min_valid_loss:.6f}--->{valid_loss:.6f}) 	 Saving The Model')
            min_valid_loss = valid_loss
            # Saving State Dict
            torch.save(model.state_dict(), 'acl_fold'+str(fold_num)+'_best_model.pth')
    return model
```

--------------------------------

### Define Batch Size

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Sets the batch size for data loading, which determines the number of samples processed in each iteration during training and evaluation.

```python
batch_size = 8
```

--------------------------------

### Apply Label Encoding to DataFrames

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Applies the `get_label` function to the 'label' column of the training, validation, and test DataFrames to convert string labels to integers.

```python
df_train['label']=df_train['label'].apply(get_label)
```

```python
df_val['label']=df_val['label'].apply(get_label)
df_test['label']=df_test['label'].apply(get_label)
```

--------------------------------

### Define ResNet50 Backbone Network

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Defines a PyTorch `nn.Module` for a ResNet50 backbone, extracting layers up to the average pooling. This is useful for feature extraction in image classification tasks.

```python
class Backbone(nn.Module):
    def __init__(self):
        super().__init__()
        base_model = resnet50(pretrained=False)
        self.backbone = nn.Sequential(*list(base_model.children())[:9])  # up to AvgPool

    def forward(self, x):
        return self.backbone(x)
```

--------------------------------

### Define Backbone Feature Extractor

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Defines a backbone model using a pre-trained ResNet50. It extracts features from the input image by taking the first 9 layers of the ResNet50 architecture.

```python
class Backbone(nn.Module):
    def __init__(self):
        super().__init__()
        base_model = resnet50(pretrained=False)
        encoder_layers = list(base_model.children())
        self.backbone = nn.Sequential(*encoder_layers[:9])
                        
    def forward(self, x):
        return self.backbone(x)
```

--------------------------------

### Define Classifier Model

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Defines a simple classifier model consisting of a dropout layer and a linear layer. It takes a flattened input and outputs class scores. The input size is assumed to be 2048, likely from a pre-trained feature extractor.

```python
class Classifier(nn.Module):
    def __init__(self, num_class):
        super().__init__()
        self.drop_out = nn.Dropout()
        self.linear = nn.Linear(2048, num_class)

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.drop_out(x)
        x = self.linear(x)
        #x = torch.softmax(x, dim=-1)
        return x
```

--------------------------------

### Define Classifier Network

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Defines a PyTorch `nn.Module` for a classifier head, including dropout and a linear layer. It takes the flattened output from a backbone and maps it to the number of classes.

```python
class Classifier(nn.Module):
    def __init__(self, num_class):
        super().__init__()
        self.drop_out = nn.Dropout()
        self.linear   = nn.Linear(2048, num_class)

    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = self.drop_out(x)
        return self.linear(x)
```

--------------------------------

### COVID-19 Chest CT Classification Training Script CLI

Source: https://context7.com/bmeii-ai/radimagenet/llms.txt

Command-line interface for training the COVID-19 chest CT classification model. This script uses a single train/val split and allows configuration of GPU, database, model, batch size, image size, epochs, structure, and learning rate.

```bash
# COVID-19 chest CT classification (no fold loop — single train/val split)
python covid19/covid19_train.py \
  --gpu_node 0 \
  --database RadImageNet \
  --model_name InceptionV3 \
  --batch_size 1024 \
  --image_size 224 \
  --epoch 30 \
  --structure unfreezetop10 \
  --lr 0.00001
```

--------------------------------

### Determine Number of Classes

Source: https://github.com/bmeii-ai/radimagenet/blob/main/pytorch_example.ipynb

Calculates the number of unique classes from the training data labels. This is essential for defining the output layer of the classification model.

```python
num_class = len(df_train.label.unique())
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.