Add files using upload-large-folder tool

source_code/SegMamba/monai/_extensions/gmm/gmm_cuda.cu

@@ -0,0 +1,516 @@
+/*
+Copyright (c) MONAI Consortium
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+#include "gmm.h"
+
+#include "gmm_cuda_linalg.cuh"
+
+#define EPSILON 1e-5
+#define BLOCK_SIZE 32
+#define TILE(SIZE, STRIDE) ((((SIZE)-1) / (STRIDE)) + 1)
+#ifdef __HIP_PLATFORM_AMD__
+#define __SHFL_DOWN(a, b) __shfl_down(a, b)
+#define __SHFL_XOR(a, b) __shfl_xor(a, b)
+#else
+#define __SHFL_DOWN(a, b) __shfl_down_sync(0xffffffff, a, b)
+#define __SHFL_XOR(a, b) __shfl_xor_sync(0xffffffff, a, b)
+#endif
+
+template <int warp_count, int load_count>
+__global__ void CovarianceReductionKernel(
+    int gaussian_index,
+    const float* g_image,
+    const int* g_alpha,
+    float* g_matrices,
+    int element_count) {
+  constexpr int block_size = warp_count * 32;
+
+  __shared__ float s_matrix_component[warp_count];
+
+  int batch_index = blockIdx.z;
+
+  const float* g_batch_image = g_image + batch_index * element_count * CHANNEL_COUNT;
+  const int* g_batch_alpha = g_alpha + batch_index * element_count;
+  float* g_batch_matrices = g_matrices + batch_index * GMM_COUNT * GMM_COMPONENT_COUNT * gridDim.x;
+
+  int local_index = threadIdx.x;
+  int block_index = blockIdx.x;
+  int warp_index = local_index >> 5;
+  int lane_index = local_index & 31;
+  int global_index = local_index + block_index * block_size * load_count;
+  int matrix_offset = (gaussian_index * gridDim.x + block_index) * GMM_COMPONENT_COUNT;
+
+  float matrix[MATRIX_COMPONENT_COUNT];
+
+  for (int i = 0; i < MATRIX_COMPONENT_COUNT; i++) {
+    matrix[i] = 0;
+  }
+
+  for (int load = 0; load < load_count; load++) {
+    global_index += load * block_size;
+
+    if (global_index < element_count) {
+      int my_alpha = g_batch_alpha[global_index];
+
+      if (my_alpha != -1) {
+        if (gaussian_index == (my_alpha & 15) + (my_alpha >> 4) * MIXTURE_COUNT) {
+          float feature[CHANNEL_COUNT + 1];
+
+          feature[0] = 1;
+
+          for (int i = 0; i < CHANNEL_COUNT; i++) {
+            feature[i + 1] = g_batch_image[global_index + i * element_count];
+          }
+
+          for (int index = 0, i = 0; i < CHANNEL_COUNT + 1; i++) {
+            for (int j = i; j < CHANNEL_COUNT + 1; j++, index++) {
+              matrix[index] += feature[i] * feature[j];
+            }
+          }
+        }
+      }
+    }
+  }
+
+  __syncthreads();
+
+  for (int i = 0; i < MATRIX_COMPONENT_COUNT; i++) {
+    float matrix_component = matrix[i];
+    matrix_component += __SHFL_DOWN(matrix_component, 16);
+    matrix_component += __SHFL_DOWN(matrix_component, 8);
+    matrix_component += __SHFL_DOWN(matrix_component, 4);
+    matrix_component += __SHFL_DOWN(matrix_component, 2);
+    matrix_component += __SHFL_DOWN(matrix_component, 1);
+    if (lane_index == 0) {
+      s_matrix_component[warp_index] = matrix_component;
+    }
+
+    __syncthreads();
+
+    if (warp_index == 0) {
+      matrix_component = s_matrix_component[lane_index];
+      if (warp_count >= 32) {
+        matrix_component += __SHFL_DOWN(matrix_component, 16);
+      }
+      if (warp_count >= 16) {
+        matrix_component += __SHFL_DOWN(matrix_component, 8);
+      }
+      if (warp_count >= 8) {
+        matrix_component += __SHFL_DOWN(matrix_component, 4);
+      }
+      if (warp_count >= 4) {
+        matrix_component += __SHFL_DOWN(matrix_component, 2);
+      }
+      if (warp_count >= 2) {
+        matrix_component += __SHFL_DOWN(matrix_component, 1);
+      }
+      if (lane_index == 0) {
+        g_batch_matrices[matrix_offset + i] = matrix_component;
+      }
+    }
+
+    __syncthreads();
+  }
+}
+
+template <int warp_count, bool invert_matrix>
+__global__ void CovarianceFinalizationKernel(const float* g_matrices, float* g_gmm, int matrix_count) {
+  constexpr int block_size = warp_count * 32;
+
+  __shared__ float s_matrix_component[warp_count];
+  __shared__ float s_gmm[GMM_COMPONENT_COUNT];
+
+  int batch_index = blockIdx.z;
+
+  const float* g_batch_matrices = g_matrices + batch_index * GMM_COUNT * GMM_COMPONENT_COUNT * matrix_count;
+  float* g_batch_gmm = g_gmm + batch_index * GMM_COUNT * GMM_COMPONENT_COUNT;
+
+  int local_index = threadIdx.x;
+  int warp_index = local_index >> 5;
+  int lane_index = local_index & 31;
+  int gmm_index = blockIdx.x;
+  int matrix_offset = gmm_index * matrix_count;
+
+  int load_count = TILE(matrix_count, block_size);
+
+  float norm_factor = 1.0f;
+
+  for (int index = 0, i = 0; i < CHANNEL_COUNT + 1; i++) {
+    for (int j = i; j < CHANNEL_COUNT + 1; j++, index++) {
+      float matrix_component = 0.0f;
+
+      for (int load = 0; load < load_count; load++) {
+        int matrix_index = local_index + load * block_size;
+
+        if (matrix_index < matrix_count) {
+          matrix_component += g_batch_matrices[(matrix_offset + matrix_index) * GMM_COMPONENT_COUNT + index];
+        }
+      }
+      matrix_component += __SHFL_DOWN(matrix_component, 16);
+      matrix_component += __SHFL_DOWN(matrix_component, 8);
+      matrix_component += __SHFL_DOWN(matrix_component, 4);
+      matrix_component += __SHFL_DOWN(matrix_component, 2);
+      matrix_component += __SHFL_DOWN(matrix_component, 1);
+      if (lane_index == 0) {
+        s_matrix_component[warp_index] = matrix_component;
+      }
+
+      __syncthreads();
+
+      if (warp_index == 0) {
+        matrix_component = s_matrix_component[lane_index];
+        if (warp_count >= 32) {
+          matrix_component += __SHFL_DOWN(matrix_component, 16);
+        }
+        if (warp_count >= 16) {
+          matrix_component += __SHFL_DOWN(matrix_component, 8);
+        }
+        if (warp_count >= 8) {
+          matrix_component += __SHFL_DOWN(matrix_component, 4);
+        }
+        if (warp_count >= 4) {
+          matrix_component += __SHFL_DOWN(matrix_component, 2);
+        }
+        if (warp_count >= 2) {
+          matrix_component += __SHFL_DOWN(matrix_component, 1);
+        }
+        if (lane_index == 0) {
+          float constant = i == 0 ? 0.0f : s_gmm[i] * s_gmm[j];
+
+          if (i != 0 && i == j) {
+            constant -= EPSILON;
+          }
+
+          s_gmm[index] = norm_factor * matrix_component - constant;
+
+          if (index == 0 && matrix_component > 0) {
+            norm_factor = 1.0f / matrix_component;
+          }
+        }
+      }
+
+      __syncthreads();
+    }
+  }
+
+  float* matrix = s_gmm + (CHANNEL_COUNT + 1);
+  float* det_ptr = s_gmm + MATRIX_COMPONENT_COUNT;
+
+  if (local_index == 0) {
+    float square_mat[CHANNEL_COUNT][CHANNEL_COUNT];
+    float cholesky_mat[CHANNEL_COUNT][CHANNEL_COUNT];
+
+    for (int i = 0; i < CHANNEL_COUNT; i++) {
+      for (int j = 0; j < CHANNEL_COUNT; j++) {
+        square_mat[i][j] = 0.0f;
+        cholesky_mat[i][j] = 0.0f;
+      }
+    }
+
+    to_square(matrix, square_mat);
+    cholesky(square_mat, cholesky_mat);
+
+    *det_ptr = chol_det(cholesky_mat);
+
+    if (invert_matrix) {
+      chol_inv(cholesky_mat, square_mat);
+      to_triangle(square_mat, matrix);
+    }
+  }
+
+  if (local_index < GMM_COMPONENT_COUNT) {
+    g_batch_gmm[gmm_index * GMM_COMPONENT_COUNT + local_index] = s_gmm[local_index];
+  }
+}
+
+struct GMMSplit_t {
+  int idx;
+  float threshold;
+  float eigenvector[CHANNEL_COUNT];
+};
+
+// 1 Block, 32xMIXTURE_COUNT
+__global__ void GMMFindSplit(GMMSplit_t* gmmSplit, int gmmK, float* gmm) {
+  int batch_index = blockIdx.z;
+
+  float* g_batch_gmm = gmm + batch_index * GMM_COUNT * GMM_COMPONENT_COUNT;
+  GMMSplit_t* g_batch_gmmSplit = gmmSplit + batch_index * MIXTURE_COUNT;
+
+  int gmm_idx = threadIdx.x * MIXTURE_COUNT + threadIdx.y;
+
+  float eigenvalue = 0;
+  float eigenvector[CHANNEL_COUNT];
+
+  if (threadIdx.x < gmmK) {
+    float* matrix = g_batch_gmm + gmm_idx * GMM_COMPONENT_COUNT + (CHANNEL_COUNT + 1);
+    largest_eigenpair(matrix, eigenvector, &eigenvalue);
+  }
+
+  float max_value = eigenvalue;
+  max_value = max(max_value, __SHFL_XOR(max_value, 16));
+  max_value = max(max_value, __SHFL_XOR(max_value, 8));
+  max_value = max(max_value, __SHFL_XOR(max_value, 4));
+  max_value = max(max_value, __SHFL_XOR(max_value, 2));
+  max_value = max(max_value, __SHFL_XOR(max_value, 1));
+  if (max_value == eigenvalue) {
+    GMMSplit_t split;
+
+    float* average_feature = gmm + gmm_idx * GMM_COMPONENT_COUNT + 1;
+
+    split.idx = threadIdx.x;
+    split.threshold = scalar_prod(average_feature, eigenvector);
+
+    for (int i = 0; i < CHANNEL_COUNT; i++) {
+      split.eigenvector[i] = eigenvector[i];
+    }
+
+    g_batch_gmmSplit[threadIdx.y] = split;
+  }
+}
+
+#define DO_SPLIT_DEGENERACY 4
+
+__global__ void GMMDoSplit(const GMMSplit_t* gmmSplit, int k, const float* image, int* alpha, int element_count) {
+  __shared__ GMMSplit_t s_gmmSplit[MIXTURE_COUNT];
+
+  int batch_index = blockIdx.z;
+
+  const GMMSplit_t* g_batch_gmmSplit = gmmSplit + batch_index * MIXTURE_COUNT;
+  const float* g_batch_image = image + batch_index * element_count * CHANNEL_COUNT;
+  int* g_batch_alpha = alpha + batch_index * element_count;
+
+  int* s_linear = (int*)s_gmmSplit;
+  int* g_linear = (int*)g_batch_gmmSplit;
+
+  if (threadIdx.x < MIXTURE_COUNT * sizeof(GMMSplit_t)) {
+    s_linear[threadIdx.x] = g_linear[threadIdx.x];
+  }
+
+  __syncthreads();
+
+  int index = threadIdx.x + blockIdx.x * BLOCK_SIZE * DO_SPLIT_DEGENERACY;
+
+  for (int i = 0; i < DO_SPLIT_DEGENERACY; i++) {
+    index += BLOCK_SIZE;
+
+    if (index < element_count) {
+      int my_alpha = g_batch_alpha[index];
+
+      if (my_alpha != -1) {
+        int select = my_alpha & 15;
+        int gmm_idx = my_alpha >> 4;
+
+        if (gmm_idx == s_gmmSplit[select].idx) {
+          // in the split cluster now
+          float feature[CHANNEL_COUNT];
+
+          for (int i = 0; i < CHANNEL_COUNT; i++) {
+            feature[i] = g_batch_image[index + i * element_count];
+          }
+
+          float value = scalar_prod(s_gmmSplit[select].eigenvector, feature);
+
+          if (value > s_gmmSplit[select].threshold) {
+            // assign pixel to new cluster
+            g_batch_alpha[index] = k + select;
+          }
+        }
+      }
+    }
+  }
+}
+
+// Single block, 32xMIXTURE_COUNT
+__global__ void GMMcommonTerm(float* g_gmm) {
+  int batch_index = blockIdx.z;
+
+  float* g_batch_gmm = g_gmm + batch_index * GMM_COUNT * GMM_COMPONENT_COUNT;
+
+  int gmm_index = (threadIdx.x * MIXTURE_COUNT) + threadIdx.y;
+
+  float gmm_n = threadIdx.x < MIXTURE_SIZE ? g_batch_gmm[gmm_index * GMM_COMPONENT_COUNT] : 0.0f;
+
+  float sum = gmm_n;
+  sum += __SHFL_XOR(sum, 1);
+  sum += __SHFL_XOR(sum, 2);
+  sum += __SHFL_XOR(sum, 4);
+  sum += __SHFL_XOR(sum, 8);
+  sum += __SHFL_XOR(sum, 16);
+
+  if (threadIdx.x < MIXTURE_SIZE) {
+    float det = g_batch_gmm[gmm_index * GMM_COMPONENT_COUNT + MATRIX_COMPONENT_COUNT] + EPSILON;
+    float commonTerm = det > 0.0f ? gmm_n / (sqrtf(det) * sum) : gmm_n / sum;
+
+    g_batch_gmm[gmm_index * GMM_COMPONENT_COUNT + MATRIX_COMPONENT_COUNT] = commonTerm;
+  }
+}
+
+__device__ float GMMTerm(float* feature, const float* gmm) {
+  const float* average_feature = gmm + 1;
+  const float* matrix = gmm + CHANNEL_COUNT + 1;
+
+  float diff[CHANNEL_COUNT];
+
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    diff[i] = feature[i] - average_feature[i];
+  }
+
+  float value = 0.0f;
+
+  for (int index = 0, i = 0; i < CHANNEL_COUNT; i++) {
+    for (int j = i; j < CHANNEL_COUNT; j++, index++) {
+      float term = diff[i] * diff[j] * matrix[index];
+
+      value += i == j ? term : 2 * term;
+    }
+  }
+
+  return gmm[MATRIX_COMPONENT_COUNT] * expf(-0.5 * value);
+}
+
+__global__ void GMMDataTermKernel(const float* image, const float* gmm, float* output, int element_count) {
+  int batch_index = blockIdx.z;
+
+  const float* g_batch_image = image + batch_index * element_count * CHANNEL_COUNT;
+  const float* g_batch_gmm = gmm + batch_index * GMM_COUNT * GMM_COMPONENT_COUNT;
+  float* g_batch_output = output + batch_index * element_count * MIXTURE_COUNT;
+
+  int index = blockIdx.x * blockDim.x + threadIdx.x;
+
+  if (index >= element_count)
+    return;
+
+  float feature[CHANNEL_COUNT];
+
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    feature[i] = g_batch_image[index + i * element_count];
+  }
+
+  float weights[MIXTURE_COUNT];
+  float weight_total = 0.0f;
+
+  for (int i = 0; i < MIXTURE_COUNT; i++) {
+    float mixture_weight = 0.0f;
+
+    for (int j = 0; j < MIXTURE_SIZE; j++) {
+      mixture_weight += GMMTerm(feature, &g_batch_gmm[(MIXTURE_COUNT * j + i) * GMM_COMPONENT_COUNT]);
+    }
+
+    weights[i] = mixture_weight;
+    weight_total += mixture_weight;
+  }
+
+  for (int i = 0; i < MIXTURE_COUNT; i++) {
+    // protecting against pixels with 0 in all mixtures
+    float final_weight = weight_total > 0.0f ? weights[i] / weight_total : 0.0f;
+    g_batch_output[index + i * element_count] = final_weight;
+  }
+}
+
+#define THREADS 512
+#define WARPS 16
+#define BLOCK (WARPS << 5)
+#define LOAD 4
+
+void GMMInitialize(
+    const float* image,
+    int* alpha,
+    float* gmm,
+    float* scratch_mem,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  unsigned int block_count = TILE(element_count, BLOCK * LOAD);
+
+  float* block_gmm_scratch = scratch_mem;
+  GMMSplit_t* gmm_split_scratch = (GMMSplit_t*)scratch_mem;
+
+  int gmm_N = MIXTURE_COUNT * MIXTURE_SIZE;
+
+  for (unsigned int k = MIXTURE_COUNT; k < gmm_N; k += MIXTURE_COUNT) {
+    for (unsigned int i = 0; i < k; ++i) {
+      CovarianceReductionKernel<WARPS, LOAD>
+          <<<dim3(block_count, 1, batch_count), BLOCK>>>(i, image, alpha, block_gmm_scratch, element_count);
+    }
+
+    CovarianceFinalizationKernel<WARPS, false><<<dim3(k, 1, batch_count), BLOCK>>>(block_gmm_scratch, gmm, block_count);
+
+    GMMFindSplit<<<dim3(1, 1, batch_count), dim3(BLOCK_SIZE, MIXTURE_COUNT)>>>(
+        gmm_split_scratch, k / MIXTURE_COUNT, gmm);
+    GMMDoSplit<<<dim3(TILE(element_count, BLOCK_SIZE * DO_SPLIT_DEGENERACY), 1, batch_count), BLOCK_SIZE>>>(
+        gmm_split_scratch, (k / MIXTURE_COUNT) << 4, image, alpha, element_count);
+  }
+}
+
+void GMMUpdate(
+    const float* image,
+    int* alpha,
+    float* gmm,
+    float* scratch_mem,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  unsigned int block_count = TILE(element_count, BLOCK * LOAD);
+
+  float* block_gmm_scratch = scratch_mem;
+
+  unsigned int gmm_N = MIXTURE_COUNT * MIXTURE_SIZE;
+
+  for (unsigned int i = 0; i < gmm_N; ++i) {
+    CovarianceReductionKernel<WARPS, LOAD>
+        <<<dim3(block_count, 1, batch_count), BLOCK>>>(i, image, alpha, block_gmm_scratch, element_count);
+  }
+
+  CovarianceFinalizationKernel<WARPS, true>
+      <<<dim3(gmm_N, 1, batch_count), BLOCK>>>(block_gmm_scratch, gmm, block_count);
+
+  GMMcommonTerm<<<dim3(1, 1, batch_count), dim3(BLOCK_SIZE, MIXTURE_COUNT)>>>(gmm);
+}
+
+void GMMDataTerm(
+    const float* image,
+    const float* gmm,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  dim3 block(BLOCK_SIZE, 1);
+  dim3 grid(TILE(element_count, BLOCK_SIZE), 1, batch_count);
+
+  GMMDataTermKernel<<<grid, block>>>(image, gmm, output, element_count);
+}
+
+void learn_cuda(
+    const float* input,
+    const int* labels,
+    float* gmm,
+    float* scratch_memory,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  int* alpha = (int*)scratch_memory;
+  float* scratch_mem = scratch_memory + batch_count * element_count;
+
+  cudaMemcpyAsync(alpha, labels, batch_count * element_count * sizeof(int), cudaMemcpyDeviceToDevice);
+
+  GMMInitialize(input, alpha, gmm, scratch_mem, batch_count, element_count);
+  GMMUpdate(input, alpha, gmm, scratch_mem, batch_count, element_count);
+}
+
+void apply_cuda(
+    const float* gmm,
+    const float* input,
+    float* output,
+    unsigned int batch_count,
+    unsigned int element_count) {
+  GMMDataTerm(input, gmm, output, batch_count, element_count);
+}

source_code/SegMamba/monai/_extensions/gmm/gmm_cuda_linalg.cuh

@@ -0,0 +1,144 @@
+/*
+Copyright (c) MONAI Consortium
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+__device__ void to_square(float in[SUB_MATRIX_COMPONENT_COUNT], float out[CHANNEL_COUNT][CHANNEL_COUNT]) {
+  for (int index = 0, i = 0; i < CHANNEL_COUNT; i++) {
+    for (int j = i; j < CHANNEL_COUNT; j++, index++) {
+      out[i][j] = in[index];
+      out[j][i] = in[index];
+    }
+  }
+}
+
+__device__ void to_triangle(float in[CHANNEL_COUNT][CHANNEL_COUNT], float out[SUB_MATRIX_COMPONENT_COUNT]) {
+  for (int index = 0, i = 0; i < CHANNEL_COUNT; i++) {
+    for (int j = i; j < CHANNEL_COUNT; j++, index++) {
+      out[index] = in[j][i];
+    }
+  }
+}
+
+__device__ void cholesky(float in[CHANNEL_COUNT][CHANNEL_COUNT], float out[CHANNEL_COUNT][CHANNEL_COUNT]) {
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    for (int j = 0; j < i + 1; j++) {
+      float sum = 0.0f;
+
+      for (int k = 0; k < j; k++) {
+        sum += out[i][k] * out[j][k];
+      }
+
+      if (i == j) {
+        out[i][j] = sqrtf(in[i][i] - sum);
+      } else {
+        out[i][j] = (in[i][j] - sum) / out[j][j];
+      }
+    }
+  }
+}
+
+__device__ float chol_det(float in[CHANNEL_COUNT][CHANNEL_COUNT]) {
+  float det = 1.0f;
+
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    det *= in[i][i];
+  }
+
+  return det * det;
+}
+
+__device__ void chol_inv(float in[CHANNEL_COUNT][CHANNEL_COUNT], float out[CHANNEL_COUNT][CHANNEL_COUNT]) {
+  // Invert cholesky matrix
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    in[i][i] = 1.0f / (in[i][i] + 0.0001f);
+
+    for (int j = 0; j < i; j++) {
+      float sum = 0.0f;
+
+      for (int k = j; k < i; k++) {
+        sum += in[i][k] * in[k][j];
+      }
+
+      in[i][j] = -in[i][i] * sum;
+    }
+  }
+
+  // Dot with transpose of self
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    for (int j = 0; j < CHANNEL_COUNT; j++) {
+      out[i][j] = 0.0f;
+
+      for (int k = max(i, j); k < CHANNEL_COUNT; k++) {
+        out[i][j] += in[k][i] * in[k][j];
+      }
+    }
+  }
+}
+
+__device__ void normalize(float* v) {
+  float norm = 0.0f;
+
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    norm += v[i] * v[i];
+  }
+
+  norm = 1.0f / sqrtf(norm);
+
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    v[i] *= norm;
+  }
+}
+
+__device__ float scalar_prod(float* a, float* b) {
+  float product = 0.0f;
+
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    product += a[i] * b[i];
+  }
+
+  return product;
+}
+
+__device__ void largest_eigenpair(const float* M, float* evec, float* eval) {
+  float scratch[CHANNEL_COUNT];
+
+  for (int i = 0; i < CHANNEL_COUNT; i++) {
+    scratch[i] = i + 1;
+  }
+
+  for (int itr = 0; itr < 10; itr++) {
+    *eval = 0.0f;
+
+    for (int i = 0; i < CHANNEL_COUNT; i++) {
+      int index = i;
+
+      evec[i] = 0.0f;
+
+      for (int j = 0; j < CHANNEL_COUNT; j++) {
+        evec[i] += M[index] * scratch[j];
+
+        if (j < i) {
+          index += CHANNEL_COUNT - (j + 1);
+        } else {
+          index += 1;
+        }
+      }
+
+      *eval = max(*eval, evec[i]);
+    }
+
+    for (int i = 0; i < CHANNEL_COUNT; i++) {
+      evec[i] /= *eval;
+      scratch[i] = evec[i];
+    }
+  }
+}

source_code/SegMamba/monai/apps/auto3dseg/auto_runner.py

@@ -0,0 +1,898 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+import shutil
+import warnings
+from copy import deepcopy
+from time import sleep
+from typing import Any, cast
+
+import torch
+
+from monai.apps.auto3dseg.bundle_gen import BundleGen
+from monai.apps.auto3dseg.data_analyzer import DataAnalyzer
+from monai.apps.auto3dseg.ensemble_builder import EnsembleRunner
+from monai.apps.auto3dseg.hpo_gen import NNIGen
+from monai.apps.auto3dseg.utils import export_bundle_algo_history, import_bundle_algo_history
+from monai.apps.utils import get_logger
+from monai.auto3dseg.utils import algo_to_pickle
+from monai.bundle import ConfigParser
+from monai.transforms import SaveImage
+from monai.utils import AlgoKeys, has_option, look_up_option, optional_import
+from monai.utils.misc import check_kwargs_exist_in_class_init, run_cmd
+
+logger = get_logger(module_name=__name__)
+
+nni, has_nni = optional_import("nni")
+
+
+class AutoRunner:
+    """
+    An interface for handling Auto3Dseg with minimal inputs and understanding of the internal states in Auto3Dseg.
+    The users can run the Auto3Dseg with default settings in one line of code. They can also customize the advanced
+    features Auto3Dseg in a few additional lines. Examples of customization include
+
+        - change cross-validation folds
+        - change training/prediction parameters
+        - change ensemble methods
+        - automatic hyperparameter optimization.
+
+    The output of the interface is a directory that contains
+
+        - data statistics analysis report
+        - algorithm definition files (scripts, configs, pickle objects) and training results (checkpoints, accuracies)
+        - the predictions on the testing datasets from the final algorithm ensemble
+        - a copy of the input arguments in form of YAML
+        - cached intermediate results
+
+    Args:
+        work_dir: working directory to save the intermediate and final results.
+        input: the configuration dictionary or the file path to the configuration in form of YAML.
+            The configuration should contain datalist, dataroot, modality, multigpu, and class_names info.
+        algos: optionally specify algorithms to use.  If a dictionary, must be in the form
+            {"algname": dict(_target_="algname.scripts.algo.AlgnameAlgo", template_path="algname"), ...}
+            If a list or a string, defines a subset of names of the algorithms to use, e.g. 'segresnet' or
+            ['segresnet', 'dints'] out of the full set of algorithm templates provided by templates_path_or_url.
+            Defaults to None, to use all available algorithms.
+        analyze: on/off switch to run DataAnalyzer and generate a datastats report. Defaults to None, to automatically
+            decide based on cache, and run data analysis only if we have not completed this step yet.
+        algo_gen: on/off switch to run AlgoGen and generate templated BundleAlgos. Defaults to None, to automatically
+            decide based on cache, and run algorithm folders generation only if we have not completed this step yet.
+        train: on/off switch to run training and generate algorithm checkpoints. Defaults to None, to automatically
+            decide based on cache, and run training only if we have not completed this step yet.
+        hpo: use hyperparameter optimization (HPO) in the training phase. Users can provide a list of
+            hyper-parameter and a search will be performed to investigate the algorithm performances.
+        hpo_backend: a string that indicates the backend of the HPO. Currently, only NNI Grid-search mode
+            is supported
+        ensemble: on/off switch to run model ensemble and use the ensemble to predict outputs in testing
+            datasets.
+        not_use_cache: if the value is True, it will ignore all cached results in data analysis,
+            algorithm generation, or training, and start the pipeline from scratch.
+        templates_path_or_url: the folder with the algorithm templates or a url. If None provided, the default template
+            zip url will be downloaded and extracted into the work_dir.
+        allow_skip: a switch passed to BundleGen process which determines if some Algo in the default templates
+            can be skipped based on the analysis on the dataset from Auto3DSeg DataAnalyzer.
+        mlflow_tracking_uri: a tracking URI for MLflow server which could be local directory or address of the remote
+            tracking Server; MLflow runs will be recorded locally in algorithms' model folder if the value is None.
+        mlflow_experiment_name: the name of the experiment in MLflow server.
+        kwargs: image writing parameters for the ensemble inference. The kwargs format follows the SaveImage
+            transform. For more information, check https://docs.monai.io/en/stable/transforms.html#saveimage.
+
+
+    Examples:
+        - User can use the one-liner to start the Auto3Dseg workflow
+
+        .. code-block:: bash
+
+            python -m monai.apps.auto3dseg AutoRunner run --input \
+            '{"modality": "ct", "datalist": "dl.json", "dataroot": "/dr", "multigpu": true, "class_names": ["A", "B"]}'
+
+        - User can also save the input dictionary as a input YAML file and use the following one-liner
+
+        .. code-block:: bash
+
+            python -m monai.apps.auto3dseg AutoRunner run --input=./input.yaml
+
+        - User can specify work_dir and data source config input and run AutoRunner:
+
+        .. code-block:: python
+
+            work_dir = "./work_dir"
+            input = "path/to/input_yaml"
+            runner = AutoRunner(work_dir=work_dir, input=input)
+            runner.run()
+
+        - User can specify a subset of algorithms to use and run AutoRunner:
+
+        .. code-block:: python
+
+            work_dir = "./work_dir"
+            input = "path/to/input_yaml"
+            algos = ["segresnet", "dints"]
+            runner = AutoRunner(work_dir=work_dir, input=input, algos=algos)
+            runner.run()
+
+        - User can specify a local folder with algorithms templates and run AutoRunner:
+
+        .. code-block:: python
+
+            work_dir = "./work_dir"
+            input = "path/to/input_yaml"
+            algos = "segresnet"
+            templates_path_or_url = "./local_path_to/algorithm_templates"
+            runner = AutoRunner(work_dir=work_dir, input=input, algos=algos, templates_path_or_url=templates_path_or_url)
+            runner.run()
+
+        - User can specify training parameters by:
+
+        .. code-block:: python
+
+            input = "path/to/input_yaml"
+            runner = AutoRunner(input=input)
+            train_param = {
+                "num_epochs_per_validation": 1,
+                "num_images_per_batch": 2,
+                "num_epochs": 2,
+            }
+            runner.set_training_params(params=train_param)  # 2 epochs
+            runner.run()
+
+        - User can specify the fold number of cross validation
+
+        .. code-block:: python
+
+            input = "path/to/input_yaml"
+            runner = AutoRunner(input=input)
+            runner.set_num_fold(n_fold = 2)
+            runner.run()
+
+        - User can specify the prediction parameters during algo ensemble inference:
+
+        .. code-block:: python
+
+            input = "path/to/input_yaml"
+            pred_params = {
+                'files_slices': slice(0,2),
+                'mode': "vote",
+                'sigmoid': True,
+            }
+            runner = AutoRunner(input=input)
+            runner.set_prediction_params(params=pred_params)
+            runner.run()
+
+        - User can define a grid search space and use the HPO during training.
+
+        .. code-block:: python
+
+            input = "path/to/input_yaml"
+            runner = AutoRunner(input=input, hpo=True)
+            runner.set_nni_search_space({"learning_rate": {"_type": "choice", "_value": [0.0001, 0.001, 0.01, 0.1]}})
+            runner.run()
+
+    Notes:
+        Expected results in the work_dir as below::
+
+            work_dir/
+            ├── algorithm_templates # bundle algo templates (scripts/configs)
+            ├── cache.yaml          # Autorunner will automatically cache results to save time
+            ├── datastats.yaml      # datastats of the dataset
+            ├── dints_0             # network scripts/configs/checkpoints and pickle object of the algo
+            ├── ensemble_output     # the prediction of testing datasets from the ensemble of the algos
+            ├── input.yaml          # copy of the input data source configs
+            ├── segresnet_0         # network scripts/configs/checkpoints and pickle object of the algo
+            ├── segresnet2d_0       # network scripts/configs/checkpoints and pickle object of the algo
+            └── swinunetr_0         # network scripts/configs/checkpoints and pickle object of the algo
+
+    """
+
+    analyze_params: dict | None
+
+    def __init__(
+        self,
+        work_dir: str = "./work_dir",
+        input: dict[str, Any] | str | None = None,
+        algos: dict | list | str | None = None,
+        analyze: bool | None = None,
+        algo_gen: bool | None = None,
+        train: bool | None = None,
+        hpo: bool = False,
+        hpo_backend: str = "nni",
+        ensemble: bool = True,
+        not_use_cache: bool = False,
+        templates_path_or_url: str | None = None,
+        allow_skip: bool = True,
+        mlflow_tracking_uri: str | None = None,
+        mlflow_experiment_name: str | None = None,
+        **kwargs: Any,
+    ):
+        if input is None and os.path.isfile(os.path.join(os.path.abspath(work_dir), "input.yaml")):
+            input = os.path.join(os.path.abspath(work_dir), "input.yaml")
+            logger.info(f"Input config is not provided, using the default {input}")
+
+        self.data_src_cfg = dict()
+        if isinstance(input, dict):
+            self.data_src_cfg = input
+        elif isinstance(input, str) and os.path.isfile(input):
+            self.data_src_cfg = ConfigParser.load_config_file(input)
+            logger.info(f"Loading input config {input}")
+        else:
+            raise ValueError(f"{input} is not a valid file or dict")
+
+        if "work_dir" in self.data_src_cfg:  # override from config
+            work_dir = self.data_src_cfg["work_dir"]
+        self.work_dir = os.path.abspath(work_dir)
+
+        logger.info(f"AutoRunner using work directory {self.work_dir}")
+        os.makedirs(self.work_dir, exist_ok=True)
+        self.data_src_cfg_name = os.path.join(self.work_dir, "input.yaml")
+
+        self.algos = algos
+        self.templates_path_or_url = templates_path_or_url
+        self.allow_skip = allow_skip
+
+        # cache.yaml
+        self.not_use_cache = not_use_cache
+        self.cache_filename = os.path.join(self.work_dir, "cache.yaml")
+        self.cache = self.read_cache()
+        self.export_cache()
+
+        # determine if we need to analyze, algo_gen or train from cache, unless manually provided
+        self.analyze = not self.cache["analyze"] if analyze is None else analyze
+        self.algo_gen = not self.cache["algo_gen"] if algo_gen is None else algo_gen
+        self.train = train
+        self.ensemble = ensemble  # last step, no need to check
+        self.hpo = hpo and has_nni
+        self.hpo_backend = hpo_backend
+        self.mlflow_tracking_uri = mlflow_tracking_uri
+        self.mlflow_experiment_name = mlflow_experiment_name
+        self.kwargs = deepcopy(kwargs)
+
+        # parse input config for AutoRunner param overrides
+        for param in [
+            "analyze",
+            "algo_gen",
+            "train",
+            "hpo",
+            "ensemble",
+            "not_use_cache",
+            "allow_skip",
+        ]:  # override from config
+            if param in self.data_src_cfg and isinstance(self.data_src_cfg[param], bool):
+                setattr(self, param, self.data_src_cfg[param])  # e.g. self.analyze = self.data_src_cfg["analyze"]
+
+        for param in [
+            "algos",
+            "hpo_backend",
+            "templates_path_or_url",
+            "mlflow_tracking_uri",
+            "mlflow_experiment_name",
+        ]:  # override from config
+            if param in self.data_src_cfg:
+                setattr(self, param, self.data_src_cfg[param])  # e.g. self.algos = self.data_src_cfg["algos"]
+
+        missing_keys = {"dataroot", "datalist", "modality"}.difference(self.data_src_cfg.keys())
+        if len(missing_keys) > 0:
+            raise ValueError(f"Config keys are missing {missing_keys}")
+
+        if not os.path.exists(self.data_src_cfg["datalist"]):
+            raise ValueError(f"Datalist file is not found {self.data_src_cfg['datalist']}")
+
+        # copy datalist to work_dir
+        datalist_filename = os.path.join(self.work_dir, os.path.basename(self.data_src_cfg["datalist"]))
+        if datalist_filename != self.data_src_cfg["datalist"]:
+            try:
+                shutil.copyfile(self.data_src_cfg["datalist"], datalist_filename)
+                logger.info(f"Datalist was copied to work_dir: {datalist_filename}")
+            except shutil.SameFileError:
+                pass
+
+        # inspect and update folds
+        self.max_fold = self.inspect_datalist_folds(datalist_filename=datalist_filename)
+        if "num_fold" in self.data_src_cfg:
+            num_fold = int(self.data_src_cfg["num_fold"])  # override from config
+            logger.info(f"Setting num_fold {num_fold} based on the input config.")
+        else:
+            num_fold = self.max_fold
+            logger.info(f"Setting num_fold {num_fold} based on the input datalist {datalist_filename}.")
+
+        self.data_src_cfg["datalist"] = datalist_filename  # update path to a version in work_dir and save user input
+        ConfigParser.export_config_file(
+            config=self.data_src_cfg, filepath=self.data_src_cfg_name, fmt="yaml", sort_keys=False
+        )
+
+        self.dataroot = self.data_src_cfg["dataroot"]
+        self.datastats_filename = os.path.join(self.work_dir, "datastats.yaml")
+        self.datalist_filename = datalist_filename
+
+        self.set_training_params()
+        self.set_device_info()
+        self.set_prediction_params()
+        self.set_analyze_params()
+        self.set_ensemble_method()
+        self.set_num_fold(num_fold=num_fold)
+
+        self.gpu_customization = False
+        self.gpu_customization_specs: dict[str, Any] = {}
+
+        # hpo
+        if self.hpo_backend.lower() != "nni":
+            raise NotImplementedError("HPOGen backend only supports NNI")
+        self.hpo = self.hpo and has_nni
+        self.set_hpo_params()
+        self.search_space: dict[str, dict[str, Any]] = {}
+        self.hpo_tasks = 0
+
+        if "sigmoid" not in self.kwargs and "sigmoid" in self.data_src_cfg:
+            self.kwargs["sigmoid"] = self.data_src_cfg["sigmoid"]
+
+    def read_cache(self):
+        """
+        Check if the intermediate result is cached after each step in the current working directory
+
+        Returns:
+            a dict of cache results. If not_use_cache is set to True, or there is no cache file in the
+            working directory, the result will be ``empty_cache`` in which all ``has_cache`` keys are
+            set to False.
+        """
+
+        empty_cache = {"analyze": False, "datastats": None, "algo_gen": False, "train": False}
+
+        if self.not_use_cache or not os.path.isfile(self.cache_filename):
+            return empty_cache
+
+        cache = ConfigParser.load_config_file(self.cache_filename)
+
+        for k, v in empty_cache.items():
+            cache.setdefault(k, v)
+
+        if cache["analyze"]:
+            if not (isinstance(cache["datastats"], str) and os.path.isfile(cache["datastats"])):
+                cache["analyze"] = False
+                cache["datastats"] = None
+
+        if cache["algo_gen"]:
+            history = import_bundle_algo_history(self.work_dir, only_trained=False)
+            if len(history) == 0:  # no saved algo_objects
+                cache["algo_gen"] = False
+
+        if cache["train"]:
+            trained_history = import_bundle_algo_history(self.work_dir, only_trained=True)
+            if len(trained_history) == 0:
+                cache["train"] = False
+
+        return cache
+
+    def export_cache(self, **kwargs):
+        """
+        Save the cache state as ``cache.yaml`` in the working directory
+        """
+        self.cache.update(kwargs)
+        ConfigParser.export_config_file(
+            self.cache, self.cache_filename, fmt="yaml", default_flow_style=None, sort_keys=False
+        )
+
+    def inspect_datalist_folds(self, datalist_filename: str) -> int:
+        """
+        Returns number of folds in the datalist file, and assigns fold numbers if not provided.
+
+        Args:
+            datalist_filename: path to the datalist file.
+
+        Notes:
+            If the fold key is not provided, it auto generates 5 folds assignments in the training key list.
+            If validation key list is available, then it assumes a single fold validation.
+        """
+
+        datalist = ConfigParser.load_config_file(datalist_filename)
+        if "training" not in datalist:
+            raise ValueError("Datalist files has no training key:" + str(datalist_filename))
+
+        fold_list = [int(d["fold"]) for d in datalist["training"] if "fold" in d]
+
+        if len(fold_list) > 0:
+            num_fold = max(fold_list) + 1
+            logger.info(f"Found num_fold {num_fold} based on the input datalist {datalist_filename}.")
+            # check if every fold is present
+            if len(set(fold_list)) != num_fold:
+                raise ValueError(f"Fold numbers are not continuous from 0 to {num_fold - 1}")
+        elif "validation" in datalist and len(datalist["validation"]) > 0:
+            logger.info("No fold numbers provided, attempting to use a single fold based on the validation key")
+            # update the datalist file
+            for d in datalist["training"]:
+                d["fold"] = 1
+            for d in datalist["validation"]:
+                d["fold"] = 0
+
+            val_labels = {d["label"]: d for d in datalist["validation"] if "label" in d}
+            logger.info(
+                f"Found {len(val_labels)} items in the validation key, saving updated datalist to", datalist_filename
+            )
+
+            # check for duplicates
+            for d in datalist["training"]:
+                if d["label"] in val_labels:
+                    d["fold"] = 0
+                    del val_labels[d["label"]]
+
+            datalist["training"] = datalist["training"] + list(val_labels.values())
+
+            ConfigParser.export_config_file(datalist, datalist_filename, fmt="json", indent=4)
+            num_fold = 1
+
+        else:
+            num_fold = 5
+
+            warnings.warn(
+                f"Datalist has no folds specified {datalist_filename}..."
+                f"Generating {num_fold} folds randomly."
+                f"Please consider presaving fold numbers beforehand for repeated experiments."
+            )
+
+            from sklearn.model_selection import KFold
+
+            kf = KFold(n_splits=num_fold, shuffle=True, random_state=0)
+            for i, (_, valid_idx) in enumerate(kf.split(datalist["training"])):
+                for vi in valid_idx:
+                    datalist["training"][vi]["fold"] = i
+
+            ConfigParser.export_config_file(datalist, datalist_filename, fmt="json", indent=4)
+
+        return num_fold
+
+    def set_gpu_customization(
+        self, gpu_customization: bool = False, gpu_customization_specs: dict[str, Any] | None = None
+    ) -> AutoRunner:
+        """
+        Set options for GPU-based parameter customization/optimization.
+
+        Args:
+            gpu_customization: the switch to determine automatically customize/optimize bundle script/config
+                parameters for each bundleAlgo based on gpus. Custom parameters are obtained through dummy
+                training to simulate the actual model training process and hyperparameter optimization (HPO)
+                experiments.
+            gpu_customization_specs (optional): the dictionary to enable users overwrite the HPO settings. user can
+                overwrite part of variables as follows or all of them. The structure is as follows.
+
+                .. code-block:: python
+
+                    gpu_customization_specs = {
+                        'ALGO': {
+                            'num_trials': 6,
+                            'range_num_images_per_batch': [1, 20],
+                            'range_num_sw_batch_size': [1, 20]
+                        }
+                    }
+
+            ALGO: the name of algorithm. It could be one of algorithm names (e.g., 'dints') or 'universal' which
+                would apply changes to all algorithms. Possible options are
+
+                - {``"universal"``, ``"dints"``, ``"segresnet"``, ``"segresnet2d"``, ``"swinunetr"``}.
+
+            num_trials: the number of HPO trials/experiments to run.
+            range_num_images_per_batch: the range of number of images per mini-batch.
+            range_num_sw_batch_size: the range of batch size in sliding-window inferer.
+        """
+        self.gpu_customization = gpu_customization
+        if gpu_customization_specs is not None:
+            self.gpu_customization_specs = gpu_customization_specs
+
+        return self
+
+    def set_num_fold(self, num_fold: int = 5) -> AutoRunner:
+        """
+        Set the number of cross validation folds for all algos.
+
+        Args:
+            num_fold: a positive integer to define the number of folds.
+        """
+
+        if num_fold <= 0:
+            raise ValueError(f"num_fold is expected to be an integer greater than zero. Now it gets {num_fold}")
+        if num_fold > self.max_fold + 1:
+            # Auto3DSeg allows no validation set, so the maximum fold number is max_fold + 1
+            raise ValueError(
+                f"num_fold is greater than the maximum fold number {self.max_fold} in {self.datalist_filename}."
+            )
+        self.num_fold = num_fold
+
+        return self
+
+    def set_training_params(self, params: dict[str, Any] | None = None) -> AutoRunner:
+        """
+        Set the training params for all algos.
+
+        Args:
+            params: a dict that defines the overriding key-value pairs during training. The overriding method
+                is defined by the algo class.
+
+        Examples:
+            For BundleAlgo objects, the training parameter to shorten the training time to a few epochs can be
+                {"num_epochs": 2, "num_epochs_per_validation": 1}
+
+        """
+        self.train_params = deepcopy(params) if params is not None else {}
+        if "CUDA_VISIBLE_DEVICES" in self.train_params:
+            warnings.warn(
+                "CUDA_VISIBLE_DEVICES is deprecated from 'set_training_params'. Use 'set_device_info' instead.",
+                DeprecationWarning,
+            )
+
+        return self
+
+    def set_device_info(
+        self,
+        cuda_visible_devices: list[int] | str | None = None,
+        num_nodes: int | None = None,
+        mn_start_method: str | None = None,
+        cmd_prefix: str | None = None,
+    ) -> AutoRunner:
+        """
+        Set the device related info
+
+        Args:
+            cuda_visible_devices: define GPU ids for data analyzer, training, and ensembling.
+                List of GPU ids [0,1,2,3] or a string "0,1,2,3".
+                Default using env "CUDA_VISIBLE_DEVICES" or all devices available.
+            num_nodes: number of nodes for training and ensembling.
+                Default using env "NUM_NODES" or 1 if "NUM_NODES" is unset.
+            mn_start_method: multi-node start method. Autorunner will use the method to start multi-node processes.
+                Default using env "MN_START_METHOD" or 'bcprun' if "MN_START_METHOD" is unset.
+            cmd_prefix: command line prefix for subprocess running in BundleAlgo and EnsembleRunner.
+                Default using env "CMD_PREFIX" or None, examples are:
+
+                    - single GPU/CPU or multinode bcprun: "python " or "/opt/conda/bin/python3.8 ",
+                    - single node multi-GPU running "torchrun --nnodes=1 --nproc_per_node=2 "
+
+                If user define this prefix, please make sure --nproc_per_node matches cuda_visible_device or
+                os.env['CUDA_VISIBLE_DEVICES']. Also always set --nnodes=1. Set num_nodes for multi-node.
+        """
+        self.device_setting: dict[str, Any] = {}
+        if cuda_visible_devices is None:
+            cuda_visible_devices = os.environ.get("CUDA_VISIBLE_DEVICES")
+        if cuda_visible_devices is None:  # still None after reading the environ
+            self.device_setting["CUDA_VISIBLE_DEVICES"] = ",".join([str(x) for x in range(torch.cuda.device_count())])
+            self.device_setting["n_devices"] = torch.cuda.device_count()
+        elif isinstance(cuda_visible_devices, str):
+            self.device_setting["CUDA_VISIBLE_DEVICES"] = cuda_visible_devices
+            self.device_setting["n_devices"] = len(cuda_visible_devices.split(","))
+        elif isinstance(cuda_visible_devices, (list, tuple)):
+            self.device_setting["CUDA_VISIBLE_DEVICES"] = ",".join([str(x) for x in cuda_visible_devices])
+            self.device_setting["n_devices"] = len(cuda_visible_devices)
+        else:
+            logger.warn(f"Wrong format of cuda_visible_devices {cuda_visible_devices}, devices not set")
+
+        if num_nodes is None:
+            num_nodes = int(os.environ.get("NUM_NODES", 1))
+        self.device_setting["NUM_NODES"] = num_nodes
+
+        if mn_start_method is None:
+            mn_start_method = os.environ.get("MN_START_METHOD", "bcprun")
+        self.device_setting["MN_START_METHOD"] = mn_start_method
+
+        if cmd_prefix is None:
+            cmd_prefix = os.environ.get("CMD_PREFIX", "")
+        self.device_setting["CMD_PREFIX"] = cmd_prefix
+
+        if cmd_prefix is not None:
+            logger.info(f"Using user defined command running prefix {cmd_prefix}, will override other settings")
+
+        return self
+
+    def set_ensemble_method(self, ensemble_method_name: str = "AlgoEnsembleBestByFold", **kwargs: Any) -> AutoRunner:
+        """
+        Set the bundle ensemble method name and parameters for save image transform parameters.
+
+        Args:
+            ensemble_method_name: the name of the ensemble method. Only two methods are supported "AlgoEnsembleBestN"
+                and "AlgoEnsembleBestByFold".
+            kwargs: the keyword arguments used to define the ensemble method. Currently only ``n_best`` for
+                ``AlgoEnsembleBestN`` is supported.
+        """
+        self.ensemble_method_name = look_up_option(
+            ensemble_method_name, supported=["AlgoEnsembleBestN", "AlgoEnsembleBestByFold"]
+        )
+        self.kwargs.update(kwargs)
+
+        return self
+
+    def set_image_save_transform(self, **kwargs: Any) -> AutoRunner:
+        """
+        Set the ensemble output transform.
+
+        Args:
+            kwargs: image writing parameters for the ensemble inference. The kwargs format follows SaveImage
+                transform. For more information, check https://docs.monai.io/en/stable/transforms.html#saveimage.
+
+        """
+
+        are_all_args_present, extra_args = check_kwargs_exist_in_class_init(SaveImage, kwargs)
+        if are_all_args_present:
+            self.kwargs.update(kwargs)
+        else:
+            raise ValueError(
+                f"{extra_args} are not supported in monai.transforms.SaveImage,"
+                "Check https://docs.monai.io/en/stable/transforms.html#saveimage for more information."
+            )
+
+        return self
+
+    def set_prediction_params(self, params: dict[str, Any] | None = None) -> AutoRunner:
+        """
+        Set the prediction params for all algos.
+
+        Args:
+            params: a dict that defines the overriding key-value pairs during prediction. The overriding method
+                is defined by the algo class.
+
+        Examples:
+
+            For BundleAlgo objects, this set of param will specify the algo ensemble to only inference the first
+                two files in the testing datalist {"file_slices": slice(0, 2)}
+
+        """
+        self.pred_params = deepcopy(params) if params is not None else {}
+
+        return self
+
+    def set_analyze_params(self, params: dict[str, Any] | None = None) -> AutoRunner:
+        """
+        Set the data analysis extra params.
+
+        Args:
+            params: a dict that defines the overriding key-value pairs during training. The overriding method
+                is defined by the algo class.
+
+        """
+        if params is None:
+            self.analyze_params = {"do_ccp": False, "device": "cuda"}
+        else:
+            self.analyze_params = deepcopy(params)
+
+        return self
+
+    def set_hpo_params(self, params: dict[str, Any] | None = None) -> AutoRunner:
+        """
+        Set parameters for the HPO module and the algos before the training. It will attempt to (1) override bundle
+        templates with the key-value pairs in ``params`` (2) change the config of the HPO module (e.g. NNI) if the
+        key is found to be one of:
+
+            - "trialCodeDirectory"
+            - "trialGpuNumber"
+            - "trialConcurrency"
+            - "maxTrialNumber"
+            - "maxExperimentDuration"
+            - "tuner"
+            - "trainingService"
+
+        and (3) enable the dry-run mode if the user would generate the NNI configs without starting the NNI service.
+
+        Args:
+            params: a dict that defines the overriding key-value pairs during instantiation of the algo. For
+                BundleAlgo, it will override the template config filling.
+
+        Notes:
+            Users can set ``nni_dry_run`` to ``True`` in the ``params`` to enable the dry-run mode for the NNI backend.
+
+        """
+        self.hpo_params = self.train_params if params is None else params
+
+        return self
+
+    def set_nni_search_space(self, search_space: dict[str, Any]) -> AutoRunner:
+        """
+        Set the search space for NNI parameter search.
+
+        Args:
+            search_space: hyper parameter search space in the form of dict. For more information, please check
+                NNI documentation: https://nni.readthedocs.io/en/v2.2/Tutorial/SearchSpaceSpec.html .
+        """
+        value_combinations = 1
+        for k, v in search_space.items():
+            if "_value" not in v:
+                raise ValueError(f"{search_space} key {k} value {v} has not _value")
+            value_combinations *= len(v["_value"])
+
+        self.search_space = search_space
+        self.hpo_tasks = value_combinations
+
+        return self
+
+    def _train_algo_in_sequence(self, history: list[dict[str, Any]]) -> None:
+        """
+        Train the Algos in a sequential scheme. The order of training is randomized.
+
+        Args:
+            history: the history of generated Algos. It is a list of dicts. Each element has the task name
+                (e.g. "dints_0" for dints network in fold 0) as the key and the algo object as the value.
+                After the training, the algo object with the ``best_metric`` will be saved as a pickle file.
+
+        Note:
+            The final results of the model training will be written to all the generated algorithm's output
+            folders under the working directory. The results include the model checkpoints, a
+            progress.yaml, accuracies in CSV and a pickle file of the Algo object.
+        """
+        for algo_dict in history:
+            algo = algo_dict[AlgoKeys.ALGO]
+            if has_option(algo.train, "device_setting"):
+                algo.train(self.train_params, self.device_setting)
+            else:
+                algo.train(self.train_params)
+            acc = algo.get_score()
+
+            algo_meta_data = {str(AlgoKeys.SCORE): acc}
+            algo_to_pickle(algo, template_path=algo.template_path, **algo_meta_data)
+
+    def _train_algo_in_nni(self, history: list[dict[str, Any]]) -> None:
+        """
+        Train the Algos using HPO.
+
+        Args:
+            history: the history of generated Algos. It is a list of dicts. Each element has the task name
+                (e.g. "dints_0" for dints network in fold 0) as the key and the algo object as the value.
+                After the training, the algo object with the ``best_metric`` will be saved as a pickle file.
+
+        Note:
+            The final results of the model training will not be written to all the previously generated
+            algorithm's output folders. Instead, HPO will generate a new algo during the searching, and
+            the new algo will be saved under the working directory with a different format of the name.
+            For example, if the searching space has "learning_rate", the result of HPO will be written to
+            a folder name with original task name and the param (e.g. "dints_0_learning_rate_0.001").
+            The results include the model checkpoints, a progress.yaml, accuracies in CSV and a pickle
+            file of the Algo object.
+
+        """
+        default_nni_config = {
+            "trialCodeDirectory": ".",
+            "trialGpuNumber": torch.cuda.device_count(),
+            "trialConcurrency": 1,
+            "maxTrialNumber": 10,
+            "maxExperimentDuration": "1h",
+            "tuner": {"name": "GridSearch"},
+            "trainingService": {"platform": "local", "useActiveGpu": True},
+        }
+
+        last_total_tasks = len(import_bundle_algo_history(self.work_dir, only_trained=True))
+        mode_dry_run = self.hpo_params.pop("nni_dry_run", False)
+        for algo_dict in history:
+            name = algo_dict[AlgoKeys.ID]
+            algo = algo_dict[AlgoKeys.ALGO]
+            nni_gen = NNIGen(algo=algo, params=self.hpo_params)
+            obj_filename = nni_gen.get_obj_filename()
+            nni_config = deepcopy(default_nni_config)
+            # override the default nni config with the same key in hpo_params
+            for key in self.hpo_params:
+                if key in nni_config:
+                    nni_config[key] = self.hpo_params[key]
+            nni_config.update({"experimentName": name})
+            nni_config.update({"search_space": self.search_space})
+            trial_cmd = "python -m monai.apps.auto3dseg NNIGen run_algo " + obj_filename + " " + self.work_dir
+            nni_config.update({"trialCommand": trial_cmd})
+            nni_config_filename = os.path.abspath(os.path.join(self.work_dir, f"{name}_nni_config.yaml"))
+            ConfigParser.export_config_file(nni_config, nni_config_filename, fmt="yaml", default_flow_style=None)
+
+            max_trial = min(self.hpo_tasks, cast(int, default_nni_config["maxTrialNumber"]))
+            cmd = "nnictl create --config " + nni_config_filename + " --port 8088"
+
+            if mode_dry_run:
+                logger.info(f"AutoRunner HPO is in dry-run mode. Please manually launch: {cmd}")
+                continue
+
+            run_cmd(cmd.split(), check=True)
+
+            n_trainings = len(import_bundle_algo_history(self.work_dir, only_trained=True))
+            while n_trainings - last_total_tasks < max_trial:
+                sleep(1)
+                n_trainings = len(import_bundle_algo_history(self.work_dir, only_trained=True))
+
+            cmd = "nnictl stop --all"
+            run_cmd(cmd.split(), check=True)
+            logger.info(f"NNI completes HPO on {name}")
+            last_total_tasks = n_trainings
+
+    def run(self):
+        """
+        Run the AutoRunner pipeline
+        """
+        # step 1: data analysis
+        if self.analyze and self.analyze_params is not None:
+            logger.info("Running data analysis...")
+            da = DataAnalyzer(
+                self.datalist_filename, self.dataroot, output_path=self.datastats_filename, **self.analyze_params
+            )
+            da.get_all_case_stats()
+
+            da = None  # type: ignore
+            torch.cuda.empty_cache()
+
+            self.export_cache(analyze=True, datastats=self.datastats_filename)
+        else:
+            logger.info("Skipping data analysis...")
+
+        # step 2: algorithm generation
+        if self.algo_gen:
+            if not os.path.isfile(self.datastats_filename):
+                raise ValueError(
+                    f"Could not find the datastats file {self.datastats_filename}. "
+                    "Possibly the required data analysis step was not completed."
+                )
+
+            bundle_generator = BundleGen(
+                algos=self.algos,
+                algo_path=self.work_dir,
+                templates_path_or_url=self.templates_path_or_url,
+                data_stats_filename=self.datastats_filename,
+                data_src_cfg_name=self.data_src_cfg_name,
+                mlflow_tracking_uri=self.mlflow_tracking_uri,
+                mlflow_experiment_name=self.mlflow_experiment_name,
+            )
+
+            if self.gpu_customization:
+                bundle_generator.generate(
+                    self.work_dir,
+                    num_fold=self.num_fold,
+                    gpu_customization=self.gpu_customization,
+                    gpu_customization_specs=self.gpu_customization_specs,
+                    allow_skip=self.allow_skip,
+                )
+            else:
+                bundle_generator.generate(self.work_dir, num_fold=self.num_fold, allow_skip=self.allow_skip)
+            history = bundle_generator.get_history()
+            export_bundle_algo_history(history)
+            self.export_cache(algo_gen=True)
+        else:
+            logger.info("Skipping algorithm generation...")
+
+        # step 3: algo training
+        auto_train_choice = self.train is None
+        if self.train or (auto_train_choice and not self.cache["train"]):
+            history = import_bundle_algo_history(self.work_dir, only_trained=False)
+
+            if len(history) == 0:
+                raise ValueError(
+                    f"Could not find training scripts in {self.work_dir}. "
+                    "Possibly the required algorithms generation step was not completed."
+                )
+
+            if auto_train_choice:
+                skip_algos = [h[AlgoKeys.ID] for h in history if h[AlgoKeys.IS_TRAINED]]
+                if skip_algos:
+                    logger.info(
+                        f"Skipping already trained algos {skip_algos}."
+                        "Set option train=True to always retrain all algos."
+                    )
+                    history = [h for h in history if not h[AlgoKeys.IS_TRAINED]]
+
+            if len(history) > 0:
+                if not self.hpo:
+                    self._train_algo_in_sequence(history)
+                else:
+                    self._train_algo_in_nni(history)
+
+            self.export_cache(train=True)
+        else:
+            logger.info("Skipping algorithm training...")
+
+        # step 4: model ensemble and write the prediction to disks.
+        if self.ensemble:
+            ensemble_runner = EnsembleRunner(
+                data_src_cfg_name=self.data_src_cfg_name,
+                work_dir=self.work_dir,
+                num_fold=self.num_fold,
+                ensemble_method_name=self.ensemble_method_name,
+                mgpu=int(self.device_setting["n_devices"]) > 1,
+                **self.kwargs,  # for set_image_save_transform
+                **self.pred_params,
+            )  # for inference
+            ensemble_runner.run(self.device_setting)
+        logger.info("Auto3Dseg pipeline is completed successfully.")

source_code/SegMamba/monai/apps/auto3dseg/bundle_gen.py

@@ -0,0 +1,665 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import importlib
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+import warnings
+from copy import deepcopy
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Any
+from urllib.parse import urlparse
+
+import torch
+
+from monai.apps import download_and_extract
+from monai.apps.utils import get_logger
+from monai.auto3dseg.algo_gen import Algo, AlgoGen
+from monai.auto3dseg.utils import (
+    _prepare_cmd_bcprun,
+    _prepare_cmd_default,
+    _prepare_cmd_torchrun,
+    _run_cmd_bcprun,
+    _run_cmd_torchrun,
+    algo_to_pickle,
+)
+from monai.bundle.config_parser import ConfigParser
+from monai.config import PathLike
+from monai.utils import ensure_tuple, look_up_option, run_cmd
+from monai.utils.enums import AlgoKeys
+from monai.utils.misc import MONAIEnvVars
+
+logger = get_logger(module_name=__name__)
+ALGO_HASH = MONAIEnvVars.algo_hash()
+
+__all__ = ["BundleAlgo", "BundleGen"]
+
+
+class BundleAlgo(Algo):
+    """
+    An algorithm represented by a set of bundle configurations and scripts.
+
+    ``BundleAlgo.cfg`` is a ``monai.bundle.ConfigParser`` instance.
+
+    .. code-block:: python
+
+        from monai.apps.auto3dseg import BundleAlgo
+
+        data_stats_yaml = "../datastats.yaml"
+        algo = BundleAlgo(template_path="../algorithm_templates")
+        algo.set_data_stats(data_stats_yaml)
+        # algo.set_data_src("../data_src.json")
+        algo.export_to_disk(".", algo_name="segresnet2d_1")
+
+    This class creates MONAI bundles from a directory of 'bundle template'. Different from the regular MONAI bundle
+    format, the bundle template may contain placeholders that must be filled using ``fill_template_config`` during
+    ``export_to_disk``. Then created bundle keeps the same file structure as the template.
+
+    """
+
+    def __init__(self, template_path: PathLike):
+        """
+        Create an Algo instance based on the predefined Algo template.
+
+        Args:
+            template_path: path to a folder that contains the algorithm templates.
+                Please check https://github.com/Project-MONAI/research-contributions/tree/main/auto3dseg/algorithm_templates
+
+        """
+
+        self.template_path = template_path
+        self.data_stats_files = ""
+        self.data_list_file = ""
+        self.mlflow_tracking_uri: str | None = None
+        self.mlflow_experiment_name: str | None = None
+        self.output_path = ""
+        self.name = ""
+        self.best_metric = None
+        # track records when filling template config: {"<config name>": {"<placeholder key>": value, ...}, ...}
+        self.fill_records: dict = {}
+        # device_setting set default value and sanity check, in case device_setting not from autorunner
+        self.device_setting: dict[str, int | str] = {
+            "CUDA_VISIBLE_DEVICES": ",".join([str(x) for x in range(torch.cuda.device_count())]),
+            "n_devices": int(torch.cuda.device_count()),
+            "NUM_NODES": int(os.environ.get("NUM_NODES", 1)),
+            "MN_START_METHOD": os.environ.get("MN_START_METHOD", "bcprun"),
+            "CMD_PREFIX": os.environ.get("CMD_PREFIX", ""),
+        }
+
+    def pre_check_skip_algo(self, skip_bundlegen: bool = False, skip_info: str = "") -> tuple[bool, str]:
+        """
+        Analyse the data analysis report and check if the algorithm needs to be skipped.
+        This function is overriden within algo.
+        Args:
+            skip_bundlegen: skip generating bundles for this algo if true.
+            skip_info: info to print when skipped.
+        """
+        return skip_bundlegen, skip_info
+
+    def set_data_stats(self, data_stats_files: str) -> None:
+        """
+        Set the data analysis report (generated by DataAnalyzer).
+
+        Args:
+            data_stats_files: path to the datastats yaml file
+        """
+        self.data_stats_files = data_stats_files
+
+    def set_data_source(self, data_src_cfg: str) -> None:
+        """
+        Set the data source configuration file
+
+        Args:
+            data_src_cfg: path to a configuration file (yaml) that contains datalist, dataroot, and other params.
+                The config will be in a form of {"modality": "ct", "datalist": "path_to_json_datalist", "dataroot":
+                "path_dir_data"}
+        """
+        self.data_list_file = data_src_cfg
+
+    def set_mlflow_tracking_uri(self, mlflow_tracking_uri: str | None) -> None:
+        """
+        Set the tracking URI for MLflow server
+
+        Args:
+            mlflow_tracking_uri: a tracking URI for MLflow server which could be local directory or address of
+                the remote tracking Server; MLflow runs will be recorded locally in algorithms' model folder if
+                the value is None.
+        """
+        self.mlflow_tracking_uri = mlflow_tracking_uri
+
+    def set_mlflow_experiment_name(self, mlflow_experiment_name: str | None) -> None:
+        """
+        Set the experiment name for MLflow server
+
+        Args:
+            mlflow_experiment_name: a string to specify the experiment name for MLflow server.
+        """
+        self.mlflow_experiment_name = mlflow_experiment_name
+
+    def fill_template_config(self, data_stats_filename: str, algo_path: str, **kwargs: Any) -> dict:
+        """
+        The configuration files defined when constructing this Algo instance might not have a complete training
+        and validation pipelines. Some configuration components and hyperparameters of the pipelines depend on the
+        training data and other factors. This API is provided to allow the creation of fully functioning config files.
+        Return the records of filling template config: {"<config name>": {"<placeholder key>": value, ...}, ...}.
+
+        Args:
+            data_stats_filename: filename of the data stats report (generated by DataAnalyzer)
+
+        Notes:
+            Template filling is optional. The user can construct a set of pre-filled configs without replacing values
+            by using the data analysis results. It is also intended to be re-implemented in subclasses of BundleAlgo
+            if the user wants their own way of auto-configured template filling.
+        """
+        return {}
+
+    def export_to_disk(self, output_path: str, algo_name: str, **kwargs: Any) -> None:
+        """
+        Fill the configuration templates, write the bundle (configs + scripts) to folder `output_path/algo_name`.
+
+        Args:
+            output_path: Path to export the 'scripts' and 'configs' directories.
+            algo_name: the identifier of the algorithm (usually contains the name and extra info like fold ID).
+            kwargs: other parameters, including: "copy_dirs=True/False" means whether to copy the template as output
+                instead of inplace operation, "fill_template=True/False" means whether to fill the placeholders
+                in the template. other parameters are for `fill_template_config` function.
+
+        """
+        if kwargs.pop("copy_dirs", True):
+            self.output_path = os.path.join(output_path, algo_name)
+            os.makedirs(self.output_path, exist_ok=True)
+            if os.path.isdir(self.output_path):
+                shutil.rmtree(self.output_path)
+            # copy algorithm_templates/<Algo> to the working directory output_path
+            shutil.copytree(os.path.join(str(self.template_path), self.name), self.output_path)
+        else:
+            self.output_path = str(self.template_path)
+        if kwargs.pop("fill_template", True):
+            self.fill_records = self.fill_template_config(self.data_stats_files, self.output_path, **kwargs)
+        logger.info(f"Generated:{self.output_path}")
+
+    def _create_cmd(self, train_params: None | dict = None) -> tuple[str, str]:
+        """
+        Create the command to execute training.
+
+        """
+        if train_params is None:
+            train_params = {}
+        params = deepcopy(train_params)
+
+        train_py = os.path.join(self.output_path, "scripts", "train.py")
+        config_dir = os.path.join(self.output_path, "configs")
+
+        config_files = []
+        if os.path.isdir(config_dir):
+            for file in sorted(os.listdir(config_dir)):
+                if file.endswith("yaml") or file.endswith("json"):
+                    # Python Fire may be confused by single-quoted WindowsPath
+                    config_files.append(Path(os.path.join(config_dir, file)).as_posix())
+
+        if int(self.device_setting["NUM_NODES"]) > 1:
+            # multi-node command
+            # only bcprun is supported for now
+            try:
+                look_up_option(self.device_setting["MN_START_METHOD"], ["bcprun"])
+            except ValueError as err:
+                raise NotImplementedError(
+                    f"{self.device_setting['MN_START_METHOD']} is not supported yet."
+                    "Try modify BundleAlgo._create_cmd for your cluster."
+                ) from err
+
+            return (
+                _prepare_cmd_bcprun(
+                    f"{train_py} run",
+                    cmd_prefix=f"{self.device_setting['CMD_PREFIX']}",
+                    config_file=config_files,
+                    **params,
+                ),
+                "",
+            )
+        elif int(self.device_setting["n_devices"]) > 1:
+            return _prepare_cmd_torchrun(f"{train_py} run", config_file=config_files, **params), ""
+        else:
+            return (
+                _prepare_cmd_default(
+                    f"{train_py} run",
+                    cmd_prefix=f"{self.device_setting['CMD_PREFIX']}",
+                    config_file=config_files,
+                    **params,
+                ),
+                "",
+            )
+
+    def _run_cmd(self, cmd: str, devices_info: str = "") -> subprocess.CompletedProcess:
+        """
+        Execute the training command with target devices information.
+
+        """
+        if devices_info:
+            warnings.warn(f"input devices_info {devices_info} is deprecated and ignored.")
+
+        ps_environ = os.environ.copy()
+        ps_environ["CUDA_VISIBLE_DEVICES"] = str(self.device_setting["CUDA_VISIBLE_DEVICES"])
+
+        # delete pattern "VAR=VALUE" at the beginning of the string, with optional leading/trailing whitespaces
+        cmd = re.sub(r"^\s*\w+=.*?\s+", "", cmd)
+
+        if int(self.device_setting["NUM_NODES"]) > 1:
+            try:
+                look_up_option(self.device_setting["MN_START_METHOD"], ["bcprun"])
+            except ValueError as err:
+                raise NotImplementedError(
+                    f"{self.device_setting['MN_START_METHOD']} is not supported yet."
+                    "Try modify BundleAlgo._run_cmd for your cluster."
+                ) from err
+
+            return _run_cmd_bcprun(cmd, n=self.device_setting["NUM_NODES"], p=self.device_setting["n_devices"])
+        elif int(self.device_setting["n_devices"]) > 1:
+            return _run_cmd_torchrun(
+                cmd, nnodes=1, nproc_per_node=self.device_setting["n_devices"], env=ps_environ, check=True
+            )
+        else:
+            return run_cmd(cmd.split(), run_cmd_verbose=True, env=ps_environ, check=True)
+
+    def train(
+        self, train_params: None | dict = None, device_setting: None | dict = None
+    ) -> subprocess.CompletedProcess:
+        """
+        Load the run function in the training script of each model. Training parameter is predefined by the
+        algo_config.yaml file, which is pre-filled by the fill_template_config function in the same instance.
+
+        Args:
+            train_params:  training parameters
+            device_setting: device related settings, should follow the device_setting in auto_runner.set_device_info.
+                'CUDA_VISIBLE_DEVICES' should be a string e.g. '0,1,2,3'
+        """
+        if device_setting is not None:
+            self.device_setting.update(device_setting)
+            self.device_setting["n_devices"] = len(str(self.device_setting["CUDA_VISIBLE_DEVICES"]).split(","))
+
+        if train_params is not None and "CUDA_VISIBLE_DEVICES" in train_params:
+            warnings.warn("CUDA_VISIBLE_DEVICES is deprecated from train_params!")
+            train_params.pop("CUDA_VISIBLE_DEVICES")
+
+        cmd, _unused_return = self._create_cmd(train_params)
+        return self._run_cmd(cmd)
+
+    def get_score(self, *args, **kwargs):
+        """
+        Returns validation scores of the model trained by the current Algo.
+        """
+        config_yaml = os.path.join(self.output_path, "configs", "hyper_parameters.yaml")
+        parser = ConfigParser()
+        parser.read_config(config_yaml)
+        ckpt_path = parser.get_parsed_content("ckpt_path", default=self.output_path)
+
+        dict_file = ConfigParser.load_config_file(os.path.join(ckpt_path, "progress.yaml"))
+        # dict_file: a list of scores saved in the form of dict in progress.yaml
+        return dict_file[-1]["best_avg_dice_score"]  # the last one is the best one
+
+    def get_inferer(self, *args, **kwargs):
+        """
+        Load the InferClass from the infer.py. The InferClass should be defined in the template under the path of
+        `"scripts/infer.py"`. It is required to define the "InferClass" (name is fixed) with two functions at least
+        (``__init__`` and ``infer``). The init class has an override kwargs that can be used to override parameters in
+        the run-time optionally.
+
+        Examples:
+
+        .. code-block:: python
+
+            class InferClass
+                def __init__(self, config_file: Optional[Union[str, Sequence[str]]] = None, **override):
+                    # read configs from config_file (sequence)
+                    # set up transforms
+                    # set up model
+                    # set up other hyper parameters
+                    return
+
+                @torch.no_grad()
+                def infer(self, image_file):
+                    # infer the model and save the results to output
+                    return output
+
+        """
+        infer_py = os.path.join(self.output_path, "scripts", "infer.py")
+        if not os.path.isfile(infer_py):
+            raise ValueError(f"{infer_py} is not found, please check the path.")
+
+        config_dir = os.path.join(self.output_path, "configs")
+        configs_path = [os.path.join(config_dir, f) for f in os.listdir(config_dir)]
+
+        spec = importlib.util.spec_from_file_location("InferClass", infer_py)
+        infer_class = importlib.util.module_from_spec(spec)  # type: ignore
+        sys.modules["InferClass"] = infer_class
+        spec.loader.exec_module(infer_class)  # type: ignore
+        return infer_class.InferClass(configs_path, *args, **kwargs)
+
+    def predict(self, predict_files: list, predict_params: dict | None = None) -> list:
+        """
+        Use the trained model to predict the outputs with a given input image.
+
+        Args:
+            predict_files: a list of paths to files to run inference on ["path_to_image_1", "path_to_image_2"]
+            predict_params: a dict to override the parameters in the bundle config (including the files to predict).
+
+        """
+        params = {} if predict_params is None else deepcopy(predict_params)
+        inferer = self.get_inferer(**params)
+        return [inferer.infer(f) for f in ensure_tuple(predict_files)]
+
+    def get_output_path(self):
+        """Returns the algo output paths to find the algo scripts and configs."""
+        return self.output_path
+
+
+# path to download the algo_templates
+default_algo_zip = (
+    f"https://github.com/Project-MONAI/research-contributions/releases/download/algo_templates/{ALGO_HASH}.tar.gz"
+)
+
+# default algorithms
+default_algos = {
+    "segresnet2d": dict(_target_="segresnet2d.scripts.algo.Segresnet2dAlgo"),
+    "dints": dict(_target_="dints.scripts.algo.DintsAlgo"),
+    "swinunetr": dict(_target_="swinunetr.scripts.algo.SwinunetrAlgo"),
+    "segresnet": dict(_target_="segresnet.scripts.algo.SegresnetAlgo"),
+}
+
+
+def _download_algos_url(url: str, at_path: str) -> dict[str, dict[str, str]]:
+    """
+    Downloads the algorithm templates release archive, and extracts it into a parent directory of the at_path folder.
+    Returns a dictionary of the algorithm templates.
+    """
+    at_path = os.path.abspath(at_path)
+    zip_download_dir = TemporaryDirectory()
+    algo_compressed_file = os.path.join(zip_download_dir.name, "algo_templates.tar.gz")
+
+    download_attempts = 3
+    for i in range(download_attempts):
+        try:
+            download_and_extract(url=url, filepath=algo_compressed_file, output_dir=os.path.dirname(at_path))
+        except Exception as e:
+            msg = f"Download and extract of {url} failed, attempt {i+1}/{download_attempts}."
+            if i < download_attempts - 1:
+                warnings.warn(msg)
+                time.sleep(i)
+            else:
+                zip_download_dir.cleanup()
+                raise ValueError(msg) from e
+        else:
+            break
+
+    zip_download_dir.cleanup()
+
+    algos_all = deepcopy(default_algos)
+    for name in algos_all:
+        algos_all[name]["template_path"] = at_path
+
+    return algos_all
+
+
+def _copy_algos_folder(folder, at_path):
+    """
+    Copies the algorithm templates folder to at_path.
+    Returns a dictionary of algorithm templates.
+    """
+    folder = os.path.abspath(folder)
+    at_path = os.path.abspath(at_path)
+
+    if folder != at_path:
+        if os.path.exists(at_path):
+            shutil.rmtree(at_path)
+        shutil.copytree(folder, at_path)
+
+    algos_all = {}
+    for name in os.listdir(at_path):
+        if os.path.exists(os.path.join(folder, name, "scripts", "algo.py")):
+            algos_all[name] = dict(_target_=f"{name}.scripts.algo.{name.capitalize()}Algo", template_path=at_path)
+            logger.info(f"Copying template: {name} -- {algos_all[name]}")
+    if not algos_all:
+        raise ValueError(f"Unable to find any algos in {folder}")
+
+    return algos_all
+
+
+class BundleGen(AlgoGen):
+    """
+    This class generates a set of bundles according to the cross-validation folds, each of them can run independently.
+
+    Args:
+        algo_path: the directory path to save the algorithm templates. Default is the current working dir.
+        algos: If dictionary, it outlines the algorithm to use. If a list or a string, defines a subset of names of
+            the algorithms to use, e.g. ('segresnet', 'dints') out of the full set of algorithm templates provided
+            by templates_path_or_url. Defaults to None - to use all available algorithms.
+        templates_path_or_url: the folder with the algorithm templates or a url. If None provided, the default template
+            zip url will be downloaded and extracted into the algo_path. The current default options are released at:
+            https://github.com/Project-MONAI/research-contributions/tree/main/auto3dseg.
+        data_stats_filename: the path to the data stats file (generated by DataAnalyzer).
+        data_src_cfg_name: the path to the data source config YAML file. The config will be in a form of
+                           {"modality": "ct", "datalist": "path_to_json_datalist", "dataroot": "path_dir_data"}.
+        mlflow_tracking_uri: a tracking URI for MLflow server which could be local directory or address of
+            the remote tracking Server; MLflow runs will be recorded locally in algorithms' model folder if
+            the value is None.
+        mlfow_experiment_name: a string to specify the experiment name for MLflow server.
+    .. code-block:: bash
+
+        python -m monai.apps.auto3dseg BundleGen generate --data_stats_filename="../algorithms/datastats.yaml"
+    """
+
+    def __init__(
+        self,
+        algo_path: str = ".",
+        algos: dict | list | str | None = None,
+        templates_path_or_url: str | None = None,
+        data_stats_filename: str | None = None,
+        data_src_cfg_name: str | None = None,
+        mlflow_tracking_uri: str | None = None,
+        mlflow_experiment_name: str | None = None,
+    ):
+        if algos is None or isinstance(algos, (list, tuple, str)):
+            if templates_path_or_url is None:
+                templates_path_or_url = default_algo_zip
+
+            at_path = os.path.join(os.path.abspath(algo_path), "algorithm_templates")
+
+            if os.path.isdir(templates_path_or_url):
+                # if a local folder, copy if necessary
+                logger.info(f"BundleGen from directory {templates_path_or_url}")
+                algos_all = _copy_algos_folder(folder=templates_path_or_url, at_path=at_path)
+            elif urlparse(templates_path_or_url).scheme in ("http", "https"):
+                # if url, trigger the download and extract process
+                logger.info(f"BundleGen from {templates_path_or_url}")
+                algos_all = _download_algos_url(url=templates_path_or_url, at_path=at_path)
+            else:
+                raise ValueError(f"{self.__class__} received invalid templates_path_or_url: {templates_path_or_url}")
+
+            if algos is not None:
+                algos = {k: v for k, v in algos_all.items() if k in ensure_tuple(algos)}  # keep only provided
+                if len(algos) == 0:
+                    raise ValueError(f"Unable to find provided algos in {algos_all}")
+            else:
+                algos = algos_all
+
+        self.algos: Any = []
+        if isinstance(algos, dict):
+            for algo_name, algo_params in sorted(algos.items()):
+                template_path = algo_params.get("template_path", ".")
+                if len(template_path) > 0 and template_path not in sys.path:
+                    sys.path.append(template_path)
+
+                try:
+                    onealgo = ConfigParser(algo_params).get_parsed_content()
+                    onealgo.name = algo_name
+                    self.algos.append(onealgo)
+                except RuntimeError as e:
+                    msg = """Please make sure the folder structure of an Algo Template follows
+                        [algo_name]
+                        ├── configs
+                        │   ├── hyper_parameters.yaml  # automatically generated yaml from a set of ``template_configs``
+                        └── scripts
+                            ├── test.py
+                            ├── __init__.py
+                            └── validate.py
+                    """
+                    raise RuntimeError(msg) from e
+        else:
+            raise ValueError("Unexpected error algos is not a dict")
+
+        self.data_stats_filename = data_stats_filename
+        self.data_src_cfg_name = data_src_cfg_name
+        self.mlflow_tracking_uri = mlflow_tracking_uri
+        self.mlflow_experiment_name = mlflow_experiment_name
+        self.history: list[dict] = []
+
+    def set_data_stats(self, data_stats_filename: str) -> None:
+        """
+        Set the data stats filename
+
+        Args:
+            data_stats_filename: filename of datastats
+        """
+        self.data_stats_filename = data_stats_filename
+
+    def get_data_stats(self):
+        """Get the filename of the data stats"""
+        return self.data_stats_filename
+
+    def set_data_src(self, data_src_cfg_name):
+        """
+        Set the data source filename
+
+        Args:
+            data_src_cfg_name: filename of data_source file
+        """
+        self.data_src_cfg_name = data_src_cfg_name
+
+    def get_data_src(self):
+        """Get the data source filename"""
+        return self.data_src_cfg_name
+
+    def set_mlflow_tracking_uri(self, mlflow_tracking_uri):
+        """
+        Set the tracking URI for MLflow server
+
+        Args:
+            mlflow_tracking_uri: a tracking URI for MLflow server which could be local directory or address of
+                the remote tracking Server; MLflow runs will be recorded locally in algorithms' model folder if
+                the value is None.
+        """
+        self.mlflow_tracking_uri = mlflow_tracking_uri
+
+    def set_mlflow_experiment_name(self, mlflow_experiment_name):
+        """
+        Set the experiment name for MLflow server
+
+        Args:
+            mlflow_experiment_name: a string to specify the experiment name for MLflow server.
+        """
+        self.mlflow_experiment_name = mlflow_experiment_name
+
+    def get_mlflow_tracking_uri(self):
+        """Get the tracking URI for MLflow server"""
+        return self.mlflow_tracking_uri
+
+    def get_mlflow_experiment_name(self):
+        """Get the experiment name for MLflow server"""
+        return self.mlflow_experiment_name
+
+    def get_history(self) -> list:
+        """Get the history of the bundleAlgo object with their names/identifiers"""
+        return self.history
+
+    def generate(
+        self,
+        output_folder: str = ".",
+        num_fold: int = 5,
+        gpu_customization: bool = False,
+        gpu_customization_specs: dict[str, Any] | None = None,
+        allow_skip: bool = True,
+    ) -> None:
+        """
+        Generate the bundle scripts/configs for each bundleAlgo
+
+        Args:
+            output_folder: the output folder to save each algorithm.
+            num_fold: the number of cross validation fold.
+            gpu_customization: the switch to determine automatically customize/optimize bundle script/config
+                parameters for each bundleAlgo based on gpus. Custom parameters are obtained through dummy
+                training to simulate the actual model training process and hyperparameter optimization (HPO)
+                experiments.
+            gpu_customization_specs: the dictionary to enable users overwrite the HPO settings. user can
+                overwrite part of variables as follows or all of them. The structure is as follows.
+            allow_skip: a switch to determine if some Algo in the default templates can be skipped based on the
+                analysis on the dataset from Auto3DSeg DataAnalyzer.
+
+                .. code-block:: python
+
+                    gpu_customization_specs = {
+                        'ALGO': {
+                            'num_trials': 6,
+                            'range_num_images_per_batch': [1, 20],
+                            'range_num_sw_batch_size': [1, 20]
+                        }
+                    }
+
+            ALGO: the name of algorithm. It could be one of algorithm names (e.g., 'dints') or 'universal' which
+                would apply changes to all algorithms. Possible options are
+
+                - {``"universal"``, ``"dints"``, ``"segresnet"``, ``"segresnet2d"``, ``"swinunetr"``}.
+
+            num_trials: the number of HPO trials/experiments to run.
+            range_num_images_per_batch: the range of number of images per mini-batch.
+            range_num_sw_batch_size: the range of batch size in sliding-window inferer.
+        """
+        fold_idx = list(range(num_fold))
+        for algo in self.algos:
+            for f_id in ensure_tuple(fold_idx):
+                data_stats = self.get_data_stats()
+                data_src_cfg = self.get_data_src()
+                mlflow_tracking_uri = self.get_mlflow_tracking_uri()
+                mlflow_experiment_name = self.get_mlflow_experiment_name()
+                gen_algo = deepcopy(algo)
+                gen_algo.set_data_stats(data_stats)
+                gen_algo.set_data_source(data_src_cfg)
+                gen_algo.set_mlflow_tracking_uri(mlflow_tracking_uri)
+                gen_algo.set_mlflow_experiment_name(mlflow_experiment_name)
+                name = f"{gen_algo.name}_{f_id}"
+
+                if allow_skip:
+                    skip_bundlegen, skip_info = gen_algo.pre_check_skip_algo()
+                    if skip_bundlegen:
+                        logger.info(f"{name} is skipped! {skip_info}")
+                        continue
+
+                if gpu_customization:
+                    gen_algo.export_to_disk(
+                        output_folder,
+                        name,
+                        fold=f_id,
+                        gpu_customization=True,
+                        gpu_customization_specs=gpu_customization_specs,
+                    )
+                else:
+                    gen_algo.export_to_disk(output_folder, name, fold=f_id)
+
+                algo_to_pickle(gen_algo, template_path=algo.template_path)
+                self.history.append(
+                    {AlgoKeys.ID: name, AlgoKeys.ALGO: gen_algo}
+                )  # track the previous, may create a persistent history

source_code/SegMamba/monai/apps/auto3dseg/data_analyzer.py

@@ -0,0 +1,386 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from os import path
+from typing import Any, cast
+
+import numpy as np
+import torch
+from torch.multiprocessing import get_context
+
+from monai.apps.auto3dseg.transforms import EnsureSameShaped
+from monai.apps.utils import get_logger
+from monai.auto3dseg import SegSummarizer
+from monai.auto3dseg.utils import datafold_read
+from monai.bundle import config_parser
+from monai.bundle.config_parser import ConfigParser
+from monai.data import DataLoader, Dataset, partition_dataset
+from monai.data.utils import no_collation
+from monai.transforms import Compose, EnsureTyped, LoadImaged, Orientationd
+from monai.utils import ImageMetaKey, StrEnum, min_version, optional_import
+from monai.utils.enums import DataStatsKeys, ImageStatsKeys
+
+
+def strenum_representer(dumper, data):
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data.value)
+
+
+if optional_import("yaml")[1]:
+    config_parser.yaml.SafeDumper.add_multi_representer(StrEnum, strenum_representer)
+
+tqdm, has_tqdm = optional_import("tqdm", "4.47.0", min_version, "tqdm")
+logger = get_logger(module_name=__name__)
+
+__all__ = ["DataAnalyzer"]
+
+
+class DataAnalyzer:
+    """
+    The DataAnalyzer automatically analyzes given medical image dataset and reports the statistics.
+    The module expects file paths to the image data and utilizes the LoadImaged transform to read the
+    files, which supports nii, nii.gz, png, jpg, bmp, npz, npy, and dcm formats. Currently, only
+    segmentation task is supported, so the user needs to provide paths to the image and label files
+    (if have). Also, label data format is preferred to be (1,H,W,D), with the label index in the
+    first dimension. If it is in onehot format, it will be converted to the preferred format.
+
+    Args:
+        datalist: a Python dictionary storing group, fold, and other information of the medical
+            image dataset, or a string to the JSON file storing the dictionary.
+        dataroot: user's local directory containing the datasets.
+        output_path: path to save the analysis result.
+        average: whether to average the statistical value across different image modalities.
+        do_ccp: apply the connected component algorithm to process the labels/images
+        device: a string specifying hardware (CUDA/CPU) utilized for the operations.
+        worker: number of workers to use for loading datasets in each GPU/CPU sub-process.
+        image_key: a string that user specify for the image. The DataAnalyzer will look it up in the
+            datalist to locate the image files of the dataset.
+        label_key: a string that user specify for the label. The DataAnalyzer will look it up in the
+            datalist to locate the label files of the dataset. If label_key is NoneType or "None",
+            the DataAnalyzer will skip looking for labels and all label-related operations.
+        hist_bins: bins to compute histogram for each image channel.
+        hist_range: ranges to compute histogram for each image channel.
+        fmt: format used to save the analysis results. Currently support ``"json"`` and ``"yaml"``, defaults to "yaml".
+        histogram_only: whether to only compute histograms. Defaults to False.
+        extra_params: other optional arguments. Currently supported arguments are :
+            'allowed_shape_difference' (default 5) can be used to change the default tolerance of
+            the allowed shape differences between the image and label items. In case of shape mismatch below
+            the tolerance, the label image will be resized to match the image using nearest interpolation.
+
+
+    Examples:
+        .. code-block:: python
+
+            from monai.apps.auto3dseg.data_analyzer import DataAnalyzer
+
+            datalist = {
+                "testing": [{"image": "image_003.nii.gz"}],
+                "training": [
+                    {"fold": 0, "image": "image_001.nii.gz", "label": "label_001.nii.gz"},
+                    {"fold": 0, "image": "image_002.nii.gz", "label": "label_002.nii.gz"},
+                    {"fold": 1, "image": "image_001.nii.gz", "label": "label_001.nii.gz"},
+                    {"fold": 1, "image": "image_004.nii.gz", "label": "label_004.nii.gz"},
+                ],
+            }
+
+            dataroot = '/datasets' # the directory where you have the image files (nii.gz)
+            DataAnalyzer(datalist, dataroot)
+
+    Notes:
+        The module can also be called from the command line interface (CLI).
+
+    For example:
+
+    .. code-block:: bash
+
+        python -m monai.apps.auto3dseg \\
+            DataAnalyzer \\
+            get_all_case_stats \\
+            --datalist="my_datalist.json" \\
+            --dataroot="my_dataroot_dir"
+
+    """
+
+    def __init__(
+        self,
+        datalist: str | dict,
+        dataroot: str = "",
+        output_path: str = "./datastats.yaml",
+        average: bool = True,
+        do_ccp: bool = False,
+        device: str | torch.device = "cuda",
+        worker: int = 4,
+        image_key: str = "image",
+        label_key: str | None = "label",
+        hist_bins: list | int | None = 0,
+        hist_range: list | None = None,
+        fmt: str = "yaml",
+        histogram_only: bool = False,
+        **extra_params: Any,
+    ):
+        if path.isfile(output_path):
+            warnings.warn(f"File {output_path} already exists and will be overwritten.")
+            logger.debug(f"{output_path} will be overwritten by a new datastat.")
+
+        self.datalist = datalist
+        self.dataroot = dataroot
+        self.output_path = output_path
+        self.average = average
+        self.do_ccp = do_ccp
+        self.device = torch.device(device)
+        self.worker = worker
+        self.image_key = image_key
+        self.label_key = None if label_key == "None" else label_key
+        self.hist_bins = hist_bins
+        self.hist_range: list = [-500, 500] if hist_range is None else hist_range
+        self.fmt = fmt
+        self.histogram_only = histogram_only
+        self.extra_params = extra_params
+
+    @staticmethod
+    def _check_data_uniformity(keys: list[str], result: dict) -> bool:
+        """
+        Check data uniformity since DataAnalyzer provides no support to multi-modal images with different
+        affine matrices/spacings due to monai transforms.
+
+        Args:
+            keys: a list of string-type keys under image_stats dictionary.
+
+        Returns:
+            False if one of the selected key values is not constant across the dataset images.
+
+        """
+
+        if DataStatsKeys.SUMMARY not in result or DataStatsKeys.IMAGE_STATS not in result[DataStatsKeys.SUMMARY]:
+            return True
+        constant_props = [result[DataStatsKeys.SUMMARY][DataStatsKeys.IMAGE_STATS][key] for key in keys]
+        for prop in constant_props:
+            if "stdev" in prop and np.any(prop["stdev"]):
+                logger.debug(f"summary image_stats {prop} has non-zero stdev {prop['stdev']}.")
+                return False
+
+        return True
+
+    def get_all_case_stats(self, key="training", transform_list=None):
+        """
+        Get all case stats. Caller of the DataAnalyser class. The function initiates multiple GPU or CPU processes of the internal
+        _get_all_case_stats functions, which iterates datalist and call SegSummarizer to generate stats for each case.
+        After all case stats are generated, SegSummarizer is called to combine results.
+
+        Args:
+            key: dataset key
+            transform_list: option list of transforms before SegSummarizer
+
+        Returns:
+            A data statistics dictionary containing
+                "stats_summary" (summary statistics of the entire datasets). Within stats_summary
+                there are "image_stats"  (summarizing info of shape, channel, spacing, and etc
+                using operations_summary), "image_foreground_stats" (info of the intensity for the
+                non-zero labeled voxels), and "label_stats" (info of the labels, pixel percentage,
+                image_intensity, and each individual label in a list)
+                "stats_by_cases" (List type value. Each element of the list is statistics of
+                an image-label info. Within each element, there are: "image" (value is the
+                path to an image), "label" (value is the path to the corresponding label), "image_stats"
+                (summarizing info of shape, channel, spacing, and etc using operations),
+                "image_foreground_stats" (similar to the previous one but one foreground image), and
+                "label_stats" (stats of the individual labels )
+
+        Notes:
+            Since the backend of the statistics computation are torch/numpy, nan/inf value
+            may be generated and carried over in the computation. In such cases, the output
+            dictionary will include .nan/.inf in the statistics.
+
+        """
+        result: dict[DataStatsKeys, Any] = {DataStatsKeys.SUMMARY: {}, DataStatsKeys.BY_CASE: []}
+        result_bycase: dict[DataStatsKeys, Any] = {DataStatsKeys.SUMMARY: {}, DataStatsKeys.BY_CASE: []}
+        if self.device.type == "cpu":
+            nprocs = 1
+            logger.info("Using CPU for data analyzing!")
+        else:
+            nprocs = torch.cuda.device_count()
+            logger.info(f"Found {nprocs} GPUs for data analyzing!")
+        if nprocs > 1:
+            tmp_ctx: Any = get_context("forkserver")
+            with tmp_ctx.Manager() as manager:
+                manager_list = manager.list()
+                processes = []
+                for rank in range(nprocs):
+                    p = tmp_ctx.Process(
+                        target=self._get_all_case_stats, args=(rank, nprocs, manager_list, key, transform_list)
+                    )
+                    processes.append(p)
+                for p in processes:
+                    p.start()
+                for p in processes:
+                    p.join()
+                # merge DataStatsKeys.BY_CASE
+                for _ in manager_list:
+                    result_bycase[DataStatsKeys.BY_CASE].extend(_[DataStatsKeys.BY_CASE])
+        else:
+            result_bycase = self._get_all_case_stats(0, 1, None, key, transform_list)
+
+        summarizer = SegSummarizer(
+            self.image_key,
+            self.label_key,
+            average=self.average,
+            do_ccp=self.do_ccp,
+            hist_bins=self.hist_bins,
+            hist_range=self.hist_range,
+            histogram_only=self.histogram_only,
+        )
+        n_cases = len(result_bycase[DataStatsKeys.BY_CASE])
+        result[DataStatsKeys.SUMMARY] = summarizer.summarize(cast(list, result_bycase[DataStatsKeys.BY_CASE]))
+        result[DataStatsKeys.SUMMARY]["n_cases"] = n_cases
+        result_bycase[DataStatsKeys.SUMMARY] = result[DataStatsKeys.SUMMARY]
+        if not self._check_data_uniformity([ImageStatsKeys.SPACING], result):
+            logger.info("Data spacing is not completely uniform. MONAI transforms may provide unexpected result")
+        if self.output_path:
+            logger.info(f"Writing data stats to {self.output_path}.")
+            ConfigParser.export_config_file(
+                result, self.output_path, fmt=self.fmt, default_flow_style=None, sort_keys=False
+            )
+            by_case_path = self.output_path.replace(f".{self.fmt}", f"_by_case.{self.fmt}")
+            if by_case_path == self.output_path:  # self.output_path not ended with self.fmt?
+                by_case_path += f".by_case.{self.fmt}"
+            logger.info(f"Writing by-case data stats to {by_case_path}, this may take a while.")
+            ConfigParser.export_config_file(
+                result_bycase, by_case_path, fmt=self.fmt, default_flow_style=None, sort_keys=False
+            )
+        # release memory
+        if self.device.type == "cuda":
+            # release unreferenced tensors to mitigate OOM
+            # limitation: https://github.com/pytorch/pytorch/issues/12873#issuecomment-482916237
+            torch.cuda.empty_cache()
+        result[DataStatsKeys.BY_CASE] = result_bycase[DataStatsKeys.BY_CASE]
+        return result
+
+    def _get_all_case_stats(
+        self,
+        rank: int = 0,
+        world_size: int = 1,
+        manager_list: list | None = None,
+        key: str = "training",
+        transform_list: list | None = None,
+    ) -> Any:
+        """
+        Get all case stats from a partitioned datalist. The function can only be called internally by get_all_case_stats.
+        Args:
+            rank: GPU process rank, 0 for CPU process
+            world_size: total number of GPUs, 1 for CPU process
+            manager_list: multiprocessing manager list object, if using multi-GPU.
+            key: dataset key
+            transform_list: option list of transforms before SegSummarizer
+        """
+        summarizer = SegSummarizer(
+            self.image_key,
+            self.label_key,
+            average=self.average,
+            do_ccp=self.do_ccp,
+            hist_bins=self.hist_bins,
+            hist_range=self.hist_range,
+            histogram_only=self.histogram_only,
+        )
+        keys = list(filter(None, [self.image_key, self.label_key]))
+        if transform_list is None:
+            transform_list = [
+                LoadImaged(keys=keys, ensure_channel_first=True, image_only=True),
+                EnsureTyped(keys=keys, data_type="tensor", dtype=torch.float),
+                Orientationd(keys=keys, axcodes="RAS"),
+            ]
+            if self.label_key is not None:
+                allowed_shape_difference = self.extra_params.pop("allowed_shape_difference", 5)
+                transform_list.append(
+                    EnsureSameShaped(
+                        keys=self.label_key,
+                        source_key=self.image_key,
+                        allowed_shape_difference=allowed_shape_difference,
+                    )
+                )
+
+        transform = Compose(transform_list)
+        files, _ = datafold_read(datalist=self.datalist, basedir=self.dataroot, fold=-1, key=key)
+        if world_size <= len(files):
+            files = partition_dataset(data=files, num_partitions=world_size)[rank]
+        else:
+            files = partition_dataset(data=files, num_partitions=len(files))[rank] if rank < len(files) else []
+        dataset = Dataset(data=files, transform=transform)
+        dataloader = DataLoader(
+            dataset,
+            batch_size=1,
+            shuffle=False,
+            num_workers=self.worker,
+            collate_fn=no_collation,
+            pin_memory=self.device.type == "cuda",
+        )
+        result_bycase: dict[DataStatsKeys, Any] = {DataStatsKeys.SUMMARY: {}, DataStatsKeys.BY_CASE: []}
+        device = self.device if self.device.type == "cpu" else torch.device("cuda", rank)
+        if device.type == "cuda" and not (torch.cuda.is_available() and torch.cuda.device_count() > 0):
+            logger.info(f"device={device} but CUDA device is not available, using CPU instead.")
+            device = torch.device("cpu")
+        if not has_tqdm:
+            warnings.warn("tqdm is not installed. not displaying the caching progress.")
+
+        for batch_data in tqdm(dataloader) if (has_tqdm and rank == 0) else dataloader:
+            batch_data = batch_data[0]
+            try:
+                batch_data[self.image_key] = batch_data[self.image_key].to(device)
+                _label_argmax = False
+                if self.label_key is not None:
+                    label = batch_data[self.label_key]
+                    label = torch.argmax(label, dim=0) if label.shape[0] > 1 else label[0]
+                    _label_argmax = True  # track if label is argmaxed
+                    batch_data[self.label_key] = label.to(device)
+                d = summarizer(batch_data)
+            except BaseException as err:
+                if "image_meta_dict" in batch_data.keys():
+                    filename = batch_data["image_meta_dict"][ImageMetaKey.FILENAME_OR_OBJ]
+                else:
+                    filename = batch_data[self.image_key].meta[ImageMetaKey.FILENAME_OR_OBJ]
+                logger.info(f"Unable to process data {filename} on {device}. {err}")
+                if self.device.type == "cuda":
+                    logger.info("DataAnalyzer `device` set to GPU execution hit an exception. Falling back to `cpu`.")
+                    try:
+                        batch_data[self.image_key] = batch_data[self.image_key].to("cpu")
+                        if self.label_key is not None:
+                            label = batch_data[self.label_key]
+                            if not _label_argmax:
+                                label = torch.argmax(label, dim=0) if label.shape[0] > 1 else label[0]
+                            batch_data[self.label_key] = label.to("cpu")
+                        d = summarizer(batch_data)
+                    except BaseException as err:
+                        logger.info(f"Unable to process data {filename} on {device}. {err}")
+                        continue
+                else:
+                    continue
+
+            stats_by_cases = {
+                DataStatsKeys.BY_CASE_IMAGE_PATH: d[DataStatsKeys.BY_CASE_IMAGE_PATH],
+                DataStatsKeys.BY_CASE_LABEL_PATH: d[DataStatsKeys.BY_CASE_LABEL_PATH],
+            }
+            if not self.histogram_only:
+                stats_by_cases[DataStatsKeys.IMAGE_STATS] = d[DataStatsKeys.IMAGE_STATS]
+            if self.hist_bins != 0:
+                stats_by_cases[DataStatsKeys.IMAGE_HISTOGRAM] = d[DataStatsKeys.IMAGE_HISTOGRAM]
+
+            if self.label_key is not None:
+                stats_by_cases.update(
+                    {
+                        DataStatsKeys.FG_IMAGE_STATS: d[DataStatsKeys.FG_IMAGE_STATS],
+                        DataStatsKeys.LABEL_STATS: d[DataStatsKeys.LABEL_STATS],
+                    }
+                )
+            result_bycase[DataStatsKeys.BY_CASE].append(stats_by_cases)
+        if manager_list is None:
+            return result_bycase
+        else:
+            manager_list.append(result_bycase)

source_code/SegMamba/monai/apps/auto3dseg/ensemble_builder.py

@@ -0,0 +1,660 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from collections.abc import Mapping, Sequence
+from copy import deepcopy
+from typing import Any, cast
+from warnings import warn
+
+import numpy as np
+import torch
+import torch.distributed as dist
+
+from monai.apps.auto3dseg.bundle_gen import BundleAlgo
+from monai.apps.auto3dseg.utils import get_name_from_algo_id, import_bundle_algo_history
+from monai.apps.utils import get_logger
+from monai.auto3dseg import concat_val_to_np
+from monai.auto3dseg.utils import (
+    _prepare_cmd_bcprun,
+    _prepare_cmd_torchrun,
+    _run_cmd_bcprun,
+    _run_cmd_torchrun,
+    datafold_read,
+)
+from monai.bundle import ConfigParser
+from monai.data import partition_dataset
+from monai.transforms import MeanEnsemble, SaveImage, VoteEnsemble
+from monai.utils import RankFilter
+from monai.utils.enums import AlgoKeys
+from monai.utils.misc import check_kwargs_exist_in_class_init, prob2class
+from monai.utils.module import look_up_option, optional_import
+
+tqdm, has_tqdm = optional_import("tqdm", name="tqdm")
+
+logger = get_logger(module_name=__name__)
+
+
+class AlgoEnsemble(ABC):
+    """
+    The base class of Ensemble methods
+    """
+
+    def __init__(self):
+        self.algos = []
+        self.mode = "mean"
+        self.infer_files = []
+        self.algo_ensemble = []
+
+    def set_algos(self, infer_algos):
+        """
+        Register model in the ensemble
+        """
+        self.algos = deepcopy(infer_algos)
+
+    def get_algo(self, identifier):
+        """
+        Get a model by identifier.
+
+        Args:
+            identifier: the name of the bundleAlgo
+        """
+        for algo in self.algos:
+            if identifier == algo[AlgoKeys.ID]:
+                return algo
+
+    def get_algo_ensemble(self):
+        """
+        Get the algo ensemble after ranking or a empty list if ranking was not started.
+
+        Returns:
+            A list of Algo
+        """
+        return self.algo_ensemble
+
+    def set_infer_files(self, dataroot: str, data_list_or_path: str | list, data_key: str = "testing") -> None:
+        """
+        Set the files to perform model inference.
+
+        Args:
+            dataroot: the path of the files
+            data_list_or_path: the data source file path
+        """
+
+        self.infer_files = []
+
+        if isinstance(data_list_or_path, list):
+            self.infer_files = data_list_or_path
+        elif isinstance(data_list_or_path, str):
+            datalist = ConfigParser.load_config_file(data_list_or_path)
+            if data_key in datalist:
+                self.infer_files, _ = datafold_read(datalist=datalist, basedir=dataroot, fold=-1, key=data_key)
+            elif not hasattr(self, "rank") or self.rank == 0:
+                logger.info(f"Datalist file has no testing key - {data_key}. No data for inference is specified")
+
+        else:
+            raise ValueError("Unsupported parameter type")
+
+    def ensemble_pred(self, preds, sigmoid=False):
+        """
+        ensemble the results using either "mean" or "vote" method
+
+        Args:
+            preds: a list of probability prediction in Tensor-Like format.
+            sigmoid: use the sigmoid function to threshold probability one-hot map,
+                otherwise argmax is used. Defaults to False
+
+        Returns:
+            a tensor which is the ensembled prediction.
+        """
+
+        if any(not p.is_cuda for p in preds):
+            preds = [p.cpu() for p in preds]  # ensure CPU if at least one is on CPU
+
+        if self.mode == "mean":
+            prob = MeanEnsemble()(preds)
+            return prob2class(cast(torch.Tensor, prob), dim=0, keepdim=True, sigmoid=sigmoid)
+        elif self.mode == "vote":
+            classes = [prob2class(p, dim=0, keepdim=True, sigmoid=sigmoid) for p in preds]
+            if sigmoid:
+                return VoteEnsemble()(classes)  # do not specify num_classes for one-hot encoding
+            else:
+                return VoteEnsemble(num_classes=preds[0].shape[0])(classes)
+
+    def _apply_algo_specific_param(self, algo_spec_param: dict, param: dict, algo_name: str) -> dict:
+        """
+        Apply the model-specific params to the prediction params based on the name of the Algo.
+
+        Args:
+            algo_spec_param: a dict that has structure of {"<name of algo>": "<pred_params for that algo>"}.
+            param: the prediction params to override.
+            algo_name: name of the Algo
+
+        Returns:
+            param after being updated with the model-specific param
+        """
+        _param_to_override = deepcopy(algo_spec_param)
+        _param = deepcopy(param)
+        for k, v in _param_to_override.items():
+            if k.lower() == algo_name.lower():
+                _param.update(v)
+        return _param
+
+    def __call__(self, pred_param: dict | None = None) -> list:
+        """
+        Use the ensembled model to predict result.
+
+        Args:
+            pred_param: prediction parameter dictionary. The key has two groups: the first one will be consumed
+                in this function, and the second group will be passed to the `InferClass` to override the
+                parameters of the class functions.
+                The first group contains:
+
+                    - ``"infer_files"``: file paths to the images to read in a list.
+                    - ``"files_slices"``: a value type of `slice`. The files_slices will slice the ``"infer_files"`` and
+                      only make prediction on the infer_files[file_slices].
+                    - ``"mode"``: ensemble mode. Currently "mean" and "vote" (majority voting) schemes are supported.
+                    - ``"image_save_func"``: a dictionary used to instantiate the ``SaveImage`` transform. When specified,
+                      the ensemble prediction will save the prediction files, instead of keeping the files in the memory.
+                      Example: `{"_target_": "SaveImage", "output_dir": "./"}`
+                    - ``"sigmoid"``: use the sigmoid function (e.g. x > 0.5) to convert the prediction probability map
+                      to the label class prediction, otherwise argmax(x) is used.
+                    - ``"algo_spec_params"``: a dictionary to add pred_params that are specific to a model.
+                      The dict has a format of {"<name of algo>": "<pred_params for that algo>"}.
+
+                The parameters in the second group is defined in the ``config`` of each Algo templates. Please check:
+                https://github.com/Project-MONAI/research-contributions/tree/main/auto3dseg/algorithm_templates
+
+        Returns:
+            A list of tensors or file paths, depending on whether ``"image_save_func"`` is set.
+        """
+        param = {} if pred_param is None else deepcopy(pred_param)
+        files = self.infer_files
+
+        if "infer_files" in param:
+            files = param.pop("infer_files")
+
+        if "files_slices" in param:
+            slices = param.pop("files_slices")
+            files = files[slices]
+
+        if "mode" in param:
+            mode = param.pop("mode")
+            self.mode = look_up_option(mode, supported=["mean", "vote"])
+
+        sigmoid = param.pop("sigmoid", False)
+
+        if "image_save_func" in param:
+            img_saver = ConfigParser(param["image_save_func"]).get_parsed_content()
+
+        algo_spec_params = param.pop("algo_spec_params", {})
+
+        outputs = []
+        for _, file in (
+            enumerate(tqdm(files, desc="Ensembling (rank 0)..."))
+            if has_tqdm and pred_param and pred_param.get("rank", 0) == 0
+            else enumerate(files)
+        ):
+            preds = []
+            for algo in self.algo_ensemble:
+                infer_algo_name = get_name_from_algo_id(algo[AlgoKeys.ID])
+                infer_instance = algo[AlgoKeys.ALGO]
+                _param = self._apply_algo_specific_param(algo_spec_params, param, infer_algo_name)
+                pred = infer_instance.predict(predict_files=[file], predict_params=_param)
+                preds.append(pred[0])
+            if "image_save_func" in param:
+                try:
+                    ensemble_preds = self.ensemble_pred(preds, sigmoid=sigmoid)
+                except BaseException:
+                    ensemble_preds = self.ensemble_pred([_.to("cpu") for _ in preds], sigmoid=sigmoid)
+                res = img_saver(ensemble_preds)
+                # res is the path to the saved results
+                if hasattr(res, "meta") and "saved_to" in res.meta.keys():
+                    res = res.meta["saved_to"]
+                else:
+                    warn("Image save path not returned.")
+                    res = None
+            else:
+                warn("Prediction returned in list instead of disk, provide image_save_func to avoid out of memory.")
+                res = self.ensemble_pred(preds, sigmoid=sigmoid)
+            outputs.append(res)
+        return outputs
+
+    @abstractmethod
+    def collect_algos(self, *args, **kwargs):
+        raise NotImplementedError
+
+
+class AlgoEnsembleBestN(AlgoEnsemble):
+    """
+    Ensemble method that select N model out of all using the models' best_metric scores
+
+    Args:
+        n_best: number of models to pick for ensemble (N).
+    """
+
+    def __init__(self, n_best: int = 5):
+        super().__init__()
+        self.n_best = n_best
+
+    def sort_score(self):
+        """
+        Sort the best_metrics
+        """
+        scores = concat_val_to_np(self.algos, [AlgoKeys.SCORE])
+        return np.argsort(scores).tolist()
+
+    def collect_algos(self, n_best: int = -1) -> None:
+        """
+        Rank the algos by finding the top N (n_best) validation scores.
+        """
+
+        if n_best <= 0:
+            n_best = self.n_best
+
+        ranks = self.sort_score()
+        if len(ranks) < n_best:
+            warn(f"Found {len(ranks)} available algos (pre-defined n_best={n_best}). All {len(ranks)} will be used.")
+            n_best = len(ranks)
+
+        # get the ranks for which the indices are lower than N-n_best
+        indices = [r for (i, r) in enumerate(ranks) if i < (len(ranks) - n_best)]
+
+        # remove the found indices
+        indices = sorted(indices, reverse=True)
+
+        self.algo_ensemble = deepcopy(self.algos)
+        for idx in indices:
+            if idx < len(self.algo_ensemble):
+                self.algo_ensemble.pop(idx)
+
+
+class AlgoEnsembleBestByFold(AlgoEnsemble):
+    """
+    Ensemble method that select the best models that are the tops in each fold.
+
+    Args:
+        n_fold: number of cross-validation folds used in training
+    """
+
+    def __init__(self, n_fold: int = 5):
+        super().__init__()
+        self.n_fold = n_fold
+
+    def collect_algos(self) -> None:
+        """
+        Rank the algos by finding the best model in each cross-validation fold
+        """
+
+        self.algo_ensemble = []
+        for f_idx in range(self.n_fold):
+            best_score = -1.0
+            best_model: BundleAlgo | None = None
+            for algo in self.algos:
+                # algorithm folder: {net}_{fold_index}_{other}
+                identifier = algo[AlgoKeys.ID].split("_")[1]
+                try:
+                    algo_id = int(identifier)
+                except ValueError as err:
+                    raise ValueError(f"model identifier {identifier} is not number.") from err
+                if algo_id == f_idx and algo[AlgoKeys.SCORE] > best_score:
+                    best_model = algo
+                    best_score = algo[AlgoKeys.SCORE]
+            self.algo_ensemble.append(best_model)
+
+
+class AlgoEnsembleBuilder:
+    """
+    Build ensemble workflow from configs and arguments.
+
+    Args:
+        history: a collection of trained bundleAlgo algorithms.
+        data_src_cfg_name: filename of the data source.
+
+    Examples:
+
+        .. code-block:: python
+
+            builder = AlgoEnsembleBuilder(history, data_src_cfg)
+            builder.set_ensemble_method(BundleAlgoEnsembleBestN(3))
+            ensemble = builder.get_ensemble()
+
+    """
+
+    def __init__(self, history: Sequence[dict[str, Any]], data_src_cfg_name: str | None = None):
+        self.infer_algos: list[dict[AlgoKeys, Any]] = []
+        self.ensemble: AlgoEnsemble
+        self.data_src_cfg = ConfigParser(globals=False)
+
+        if data_src_cfg_name is not None and os.path.exists(str(data_src_cfg_name)):
+            self.data_src_cfg.read_config(data_src_cfg_name)
+
+        for algo_dict in history:
+            # load inference_config_paths
+
+            name = algo_dict[AlgoKeys.ID]
+            gen_algo = algo_dict[AlgoKeys.ALGO]
+
+            best_metric = gen_algo.get_score()
+            algo_path = gen_algo.output_path
+            infer_path = os.path.join(algo_path, "scripts", "infer.py")
+
+            if not os.path.isdir(algo_path):
+                warn(f"{gen_algo.output_path} is not a directory. Please check the path.")
+
+            if not os.path.isfile(infer_path):
+                warn(f"{infer_path} is not found. Please check the path.")
+
+            self.add_inferer(name, gen_algo, best_metric)
+
+    def add_inferer(self, identifier: str, gen_algo: BundleAlgo, best_metric: float | None = None) -> None:
+        """
+        Add model inferer to the builder.
+
+        Args:
+            identifier: name of the bundleAlgo.
+            gen_algo: a trained BundleAlgo model object.
+            best_metric: the best metric in validation of the trained model.
+        """
+
+        if best_metric is None:
+            raise ValueError("Feature to re-validate is to be implemented")
+
+        algo = {AlgoKeys.ID: identifier, AlgoKeys.ALGO: gen_algo, AlgoKeys.SCORE: best_metric}
+        self.infer_algos.append(algo)
+
+    def set_ensemble_method(self, ensemble: AlgoEnsemble, *args: Any, **kwargs: Any) -> None:
+        """
+        Set the ensemble method.
+
+        Args:
+            ensemble: the AlgoEnsemble to build.
+        """
+
+        ensemble.set_algos(self.infer_algos)
+        ensemble.collect_algos(*args, **kwargs)
+        ensemble.set_infer_files(self.data_src_cfg["dataroot"], self.data_src_cfg["datalist"])
+
+        self.ensemble = ensemble
+
+    def get_ensemble(self):
+        """Get the ensemble"""
+
+        return self.ensemble
+
+
+class EnsembleRunner:
+    """
+    The Runner for ensembler. It ensembles predictions and saves them to the disk with a support of using multi-GPU.
+
+    Args:
+        data_src_cfg_name: filename of the data source.
+        work_dir: working directory to save the intermediate and final results. Default is `./work_dir`.
+        num_fold: number of fold. Default is 5.
+        ensemble_method_name: method to ensemble predictions from different model. Default is AlgoEnsembleBestByFold.
+                              Supported methods: ["AlgoEnsembleBestN", "AlgoEnsembleBestByFold"].
+        mgpu: if using multi-gpu. Default is True.
+        kwargs: additional image writing, ensembling parameters and prediction parameters for the ensemble inference.
+              - for image saving, please check the supported parameters in SaveImage transform.
+              - for prediction parameters, please check the supported parameters in the ``AlgoEnsemble`` callables.
+              - for ensemble parameters, please check the documentation of the selected AlgoEnsemble callable.
+
+    Example:
+
+        .. code-block:: python
+
+            ensemble_runner = EnsembleRunner(data_src_cfg_name,
+                                             work_dir,
+                                             ensemble_method_name,
+                                             mgpu=device_setting['n_devices']>1,
+                                             **kwargs,
+                                             **pred_params)
+            ensemble_runner.run(device_setting)
+
+    """
+
+    def __init__(
+        self,
+        data_src_cfg_name: str,
+        work_dir: str = "./work_dir",
+        num_fold: int = 5,
+        ensemble_method_name: str = "AlgoEnsembleBestByFold",
+        mgpu: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        self.data_src_cfg_name = data_src_cfg_name
+        self.work_dir = work_dir
+        self.num_fold = num_fold
+        self.ensemble_method_name = ensemble_method_name
+        self.mgpu = mgpu
+        self.kwargs = deepcopy(kwargs)
+        self.rank = 0
+        self.world_size = 1
+        self.device_setting: dict[str, int | str] = {
+            "CUDA_VISIBLE_DEVICES": ",".join([str(x) for x in range(torch.cuda.device_count())]),
+            "n_devices": torch.cuda.device_count(),
+            "NUM_NODES": int(os.environ.get("NUM_NODES", 1)),
+            "MN_START_METHOD": os.environ.get("MN_START_METHOD", "bcprun"),
+            "CMD_PREFIX": os.environ.get("CMD_PREFIX", ""),
+        }
+
+    def set_ensemble_method(self, ensemble_method_name: str = "AlgoEnsembleBestByFold", **kwargs: Any) -> None:
+        """
+        Set the bundle ensemble method
+
+        Args:
+            ensemble_method_name: the name of the ensemble method. Only two methods are supported "AlgoEnsembleBestN"
+                and "AlgoEnsembleBestByFold".
+            kwargs: the keyword arguments used to define the ensemble method. Currently only ``n_best`` for
+                ``AlgoEnsembleBestN`` is supported.
+
+        """
+        self.ensemble_method_name = look_up_option(
+            ensemble_method_name, supported=["AlgoEnsembleBestN", "AlgoEnsembleBestByFold"]
+        )
+        if self.ensemble_method_name == "AlgoEnsembleBestN":
+            n_best = kwargs.pop("n_best", 2)
+            self.ensemble_method = AlgoEnsembleBestN(n_best=n_best)
+        elif self.ensemble_method_name == "AlgoEnsembleBestByFold":
+            self.ensemble_method = AlgoEnsembleBestByFold(n_fold=self.num_fold)  # type: ignore
+        else:
+            raise NotImplementedError(f"Ensemble method {self.ensemble_method_name} is not implemented.")
+
+    def _pop_kwargs_to_get_image_save_transform(self, **kwargs):
+        """
+        Pop the kwargs used to define ImageSave class for the ensemble output.
+
+        Args:
+            kwargs: image writing parameters for the ensemble inference. The kwargs format follows SaveImage
+                transform. For more information, check https://docs.monai.io/en/stable/transforms.html#saveimage .
+
+        Returns:
+            save_image: a dictionary that can be used to instantiate a SaveImage class in ConfigParser.
+        """
+
+        output_dir = kwargs.pop("output_dir", None)
+
+        if output_dir is None:
+            output_dir = os.path.join(self.work_dir, "ensemble_output")
+            logger.info(f"The output_dir is not specified. {output_dir} will be used to save ensemble predictions.")
+
+        if not os.path.isdir(output_dir):
+            os.makedirs(output_dir, exist_ok=True)
+            logger.info(f"Directory {output_dir} is created to save ensemble predictions")
+
+        input_yaml = ConfigParser.load_config_file(self.data_src_cfg_name)
+        data_root_dir = input_yaml.get("dataroot", "")
+
+        save_image = {
+            "_target_": "SaveImage",
+            "output_dir": output_dir,
+            "output_postfix": kwargs.pop("output_postfix", "ensemble"),
+            "output_dtype": kwargs.pop("output_dtype", "$np.uint8"),
+            "resample": kwargs.pop("resample", False),
+            "print_log": False,
+            "savepath_in_metadict": True,
+            "data_root_dir": kwargs.pop("data_root_dir", data_root_dir),
+            "separate_folder": kwargs.pop("separate_folder", False),
+        }
+
+        are_all_args_save_image, extra_args = check_kwargs_exist_in_class_init(SaveImage, kwargs)
+        if are_all_args_save_image:
+            save_image.update(kwargs)
+        else:
+            # kwargs has extra values for other purposes, for example, pred_params
+            for args in list(kwargs):
+                if args not in extra_args:
+                    save_image.update({args: kwargs.pop(args)})
+
+        return save_image
+
+    def set_image_save_transform(self, **kwargs: Any) -> None:
+        """
+        Set the ensemble output transform.
+
+        Args:
+            kwargs: image writing parameters for the ensemble inference. The kwargs format follows SaveImage
+                transform. For more information, check https://docs.monai.io/en/stable/transforms.html#saveimage .
+
+        """
+        are_all_args_present, extra_args = check_kwargs_exist_in_class_init(SaveImage, kwargs)
+        if are_all_args_present:
+            self.kwargs.update(kwargs)
+        else:
+            raise ValueError(
+                f"{extra_args} are not supported in monai.transforms.SaveImage,"
+                "Check https://docs.monai.io/en/stable/transforms.html#saveimage for more information."
+            )
+
+    def set_num_fold(self, num_fold: int = 5) -> None:
+        """
+        Set the number of cross validation folds for all algos.
+
+        Args:
+            num_fold: a positive integer to define the number of folds.
+        """
+
+        if num_fold <= 0:
+            raise ValueError(f"num_fold is expected to be an integer greater than zero. Now it gets {num_fold}")
+        self.num_fold = num_fold
+
+    def ensemble(self):
+        if self.mgpu:  # torch.cuda.device_count() is not used because env is not set by autorunner
+            # init multiprocessing and update infer_files
+            dist.init_process_group(backend="nccl", init_method="env://")
+            self.world_size = dist.get_world_size()
+            self.rank = dist.get_rank()
+            logger.addFilter(RankFilter())
+        # set params after init_process_group to know the rank
+        self.set_num_fold(num_fold=self.num_fold)
+        self.set_ensemble_method(self.ensemble_method_name, **self.kwargs)
+        # self.kwargs needs to pop out args for set_image_save_transform
+        save_image = self._pop_kwargs_to_get_image_save_transform(**self.kwargs)
+
+        history = import_bundle_algo_history(self.work_dir, only_trained=False)
+        history_untrained = [h for h in history if not h[AlgoKeys.IS_TRAINED]]
+        if history_untrained:
+            logger.warning(
+                f"Ensembling step will skip {[h[AlgoKeys.ID] for h in history_untrained]} untrained algos."
+                "Generally it means these algos did not complete training."
+            )
+            history = [h for h in history if h[AlgoKeys.IS_TRAINED]]
+        if len(history) == 0:
+            raise ValueError(
+                f"Could not find the trained results in {self.work_dir}. "
+                "Possibly the required training step was not completed."
+            )
+
+        builder = AlgoEnsembleBuilder(history, self.data_src_cfg_name)
+        builder.set_ensemble_method(self.ensemble_method)
+        self.ensembler = builder.get_ensemble()
+        infer_files = self.ensembler.infer_files
+        if len(infer_files) < self.world_size:
+            if len(infer_files) == 0:
+                logger.info("No testing files for inference is provided. Ensembler ending.")
+                return
+            infer_files = [infer_files[self.rank]] if self.rank < len(infer_files) else []
+        else:
+            infer_files = partition_dataset(
+                data=infer_files, shuffle=False, num_partitions=self.world_size, even_divisible=False
+            )[self.rank]
+
+        # TO DO: Add some function in ensembler for infer_files update?
+        self.ensembler.infer_files = infer_files
+        # add rank to pred_params
+        self.kwargs["rank"] = self.rank
+        self.kwargs["image_save_func"] = save_image
+        logger.info("Auto3Dseg picked the following networks to ensemble:")
+        for algo in self.ensembler.get_algo_ensemble():
+            logger.info(algo[AlgoKeys.ID])
+        output_dir = save_image["output_dir"]
+        logger.info(f"Auto3Dseg ensemble prediction outputs will be saved in {output_dir}.")
+        self.ensembler(pred_param=self.kwargs)
+
+        if self.mgpu:
+            dist.destroy_process_group()
+
+    def run(self, device_setting: dict | None = None) -> None:
+        """
+        Load the run function in the training script of each model. Training parameter is predefined by the
+        algo_config.yaml file, which is pre-filled by the fill_template_config function in the same instance.
+
+        Args:
+            device_setting: device related settings, should follow the device_setting in auto_runner.set_device_info.
+                'CUDA_VISIBLE_DEVICES' should be a string e.g. '0,1,2,3'
+        """
+        # device_setting set default value and sanity check, in case device_setting not from autorunner
+        if device_setting is not None:
+            self.device_setting.update(device_setting)
+            self.device_setting["n_devices"] = len(str(self.device_setting["CUDA_VISIBLE_DEVICES"]).split(","))
+        self._create_cmd()
+
+    def _create_cmd(self) -> None:
+        if int(self.device_setting["NUM_NODES"]) <= 1 and int(self.device_setting["n_devices"]) <= 1:
+            # if single GPU
+            logger.info("Ensembling using single GPU!")
+            self.ensemble()
+            return
+
+        # define base cmd for subprocess
+        base_cmd = f"monai.apps.auto3dseg EnsembleRunner ensemble \
+                --data_src_cfg_name {self.data_src_cfg_name} \
+                --work_dir {self.work_dir} \
+                --num_fold {self.num_fold} \
+                --ensemble_method_name {self.ensemble_method_name} \
+                --mgpu True"
+
+        if self.kwargs and isinstance(self.kwargs, Mapping):
+            for k, v in self.kwargs.items():
+                base_cmd += f" --{k}={v}"
+        # define env for subprocess
+        ps_environ = os.environ.copy()
+        ps_environ["CUDA_VISIBLE_DEVICES"] = str(self.device_setting["CUDA_VISIBLE_DEVICES"])
+        if int(self.device_setting["NUM_NODES"]) > 1:
+            if self.device_setting["MN_START_METHOD"] != "bcprun":
+                raise NotImplementedError(
+                    f"{self.device_setting['MN_START_METHOD']} is not supported yet. "
+                    "Try modify EnsembleRunner._create_cmd for your cluster."
+                )
+            logger.info(f"Ensembling on {self.device_setting['NUM_NODES']} nodes!")
+            cmd = _prepare_cmd_bcprun("-m " + base_cmd, cmd_prefix=f"{self.device_setting['CMD_PREFIX']}")
+            _run_cmd_bcprun(cmd, n=self.device_setting["NUM_NODES"], p=self.device_setting["n_devices"])
+
+        else:
+            logger.info(f"Ensembling using {self.device_setting['n_devices']} GPU!")
+            cmd = _prepare_cmd_torchrun("-m " + base_cmd)
+            _run_cmd_torchrun(
+                cmd, nnodes=1, nproc_per_node=self.device_setting["n_devices"], env=ps_environ, check=True
+            )
+        return

source_code/SegMamba/monai/apps/auto3dseg/hpo_gen.py

@@ -0,0 +1,401 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+from abc import abstractmethod
+from copy import deepcopy
+from typing import Any, cast
+from warnings import warn
+
+from monai.apps.auto3dseg.bundle_gen import BundleAlgo
+from monai.apps.utils import get_logger
+from monai.auto3dseg import Algo, AlgoGen, algo_from_pickle, algo_to_pickle
+from monai.bundle.config_parser import ConfigParser
+from monai.config import PathLike
+from monai.utils import optional_import
+from monai.utils.enums import AlgoKeys
+
+nni, has_nni = optional_import("nni")
+optuna, has_optuna = optional_import("optuna")
+logger = get_logger(module_name=__name__)
+
+__all__ = ["HPOGen", "NNIGen", "OptunaGen"]
+
+
+class HPOGen(AlgoGen):
+    """
+    The base class for hyperparameter optimization (HPO) interfaces to generate algos in the Auto3Dseg pipeline.
+    The auto-generated algos are saved at their ``output_path`` on the disk. The files in the ``output_path``
+    may contain scripts that define the algo, configuration files, and pickle files that save the internal states
+    of the algo before/after the training. Compared to the BundleGen class, HPOGen generates Algo on-the-fly, so
+    training and algo generation may be executed alternatively and take a long time to finish the generation process.
+
+    """
+
+    @abstractmethod
+    def get_hyperparameters(self):
+        """Get the hyperparameter from HPO."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_params(self, *args, **kwargs):
+        """Update Algo parameters according to the hyperparameters to be evaluated."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_score(self):
+        """Report the evaluated results to HPO."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def run_algo(self, *args, **kwargs):
+        """Interface for launch the training given the fetched hyperparameters."""
+        raise NotImplementedError
+
+
+class NNIGen(HPOGen):
+    """
+    Generate algorithms for the NNI to automate hyperparameter tuning. The module has two major interfaces:
+    ``__init__`` which prints out how to set up the NNI, and a trialCommand function ``run_algo`` for the NNI library to
+    start the trial of the algo. More about trialCommand function can be found in ``trail code`` section in NNI webpage
+    https://nni.readthedocs.io/en/latest/tutorials/hpo_quickstart_pytorch/main.html .
+
+    Args:
+        algo: an Algo object (e.g. BundleAlgo) with defined methods: ``get_output_path`` and train
+            and supports saving to and loading from pickle files via ``algo_from_pickle`` and ``algo_to_pickle``.
+        params: a set of parameter to override the algo if override is supported by Algo subclass.
+
+    Examples::
+
+        The experiment will keep generating new folders to save the model checkpoints, scripts, and configs if available.
+        ├── algorithm_templates
+        │   └── unet
+        ├── unet_0
+        │   ├── algo_object.pkl
+        │   ├── configs
+        │   └── scripts
+        ├── unet_0_learning_rate_0.01
+        │   ├── algo_object.pkl
+        │   ├── configs
+        │   ├── model_fold0
+        │   └── scripts
+        └── unet_0_learning_rate_0.1
+            ├── algo_object.pkl
+            ├── configs
+            ├── model_fold0
+            └── scripts
+
+        .. code-block:: python
+            # Bundle Algorithms are already generated by BundleGen in work_dir
+            import_bundle_algo_history(work_dir, only_trained=False)
+            algo_dict = self.history[0]  # pick the first algorithm
+            algo_name = algo_dict[AlgoKeys.ID]
+            onealgo = algo_dict[AlgoKeys.ALGO]
+            nni_gen = NNIGen(algo=onealgo)
+            nni_gen.print_bundle_algo_instruction()
+
+    Notes:
+        The NNIGen will prepare the algorithms in a folder and suggest a command to replace trialCommand in the experiment
+        config. However, NNIGen will not trigger NNI. User needs to write their NNI experiment configs, and then run the
+        NNI command manually.
+    """
+
+    def __init__(self, algo: Algo | None = None, params: dict | None = None):
+        self.algo: Algo
+        self.hint = ""
+        self.obj_filename = ""
+
+        if algo is not None:
+            if isinstance(algo, BundleAlgo):
+                if params is None:
+                    self.algo = algo
+                else:
+                    self.algo = deepcopy(algo)
+                    name = os.path.basename(algo.get_output_path()) + "_override"
+                    output_folder = os.path.dirname(algo.get_output_path())
+
+                    params.update({"fill_with_datastats": False})  # just copy, not using datastats to fill
+                    self.algo.export_to_disk(output_folder, name, **params)
+            else:
+                self.algo = algo
+
+            self.obj_filename = algo_to_pickle(self.algo, template_path=self.algo.template_path)
+
+    def get_obj_filename(self):
+        """Return the filename of the dumped pickle algo object."""
+        return self.obj_filename
+
+    def print_bundle_algo_instruction(self):
+        """
+        Print how to write the trial commands for Bundle Algo.
+        """
+        hint = "python -m monai.apps.auto3dseg NNIGen run_algo "
+        logger.info("=" * 140)
+        logger.info("If NNI will run in your local env: ")
+        logger.info("1. Add the following line to the trialCommand in your NNI config: ")
+        logger.info(f"{hint} {self.obj_filename} {{result_dir}}")
+        logger.info("-" * 140)
+        logger.info("If NNI will run in a remote env: ")
+        logger.info(
+            f"1. Copy the algorithm_templates folder {cast(BundleAlgo, self.algo).template_path} "
+            f"to remote {{remote_algorithm_templates_dir}}"
+        )
+        logger.info(f"2. Copy the older {self.algo.get_output_path()} to the remote machine {{remote_algo_dir}}")
+        logger.info("Then add the following line to the trialCommand in your NNI config: ")
+        logger.info(f"{hint} {{remote_algo_dir}} {{result_dir}} {{remote_algorithm_templates_dir}}")
+        logger.info("=" * 140)
+
+    def get_hyperparameters(self):
+        """
+        Get parameter for next round of training from NNI server.
+        """
+        if has_nni:
+            return nni.get_next_parameter()
+        warn("NNI is not detected. The code will continue to run without NNI.")
+        return {}
+
+    def update_params(self, params: dict) -> None:
+        """
+        Translate the parameter from monai bundle to meet NNI requirements.
+
+        Args:
+            params: a dict of parameters.
+        """
+        self.params = params
+
+    def get_task_id(self):
+        """
+        Get the identifier of the current experiment. In the format of listing the searching parameter name and values
+        connected by underscore in the file name.
+        """
+        return "".join(f"_{k}_{v}" for k, v in self.params.items()) or "_None"
+
+    def generate(self, output_folder: str = ".") -> None:
+        """
+        Generate the record for each Algo. If it is a BundleAlgo, it will generate the config files.
+
+        Args:
+            output_folder: the directory nni will save the results to.
+        """
+        task_id = self.get_task_id()
+        task_prefix = os.path.basename(self.algo.get_output_path())
+        write_path = os.path.join(output_folder, task_prefix + task_id)
+        self.obj_filename = os.path.join(write_path, "algo_object.pkl")
+
+        if isinstance(self.algo, BundleAlgo):
+            self.algo.export_to_disk(
+                output_folder, task_prefix + task_id, bundle_root=write_path, fill_with_datastats=False
+            )
+        else:
+            ConfigParser.export_config_file(self.params, write_path)
+            logger.info(write_path)
+
+    def set_score(self, acc):
+        """
+        Report the acc to NNI server.
+        """
+        if has_nni:
+            nni.report_final_result(acc)
+        else:
+            warn("NNI is not detected. The code will continue to run without NNI.")
+
+    def run_algo(self, obj_filename: str, output_folder: str = ".", template_path: PathLike | None = None) -> None:
+        """
+        The python interface for NNI to run.
+
+        Args:
+            obj_filename: the pickle-exported Algo object.
+            output_folder: the root path of the algorithms templates.
+            template_path: the algorithm_template. It must contain algo.py in the follow path:
+                ``{algorithm_templates_dir}/{network}/scripts/algo.py``
+        """
+        if not os.path.isfile(obj_filename):
+            raise ValueError(f"{obj_filename} is not found")
+
+        self.algo, algo_meta_data = algo_from_pickle(obj_filename, template_path=template_path)
+
+        # step 1 sample hyperparams
+        params = self.get_hyperparameters()
+        # step 2 set the update params for the algo to run in the next trial
+        self.update_params(params)
+        # step 3 generate the folder to save checkpoints and train
+        self.generate(output_folder)
+        self.algo.train(self.params)
+        # step 4 report validation acc to controller
+        acc = self.algo.get_score()
+        algo_meta_data = {str(AlgoKeys.SCORE): acc}
+
+        algo_to_pickle(self.algo, template_path=self.algo.template_path, **algo_meta_data)
+        self.set_score(acc)
+
+
+class OptunaGen(HPOGen):
+    """
+    Generate algorithms for the Optuna to automate hyperparameter tuning. Please refer to NNI and Optuna
+    (https://optuna.readthedocs.io/en/stable/) for more information. Optuna has different running scheme
+    compared to NNI. The hyperparameter samples come from a trial object (trial.suggest...) created by Optuna,
+    so OptunaGen needs to accept this trial object as input. Meanwhile, Optuna calls OptunaGen,
+    thus OptunaGen.__call__() should return the accuracy. Use functools.partial to wrap OptunaGen
+    for addition input arguments.
+
+    Args:
+        algo: an Algo object (e.g. BundleAlgo). The object must at least define two methods: get_output_path and train
+            and supports saving to and loading from pickle files via ``algo_from_pickle`` and ``algo_to_pickle``.
+        params: a set of parameter to override the algo if override is supported by Algo subclass.
+
+    Examples::
+
+        The experiment will keep generating new folders to save the model checkpoints, scripts, and configs if available.
+        ├── algorithm_templates
+        │   └── unet
+        ├── unet_0
+        │   ├── algo_object.pkl
+        │   ├── configs
+        │   └── scripts
+        ├── unet_0_learning_rate_0.01
+        │   ├── algo_object.pkl
+        │   ├── configs
+        │   ├── model_fold0
+        │   └── scripts
+        └── unet_0_learning_rate_0.1
+            ├── algo_object.pkl
+            ├── configs
+            ├── model_fold0
+            └── scripts
+
+    Notes:
+        Different from NNI and NNIGen, OptunaGen and Optuna can be ran within the Python process.
+
+    """
+
+    def __init__(self, algo: Algo | None = None, params: dict | None = None) -> None:
+        self.algo: Algo
+        self.obj_filename = ""
+
+        if algo is not None:
+            if isinstance(algo, BundleAlgo):
+                if params is None:
+                    self.algo = algo
+                else:
+                    self.algo = deepcopy(algo)
+                    name = os.path.basename(algo.get_output_path()) + "_override"
+                    output_folder = os.path.dirname(algo.get_output_path())
+
+                    params.update({"fill_with_datastats": False})  # just copy, not using datastats to fill
+                    self.algo.export_to_disk(output_folder, name, **params)
+            else:
+                self.algo = algo
+
+            self.obj_filename = algo_to_pickle(self.algo, template_path=self.algo.template_path)
+
+    def get_obj_filename(self):
+        """Return the dumped pickle object of algo."""
+        return self.obj_filename
+
+    def get_hyperparameters(self):
+        """
+        Get parameter for next round of training from optuna trial object.
+        This function requires user rewrite during usage for different search space.
+        """
+        if has_optuna:
+            logger.info("Please rewrite this code by creating a child class")
+            return {"learning_rate": self.trial.suggest_float("learning_rate", 0.0001, 0.1)}
+        else:
+            warn("Optuna is not detected. The code will continue to run without Optuna.")
+            return {}
+
+    def set_score(self, acc):
+        """Set the accuracy score"""
+        self.acc = acc
+
+    def set_trial(self, trial):
+        """Set the Optuna trial"""
+        self.trial = trial
+
+    def __call__(
+        self, trial: Any, obj_filename: str, output_folder: str = ".", template_path: PathLike | None = None
+    ) -> Any:
+        """
+        Callable that Optuna will use to optimize the hyper-parameters
+
+        Args:
+            obj_filename: the pickle-exported Algo object.
+            output_folder: the root path of the algorithms templates.
+            template_path: the algorithm_template. It must contain algo.py in the follow path:
+                ``{algorithm_templates_dir}/{network}/scripts/algo.py``
+        """
+        self.set_trial(trial)
+        self.run_algo(obj_filename, output_folder, template_path)
+        return self.acc
+
+    def update_params(self, params: dict) -> None:
+        """
+        Translate the parameter from monai bundle.
+
+        Args:
+            params: a dict of parameters.
+        """
+        self.params = params
+
+    def get_task_id(self):
+        """
+        Get the identifier of the current experiment. In the format of listing the searching parameter name and values
+        connected by underscore in the file name.
+        """
+        return "".join(f"_{k}_{v}" for k, v in self.params.items()) or "_None"
+
+    def generate(self, output_folder: str = ".") -> None:
+        """
+        Generate the record for each Algo. If it is a BundleAlgo, it will generate the config files.
+
+        Args:
+            output_folder: the directory nni will save the results to.
+        """
+        task_id = self.get_task_id()
+        task_prefix = os.path.basename(self.algo.get_output_path())
+        write_path = os.path.join(output_folder, task_prefix + task_id)
+        self.obj_filename = os.path.join(write_path, "algo_object.pkl")
+
+        if isinstance(self.algo, BundleAlgo):
+            self.algo.export_to_disk(output_folder, task_prefix + task_id, fill_with_datastats=False)
+        else:
+            ConfigParser.export_config_file(self.params, write_path)
+            logger.info(write_path)
+
+    def run_algo(self, obj_filename: str, output_folder: str = ".", template_path: PathLike | None = None) -> None:
+        """
+        The python interface for NNI to run.
+
+        Args:
+            obj_filename: the pickle-exported Algo object.
+            output_folder: the root path of the algorithms templates.
+            template_path: the algorithm_template. It must contain algo.py in the follow path:
+                ``{algorithm_templates_dir}/{network}/scripts/algo.py``
+        """
+        if not os.path.isfile(obj_filename):
+            raise ValueError(f"{obj_filename} is not found")
+
+        self.algo, algo_meta_data = algo_from_pickle(obj_filename, template_path=template_path)
+
+        # step 1 sample hyperparams
+        params = self.get_hyperparameters()
+        # step 2 set the update params for the algo to run in the next trial
+        self.update_params(params)
+        # step 3 generate the folder to save checkpoints and train
+        self.generate(output_folder)
+        self.algo.train(self.params)
+        # step 4 report validation acc to controller
+        acc = self.algo.get_score()
+        algo_meta_data = {str(AlgoKeys.SCORE): acc}
+        algo_to_pickle(self.algo, template_path=self.algo.template_path, **algo_meta_data)
+        self.set_score(acc)

source_code/SegMamba/monai/apps/deepedit/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/deepedit/interaction.py

@@ -0,0 +1,100 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import numpy as np
+import torch
+
+from monai.data import decollate_batch, list_data_collate
+from monai.engines import SupervisedEvaluator, SupervisedTrainer
+from monai.engines.utils import IterationEvents
+from monai.transforms import Compose
+from monai.utils.enums import CommonKeys
+
+
+class Interaction:
+    """
+    Ignite process_function used to introduce interactions (simulation of clicks) for DeepEdit Training/Evaluation.
+
+    More details about this can be found at:
+
+        Diaz-Pinto et al., MONAI Label: A framework for AI-assisted Interactive
+        Labeling of 3D Medical Images. (2022) https://arxiv.org/abs/2203.12362
+
+    Args:
+        deepgrow_probability: probability of simulating clicks in an iteration
+        transforms: execute additional transformation during every iteration (before train).
+            Typically, several Tensor based transforms composed by `Compose`.
+        train: True for training mode or False for evaluation mode
+        click_probability_key: key to click/interaction probability
+        label_names: Dict of label names
+        max_interactions: maximum number of interactions per iteration
+    """
+
+    def __init__(
+        self,
+        deepgrow_probability: float,
+        transforms: Sequence[Callable] | Callable,
+        train: bool,
+        label_names: None | dict[str, int] = None,
+        click_probability_key: str = "probability",
+        max_interactions: int = 1,
+    ) -> None:
+        self.deepgrow_probability = deepgrow_probability
+        self.transforms = Compose(transforms) if not isinstance(transforms, Compose) else transforms
+        self.train = train
+        self.label_names = label_names
+        self.click_probability_key = click_probability_key
+        self.max_interactions = max_interactions
+
+    def __call__(self, engine: SupervisedTrainer | SupervisedEvaluator, batchdata: dict[str, torch.Tensor]) -> dict:
+        if batchdata is None:
+            raise ValueError("Must provide batch data for current iteration.")
+
+        if np.random.choice([True, False], p=[self.deepgrow_probability, 1 - self.deepgrow_probability]):
+            for j in range(self.max_interactions):
+                inputs, _ = engine.prepare_batch(batchdata)
+                inputs = inputs.to(engine.state.device)
+
+                engine.fire_event(IterationEvents.INNER_ITERATION_STARTED)
+                engine.network.eval()
+
+                with torch.no_grad():
+                    if engine.amp:
+                        with torch.cuda.amp.autocast():
+                            predictions = engine.inferer(inputs, engine.network)
+                    else:
+                        predictions = engine.inferer(inputs, engine.network)
+                batchdata.update({CommonKeys.PRED: predictions})
+
+                # decollate/collate batchdata to execute click transforms
+                batchdata_list = decollate_batch(batchdata, detach=True)
+                for i in range(len(batchdata_list)):
+                    batchdata_list[i][self.click_probability_key] = (
+                        (1.0 - ((1.0 / self.max_interactions) * j)) if self.train else 1.0
+                    )
+                    batchdata_list[i] = self.transforms(batchdata_list[i])
+
+                batchdata = list_data_collate(batchdata_list)
+                engine.fire_event(IterationEvents.INNER_ITERATION_COMPLETED)
+        else:
+            # zero out input guidance channels
+            batchdata_list = decollate_batch(batchdata, detach=True)
+            for i in range(1, len(batchdata_list[0][CommonKeys.IMAGE])):
+                batchdata_list[0][CommonKeys.IMAGE][i] *= 0
+            batchdata = list_data_collate(batchdata_list)
+
+        # first item in batch only
+        engine.state.batch = batchdata
+        return engine._iteration(engine, batchdata)  # type: ignore[arg-type]

source_code/SegMamba/monai/apps/deepedit/transforms.py

@@ -0,0 +1,915 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import json
+import logging
+import random
+import warnings
+from collections.abc import Hashable, Mapping, Sequence, Sized
+
+import numpy as np
+import torch
+
+from monai.config import KeysCollection
+from monai.data import MetaTensor
+from monai.networks.layers import GaussianFilter
+from monai.transforms.transform import MapTransform, Randomizable, Transform
+from monai.utils import min_version, optional_import
+
+measure, _ = optional_import("skimage.measure", "0.14.2", min_version)
+
+logger = logging.getLogger(__name__)
+
+distance_transform_cdt, _ = optional_import("scipy.ndimage.morphology", name="distance_transform_cdt")
+
+
+class DiscardAddGuidanced(MapTransform):
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        number_intensity_ch: int = 1,
+        probability: float = 1.0,
+        label_names: Sized | None = None,
+        allow_missing_keys: bool = False,
+    ):
+        """
+        Discard positive and negative points according to discard probability
+
+        Args:
+            keys: The ``keys`` parameter will be used to get and set the actual data item to transform
+            number_intensity_ch: number of intensity channels
+            probability: probability of discarding clicks
+        """
+        super().__init__(keys, allow_missing_keys)
+
+        self.number_intensity_ch = number_intensity_ch
+        self.discard_probability = probability
+        self.label_names = label_names or []
+
+    def _apply(self, image):
+        if self.discard_probability >= 1.0 or np.random.choice(
+            [True, False], p=[self.discard_probability, 1 - self.discard_probability]
+        ):
+            signal = np.zeros(
+                (len(self.label_names), image.shape[-3], image.shape[-2], image.shape[-1]), dtype=np.float32
+            )
+            if image.shape[0] == self.number_intensity_ch + len(self.label_names):
+                image[self.number_intensity_ch :, ...] = signal
+            else:
+                image = np.concatenate([image, signal], axis=0)
+        return image
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "image":
+                tmp_image = self._apply(d[key])
+                if isinstance(d[key], MetaTensor):
+                    d[key].array = tmp_image
+                else:
+                    d[key] = tmp_image
+            else:
+                print("This transform only applies to the image")
+        return d
+
+
+class NormalizeLabelsInDatasetd(MapTransform):
+
+    def __init__(
+        self, keys: KeysCollection, label_names: dict[str, int] | None = None, allow_missing_keys: bool = False
+    ):
+        """
+        Normalize label values according to label names dictionary
+
+        Args:
+            keys: The ``keys`` parameter will be used to get and set the actual data item to transform
+            label_names: all label names
+        """
+        super().__init__(keys, allow_missing_keys)
+
+        self.label_names = label_names or {}
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            # Dictionary containing new label numbers
+            new_label_names = {}
+            label = np.zeros(d[key].shape)
+            # Making sure the range values and number of labels are the same
+            for idx, (key_label, val_label) in enumerate(self.label_names.items(), start=1):
+                if key_label != "background":
+                    new_label_names[key_label] = idx
+                    label[d[key] == val_label] = idx
+                if key_label == "background":
+                    new_label_names["background"] = 0
+
+            d["label_names"] = new_label_names
+            if isinstance(d[key], MetaTensor):
+                d[key].array = label
+            else:
+                d[key] = label
+        return d
+
+
+class SingleLabelSelectiond(MapTransform):
+
+    def __init__(
+        self, keys: KeysCollection, label_names: Sequence[str] | None = None, allow_missing_keys: bool = False
+    ):
+        """
+        Selects one label at a time to train the DeepEdit
+
+        Args:
+            keys: The ``keys`` parameter will be used to get and set the actual data item to transform
+            label_names: all label names
+        """
+        super().__init__(keys, allow_missing_keys)
+
+        self.label_names: Sequence[str] = label_names or []
+        self.all_label_values = {
+            "spleen": 1,
+            "right kidney": 2,
+            "left kidney": 3,
+            "gallbladder": 4,
+            "esophagus": 5,
+            "liver": 6,
+            "stomach": 7,
+            "aorta": 8,
+            "inferior vena cava": 9,
+            "portal_vein": 10,
+            "splenic_vein": 11,
+            "pancreas": 12,
+            "right adrenal gland": 13,
+            "left adrenal gland": 14,
+        }
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "label":
+                # Taking one label at a time
+                t_label = np.random.choice(self.label_names)
+                d["current_label"] = t_label
+                d[key][d[key] != self.all_label_values[t_label]] = 0.0
+                # Convert label to index values following label_names argument
+                max_label_val = self.label_names.index(t_label) + 1
+                d[key][d[key] > 0] = max_label_val
+                print(f"Using label {t_label} with number: {d[key].max()}")
+            else:
+                warnings.warn("This transform only applies to the label")
+        return d
+
+
+class AddGuidanceSignalDeepEditd(MapTransform):
+    """
+    Add Guidance signal for input image. Multilabel DeepEdit
+
+    Based on the "guidance" points, apply Gaussian to them and add them as new channel for input image.
+
+    Args:
+        guidance: key to store guidance.
+        sigma: standard deviation for Gaussian kernel.
+        number_intensity_ch: channel index.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        guidance: str = "guidance",
+        sigma: int = 3,
+        number_intensity_ch: int = 1,
+        allow_missing_keys: bool = False,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.guidance = guidance
+        self.sigma = sigma
+        self.number_intensity_ch = number_intensity_ch
+
+    def _get_signal(self, image, guidance):
+        dimensions = 3 if len(image.shape) > 3 else 2
+        guidance = guidance.tolist() if isinstance(guidance, np.ndarray) else guidance
+        guidance = json.loads(guidance) if isinstance(guidance, str) else guidance
+
+        # In inference the user may not provide clicks for some channels/labels
+        if len(guidance):
+            if dimensions == 3:
+                # Assume channel is first and depth is last CHWD
+                signal = np.zeros((1, image.shape[-3], image.shape[-2], image.shape[-1]), dtype=np.float32)
+            else:
+                signal = np.zeros((1, image.shape[-2], image.shape[-1]), dtype=np.float32)
+
+            sshape = signal.shape
+            for point in guidance:  # TO DO: make the guidance a list only - it is currently a list of list
+                if np.any(np.asarray(point) < 0):
+                    continue
+
+                if dimensions == 3:
+                    # Making sure points fall inside the image dimension
+                    p1 = max(0, min(int(point[-3]), sshape[-3] - 1))
+                    p2 = max(0, min(int(point[-2]), sshape[-2] - 1))
+                    p3 = max(0, min(int(point[-1]), sshape[-1] - 1))
+                    signal[:, p1, p2, p3] = 1.0
+                else:
+                    p1 = max(0, min(int(point[-2]), sshape[-2] - 1))
+                    p2 = max(0, min(int(point[-1]), sshape[-1] - 1))
+                    signal[:, p1, p2] = 1.0
+
+            # Apply a Gaussian filter to the signal
+            if np.max(signal[0]) > 0:
+                signal_tensor = torch.tensor(signal[0])
+                pt_gaussian = GaussianFilter(len(signal_tensor.shape), sigma=self.sigma)
+                signal_tensor = pt_gaussian(signal_tensor.unsqueeze(0).unsqueeze(0))
+                signal_tensor = signal_tensor.squeeze(0).squeeze(0)
+                signal[0] = signal_tensor.detach().cpu().numpy()
+                signal[0] = (signal[0] - np.min(signal[0])) / (np.max(signal[0]) - np.min(signal[0]))
+            return signal
+        else:
+            if dimensions == 3:
+                signal = np.zeros((1, image.shape[-3], image.shape[-2], image.shape[-1]), dtype=np.float32)
+            else:
+                signal = np.zeros((1, image.shape[-2], image.shape[-1]), dtype=np.float32)
+            return signal
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "image":
+                image = d[key]
+                tmp_image = image[0 : 0 + self.number_intensity_ch, ...]
+                guidance = d[self.guidance]
+                for key_label in guidance.keys():
+                    # Getting signal based on guidance
+                    signal = self._get_signal(image, guidance[key_label])
+                    tmp_image = np.concatenate([tmp_image, signal], axis=0)
+                    if isinstance(d[key], MetaTensor):
+                        d[key].array = tmp_image
+                    else:
+                        d[key] = tmp_image
+                return d
+            else:
+                print("This transform only applies to image key")
+        return d
+
+
+class FindAllValidSlicesDeepEditd(MapTransform):
+    """
+    Find/List all valid slices in the labels.
+    Label is assumed to be a 4D Volume with shape CHWD, where C=1.
+
+    Args:
+        sids: key to store slices indices having valid label map.
+    """
+
+    def __init__(self, keys: KeysCollection, sids: Hashable = "sids", allow_missing_keys: bool = False):
+        super().__init__(keys, allow_missing_keys)
+        self.sids = sids
+
+    def _apply(self, label, d):
+        sids = {}
+        for key_label in d["label_names"].keys():
+            l_ids = []
+            for sid in range(label.shape[-1]):  # Assume channel is first and depth is last CHWD
+                if d["label_names"][key_label] in label[0][..., sid]:
+                    l_ids.append(sid)
+            sids[key_label] = l_ids
+        return sids
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "label":
+                label = d[key]
+                if label.shape[0] != 1:
+                    raise ValueError("Only supports single channel labels!")
+
+                if len(label.shape) != 4:  # only for 3D
+                    raise ValueError("Only supports label with shape CHWD!")
+
+                sids = self._apply(label, d)
+                if sids is not None and len(sids.keys()):
+                    d[self.sids] = sids
+                return d
+            else:
+                print("This transform only applies to label key")
+        return d
+
+
+class AddInitialSeedPointDeepEditd(Randomizable, MapTransform):
+    """
+    Add random guidance as initial seed point for a given label.
+
+    Note that the label is of size (C, D, H, W) or (C, H, W)
+
+    The guidance is of size (2, N, # of dims) where N is number of guidance added.
+    # of dims = 4 when C, D, H, W; # of dims = 3 when (C, H, W)
+
+    Args:
+        guidance: key to store guidance.
+        sids: key that represents lists of valid slice indices for the given label.
+        sid: key that represents the slice to add initial seed point.  If not present, random sid will be chosen.
+        connected_regions: maximum connected regions to use for adding initial points.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        guidance: str = "guidance",
+        sids: str = "sids",
+        sid: str = "sid",
+        connected_regions: int = 5,
+        allow_missing_keys: bool = False,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.sids_key = sids
+        self.sid_key = sid
+        self.sid: dict[str, int] = dict()
+        self.guidance = guidance
+        self.connected_regions = connected_regions
+
+    def _apply(self, label, sid, key_label):
+        dimensions = 3 if len(label.shape) > 3 else 2
+        self.default_guidance = [-1] * (dimensions + 1)
+
+        dims = dimensions
+        if sid is not None and dimensions == 3:
+            dims = 2
+            label = label[0][..., sid][np.newaxis]  # Assume channel is first and depth is last CHWD
+
+        # THERE MAY BE MULTIPLE BLOBS FOR SINGLE LABEL IN THE SELECTED SLICE
+        label = (label > 0.5).astype(np.float32)
+        # measure.label: Label connected regions of an integer array - Two pixels are connected
+        # when they are neighbors and have the same value
+        blobs_labels = measure.label(label.astype(int), background=0) if dims == 2 else label
+        if np.max(blobs_labels) <= 0:
+            raise AssertionError(f"SLICES NOT FOUND FOR LABEL: {key_label}")
+
+        pos_guidance = []
+        for ridx in range(1, 2 if dims == 3 else self.connected_regions + 1):
+            if dims == 2:
+                label = (blobs_labels == ridx).astype(np.float32)
+                if np.sum(label) == 0:
+                    pos_guidance.append(self.default_guidance)
+                    continue
+
+            # The distance transform provides a metric or measure of the separation of points in the image.
+            # This function calculates the distance between each pixel that is set to off (0) and
+            # the nearest nonzero pixel for binary images - http://matlab.izmiran.ru/help/toolbox/images/morph14.html
+            distance = distance_transform_cdt(label).flatten()
+            probability = np.exp(distance) - 1.0
+
+            idx = np.where(label.flatten() > 0)[0]
+            seed = self.R.choice(idx, size=1, p=probability[idx] / np.sum(probability[idx]))
+            dst = distance[seed]
+
+            g = np.asarray(np.unravel_index(seed, label.shape)).transpose().tolist()[0]
+            g[0] = dst[0]  # for debug
+            if dimensions == 2 or dims == 3:
+                pos_guidance.append(g)
+            else:
+                # Clicks are created using this convention Channel Height Width Depth (CHWD)
+                pos_guidance.append([g[0], g[-2], g[-1], sid])  # Assume channel is first and depth is last CHWD
+
+        return np.asarray([pos_guidance])
+
+    def _randomize(self, d, key_label):
+        sids = d.get(self.sids_key).get(key_label) if d.get(self.sids_key) is not None else None
+        sid = d.get(self.sid_key).get(key_label) if d.get(self.sid_key) is not None else None
+        if sids is not None and sids:
+            if sid is None or sid not in sids:
+                sid = self.R.choice(sids, replace=False)
+        else:
+            logger.info(f"Not slice IDs for label: {key_label}")
+            sid = None
+        self.sid[key_label] = sid
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "label":
+                label_guidances = {}
+                for key_label in d["sids"].keys():
+                    # Randomize: Select a random slice
+                    self._randomize(d, key_label)
+                    # Generate guidance base on selected slice
+                    tmp_label = np.copy(d[key])
+                    # Taking one label to create the guidance
+                    if key_label != "background":
+                        tmp_label[tmp_label != float(d["label_names"][key_label])] = 0
+                    else:
+                        tmp_label[tmp_label != float(d["label_names"][key_label])] = 1
+                        tmp_label = 1 - tmp_label
+                    label_guidances[key_label] = json.dumps(
+                        self._apply(tmp_label, self.sid.get(key_label), key_label).astype(int).tolist()
+                    )
+                d[self.guidance] = label_guidances
+                return d
+            else:
+                print("This transform only applies to label key")
+        return d
+
+
+class FindDiscrepancyRegionsDeepEditd(MapTransform):
+    """
+    Find discrepancy between prediction and actual during click interactions during training.
+
+    Args:
+        pred: key to prediction source.
+        discrepancy: key to store discrepancies found between label and prediction.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        pred: str = "pred",
+        discrepancy: str = "discrepancy",
+        allow_missing_keys: bool = False,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.pred = pred
+        self.discrepancy = discrepancy
+
+    @staticmethod
+    def disparity(label, pred):
+        disparity = label - pred
+        # Negative ONES mean predicted label is not part of the ground truth
+        # Positive ONES mean predicted label missed that region of the ground truth
+        pos_disparity = (disparity > 0).astype(np.float32)
+        neg_disparity = (disparity < 0).astype(np.float32)
+        return [pos_disparity, neg_disparity]
+
+    def _apply(self, label, pred):
+        return self.disparity(label, pred)
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "label":
+                all_discrepancies = {}
+                for _, (key_label, val_label) in enumerate(d["label_names"].items()):
+                    if key_label != "background":
+                        # Taking single label
+                        label = np.copy(d[key])
+                        label[label != val_label] = 0
+                        # Label should be represented in 1
+                        label = (label > 0.5).astype(np.float32)
+                        # Taking single prediction
+                        pred = np.copy(d[self.pred])
+                        pred[pred != val_label] = 0
+                        # Prediction should be represented in one
+                        pred = (pred > 0.5).astype(np.float32)
+                    else:
+                        # Taking single label
+                        label = np.copy(d[key])
+                        label[label != val_label] = 1
+                        label = 1 - label
+                        # Label should be represented in 1
+                        label = (label > 0.5).astype(np.float32)
+                        # Taking single prediction
+                        pred = np.copy(d[self.pred])
+                        pred[pred != val_label] = 1
+                        pred = 1 - pred
+                        # Prediction should be represented in one
+                        pred = (pred > 0.5).astype(np.float32)
+                    all_discrepancies[key_label] = self._apply(label, pred)
+                d[self.discrepancy] = all_discrepancies
+                return d
+            else:
+                print("This transform only applies to 'label' key")
+        return d
+
+
+class AddRandomGuidanceDeepEditd(Randomizable, MapTransform):
+    """
+    Add random guidance based on discrepancies that were found between label and prediction.
+
+    Args:
+        guidance: key to guidance source, shape (2, N, # of dim)
+        discrepancy: key to discrepancy map between label and prediction shape (2, C, H, W, D) or (2, C, H, W)
+        probability: key to click/interaction probability, shape (1)
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        guidance: str = "guidance",
+        discrepancy: str = "discrepancy",
+        probability: str = "probability",
+        allow_missing_keys: bool = False,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.guidance_key = guidance
+        self.discrepancy = discrepancy
+        self.probability = probability
+        self._will_interact = None
+        self.is_pos: bool | None = None
+        self.is_other: bool | None = None
+        self.default_guidance = None
+        self.guidance: dict[str, list[list[int]]] = {}
+
+    def randomize(self, data=None):
+        probability = data[self.probability]
+        self._will_interact = self.R.choice([True, False], p=[probability, 1.0 - probability])
+
+    def find_guidance(self, discrepancy):
+        distance = distance_transform_cdt(discrepancy).flatten()
+        probability = np.exp(distance.flatten()) - 1.0
+        idx = np.where(discrepancy.flatten() > 0)[0]
+
+        if np.sum(discrepancy > 0) > 0:
+            seed = self.R.choice(idx, size=1, p=probability[idx] / np.sum(probability[idx]))
+            dst = distance[seed]
+
+            g = np.asarray(np.unravel_index(seed, discrepancy.shape)).transpose().tolist()[0]
+            g[0] = dst[0]
+            return g
+        return None
+
+    def add_guidance(self, guidance, discrepancy, label_names, labels):
+        # Positive clicks of the segment in the iteration
+        pos_discr = discrepancy[0]  # idx 0 is positive discrepancy and idx 1 is negative discrepancy
+
+        # Check the areas that belong to other segments
+        other_discrepancy_areas = {}
+        for _, (key_label, val_label) in enumerate(label_names.items()):
+            if key_label != "background":
+                tmp_label = np.copy(labels)
+                tmp_label[tmp_label != val_label] = 0
+                tmp_label = (tmp_label > 0.5).astype(np.float32)
+                other_discrepancy_areas[key_label] = np.sum(discrepancy[1] * tmp_label)
+            else:
+                tmp_label = np.copy(labels)
+                tmp_label[tmp_label != val_label] = 1
+                tmp_label = 1 - tmp_label
+                other_discrepancy_areas[key_label] = np.sum(discrepancy[1] * tmp_label)
+
+        # Add guidance to the current key label
+        if np.sum(pos_discr) > 0:
+            guidance.append(self.find_guidance(pos_discr))
+            self.is_pos = True
+
+        # Add guidance to the other areas
+        for key_label in label_names.keys():
+            # Areas that cover more than 50 voxels
+            if other_discrepancy_areas[key_label] > 50:
+                self.is_other = True
+                if key_label != "background":
+                    tmp_label = np.copy(labels)
+                    tmp_label[tmp_label != label_names[key_label]] = 0
+                    tmp_label = (tmp_label > 0.5).astype(np.float32)
+                    self.guidance[key_label].append(self.find_guidance(discrepancy[1] * tmp_label))
+                else:
+                    tmp_label = np.copy(labels)
+                    tmp_label[tmp_label != label_names[key_label]] = 1
+                    tmp_label = 1 - tmp_label
+                    self.guidance[key_label].append(self.find_guidance(discrepancy[1] * tmp_label))
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        guidance = d[self.guidance_key]
+        discrepancy = d[self.discrepancy]
+        self.randomize(data)
+        if self._will_interact:
+            # Convert all guidance to lists so new guidance can be easily appended
+            for key_label in d["label_names"].keys():
+                tmp_gui = guidance[key_label]
+                tmp_gui = tmp_gui.tolist() if isinstance(tmp_gui, np.ndarray) else tmp_gui
+                tmp_gui = json.loads(tmp_gui) if isinstance(tmp_gui, str) else tmp_gui
+                self.guidance[key_label] = [j for j in tmp_gui if -1 not in j]
+
+            # Add guidance according to discrepancy
+            for key_label in d["label_names"].keys():
+                # Add guidance based on discrepancy
+                self.add_guidance(self.guidance[key_label], discrepancy[key_label], d["label_names"], d["label"])
+
+            # Checking the number of clicks
+            num_clicks = random.randint(1, 10)
+            counter = 0
+            keep_guidance = []
+            while True:
+                aux_label = random.choice(list(d["label_names"].keys()))
+                if aux_label in keep_guidance:
+                    pass
+                else:
+                    keep_guidance.append(aux_label)
+                    counter = counter + len(self.guidance[aux_label])
+                    # If collected clicks is bigger than max clicks, discard the others
+                    if counter >= num_clicks:
+                        for key_label in d["label_names"].keys():
+                            if key_label not in keep_guidance:
+                                self.guidance[key_label] = []
+                        logger.info(f"Number of simulated clicks: {counter}")
+                        break
+
+                # Breaking once all labels are covered
+                if len(keep_guidance) == len(d["label_names"].keys()):
+                    logger.info(f"Number of simulated clicks: {counter}")
+                    break
+        d[self.guidance_key] = self.guidance  # Update the guidance
+        return d
+
+
+class AddGuidanceFromPointsDeepEditd(Transform):
+    """
+    Add guidance based on user clicks. ONLY WORKS FOR 3D
+
+    We assume the input is loaded by LoadImaged and has the shape of (H, W, D) originally.
+    Clicks always specify the coordinates in (H, W, D)
+
+    Args:
+        ref_image: key to reference image to fetch current and original image details.
+        guidance: output key to store guidance.
+        meta_keys: explicitly indicate the key of the metadata dictionary of `ref_image`.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            if None, will try to construct meta_keys by `{ref_image}_{meta_key_postfix}`.
+        meta_key_postfix: if meta_key is None, use `{ref_image}_{meta_key_postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+
+    """
+
+    def __init__(
+        self,
+        ref_image: str,
+        guidance: str = "guidance",
+        label_names: dict | None = None,
+        meta_keys: str | None = None,
+        meta_key_postfix: str = "meta_dict",
+    ):
+        self.ref_image = ref_image
+        self.guidance = guidance
+        self.label_names = label_names or {}
+        self.meta_keys = meta_keys
+        self.meta_key_postfix = meta_key_postfix
+
+    @staticmethod
+    def _apply(clicks, factor):
+        if len(clicks):
+            guidance = np.multiply(clicks, factor).astype(int).tolist()
+            return guidance
+        else:
+            return []
+
+    def __call__(self, data):
+        d = dict(data)
+        meta_dict_key = self.meta_keys or f"{self.ref_image}_{self.meta_key_postfix}"
+        # extract affine matrix from metadata
+        if isinstance(d[self.ref_image], MetaTensor):
+            meta_dict = d[self.ref_image].meta
+        elif meta_dict_key in d:
+            meta_dict = d[meta_dict_key]
+        else:
+            raise ValueError(
+                f"{meta_dict_key} is not found. Please check whether it is the correct the image meta key."
+            )
+
+        if "spatial_shape" not in meta_dict:
+            raise RuntimeError('Missing "spatial_shape" in meta_dict!')
+
+        # Assume channel is first and depth is last CHWD
+        original_shape = meta_dict["spatial_shape"]
+        current_shape = list(d[self.ref_image].shape)[1:]
+
+        # in here we assume the depth dimension is in the last dimension of "original_shape" and "current_shape"
+        factor = np.array(current_shape) / original_shape
+
+        # Creating guidance for all clicks
+        all_guidances = {}
+        for key_label in self.label_names.keys():
+            clicks = d.get(key_label, [])
+            clicks = list(np.array(clicks).astype(int))
+            all_guidances[key_label] = self._apply(clicks, factor)
+        d[self.guidance] = all_guidances
+        return d
+
+
+class ResizeGuidanceMultipleLabelDeepEditd(Transform):
+    """
+    Resize the guidance based on cropped vs resized image.
+
+    """
+
+    def __init__(self, guidance: str, ref_image: str) -> None:
+        self.guidance = guidance
+        self.ref_image = ref_image
+
+    def __call__(self, data):
+        d = dict(data)
+        # Assume channel is first and depth is last CHWD
+        current_shape = d[self.ref_image].shape[1:]
+
+        meta_dict_key = "image_meta_dict"
+        # extract affine matrix from metadata
+        if isinstance(d[self.ref_image], MetaTensor):
+            meta_dict = d[self.ref_image].meta
+        elif meta_dict_key in d:
+            meta_dict = d[meta_dict_key]
+        else:
+            raise ValueError(
+                f"{meta_dict_key} is not found. Please check whether it is the correct the image meta key."
+            )
+
+        original_shape = meta_dict["spatial_shape"]
+
+        factor = np.divide(current_shape, original_shape)
+        all_guidances = {}
+        for key_label in d[self.guidance].keys():
+            guidance = (
+                np.multiply(d[self.guidance][key_label], factor).astype(int).tolist()
+                if len(d[self.guidance][key_label])
+                else []
+            )
+            all_guidances[key_label] = guidance
+
+        d[self.guidance] = all_guidances
+        return d
+
+
+class SplitPredsLabeld(MapTransform):
+    """
+    Split preds and labels for individual evaluation
+
+    """
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "pred":
+                for idx, (key_label, _) in enumerate(d["label_names"].items()):
+                    if key_label != "background":
+                        d[f"pred_{key_label}"] = d[key][idx + 1, ...][None]
+                        d[f"label_{key_label}"] = d["label"][idx + 1, ...][None]
+            elif key != "pred":
+                logger.info("This is only for pred key")
+        return d
+
+
+class AddInitialSeedPointMissingLabelsd(Randomizable, MapTransform):
+    """
+    Add random guidance as initial seed point for a given label.
+    Note that the label is of size (C, D, H, W) or (C, H, W)
+    The guidance is of size (2, N, # of dims) where N is number of guidance added.
+    # of dims = 4 when C, D, H, W; # of dims = 3 when (C, H, W)
+    Args:
+        guidance: key to store guidance.
+        sids: key that represents lists of valid slice indices for the given label.
+        sid: key that represents the slice to add initial seed point.  If not present, random sid will be chosen.
+        connected_regions: maximum connected regions to use for adding initial points.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        guidance: str = "guidance",
+        sids: str = "sids",
+        sid: str = "sid",
+        connected_regions: int = 5,
+        allow_missing_keys: bool = False,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.sids_key = sids
+        self.sid_key = sid
+        self.sid: dict[str, int] = dict()
+        self.guidance = guidance
+        self.connected_regions = connected_regions
+
+    def _apply(self, label, sid):
+        dimensions = 3 if len(label.shape) > 3 else 2
+        self.default_guidance = [-1] * (dimensions + 1)
+
+        dims = dimensions
+        if sid is not None and dimensions == 3:
+            dims = 2
+            label = label[0][..., sid][np.newaxis]  # Assume channel is first and depth is last CHWD
+
+        # THERE MAY BE MULTIPLE BLOBS FOR SINGLE LABEL IN THE SELECTED SLICE
+        label = (label > 0.5).astype(np.float32)
+        # measure.label: Label connected regions of an integer array - Two pixels are connected
+        # when they are neighbors and have the same value
+        blobs_labels = measure.label(label.astype(int), background=0) if dims == 2 else label
+
+        label_guidance = []
+        # If there are is presence of that label in this slice
+        if np.max(blobs_labels) <= 0:
+            label_guidance.append(self.default_guidance)
+        else:
+            for ridx in range(1, 2 if dims == 3 else self.connected_regions + 1):
+                if dims == 2:
+                    label = (blobs_labels == ridx).astype(np.float32)
+                    if np.sum(label) == 0:
+                        label_guidance.append(self.default_guidance)
+                        continue
+
+                # The distance transform provides a metric or measure of the separation of points in the image.
+                # This function calculates the distance between each pixel that is set to off (0) and
+                # the nearest nonzero pixel for binary images
+                # http://matlab.izmiran.ru/help/toolbox/images/morph14.html
+                distance = distance_transform_cdt(label).flatten()
+                probability = np.exp(distance) - 1.0
+
+                idx = np.where(label.flatten() > 0)[0]
+                seed = self.R.choice(idx, size=1, p=probability[idx] / np.sum(probability[idx]))
+                dst = distance[seed]
+
+                g = np.asarray(np.unravel_index(seed, label.shape)).transpose().tolist()[0]
+                g[0] = dst[0]  # for debug
+                if dimensions == 2 or dims == 3:
+                    label_guidance.append(g)
+                else:
+                    # Clicks are created using this convention Channel Height Width Depth (CHWD)
+                    label_guidance.append([g[0], g[-2], g[-1], sid])  # Assume channel is first and depth is last CHWD
+
+        return np.asarray(label_guidance)
+
+    def _randomize(self, d, key_label):
+        sids = d.get(self.sids_key).get(key_label) if d.get(self.sids_key) is not None else None
+        sid = d.get(self.sid_key).get(key_label) if d.get(self.sid_key) is not None else None
+        if sids is not None and sids:
+            if sid is None or sid not in sids:
+                sid = self.R.choice(sids, replace=False)
+        else:
+            logger.info(f"Not slice IDs for label: {key_label}")
+            sid = None
+        self.sid[key_label] = sid
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "label":
+                label_guidances = {}
+                for key_label in d["sids"].keys():
+                    # Randomize: Select a random slice
+                    self._randomize(d, key_label)
+                    # Generate guidance base on selected slice
+                    tmp_label = np.copy(d[key])
+                    # Taking one label to create the guidance
+                    if key_label != "background":
+                        tmp_label[tmp_label != float(d["label_names"][key_label])] = 0
+                    else:
+                        tmp_label[tmp_label != float(d["label_names"][key_label])] = 1
+                        tmp_label = 1 - tmp_label
+                    label_guidances[key_label] = json.dumps(
+                        self._apply(tmp_label, self.sid.get(key_label)).astype(int).tolist()
+                    )
+                d[self.guidance] = label_guidances
+                return d
+            else:
+                print("This transform only applies to label key")
+        return d
+
+
+class FindAllValidSlicesMissingLabelsd(MapTransform):
+    """
+    Find/List all valid slices in the labels.
+    Label is assumed to be a 4D Volume with shape CHWD, where C=1.
+    Args:
+        sids: key to store slices indices having valid label map.
+    """
+
+    def __init__(self, keys: KeysCollection, sids: Hashable = "sids", allow_missing_keys: bool = False):
+        super().__init__(keys, allow_missing_keys)
+        self.sids = sids
+
+    def _apply(self, label, d):
+        sids = {}
+        for key_label in d["label_names"].keys():
+            l_ids = []
+            for sid in range(label.shape[-1]):  # Assume channel is first and depth is last CHWD
+                if d["label_names"][key_label] in label[0][..., sid]:
+                    l_ids.append(sid)
+            # If there are not slices with the label
+            if l_ids == []:
+                l_ids = [-1] * 10
+            sids[key_label] = l_ids
+        return sids
+
+    def __call__(self, data: Mapping[Hashable, np.ndarray]) -> dict[Hashable, np.ndarray]:
+        d: dict = dict(data)
+        for key in self.key_iterator(d):
+            if key == "label":
+                label = d[key]
+                if label.shape[0] != 1:
+                    raise ValueError("Only supports single channel labels!")
+
+                if len(label.shape) != 4:  # only for 3D
+                    raise ValueError("Only supports label with shape CHWD!")
+
+                sids = self._apply(label, d)
+                if sids is not None and len(sids.keys()):
+                    d[self.sids] = sids
+                return d
+            else:
+                print("This transform only applies to label key")
+        return d

source_code/SegMamba/monai/apps/deepgrow/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/deepgrow/dataset.py

@@ -0,0 +1,271 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Sequence
+
+import numpy as np
+
+from monai.config import PathLike
+from monai.transforms import Compose, EnsureChannelFirstd, LoadImaged, Orientationd, Spacingd, SqueezeDimd, Transform
+from monai.utils import GridSampleMode
+
+
+def create_dataset(
+    datalist: list[dict],
+    output_dir: str,
+    dimension: int,
+    pixdim: Sequence[float] | float,
+    image_key: str = "image",
+    label_key: str = "label",
+    base_dir: PathLike | None = None,
+    limit: int = 0,
+    relative_path: bool = False,
+    transforms: Transform | None = None,
+) -> list[dict]:
+    """
+    Utility to pre-process and create dataset list for Deepgrow training over on existing one.
+    The input data list is normally a list of images and labels (3D volume) that needs pre-processing
+    for Deepgrow training pipeline.
+
+    Args:
+        datalist: A list of data dictionary. Each entry should at least contain 'image_key': <image filename>.
+            For example, typical input data can be a list of dictionaries::
+
+                [{'image': <image filename>, 'label': <label filename>}]
+
+        output_dir: target directory to store the training data for Deepgrow Training
+        pixdim: output voxel spacing.
+        dimension: dimension for Deepgrow training.  It can be 2 or 3.
+        image_key: image key in input datalist. Defaults to 'image'.
+        label_key: label key in input datalist. Defaults to 'label'.
+        base_dir: base directory in case related path is used for the keys in datalist.  Defaults to None.
+        limit: limit number of inputs for pre-processing.  Defaults to 0 (no limit).
+        relative_path: output keys values should be based on relative path.  Defaults to False.
+        transforms: explicit transforms to execute operations on input data.
+
+    Raises:
+        ValueError: When ``dimension`` is not one of [2, 3]
+        ValueError: When ``datalist`` is Empty
+
+    Returns:
+        A new datalist that contains path to the images/labels after pre-processing.
+
+    Example::
+
+        datalist = create_dataset(
+            datalist=[{'image': 'img1.nii', 'label': 'label1.nii'}],
+            base_dir=None,
+            output_dir=output_2d,
+            dimension=2,
+            image_key='image',
+            label_key='label',
+            pixdim=(1.0, 1.0),
+            limit=0,
+            relative_path=True
+        )
+
+        print(datalist[0]["image"], datalist[0]["label"])
+    """
+
+    if dimension not in [2, 3]:
+        raise ValueError("Dimension can be only 2 or 3 as Deepgrow supports only 2D/3D Training")
+
+    if not len(datalist):
+        raise ValueError("Input datalist is empty")
+
+    transforms = _default_transforms(image_key, label_key, pixdim) if transforms is None else transforms
+    new_datalist = []
+    for idx, item in enumerate(datalist):
+        if limit and idx >= limit:
+            break
+
+        image = item[image_key]
+        label = item.get(label_key, None)
+        if base_dir:
+            image = os.path.join(base_dir, image)
+            label = os.path.join(base_dir, label) if label else None
+
+        image = os.path.abspath(image)
+        label = os.path.abspath(label) if label else None
+
+        logging.info(f"Image: {image}; Label: {label if label else None}")
+        data = transforms({image_key: image, label_key: label})
+
+        vol_image = data[image_key]
+        vol_label = data.get(label_key)
+        logging.info(f"Image (transform): {vol_image.shape}; Label: {None if vol_label is None else vol_label.shape}")
+
+        vol_image = np.moveaxis(vol_image, -1, 0)
+        if vol_label is not None:
+            vol_label = np.moveaxis(vol_label, -1, 0)
+        logging.info(f"Image (final): {vol_image.shape}; Label: {None if vol_label is None else vol_label.shape}")
+
+        if dimension == 2:
+            data = _save_data_2d(
+                vol_idx=idx,
+                vol_image=vol_image,
+                vol_label=vol_label,
+                dataset_dir=output_dir,
+                relative_path=relative_path,
+            )
+        else:
+            data = _save_data_3d(
+                vol_idx=idx,
+                vol_image=vol_image,
+                vol_label=vol_label,
+                dataset_dir=output_dir,
+                relative_path=relative_path,
+            )
+        new_datalist.extend(data)
+    return new_datalist
+
+
+def _default_transforms(image_key, label_key, pixdim):
+    keys = [image_key] if label_key is None else [image_key, label_key]
+    mode = [GridSampleMode.BILINEAR, GridSampleMode.NEAREST] if len(keys) == 2 else [GridSampleMode.BILINEAR]
+    return Compose(
+        [
+            LoadImaged(keys=keys),
+            EnsureChannelFirstd(keys=keys),
+            Orientationd(keys=keys, axcodes="RAS"),
+            Spacingd(keys=keys, pixdim=pixdim, mode=mode),
+            SqueezeDimd(keys=keys),
+        ]
+    )
+
+
+def _save_data_2d(vol_idx, vol_image, vol_label, dataset_dir, relative_path):
+    data_list: list[dict[str, str | int]] = []
+
+    image_count = 0
+    label_count = 0
+    unique_labels_count = 0
+    for sid in range(vol_image.shape[0]):
+        image = vol_image[sid, ...]
+        label = vol_label[sid, ...] if vol_label is not None else None
+
+        if vol_label is not None and np.sum(label) == 0:
+            continue
+
+        image_file_prefix = f"vol_idx_{vol_idx:0>4d}_slice_{sid:0>3d}"
+        image_file = os.path.join(dataset_dir, "images", image_file_prefix)
+        image_file += ".npy"
+
+        os.makedirs(os.path.join(dataset_dir, "images"), exist_ok=True)
+        np.save(image_file, image)
+        image_count += 1
+
+        # Test Data
+        if vol_label is None:
+            data_list.append(
+                {"image": image_file.replace(dataset_dir + os.pathsep, "") if relative_path else image_file}
+            )
+            continue
+
+        # For all Labels
+        unique_labels = np.unique(label.flatten())
+        unique_labels = unique_labels[unique_labels != 0]
+        unique_labels_count = max(unique_labels_count, len(unique_labels))
+
+        for idx in unique_labels:
+            label_file_prefix = f"{image_file_prefix}_region_{int(idx):0>2d}"
+            label_file = os.path.join(dataset_dir, "labels", label_file_prefix)
+            label_file += ".npy"
+
+            os.makedirs(os.path.join(dataset_dir, "labels"), exist_ok=True)
+            curr_label = (label == idx).astype(np.float32)
+            np.save(label_file, curr_label)
+
+            label_count += 1
+            data_list.append(
+                {
+                    "image": image_file.replace(dataset_dir + os.pathsep, "") if relative_path else image_file,
+                    "label": label_file.replace(dataset_dir + os.pathsep, "") if relative_path else label_file,
+                    "region": int(idx),
+                }
+            )
+
+    if unique_labels_count >= 20:
+        logging.warning(f"Unique labels {unique_labels_count} exceeds 20. Please check if this is correct.")
+
+    logging.info(
+        "{} => Image Shape: {} => {}; Label Shape: {} => {}; Unique Labels: {}".format(
+            vol_idx,
+            vol_image.shape,
+            image_count,
+            vol_label.shape if vol_label is not None else None,
+            label_count,
+            unique_labels_count,
+        )
+    )
+    return data_list
+
+
+def _save_data_3d(vol_idx, vol_image, vol_label, dataset_dir, relative_path):
+    data_list: list[dict[str, str | int]] = []
+
+    image_count = 0
+    label_count = 0
+    unique_labels_count = 0
+
+    image_file_prefix = f"vol_idx_{vol_idx:0>4d}"
+    image_file = os.path.join(dataset_dir, "images", image_file_prefix)
+    image_file += ".npy"
+
+    os.makedirs(os.path.join(dataset_dir, "images"), exist_ok=True)
+    np.save(image_file, vol_image)
+    image_count += 1
+
+    # Test Data
+    if vol_label is None:
+        data_list.append({"image": image_file.replace(dataset_dir + os.pathsep, "") if relative_path else image_file})
+    else:
+        # For all Labels
+        unique_labels = np.unique(vol_label.flatten())
+        unique_labels = unique_labels[unique_labels != 0]
+        unique_labels_count = max(unique_labels_count, len(unique_labels))
+
+        for idx in unique_labels:
+            label_file_prefix = f"{image_file_prefix}_region_{int(idx):0>2d}"
+            label_file = os.path.join(dataset_dir, "labels", label_file_prefix)
+            label_file += ".npy"
+
+            curr_label = (vol_label == idx).astype(np.float32)
+            os.makedirs(os.path.join(dataset_dir, "labels"), exist_ok=True)
+            np.save(label_file, curr_label)
+
+            label_count += 1
+            data_list.append(
+                {
+                    "image": image_file.replace(dataset_dir + os.pathsep, "") if relative_path else image_file,
+                    "label": label_file.replace(dataset_dir + os.pathsep, "") if relative_path else label_file,
+                    "region": int(idx),
+                }
+            )
+
+    if unique_labels_count >= 20:
+        logging.warning(f"Unique labels {unique_labels_count} exceeds 20. Please check if this is correct.")
+
+    logging.info(
+        "{} => Image Shape: {} => {}; Label Shape: {} => {}; Unique Labels: {}".format(
+            vol_idx,
+            vol_image.shape,
+            image_count,
+            vol_label.shape if vol_label is not None else None,
+            label_count,
+            unique_labels_count,
+        )
+    )
+    return data_list

source_code/SegMamba/monai/apps/deepgrow/interaction.py

@@ -0,0 +1,90 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import torch
+
+from monai.data import decollate_batch, list_data_collate
+from monai.engines import SupervisedEvaluator, SupervisedTrainer
+from monai.engines.utils import IterationEvents
+from monai.transforms import Compose
+from monai.utils.enums import CommonKeys
+
+
+class Interaction:
+    """
+    Ignite process_function used to introduce interactions (simulation of clicks) for Deepgrow Training/Evaluation.
+    For more details please refer to: https://pytorch.org/ignite/generated/ignite.engine.engine.Engine.html.
+    This implementation is based on:
+
+        Sakinis et al., Interactive segmentation of medical images through
+        fully convolutional neural networks. (2019) https://arxiv.org/abs/1903.08205
+
+    Args:
+        transforms: execute additional transformation during every iteration (before train).
+            Typically, several Tensor based transforms composed by `Compose`.
+        max_interactions: maximum number of interactions per iteration
+        train: training or evaluation
+        key_probability: field name to fill probability for every interaction
+    """
+
+    def __init__(
+        self,
+        transforms: Sequence[Callable] | Callable,
+        max_interactions: int,
+        train: bool,
+        key_probability: str = "probability",
+    ) -> None:
+        if not isinstance(transforms, Compose):
+            transforms = Compose(transforms)
+
+        self.transforms: Compose = transforms
+        self.max_interactions = max_interactions
+        self.train = train
+        self.key_probability = key_probability
+
+    def __call__(self, engine: SupervisedTrainer | SupervisedEvaluator, batchdata: dict[str, torch.Tensor]) -> dict:
+        if batchdata is None:
+            raise ValueError("Must provide batch data for current iteration.")
+
+        for j in range(self.max_interactions):
+            inputs, _ = engine.prepare_batch(batchdata)
+            inputs = inputs.to(engine.state.device)
+
+            engine.fire_event(IterationEvents.INNER_ITERATION_STARTED)
+
+            engine.network.eval()
+            with torch.no_grad():
+                if engine.amp:
+                    with torch.cuda.amp.autocast():
+                        predictions = engine.inferer(inputs, engine.network)
+                else:
+                    predictions = engine.inferer(inputs, engine.network)
+
+            engine.fire_event(IterationEvents.INNER_ITERATION_COMPLETED)
+
+            batchdata.update({CommonKeys.PRED: predictions})
+
+            # decollate batch data to execute click transforms
+            batchdata_list = decollate_batch(batchdata, detach=True)
+            for i in range(len(batchdata_list)):
+                batchdata_list[i][self.key_probability] = (
+                    (1.0 - ((1.0 / self.max_interactions) * j)) if self.train else 1.0
+                )
+                batchdata_list[i] = self.transforms(batchdata_list[i])
+
+            # collate list into a batch for next round interaction
+            batchdata = list_data_collate(batchdata_list)
+
+        return engine._iteration(engine, batchdata)  # type: ignore[arg-type]

source_code/SegMamba/monai/apps/deepgrow/transforms.py

@@ -0,0 +1,950 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Hashable, Iterable, Sequence
+from typing import Any
+
+import numpy as np
+import torch
+
+from monai.config import IndexSelection, KeysCollection, NdarrayOrTensor
+from monai.networks.layers import GaussianFilter
+from monai.transforms import Resize, SpatialCrop
+from monai.transforms.transform import MapTransform, Randomizable, Transform
+from monai.transforms.utils import generate_spatial_bounding_box, is_positive
+from monai.utils import InterpolateMode, ensure_tuple, ensure_tuple_rep, min_version, optional_import
+from monai.utils.enums import PostFix
+
+measure, _ = optional_import("skimage.measure", "0.14.2", min_version)
+distance_transform_cdt, _ = optional_import("scipy.ndimage.morphology", name="distance_transform_cdt")
+
+DEFAULT_POST_FIX = PostFix.meta()
+
+
+# Transforms to support Training for Deepgrow models
+class FindAllValidSlicesd(Transform):
+    """
+    Find/List all valid slices in the label.
+    Label is assumed to be a 4D Volume with shape CDHW, where C=1.
+
+    Args:
+        label: key to the label source.
+        sids: key to store slices indices having valid label map.
+    """
+
+    def __init__(self, label: str = "label", sids: str = "sids"):
+        self.label = label
+        self.sids = sids
+
+    def _apply(self, label):
+        sids = []
+        for sid in range(label.shape[1]):  # Assume channel is first
+            if np.sum(label[0][sid]) != 0:
+                sids.append(sid)
+        return np.asarray(sids)
+
+    def __call__(self, data: Any) -> dict:
+        d: dict = dict(data)
+        label = d[self.label].numpy() if isinstance(data[self.label], torch.Tensor) else data[self.label]
+        if label.shape[0] != 1:
+            raise ValueError(f"Only supports single channel labels, got label shape {label.shape}!")
+
+        if len(label.shape) != 4:  # only for 3D
+            raise ValueError(f"Only supports label with shape CDHW, got label shape {label.shape}!")
+
+        sids = self._apply(label)
+        if sids is not None and len(sids):
+            d[self.sids] = sids
+        return d
+
+
+class AddInitialSeedPointd(Randomizable, Transform):
+    """
+    Add random guidance as initial seed point for a given label.
+
+    Note that the label is of size (C, D, H, W) or (C, H, W)
+
+    The guidance is of size (2, N, # of dims) where N is number of guidance added.
+    # of dims = 4 when C, D, H, W; # of dims = 3 when (C, H, W)
+
+    Args:
+        label: label source.
+        guidance: key to store guidance.
+        sids: key that represents list of valid slice indices for the given label.
+        sid: key that represents the slice to add initial seed point.  If not present, random sid will be chosen.
+        connected_regions: maximum connected regions to use for adding initial points.
+    """
+
+    def __init__(
+        self,
+        label: str = "label",
+        guidance: str = "guidance",
+        sids: str = "sids",
+        sid: str = "sid",
+        connected_regions: int = 5,
+    ):
+        self.label = label
+        self.sids_key = sids
+        self.sid_key = sid
+        self.sid = None
+        self.guidance = guidance
+        self.connected_regions = connected_regions
+
+    def randomize(self, data):
+        sid = data.get(self.sid_key, None)
+        sids = data.get(self.sids_key, None)
+        if sids is not None:
+            if sid is None or sid not in sids:
+                sid = self.R.choice(sids, replace=False)
+        else:
+            sid = None
+        self.sid = sid
+
+    def _apply(self, label, sid):
+        dimensions = 3 if len(label.shape) > 3 else 2
+        default_guidance = [-1] * (dimensions + 1)
+
+        dims = dimensions
+        if sid is not None and dimensions == 3:
+            dims = 2
+            label = label[0][sid][np.newaxis]  # Assume channel is first
+
+        label = (label > 0.5).astype(np.float32)
+        blobs_labels = measure.label(label.astype(int), background=0) if dims == 2 else label
+        if np.max(blobs_labels) <= 0:
+            raise AssertionError("Not a valid Label")
+
+        pos_guidance = []
+        for ridx in range(1, 2 if dims == 3 else self.connected_regions + 1):
+            if dims == 2:
+                label = (blobs_labels == ridx).astype(np.float32)
+                if np.sum(label) == 0:
+                    pos_guidance.append(default_guidance)
+                    continue
+
+            distance = distance_transform_cdt(label).flatten()
+            probability = np.exp(distance) - 1.0
+
+            idx = np.where(label.flatten() > 0)[0]
+            seed = self.R.choice(idx, size=1, p=probability[idx] / np.sum(probability[idx]))
+            dst = distance[seed]
+
+            g = np.asarray(np.unravel_index(seed, label.shape)).transpose().tolist()[0]
+            g[0] = dst[0]  # for debug
+            if dimensions == 2 or dims == 3:
+                pos_guidance.append(g)
+            else:
+                pos_guidance.append([g[0], sid, g[-2], g[-1]])
+
+        return np.asarray([pos_guidance, [default_guidance] * len(pos_guidance)])
+
+    def __call__(self, data):
+        d = dict(data)
+        self.randomize(data)
+        d[self.guidance] = json.dumps(self._apply(d[self.label], self.sid).astype(int, copy=False).tolist())
+        return d
+
+
+class AddGuidanceSignald(Transform):
+    """
+    Add Guidance signal for input image.
+
+    Based on the "guidance" points, apply gaussian to them and add them as new channel for input image.
+
+    Args:
+        image: key to the image source.
+        guidance: key to store guidance.
+        sigma: standard deviation for Gaussian kernel.
+        number_intensity_ch: channel index.
+
+    """
+
+    def __init__(self, image: str = "image", guidance: str = "guidance", sigma: int = 2, number_intensity_ch: int = 1):
+        self.image = image
+        self.guidance = guidance
+        self.sigma = sigma
+        self.number_intensity_ch = number_intensity_ch
+
+    def _get_signal(self, image, guidance):
+        dimensions = 3 if len(image.shape) > 3 else 2
+        guidance = guidance.tolist() if isinstance(guidance, np.ndarray) else guidance
+        guidance = json.loads(guidance) if isinstance(guidance, str) else guidance
+        if dimensions == 3:
+            signal = np.zeros((len(guidance), image.shape[-3], image.shape[-2], image.shape[-1]), dtype=np.float32)
+        else:
+            signal = np.zeros((len(guidance), image.shape[-2], image.shape[-1]), dtype=np.float32)
+
+        sshape = signal.shape
+        for i, g_i in enumerate(guidance):
+            for point in g_i:
+                if np.any(np.asarray(point) < 0):
+                    continue
+
+                if dimensions == 3:
+                    p1 = max(0, min(int(point[-3]), sshape[-3] - 1))
+                    p2 = max(0, min(int(point[-2]), sshape[-2] - 1))
+                    p3 = max(0, min(int(point[-1]), sshape[-1] - 1))
+                    signal[i, p1, p2, p3] = 1.0
+                else:
+                    p1 = max(0, min(int(point[-2]), sshape[-2] - 1))
+                    p2 = max(0, min(int(point[-1]), sshape[-1] - 1))
+                    signal[i, p1, p2] = 1.0
+
+            if np.max(signal[i]) > 0:
+                signal_tensor = torch.tensor(signal[i])
+                pt_gaussian = GaussianFilter(len(signal_tensor.shape), sigma=self.sigma)
+                signal_tensor = pt_gaussian(signal_tensor.unsqueeze(0).unsqueeze(0))
+                signal_tensor = signal_tensor.squeeze(0).squeeze(0)
+                signal[i] = signal_tensor.detach().cpu().numpy()
+                signal[i] = (signal[i] - np.min(signal[i])) / (np.max(signal[i]) - np.min(signal[i]))
+        return signal
+
+    def _apply(self, image, guidance):
+        signal = self._get_signal(image, guidance)
+
+        if isinstance(image, torch.Tensor):
+            image = image.detach().cpu().numpy()
+
+        image = image[0 : 0 + self.number_intensity_ch, ...]
+        return np.concatenate([image, signal], axis=0)
+
+    def __call__(self, data):
+        d = dict(data)
+        image = d[self.image]
+        guidance = d[self.guidance]
+
+        d[self.image] = self._apply(image, guidance)
+        return d
+
+
+class FindDiscrepancyRegionsd(Transform):
+    """
+    Find discrepancy between prediction and actual during click interactions during training.
+
+    Args:
+        label: key to label source.
+        pred: key to prediction source.
+        discrepancy: key to store discrepancies found between label and prediction.
+
+    """
+
+    def __init__(self, label: str = "label", pred: str = "pred", discrepancy: str = "discrepancy"):
+        self.label = label
+        self.pred = pred
+        self.discrepancy = discrepancy
+
+    @staticmethod
+    def disparity(label, pred):
+        label = (label > 0.5).astype(np.float32)
+        pred = (pred > 0.5).astype(np.float32)
+        disparity = label - pred
+
+        pos_disparity = (disparity > 0).astype(np.float32)
+        neg_disparity = (disparity < 0).astype(np.float32)
+        return [pos_disparity, neg_disparity]
+
+    def _apply(self, label, pred):
+        return self.disparity(label, pred)
+
+    def __call__(self, data):
+        d = dict(data)
+        label = d[self.label]
+        pred = d[self.pred]
+
+        d[self.discrepancy] = self._apply(label, pred)
+        return d
+
+
+class AddRandomGuidanced(Randomizable, Transform):
+    """
+    Add random guidance based on discrepancies that were found between label and prediction.
+    input shape is as below:
+    Guidance is of shape (2, N, # of dim)
+    Discrepancy is of shape (2, C, D, H, W) or (2, C, H, W)
+    Probability is of shape (1)
+
+    Args:
+        guidance: key to guidance source.
+        discrepancy: key that represents discrepancies found between label and prediction.
+        probability: key that represents click/interaction probability.
+
+    """
+
+    def __init__(self, guidance: str = "guidance", discrepancy: str = "discrepancy", probability: str = "probability"):
+        self.guidance = guidance
+        self.discrepancy = discrepancy
+        self.probability = probability
+        self._will_interact = None
+
+    def randomize(self, data=None):
+        probability = data[self.probability]
+        self._will_interact = self.R.choice([True, False], p=[probability, 1.0 - probability])
+
+    def find_guidance(self, discrepancy):
+        distance = distance_transform_cdt(discrepancy).flatten()
+        probability = np.exp(distance) - 1.0
+        idx = np.where(discrepancy.flatten() > 0)[0]
+
+        if np.sum(discrepancy > 0) > 0:
+            seed = self.R.choice(idx, size=1, p=probability[idx] / np.sum(probability[idx]))
+            dst = distance[seed]
+
+            g = np.asarray(np.unravel_index(seed, discrepancy.shape)).transpose().tolist()[0]
+            g[0] = dst[0]
+            return g
+        return None
+
+    def add_guidance(self, discrepancy, will_interact):
+        if not will_interact:
+            return None, None
+
+        pos_discr = discrepancy[0]
+        neg_discr = discrepancy[1]
+
+        can_be_positive = np.sum(pos_discr) > 0
+        can_be_negative = np.sum(neg_discr) > 0
+        correct_pos = np.sum(pos_discr) >= np.sum(neg_discr)
+
+        if correct_pos and can_be_positive:
+            return self.find_guidance(pos_discr), None
+
+        if not correct_pos and can_be_negative:
+            return None, self.find_guidance(neg_discr)
+        return None, None
+
+    def _apply(self, guidance, discrepancy):
+        guidance = guidance.tolist() if isinstance(guidance, np.ndarray) else guidance
+        guidance = json.loads(guidance) if isinstance(guidance, str) else guidance
+        pos, neg = self.add_guidance(discrepancy, self._will_interact)
+        if pos:
+            guidance[0].append(pos)
+            guidance[1].append([-1] * len(pos))
+        if neg:
+            guidance[0].append([-1] * len(neg))
+            guidance[1].append(neg)
+
+        return json.dumps(np.asarray(guidance, dtype=int).tolist())
+
+    def __call__(self, data):
+        d = dict(data)
+        guidance = d[self.guidance]
+        discrepancy = d[self.discrepancy]
+
+        self.randomize(data)
+        d[self.guidance] = self._apply(guidance, discrepancy)
+        return d
+
+
+class SpatialCropForegroundd(MapTransform):
+    """
+    Crop only the foreground object of the expected images.
+
+    Difference VS :py:class:`monai.transforms.CropForegroundd`:
+
+      1. If the bounding box is smaller than spatial size in all dimensions then this transform will crop the
+         object using box's center and spatial_size.
+
+      2. This transform will set "start_coord_key", "end_coord_key", "original_shape_key" and "cropped_shape_key"
+         in data[{key}_{meta_key_postfix}]
+
+    The typical usage is to help training and evaluation if the valid part is small in the whole medical image.
+    The valid part can be determined by any field in the data with `source_key`, for example:
+
+    - Select values > 0 in image field as the foreground and crop on all fields specified by `keys`.
+    - Select label = 3 in label field as the foreground to crop on all fields specified by `keys`.
+    - Select label > 0 in the third channel of a One-Hot label field as the foreground to crop all `keys` fields.
+
+    Users can define arbitrary function to select expected foreground from the whole source image or specified
+    channels. And it can also add margin to every dim of the bounding box of foreground object.
+
+    Args:
+        keys: keys of the corresponding items to be transformed.
+            See also: :py:class:`monai.transforms.MapTransform`
+        source_key: data source to generate the bounding box of foreground, can be image or label, etc.
+        spatial_size: minimal spatial size of the image patch e.g. [128, 128, 128] to fit in.
+        select_fn: function to select expected foreground, default is to select values > 0.
+        channel_indices: if defined, select foreground only on the specified channels
+            of image. if None, select foreground on the whole image.
+        margin: add margin value to spatial dims of the bounding box, if only 1 value provided, use it for all dims.
+        allow_smaller: when computing box size with `margin`, whether allow the image size to be smaller
+            than box size, default to `True`. if the margined size is bigger than image size, will pad with
+            specified `mode`.
+        meta_keys: explicitly indicate the key of the corresponding metadata dictionary.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            it can be a sequence of string, map to the `keys`.
+            if None, will try to construct meta_keys by `key_{meta_key_postfix}`.
+        meta_key_postfix: if meta_keys is None, use `{key}_{meta_key_postfix}` to fetch/store the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        start_coord_key: key to record the start coordinate of spatial bounding box for foreground.
+        end_coord_key: key to record the end coordinate of spatial bounding box for foreground.
+        original_shape_key: key to record original shape for foreground.
+        cropped_shape_key: key to record cropped shape for foreground.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        source_key: str,
+        spatial_size: Sequence[int] | np.ndarray,
+        select_fn: Callable = is_positive,
+        channel_indices: IndexSelection | None = None,
+        margin: int = 0,
+        allow_smaller: bool = True,
+        meta_keys: KeysCollection | None = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        start_coord_key: str = "foreground_start_coord",
+        end_coord_key: str = "foreground_end_coord",
+        original_shape_key: str = "foreground_original_shape",
+        cropped_shape_key: str = "foreground_cropped_shape",
+        allow_missing_keys: bool = False,
+    ) -> None:
+        super().__init__(keys, allow_missing_keys)
+
+        self.source_key = source_key
+        self.spatial_size = list(spatial_size)
+        self.select_fn = select_fn
+        self.channel_indices = channel_indices
+        self.margin = margin
+        self.allow_smaller = allow_smaller
+        self.meta_keys = ensure_tuple_rep(None, len(self.keys)) if meta_keys is None else ensure_tuple(meta_keys)
+        if len(self.keys) != len(self.meta_keys):
+            raise ValueError("meta_keys should have the same length as keys.")
+        self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys))
+        self.start_coord_key = start_coord_key
+        self.end_coord_key = end_coord_key
+        self.original_shape_key = original_shape_key
+        self.cropped_shape_key = cropped_shape_key
+
+    def __call__(self, data):
+        d = dict(data)
+        box_start, box_end = generate_spatial_bounding_box(
+            d[self.source_key], self.select_fn, self.channel_indices, self.margin, self.allow_smaller
+        )
+
+        center = list(np.mean([box_start, box_end], axis=0).astype(int, copy=False))
+        current_size = list(np.subtract(box_end, box_start).astype(int, copy=False))
+
+        if np.all(np.less(current_size, self.spatial_size)):
+            cropper = SpatialCrop(roi_center=center, roi_size=self.spatial_size)
+            box_start = np.array([s.start for s in cropper.slices])
+            box_end = np.array([s.stop for s in cropper.slices])
+        else:
+            cropper = SpatialCrop(roi_start=box_start, roi_end=box_end)
+
+        for key, meta_key, meta_key_postfix in self.key_iterator(d, self.meta_keys, self.meta_key_postfix):
+            meta_key = meta_key or f"{key}_{meta_key_postfix}"
+            d[meta_key][self.start_coord_key] = box_start
+            d[meta_key][self.end_coord_key] = box_end
+            d[meta_key][self.original_shape_key] = d[key].shape
+
+            image = cropper(d[key])
+            d[meta_key][self.cropped_shape_key] = image.shape
+            d[key] = image
+        return d
+
+
+# Transforms to support Inference for Deepgrow models
+class AddGuidanceFromPointsd(Transform):
+    """
+    Add guidance based on user clicks.
+
+    We assume the input is loaded by LoadImaged and has the shape of (H, W, D) originally.
+    Clicks always specify the coordinates in (H, W, D)
+
+    If depth_first is True:
+
+        Input is now of shape (D, H, W), will return guidance that specifies the coordinates in (D, H, W)
+
+    else:
+
+        Input is now of shape (H, W, D), will return guidance that specifies the coordinates in (H, W, D)
+
+    Args:
+        ref_image: key to reference image to fetch current and original image details.
+        guidance: output key to store guidance.
+        foreground: key that represents user foreground (+ve) clicks.
+        background: key that represents user background (-ve) clicks.
+        axis: axis that represents slices in 3D volume. (axis to Depth)
+        depth_first: if depth (slices) is positioned at first dimension.
+        spatial_dims: dimensions based on model used for deepgrow (2D vs 3D).
+        slice_key: key that represents applicable slice to add guidance.
+        meta_keys: explicitly indicate the key of the metadata dictionary of `ref_image`.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            if None, will try to construct meta_keys by `{ref_image}_{meta_key_postfix}`.
+        meta_key_postfix: if meta_key is None, use `{ref_image}_{meta_key_postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+
+    """
+
+    def __init__(
+        self,
+        ref_image: str,
+        guidance: str = "guidance",
+        foreground: str = "foreground",
+        background: str = "background",
+        axis: int = 0,
+        depth_first: bool = True,
+        spatial_dims: int = 2,
+        slice_key: str = "slice",
+        meta_keys: str | None = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+    ):
+        self.ref_image = ref_image
+        self.guidance = guidance
+        self.foreground = foreground
+        self.background = background
+        self.axis = axis
+        self.depth_first = depth_first
+        self.dimensions = spatial_dims
+        self.slice = slice_key
+        self.meta_keys = meta_keys
+        self.meta_key_postfix = meta_key_postfix
+
+    def _apply(self, pos_clicks, neg_clicks, factor, slice_num):
+        pos = neg = []
+
+        if self.dimensions == 2:
+            points: list = list(pos_clicks)
+            points.extend(neg_clicks)
+
+            slices = list(np.unique(np.array(points)[:, self.axis]))
+            slice_idx = slices[0] if slice_num is None else next(x for x in slices if x == slice_num)
+
+            if len(pos_clicks):
+                pos_clicks = np.array(pos_clicks)
+                pos = (pos_clicks[np.where(pos_clicks[:, self.axis] == slice_idx)] * factor)[:, 1:].astype(int).tolist()
+            if len(neg_clicks):
+                neg_clicks = np.array(neg_clicks)
+                neg = (neg_clicks[np.where(neg_clicks[:, self.axis] == slice_idx)] * factor)[:, 1:].astype(int).tolist()
+
+            guidance = [pos, neg, slice_idx]
+        else:
+            if len(pos_clicks):
+                pos = np.multiply(pos_clicks, factor).astype(int, copy=False).tolist()
+            if len(neg_clicks):
+                neg = np.multiply(neg_clicks, factor).astype(int, copy=False).tolist()
+            guidance = [pos, neg]
+        return guidance
+
+    def __call__(self, data):
+        d = dict(data)
+        meta_dict_key = self.meta_keys or f"{self.ref_image}_{self.meta_key_postfix}"
+        if meta_dict_key not in d:
+            raise RuntimeError(f"Missing meta_dict {meta_dict_key} in data!")
+        if "spatial_shape" not in d[meta_dict_key]:
+            raise RuntimeError('Missing "spatial_shape" in meta_dict!')
+        original_shape = d[meta_dict_key]["spatial_shape"]
+        current_shape = list(d[self.ref_image].shape)
+
+        if self.depth_first:
+            if self.axis != 0:
+                raise RuntimeError("Depth first means the depth axis should be 0.")
+            # in here we assume the depth dimension was in the last dimension of "original_shape"
+            original_shape = np.roll(original_shape, 1)
+
+        factor = np.array(current_shape) / original_shape
+
+        fg_bg_clicks = []
+        for key in [self.foreground, self.background]:
+            clicks = d[key]
+            clicks = list(np.array(clicks, dtype=int))
+            if self.depth_first:
+                for i in range(len(clicks)):
+                    clicks[i] = list(np.roll(clicks[i], 1))
+            fg_bg_clicks.append(clicks)
+        d[self.guidance] = self._apply(fg_bg_clicks[0], fg_bg_clicks[1], factor, d.get(self.slice))
+        return d
+
+
+class SpatialCropGuidanced(MapTransform):
+    """
+    Crop image based on guidance with minimal spatial size.
+
+    - If the bounding box is smaller than spatial size in all dimensions then this transform will crop the
+      object using box's center and spatial_size.
+
+    - This transform will set "start_coord_key", "end_coord_key", "original_shape_key" and "cropped_shape_key"
+      in data[{key}_{meta_key_postfix}]
+
+    Input data is of shape (C, spatial_1, [spatial_2, ...])
+
+    Args:
+        keys: keys of the corresponding items to be transformed.
+        guidance: key to the guidance. It is used to generate the bounding box of foreground
+        spatial_size: minimal spatial size of the image patch e.g. [128, 128, 128] to fit in.
+        margin: add margin value to spatial dims of the bounding box, if only 1 value provided, use it for all dims.
+        meta_keys: explicitly indicate the key of the corresponding metadata dictionary.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            it can be a sequence of string, map to the `keys`.
+            if None, will try to construct meta_keys by `key_{meta_key_postfix}`.
+        meta_key_postfix: if meta_keys is None, use `key_{postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        start_coord_key: key to record the start coordinate of spatial bounding box for foreground.
+        end_coord_key: key to record the end coordinate of spatial bounding box for foreground.
+        original_shape_key: key to record original shape for foreground.
+        cropped_shape_key: key to record cropped shape for foreground.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        guidance: str,
+        spatial_size: Iterable[int],
+        margin: int = 20,
+        meta_keys: KeysCollection | None = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        start_coord_key: str = "foreground_start_coord",
+        end_coord_key: str = "foreground_end_coord",
+        original_shape_key: str = "foreground_original_shape",
+        cropped_shape_key: str = "foreground_cropped_shape",
+        allow_missing_keys: bool = False,
+    ) -> None:
+        super().__init__(keys, allow_missing_keys)
+
+        self.guidance = guidance
+        self.spatial_size = list(spatial_size)
+        self.margin = margin
+        self.meta_keys = ensure_tuple_rep(None, len(self.keys)) if meta_keys is None else ensure_tuple(meta_keys)
+        if len(self.keys) != len(self.meta_keys):
+            raise ValueError("meta_keys should have the same length as keys.")
+        self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys))
+        self.start_coord_key = start_coord_key
+        self.end_coord_key = end_coord_key
+        self.original_shape_key = original_shape_key
+        self.cropped_shape_key = cropped_shape_key
+
+    def bounding_box(self, points, img_shape):
+        ndim = len(img_shape)
+        margin = ensure_tuple_rep(self.margin, ndim)
+        for m in margin:
+            if m < 0:
+                raise ValueError("margin value should not be negative number.")
+
+        box_start = [0] * ndim
+        box_end = [0] * ndim
+
+        for di in range(ndim):
+            dt = points[..., di]
+            min_d = max(min(dt - margin[di]), 0)
+            max_d = min(img_shape[di], max(dt + margin[di] + 1))
+            box_start[di], box_end[di] = min_d, max_d
+        return box_start, box_end
+
+    def __call__(self, data: Any) -> dict:
+        d: dict = dict(data)
+        first_key: Hashable = self.first_key(d)
+        if first_key == ():
+            return d
+
+        guidance = d[self.guidance]
+        original_spatial_shape = d[first_key].shape[1:]
+        box_start, box_end = self.bounding_box(np.array(guidance[0] + guidance[1]), original_spatial_shape)
+        center = list(np.mean([box_start, box_end], axis=0).astype(int, copy=False))
+        spatial_size = self.spatial_size
+
+        box_size = list(np.subtract(box_end, box_start).astype(int, copy=False))
+        spatial_size = spatial_size[-len(box_size) :]
+
+        if len(spatial_size) < len(box_size):
+            # If the data is in 3D and spatial_size is specified as 2D [256,256]
+            # Then we will get all slices in such case
+            diff = len(box_size) - len(spatial_size)
+            spatial_size = list(original_spatial_shape[1 : (1 + diff)]) + spatial_size
+
+        if np.all(np.less(box_size, spatial_size)):
+            if len(center) == 3:
+                # 3D Deepgrow: set center to be middle of the depth dimension (D)
+                center[0] = spatial_size[0] // 2
+            cropper = SpatialCrop(roi_center=center, roi_size=spatial_size)
+        else:
+            cropper = SpatialCrop(roi_start=box_start, roi_end=box_end)
+
+        # update bounding box in case it was corrected by the SpatialCrop constructor
+        box_start = np.array([s.start for s in cropper.slices])
+        box_end = np.array([s.stop for s in cropper.slices])
+        for key, meta_key, meta_key_postfix in self.key_iterator(d, self.meta_keys, self.meta_key_postfix):
+            if not np.array_equal(d[key].shape[1:], original_spatial_shape):
+                raise RuntimeError("All the image specified in keys should have same spatial shape")
+            meta_key = meta_key or f"{key}_{meta_key_postfix}"
+            d[meta_key][self.start_coord_key] = box_start
+            d[meta_key][self.end_coord_key] = box_end
+            d[meta_key][self.original_shape_key] = d[key].shape
+
+            image = cropper(d[key])
+            d[meta_key][self.cropped_shape_key] = image.shape
+            d[key] = image
+
+        pos_clicks, neg_clicks = guidance[0], guidance[1]
+        pos = np.subtract(pos_clicks, box_start).tolist() if len(pos_clicks) else []
+        neg = np.subtract(neg_clicks, box_start).tolist() if len(neg_clicks) else []
+
+        d[self.guidance] = [pos, neg]
+        return d
+
+
+class ResizeGuidanced(Transform):
+    """
+    Resize the guidance based on cropped vs resized image.
+
+    This transform assumes that the images have been cropped and resized. And the shape after cropped is store inside
+    the meta dict of ref image.
+
+    Args:
+        guidance: key to guidance
+        ref_image: key to reference image to fetch current and original image details
+        meta_keys: explicitly indicate the key of the metadata dictionary of `ref_image`.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            if None, will try to construct meta_keys by `{ref_image}_{meta_key_postfix}`.
+        meta_key_postfix: if meta_key is None, use `{ref_image}_{meta_key_postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        cropped_shape_key: key that records cropped shape for foreground.
+    """
+
+    def __init__(
+        self,
+        guidance: str,
+        ref_image: str,
+        meta_keys: str | None = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        cropped_shape_key: str = "foreground_cropped_shape",
+    ) -> None:
+        self.guidance = guidance
+        self.ref_image = ref_image
+        self.meta_keys = meta_keys
+        self.meta_key_postfix = meta_key_postfix
+        self.cropped_shape_key = cropped_shape_key
+
+    def __call__(self, data: Any) -> dict:
+        d = dict(data)
+        guidance = d[self.guidance]
+        meta_dict: dict = d[self.meta_keys or f"{self.ref_image}_{self.meta_key_postfix}"]
+        current_shape = d[self.ref_image].shape[1:]
+        cropped_shape = meta_dict[self.cropped_shape_key][1:]
+        factor = np.divide(current_shape, cropped_shape)
+
+        pos_clicks, neg_clicks = guidance[0], guidance[1]
+        pos = np.multiply(pos_clicks, factor).astype(int, copy=False).tolist() if len(pos_clicks) else []
+        neg = np.multiply(neg_clicks, factor).astype(int, copy=False).tolist() if len(neg_clicks) else []
+
+        d[self.guidance] = [pos, neg]
+        return d
+
+
+class RestoreLabeld(MapTransform):
+    """
+    Restores label based on the ref image.
+
+    The ref_image is assumed that it went through the following transforms:
+
+        1. Fetch2DSliced (If 2D)
+        2. Spacingd
+        3. SpatialCropGuidanced
+        4. Resized
+
+    And its shape is assumed to be (C, D, H, W)
+
+    This transform tries to undo these operation so that the result label can be overlapped with original volume.
+    It does the following operation:
+
+        1. Undo Resized
+        2. Undo SpatialCropGuidanced
+        3. Undo Spacingd
+        4. Undo Fetch2DSliced
+
+    The resulting label is of shape (D, H, W)
+
+    Args:
+        keys: keys of the corresponding items to be transformed.
+        ref_image: reference image to fetch current and original image details
+        slice_only: apply only to an applicable slice, in case of 2D model/prediction
+        mode: {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``,
+            ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}
+            One of the listed string values or a user supplied function for padding. Defaults to ``"constant"``.
+            See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
+        align_corners: Geometrically, we consider the pixels of the input as squares rather than points.
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html
+            It also can be a sequence of bool, each element corresponds to a key in ``keys``.
+        meta_keys: explicitly indicate the key of the corresponding metadata dictionary.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            it can be a sequence of string, map to the `keys`.
+            if None, will try to construct meta_keys by `key_{meta_key_postfix}`.
+        meta_key_postfix: if meta_key is None, use `key_{meta_key_postfix} to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        start_coord_key: key that records the start coordinate of spatial bounding box for foreground.
+        end_coord_key: key that records the end coordinate of spatial bounding box for foreground.
+        original_shape_key: key that records original shape for foreground.
+        cropped_shape_key: key that records cropped shape for foreground.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        ref_image: str,
+        slice_only: bool = False,
+        mode: Sequence[InterpolateMode | str] | InterpolateMode | str = InterpolateMode.NEAREST,
+        align_corners: Sequence[bool | None] | bool | None = None,
+        meta_keys: str | None = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        start_coord_key: str = "foreground_start_coord",
+        end_coord_key: str = "foreground_end_coord",
+        original_shape_key: str = "foreground_original_shape",
+        cropped_shape_key: str = "foreground_cropped_shape",
+        allow_missing_keys: bool = False,
+    ) -> None:
+        super().__init__(keys, allow_missing_keys)
+        self.ref_image = ref_image
+        self.slice_only = slice_only
+        self.mode = ensure_tuple_rep(mode, len(self.keys))
+        self.align_corners = ensure_tuple_rep(align_corners, len(self.keys))
+        self.meta_keys = ensure_tuple_rep(None, len(self.keys)) if meta_keys is None else ensure_tuple(meta_keys)
+        if len(self.keys) != len(self.meta_keys):
+            raise ValueError("meta_keys should have the same length as keys.")
+        self.meta_key_postfix = meta_key_postfix
+        self.start_coord_key = start_coord_key
+        self.end_coord_key = end_coord_key
+        self.original_shape_key = original_shape_key
+        self.cropped_shape_key = cropped_shape_key
+
+    def __call__(self, data: Any) -> dict:
+        d = dict(data)
+        meta_dict: dict = d[f"{self.ref_image}_{self.meta_key_postfix}"]
+
+        for key, mode, align_corners, meta_key in self.key_iterator(d, self.mode, self.align_corners, self.meta_keys):
+            image = d[key]
+
+            # Undo Resize
+            current_shape = image.shape
+            cropped_shape = meta_dict[self.cropped_shape_key]
+            if np.any(np.not_equal(current_shape, cropped_shape)):
+                resizer = Resize(spatial_size=cropped_shape[1:], mode=mode)
+                image = resizer(image, mode=mode, align_corners=align_corners)
+
+            # Undo Crop
+            original_shape = meta_dict[self.original_shape_key]
+            result = np.zeros(original_shape, dtype=np.float32)
+            box_start = meta_dict[self.start_coord_key]
+            box_end = meta_dict[self.end_coord_key]
+
+            spatial_dims = min(len(box_start), len(image.shape[1:]))
+            slices = tuple(
+                [slice(None)] + [slice(s, e) for s, e in zip(box_start[:spatial_dims], box_end[:spatial_dims])]
+            )
+            result[slices] = image
+
+            # Undo Spacing
+            current_size = result.shape[1:]
+            # change spatial_shape from HWD to DHW
+            spatial_shape = list(np.roll(meta_dict["spatial_shape"], 1))
+            spatial_size = spatial_shape[-len(current_size) :]
+
+            if np.any(np.not_equal(current_size, spatial_size)):
+                resizer = Resize(spatial_size=spatial_size, mode=mode)
+                result = resizer(result, mode=mode, align_corners=align_corners)  # type: ignore
+
+            # Undo Slicing
+            slice_idx = meta_dict.get("slice_idx")
+            final_result: NdarrayOrTensor
+            if slice_idx is None or self.slice_only:
+                final_result = result if len(result.shape) <= 3 else result[0]
+            else:
+                slice_idx = meta_dict["slice_idx"][0]
+                final_result = np.zeros(tuple(spatial_shape))
+                final_result[slice_idx] = result
+            d[key] = final_result
+
+            meta_key = meta_key or f"{key}_{self.meta_key_postfix}"
+            meta = d.get(meta_key)
+            if meta is None:
+                meta = dict()
+                d[meta_key] = meta
+            meta["slice_idx"] = slice_idx
+            meta["affine"] = meta_dict["original_affine"]
+        return d
+
+
+class Fetch2DSliced(MapTransform):
+    """
+    Fetch one slice in case of a 3D volume.
+
+    The volume only contains spatial coordinates.
+
+    Args:
+        keys: keys of the corresponding items to be transformed.
+        guidance: key that represents guidance.
+        axis: axis that represents slice in 3D volume.
+        meta_keys: explicitly indicate the key of the corresponding metadata dictionary.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            it can be a sequence of string, map to the `keys`.
+            if None, will try to construct meta_keys by `key_{meta_key_postfix}`.
+        meta_key_postfix: use `key_{meta_key_postfix}` to fetch the metadata according to the key data,
+            default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        guidance: str = "guidance",
+        axis: int = 0,
+        meta_keys: KeysCollection | None = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        allow_missing_keys: bool = False,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.guidance = guidance
+        self.axis = axis
+        self.meta_keys = ensure_tuple_rep(None, len(self.keys)) if meta_keys is None else ensure_tuple(meta_keys)
+        if len(self.keys) != len(self.meta_keys):
+            raise ValueError("meta_keys should have the same length as keys.")
+        self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys))
+
+    def _apply(self, image, guidance):
+        slice_idx = guidance[2]  # (pos, neg, slice_idx)
+        idx = []
+        for i, size_i in enumerate(image.shape):
+            idx.append(slice_idx) if i == self.axis else idx.append(slice(0, size_i))
+
+        return image[tuple(idx)], tuple(idx)
+
+    def __call__(self, data):
+        d = dict(data)
+        guidance = d[self.guidance]
+        if len(guidance) < 3:
+            raise RuntimeError("Guidance does not container slice_idx!")
+        for key, meta_key, meta_key_postfix in self.key_iterator(d, self.meta_keys, self.meta_key_postfix):
+            img_slice, idx = self._apply(d[key], guidance)
+            d[key] = img_slice
+            d[meta_key or f"{key}_{meta_key_postfix}"]["slice_idx"] = idx
+        return d

source_code/SegMamba/monai/apps/detection/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/detection/metrics/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/detection/metrics/coco.py

@@ -0,0 +1,548 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/evaluator/detection/coco.py
+# which has the following license...
+# https://github.com/MIC-DKFZ/nnDetection/blob/main/LICENSE
+#
+# Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#    http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/cocodataset/cocoapi
+# which has the following license...
+# https://github.com/cocodataset/cocoapi/blob/master/license.txt
+
+# Copyright (c) 2014, Piotr Dollar and Tsung-Yi Lin
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+"""
+This script is almost same with https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/evaluator/detection/coco.py
+The changes include 1) code reformatting, 2) docstrings.
+"""
+
+from __future__ import annotations
+
+import logging as logger
+import time
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+
+class COCOMetric:
+
+    def __init__(
+        self,
+        classes: Sequence[str],
+        iou_list: Sequence[float] = (0.1, 0.5, 0.75),
+        iou_range: Sequence[float] = (0.1, 0.5, 0.05),
+        max_detection: Sequence[int] = (1, 5, 100),
+        per_class: bool = True,
+        verbose: bool = True,
+    ):
+        """
+        Class to compute COCO metrics
+        Metrics computed includes,
+
+        - mAP over the IoU range specified by `iou_range` at last value of `max_detection`
+        - AP values at IoU thresholds specified by `iou_list` at last value of `max_detection`
+        - AR over max detections thresholds defined by `max_detection` (over iou range)
+
+        Args:
+            classes (Sequence[str]): name of each class (index needs to correspond to predicted class indices!)
+            iou_list (Sequence[float]): specific thresholds where ap is evaluated and saved
+            iou_range (Sequence[float]): (start, stop, step) for mAP iou thresholds
+            max_detection (Sequence[int]): maximum number of detections per image
+            verbose (bool): log time needed for evaluation
+
+        Example:
+
+            .. code-block:: python
+
+                from monai.data.box_utils import box_iou
+                from monai.apps.detection.metrics.coco import COCOMetric
+                from monai.apps.detection.metrics.matching import matching_batch
+                # 3D example outputs of one image from detector
+                val_outputs_all = [
+                        {"boxes": torch.tensor([[1,1,1,3,4,5]],dtype=torch.float16),
+                        "labels": torch.randint(3,(1,)),
+                        "scores": torch.randn((1,)).absolute()},
+                ]
+                val_targets_all = [
+                        {"boxes": torch.tensor([[1,1,1,2,6,4]],dtype=torch.float16),
+                        "labels": torch.randint(3,(1,))},
+                ]
+
+                coco_metric = COCOMetric(
+                    classes=['c0','c1','c2'], iou_list=[0.1], max_detection=[10]
+                )
+                results_metric = matching_batch(
+                    iou_fn=box_iou,
+                    iou_thresholds=coco_metric.iou_thresholds,
+                    pred_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_outputs_all],
+                    pred_classes=[val_data_i["labels"].numpy() for val_data_i in val_outputs_all],
+                    pred_scores=[val_data_i["scores"].numpy() for val_data_i in val_outputs_all],
+                    gt_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_targets_all],
+                    gt_classes=[val_data_i["labels"].numpy() for val_data_i in val_targets_all],
+                )
+                val_metric_dict = coco_metric(results_metric)
+                print(val_metric_dict)
+        """
+        self.verbose = verbose
+        self.classes = classes
+        self.per_class = per_class
+
+        iou_list_np = np.array(iou_list)
+        _iou_range = np.linspace(
+            iou_range[0], iou_range[1], int(np.round((iou_range[1] - iou_range[0]) / iou_range[2])) + 1, endpoint=True
+        )
+        self.iou_thresholds = np.union1d(iou_list_np, _iou_range)
+        self.iou_range = iou_range
+
+        # get indices of iou values of ious range and ious list for later evaluation
+        self.iou_list_idx = np.nonzero(iou_list_np[:, np.newaxis] == self.iou_thresholds[np.newaxis])[1]
+        self.iou_range_idx = np.nonzero(_iou_range[:, np.newaxis] == self.iou_thresholds[np.newaxis])[1]
+
+        if (
+            not (self.iou_thresholds[self.iou_list_idx] == iou_list_np).all()
+            or not (self.iou_thresholds[self.iou_range_idx] == _iou_range).all()
+        ):
+            raise ValueError(
+                "Require self.iou_thresholds[self.iou_list_idx] == iou_list_np and "
+                "self.iou_thresholds[self.iou_range_idx] == _iou_range."
+            )
+
+        self.recall_thresholds = np.linspace(0.0, 1.00, int(np.round((1.00 - 0.0) / 0.01)) + 1, endpoint=True)
+        self.max_detections = max_detection
+
+    def __call__(self, *args: Any, **kwargs: Any) -> tuple[dict[str, float], dict[str, np.ndarray] | None]:
+        """
+        Compute metric. See :func:`compute` for more information.
+
+        Args:
+            *args: positional arguments passed to :func:`compute`
+            **kwargs: keyword arguments passed to :func:`compute`
+
+        Returns:
+            dict[str, float]: dictionary with scalar values for evaluation
+            dict[str, np.ndarray]: dictionary with arrays, e.g. for visualization of graphs
+        """
+        return self.compute(*args, **kwargs)
+
+    def check_number_of_iou(self, *args: np.ndarray) -> None:
+        """
+        Check if shape of input in first dimension is consistent with expected IoU values
+        (assumes IoU dimension is the first dimension)
+
+        Args:
+            args: array like inputs with shape function
+        """
+        num_ious = len(self.get_iou_thresholds())
+        for arg in args:
+            if arg.shape[0] != num_ious:
+                raise ValueError(
+                    f"Require arg.shape[0] == len(self.get_iou_thresholds()). Got arg.shape[0]={arg.shape[0]}, "
+                    f"self.get_iou_thresholds()={self.get_iou_thresholds()}."
+                )
+
+    def get_iou_thresholds(self) -> Sequence[float]:
+        """
+        Return IoU thresholds needed for this metric in an numpy array
+
+        Returns:
+            Sequence[float]: IoU thresholds [M], M is the number of thresholds
+        """
+        return list(self.iou_thresholds)
+
+    def compute(self, results_list: list[dict[int, dict[str, np.ndarray]]]) -> tuple[dict[str, float], None]:
+        """
+        Compute COCO metrics
+
+        Args:
+            results_list (list[dict[int, dict[str, np.ndarray]]]): list with results per image (in list)
+                per category (dict). Inner dict contains multiple results obtained by :func:`box_matching_batch`.
+
+                - `dtMatches`: matched detections [T, D], where T = number of
+                  thresholds, D = number of detections
+                - `gtMatches`: matched ground truth boxes [T, G], where T = number
+                  of thresholds, G = number of ground truth
+                - `dtScores`: prediction scores [D] detection scores
+                - `gtIgnore`: ground truth boxes which should be ignored
+                  [G] indicate whether ground truth should be ignored
+                - `dtIgnore`: detections which should be ignored [T, D],
+                  indicate which detections should be ignored
+
+        Returns:
+            dict[str, float], dictionary with coco metrics
+        """
+        if self.verbose:
+            logger.info("Start COCO metric computation...")
+            tic = time.time()
+
+        dataset_statistics = self._compute_statistics(results_list=results_list)  # dict[str, Union[np.ndarray, list]]
+
+        if self.verbose:
+            toc = time.time()
+            logger.info(f"Statistics for COCO metrics finished (t={(toc - tic):0.2f}s).")
+
+        results = {}
+        results.update(self._compute_ap(dataset_statistics))
+        results.update(self._compute_ar(dataset_statistics))
+
+        if self.verbose:
+            toc = time.time()
+            logger.info(f"COCO metrics computed in t={(toc - tic):0.2f}s.")
+        return results, None
+
+    def _compute_ap(self, dataset_statistics: dict[str, np.ndarray | list]) -> dict[str, float]:
+        """
+        Compute AP metrics
+
+        Args:
+            dataset_statistics (list[dict[int, dict[str, np.ndarray]]]): list with result s per image (in list)
+                per category (dict). Inner dict contains multiple results obtained by :func:`box_matching_batch`.
+
+                - `dtMatches`: matched detections [T, D], where T = number of
+                  thresholds, D = number of detections
+                - `gtMatches`: matched ground truth boxes [T, G], where T = number
+                  of thresholds, G = number of ground truth
+                - `dtScores`: prediction scores [D] detection scores
+                - `gtIgnore`: ground truth boxes which should be ignored
+                  [G] indicate whether ground truth should be ignored
+                - `dtIgnore`: detections which should be ignored [T, D],
+                  indicate which detections should be ignored
+        """
+        results = {}
+        if self.iou_range:  # mAP
+            key = (
+                f"mAP_IoU_{self.iou_range[0]:.2f}_{self.iou_range[1]:.2f}_{self.iou_range[2]:.2f}_"
+                f"MaxDet_{self.max_detections[-1]}"
+            )
+            results[key] = self._select_ap(dataset_statistics, iou_idx=self.iou_range_idx, max_det_idx=-1)
+
+            if self.per_class:
+                for cls_idx, cls_str in enumerate(self.classes):  # per class results
+                    key = (
+                        f"{cls_str}_"
+                        f"mAP_IoU_{self.iou_range[0]:.2f}_{self.iou_range[1]:.2f}_{self.iou_range[2]:.2f}_"
+                        f"MaxDet_{self.max_detections[-1]}"
+                    )
+                    results[key] = self._select_ap(
+                        dataset_statistics, iou_idx=self.iou_range_idx, cls_idx=cls_idx, max_det_idx=-1
+                    )
+
+        for idx in self.iou_list_idx:  # AP@IoU
+            key = f"AP_IoU_{self.iou_thresholds[idx]:.2f}_MaxDet_{self.max_detections[-1]}"
+            results[key] = self._select_ap(dataset_statistics, iou_idx=[idx], max_det_idx=-1)
+
+            if self.per_class:
+                for cls_idx, cls_str in enumerate(self.classes):  # per class results
+                    key = f"{cls_str}_" f"AP_IoU_{self.iou_thresholds[idx]:.2f}_" f"MaxDet_{self.max_detections[-1]}"
+                    results[key] = self._select_ap(dataset_statistics, iou_idx=[idx], cls_idx=cls_idx, max_det_idx=-1)
+        return results
+
+    def _compute_ar(self, dataset_statistics: dict[str, np.ndarray | list]) -> dict[str, float]:
+        """
+        Compute AR metrics
+
+        Args:
+            dataset_statistics (list[dict[int, dict[str, np.ndarray]]]): list with result s per image (in list)
+                per category (dict). Inner dict contains multiple results obtained by :func:`box_matching_batch`.
+
+                - `dtMatches`: matched detections [T, D], where T = number of
+                  thresholds, D = number of detections
+                - `gtMatches`: matched ground truth boxes [T, G], where T = number
+                  of thresholds, G = number of ground truth
+                - `dtScores`: prediction scores [D] detection scores
+                - `gtIgnore`: ground truth boxes which should be ignored
+                  [G] indicate whether ground truth should be ignored
+                - `dtIgnore`: detections which should be ignored [T, D],
+                  indicate which detections should be ignored
+        """
+        results = {}
+        for max_det_idx, max_det in enumerate(self.max_detections):  # mAR
+            key = f"mAR_IoU_{self.iou_range[0]:.2f}_{self.iou_range[1]:.2f}_{self.iou_range[2]:.2f}_MaxDet_{max_det}"
+            results[key] = self._select_ar(dataset_statistics, max_det_idx=max_det_idx)
+
+            if self.per_class:
+                for cls_idx, cls_str in enumerate(self.classes):  # per class results
+                    key = (
+                        f"{cls_str}_"
+                        f"mAR_IoU_{self.iou_range[0]:.2f}_{self.iou_range[1]:.2f}_{self.iou_range[2]:.2f}_"
+                        f"MaxDet_{max_det}"
+                    )
+                    results[key] = self._select_ar(dataset_statistics, cls_idx=cls_idx, max_det_idx=max_det_idx)
+
+        for idx in self.iou_list_idx:  # AR@IoU
+            key = f"AR_IoU_{self.iou_thresholds[idx]:.2f}_MaxDet_{self.max_detections[-1]}"
+            results[key] = self._select_ar(dataset_statistics, iou_idx=idx, max_det_idx=-1)
+
+            if self.per_class:
+                for cls_idx, cls_str in enumerate(self.classes):  # per class results
+                    key = f"{cls_str}_" f"AR_IoU_{self.iou_thresholds[idx]:.2f}_" f"MaxDet_{self.max_detections[-1]}"
+                    results[key] = self._select_ar(dataset_statistics, iou_idx=idx, cls_idx=cls_idx, max_det_idx=-1)
+        return results
+
+    @staticmethod
+    def _select_ap(
+        dataset_statistics: dict,
+        iou_idx: int | list[int] | np.ndarray | None = None,
+        cls_idx: int | Sequence[int] | None = None,
+        max_det_idx: int = -1,
+    ) -> float:
+        """
+        Compute average precision
+
+        Args:
+            dataset_statistics (dict): computed statistics over dataset
+
+                - `counts`: Number of thresholds, Number recall thresholds, Number of classes, Number of max
+                  detection thresholds
+                - `recall`: Computed recall values [num_iou_th, num_classes, num_max_detections]
+                - `precision`: Precision values at specified recall thresholds
+                  [num_iou_th, num_recall_th, num_classes, num_max_detections]
+                - `scores`: Scores corresponding to specified recall thresholds
+                  [num_iou_th, num_recall_th, num_classes, num_max_detections]
+            iou_idx: index of IoU values to select for evaluation(if None, all values are used)
+            cls_idx: class indices to select, if None all classes will be selected
+            max_det_idx (int): index to select max detection threshold from data
+
+        Returns:
+            np.ndarray: AP value
+        """
+        prec = dataset_statistics["precision"]
+        if iou_idx is not None:
+            prec = prec[iou_idx]
+        if cls_idx is not None:
+            prec = prec[..., cls_idx, :]
+        prec = prec[..., max_det_idx]
+        return float(np.mean(prec))
+
+    @staticmethod
+    def _select_ar(
+        dataset_statistics: dict,
+        iou_idx: int | Sequence[int] | None = None,
+        cls_idx: int | Sequence[int] | None = None,
+        max_det_idx: int = -1,
+    ) -> float:
+        """
+        Compute average recall
+
+        Args:
+            dataset_statistics (dict): computed statistics over dataset
+
+                - `counts`: Number of thresholds, Number recall thresholds, Number of classes, Number of max
+                  detection thresholds
+                - `recall`: Computed recall values [num_iou_th, num_classes, num_max_detections]
+                - `precision`: Precision values at specified recall thresholds
+                  [num_iou_th, num_recall_th, num_classes, num_max_detections]
+                - `scores`: Scores corresponding to specified recall thresholds
+                  [num_iou_th, num_recall_th, num_classes, num_max_detections]
+            iou_idx: index of IoU values to select for evaluation(if None, all values are used)
+            cls_idx: class indices to select, if None all classes will be selected
+            max_det_idx (int): index to select max detection threshold from data
+
+        Returns:
+            np.ndarray: recall value
+        """
+        rec = dataset_statistics["recall"]
+        if iou_idx is not None:
+            rec = rec[iou_idx]
+        if cls_idx is not None:
+            rec = rec[..., cls_idx, :]
+        rec = rec[..., max_det_idx]
+
+        if len(rec[rec > -1]) == 0:
+            return -1.0
+
+        return float(np.mean(rec[rec > -1]))
+
+    def _compute_statistics(self, results_list: list[dict[int, dict[str, np.ndarray]]]) -> dict[str, np.ndarray | list]:
+        """
+        Compute statistics needed for COCO metrics (mAP, AP of individual classes, mAP@IoU_Thresholds, AR)
+        Adapted from https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/cocoeval.py
+
+        Args:
+            results_list (list[dict[int, dict[str, np.ndarray]]]): list with result s per image (in list)
+                per category (dict). Inner dict contains multiple results obtained by :func:`box_matching_batch`.
+
+                - `dtMatches`: matched detections [T, D], where T = number of
+                  thresholds, D = number of detections
+                - `gtMatches`: matched ground truth boxes [T, G], where T = number
+                  of thresholds, G = number of ground truth
+                - `dtScores`: prediction scores [D] detection scores
+                - `gtIgnore`: ground truth boxes which should be ignored
+                  [G] indicate whether ground truth should be ignored
+                - `dtIgnore`: detections which should be ignored [T, D],
+                  indicate which detections should be ignored
+
+        Returns:
+            dict: computed statistics over dataset
+                - `counts`: Number of thresholds, Number recall thresholds, Number of classes, Number of max
+                  detection thresholds
+                - `recall`: Computed recall values [num_iou_th, num_classes, num_max_detections]
+                - `precision`: Precision values at specified recall thresholds
+                  [num_iou_th, num_recall_th, num_classes, num_max_detections]
+                - `scores`: Scores corresponding to specified recall thresholds
+                  [num_iou_th, num_recall_th, num_classes, num_max_detections]
+        """
+        num_iou_th = len(self.iou_thresholds)
+        num_recall_th = len(self.recall_thresholds)
+        num_classes = len(self.classes)
+        num_max_detections = len(self.max_detections)
+
+        # -1 for the precision of absent categories
+        precision = -np.ones((num_iou_th, num_recall_th, num_classes, num_max_detections))
+        recall = -np.ones((num_iou_th, num_classes, num_max_detections))
+        scores = -np.ones((num_iou_th, num_recall_th, num_classes, num_max_detections))
+
+        for cls_idx, cls_i in enumerate(self.classes):  # for each class
+            for max_det_idx, max_det in enumerate(self.max_detections):  # for each maximum number of detections
+                results = [r[cls_idx] for r in results_list if cls_idx in r]  # len is num_images
+
+                if len(results) == 0:
+                    logger.warning(f"WARNING, no results found for coco metric for class {cls_i}")
+                    continue
+
+                dt_scores = np.concatenate([r["dtScores"][0:max_det] for r in results])
+                # different sorting method generates slightly different results.
+                # mergesort is used to be consistent as Matlab implementation.
+                inds = np.argsort(-dt_scores, kind="mergesort")
+                dt_scores_sorted = dt_scores[inds]
+
+                # r['dtMatches'] [T, R], where R = sum(all detections)
+                dt_matches = np.concatenate([r["dtMatches"][:, 0:max_det] for r in results], axis=1)[:, inds]
+                dt_ignores = np.concatenate([r["dtIgnore"][:, 0:max_det] for r in results], axis=1)[:, inds]
+                self.check_number_of_iou(dt_matches, dt_ignores)
+                gt_ignore = np.concatenate([r["gtIgnore"] for r in results])
+                num_gt = np.count_nonzero(gt_ignore == 0)  # number of ground truth boxes (non ignored)
+                if num_gt == 0:
+                    logger.warning(f"WARNING, no gt found for coco metric for class {cls_i}")
+                    continue
+
+                # ignore cases need to be handled differently for tp and fp
+                tps = np.logical_and(dt_matches, np.logical_not(dt_ignores))
+                fps = np.logical_and(np.logical_not(dt_matches), np.logical_not(dt_ignores))
+
+                tp_sum = np.cumsum(tps, axis=1).astype(dtype=np.float32)
+                fp_sum = np.cumsum(fps, axis=1).astype(dtype=np.float32)
+
+                for th_ind, (tp, fp) in enumerate(zip(tp_sum, fp_sum)):  # for each threshold th_ind
+                    tp, fp = np.array(tp), np.array(fp)
+                    r, p, s = _compute_stats_single_threshold(tp, fp, dt_scores_sorted, self.recall_thresholds, num_gt)
+                    recall[th_ind, cls_idx, max_det_idx] = r
+                    precision[th_ind, :, cls_idx, max_det_idx] = p
+                    # corresponding score thresholds for recall steps
+                    scores[th_ind, :, cls_idx, max_det_idx] = s
+
+        return {
+            "counts": [num_iou_th, num_recall_th, num_classes, num_max_detections],  # [4]
+            "recall": recall,  # [num_iou_th, num_classes, num_max_detections]
+            "precision": precision,  # [num_iou_th, num_recall_th, num_classes, num_max_detections]
+            "scores": scores,  # [num_iou_th, num_recall_th, num_classes, num_max_detections]
+        }
+
+
+def _compute_stats_single_threshold(
+    tp: np.ndarray,
+    fp: np.ndarray,
+    dt_scores_sorted: np.ndarray,
+    recall_thresholds: np.ndarray | Sequence[float],
+    num_gt: int,
+) -> tuple[float, np.ndarray, np.ndarray]:
+    """
+    Compute recall value, precision curve and scores thresholds
+    Adapted from https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/cocoeval.py
+
+    Args:
+        tp (np.ndarray): cumsum over true positives [R], R is the number of detections
+        fp (np.ndarray): cumsum over false positives [R], R is the number of detections
+        dt_scores_sorted (np.ndarray): sorted (descending) scores [R], R is the number of detections
+        recall_thresholds (Sequence[float]): recall thresholds which should be evaluated
+        num_gt (int): number of ground truth bounding boxes (excluding boxes which are ignored)
+
+    Returns:
+        - float, overall recall for given IoU value
+        - np.ndarray, precision values at defined recall values
+          [RTH], where RTH is the number of recall thresholds
+        - np.ndarray, prediction scores corresponding to recall values
+          [RTH], where RTH is the number of recall thresholds
+    """
+    num_recall_th = len(recall_thresholds)
+
+    rc = tp / num_gt
+    # np.spacing(1) is the smallest representable epsilon with float
+    pr = tp / (fp + tp + np.spacing(1))
+
+    if len(tp):
+        recall = rc[-1]
+    else:
+        # no prediction
+        recall = 0
+
+    # array where precision values nearest to given recall th are saved
+    precision = np.zeros((num_recall_th,))
+    # save scores for corresponding recall value in here
+    th_scores = np.zeros((num_recall_th,))
+    # numpy is slow without cython optimization for accessing elements
+    # use python array gets significant speed improvement
+    pr = pr.tolist()
+    precision = precision.tolist()
+
+    # smooth precision curve (create box shape)
+    for i in range(len(tp) - 1, 0, -1):
+        if pr[i] > pr[i - 1]:
+            pr[i - 1] = pr[i]
+
+    # get indices to nearest given recall threshold (nn interpolation!)
+    inds = np.searchsorted(rc, recall_thresholds, side="left")
+    try:
+        for save_idx, array_index in enumerate(inds):
+            precision[save_idx] = pr[array_index]
+            th_scores[save_idx] = dt_scores_sorted[array_index]
+    except BaseException:
+        pass
+
+    return recall, np.array(precision), np.array(th_scores)

source_code/SegMamba/monai/apps/detection/metrics/matching.py

@@ -0,0 +1,368 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/evaluator/detection/matching.py
+# which has the following license...
+# https://github.com/MIC-DKFZ/nnDetection/blob/main/LICENSE
+#
+# Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#    http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/cocodataset/cocoapi
+# which has the following license...
+# https://github.com/cocodataset/cocoapi/blob/master/license.txt
+
+# Copyright (c) 2014, Piotr Dollar and Tsung-Yi Lin
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+"""
+This script is almost same with https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/evaluator/detection/matching.py
+The changes include 1) code reformatting, 2) docstrings,
+3) allow input args gt_ignore to be optional. (If so, no GT boxes will be ignored.)
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import numpy as np
+
+__all__ = ["matching_batch"]
+
+
+def matching_batch(
+    iou_fn: Callable[[np.ndarray, np.ndarray], np.ndarray],
+    iou_thresholds: Sequence[float],
+    pred_boxes: Sequence[np.ndarray],
+    pred_classes: Sequence[np.ndarray],
+    pred_scores: Sequence[np.ndarray],
+    gt_boxes: Sequence[np.ndarray],
+    gt_classes: Sequence[np.ndarray],
+    gt_ignore: Sequence[Sequence[bool]] | Sequence[np.ndarray] | None = None,
+    max_detections: int = 100,
+) -> list[dict[int, dict[str, np.ndarray]]]:
+    """
+    Match boxes of a batch to corresponding ground truth for each category
+    independently.
+
+    Args:
+        iou_fn: compute overlap for each pair
+        iou_thresholds: defined which IoU thresholds should be evaluated
+        pred_boxes: predicted boxes from single batch; List[[D, dim * 2]],
+            D number of predictions
+        pred_classes: predicted classes from a single batch; List[[D]],
+            D number of predictions
+        pred_scores: predicted score for each bounding box; List[[D]],
+            D number of predictions
+        gt_boxes: ground truth boxes; List[[G, dim * 2]], G number of ground
+            truth
+        gt_classes: ground truth classes; List[[G]], G number of ground truth
+        gt_ignore: specified if which ground truth boxes are not counted as
+            true positives. If not given, when use all the gt_boxes.
+            (detections which match theses boxes are not counted as false
+            positives either); List[[G]], G number of ground truth
+        max_detections: maximum number of detections which should be evaluated
+
+    Returns:
+        List[Dict[int, Dict[str, np.ndarray]]], each Dict[str, np.ndarray] corresponds to an image.
+        Dict has the following keys.
+
+        - `dtMatches`: matched detections [T, D], where T = number of
+          thresholds, D = number of detections
+        - `gtMatches`: matched ground truth boxes [T, G], where T = number
+          of thresholds, G = number of ground truth
+        - `dtScores`: prediction scores [D] detection scores
+        - `gtIgnore`: ground truth boxes which should be ignored
+          [G] indicate whether ground truth should be ignored
+        - `dtIgnore`: detections which should be ignored [T, D],
+          indicate which detections should be ignored
+
+    Example:
+
+        .. code-block:: python
+
+            from monai.data.box_utils import box_iou
+            from monai.apps.detection.metrics.coco import COCOMetric
+            from monai.apps.detection.metrics.matching import matching_batch
+            # 3D example outputs of one image from detector
+            val_outputs_all = [
+                    {"boxes": torch.tensor([[1,1,1,3,4,5]],dtype=torch.float16),
+                    "labels": torch.randint(3,(1,)),
+                    "scores": torch.randn((1,)).absolute()},
+            ]
+            val_targets_all = [
+                    {"boxes": torch.tensor([[1,1,1,2,6,4]],dtype=torch.float16),
+                    "labels": torch.randint(3,(1,))},
+            ]
+
+            coco_metric = COCOMetric(
+                classes=['c0','c1','c2'], iou_list=[0.1], max_detection=[10]
+            )
+            results_metric = matching_batch(
+                iou_fn=box_iou,
+                iou_thresholds=coco_metric.iou_thresholds,
+                pred_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_outputs_all],
+                pred_classes=[val_data_i["labels"].numpy() for val_data_i in val_outputs_all],
+                pred_scores=[val_data_i["scores"].numpy() for val_data_i in val_outputs_all],
+                gt_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_targets_all],
+                gt_classes=[val_data_i["labels"].numpy() for val_data_i in val_targets_all],
+            )
+            val_metric_dict = coco_metric(results_metric)
+            print(val_metric_dict)
+    """
+    results = []
+    if gt_ignore is None:
+        gt_ignore = [np.full_like(gt_c, False) for gt_c in gt_classes]
+    # iterate over images/batches
+    for pboxes, pclasses, pscores, gboxes, gclasses, gignore in zip(
+        pred_boxes, pred_classes, pred_scores, gt_boxes, gt_classes, gt_ignore
+    ):
+        # for each image
+        img_classes = np.union1d(pclasses, gclasses)  # possible class labels
+        result = {}  # dict contains results for each class in one image
+        for c in img_classes:
+            pred_mask = pclasses == c  # bool mask predictions with current class
+            gt_mask = gclasses == c  # bool mask ground truth with current class
+
+            if not np.any(gt_mask):  # no ground truth
+                result[c] = _matching_no_gt(
+                    iou_thresholds=iou_thresholds, pred_scores=pscores[pred_mask], max_detections=max_detections
+                )
+            elif not np.any(pred_mask):  # no predictions
+                result[c] = _matching_no_pred(iou_thresholds=iou_thresholds, gt_ignore=gignore[gt_mask])
+            else:  # at least one prediction and one ground truth
+                result[c] = _matching_single_image_single_class(
+                    iou_fn=iou_fn,
+                    pred_boxes=pboxes[pred_mask],
+                    pred_scores=pscores[pred_mask],
+                    gt_boxes=gboxes[gt_mask],
+                    gt_ignore=gignore[gt_mask],
+                    max_detections=max_detections,
+                    iou_thresholds=iou_thresholds,
+                )
+        results.append(result)
+    return results
+
+
+def _matching_no_gt(
+    iou_thresholds: Sequence[float], pred_scores: np.ndarray, max_detections: int
+) -> dict[str, np.ndarray]:
+    """
+    Matching result with not ground truth in image
+
+    Args:
+        iou_thresholds: defined which IoU thresholds should be evaluated
+        dt_scores: predicted scores
+        max_detections: maximum number of allowed detections per image.
+            This functions uses this parameter to stay consistent with
+            the actual matching function which needs this limit.
+
+    Returns:
+        computed matching, a Dict[str, np.ndarray]
+
+        - `dtMatches`: matched detections [T, D], where T = number of
+          thresholds, D = number of detections
+        - `gtMatches`: matched ground truth boxes [T, G], where T = number
+          of thresholds, G = number of ground truth
+        - `dtScores`: prediction scores [D] detection scores
+        - `gtIgnore`: ground truth boxes which should be ignored
+          [G] indicate whether ground truth should be ignored
+        - `dtIgnore`: detections which should be ignored [T, D],
+          indicate which detections should be ignored
+    """
+    dt_ind = np.argsort(-pred_scores, kind="mergesort")
+    dt_ind = dt_ind[:max_detections]
+    dt_scores = pred_scores[dt_ind]
+
+    num_preds = len(dt_scores)
+
+    gt_match: np.ndarray = np.array([[]] * len(iou_thresholds))
+    dt_match: np.ndarray = np.zeros((len(iou_thresholds), num_preds))
+    dt_ignore: np.ndarray = np.zeros((len(iou_thresholds), num_preds))
+
+    return {
+        "dtMatches": dt_match,  # [T, D], where T = number of thresholds, D = number of detections
+        "gtMatches": gt_match,  # [T, G], where T = number of thresholds, G = number of ground truth
+        "dtScores": dt_scores,  # [D] detection scores
+        "gtIgnore": np.array([]).reshape(-1),  # [G] indicate whether ground truth should be ignored
+        "dtIgnore": dt_ignore,  # [T, D], indicate which detections should be ignored
+    }
+
+
+def _matching_no_pred(iou_thresholds: Sequence[float], gt_ignore: np.ndarray) -> dict[str, np.ndarray]:
+    """
+    Matching result with no predictions
+
+    Args:
+        iou_thresholds: defined which IoU thresholds should be evaluated
+        gt_ignore: specified if which ground truth boxes are not counted as
+            true positives (detections which match theses boxes are not
+            counted as false positives either); [G], G number of ground truth
+
+    Returns:
+        dict: computed matching
+
+        - `dtMatches`: matched detections [T, D], where T = number of
+          thresholds, D = number of detections
+        - `gtMatches`: matched ground truth boxes [T, G], where T = number
+          of thresholds, G = number of ground truth
+        - `dtScores`: prediction scores [D] detection scores
+        - `gtIgnore`: ground truth boxes which should be ignored
+          [G] indicate whether ground truth should be ignored
+        - `dtIgnore`: detections which should be ignored [T, D],
+          indicate which detections should be ignored
+    """
+    dt_scores: np.ndarray = np.array([])
+    dt_match: np.ndarray = np.array([[]] * len(iou_thresholds))
+    dt_ignore: np.ndarray = np.array([[]] * len(iou_thresholds))
+
+    n_gt = 0 if gt_ignore.size == 0 else gt_ignore.shape[0]
+    gt_match = np.zeros((len(iou_thresholds), n_gt))
+
+    return {
+        "dtMatches": dt_match,  # [T, D], where T = number of thresholds, D = number of detections
+        "gtMatches": gt_match,  # [T, G], where T = number of thresholds, G = number of ground truth
+        "dtScores": dt_scores,  # [D] detection scores
+        "gtIgnore": gt_ignore.reshape(-1),  # [G] indicate whether ground truth should be ignored
+        "dtIgnore": dt_ignore,  # [T, D], indicate which detections should be ignored
+    }
+
+
+def _matching_single_image_single_class(
+    iou_fn: Callable[[np.ndarray, np.ndarray], np.ndarray],
+    pred_boxes: np.ndarray,
+    pred_scores: np.ndarray,
+    gt_boxes: np.ndarray,
+    gt_ignore: np.ndarray,
+    max_detections: int,
+    iou_thresholds: Sequence[float],
+) -> dict[str, np.ndarray]:
+    """
+    Adapted from https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocotools/cocoeval.py
+
+    Args:
+        iou_fn: compute overlap for each pair
+        iou_thresholds: defined which IoU thresholds should be evaluated
+        pred_boxes: predicted boxes from single batch; [D, dim * 2], D number
+            of predictions
+        pred_scores: predicted score for each bounding box; [D], D number of
+            predictions
+        gt_boxes: ground truth boxes; [G, dim * 2], G number of ground truth
+        gt_ignore: specified if which ground truth boxes are not counted as
+            true positives (detections which match theses boxes are not
+            counted as false positives either); [G], G number of ground truth
+        max_detections: maximum number of detections which should be evaluated
+
+    Returns:
+        dict: computed matching
+
+        - `dtMatches`: matched detections [T, D], where T = number of
+          thresholds, D = number of detections
+        - `gtMatches`: matched ground truth boxes [T, G], where T = number
+          of thresholds, G = number of ground truth
+        - `dtScores`: prediction scores [D] detection scores
+        - `gtIgnore`: ground truth boxes which should be ignored
+          [G] indicate whether ground truth should be ignored
+        - `dtIgnore`: detections which should be ignored [T, D],
+          indicate which detections should be ignored
+    """
+    # filter for max_detections highest scoring predictions to speed up computation
+    dt_ind = np.argsort(-pred_scores, kind="mergesort")
+    dt_ind = dt_ind[:max_detections]
+
+    pred_boxes = pred_boxes[dt_ind]
+    pred_scores = pred_scores[dt_ind]
+
+    # sort ignored ground truth to last positions
+    gt_ind = np.argsort(gt_ignore, kind="mergesort")
+    gt_boxes = gt_boxes[gt_ind]
+    gt_ignore = gt_ignore[gt_ind]
+
+    # ious between sorted(!) predictions and ground truth
+    ious = iou_fn(pred_boxes, gt_boxes)  # array sized (num_preds, num_gts)
+
+    num_preds, num_gts = ious.shape[0], ious.shape[1]
+    gt_match = np.zeros((len(iou_thresholds), num_gts))
+    dt_match = np.zeros((len(iou_thresholds), num_preds))
+    dt_ignore = np.zeros((len(iou_thresholds), num_preds))
+
+    for tind, t in enumerate(iou_thresholds):
+        for dind, _d in enumerate(pred_boxes):  # iterate detections starting from highest scoring one
+            # information about best match so far (m=-1 -> unmatched)
+            iou = min([t, 1 - 1e-10])
+            m = -1
+
+            for gind, _g in enumerate(gt_boxes):  # iterate ground truth
+                # if this gt already matched, continue
+                if gt_match[tind, gind] > 0:
+                    continue
+
+                # if dt matched to reg gt, and on ignore gt, stop
+                if m > -1 and gt_ignore[m] == 0 and gt_ignore[gind] == 1:
+                    break
+
+                # continue to next gt unless better match made
+                if ious[dind, gind] < iou:
+                    continue
+
+                # if match successful and best so far, store appropriately
+                iou = ious[dind, gind]
+                m = gind
+
+            # if match made, store id of match for both dt and gt
+            if m == -1:
+                continue
+            else:
+                dt_ignore[tind, dind] = int(gt_ignore[m])
+                dt_match[tind, dind] = 1
+                gt_match[tind, m] = 1
+
+    # store results for given image and category
+    return {
+        "dtMatches": dt_match,  # [T, D], where T = number of thresholds, D = number of detections
+        "gtMatches": gt_match,  # [T, G], where T = number of thresholds, G = number of ground truth
+        "dtScores": pred_scores,  # [D] detection scores
+        "gtIgnore": gt_ignore.reshape(-1),  # [G] indicate whether ground truth should be ignored
+        "dtIgnore": dt_ignore,  # [T, D], indicate which detections should be ignored
+    }

source_code/SegMamba/monai/apps/detection/networks/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/detection/networks/retinanet_detector.py

@@ -0,0 +1,1081 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/pytorch/vision/blob/main/torchvision/models/detection/retinanet.py
+# which has the following license...
+# https://github.com/pytorch/vision/blob/main/LICENSE
+
+# BSD 3-Clause License
+
+# Copyright (c) Soumith Chintala 2016,
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+"""
+Part of this script is adapted from
+https://github.com/pytorch/vision/blob/main/torchvision/models/detection/retinanet.py
+"""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable, Sequence
+from typing import Any
+
+import torch
+from torch import Tensor, nn
+
+from monai.apps.detection.networks.retinanet_network import RetinaNet, resnet_fpn_feature_extractor
+from monai.apps.detection.utils.anchor_utils import AnchorGenerator
+from monai.apps.detection.utils.ATSS_matcher import ATSSMatcher
+from monai.apps.detection.utils.box_coder import BoxCoder
+from monai.apps.detection.utils.box_selector import BoxSelector
+from monai.apps.detection.utils.detector_utils import check_training_targets, preprocess_images
+from monai.apps.detection.utils.hard_negative_sampler import HardNegativeSampler
+from monai.apps.detection.utils.predict_utils import ensure_dict_value_to_list_, predict_with_inferer
+from monai.data.box_utils import box_iou
+from monai.inferers import SlidingWindowInferer
+from monai.networks.nets import resnet
+from monai.utils import BlendMode, PytorchPadMode, ensure_tuple_rep, optional_import
+
+BalancedPositiveNegativeSampler, _ = optional_import(
+    "torchvision.models.detection._utils", name="BalancedPositiveNegativeSampler"
+)
+Matcher, _ = optional_import("torchvision.models.detection._utils", name="Matcher")
+
+
+class RetinaNetDetector(nn.Module):
+    """
+    Retinanet detector, expandable to other one stage anchor based box detectors in the future.
+    An example of construction can found in the source code of
+    :func:`~monai.apps.detection.networks.retinanet_detector.retinanet_resnet50_fpn_detector` .
+
+    The input to the model is expected to be a list of tensors, each of shape (C, H, W) or  (C, H, W, D),
+    one for each image, and should be in 0-1 range. Different images can have different sizes.
+    Or it can also be a Tensor sized (B, C, H, W) or  (B, C, H, W, D). In this case, all images have same size.
+
+    The behavior of the model changes depending if it is in training or evaluation mode.
+
+    During training, the model expects both the input tensors, as well as a targets (list of dictionary),
+    containing:
+
+    - boxes (``FloatTensor[N, 4]`` or ``FloatTensor[N, 6]``): the ground-truth boxes in ``StandardMode``, i.e.,
+      ``[xmin, ymin, xmax, ymax]`` or ``[xmin, ymin, zmin, xmax, ymax, zmax]`` format,
+      with ``0 <= xmin < xmax <= H``, ``0 <= ymin < ymax <= W``, ``0 <= zmin < zmax <= D``.
+    - labels: the class label for each ground-truth box
+
+    The model returns a Dict[str, Tensor] during training, containing the classification and regression
+    losses.
+    When saving the model, only self.network contains trainable parameters and needs to be saved.
+
+    During inference, the model requires only the input tensors, and returns the post-processed
+    predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as
+    follows:
+
+    - boxes (``FloatTensor[N, 4]`` or ``FloatTensor[N, 6]``): the predicted boxes in ``StandardMode``, i.e.,
+      ``[xmin, ymin, xmax, ymax]`` or ``[xmin, ymin, zmin, xmax, ymax, zmax]`` format,
+      with ``0 <= xmin < xmax <= H``, ``0 <= ymin < ymax <= W``, ``0 <= zmin < zmax <= D``.
+    - labels (Int64Tensor[N]): the predicted labels for each image
+    - labels_scores (Tensor[N]): the scores for each prediction
+
+    Args:
+        network: a network that takes an image Tensor sized (B, C, H, W) or (B, C, H, W, D) as input
+            and outputs a dictionary Dict[str, List[Tensor]] or Dict[str, Tensor].
+        anchor_generator: anchor generator.
+        box_overlap_metric: func that compute overlap between two sets of boxes, default is Intersection over Union (IoU).
+        debug: whether to print out internal parameters, used for debugging and parameter tuning.
+
+    Notes:
+
+        Input argument ``network`` can be a monai.apps.detection.networks.retinanet_network.RetinaNet(*) object,
+        but any network that meets the following rules is a valid input ``network``.
+
+        1. It should have attributes including spatial_dims, num_classes, cls_key, box_reg_key, num_anchors, size_divisible.
+
+            - spatial_dims (int) is the spatial dimension of the network, we support both 2D and 3D.
+            - num_classes (int) is the number of classes, excluding the background.
+            - size_divisible (int or Sequence[int]) is the expectation on the input image shape.
+              The network needs the input spatial_size to be divisible by size_divisible, length should be 2 or 3.
+            - cls_key (str) is the key to represent classification in the output dict.
+            - box_reg_key (str) is the key to represent box regression in the output dict.
+            - num_anchors (int) is the number of anchor shapes at each location. it should equal to
+              ``self.anchor_generator.num_anchors_per_location()[0]``.
+
+            If network does not have these attributes, user needs to provide them for the detector.
+
+        2. Its input should be an image Tensor sized (B, C, H, W) or (B, C, H, W, D).
+
+        3. About its output ``head_outputs``, it should be either a list of tensors or a dictionary of str: List[Tensor]:
+
+            - If it is a dictionary, it needs to have at least two keys:
+              ``network.cls_key`` and ``network.box_reg_key``, representing predicted classification maps and box regression maps.
+              ``head_outputs[network.cls_key]`` should be List[Tensor] or Tensor. Each Tensor represents
+              classification logits map at one resolution level,
+              sized (B, num_classes*num_anchors, H_i, W_i) or (B, num_classes*num_anchors, H_i, W_i, D_i).
+              ``head_outputs[network.box_reg_key]`` should be List[Tensor] or Tensor. Each Tensor represents
+              box regression map at one resolution level,
+              sized (B, 2*spatial_dims*num_anchors, H_i, W_i)or (B, 2*spatial_dims*num_anchors, H_i, W_i, D_i).
+              ``len(head_outputs[network.cls_key]) == len(head_outputs[network.box_reg_key])``.
+            - If it is a list of 2N tensors, the first N tensors should be the predicted classification maps,
+              and the second N tensors should be the predicted box regression maps.
+
+    Example:
+
+        .. code-block:: python
+
+            # define a naive network
+            import torch
+            class NaiveNet(torch.nn.Module):
+                def __init__(self, spatial_dims: int, num_classes: int):
+                    super().__init__()
+                    self.spatial_dims = spatial_dims
+                    self.num_classes = num_classes
+                    self.size_divisible = 2
+                    self.cls_key = "cls"
+                    self.box_reg_key = "box_reg"
+                    self.num_anchors = 1
+                def forward(self, images: torch.Tensor):
+                    spatial_size = images.shape[-self.spatial_dims:]
+                    out_spatial_size = tuple(s//self.size_divisible for s in spatial_size)  # half size of input
+                    out_cls_shape = (images.shape[0],self.num_classes*self.num_anchors) + out_spatial_size
+                    out_box_reg_shape = (images.shape[0],2*self.spatial_dims*self.num_anchors) + out_spatial_size
+                    return {self.cls_key: [torch.randn(out_cls_shape)], self.box_reg_key: [torch.randn(out_box_reg_shape)]}
+
+            # create a RetinaNetDetector detector
+            spatial_dims = 3
+            num_classes = 5
+            anchor_generator = monai.apps.detection.utils.anchor_utils.AnchorGeneratorWithAnchorShape(
+                feature_map_scales=(1, ), base_anchor_shapes=((8,) * spatial_dims)
+            )
+            net = NaiveNet(spatial_dims, num_classes)
+            detector = RetinaNetDetector(net, anchor_generator)
+
+            # only detector.network may contain trainable parameters.
+            optimizer = torch.optim.SGD(
+                detector.network.parameters(),
+                1e-3,
+                momentum=0.9,
+                weight_decay=3e-5,
+                nesterov=True,
+            )
+            torch.save(detector.network.state_dict(), 'model.pt')  # save model
+            detector.network.load_state_dict(torch.load('model.pt'))  # load model
+    """
+
+    def __init__(
+        self,
+        network: nn.Module,
+        anchor_generator: AnchorGenerator,
+        box_overlap_metric: Callable = box_iou,
+        spatial_dims: int | None = None,  # used only when network.spatial_dims does not exist
+        num_classes: int | None = None,  # used only when network.num_classes does not exist
+        size_divisible: Sequence[int] | int = 1,  # used only when network.size_divisible does not exist
+        cls_key: str = "classification",  # used only when network.cls_key does not exist
+        box_reg_key: str = "box_regression",  # used only when network.box_reg_key does not exist
+        debug: bool = False,
+    ):
+        super().__init__()
+
+        self.network = network
+        # network attribute
+        self.spatial_dims = self.get_attribute_from_network("spatial_dims", default_value=spatial_dims)
+        self.num_classes = self.get_attribute_from_network("num_classes", default_value=num_classes)
+
+        self.size_divisible = self.get_attribute_from_network("size_divisible", default_value=size_divisible)
+        self.size_divisible = ensure_tuple_rep(self.size_divisible, self.spatial_dims)
+        # keys for the network output
+        self.cls_key = self.get_attribute_from_network("cls_key", default_value=cls_key)
+        self.box_reg_key = self.get_attribute_from_network("box_reg_key", default_value=box_reg_key)
+
+        # check if anchor_generator matches with network
+        self.anchor_generator = anchor_generator
+        self.num_anchors_per_loc = self.anchor_generator.num_anchors_per_location()[0]
+        network_num_anchors = self.get_attribute_from_network("num_anchors", default_value=self.num_anchors_per_loc)
+        if self.num_anchors_per_loc != network_num_anchors:
+            raise ValueError(
+                f"Number of feature map channels ({network_num_anchors}) "
+                f"should match with number of anchors at each location ({self.num_anchors_per_loc})."
+            )
+        # if new coming input images has same shape with
+        # self.previous_image_shape, there is no need to generate new anchors.
+        self.anchors: list[Tensor] | None = None
+        self.previous_image_shape: Any | None = None
+
+        self.box_overlap_metric = box_overlap_metric
+        self.debug = debug
+
+        # default setting for training
+        self.fg_bg_sampler: Any | None = None
+        self.set_cls_loss(torch.nn.BCEWithLogitsLoss(reduction="mean"))  # classification loss
+        self.set_box_regression_loss(
+            torch.nn.SmoothL1Loss(beta=1.0 / 9, reduction="mean"), encode_gt=True, decode_pred=False
+        )  # box regression loss
+
+        # default setting for both training and inference
+        # can be updated by self.set_box_coder_weights(*)
+        self.box_coder = BoxCoder(weights=(1.0,) * 2 * self.spatial_dims)
+
+        # default keys in the ground truth targets and predicted boxes,
+        # can be updated by self.set_target_keys(*)
+        self.target_box_key = "boxes"
+        self.target_label_key = "labels"
+        self.pred_score_key = self.target_label_key + "_scores"  # score key for the detected boxes
+
+        # default setting for inference,
+        # can be updated by self.set_sliding_window_inferer(*)
+        self.inferer: SlidingWindowInferer | None = None
+        # can be updated by self.set_box_selector_parameters(*),
+        self.box_selector = BoxSelector(
+            box_overlap_metric=self.box_overlap_metric,
+            score_thresh=0.05,
+            topk_candidates_per_level=1000,
+            nms_thresh=0.5,
+            detections_per_img=300,
+            apply_sigmoid=True,
+        )
+
+    def get_attribute_from_network(self, attr_name, default_value=None):
+        if hasattr(self.network, attr_name):
+            return getattr(self.network, attr_name)
+        elif default_value is not None:
+            return default_value
+        else:
+            raise ValueError(f"network does not have attribute {attr_name}, please provide it in the detector.")
+
+    def set_box_coder_weights(self, weights: tuple[float]) -> None:
+        """
+        Set the weights for box coder.
+
+        Args:
+            weights: a list/tuple with length of 2*self.spatial_dims
+
+        """
+        if len(weights) != 2 * self.spatial_dims:
+            raise ValueError(f"len(weights) should be {2 * self.spatial_dims}, got weights={weights}.")
+        self.box_coder = BoxCoder(weights=weights)
+
+    def set_target_keys(self, box_key: str, label_key: str) -> None:
+        """
+        Set keys for the training targets and inference outputs.
+        During training, both box_key and label_key should be keys in the targets
+        when performing ``self.forward(input_images, targets)``.
+        During inference, they will be the keys in the output dict of `self.forward(input_images)``.
+        """
+        self.target_box_key = box_key
+        self.target_label_key = label_key
+        self.pred_score_key = label_key + "_scores"
+
+    def set_cls_loss(self, cls_loss: nn.Module) -> None:
+        """
+        Using for training. Set loss for classification that takes logits as inputs, make sure sigmoid/softmax is built in.
+
+        Args:
+            cls_loss: loss module for classification
+
+        Example:
+            .. code-block:: python
+
+                detector.set_cls_loss(torch.nn.BCEWithLogitsLoss(reduction="mean"))
+                detector.set_cls_loss(FocalLoss(reduction="mean", gamma=2.0))
+        """
+        self.cls_loss_func = cls_loss
+
+    def set_box_regression_loss(self, box_loss: nn.Module, encode_gt: bool, decode_pred: bool) -> None:
+        """
+        Using for training. Set loss for box regression.
+
+        Args:
+            box_loss: loss module for box regression
+            encode_gt: if True, will encode ground truth boxes to target box regression
+                before computing the losses. Should be True for L1 loss and False for GIoU loss.
+            decode_pred: if True, will decode predicted box regression into predicted boxes
+                before computing losses. Should be False for L1 loss and True for GIoU loss.
+
+        Example:
+            .. code-block:: python
+
+                detector.set_box_regression_loss(
+                    torch.nn.SmoothL1Loss(beta=1.0 / 9, reduction="mean"),
+                    encode_gt = True, decode_pred = False
+                )
+                detector.set_box_regression_loss(
+                    monai.losses.giou_loss.BoxGIoULoss(reduction="mean"),
+                    encode_gt = False, decode_pred = True
+                )
+        """
+        self.box_loss_func = box_loss
+        self.encode_gt = encode_gt
+        self.decode_pred = decode_pred
+
+    def set_regular_matcher(
+        self, fg_iou_thresh: float, bg_iou_thresh: float, allow_low_quality_matches: bool = True
+    ) -> None:
+        """
+        Using for training. Set torchvision matcher that matches anchors with ground truth boxes.
+
+        Args:
+            fg_iou_thresh: foreground IoU threshold for Matcher, considered as matched if IoU > fg_iou_thresh
+            bg_iou_thresh: background IoU threshold for Matcher, considered as not matched if IoU < bg_iou_thresh
+            allow_low_quality_matches: if True, produce additional matches
+                for predictions that have only low-quality match candidates.
+        """
+        if fg_iou_thresh < bg_iou_thresh:
+            raise ValueError(
+                "Require fg_iou_thresh >= bg_iou_thresh. "
+                f"Got fg_iou_thresh={fg_iou_thresh}, bg_iou_thresh={bg_iou_thresh}."
+            )
+        self.proposal_matcher = Matcher(
+            fg_iou_thresh, bg_iou_thresh, allow_low_quality_matches=allow_low_quality_matches
+        )
+
+    def set_atss_matcher(self, num_candidates: int = 4, center_in_gt: bool = False) -> None:
+        """
+        Using for training. Set ATSS matcher that matches anchors with ground truth boxes
+
+        Args:
+            num_candidates: number of positions to select candidates from.
+                Smaller value will result in a higher matcher threshold and less matched candidates.
+            center_in_gt: If False (default), matched anchor center points do not need
+                to lie withing the ground truth box. Recommend False for small objects.
+                If True, will result in a strict matcher and less matched candidates.
+        """
+        self.proposal_matcher = ATSSMatcher(num_candidates, self.box_overlap_metric, center_in_gt, debug=self.debug)
+
+    def set_hard_negative_sampler(
+        self, batch_size_per_image: int, positive_fraction: float, min_neg: int = 1, pool_size: float = 10
+    ) -> None:
+        """
+        Using for training. Set hard negative sampler that samples part of the anchors for training.
+
+        HardNegativeSampler is used to suppress false positive rate in classification tasks.
+        During training, it select negative samples with high prediction scores.
+
+        Args:
+            batch_size_per_image: number of elements to be selected per image
+            positive_fraction: percentage of positive elements in the selected samples
+            min_neg: minimum number of negative samples to select if possible.
+            pool_size: when we need ``num_neg`` hard negative samples, they will be randomly selected from
+                ``num_neg * pool_size`` negative samples with the highest prediction scores.
+                Larger ``pool_size`` gives more randomness, yet selects negative samples that are less 'hard',
+                i.e., negative samples with lower prediction scores.
+        """
+        self.fg_bg_sampler = HardNegativeSampler(
+            batch_size_per_image=batch_size_per_image,
+            positive_fraction=positive_fraction,
+            min_neg=min_neg,
+            pool_size=pool_size,
+        )
+
+    def set_balanced_sampler(self, batch_size_per_image: int, positive_fraction: float) -> None:
+        """
+        Using for training. Set torchvision balanced sampler that samples part of the anchors for training.
+
+        Args:
+            batch_size_per_image: number of elements to be selected per image
+            positive_fraction: percentage of positive elements per batch
+
+        """
+        self.fg_bg_sampler = BalancedPositiveNegativeSampler(
+            batch_size_per_image=batch_size_per_image, positive_fraction=positive_fraction
+        )
+
+    def set_sliding_window_inferer(
+        self,
+        roi_size: Sequence[int] | int,
+        sw_batch_size: int = 1,
+        overlap: float = 0.5,
+        mode: BlendMode | str = BlendMode.CONSTANT,
+        sigma_scale: Sequence[float] | float = 0.125,
+        padding_mode: PytorchPadMode | str = PytorchPadMode.CONSTANT,
+        cval: float = 0.0,
+        sw_device: torch.device | str | None = None,
+        device: torch.device | str | None = None,
+        progress: bool = False,
+        cache_roi_weight_map: bool = False,
+    ) -> None:
+        """
+        Define sliding window inferer and store it to self.inferer.
+        """
+        self.inferer = SlidingWindowInferer(
+            roi_size,
+            sw_batch_size,
+            overlap,
+            mode,
+            sigma_scale,
+            padding_mode,
+            cval,
+            sw_device,
+            device,
+            progress,
+            cache_roi_weight_map,
+        )
+
+    def set_box_selector_parameters(
+        self,
+        score_thresh: float = 0.05,
+        topk_candidates_per_level: int = 1000,
+        nms_thresh: float = 0.5,
+        detections_per_img: int = 300,
+        apply_sigmoid: bool = True,
+    ) -> None:
+        """
+        Using for inference. Set the parameters that are used for box selection during inference.
+        The box selection is performed with the following steps:
+
+        #. For each level, discard boxes with scores less than self.score_thresh.
+        #. For each level, keep boxes with top self.topk_candidates_per_level scores.
+        #. For the whole image, perform non-maximum suppression (NMS) on boxes, with overlapping threshold nms_thresh.
+        #. For the whole image, keep boxes with top self.detections_per_img scores.
+
+        Args:
+            score_thresh: no box with scores less than score_thresh will be kept
+            topk_candidates_per_level: max number of boxes to keep for each level
+            nms_thresh: box overlapping threshold for NMS
+            detections_per_img: max number of boxes to keep for each image
+        """
+
+        self.box_selector = BoxSelector(
+            box_overlap_metric=self.box_overlap_metric,
+            apply_sigmoid=apply_sigmoid,
+            score_thresh=score_thresh,
+            topk_candidates_per_level=topk_candidates_per_level,
+            nms_thresh=nms_thresh,
+            detections_per_img=detections_per_img,
+        )
+
+    def forward(
+        self,
+        input_images: list[Tensor] | Tensor,
+        targets: list[dict[str, Tensor]] | None = None,
+        use_inferer: bool = False,
+    ) -> dict[str, Tensor] | list[dict[str, Tensor]]:
+        """
+        Returns a dict of losses during training, or a list predicted dict of boxes and labels during inference.
+
+        Args:
+            input_images: The input to the model is expected to be a list of tensors, each of shape (C, H, W) or  (C, H, W, D),
+                one for each image, and should be in 0-1 range. Different images can have different sizes.
+                Or it can also be a Tensor sized (B, C, H, W) or  (B, C, H, W, D). In this case, all images have same size.
+            targets: a list of dict. Each dict with two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image (optional).
+            use_inferer: whether to use self.inferer, a sliding window inferer, to do the inference.
+                If False, will simply forward the network.
+                If True, will use self.inferer, and requires
+                ``self.set_sliding_window_inferer(*args)`` to have been called before.
+
+        Return:
+            If training mode, will return a dict with at least two keys,
+            including self.cls_key and self.box_reg_key, representing classification loss and box regression loss.
+
+            If evaluation mode, will return a list of detection results.
+            Each element corresponds to an images in ``input_images``, is a dict with at least three keys,
+            including self.target_box_key, self.target_label_key, self.pred_score_key,
+            representing predicted boxes, classification labels, and classification scores.
+
+        """
+        # 1. Check if input arguments are valid
+        if self.training:
+            targets = check_training_targets(
+                input_images, targets, self.spatial_dims, self.target_label_key, self.target_box_key
+            )
+            self._check_detector_training_components()
+
+        # 2. Pad list of images to a single Tensor `images` with spatial size divisible by self.size_divisible.
+        # image_sizes stores the original spatial_size of each image before padding.
+        images, image_sizes = preprocess_images(input_images, self.spatial_dims, self.size_divisible)
+
+        # 3. Generate network outputs. Use inferer only in evaluation mode.
+        if self.training or (not use_inferer):
+            head_outputs = self.network(images)
+            if isinstance(head_outputs, (tuple, list)):
+                tmp_dict = {}
+                tmp_dict[self.cls_key] = head_outputs[: len(head_outputs) // 2]
+                tmp_dict[self.box_reg_key] = head_outputs[len(head_outputs) // 2 :]
+                head_outputs = tmp_dict
+            else:
+                # ensure head_outputs is Dict[str, List[Tensor]]
+                ensure_dict_value_to_list_(head_outputs)
+        else:
+            if self.inferer is None:
+                raise ValueError(
+                    "`self.inferer` is not defined." "Please refer to function self.set_sliding_window_inferer(*)."
+                )
+            head_outputs = predict_with_inferer(
+                images, self.network, keys=[self.cls_key, self.box_reg_key], inferer=self.inferer
+            )
+
+        # 4. Generate anchors and store it in self.anchors: List[Tensor]
+        self.generate_anchors(images, head_outputs)
+        # num_anchor_locs_per_level: List[int], list of HW or HWD for each level
+        num_anchor_locs_per_level = [x.shape[2:].numel() for x in head_outputs[self.cls_key]]
+
+        # 5. Reshape and concatenate head_outputs values from List[Tensor] to Tensor
+        # head_outputs, originally being Dict[str, List[Tensor]], will be reshaped to Dict[str, Tensor]
+        for key in [self.cls_key, self.box_reg_key]:
+            # reshape to Tensor sized(B, sum(HWA), self.num_classes) for self.cls_key
+            # or (B, sum(HWA), 2* self.spatial_dims) for self.box_reg_key
+            # A = self.num_anchors_per_loc
+            head_outputs[key] = self._reshape_maps(head_outputs[key])
+
+        # 6(1). If during training, return losses
+        if self.training:
+            losses = self.compute_loss(head_outputs, targets, self.anchors, num_anchor_locs_per_level)  # type: ignore
+            return losses
+
+        # 6(2). If during inference, return detection results
+        detections = self.postprocess_detections(
+            head_outputs, self.anchors, image_sizes, num_anchor_locs_per_level  # type: ignore
+        )
+        return detections
+
+    def _check_detector_training_components(self):
+        """
+        Check if self.proposal_matcher and self.fg_bg_sampler have been set for training.
+        """
+        if not hasattr(self, "proposal_matcher"):
+            raise AttributeError(
+                "Matcher is not set. Please refer to self.set_regular_matcher(*) or self.set_atss_matcher(*)."
+            )
+        if self.fg_bg_sampler is None and self.debug:
+            warnings.warn(
+                "No balanced sampler is used. Negative samples are likely to "
+                "be much more than positive samples. Please set balanced samplers with self.set_balanced_sampler(*) "
+                "or self.set_hard_negative_sampler(*), "
+                "or set classification loss function as Focal loss with self.set_cls_loss(*)"
+            )
+
+    def generate_anchors(self, images: Tensor, head_outputs: dict[str, list[Tensor]]) -> None:
+        """
+        Generate anchors and store it in self.anchors: List[Tensor].
+        We generate anchors only when there is no stored anchors,
+        or the new coming images has different shape with self.previous_image_shape
+
+        Args:
+            images: input images, a (B, C, H, W) or (B, C, H, W, D) Tensor.
+            head_outputs: head_outputs. ``head_output_reshape[self.cls_key]`` is a Tensor
+              sized (B, sum(HW(D)A), self.num_classes). ``head_output_reshape[self.box_reg_key]`` is a Tensor
+              sized (B, sum(HW(D)A), 2*self.spatial_dims)
+        """
+        if (self.anchors is None) or (self.previous_image_shape != images.shape):
+            self.anchors = self.anchor_generator(images, head_outputs[self.cls_key])  # List[Tensor], len = batchsize
+            self.previous_image_shape = images.shape
+
+    def _reshape_maps(self, result_maps: list[Tensor]) -> Tensor:
+        """
+        Concat network output map list to a single Tensor.
+        This function is used in both training and inference.
+
+        Args:
+            result_maps: a list of Tensor, each Tensor is a (B, num_channel*A, H, W) or (B, num_channel*A, H, W, D) map.
+                A = self.num_anchors_per_loc
+
+        Return:
+            reshaped and concatenated result, sized (B, sum(HWA), num_channel) or (B, sum(HWDA), num_channel)
+        """
+        all_reshaped_result_map = []
+
+        for result_map in result_maps:
+            batch_size = result_map.shape[0]
+            num_channel = result_map.shape[1] // self.num_anchors_per_loc
+            spatial_size = result_map.shape[-self.spatial_dims :]
+
+            # reshaped_result_map will become (B, A, num_channel, H, W) or (B, A, num_channel, H, W, D)
+            # A = self.num_anchors_per_loc
+            view_shape = (batch_size, -1, num_channel) + spatial_size
+            reshaped_result_map = result_map.view(view_shape)
+
+            # permute output to (B, H, W, A, num_channel) or (B, H, W, D, A, num_channel)
+            if self.spatial_dims == 2:
+                reshaped_result_map = reshaped_result_map.permute(0, 3, 4, 1, 2)
+            elif self.spatial_dims == 3:
+                reshaped_result_map = reshaped_result_map.permute(0, 3, 4, 5, 1, 2)
+            else:
+                ValueError("Images can only be 2D or 3D.")
+
+            # reshaped_result_map will become (B, HWA, num_channel) or (B, HWDA, num_channel)
+            reshaped_result_map = reshaped_result_map.reshape(batch_size, -1, num_channel)
+
+            if torch.isnan(reshaped_result_map).any() or torch.isinf(reshaped_result_map).any():
+                if torch.is_grad_enabled():
+                    raise ValueError("Concatenated result is NaN or Inf.")
+                else:
+                    warnings.warn("Concatenated result is NaN or Inf.")
+
+            all_reshaped_result_map.append(reshaped_result_map)
+
+        return torch.cat(all_reshaped_result_map, dim=1)
+
+    def postprocess_detections(
+        self,
+        head_outputs_reshape: dict[str, Tensor],
+        anchors: list[Tensor],
+        image_sizes: list[list[int]],
+        num_anchor_locs_per_level: Sequence[int],
+        need_sigmoid: bool = True,
+    ) -> list[dict[str, Tensor]]:
+        """
+        Postprocessing to generate detection result from classification logits and box regression.
+        Use self.box_selector to select the final output boxes for each image.
+
+        Args:
+            head_outputs_reshape: reshaped head_outputs. ``head_output_reshape[self.cls_key]`` is a Tensor
+              sized (B, sum(HW(D)A), self.num_classes). ``head_output_reshape[self.box_reg_key]`` is a Tensor
+              sized (B, sum(HW(D)A), 2*self.spatial_dims)
+            targets: a list of dict. Each dict with two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image.
+            anchors: a list of Tensor. Each Tensor represents anchors for each image,
+                sized (sum(HWA), 2*spatial_dims) or (sum(HWDA), 2*spatial_dims).
+                A = self.num_anchors_per_loc.
+
+        Return:
+            a list of dict, each dict corresponds to detection result on image.
+        """
+
+        # recover level sizes, HWA or HWDA for each level
+        num_anchors_per_level = [
+            num_anchor_locs * self.num_anchors_per_loc for num_anchor_locs in num_anchor_locs_per_level
+        ]
+
+        # split outputs per level
+        split_head_outputs: dict[str, list[Tensor]] = {}
+        for k in head_outputs_reshape:
+            split_head_outputs[k] = list(head_outputs_reshape[k].split(num_anchors_per_level, dim=1))
+        split_anchors = [list(a.split(num_anchors_per_level)) for a in anchors]  # List[List[Tensor]]
+
+        class_logits = split_head_outputs[self.cls_key]  # List[Tensor], each sized (B, HWA, self.num_classes)
+        box_regression = split_head_outputs[self.box_reg_key]  # List[Tensor], each sized (B, HWA, 2*spatial_dims)
+        compute_dtype = class_logits[0].dtype
+
+        num_images = len(image_sizes)  # B
+
+        detections: list[dict[str, Tensor]] = []
+
+        for index in range(num_images):
+            box_regression_per_image = [
+                br[index] for br in box_regression
+            ]  # List[Tensor], each sized (HWA, 2*spatial_dims)
+            logits_per_image = [cl[index] for cl in class_logits]  # List[Tensor], each sized (HWA, self.num_classes)
+            anchors_per_image, img_spatial_size = split_anchors[index], image_sizes[index]
+            # decode box regression into boxes
+            boxes_per_image = [
+                self.box_coder.decode_single(b.to(torch.float32), a).to(compute_dtype)
+                for b, a in zip(box_regression_per_image, anchors_per_image)
+            ]  # List[Tensor], each sized (HWA, 2*spatial_dims)
+
+            selected_boxes, selected_scores, selected_labels = self.box_selector.select_boxes_per_image(
+                boxes_per_image, logits_per_image, img_spatial_size
+            )
+
+            detections.append(
+                {
+                    self.target_box_key: selected_boxes,  # Tensor, sized (N, 2*spatial_dims)
+                    self.pred_score_key: selected_scores,  # Tensor, sized (N, )
+                    self.target_label_key: selected_labels,  # Tensor, sized (N, )
+                }
+            )
+
+        return detections
+
+    def compute_loss(
+        self,
+        head_outputs_reshape: dict[str, Tensor],
+        targets: list[dict[str, Tensor]],
+        anchors: list[Tensor],
+        num_anchor_locs_per_level: Sequence[int],
+    ) -> dict[str, Tensor]:
+        """
+        Compute losses.
+
+        Args:
+            head_outputs_reshape: reshaped head_outputs. ``head_output_reshape[self.cls_key]`` is a Tensor
+              sized (B, sum(HW(D)A), self.num_classes). ``head_output_reshape[self.box_reg_key]`` is a Tensor
+              sized (B, sum(HW(D)A), 2*self.spatial_dims)
+            targets: a list of dict. Each dict with two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image.
+            anchors: a list of Tensor. Each Tensor represents anchors for each image,
+                sized (sum(HWA), 2*spatial_dims) or (sum(HWDA), 2*spatial_dims).
+                A = self.num_anchors_per_loc.
+
+        Return:
+            a dict of several kinds of losses.
+        """
+        matched_idxs = self.compute_anchor_matched_idxs(anchors, targets, num_anchor_locs_per_level)
+        losses_cls = self.compute_cls_loss(head_outputs_reshape[self.cls_key], targets, matched_idxs)
+        losses_box_regression = self.compute_box_loss(
+            head_outputs_reshape[self.box_reg_key], targets, anchors, matched_idxs
+        )
+        return {self.cls_key: losses_cls, self.box_reg_key: losses_box_regression}
+
+    def compute_anchor_matched_idxs(
+        self, anchors: list[Tensor], targets: list[dict[str, Tensor]], num_anchor_locs_per_level: Sequence[int]
+    ) -> list[Tensor]:
+        """
+        Compute the matched indices between anchors and ground truth (gt) boxes in targets.
+        output[k][i] represents the matched gt index for anchor[i] in image k.
+        Suppose there are M gt boxes for image k. The range of it output[k][i] value is [-2, -1, 0, ..., M-1].
+        [0, M - 1] indicates this anchor is matched with a gt box,
+        while a negative value indicating that it is not matched.
+
+        Args:
+            anchors: a list of Tensor. Each Tensor represents anchors for each image,
+                sized (sum(HWA), 2*spatial_dims) or (sum(HWDA), 2*spatial_dims).
+                A = self.num_anchors_per_loc.
+            targets: a list of dict. Each dict with two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image.
+            num_anchor_locs_per_level: each element represents HW or HWD at this level.
+
+
+        Return:
+            a list of matched index `matched_idxs_per_image` (Tensor[int64]), Tensor sized (sum(HWA),) or (sum(HWDA),).
+            Suppose there are M gt boxes. `matched_idxs_per_image[i]` is a matched gt index in [0, M - 1]
+            or a negative value indicating that anchor i could not be matched.
+            BELOW_LOW_THRESHOLD = -1, BETWEEN_THRESHOLDS = -2
+        """
+        matched_idxs = []
+        for anchors_per_image, targets_per_image in zip(anchors, targets):
+            # anchors_per_image: Tensor, targets_per_image: Dice[str, Tensor]
+            if targets_per_image[self.target_box_key].numel() == 0:
+                # if no GT boxes
+                matched_idxs.append(
+                    torch.full((anchors_per_image.size(0),), -1, dtype=torch.int64, device=anchors_per_image.device)
+                )
+                continue
+
+            # matched_idxs_per_image (Tensor[int64]): Tensor sized (sum(HWA),) or (sum(HWDA),)
+            # Suppose there are M gt boxes. matched_idxs_per_image[i] is a matched gt index in [0, M - 1]
+            # or a negative value indicating that anchor i could not be matched.
+            # BELOW_LOW_THRESHOLD = -1, BETWEEN_THRESHOLDS = -2
+            if isinstance(self.proposal_matcher, Matcher):
+                # if torchvision matcher
+                match_quality_matrix = self.box_overlap_metric(
+                    targets_per_image[self.target_box_key].to(anchors_per_image.device), anchors_per_image
+                )
+                matched_idxs_per_image = self.proposal_matcher(match_quality_matrix)
+            elif isinstance(self.proposal_matcher, ATSSMatcher):
+                # if monai ATSS matcher
+                match_quality_matrix, matched_idxs_per_image = self.proposal_matcher(
+                    targets_per_image[self.target_box_key].to(anchors_per_image.device),
+                    anchors_per_image,
+                    num_anchor_locs_per_level,
+                    self.num_anchors_per_loc,
+                )
+            else:
+                raise NotImplementedError(
+                    "Currently support torchvision Matcher and monai ATSS matcher. Other types of matcher not supported. "
+                    "Please override self.compute_anchor_matched_idxs(*) for your own matcher."
+                )
+
+            if self.debug:
+                print(f"Max box overlap between anchors and gt boxes: {torch.max(match_quality_matrix,dim=1)[0]}.")
+
+            if torch.max(matched_idxs_per_image) < 0:
+                warnings.warn(
+                    f"No anchor is matched with GT boxes. Please adjust matcher setting, anchor setting,"
+                    " or the network setting to change zoom scale between network output and input images."
+                    f"GT boxes are {targets_per_image[self.target_box_key]}."
+                )
+
+            matched_idxs.append(matched_idxs_per_image)
+        return matched_idxs
+
+    def compute_cls_loss(
+        self, cls_logits: Tensor, targets: list[dict[str, Tensor]], matched_idxs: list[Tensor]
+    ) -> Tensor:
+        """
+        Compute classification losses.
+
+        Args:
+            cls_logits: classification logits, sized (B, sum(HW(D)A), self.num_classes)
+            targets: a list of dict. Each dict with two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image.
+            matched_idxs: a list of matched index. each element is sized (sum(HWA),) or  (sum(HWDA),)
+
+        Return:
+            classification losses.
+        """
+        total_cls_logits_list = []
+        total_gt_classes_target_list = []
+        for targets_per_image, cls_logits_per_image, matched_idxs_per_image in zip(targets, cls_logits, matched_idxs):
+            # for each image, get training samples
+            sampled_cls_logits_per_image, sampled_gt_classes_target = self.get_cls_train_sample_per_image(
+                cls_logits_per_image, targets_per_image, matched_idxs_per_image
+            )
+            total_cls_logits_list.append(sampled_cls_logits_per_image)
+            total_gt_classes_target_list.append(sampled_gt_classes_target)
+
+        total_cls_logits = torch.cat(total_cls_logits_list, dim=0)
+        total_gt_classes_target = torch.cat(total_gt_classes_target_list, dim=0)
+        losses: Tensor = self.cls_loss_func(total_cls_logits, total_gt_classes_target).to(total_cls_logits.dtype)
+        return losses
+
+    def compute_box_loss(
+        self,
+        box_regression: Tensor,
+        targets: list[dict[str, Tensor]],
+        anchors: list[Tensor],
+        matched_idxs: list[Tensor],
+    ) -> Tensor:
+        """
+        Compute box regression losses.
+
+        Args:
+            box_regression: box regression results, sized (B, sum(HWA), 2*self.spatial_dims)
+            targets: a list of dict. Each dict with two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image.
+            anchors: a list of Tensor. Each Tensor represents anchors for each image,
+                sized (sum(HWA), 2*spatial_dims) or (sum(HWDA), 2*spatial_dims).
+                A = self.num_anchors_per_loc.
+            matched_idxs: a list of matched index. each element is sized (sum(HWA),) or  (sum(HWDA),)
+
+        Return:
+            box regression losses.
+        """
+        total_box_regression_list = []
+        total_target_regression_list = []
+
+        for targets_per_image, box_regression_per_image, anchors_per_image, matched_idxs_per_image in zip(
+            targets, box_regression, anchors, matched_idxs
+        ):
+            # for each image, get training samples
+            decode_box_regression_per_image, matched_gt_boxes_per_image = self.get_box_train_sample_per_image(
+                box_regression_per_image, targets_per_image, anchors_per_image, matched_idxs_per_image
+            )
+            total_box_regression_list.append(decode_box_regression_per_image)
+            total_target_regression_list.append(matched_gt_boxes_per_image)
+
+        total_box_regression = torch.cat(total_box_regression_list, dim=0)
+        total_target_regression = torch.cat(total_target_regression_list, dim=0)
+
+        if total_box_regression.shape[0] == 0:
+            # if there is no training sample.
+            losses = torch.tensor(0.0)
+            return losses
+
+        losses = self.box_loss_func(total_box_regression, total_target_regression).to(total_box_regression.dtype)
+
+        return losses
+
+    def get_cls_train_sample_per_image(
+        self, cls_logits_per_image: Tensor, targets_per_image: dict[str, Tensor], matched_idxs_per_image: Tensor
+    ) -> tuple[Tensor, Tensor]:
+        """
+        Get samples from one image for classification losses computation.
+
+        Args:
+            cls_logits_per_image: classification logits for one image, (sum(HWA), self.num_classes)
+            targets_per_image: a dict with at least two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image.
+            matched_idxs_per_image: matched index, Tensor sized (sum(HWA),) or (sum(HWDA),)
+                Suppose there are M gt boxes. matched_idxs_per_image[i] is a matched gt index in [0, M - 1]
+                or a negative value indicating that anchor i could not be matched.
+                BELOW_LOW_THRESHOLD = -1, BETWEEN_THRESHOLDS = -2
+
+        Return:
+            paired predicted and GT samples from one image for classification losses computation
+        """
+
+        if torch.isnan(cls_logits_per_image).any() or torch.isinf(cls_logits_per_image).any():
+            if torch.is_grad_enabled():
+                raise ValueError("NaN or Inf in predicted classification logits.")
+            else:
+                warnings.warn("NaN or Inf in predicted classification logits.")
+
+        foreground_idxs_per_image = matched_idxs_per_image >= 0
+
+        num_foreground = int(foreground_idxs_per_image.sum())
+        num_gt_box = targets_per_image[self.target_box_key].shape[0]
+
+        if self.debug:
+            print(f"Number of positive (matched) anchors: {num_foreground}; Number of GT box: {num_gt_box}.")
+            if num_gt_box > 0 and num_foreground < 2 * num_gt_box:
+                print(
+                    f"Only {num_foreground} anchors are matched with {num_gt_box} GT boxes. "
+                    "Please consider adjusting matcher setting, anchor setting,"
+                    " or the network setting to change zoom scale between network output and input images."
+                )
+
+        # create the target classification with one-hot encoding
+        gt_classes_target = torch.zeros_like(cls_logits_per_image)  # (sum(HW(D)A), self.num_classes)
+        gt_classes_target[
+            foreground_idxs_per_image,  # fg anchor idx in
+            targets_per_image[self.target_label_key][
+                matched_idxs_per_image[foreground_idxs_per_image]
+            ],  # fg class label
+        ] = 1.0
+
+        if self.fg_bg_sampler is None:
+            # if no balanced sampling
+            valid_idxs_per_image = matched_idxs_per_image != self.proposal_matcher.BETWEEN_THRESHOLDS
+        else:
+            # The input of fg_bg_sampler: list of tensors containing -1, 0 or positive values.
+            # Each tensor corresponds to a specific image.
+            # -1 values are ignored, 0 are considered as negatives and > 0 as positives.
+
+            # matched_idxs_per_image (Tensor[int64]): an N tensor where N[i] is a matched gt in
+            # [0, M - 1] or a negative value indicating that prediction i could not
+            # be matched. BELOW_LOW_THRESHOLD = -1, BETWEEN_THRESHOLDS = -2
+            if isinstance(self.fg_bg_sampler, HardNegativeSampler):
+                max_cls_logits_per_image = torch.max(cls_logits_per_image.to(torch.float32), dim=1)[0]
+                sampled_pos_inds_list, sampled_neg_inds_list = self.fg_bg_sampler(
+                    [matched_idxs_per_image + 1], max_cls_logits_per_image
+                )
+            elif isinstance(self.fg_bg_sampler, BalancedPositiveNegativeSampler):
+                sampled_pos_inds_list, sampled_neg_inds_list = self.fg_bg_sampler([matched_idxs_per_image + 1])
+            else:
+                raise NotImplementedError(
+                    "Currently support torchvision BalancedPositiveNegativeSampler and monai HardNegativeSampler matcher. "
+                    "Other types of sampler not supported. "
+                    "Please override self.get_cls_train_sample_per_image(*) for your own sampler."
+                )
+
+            sampled_pos_inds = torch.where(torch.cat(sampled_pos_inds_list, dim=0))[0]
+            sampled_neg_inds = torch.where(torch.cat(sampled_neg_inds_list, dim=0))[0]
+            valid_idxs_per_image = torch.cat([sampled_pos_inds, sampled_neg_inds], dim=0)
+
+        return cls_logits_per_image[valid_idxs_per_image, :], gt_classes_target[valid_idxs_per_image, :]
+
+    def get_box_train_sample_per_image(
+        self,
+        box_regression_per_image: Tensor,
+        targets_per_image: dict[str, Tensor],
+        anchors_per_image: Tensor,
+        matched_idxs_per_image: Tensor,
+    ) -> tuple[Tensor, Tensor]:
+        """
+        Get samples from one image for box regression losses computation.
+
+        Args:
+            box_regression_per_image: box regression result for one image, (sum(HWA), 2*self.spatial_dims)
+            targets_per_image: a dict with at least two keys: self.target_box_key and self.target_label_key,
+                ground-truth boxes present in the image.
+            anchors_per_image: anchors of one image,
+                sized (sum(HWA), 2*spatial_dims) or (sum(HWDA), 2*spatial_dims).
+                A = self.num_anchors_per_loc.
+            matched_idxs_per_image: matched index, sized (sum(HWA),) or  (sum(HWDA),)
+
+        Return:
+            paired predicted and GT samples from one image for box regression losses computation
+        """
+
+        if torch.isnan(box_regression_per_image).any() or torch.isinf(box_regression_per_image).any():
+            if torch.is_grad_enabled():
+                raise ValueError("NaN or Inf in predicted box regression.")
+            else:
+                warnings.warn("NaN or Inf in predicted box regression.")
+
+        foreground_idxs_per_image = torch.where(matched_idxs_per_image >= 0)[0]
+        num_gt_box = targets_per_image[self.target_box_key].shape[0]
+
+        # if no GT box, return empty arrays
+        if num_gt_box == 0:
+            return box_regression_per_image[0:0, :], box_regression_per_image[0:0, :]
+
+        # select only the foreground boxes
+        # matched GT boxes for foreground anchors
+        matched_gt_boxes_per_image = targets_per_image[self.target_box_key][
+            matched_idxs_per_image[foreground_idxs_per_image]
+        ].to(box_regression_per_image.device)
+        # predicted box regression for foreground anchors
+        box_regression_per_image = box_regression_per_image[foreground_idxs_per_image, :]
+        # foreground anchors
+        anchors_per_image = anchors_per_image[foreground_idxs_per_image, :]
+
+        # encode GT boxes or decode predicted box regression before computing losses
+        matched_gt_boxes_per_image_ = matched_gt_boxes_per_image
+        box_regression_per_image_ = box_regression_per_image
+        if self.encode_gt:
+            matched_gt_boxes_per_image_ = self.box_coder.encode_single(matched_gt_boxes_per_image_, anchors_per_image)
+        if self.decode_pred:
+            box_regression_per_image_ = self.box_coder.decode_single(box_regression_per_image_, anchors_per_image)
+
+        return box_regression_per_image_, matched_gt_boxes_per_image_
+
+
+def retinanet_resnet50_fpn_detector(
+    num_classes: int,
+    anchor_generator: AnchorGenerator,
+    returned_layers: Sequence[int] = (1, 2, 3),
+    pretrained: bool = False,
+    progress: bool = True,
+    **kwargs: Any,
+) -> RetinaNetDetector:
+    """
+    Returns a RetinaNet detector using a ResNet-50 as backbone, which can be pretrained
+    from `Med3D: Transfer Learning for 3D Medical Image Analysis <https://arxiv.org/pdf/1904.00625.pdf>`
+    _.
+
+    Args:
+        num_classes: number of output classes of the model (excluding the background).
+        anchor_generator: AnchorGenerator,
+        returned_layers: returned layers to extract feature maps. Each returned layer should be in the range [1,4].
+            len(returned_layers)+1 will be the number of extracted feature maps.
+            There is an extra maxpooling layer LastLevelMaxPool() appended.
+        pretrained: If True, returns a backbone pre-trained on 23 medical datasets
+        progress: If True, displays a progress bar of the download to stderr
+
+    Return:
+        A RetinaNetDetector object with resnet50 as backbone
+
+    Example:
+
+        .. code-block:: python
+
+            # define a naive network
+            resnet_param = {
+                "pretrained": False,
+                "spatial_dims": 3,
+                "n_input_channels": 2,
+                "num_classes": 3,
+                "conv1_t_size": 7,
+                "conv1_t_stride": (2, 2, 2)
+            }
+            returned_layers = [1]
+            anchor_generator = monai.apps.detection.utils.anchor_utils.AnchorGeneratorWithAnchorShape(
+                feature_map_scales=(1, 2), base_anchor_shapes=((8,) * resnet_param["spatial_dims"])
+            )
+            detector = retinanet_resnet50_fpn_detector(
+                **resnet_param, anchor_generator=anchor_generator, returned_layers=returned_layers
+            )
+    """
+
+    backbone = resnet.resnet50(pretrained, progress, **kwargs)
+    spatial_dims = len(backbone.conv1.stride)
+    # number of output feature maps is len(returned_layers)+1
+    feature_extractor = resnet_fpn_feature_extractor(
+        backbone=backbone,
+        spatial_dims=spatial_dims,
+        pretrained_backbone=pretrained,
+        trainable_backbone_layers=None,
+        returned_layers=returned_layers,
+    )
+    num_anchors = anchor_generator.num_anchors_per_location()[0]
+    size_divisible = [s * 2 * 2 ** max(returned_layers) for s in feature_extractor.body.conv1.stride]
+    network = RetinaNet(
+        spatial_dims=spatial_dims,
+        num_classes=num_classes,
+        num_anchors=num_anchors,
+        feature_extractor=feature_extractor,
+        size_divisible=size_divisible,
+    )
+    return RetinaNetDetector(network, anchor_generator)

source_code/SegMamba/monai/apps/detection/transforms/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/detection/transforms/array.py

@@ -0,0 +1,564 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+A collection of "vanilla" transforms for box operations
+https://github.com/Project-MONAI/MONAI/wiki/MONAI_Design
+"""
+
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+import numpy as np
+import torch
+
+from monai.config.type_definitions import DtypeLike, NdarrayOrTensor, NdarrayTensor
+from monai.data.box_utils import (
+    BoxMode,
+    clip_boxes_to_image,
+    convert_box_mode,
+    convert_box_to_standard_mode,
+    get_spatial_dims,
+    spatial_crop_boxes,
+    standardize_empty_box,
+)
+from monai.transforms import Rotate90, SpatialCrop
+from monai.transforms.transform import Transform
+from monai.utils import ensure_tuple, ensure_tuple_rep, fall_back_tuple, look_up_option
+from monai.utils.enums import TransformBackends
+
+from .box_ops import (
+    apply_affine_to_boxes,
+    convert_box_to_mask,
+    convert_mask_to_box,
+    flip_boxes,
+    resize_boxes,
+    rot90_boxes,
+    select_labels,
+    zoom_boxes,
+)
+
+__all__ = [
+    "StandardizeEmptyBox",
+    "ConvertBoxToStandardMode",
+    "ConvertBoxMode",
+    "AffineBox",
+    "ZoomBox",
+    "ResizeBox",
+    "FlipBox",
+    "ClipBoxToImage",
+    "BoxToMask",
+    "MaskToBox",
+    "SpatialCropBox",
+    "RotateBox90",
+]
+
+
+class StandardizeEmptyBox(Transform):
+    """
+    When boxes are empty, this transform standardize it to shape of (0,4) or (0,6).
+
+    Args:
+        spatial_dims: number of spatial dimensions of the bounding boxes.
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(self, spatial_dims: int) -> None:
+        self.spatial_dims = spatial_dims
+
+    def __call__(self, boxes: NdarrayOrTensor) -> NdarrayOrTensor:
+        """
+        Args:
+            boxes: source bounding boxes, Nx4 or Nx6 or 0xM torch tensor or ndarray.
+        """
+        return standardize_empty_box(boxes, spatial_dims=self.spatial_dims)
+
+
+class ConvertBoxMode(Transform):
+    """
+    This transform converts the boxes in src_mode to the dst_mode.
+
+    Args:
+        src_mode: source box mode. If it is not given, this func will assume it is ``StandardMode()``.
+        dst_mode: target box mode. If it is not given, this func will assume it is ``StandardMode()``.
+
+    Note:
+        ``StandardMode`` = :class:`~monai.data.box_utils.CornerCornerModeTypeA`,
+        also represented as "xyxy" for 2D and "xyzxyz" for 3D.
+
+        src_mode and dst_mode can be:
+            #. str: choose from :class:`~monai.utils.enums.BoxModeName`, for example,
+                - "xyxy": boxes has format [xmin, ymin, xmax, ymax]
+                - "xyzxyz": boxes has format [xmin, ymin, zmin, xmax, ymax, zmax]
+                - "xxyy": boxes has format [xmin, xmax, ymin, ymax]
+                - "xxyyzz": boxes has format [xmin, xmax, ymin, ymax, zmin, zmax]
+                - "xyxyzz": boxes has format [xmin, ymin, xmax, ymax, zmin, zmax]
+                - "xywh": boxes has format [xmin, ymin, xsize, ysize]
+                - "xyzwhd": boxes has format [xmin, ymin, zmin, xsize, ysize, zsize]
+                - "ccwh": boxes has format [xcenter, ycenter, xsize, ysize]
+                - "cccwhd": boxes has format [xcenter, ycenter, zcenter, xsize, ysize, zsize]
+            #. BoxMode class: choose from the subclasses of :class:`~monai.data.box_utils.BoxMode`, for example,
+                - CornerCornerModeTypeA: equivalent to "xyxy" or "xyzxyz"
+                - CornerCornerModeTypeB: equivalent to "xxyy" or "xxyyzz"
+                - CornerCornerModeTypeC: equivalent to "xyxy" or "xyxyzz"
+                - CornerSizeMode: equivalent to "xywh" or "xyzwhd"
+                - CenterSizeMode: equivalent to "ccwh" or "cccwhd"
+            #. BoxMode object: choose from the subclasses of :class:`~monai.data.box_utils.BoxMode`, for example,
+                - CornerCornerModeTypeA(): equivalent to "xyxy" or "xyzxyz"
+                - CornerCornerModeTypeB(): equivalent to "xxyy" or "xxyyzz"
+                - CornerCornerModeTypeC(): equivalent to "xyxy" or "xyxyzz"
+                - CornerSizeMode(): equivalent to "xywh" or "xyzwhd"
+                - CenterSizeMode(): equivalent to "ccwh" or "cccwhd"
+            #. None: will assume mode is ``StandardMode()``
+
+    Example:
+        .. code-block:: python
+
+            boxes = torch.ones(10,4)
+            # convert boxes with format [xmin, ymin, xmax, ymax] to [xcenter, ycenter, xsize, ysize].
+            box_converter = ConvertBoxMode(src_mode="xyxy", dst_mode="ccwh")
+            box_converter(boxes)
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(
+        self,
+        src_mode: str | BoxMode | type[BoxMode] | None = None,
+        dst_mode: str | BoxMode | type[BoxMode] | None = None,
+    ) -> None:
+        self.src_mode = src_mode
+        self.dst_mode = dst_mode
+
+    def __call__(self, boxes: NdarrayOrTensor) -> NdarrayOrTensor:
+        """
+        Converts the boxes in src_mode to the dst_mode.
+
+        Args:
+            boxes: source bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+
+        Returns:
+            bounding boxes with target mode, with same data type as ``boxes``, does not share memory with ``boxes``
+        """
+        return convert_box_mode(boxes, src_mode=self.src_mode, dst_mode=self.dst_mode)
+
+
+class ConvertBoxToStandardMode(Transform):
+    """
+    Convert given boxes to standard mode.
+    Standard mode is "xyxy" or "xyzxyz",
+    representing box format of [xmin, ymin, xmax, ymax] or [xmin, ymin, zmin, xmax, ymax, zmax].
+
+    Args:
+        mode: source box mode. If it is not given, this func will assume it is ``StandardMode()``.
+            It follows the same format with ``src_mode`` in :class:`~monai.apps.detection.transforms.array.ConvertBoxMode` .
+
+    Example:
+        .. code-block:: python
+
+            boxes = torch.ones(10,6)
+            # convert boxes with format [xmin, xmax, ymin, ymax, zmin, zmax] to [xmin, ymin, zmin, xmax, ymax, zmax]
+            box_converter = ConvertBoxToStandardMode(mode="xxyyzz")
+            box_converter(boxes)
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(self, mode: str | BoxMode | type[BoxMode] | None = None) -> None:
+        self.mode = mode
+
+    def __call__(self, boxes: NdarrayOrTensor) -> NdarrayOrTensor:
+        """
+        Convert given boxes to standard mode.
+        Standard mode is "xyxy" or "xyzxyz",
+        representing box format of [xmin, ymin, xmax, ymax] or [xmin, ymin, zmin, xmax, ymax, zmax].
+
+        Args:
+            boxes: source bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+
+        Returns:
+            bounding boxes with standard mode, with same data type as ``boxes``, does not share memory with ``boxes``
+        """
+        return convert_box_to_standard_mode(boxes, mode=self.mode)
+
+
+class AffineBox(Transform):
+    """
+    Applies affine matrix to the boxes
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __call__(self, boxes: NdarrayOrTensor, affine: NdarrayOrTensor | None) -> NdarrayOrTensor:  # type: ignore
+        """
+        Args:
+            boxes: source bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            affine: affine matrix to be applied to the box coordinate
+        """
+        if affine is None:
+            return boxes
+
+        return apply_affine_to_boxes(boxes, affine=affine)
+
+
+class ZoomBox(Transform):
+    """
+    Zooms an ND Box with same padding or slicing setting with Zoom().
+
+    Args:
+        zoom: The zoom factor along the spatial axes.
+            If a float, zoom is the same for each spatial axis.
+            If a sequence, zoom should contain one value for each spatial axis.
+        keep_size: Should keep original size (padding/slicing if needed), default is True.
+        kwargs: other arguments for the `np.pad` or `torch.pad` function.
+            note that `np.pad` treats channel dimension as the first dimension.
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(self, zoom: Sequence[float] | float, keep_size: bool = False, **kwargs: Any) -> None:
+        self.zoom = zoom
+        self.keep_size = keep_size
+        self.kwargs = kwargs
+
+    def __call__(self, boxes: NdarrayTensor, src_spatial_size: Sequence[int] | int | None = None) -> NdarrayTensor:
+        """
+        Args:
+            boxes: source bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            src_spatial_size: original image spatial size before zooming, used only when keep_size=True.
+        """
+        spatial_dims: int = get_spatial_dims(boxes=boxes)
+        self._zoom = ensure_tuple_rep(self.zoom, spatial_dims)  # match the spatial image dim
+
+        if not self.keep_size:
+            return zoom_boxes(boxes, self._zoom)
+
+        if src_spatial_size is None:
+            raise ValueError("keep_size=True, src_spatial_size must be provided.")
+
+        src_spatial_size = ensure_tuple_rep(src_spatial_size, spatial_dims)
+        dst_spatial_size = [int(round(z * ss)) for z, ss in zip(self._zoom, src_spatial_size)]
+        self._zoom = tuple(ds / float(ss) for ss, ds in zip(src_spatial_size, dst_spatial_size))
+        zoomed_boxes = zoom_boxes(boxes, self._zoom)
+
+        # See also keep_size in monai.transforms.spatial.array.Zoom()
+        if not np.allclose(np.array(src_spatial_size), np.array(dst_spatial_size)):
+            for axis, (od, zd) in enumerate(zip(src_spatial_size, dst_spatial_size)):
+                diff = od - zd
+                half = abs(diff) // 2
+                if diff > 0:  # need padding (half, diff - half)
+                    zoomed_boxes[:, axis] = zoomed_boxes[:, axis] + half
+                    zoomed_boxes[:, axis + spatial_dims] = zoomed_boxes[:, axis + spatial_dims] + half
+                elif diff < 0:  # need slicing (half, half + od)
+                    zoomed_boxes[:, axis] = zoomed_boxes[:, axis] - half
+                    zoomed_boxes[:, axis + spatial_dims] = zoomed_boxes[:, axis + spatial_dims] - half
+        return zoomed_boxes
+
+
+class ResizeBox(Transform):
+    """
+    Resize the input boxes when the corresponding image is
+    resized to given spatial size (with scaling, not cropping/padding).
+
+    Args:
+        spatial_size: expected shape of spatial dimensions after resize operation.
+            if some components of the `spatial_size` are non-positive values, the transform will use the
+            corresponding components of img size. For example, `spatial_size=(32, -1)` will be adapted
+            to `(32, 64)` if the second spatial dimension size of img is `64`.
+        size_mode: should be "all" or "longest", if "all", will use `spatial_size` for all the spatial dims,
+            if "longest", rescale the image so that only the longest side is equal to specified `spatial_size`,
+            which must be an int number in this case, keeping the aspect ratio of the initial image, refer to:
+            https://albumentations.ai/docs/api_reference/augmentations/geometric/resize/
+            #albumentations.augmentations.geometric.resize.LongestMaxSize.
+        kwargs: other arguments for the `np.pad` or `torch.pad` function.
+            note that `np.pad` treats channel dimension as the first dimension.
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(self, spatial_size: Sequence[int] | int, size_mode: str = "all", **kwargs: Any) -> None:
+        self.size_mode = look_up_option(size_mode, ["all", "longest"])
+        self.spatial_size = spatial_size
+
+    def __call__(self, boxes: NdarrayOrTensor, src_spatial_size: Sequence[int] | int) -> NdarrayOrTensor:  # type: ignore[override]
+        """
+        Args:
+            boxes: source bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            src_spatial_size: original image spatial size before resizing.
+
+        Raises:
+            ValueError: When ``self.spatial_size`` length is less than ``boxes`` spatial dimensions.
+        """
+        input_ndim = get_spatial_dims(boxes=boxes)  # spatial ndim
+        src_spatial_size_ = ensure_tuple_rep(src_spatial_size, input_ndim)
+
+        if self.size_mode == "all":
+            # spatial_size must be a Sequence if size_mode is 'all'
+            output_ndim = len(ensure_tuple(self.spatial_size))
+            if output_ndim != input_ndim:
+                raise ValueError(
+                    "len(spatial_size) must be greater or equal to img spatial dimensions, "
+                    f"got spatial_size={output_ndim} img={input_ndim}."
+                )
+            spatial_size_ = fall_back_tuple(self.spatial_size, src_spatial_size_)
+        else:  # for the "longest" mode
+            if not isinstance(self.spatial_size, int):
+                raise ValueError("spatial_size must be an int number if size_mode is 'longest'.")
+            scale = self.spatial_size / max(src_spatial_size_)
+            spatial_size_ = tuple(int(round(s * scale)) for s in src_spatial_size_)
+
+        return resize_boxes(boxes, src_spatial_size_, spatial_size_)
+
+
+class FlipBox(Transform):
+    """
+    Reverses the box coordinates along the given spatial axis. Preserves shape.
+
+    Args:
+        spatial_axis: spatial axes along which to flip over. Default is None.
+            The default `axis=None` will flip over all of the axes of the input array.
+            If axis is negative it counts from the last to the first axis.
+            If axis is a tuple of ints, flipping is performed on all of the axes
+            specified in the tuple.
+
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(self, spatial_axis: Sequence[int] | int | None = None) -> None:
+        self.spatial_axis = spatial_axis
+
+    def __call__(self, boxes: NdarrayOrTensor, spatial_size: Sequence[int] | int):  # type: ignore
+        """
+        Args:
+            boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            spatial_size: image spatial size.
+        """
+
+        return flip_boxes(boxes, spatial_size=spatial_size, flip_axes=self.spatial_axis)
+
+
+class ClipBoxToImage(Transform):
+    """
+    Clip the bounding boxes and the associated labels/scores to make sure they are within the image.
+    There might be multiple arrays of labels/scores associated with one array of boxes.
+
+    Args:
+        remove_empty: whether to remove the boxes and corresponding labels that are actually empty
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(self, remove_empty: bool = False) -> None:
+        self.remove_empty = remove_empty
+
+    def __call__(  # type: ignore
+        self,
+        boxes: NdarrayOrTensor,
+        labels: Sequence[NdarrayOrTensor] | NdarrayOrTensor,
+        spatial_size: Sequence[int] | int,
+    ) -> tuple[NdarrayOrTensor, tuple | NdarrayOrTensor]:
+        """
+        Args:
+            boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            labels: Sequence of array. Each element represents classification labels or scores
+                corresponding to ``boxes``, sized (N,).
+            spatial_size: The spatial size of the image where the boxes are attached. len(spatial_size) should be in [2, 3].
+
+        Returns:
+            - clipped boxes, does not share memory with original boxes
+            - clipped labels, does not share memory with original labels
+
+        Example:
+            .. code-block:: python
+
+                box_clipper = ClipBoxToImage(remove_empty=True)
+                boxes = torch.ones(2, 6)
+                class_labels = torch.Tensor([0, 1])
+                pred_scores = torch.Tensor([[0.4,0.3,0.3], [0.5,0.1,0.4]])
+                labels = (class_labels, pred_scores)
+                spatial_size = [32, 32, 32]
+                boxes_clip, labels_clip_tuple = box_clipper(boxes, labels, spatial_size)
+        """
+        spatial_dims: int = get_spatial_dims(boxes=boxes)
+        spatial_size = ensure_tuple_rep(spatial_size, spatial_dims)  # match the spatial image dim
+
+        boxes_clip, keep = clip_boxes_to_image(boxes, spatial_size, self.remove_empty)
+        return boxes_clip, select_labels(labels, keep)
+
+
+class BoxToMask(Transform):
+    """
+    Convert box to int16 mask image, which has the same size with the input image.
+
+    Args:
+        bg_label: background labels for the output mask image, make sure it is smaller than any foreground(fg) labels.
+        ellipse_mask: bool.
+
+            - If True, it assumes the object shape is close to ellipse or ellipsoid.
+            - If False, it assumes the object shape is close to rectangle or cube and well occupies the bounding box.
+            - If the users are going to apply random rotation as data augmentation, we suggest setting ellipse_mask=True
+              See also Kalra et al. "Towards Rotation Invariance in Object Detection", ICCV 2021.
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(self, bg_label: int = -1, ellipse_mask: bool = False) -> None:
+        self.bg_label = bg_label
+        self.ellipse_mask = ellipse_mask
+
+    def __call__(  # type: ignore
+        self, boxes: NdarrayOrTensor, labels: NdarrayOrTensor, spatial_size: Sequence[int] | int
+    ) -> NdarrayOrTensor:
+        """
+        Args:
+            boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``.
+            labels: classification foreground(fg) labels corresponding to `boxes`, dtype should be int, sized (N,).
+            spatial_size: image spatial size.
+
+        Return:
+            - int16 array, sized (num_box, H, W). Each channel represents a box.
+                The foreground region in channel c has intensity of labels[c].
+                The background intensity is bg_label.
+        """
+        return convert_box_to_mask(boxes, labels, spatial_size, self.bg_label, self.ellipse_mask)
+
+
+class MaskToBox(Transform):
+    """
+    Convert int16 mask image to box, which has the same size with the input image.
+    Pairs with :py:class:`monai.apps.detection.transforms.array.BoxToMask`.
+    Please make sure the same ``min_fg_label`` is used when using the two transforms in pairs.
+
+    Args:
+        bg_label: background labels for the output mask image, make sure it is smaller than any foreground(fg) labels.
+        box_dtype: output dtype for boxes
+        label_dtype: output dtype for labels
+    """
+
+    backend = [TransformBackends.NUMPY]
+
+    def __init__(
+        self,
+        bg_label: int = -1,
+        box_dtype: DtypeLike | torch.dtype = torch.float32,
+        label_dtype: DtypeLike | torch.dtype = torch.long,
+    ) -> None:
+        self.bg_label = bg_label
+        self.box_dtype = box_dtype
+        self.label_dtype = label_dtype
+
+    def __call__(self, boxes_mask: NdarrayOrTensor) -> tuple[NdarrayOrTensor, NdarrayOrTensor]:
+        """
+        Args:
+            boxes_mask: int16 array, sized (num_box, H, W). Each channel represents a box.
+                The foreground region in channel c has intensity of labels[c].
+                The background intensity is bg_label.
+
+        Return:
+            - bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``.
+            - classification foreground(fg) labels, dtype should be int, sized (N,).
+        """
+        return convert_mask_to_box(boxes_mask, self.bg_label, self.box_dtype, self.label_dtype)
+
+
+class SpatialCropBox(SpatialCrop):
+    """
+    General purpose box cropper when the corresponding image is cropped by SpatialCrop(*) with the same ROI.
+    The difference is that we do not support negative indexing for roi_slices.
+
+    If a dimension of the expected ROI size is bigger than the input image size, will not crop that dimension.
+    So the cropped result may be smaller than the expected ROI, and the cropped results of several images may
+    not have exactly the same shape.
+    It can support to crop ND spatial boxes.
+
+    The cropped region can be parameterised in various ways:
+        - a list of slices for each spatial dimension (do not allow for use of negative indexing)
+        - a spatial center and size
+        - the start and end coordinates of the ROI
+
+    Args:
+        roi_center: voxel coordinates for center of the crop ROI.
+        roi_size: size of the crop ROI, if a dimension of ROI size is bigger than image size,
+            will not crop that dimension of the image.
+        roi_start: voxel coordinates for start of the crop ROI.
+        roi_end: voxel coordinates for end of the crop ROI, if a coordinate is out of image,
+            use the end coordinate of image.
+        roi_slices: list of slices for each of the spatial dimensions.
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __init__(
+        self,
+        roi_center: Sequence[int] | NdarrayOrTensor | None = None,
+        roi_size: Sequence[int] | NdarrayOrTensor | None = None,
+        roi_start: Sequence[int] | NdarrayOrTensor | None = None,
+        roi_end: Sequence[int] | NdarrayOrTensor | None = None,
+        roi_slices: Sequence[slice] | None = None,
+    ) -> None:
+        super().__init__(roi_center, roi_size, roi_start, roi_end, roi_slices)
+        for s in self.slices:
+            if s.start < 0 or s.stop < 0 or (s.step is not None and s.step < 0):
+                raise ValueError("Currently negative indexing is not supported for SpatialCropBox.")
+
+    def __call__(  # type: ignore[override]
+        self, boxes: NdarrayTensor, labels: Sequence[NdarrayOrTensor] | NdarrayOrTensor
+    ) -> tuple[NdarrayTensor, tuple | NdarrayOrTensor]:
+        """
+        Args:
+            boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            labels: Sequence of array. Each element represents classification labels or scores
+
+        Returns:
+            - cropped boxes, does not share memory with original boxes
+            - cropped labels, does not share memory with original labels
+
+        Example:
+            .. code-block:: python
+
+                box_cropper = SpatialCropPadBox(roi_start=[0, 1, 4], roi_end=[21, 15, 8])
+                boxes = torch.ones(2, 6)
+                class_labels = torch.Tensor([0, 1])
+                pred_scores = torch.Tensor([[0.4,0.3,0.3], [0.5,0.1,0.4]])
+                labels = (class_labels, pred_scores)
+                boxes_crop, labels_crop_tuple = box_cropper(boxes, labels)
+        """
+        spatial_dims = min(len(self.slices), get_spatial_dims(boxes=boxes))  # spatial dims
+        boxes_crop, keep = spatial_crop_boxes(
+            boxes,
+            [self.slices[axis].start for axis in range(spatial_dims)],
+            [self.slices[axis].stop for axis in range(spatial_dims)],
+        )
+        return boxes_crop, select_labels(labels, keep)
+
+
+class RotateBox90(Rotate90):
+    """
+    Rotate a boxes by 90 degrees in the plane specified by `axes`.
+    See box_ops.rot90_boxes for additional details
+
+    Args:
+        k: number of times to rotate by 90 degrees.
+        spatial_axes: 2 int numbers, defines the plane to rotate with 2 spatial axes.
+            Default: (0, 1), this is the first two axis in spatial dimensions.
+            If axis is negative it counts from the last to the first axis.
+    """
+
+    backend = [TransformBackends.TORCH, TransformBackends.NUMPY]
+
+    def __call__(self, boxes: NdarrayTensor, spatial_size: Sequence[int] | int) -> NdarrayTensor:  # type: ignore[override]
+        """
+        Args:
+            img: channel first array, must have shape: (num_channels, H[, W, ..., ]),
+        """
+        return rot90_boxes(boxes, spatial_size, self.k, self.spatial_axes)

source_code/SegMamba/monai/apps/detection/transforms/box_ops.py

@@ -0,0 +1,435 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from copy import deepcopy
+
+import numpy as np
+import torch
+
+from monai.config.type_definitions import DtypeLike, NdarrayOrTensor, NdarrayTensor
+from monai.data.box_utils import COMPUTE_DTYPE, TO_REMOVE, get_spatial_dims
+from monai.transforms import Resize
+from monai.transforms.utils import create_scale
+from monai.utils import look_up_option
+from monai.utils.misc import ensure_tuple, ensure_tuple_rep
+from monai.utils.type_conversion import convert_data_type, convert_to_dst_type
+
+
+def _apply_affine_to_points(points: torch.Tensor, affine: torch.Tensor, include_shift: bool = True) -> torch.Tensor:
+    """
+    This internal function applies affine matrices to the point coordinate
+
+    Args:
+        points: point coordinates, Nx2 or Nx3 torch tensor or ndarray, representing [x, y] or [x, y, z]
+        affine: affine matrix to be applied to the point coordinates, sized (spatial_dims+1,spatial_dims+1)
+        include_shift: default True, whether the function apply translation (shift) in the affine transform
+
+    Returns:
+        transformed point coordinates, with same data type as ``points``, does not share memory with ``points``
+    """
+
+    spatial_dims = get_spatial_dims(points=points)
+
+    # compute new points
+    if include_shift:
+        # append 1 to form Nx(spatial_dims+1) vector, then transpose
+        points_affine = torch.cat(
+            [points, torch.ones(points.shape[0], 1, device=points.device, dtype=points.dtype)], dim=1
+        ).transpose(0, 1)
+        # apply affine
+        points_affine = torch.matmul(affine, points_affine)
+        # remove appended 1 and transpose back
+        points_affine = points_affine[:spatial_dims, :].transpose(0, 1)
+    else:
+        points_affine = points.transpose(0, 1)
+        points_affine = torch.matmul(affine[:spatial_dims, :spatial_dims], points_affine)
+        points_affine = points_affine.transpose(0, 1)
+
+    return points_affine
+
+
+def apply_affine_to_boxes(boxes: NdarrayTensor, affine: NdarrayOrTensor) -> NdarrayTensor:
+    """
+    This function applies affine matrices to the boxes
+
+    Args:
+        boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be StandardMode
+        affine: affine matrix to be applied to the box coordinates, sized (spatial_dims+1,spatial_dims+1)
+
+    Returns:
+        returned affine transformed boxes, with same data type as ``boxes``, does not share memory with ``boxes``
+    """
+
+    # convert numpy to tensor if needed
+    boxes_t, *_ = convert_data_type(boxes, torch.Tensor)
+
+    # some operation does not support torch.float16
+    # convert to float32
+
+    boxes_t = boxes_t.to(dtype=COMPUTE_DTYPE)
+    affine_t, *_ = convert_to_dst_type(src=affine, dst=boxes_t)
+
+    spatial_dims = get_spatial_dims(boxes=boxes_t)
+
+    # affine transform left top and bottom right points
+    # might flipped, thus lt may not be left top any more
+    lt: torch.Tensor = _apply_affine_to_points(boxes_t[:, :spatial_dims], affine_t, include_shift=True)
+    rb: torch.Tensor = _apply_affine_to_points(boxes_t[:, spatial_dims:], affine_t, include_shift=True)
+
+    # make sure lt_new is left top, and rb_new is bottom right
+    lt_new, _ = torch.min(torch.stack([lt, rb], dim=2), dim=2)
+    rb_new, _ = torch.max(torch.stack([lt, rb], dim=2), dim=2)
+
+    boxes_t_affine = torch.cat([lt_new, rb_new], dim=1)
+
+    # convert tensor back to numpy if needed
+    boxes_affine: NdarrayOrTensor
+    boxes_affine, *_ = convert_to_dst_type(src=boxes_t_affine, dst=boxes)
+    return boxes_affine  # type: ignore[return-value]
+
+
+def zoom_boxes(boxes: NdarrayTensor, zoom: Sequence[float] | float) -> NdarrayTensor:
+    """
+    Zoom boxes
+
+    Args:
+        boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be StandardMode
+        zoom: The zoom factor along the spatial axes.
+            If a float, zoom is the same for each spatial axis.
+            If a sequence, zoom should contain one value for each spatial axis.
+
+    Returns:
+        zoomed boxes, with same data type as ``boxes``, does not share memory with ``boxes``
+
+    Example:
+        .. code-block:: python
+
+            boxes = torch.ones(1,4)
+            zoom_boxes(boxes, zoom=[0.5,2.2]) #  will return tensor([[0.5, 2.2, 0.5, 2.2]])
+    """
+    spatial_dims = get_spatial_dims(boxes=boxes)
+
+    # generate affine transform corresponding to ``zoom``
+    affine = create_scale(spatial_dims=spatial_dims, scaling_factor=zoom)
+
+    return apply_affine_to_boxes(boxes=boxes, affine=affine)
+
+
+def resize_boxes(
+    boxes: NdarrayOrTensor, src_spatial_size: Sequence[int] | int, dst_spatial_size: Sequence[int] | int
+) -> NdarrayOrTensor:
+    """
+    Resize boxes when the corresponding image is resized
+
+    Args:
+        boxes: source bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+        src_spatial_size: source image spatial size.
+        dst_spatial_size: target image spatial size.
+
+    Returns:
+        resized boxes, with same data type as ``boxes``, does not share memory with ``boxes``
+
+    Example:
+        .. code-block:: python
+
+            boxes = torch.ones(1,4)
+            src_spatial_size = [100, 100]
+            dst_spatial_size = [128, 256]
+            resize_boxes(boxes, src_spatial_size, dst_spatial_size) #  will return tensor([[1.28, 2.56, 1.28, 2.56]])
+    """
+    spatial_dims: int = get_spatial_dims(boxes=boxes)
+
+    src_spatial_size = ensure_tuple_rep(src_spatial_size, spatial_dims)
+    dst_spatial_size = ensure_tuple_rep(dst_spatial_size, spatial_dims)
+
+    zoom = [dst_spatial_size[axis] / float(src_spatial_size[axis]) for axis in range(spatial_dims)]
+
+    return zoom_boxes(boxes=boxes, zoom=zoom)
+
+
+def flip_boxes(
+    boxes: NdarrayTensor, spatial_size: Sequence[int] | int, flip_axes: Sequence[int] | int | None = None
+) -> NdarrayTensor:
+    """
+    Flip boxes when the corresponding image is flipped
+
+    Args:
+        boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+        spatial_size: image spatial size.
+        flip_axes: spatial axes along which to flip over. Default is None.
+            The default `axis=None` will flip over all of the axes of the input array.
+            If axis is negative it counts from the last to the first axis.
+            If axis is a tuple of ints, flipping is performed on all of the axes
+            specified in the tuple.
+
+    Returns:
+        flipped boxes, with same data type as ``boxes``, does not share memory with ``boxes``
+    """
+    spatial_dims: int = get_spatial_dims(boxes=boxes)
+    spatial_size = ensure_tuple_rep(spatial_size, spatial_dims)
+    if flip_axes is None:
+        flip_axes = tuple(range(0, spatial_dims))
+    flip_axes = ensure_tuple(flip_axes)
+
+    # flip box
+    _flip_boxes: NdarrayTensor = boxes.clone() if isinstance(boxes, torch.Tensor) else deepcopy(boxes)  # type: ignore[assignment]
+
+    for axis in flip_axes:
+        _flip_boxes[:, axis + spatial_dims] = spatial_size[axis] - boxes[:, axis] - TO_REMOVE
+        _flip_boxes[:, axis] = spatial_size[axis] - boxes[:, axis + spatial_dims] - TO_REMOVE
+
+    return _flip_boxes
+
+
+def convert_box_to_mask(
+    boxes: NdarrayOrTensor,
+    labels: NdarrayOrTensor,
+    spatial_size: Sequence[int] | int,
+    bg_label: int = -1,
+    ellipse_mask: bool = False,
+) -> NdarrayOrTensor:
+    """
+    Convert box to int16 mask image, which has the same size with the input image.
+
+    Args:
+        boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``.
+        labels: classification foreground(fg) labels corresponding to `boxes`, dtype should be int, sized (N,).
+        spatial_size: image spatial size.
+        bg_label: background labels for the output mask image, make sure it is smaller than any fg labels.
+        ellipse_mask: bool.
+
+            - If True, it assumes the object shape is close to ellipse or ellipsoid.
+            - If False, it assumes the object shape is close to rectangle or cube and well occupies the bounding box.
+            - If the users are going to apply random rotation as data augmentation, we suggest setting ellipse_mask=True
+              See also Kalra et al. "Towards Rotation Invariance in Object Detection", ICCV 2021.
+
+    Return:
+        - int16 array, sized (num_box, H, W). Each channel represents a box.
+            The foreground region in channel c has intensity of labels[c].
+            The background intensity is bg_label.
+    """
+    spatial_dims: int = get_spatial_dims(boxes=boxes)
+    spatial_size = ensure_tuple_rep(spatial_size, spatial_dims)
+
+    # if no box, return empty mask
+    if labels.shape[0] == 0:
+        boxes_mask_np = np.ones((1,) + spatial_size, dtype=np.int16) * np.int16(bg_label)
+        boxes_mask, *_ = convert_to_dst_type(src=boxes_mask_np, dst=boxes, dtype=torch.int16)
+        return boxes_mask
+
+    # bg_label should be smaller than labels
+    if bg_label >= min(labels):
+        raise ValueError(
+            f"bg_label should be smaller than any foreground box labels.\n"
+            f"min(labels)={min(labels)}, while bg_label={bg_label}"
+        )
+
+    if labels.shape[0] != boxes.shape[0]:
+        raise ValueError("Number of labels should equal to number of boxes.")
+
+    # allocate memory for boxes_mask_np
+    boxes_mask_np = np.ones((labels.shape[0],) + spatial_size, dtype=np.int16) * np.int16(bg_label)
+
+    boxes_np: np.ndarray = convert_data_type(boxes, np.ndarray, dtype=np.int32)[0]
+    if np.any(boxes_np[:, spatial_dims:] > np.array(spatial_size)):
+        raise ValueError("Some boxes are larger than the image.")
+
+    labels_np, *_ = convert_to_dst_type(src=labels, dst=boxes_np)
+    for b in range(boxes_np.shape[0]):
+        # generate a foreground mask
+        box_size = [boxes_np[b, axis + spatial_dims] - boxes_np[b, axis] for axis in range(spatial_dims)]
+        if ellipse_mask:
+            # initialize a square/cube mask
+            max_box_size = max(box_size)  # max of box w/h/d
+            radius = max_box_size / 2.0
+            center = (max_box_size - 1) / 2.0
+            boxes_only_mask = np.ones([max_box_size] * spatial_dims, dtype=np.int16) * np.int16(bg_label)
+            # apply label intensity to generate circle/ball foreground
+            ranges = tuple(slice(0, max_box_size) for _ in range(spatial_dims))
+            dist_from_center = sum((grid - center) ** 2 for grid in np.ogrid[ranges])
+            boxes_only_mask[dist_from_center <= radius**2] = np.int16(labels_np[b])
+            # squeeze it to a ellipse/ellipsoid mask
+            resizer = Resize(spatial_size=box_size, mode="nearest", anti_aliasing=False)
+            boxes_only_mask = resizer(boxes_only_mask[None])[0]  # type: ignore
+        else:
+            # generate a rect mask
+            boxes_only_mask = np.ones(box_size, dtype=np.int16) * np.int16(labels_np[b])
+        # apply to global mask
+        slicing = [b]
+        slicing.extend(slice(boxes_np[b, d], boxes_np[b, d + spatial_dims]) for d in range(spatial_dims))  # type:ignore
+        boxes_mask_np[tuple(slicing)] = boxes_only_mask
+    return convert_to_dst_type(src=boxes_mask_np, dst=boxes, dtype=torch.int16)[0]
+
+
+def convert_mask_to_box(
+    boxes_mask: NdarrayOrTensor,
+    bg_label: int = -1,
+    box_dtype: DtypeLike | torch.dtype = torch.float32,
+    label_dtype: DtypeLike | torch.dtype = torch.long,
+) -> tuple[NdarrayOrTensor, NdarrayOrTensor]:
+    """
+    Convert int16 mask image to box, which has the same size with the input image
+
+    Args:
+        boxes_mask: int16 array, sized (num_box, H, W). Each channel represents a box.
+            The foreground region in channel c has intensity of labels[c].
+            The background intensity is bg_label.
+        bg_label: background labels for the boxes_mask
+        box_dtype: output dtype for boxes
+        label_dtype: output dtype for labels
+
+    Return:
+        - bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``.
+        - classification foreground(fg) labels, dtype should be int, sized (N,).
+    """
+    look_up_option(len(boxes_mask.shape), [3, 4])
+    spatial_size = list(boxes_mask.shape[1:])
+    spatial_dims = get_spatial_dims(spatial_size=spatial_size)
+
+    boxes_mask_np, *_ = convert_data_type(boxes_mask, np.ndarray)
+
+    boxes_list = []
+    labels_list = []
+    for b in range(boxes_mask_np.shape[0]):
+        fg_indices = np.nonzero(boxes_mask_np[b, ...] - bg_label)
+        if fg_indices[0].shape[0] == 0:
+            continue
+        boxes_b = []
+        for fd_i in fg_indices:
+            boxes_b.append(min(fd_i))  # top left corner
+        for fd_i in fg_indices:
+            boxes_b.append(max(fd_i) + 1 - TO_REMOVE)  # bottom right corner
+        boxes_list.append(boxes_b)
+        if spatial_dims == 2:
+            labels_list.append(boxes_mask_np[b, fg_indices[0][0], fg_indices[1][0]])
+        if spatial_dims == 3:
+            labels_list.append(boxes_mask_np[b, fg_indices[0][0], fg_indices[1][0], fg_indices[2][0]])
+
+    if len(boxes_list) == 0:
+        boxes_np, labels_np = np.zeros([0, 2 * spatial_dims]), np.zeros([0])
+    else:
+        boxes_np, labels_np = np.asarray(boxes_list), np.asarray(labels_list)
+    boxes, *_ = convert_to_dst_type(src=boxes_np, dst=boxes_mask, dtype=box_dtype)
+    labels, *_ = convert_to_dst_type(src=labels_np, dst=boxes_mask, dtype=label_dtype)
+    return boxes, labels
+
+
+def select_labels(
+    labels: Sequence[NdarrayOrTensor] | NdarrayOrTensor, keep: NdarrayOrTensor
+) -> tuple | NdarrayOrTensor:
+    """
+    For element in labels, select indices keep from it.
+
+    Args:
+        labels: Sequence of array. Each element represents classification labels or scores
+            corresponding to ``boxes``, sized (N,).
+        keep: the indices to keep, same length with each element in labels.
+
+    Return:
+        selected labels, does not share memory with original labels.
+    """
+    labels_tuple = ensure_tuple(labels, True)
+
+    labels_select_list = []
+    keep_t: torch.Tensor = convert_data_type(keep, torch.Tensor)[0]
+    for item in labels_tuple:
+        labels_t: torch.Tensor = convert_data_type(item, torch.Tensor)[0]
+        labels_t = labels_t[keep_t, ...]
+        labels_select_list.append(convert_to_dst_type(src=labels_t, dst=item)[0])
+
+    if isinstance(labels, (torch.Tensor, np.ndarray)):
+        return labels_select_list[0]  # type: ignore
+
+    return tuple(labels_select_list)
+
+
+def swapaxes_boxes(boxes: NdarrayTensor, axis1: int, axis2: int) -> NdarrayTensor:
+    """
+    Interchange two axes of boxes.
+
+    Args:
+        boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+        axis1: First axis.
+        axis2: Second axis.
+
+    Returns:
+        boxes with two axes interchanged.
+
+    """
+    spatial_dims: int = get_spatial_dims(boxes=boxes)
+
+    if isinstance(boxes, torch.Tensor):
+        boxes_swap = boxes.clone()
+    else:
+        boxes_swap = deepcopy(boxes)  # type: ignore
+    boxes_swap[:, [axis1, axis2]] = boxes_swap[:, [axis2, axis1]]
+
+    boxes_swap[:, [spatial_dims + axis1, spatial_dims + axis2]] = boxes_swap[
+        :, [spatial_dims + axis2, spatial_dims + axis1]
+    ]
+    return boxes_swap  # type: ignore[return-value]
+
+
+def rot90_boxes(
+    boxes: NdarrayTensor, spatial_size: Sequence[int] | int, k: int = 1, axes: tuple[int, int] = (0, 1)
+) -> NdarrayTensor:
+    """
+    Rotate boxes by 90 degrees in the plane specified by axes.
+    Rotation direction is from the first towards the second axis.
+
+    Args:
+        boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+        spatial_size: image spatial size.
+        k : number of times the array is rotated by 90 degrees.
+        axes: (2,) array_like
+            The array is rotated in the plane defined by the axes. Axes must be different.
+
+    Returns:
+        A rotated view of `boxes`.
+
+    Notes:
+        ``rot90_boxes(boxes, spatial_size, k=1, axes=(1,0))``  is the reverse of
+        ``rot90_boxes(boxes, spatial_size, k=1, axes=(0,1))``
+        ``rot90_boxes(boxes, spatial_size, k=1, axes=(1,0))`` is equivalent to
+        ``rot90_boxes(boxes, spatial_size, k=-1, axes=(0,1))``
+    """
+    spatial_dims: int = get_spatial_dims(boxes=boxes)
+    spatial_size_ = list(ensure_tuple_rep(spatial_size, spatial_dims))
+
+    axes = ensure_tuple(axes)
+
+    if len(axes) != 2:
+        raise ValueError("len(axes) must be 2.")
+
+    if axes[0] == axes[1] or abs(axes[0] - axes[1]) == spatial_dims:
+        raise ValueError("Axes must be different.")
+
+    if axes[0] >= spatial_dims or axes[0] < -spatial_dims or axes[1] >= spatial_dims or axes[1] < -spatial_dims:
+        raise ValueError(f"Axes={axes} out of range for array of ndim={spatial_dims}.")
+
+    k %= 4
+
+    if k == 0:
+        return boxes
+    if k == 2:
+        return flip_boxes(flip_boxes(boxes, spatial_size_, axes[0]), spatial_size_, axes[1])
+
+    if k == 1:
+        boxes_ = flip_boxes(boxes, spatial_size_, axes[1])
+        return swapaxes_boxes(boxes_, axes[0], axes[1])
+    else:
+        # k == 3
+        boxes_ = swapaxes_boxes(boxes, axes[0], axes[1])
+        spatial_size_[axes[0]], spatial_size_[axes[1]] = spatial_size_[axes[1]], spatial_size_[axes[0]]
+        return flip_boxes(boxes_, spatial_size_, axes[1])

source_code/SegMamba/monai/apps/detection/transforms/dictionary.py

@@ -0,0 +1,1414 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+A collection of dictionary-based wrappers around the "vanilla" transforms for box operations
+defined in :py:class:`monai.apps.detection.transforms.array`.
+
+Class names are ended with 'd' to denote dictionary-based transforms.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Hashable, Mapping, Sequence
+from copy import deepcopy
+from typing import Any
+
+import numpy as np
+import torch
+
+from monai.apps.detection.transforms.array import (
+    AffineBox,
+    BoxToMask,
+    ClipBoxToImage,
+    ConvertBoxMode,
+    ConvertBoxToStandardMode,
+    FlipBox,
+    MaskToBox,
+    RotateBox90,
+    SpatialCropBox,
+    StandardizeEmptyBox,
+    ZoomBox,
+)
+from monai.apps.detection.transforms.box_ops import convert_box_to_mask
+from monai.config import KeysCollection, SequenceStr
+from monai.config.type_definitions import DtypeLike, NdarrayOrTensor
+from monai.data.box_utils import COMPUTE_DTYPE, BoxMode, clip_boxes_to_image
+from monai.data.meta_tensor import MetaTensor, get_track_meta
+from monai.data.utils import orientation_ras_lps
+from monai.transforms import Flip, RandFlip, RandZoom, Rotate90, SpatialCrop, Zoom
+from monai.transforms.inverse import InvertibleTransform
+from monai.transforms.transform import MapTransform, Randomizable, RandomizableTransform
+from monai.transforms.utils import generate_pos_neg_label_crop_centers, map_binary_to_indices
+from monai.utils import InterpolateMode, NumpyPadMode, ensure_tuple, ensure_tuple_rep, fall_back_tuple
+from monai.utils.enums import PostFix, TraceKeys
+from monai.utils.type_conversion import convert_data_type, convert_to_tensor
+
+__all__ = [
+    "StandardizeEmptyBoxd",
+    "StandardizeEmptyBoxD",
+    "StandardizeEmptyBoxDict",
+    "ConvertBoxModed",
+    "ConvertBoxModeD",
+    "ConvertBoxModeDict",
+    "ConvertBoxToStandardModed",
+    "ConvertBoxToStandardModeD",
+    "ConvertBoxToStandardModeDict",
+    "AffineBoxToImageCoordinated",
+    "AffineBoxToImageCoordinateD",
+    "AffineBoxToImageCoordinateDict",
+    "ZoomBoxd",
+    "ZoomBoxD",
+    "ZoomBoxDict",
+    "RandZoomBoxd",
+    "RandZoomBoxD",
+    "RandZoomBoxDict",
+    "FlipBoxd",
+    "FlipBoxD",
+    "FlipBoxDict",
+    "RandFlipBoxd",
+    "RandFlipBoxD",
+    "RandFlipBoxDict",
+    "ClipBoxToImaged",
+    "ClipBoxToImageD",
+    "ClipBoxToImageDict",
+    "BoxToMaskd",
+    "BoxToMaskD",
+    "BoxToMaskDict",
+    "MaskToBoxd",
+    "MaskToBoxD",
+    "MaskToBoxDict",
+    "RandCropBoxByPosNegLabeld",
+    "RandCropBoxByPosNegLabelD",
+    "RandCropBoxByPosNegLabelDict",
+    "RotateBox90d",
+    "RotateBox90D",
+    "RotateBox90Dict",
+    "RandRotateBox90d",
+    "RandRotateBox90D",
+    "RandRotateBox90Dict",
+]
+
+DEFAULT_POST_FIX = PostFix.meta()
+
+
+class StandardizeEmptyBoxd(MapTransform, InvertibleTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.apps.detection.transforms.array.StandardizeEmptyBox`.
+
+    When boxes are empty, this transform standardize it to shape of (0,4) or (0,6).
+
+    Example:
+        .. code-block:: python
+
+            data = {"boxes": torch.ones(0,), "image": torch.ones(1, 128, 128, 128)}
+            box_converter = StandardizeEmptyBoxd(box_keys=["boxes"], box_ref_image_keys="image")
+            box_converter(data)
+    """
+
+    def __init__(self, box_keys: KeysCollection, box_ref_image_keys: str, allow_missing_keys: bool = False) -> None:
+        """
+        Args:
+            box_keys: Keys to pick data for transformation.
+            box_ref_image_keys: The single key that represents the reference image to which ``box_keys`` are attached.
+            allow_missing_keys: don't raise exception if key is missing.
+
+        See also :py:class:`monai.apps.detection,transforms.array.ConvertBoxToStandardMode`
+        """
+        super().__init__(box_keys, allow_missing_keys)
+        box_ref_image_keys_tuple = ensure_tuple(box_ref_image_keys)
+        if len(box_ref_image_keys_tuple) > 1:
+            raise ValueError(
+                "Please provide a single key for box_ref_image_keys.\
+                All boxes of box_keys are attached to box_ref_image_keys."
+            )
+        self.box_ref_image_keys = box_ref_image_keys
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+        spatial_dims = len(d[self.box_ref_image_keys].shape) - 1
+        self.converter = StandardizeEmptyBox(spatial_dims=spatial_dims)
+        for key in self.key_iterator(d):
+            d[key] = self.converter(d[key])
+        return d
+
+    def inverse(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        return dict(data)
+
+
+class ConvertBoxModed(MapTransform, InvertibleTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.apps.detection.transforms.array.ConvertBoxMode`.
+
+    This transform converts the boxes in src_mode to the dst_mode.
+
+    Example:
+        .. code-block:: python
+
+            data = {"boxes": torch.ones(10,4)}
+            # convert boxes with format [xmin, ymin, xmax, ymax] to [xcenter, ycenter, xsize, ysize].
+            box_converter = ConvertBoxModed(box_keys=["boxes"], src_mode="xyxy", dst_mode="ccwh")
+            box_converter(data)
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        src_mode: str | BoxMode | type[BoxMode] | None = None,
+        dst_mode: str | BoxMode | type[BoxMode] | None = None,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        """
+        Args:
+            box_keys: Keys to pick data for transformation.
+            src_mode: source box mode. If it is not given, this func will assume it is ``StandardMode()``.
+                It follows the same format with ``src_mode`` in :class:`~monai.apps.detection.transforms.array.ConvertBoxMode` .
+            dst_mode: target box mode. If it is not given, this func will assume it is ``StandardMode()``.
+                It follows the same format with ``src_mode`` in :class:`~monai.apps.detection.transforms.array.ConvertBoxMode` .
+            allow_missing_keys: don't raise exception if key is missing.
+
+        See also :py:class:`monai.apps.detection,transforms.array.ConvertBoxMode`
+        """
+        super().__init__(box_keys, allow_missing_keys)
+        self.converter = ConvertBoxMode(src_mode=src_mode, dst_mode=dst_mode)
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+        for key in self.key_iterator(d):
+            d[key] = self.converter(d[key])
+            self.push_transform(d, key, extra_info={"src": self.converter.src_mode, "dst": self.converter.dst_mode})
+        return d
+
+    def inverse(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+        for key in self.key_iterator(d):
+            tr = self.get_most_recent_transform(d, key)
+            src_mode, dst_mode = tr[TraceKeys.EXTRA_INFO]["src"], tr[TraceKeys.EXTRA_INFO]["dst"]
+            inverse_converter = ConvertBoxMode(src_mode=dst_mode, dst_mode=src_mode)
+            # Inverse is same as forward
+            d[key] = inverse_converter(d[key])
+            # Remove the applied transform
+            self.pop_transform(d, key)
+        return d
+
+
+class ConvertBoxToStandardModed(MapTransform, InvertibleTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.apps.detection.transforms.array.ConvertBoxToStandardMode`.
+
+    Convert given boxes to standard mode.
+    Standard mode is "xyxy" or "xyzxyz",
+    representing box format of [xmin, ymin, xmax, ymax] or [xmin, ymin, zmin, xmax, ymax, zmax].
+
+    Example:
+        .. code-block:: python
+
+            data = {"boxes": torch.ones(10,6)}
+            # convert boxes with format [xmin, xmax, ymin, ymax, zmin, zmax] to [xmin, ymin, zmin, xmax, ymax, zmax]
+            box_converter = ConvertBoxToStandardModed(box_keys=["boxes"], mode="xxyyzz")
+            box_converter(data)
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        mode: str | BoxMode | type[BoxMode] | None = None,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        """
+        Args:
+            box_keys: Keys to pick data for transformation.
+            mode: source box mode. If it is not given, this func will assume it is ``StandardMode()``.
+                It follows the same format with ``src_mode`` in :class:`~monai.apps.detection.transforms.array.ConvertBoxMode` .
+            allow_missing_keys: don't raise exception if key is missing.
+
+        See also :py:class:`monai.apps.detection,transforms.array.ConvertBoxToStandardMode`
+        """
+        super().__init__(box_keys, allow_missing_keys)
+        self.converter = ConvertBoxToStandardMode(mode=mode)
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+        for key in self.key_iterator(d):
+            d[key] = self.converter(d[key])
+            self.push_transform(d, key, extra_info={"mode": self.converter.mode})
+        return d
+
+    def inverse(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+        for key in self.key_iterator(d):
+            tr = self.get_most_recent_transform(d, key)
+            original_mode = tr[TraceKeys.EXTRA_INFO]["mode"]
+            inverse_converter = ConvertBoxMode(src_mode=None, dst_mode=original_mode)
+            # Inverse is same as forward
+            d[key] = inverse_converter(d[key])
+            # Remove the applied transform
+            self.pop_transform(d, key)
+        return d
+
+
+class AffineBoxToImageCoordinated(MapTransform, InvertibleTransform):
+    """
+    Dictionary-based transform that converts box in world coordinate to image coordinate.
+
+    Args:
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: The single key that represents the reference image to which ``box_keys`` are attached.
+        remove_empty: whether to remove the boxes that are actually empty
+        allow_missing_keys: don't raise exception if key is missing.
+        image_meta_key: explicitly indicate the key of the corresponding metadata dictionary.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, affine, original_shape, etc.
+            it is a string, map to the `box_ref_image_key`.
+            if None, will try to construct meta_keys by `box_ref_image_key_{meta_key_postfix}`.
+        image_meta_key_postfix: if image_meta_keys=None, use `box_ref_image_key_{postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        affine_lps_to_ras: default ``False``. Yet if 1) the image is read by ITKReader,
+            and 2) the ITKReader has affine_lps_to_ras=True, and 3) the box is in world coordinate,
+            then set ``affine_lps_to_ras=True``.
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        box_ref_image_keys: str,
+        allow_missing_keys: bool = False,
+        image_meta_key: str | None = None,
+        image_meta_key_postfix: str | None = DEFAULT_POST_FIX,
+        affine_lps_to_ras: bool = False,
+    ) -> None:
+        super().__init__(box_keys, allow_missing_keys)
+        box_ref_image_keys_tuple = ensure_tuple(box_ref_image_keys)
+        if len(box_ref_image_keys_tuple) > 1:
+            raise ValueError(
+                "Please provide a single key for box_ref_image_keys.\
+                All boxes of box_keys are attached to box_ref_image_keys."
+            )
+        self.box_ref_image_keys = box_ref_image_keys
+        self.image_meta_key = image_meta_key or f"{box_ref_image_keys}_{image_meta_key_postfix}"
+        self.converter_to_image_coordinate = AffineBox()
+        self.affine_lps_to_ras = affine_lps_to_ras
+
+    def extract_affine(self, data: Mapping[Hashable, torch.Tensor]) -> tuple[NdarrayOrTensor, torch.Tensor]:
+        d = dict(data)
+
+        meta_key = self.image_meta_key
+        # extract affine matrix from metadata
+        if isinstance(d[self.box_ref_image_keys], MetaTensor):
+            meta_dict = d[self.box_ref_image_keys].meta  # type: ignore
+        elif meta_key in d:
+            meta_dict = d[meta_key]
+        else:
+            raise ValueError(f"{meta_key} is not found. Please check whether it is the correct the image meta key.")
+        if "affine" not in meta_dict:
+            raise ValueError(
+                f"'affine' is not found in {meta_key}. \
+                Please check whether it is the correct the image meta key."
+            )
+        affine: NdarrayOrTensor = meta_dict["affine"]
+
+        if self.affine_lps_to_ras:  # RAS affine
+            affine = orientation_ras_lps(affine)
+
+        # when convert boxes from world coordinate to image coordinate,
+        # we apply inverse affine transform
+        affine_t, *_ = convert_data_type(affine, torch.Tensor)
+        # torch.inverse should not run in half precision
+        inv_affine_t = torch.inverse(affine_t.to(COMPUTE_DTYPE))
+        return affine, inv_affine_t
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+
+        affine, inv_affine_t = self.extract_affine(data)  # type: ignore
+
+        for key in self.key_iterator(d):
+            d[key] = self.converter_to_image_coordinate(d[key], affine=inv_affine_t)
+            self.push_transform(d, key, extra_info={"affine": affine})
+        return d
+
+    def inverse(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+        for key in self.key_iterator(d):
+            transform = self.get_most_recent_transform(d, key)
+            affine = transform["extra_info"]["affine"]
+            d[key] = AffineBox()(d[key], affine=affine)
+            self.pop_transform(d, key)
+        return d
+
+
+class AffineBoxToWorldCoordinated(AffineBoxToImageCoordinated):
+    """
+    Dictionary-based transform that converts box in image coordinate to world coordinate.
+
+    Args:
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: The single key that represents the reference image to which ``box_keys`` are attached.
+        remove_empty: whether to remove the boxes that are actually empty
+        allow_missing_keys: don't raise exception if key is missing.
+        image_meta_key: explicitly indicate the key of the corresponding metadata dictionary.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, affine, original_shape, etc.
+            it is a string, map to the `box_ref_image_key`.
+            if None, will try to construct meta_keys by `box_ref_image_key_{meta_key_postfix}`.
+        image_meta_key_postfix: if image_meta_keys=None, use `box_ref_image_key_{postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            For example, to handle key `image`,  read/write affine matrices from the
+            metadata `image_meta_dict` dictionary's `affine` field.
+        affine_lps_to_ras: default ``False``. Yet if 1) the image is read by ITKReader,
+            and 2) the ITKReader has affine_lps_to_ras=True, and 3) the box is in world coordinate,
+            then set ``affine_lps_to_ras=True``.
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        box_ref_image_keys: str,
+        allow_missing_keys: bool = False,
+        image_meta_key: str | None = None,
+        image_meta_key_postfix: str | None = DEFAULT_POST_FIX,
+        affine_lps_to_ras: bool = False,
+    ) -> None:
+        super().__init__(
+            box_keys, box_ref_image_keys, allow_missing_keys, image_meta_key, image_meta_key_postfix, affine_lps_to_ras
+        )
+        self.converter_to_world_coordinate = AffineBox()
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+
+        affine, inv_affine_t = self.extract_affine(data)  # type: ignore
+
+        for key in self.key_iterator(d):
+            d[key] = self.converter_to_world_coordinate(d[key], affine=affine)
+            self.push_transform(d, key, extra_info={"affine": inv_affine_t})
+        return d
+
+
+class ZoomBoxd(MapTransform, InvertibleTransform):
+    """
+    Dictionary-based transform that zooms input boxes and images with the given zoom scale.
+
+    Args:
+        image_keys: Keys to pick image data for transformation.
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: Keys that represent the reference images to which ``box_keys`` are attached.
+        zoom: The zoom factor along the spatial axes.
+            If a float, zoom is the same for each spatial axis.
+            If a sequence, zoom should contain one value for each spatial axis.
+        mode: {``"nearest"``, ``"nearest-exact"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}
+            The interpolation mode. Defaults to ``"area"``.
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html
+            It also can be a sequence of string, each element corresponds to a key in ``keys``.
+        padding_mode: available modes for numpy array:{``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``,
+            ``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}
+            available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.
+            One of the listed string values or a user supplied function. Defaults to ``"constant"``.
+            The mode to pad data after zooming.
+            See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
+            https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+        align_corners: This only has an effect when mode is
+            'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html
+            It also can be a sequence of bool or None, each element corresponds to a key in ``keys``.
+        keep_size: Should keep original size (pad if needed), default is True.
+        allow_missing_keys: don't raise exception if key is missing.
+        kwargs: other arguments for the `np.pad` or `torch.pad` function.
+            note that `np.pad` treats channel dimension as the first dimension.
+    """
+
+    def __init__(
+        self,
+        image_keys: KeysCollection,
+        box_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        zoom: Sequence[float] | float,
+        mode: SequenceStr = InterpolateMode.AREA,
+        padding_mode: SequenceStr = NumpyPadMode.EDGE,
+        align_corners: Sequence[bool | None] | bool | None = None,
+        keep_size: bool = True,
+        allow_missing_keys: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        self.image_keys = ensure_tuple(image_keys)
+        self.box_keys = ensure_tuple(box_keys)
+        super().__init__(self.image_keys + self.box_keys, allow_missing_keys)
+        self.box_ref_image_keys = ensure_tuple_rep(box_ref_image_keys, len(self.box_keys))
+
+        self.mode = ensure_tuple_rep(mode, len(self.image_keys))
+        self.padding_mode = ensure_tuple_rep(padding_mode, len(self.image_keys))
+        self.align_corners = ensure_tuple_rep(align_corners, len(self.image_keys))
+        self.zoomer = Zoom(zoom=zoom, keep_size=keep_size, **kwargs)
+        self.keep_size = keep_size
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d: dict[Hashable, torch.Tensor] = dict(data)
+
+        # zoom box
+        for box_key, box_ref_image_key in zip(self.box_keys, self.box_ref_image_keys):
+            src_spatial_size = d[box_ref_image_key].shape[1:]
+            dst_spatial_size = [int(round(z * ss)) for z, ss in zip(self.zoomer.zoom, src_spatial_size)]  # type: ignore
+            self.zoomer.zoom = [ds / float(ss) for ss, ds in zip(src_spatial_size, dst_spatial_size)]
+            d[box_key] = ZoomBox(zoom=self.zoomer.zoom, keep_size=self.keep_size)(
+                d[box_key], src_spatial_size=src_spatial_size
+            )
+            self.push_transform(
+                d,
+                box_key,
+                extra_info={"zoom": self.zoomer.zoom, "src_spatial_size": src_spatial_size, "type": "box_key"},
+            )
+
+        # zoom image
+        for key, mode, padding_mode, align_corners in zip(
+            self.image_keys, self.mode, self.padding_mode, self.align_corners
+        ):
+            d[key] = self.zoomer(d[key], mode=mode, padding_mode=padding_mode, align_corners=align_corners)
+
+        return d
+
+    def inverse(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d: dict[Hashable, torch.Tensor] = dict(data)
+
+        for key in self.key_iterator(d):
+            transform = self.get_most_recent_transform(d, key, check=False)
+            key_type = transform[TraceKeys.EXTRA_INFO].get("type", "image_key")
+            # zoom image, copied from monai.transforms.spatial.dictionary.Zoomd
+            if key_type == "image_key":
+                d[key] = self.zoomer.inverse(d[key])
+
+            # zoom boxes
+            if key_type == "box_key":
+                zoom = np.array(transform[TraceKeys.EXTRA_INFO]["zoom"])
+                src_spatial_size = transform[TraceKeys.EXTRA_INFO]["src_spatial_size"]
+                box_inverse_transform = ZoomBox(zoom=(1 / zoom).tolist(), keep_size=self.zoomer.keep_size)
+                d[key] = box_inverse_transform(d[key], src_spatial_size=src_spatial_size)
+                # Remove the applied transform
+                self.pop_transform(d, key)
+
+        return d
+
+
+class RandZoomBoxd(RandomizableTransform, MapTransform, InvertibleTransform):
+    """
+    Dictionary-based transform that randomly zooms input boxes and images with given probability within given zoom range.
+
+    Args:
+        image_keys: Keys to pick image data for transformation.
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: Keys that represent the reference images to which ``box_keys`` are attached.
+        prob: Probability of zooming.
+        min_zoom: Min zoom factor. Can be float or sequence same size as image.
+            If a float, select a random factor from `[min_zoom, max_zoom]` then apply to all spatial dims
+            to keep the original spatial shape ratio.
+            If a sequence, min_zoom should contain one value for each spatial axis.
+            If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.
+        max_zoom: Max zoom factor. Can be float or sequence same size as image.
+            If a float, select a random factor from `[min_zoom, max_zoom]` then apply to all spatial dims
+            to keep the original spatial shape ratio.
+            If a sequence, max_zoom should contain one value for each spatial axis.
+            If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.
+        mode: {``"nearest"``, ``"nearest-exact"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}
+            The interpolation mode. Defaults to ``"area"``.
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html
+            It also can be a sequence of string, each element corresponds to a key in ``keys``.
+        padding_mode: available modes for numpy array:{``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``,
+            ``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}
+            available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.
+            One of the listed string values or a user supplied function. Defaults to ``"constant"``.
+            The mode to pad data after zooming.
+            See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
+            https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+        align_corners: This only has an effect when mode is
+            'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html
+            It also can be a sequence of bool or None, each element corresponds to a key in ``keys``.
+        keep_size: Should keep original size (pad if needed), default is True.
+        allow_missing_keys: don't raise exception if key is missing.
+        kwargs: other args for `np.pad` API, note that `np.pad` treats channel dimension as the first dimension.
+            more details: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html
+    """
+
+    backend = RandZoom.backend
+
+    def __init__(
+        self,
+        image_keys: KeysCollection,
+        box_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        prob: float = 0.1,
+        min_zoom: Sequence[float] | float = 0.9,
+        max_zoom: Sequence[float] | float = 1.1,
+        mode: SequenceStr = InterpolateMode.AREA,
+        padding_mode: SequenceStr = NumpyPadMode.EDGE,
+        align_corners: Sequence[bool | None] | bool | None = None,
+        keep_size: bool = True,
+        allow_missing_keys: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        self.image_keys = ensure_tuple(image_keys)
+        self.box_keys = ensure_tuple(box_keys)
+        MapTransform.__init__(self, self.image_keys + self.box_keys, allow_missing_keys)
+        RandomizableTransform.__init__(self, prob)
+        self.box_ref_image_keys = ensure_tuple_rep(box_ref_image_keys, len(self.box_keys))
+
+        self.rand_zoom = RandZoom(prob=1.0, min_zoom=min_zoom, max_zoom=max_zoom, keep_size=keep_size, **kwargs)
+        self.mode = ensure_tuple_rep(mode, len(self.image_keys))
+        self.padding_mode = ensure_tuple_rep(padding_mode, len(self.image_keys))
+        self.align_corners = ensure_tuple_rep(align_corners, len(self.image_keys))
+        self.keep_size = keep_size
+
+    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandZoomBoxd:
+        super().set_random_state(seed, state)
+        self.rand_zoom.set_random_state(seed, state)
+        return self
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+        first_key: Hashable = self.first_key(d)
+        if first_key == ():
+            return d
+
+        self.randomize(None)
+
+        # all the keys share the same random zoom factor
+        self.rand_zoom.randomize(d[first_key])
+
+        # zoom box
+        for box_key, box_ref_image_key in zip(self.box_keys, self.box_ref_image_keys):
+            if self._do_transform:
+                src_spatial_size = d[box_ref_image_key].shape[1:]
+                dst_spatial_size = [int(round(z * ss)) for z, ss in zip(self.rand_zoom._zoom, src_spatial_size)]
+                self.rand_zoom._zoom = [ds / float(ss) for ss, ds in zip(src_spatial_size, dst_spatial_size)]
+
+                d[box_key] = ZoomBox(zoom=self.rand_zoom._zoom, keep_size=self.keep_size)(
+                    d[box_key], src_spatial_size=src_spatial_size
+                )
+                self.push_transform(
+                    d,
+                    box_key,
+                    extra_info={"zoom": self.rand_zoom._zoom, "src_spatial_size": src_spatial_size, "type": "box_key"},
+                )
+
+        # zoom image, copied from monai.transforms.spatial.dictionary.RandZoomd
+        for key, mode, padding_mode, align_corners in zip(
+            self.image_keys, self.mode, self.padding_mode, self.align_corners
+        ):
+            if self._do_transform:
+                d[key] = self.rand_zoom(
+                    d[key], mode=mode, padding_mode=padding_mode, align_corners=align_corners, randomize=False
+                )
+            else:
+                d[key] = convert_to_tensor(d[key], track_meta=get_track_meta())
+            if get_track_meta():
+                xform = self.pop_transform(d[key], check=False) if self._do_transform else {}
+                self.push_transform(d[key], extra_info=xform)
+
+        return d
+
+    def inverse(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+
+        for key in self.key_iterator(d):
+            transform = self.get_most_recent_transform(d, key, check=False)
+            key_type = transform[TraceKeys.EXTRA_INFO].get("type", "image_key")
+            # Check if random transform was actually performed (based on `prob`)
+            if transform[TraceKeys.DO_TRANSFORM]:
+                # zoom image, copied from monai.transforms.spatial.dictionary.Zoomd
+                if key_type == "image_key":
+                    xform = self.pop_transform(d[key])
+                    d[key].applied_operations.append(xform[TraceKeys.EXTRA_INFO])  # type: ignore
+                    d[key] = self.rand_zoom.inverse(d[key])
+
+                # zoom boxes
+                if key_type == "box_key":
+                    # Create inverse transform
+                    zoom = np.array(transform[TraceKeys.EXTRA_INFO]["zoom"])
+                    src_spatial_size = transform[TraceKeys.EXTRA_INFO]["src_spatial_size"]
+                    box_inverse_transform = ZoomBox(zoom=(1.0 / zoom).tolist(), keep_size=self.rand_zoom.keep_size)
+                    d[key] = box_inverse_transform(d[key], src_spatial_size=src_spatial_size)
+                    # Remove the applied transform
+                    self.pop_transform(d, key)
+        return d
+
+
+class FlipBoxd(MapTransform, InvertibleTransform):
+    """
+    Dictionary-based transform that flip boxes and images.
+
+    Args:
+        image_keys: Keys to pick image data for transformation.
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: Keys that represent the reference images to which ``box_keys`` are attached.
+        spatial_axis: Spatial axes along which to flip over. Default is None.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    backend = Flip.backend
+
+    def __init__(
+        self,
+        image_keys: KeysCollection,
+        box_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        spatial_axis: Sequence[int] | int | None = None,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        self.image_keys = ensure_tuple(image_keys)
+        self.box_keys = ensure_tuple(box_keys)
+        super().__init__(self.image_keys + self.box_keys, allow_missing_keys)
+        self.box_ref_image_keys = ensure_tuple_rep(box_ref_image_keys, len(self.box_keys))
+
+        self.flipper = Flip(spatial_axis=spatial_axis)
+        self.box_flipper = FlipBox(spatial_axis=self.flipper.spatial_axis)
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+
+        for key in self.image_keys:
+            d[key] = self.flipper(d[key])
+
+        for box_key, box_ref_image_key in zip(self.box_keys, self.box_ref_image_keys):
+            spatial_size = d[box_ref_image_key].shape[1:]
+            d[box_key] = self.box_flipper(d[box_key], spatial_size)
+            self.push_transform(d, box_key, extra_info={"spatial_size": spatial_size, "type": "box_key"})
+        return d
+
+    def inverse(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+
+        for key in self.key_iterator(d):
+            transform = self.get_most_recent_transform(d, key, check=False)
+            key_type = transform.get(TraceKeys.EXTRA_INFO, {}).get("type", "image_key")
+
+            # flip image, copied from monai.transforms.spatial.dictionary.Flipd
+            if key_type == "image_key":
+                d[key] = self.flipper.inverse(d[key])
+
+            # flip boxes
+            if key_type == "box_key":
+                spatial_size = transform[TraceKeys.EXTRA_INFO]["spatial_size"]
+                d[key] = self.box_flipper(d[key], spatial_size)
+                # Remove the applied transform
+                self.pop_transform(d, key)
+        return d
+
+
+class RandFlipBoxd(RandomizableTransform, MapTransform, InvertibleTransform):
+    """
+    Dictionary-based transform that randomly flip boxes and images with the given probabilities.
+
+    Args:
+        image_keys: Keys to pick image data for transformation.
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: Keys that represent the reference images to which ``box_keys`` are attached.
+        prob: Probability of flipping.
+        spatial_axis: Spatial axes along which to flip over. Default is None.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    backend = RandFlip.backend
+
+    def __init__(
+        self,
+        image_keys: KeysCollection,
+        box_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        prob: float = 0.1,
+        spatial_axis: Sequence[int] | int | None = None,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        self.image_keys = ensure_tuple(image_keys)
+        self.box_keys = ensure_tuple(box_keys)
+        MapTransform.__init__(self, self.image_keys + self.box_keys, allow_missing_keys)
+        RandomizableTransform.__init__(self, prob)
+        self.box_ref_image_keys = ensure_tuple_rep(box_ref_image_keys, len(self.box_keys))
+
+        self.flipper = Flip(spatial_axis=spatial_axis)
+        self.box_flipper = FlipBox(spatial_axis=spatial_axis)
+
+    def set_random_state(self, seed: int | None = None, state: np.random.RandomState | None = None) -> RandFlipBoxd:
+        super().set_random_state(seed, state)
+        return self
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+        self.randomize(None)
+
+        for key in self.image_keys:
+            if self._do_transform:
+                d[key] = self.flipper(d[key])
+            else:
+                d[key] = convert_to_tensor(d[key], track_meta=get_track_meta())
+            if get_track_meta():
+                xform_info = self.pop_transform(d[key], check=False) if self._do_transform else {}
+                self.push_transform(d[key], extra_info=xform_info)
+
+        for box_key, box_ref_image_key in zip(self.box_keys, self.box_ref_image_keys):
+            spatial_size = d[box_ref_image_key].shape[1:]
+            if self._do_transform:
+                d[box_key] = self.box_flipper(d[box_key], spatial_size)
+            self.push_transform(d, box_key, extra_info={"spatial_size": spatial_size, "type": "box_key"})
+        return d
+
+    def inverse(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+
+        for key in self.key_iterator(d):
+            transform = self.get_most_recent_transform(d, key, check=False)
+            key_type = transform[TraceKeys.EXTRA_INFO].get("type", "image_key")
+            # Check if random transform was actually performed (based on `prob`)
+            if transform[TraceKeys.DO_TRANSFORM]:
+                # flip image, copied from monai.transforms.spatial.dictionary.RandFlipd
+                if key_type == "image_key":
+                    with self.flipper.trace_transform(False):
+                        d[key] = self.flipper(d[key])
+
+                # flip boxes
+                if key_type == "box_key":
+                    spatial_size = transform[TraceKeys.EXTRA_INFO]["spatial_size"]
+                    d[key] = self.box_flipper(d[key], spatial_size)
+
+            # Remove the applied transform
+            self.pop_transform(d, key, check=False)
+        return d
+
+
+class ClipBoxToImaged(MapTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.apps.detection.transforms.array.ClipBoxToImage`.
+
+    Clip the bounding boxes and the associated labels/scores to makes sure they are within the image.
+    There might be multiple keys of labels/scores associated with one key of boxes.
+
+    Args:
+        box_keys: The single key to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        label_keys: Keys that represent the labels corresponding to the ``box_keys``. Multiple keys are allowed.
+        box_ref_image_keys: The single key that represents the reference image
+            to which ``box_keys`` and ``label_keys`` are attached.
+        remove_empty: whether to remove the boxes that are actually empty
+        allow_missing_keys: don't raise exception if key is missing.
+
+    Example:
+        .. code-block:: python
+
+            ClipBoxToImaged(
+                box_keys="boxes", box_ref_image_keys="image", label_keys=["labels", "scores"], remove_empty=True
+            )
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        label_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        remove_empty: bool = True,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        box_keys_tuple = ensure_tuple(box_keys)
+        if len(box_keys_tuple) != 1:
+            raise ValueError(
+                "Please provide a single key for box_keys.\
+                All label_keys are attached to this box_keys."
+            )
+        box_ref_image_keys_tuple = ensure_tuple(box_ref_image_keys)
+        if len(box_ref_image_keys_tuple) != 1:
+            raise ValueError(
+                "Please provide a single key for box_ref_image_keys.\
+                All box_keys and label_keys are attached to this box_ref_image_keys."
+            )
+        self.label_keys = ensure_tuple(label_keys)
+        super().__init__(box_keys_tuple, allow_missing_keys)
+
+        self.box_keys = box_keys_tuple[0]
+        self.box_ref_image_keys = box_ref_image_keys_tuple[0]
+        self.clipper = ClipBoxToImage(remove_empty=remove_empty)
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+        spatial_size = d[self.box_ref_image_keys].shape[1:]
+        labels = [d[label_key] for label_key in self.label_keys]  # could be multiple arrays
+        d[self.box_keys], clipped_labels = self.clipper(d[self.box_keys], labels, spatial_size)
+
+        for label_key, clipped_labels_i in zip(self.label_keys, clipped_labels):
+            d[label_key] = clipped_labels_i
+        return d
+
+
+class BoxToMaskd(MapTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.apps.detection.transforms.array.BoxToMask`.
+    Pairs with :py:class:`monai.apps.detection.transforms.dictionary.MaskToBoxd` .
+    Please make sure the same ``min_fg_label`` is used when using the two transforms in pairs.
+    The output ``d[box_mask_key]`` will have background intensity 0, since the following operations
+    may pad 0 on the border.
+
+    This is the general solution for transforms that need to be applied on images and boxes simultaneously.
+    It is performed with the following steps.
+
+        1) use ``BoxToMaskd`` to covert boxes and labels to box_masks;
+        2) do transforms, e.g., rotation or cropping, on images and box_masks together;
+        3) use ``MaskToBoxd`` to convert box_masks back to boxes and labels.
+
+    Args:
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_mask_keys: Keys to store output box mask results for transformation. Same length with ``box_keys``.
+        label_keys: Keys that represent the labels corresponding to the ``box_keys``. Same length with ``box_keys``.
+        box_ref_image_keys: Keys that represent the reference images to which ``box_keys`` are attached.
+        min_fg_label: min foreground box label.
+        ellipse_mask: bool.
+
+            - If True, it assumes the object shape is close to ellipse or ellipsoid.
+            - If False, it assumes the object shape is close to rectangle or cube and well occupies the bounding box.
+            - If the users are going to apply random rotation as data augmentation, we suggest setting ellipse_mask=True
+              See also Kalra et al. "Towards Rotation Invariance in Object Detection", ICCV 2021.
+        allow_missing_keys: don't raise exception if key is missing.
+
+    Example:
+        .. code-block:: python
+
+            # This code snippet creates transforms (random rotation and cropping) on boxes, labels, and image together.
+            import numpy as np
+            from monai.transforms import Compose, RandRotated, RandSpatialCropd, DeleteItemsd
+            transforms = Compose(
+                [
+                    BoxToMaskd(
+                        box_keys="boxes", label_keys="labels",
+                        box_mask_keys="box_mask", box_ref_image_keys="image",
+                        min_fg_label=0, ellipse_mask=True
+                    ),
+                    RandRotated(keys=["image","box_mask"],mode=["nearest","nearest"],
+                        prob=0.2,range_x=np.pi/6,range_y=np.pi/6,range_z=np.pi/6,
+                        keep_size=True,padding_mode="zeros"
+                    ),
+                    RandSpatialCropd(keys=["image","box_mask"],roi_size=128, random_size=False),
+                    MaskToBoxd(
+                        box_mask_keys="box_mask", box_keys="boxes",
+                        label_keys="labels", min_fg_label=0
+                    )
+                    DeleteItemsd(keys=["box_mask"]),
+                ]
+            )
+
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        box_mask_keys: KeysCollection,
+        label_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        min_fg_label: int,
+        ellipse_mask: bool = False,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        super().__init__(box_keys, allow_missing_keys)
+        self.box_keys = ensure_tuple(box_keys)
+        self.label_keys = ensure_tuple(label_keys)
+        self.box_mask_keys = ensure_tuple(box_mask_keys)
+        if not len(self.label_keys) == len(self.box_keys) == len(self.box_mask_keys):
+            raise ValueError("Please make sure len(label_keys)==len(box_keys)==len(box_mask_keys)!")
+        self.box_ref_image_keys = ensure_tuple_rep(box_ref_image_keys, len(self.box_keys))
+        self.bg_label = min_fg_label - 1  # make sure background label is always smaller than fg labels.
+        self.converter = BoxToMask(bg_label=self.bg_label, ellipse_mask=ellipse_mask)
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+
+        for box_key, label_key, box_mask_key, box_ref_image_key in zip(
+            self.box_keys, self.label_keys, self.box_mask_keys, self.box_ref_image_keys
+        ):
+            spatial_size = d[box_ref_image_key].shape[1:]
+            d[box_mask_key] = self.converter(d[box_key], d[label_key], spatial_size)
+            # make box mask background intensity to be 0, since the following operations may pad 0 on the border.
+            d[box_mask_key] -= self.bg_label
+        return d
+
+
+class MaskToBoxd(MapTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.apps.detection.transforms.array.MaskToBox`.
+    Pairs with :py:class:`monai.apps.detection.transforms.dictionary.BoxToMaskd` .
+    Please make sure the same ``min_fg_label`` is used when using the two transforms in pairs.
+
+    This is the general solution for transforms that need to be applied on images and boxes simultaneously.
+    It is performed with the following steps.
+
+        1) use ``BoxToMaskd`` to covert boxes and labels to box_masks;
+        2) do transforms, e.g., rotation or cropping, on images and box_masks together;
+        3) use ``MaskToBoxd`` to convert box_masks back to boxes and labels.
+
+    Args:
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_mask_keys: Keys to store output box mask results for transformation. Same length with ``box_keys``.
+        label_keys: Keys that represent the labels corresponding to the ``box_keys``. Same length with ``box_keys``.
+        min_fg_label: min foreground box label.
+        box_dtype: output dtype for box_keys
+        label_dtype: output dtype for label_keys
+        allow_missing_keys: don't raise exception if key is missing.
+
+    Example:
+        .. code-block:: python
+
+            # This code snippet creates transforms (random rotation and cropping) on boxes, labels, and images together.
+            import numpy as np
+            from monai.transforms import Compose, RandRotated, RandSpatialCropd, DeleteItemsd
+            transforms = Compose(
+                [
+                    BoxToMaskd(
+                        box_keys="boxes", label_keys="labels",
+                        box_mask_keys="box_mask", box_ref_image_keys="image",
+                        min_fg_label=0, ellipse_mask=True
+                    ),
+                    RandRotated(keys=["image","box_mask"],mode=["nearest","nearest"],
+                        prob=0.2,range_x=np.pi/6,range_y=np.pi/6,range_z=np.pi/6,
+                        keep_size=True,padding_mode="zeros"
+                    ),
+                    RandSpatialCropd(keys=["image","box_mask"],roi_size=128, random_size=False),
+                    MaskToBoxd(
+                        box_mask_keys="box_mask", box_keys="boxes",
+                        label_keys="labels", min_fg_label=0
+                    )
+                    DeleteItemsd(keys=["box_mask"]),
+                ]
+            )
+    """
+
+    def __init__(
+        self,
+        box_keys: KeysCollection,
+        box_mask_keys: KeysCollection,
+        label_keys: KeysCollection,
+        min_fg_label: int,
+        box_dtype: DtypeLike | torch.dtype = torch.float32,
+        label_dtype: DtypeLike | torch.dtype = torch.long,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        super().__init__(box_keys, allow_missing_keys)
+        self.box_keys = ensure_tuple(box_keys)
+        self.label_keys = ensure_tuple(label_keys)
+        self.box_mask_keys = ensure_tuple(box_mask_keys)
+        if not len(self.label_keys) == len(self.box_keys) == len(self.box_mask_keys):
+            raise ValueError("Please make sure len(label_keys)==len(box_keys)==len(box_mask_keys)!")
+        self.bg_label = min_fg_label - 1  # make sure background label is always smaller than fg labels.
+        self.converter = MaskToBox(bg_label=self.bg_label, box_dtype=box_dtype, label_dtype=label_dtype)
+        self.box_dtype = box_dtype
+
+    def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]:
+        d = dict(data)
+
+        for box_key, label_key, box_mask_key in zip(self.box_keys, self.label_keys, self.box_mask_keys):
+            d[box_mask_key] += self.bg_label  # pairs with the operation in BoxToMaskd
+            d[box_key], d[label_key] = self.converter(d[box_mask_key])
+        return d
+
+
+class RandCropBoxByPosNegLabeld(Randomizable, MapTransform):
+    """
+    Crop random fixed sized regions that contains foreground boxes.
+    Suppose all the expected fields specified by `image_keys` have same shape,
+    and add `patch_index` to the corresponding meta data.
+    And will return a list of dictionaries for all the cropped images.
+    If a dimension of the expected spatial size is bigger than the input image size,
+    will not crop that dimension. So the cropped result may be smaller than the expected size,
+    and the cropped results of several images may not have exactly the same shape.
+
+    Args:
+        image_keys: Keys to pick image data for transformation. They need to have the same spatial size.
+        box_keys: The single key to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        label_keys: Keys that represent the labels corresponding to the ``box_keys``. Multiple keys are allowed.
+        spatial_size: the spatial size of the crop region e.g. [224, 224, 128].
+            if a dimension of ROI size is bigger than image size, will not crop that dimension of the image.
+            if its components have non-positive values, the corresponding size of `data[label_key]` will be used.
+            for example: if the spatial size of input data is [40, 40, 40] and `spatial_size=[32, 64, -1]`,
+            the spatial size of output data will be [32, 40, 40].
+        pos: used with `neg` together to calculate the ratio ``pos / (pos + neg)`` for the probability
+            to pick a foreground voxel as a center rather than a background voxel.
+        neg: used with `pos` together to calculate the ratio ``pos / (pos + neg)`` for the probability
+            to pick a foreground voxel as a center rather than a background voxel.
+        num_samples: number of samples (crop regions) to take in each list.
+        whole_box: Bool, default True, whether we prefer to contain at least one whole box in the cropped foreground patch.
+            Even if True, it is still possible to get partial box if there are multiple boxes in the image.
+        thresh_image_key: if thresh_image_key is not None, use ``label == 0 & thresh_image > image_threshold`` to select
+            the negative sample(background) center. so the crop center will only exist on valid image area.
+        image_threshold: if enabled thresh_image_key, use ``thresh_image > image_threshold`` to determine
+            the valid image content area.
+        fg_indices_key: if provided pre-computed foreground indices of `label`, will ignore above `image_key` and
+            `image_threshold`, and randomly select crop centers based on them, need to provide `fg_indices_key`
+            and `bg_indices_key` together, expect to be 1 dim array of spatial indices after flattening.
+            a typical usage is to call `FgBgToIndicesd` transform first and cache the results.
+        bg_indices_key: if provided pre-computed background indices of `label`, will ignore above `image_key` and
+            `image_threshold`, and randomly select crop centers based on them, need to provide `fg_indices_key`
+            and `bg_indices_key` together, expect to be 1 dim array of spatial indices after flattening.
+            a typical usage is to call `FgBgToIndicesd` transform first and cache the results.
+        meta_keys: explicitly indicate the key of the corresponding metadata dictionary.
+            used to add `patch_index` to the meta dict.
+            for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            the metadata is a dictionary object which contains: filename, original_shape, etc.
+            it can be a sequence of string, map to the `keys`.
+            if None, will try to construct meta_keys by `key_{meta_key_postfix}`.
+        meta_key_postfix: if meta_keys is None, use `key_{postfix}` to fetch the metadata according
+            to the key data, default is `meta_dict`, the metadata is a dictionary object.
+            used to add `patch_index` to the meta dict.
+        allow_smaller: if `False`, an exception will be raised if the image is smaller than
+            the requested ROI in any dimension. If `True`, any smaller dimensions will be set to
+            match the cropped size (i.e., no cropping in that dimension).
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    def __init__(
+        self,
+        image_keys: KeysCollection,
+        box_keys: str,
+        label_keys: KeysCollection,
+        spatial_size: Sequence[int] | int,
+        pos: float = 1.0,
+        neg: float = 1.0,
+        num_samples: int = 1,
+        whole_box: bool = True,
+        thresh_image_key: str | None = None,
+        image_threshold: float = 0.0,
+        fg_indices_key: str | None = None,
+        bg_indices_key: str | None = None,
+        meta_keys: KeysCollection | None = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        allow_smaller: bool = False,
+        allow_missing_keys: bool = False,
+    ) -> None:
+        self.image_keys = ensure_tuple(image_keys)
+        if len(self.image_keys) < 1:
+            raise ValueError("At least one image_keys should be provided.")
+
+        MapTransform.__init__(self, self.image_keys, allow_missing_keys)
+
+        box_keys_tuple = ensure_tuple(box_keys)
+        if len(box_keys_tuple) != 1:
+            raise ValueError(
+                "Please provide a single key for box_keys.\
+                All label_keys are attached to this box_keys."
+            )
+        self.box_keys = box_keys_tuple[0]
+        self.label_keys = ensure_tuple(label_keys)
+
+        self.spatial_size_: tuple[int, ...] | Sequence[int] | int = spatial_size
+
+        if pos < 0 or neg < 0:
+            raise ValueError(f"pos and neg must be nonnegative, got pos={pos} neg={neg}.")
+        if pos + neg == 0:
+            raise ValueError("Incompatible values: pos=0 and neg=0.")
+        self.pos_ratio = pos / (pos + neg)
+        if num_samples < 1:
+            raise ValueError(f"num_samples needs to be positive int, got num_samples={num_samples}.")
+        self.num_samples = num_samples
+        self.whole_box = whole_box
+
+        self.thresh_image_key = thresh_image_key
+        self.image_threshold = image_threshold
+        self.fg_indices_key = fg_indices_key
+        self.bg_indices_key = bg_indices_key
+
+        self.meta_keys = ensure_tuple_rep(None, len(self.image_keys)) if meta_keys is None else ensure_tuple(meta_keys)
+        if len(self.image_keys) != len(self.meta_keys):
+            raise ValueError("meta_keys should have the same length as keys.")
+        self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.image_keys))
+        self.centers: tuple[tuple] | None = None
+        self.allow_smaller = allow_smaller
+
+    def generate_fg_center_boxes_np(self, boxes: NdarrayOrTensor, image_size: Sequence[int]) -> np.ndarray:
+        # We don't require crop center to be within the boxes.
+        # As along as the cropped patch contains a box, it is considered as a foreground patch.
+        # Positions within extended_boxes are crop centers for foreground patches
+        spatial_dims = len(image_size)
+        boxes_np, *_ = convert_data_type(boxes, np.ndarray)
+
+        extended_boxes = np.zeros_like(boxes_np, dtype=int)
+        boxes_start = np.ceil(boxes_np[:, :spatial_dims]).astype(int)
+        boxes_stop = np.floor(boxes_np[:, spatial_dims:]).astype(int)
+        for axis in range(spatial_dims):
+            if not self.whole_box:
+                extended_boxes[:, axis] = boxes_start[:, axis] - self.spatial_size[axis] // 2 + 1
+                extended_boxes[:, axis + spatial_dims] = boxes_stop[:, axis] + self.spatial_size[axis] // 2 - 1
+            else:
+                # extended box start
+                extended_boxes[:, axis] = boxes_stop[:, axis] - self.spatial_size[axis] // 2 - 1
+                extended_boxes[:, axis] = np.minimum(extended_boxes[:, axis], boxes_start[:, axis])
+                # extended box stop
+                extended_boxes[:, axis + spatial_dims] = extended_boxes[:, axis] + self.spatial_size[axis] // 2
+                extended_boxes[:, axis + spatial_dims] = np.maximum(
+                    extended_boxes[:, axis + spatial_dims], boxes_stop[:, axis]
+                )
+        extended_boxes, _ = clip_boxes_to_image(extended_boxes, image_size, remove_empty=True)  # type: ignore
+        return extended_boxes
+
+    def randomize(  # type: ignore
+        self,
+        boxes: NdarrayOrTensor,
+        image_size: Sequence[int],
+        fg_indices: NdarrayOrTensor | None = None,
+        bg_indices: NdarrayOrTensor | None = None,
+        thresh_image: NdarrayOrTensor | None = None,
+    ) -> None:
+        if fg_indices is None or bg_indices is None:
+            # We don't require crop center to be within the boxes.
+            # As along as the cropped patch contains a box, it is considered as a foreground patch.
+            # Positions within extended_boxes are crop centers for foreground patches
+            extended_boxes_np = self.generate_fg_center_boxes_np(boxes, image_size)
+            mask_img = convert_box_to_mask(
+                extended_boxes_np, np.ones(extended_boxes_np.shape[0]), image_size, bg_label=0, ellipse_mask=False
+            )
+            mask_img = np.amax(mask_img, axis=0, keepdims=True)[0:1, ...]
+            fg_indices_, bg_indices_ = map_binary_to_indices(mask_img, thresh_image, self.image_threshold)
+        else:
+            fg_indices_ = fg_indices
+            bg_indices_ = bg_indices
+
+        self.centers = generate_pos_neg_label_crop_centers(
+            self.spatial_size,
+            self.num_samples,
+            self.pos_ratio,
+            image_size,
+            fg_indices_,
+            bg_indices_,
+            self.R,
+            self.allow_smaller,
+        )
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> list[dict[Hashable, torch.Tensor]]:
+        d = dict(data)
+        image_size = d[self.image_keys[0]].shape[1:]
+        self.spatial_size = fall_back_tuple(self.spatial_size_, image_size)
+
+        # randomly sample crop centers
+        boxes = d[self.box_keys]
+        labels = [d[label_key] for label_key in self.label_keys]  # could be multiple arrays
+        fg_indices = d.pop(self.fg_indices_key, None) if self.fg_indices_key is not None else None
+        bg_indices = d.pop(self.bg_indices_key, None) if self.bg_indices_key is not None else None
+        thresh_image = d[self.thresh_image_key] if self.thresh_image_key else None
+        self.randomize(boxes, image_size, fg_indices, bg_indices, thresh_image)
+
+        if self.centers is None:
+            raise ValueError("no available ROI centers to crop.")
+
+        # initialize returned list with shallow copy to preserve key ordering
+        results: list[dict[Hashable, torch.Tensor]] = [dict(d) for _ in range(self.num_samples)]
+
+        # crop images and boxes for each center.
+        for i, center in enumerate(self.centers):
+            results[i] = deepcopy(d)
+            # compute crop start and end, always crop, no padding
+            cropper = SpatialCrop(roi_center=tuple(center), roi_size=self.spatial_size)
+            crop_start = [max(s.start, 0) for s in cropper.slices]
+            crop_end = [min(s.stop, image_size_a) for s, image_size_a in zip(cropper.slices, image_size)]
+            crop_slices = [slice(int(s), int(e)) for s, e in zip(crop_start, crop_end)]
+
+            # crop images
+            cropper = SpatialCrop(roi_slices=crop_slices)
+            for image_key in self.image_keys:
+                results[i][image_key] = cropper(d[image_key])
+
+            # crop boxes and labels
+            boxcropper = SpatialCropBox(roi_slices=crop_slices)
+            results[i][self.box_keys], cropped_labels = boxcropper(boxes, labels)
+            for label_key, cropped_labels_i in zip(self.label_keys, cropped_labels):
+                results[i][label_key] = cropped_labels_i
+
+        return results
+
+
+class RotateBox90d(MapTransform, InvertibleTransform):
+    """
+    Input boxes and images are rotated by 90 degrees
+    in the plane specified by ``spatial_axes`` for ``k`` times
+
+    Args:
+        image_keys: Keys to pick image data for transformation.
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: Keys that represent the reference images to which ``box_keys`` are attached.
+        k: number of times to rotate by 90 degrees.
+        spatial_axes: 2 int numbers, defines the plane to rotate with 2 spatial axes.
+            Default (0, 1), this is the first two axis in spatial dimensions.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    backend = RotateBox90.backend
+
+    def __init__(
+        self,
+        image_keys: KeysCollection,
+        box_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        k: int = 1,
+        spatial_axes: tuple[int, int] = (0, 1),
+        allow_missing_keys: bool = False,
+    ) -> None:
+        self.image_keys = ensure_tuple(image_keys)
+        self.box_keys = ensure_tuple(box_keys)
+        super().__init__(self.image_keys + self.box_keys, allow_missing_keys)
+        self.box_ref_image_keys = ensure_tuple_rep(box_ref_image_keys, len(self.box_keys))
+        self.img_rotator = Rotate90(k, spatial_axes)
+        self.box_rotator = RotateBox90(k, spatial_axes)
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> Mapping[Hashable, torch.Tensor]:
+        d = dict(data)
+        for key, box_ref_image_key in zip(self.box_keys, self.box_ref_image_keys):
+            spatial_size = list(d[box_ref_image_key].shape[1:])
+            d[key] = self.box_rotator(d[key], spatial_size)
+            if self.img_rotator.k % 2 == 1:
+                # if k = 1 or 3, spatial_size will be transposed
+                spatial_size[self.img_rotator.spatial_axes[0]], spatial_size[self.img_rotator.spatial_axes[1]] = (
+                    spatial_size[self.img_rotator.spatial_axes[1]],
+                    spatial_size[self.img_rotator.spatial_axes[0]],
+                )
+            self.push_transform(d, key, extra_info={"spatial_size": spatial_size, "type": "box_key"})
+
+        for key in self.image_keys:
+            d[key] = self.img_rotator(d[key])
+        return d
+
+    def inverse(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+
+        for key in self.key_iterator(d):
+            transform = self.get_most_recent_transform(d, key, check=False)
+            key_type = transform[TraceKeys.EXTRA_INFO].get("type", "image_key")
+            num_times_to_rotate = 4 - self.img_rotator.k
+
+            if key_type == "image_key":
+                d[key] = self.img_rotator.inverse(d[key])
+            if key_type == "box_key":
+                spatial_size = transform[TraceKeys.EXTRA_INFO]["spatial_size"]
+                inverse_transform = RotateBox90(num_times_to_rotate, self.box_rotator.spatial_axes)
+                d[key] = inverse_transform(d[key], spatial_size)
+                self.pop_transform(d, key)
+        return d
+
+
+class RandRotateBox90d(RandomizableTransform, MapTransform, InvertibleTransform):
+    """
+    With probability `prob`, input boxes and images are rotated by 90 degrees
+    in the plane specified by `spatial_axes`.
+
+    Args:
+        image_keys: Keys to pick image data for transformation.
+        box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
+        box_ref_image_keys: Keys that represent the reference images to which ``box_keys`` are attached.
+        prob: probability of rotating.
+            (Default 0.1, with 10% probability it returns a rotated array.)
+        max_k: number of rotations will be sampled from `np.random.randint(max_k) + 1`.
+            (Default 3)
+        spatial_axes: 2 int numbers, defines the plane to rotate with 2 spatial axes.
+            Default: (0, 1), this is the first two axis in spatial dimensions.
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    backend = RotateBox90.backend
+
+    def __init__(
+        self,
+        image_keys: KeysCollection,
+        box_keys: KeysCollection,
+        box_ref_image_keys: KeysCollection,
+        prob: float = 0.1,
+        max_k: int = 3,
+        spatial_axes: tuple[int, int] = (0, 1),
+        allow_missing_keys: bool = False,
+    ) -> None:
+        self.image_keys = ensure_tuple(image_keys)
+        self.box_keys = ensure_tuple(box_keys)
+
+        MapTransform.__init__(self, self.image_keys + self.box_keys, allow_missing_keys)
+        RandomizableTransform.__init__(self, prob)
+
+        self.max_k = max_k
+        self.spatial_axes = spatial_axes
+        self._rand_k = 0
+        self.box_ref_image_keys = ensure_tuple_rep(box_ref_image_keys, len(self.box_keys))
+
+    def __call__(self, data: Mapping[Hashable, torch.Tensor]) -> Mapping[Hashable, torch.Tensor]:
+        self.randomize()
+        d = dict(data)
+
+        if self._rand_k % 4 == 0:
+            return d
+
+        # FIXME: here we didn't use array version `RandRotate90` transform as others, because we need
+        # to be compatible with the random status of some previous integration tests
+        box_rotator = RotateBox90(self._rand_k, self.spatial_axes)
+        img_rotator = Rotate90(self._rand_k, self.spatial_axes)
+
+        for key, box_ref_image_key in zip(self.box_keys, self.box_ref_image_keys):
+            if self._do_transform:
+                spatial_size = list(d[box_ref_image_key].shape[1:])
+                d[key] = box_rotator(d[key], spatial_size)
+                if self._rand_k % 2 == 1:
+                    # if k = 1 or 3, spatial_size will be transposed
+                    spatial_size[self.spatial_axes[0]], spatial_size[self.spatial_axes[1]] = (
+                        spatial_size[self.spatial_axes[1]],
+                        spatial_size[self.spatial_axes[0]],
+                    )
+                self.push_transform(
+                    d, key, extra_info={"rand_k": self._rand_k, "spatial_size": spatial_size, "type": "box_key"}
+                )
+
+        for key in self.image_keys:
+            if self._do_transform:
+                d[key] = (
+                    img_rotator(d[key])
+                    if self._do_transform
+                    else convert_to_tensor(d[key], track_meta=get_track_meta())
+                )
+                if get_track_meta():
+                    xform = self.pop_transform(d[key], check=False) if self._do_transform else {}
+                    self.push_transform(d[key], extra_info=xform)
+        return d
+
+    def randomize(self, data: Any | None = None) -> None:
+        self._rand_k = self.R.randint(self.max_k) + 1
+        super().randomize(None)
+
+    def inverse(self, data: Mapping[Hashable, torch.Tensor]) -> dict[Hashable, torch.Tensor]:
+        d = dict(data)
+        if self._rand_k % 4 == 0:
+            return d
+
+        for key in self.key_iterator(d):
+            transform = self.get_most_recent_transform(d, key, check=False)
+            key_type = transform[TraceKeys.EXTRA_INFO].get("type", "image_key")
+            # Check if random transform was actually performed (based on `prob`)
+            if transform[TraceKeys.DO_TRANSFORM]:
+                # flip image, copied from monai.transforms.spatial.dictionary.RandFlipd
+                if key_type == "image_key":
+                    xform = self.pop_transform(d, key, check=False)
+                    d[key] = Rotate90().inverse_transform(d[key], xform[TraceKeys.EXTRA_INFO])
+                if key_type == "box_key":
+                    num_times_rotated = transform[TraceKeys.EXTRA_INFO]["rand_k"]
+                    num_times_to_rotate = 4 - num_times_rotated
+                    spatial_size = transform[TraceKeys.EXTRA_INFO]["spatial_size"]
+                    inverse_transform = RotateBox90(num_times_to_rotate, self.spatial_axes)
+                    d[key] = inverse_transform(d[key], spatial_size)
+                    self.pop_transform(d, key)
+        return d
+
+
+ConvertBoxModeD = ConvertBoxModeDict = ConvertBoxModed
+ConvertBoxToStandardModeD = ConvertBoxToStandardModeDict = ConvertBoxToStandardModed
+ZoomBoxD = ZoomBoxDict = ZoomBoxd
+RandZoomBoxD = RandZoomBoxDict = RandZoomBoxd
+AffineBoxToImageCoordinateD = AffineBoxToImageCoordinateDict = AffineBoxToImageCoordinated
+FlipBoxD = FlipBoxDict = FlipBoxd
+RandFlipBoxD = RandFlipBoxDict = RandFlipBoxd
+ClipBoxToImageD = ClipBoxToImageDict = ClipBoxToImaged
+BoxToMaskD = BoxToMaskDict = BoxToMaskd
+MaskToBoxD = MaskToBoxDict = MaskToBoxd
+RandCropBoxByPosNegLabelD = RandCropBoxByPosNegLabelDict = RandCropBoxByPosNegLabeld
+RotateBox90D = RotateBox90Dict = RotateBox90d
+RandRotateBox90D = RandRotateBox90Dict = RandRotateBox90d
+StandardizeEmptyBoxD = StandardizeEmptyBoxDict = StandardizeEmptyBoxd

source_code/SegMamba/monai/apps/detection/utils/ATSS_matcher.py

@@ -0,0 +1,291 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/core/boxes/matcher.py
+# which has the following license...
+# https://github.com/MIC-DKFZ/nnDetection/blob/main/LICENSE
+#
+# Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#    http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/pytorch/vision/blob/main/torchvision/models/detection/_utils.py
+# which has the following license...
+# https://github.com/pytorch/vision/blob/main/LICENSE
+#
+# BSD 3-Clause License
+
+# Copyright (c) Soumith Chintala 2016,
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+The functions in this script are adapted from nnDetection,
+https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/core/boxes/matcher.py
+which is adapted from torchvision.
+
+These are the changes compared with nndetection:
+1) comments and docstrings;
+2) reformat;
+3) add a debug option to ATSSMatcher to help the users to tune parameters;
+4) add a corner case return in ATSSMatcher.compute_matches;
+5) add support for float16 cpu
+"""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Sequence
+from typing import TypeVar
+
+import torch
+from torch import Tensor
+
+from monai.data.box_utils import COMPUTE_DTYPE, box_iou, boxes_center_distance, centers_in_boxes
+from monai.utils.type_conversion import convert_to_tensor
+
+# -INF should be smaller than the lower bound of similarity_fn output.
+INF = float("inf")
+
+
+class Matcher(ABC):
+    """
+    Base class of Matcher, which matches boxes and anchors to each other
+
+    Args:
+        similarity_fn: function for similarity computation between
+            boxes and anchors
+    """
+
+    BELOW_LOW_THRESHOLD: int = -1
+    BETWEEN_THRESHOLDS: int = -2
+
+    def __init__(self, similarity_fn: Callable[[Tensor, Tensor], Tensor] = box_iou):  # type: ignore
+        self.similarity_fn = similarity_fn
+
+    def __call__(
+        self, boxes: torch.Tensor, anchors: torch.Tensor, num_anchors_per_level: Sequence[int], num_anchors_per_loc: int
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Compute matches for a single image
+
+        Args:
+            boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            anchors: anchors to match Mx4 or Mx6, also assumed to be ``StandardMode``.
+            num_anchors_per_level: number of anchors per feature pyramid level
+            num_anchors_per_loc: number of anchors per position
+
+        Returns:
+            - matrix which contains the similarity from each boxes to each anchor [N, M]
+            - vector which contains the matched box index for all
+                anchors (if background `BELOW_LOW_THRESHOLD` is used
+                and if it should be ignored `BETWEEN_THRESHOLDS` is used) [M]
+
+        Note:
+            ``StandardMode`` = :class:`~monai.data.box_utils.CornerCornerModeTypeA`,
+            also represented as "xyxy" ([xmin, ymin, xmax, ymax]) for 2D
+            and "xyzxyz" ([xmin, ymin, zmin, xmax, ymax, zmax]) for 3D.
+        """
+        if boxes.numel() == 0:
+            # no ground truth
+            num_anchors = anchors.shape[0]
+            match_quality_matrix = torch.tensor([]).to(anchors)
+            matches = torch.empty(num_anchors, dtype=torch.int64).fill_(self.BELOW_LOW_THRESHOLD)
+            return match_quality_matrix, matches
+        # at least one ground truth
+        return self.compute_matches(
+            boxes=boxes,
+            anchors=anchors,
+            num_anchors_per_level=num_anchors_per_level,
+            num_anchors_per_loc=num_anchors_per_loc,
+        )
+
+    @abstractmethod
+    def compute_matches(
+        self, boxes: torch.Tensor, anchors: torch.Tensor, num_anchors_per_level: Sequence[int], num_anchors_per_loc: int
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Compute matches
+
+        Args:
+            boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            anchors: anchors to match Mx4 or Mx6, also assumed to be ``StandardMode``.
+            num_anchors_per_level: number of anchors per feature pyramid level
+            num_anchors_per_loc: number of anchors per position
+
+        Returns:
+            - matrix which contains the similarity from each boxes to each anchor [N, M]
+            - vector which contains the matched box index for all
+              anchors (if background `BELOW_LOW_THRESHOLD` is used
+              and if it should be ignored `BETWEEN_THRESHOLDS` is used) [M]
+        """
+        raise NotImplementedError
+
+
+class ATSSMatcher(Matcher):
+
+    def __init__(
+        self,
+        num_candidates: int = 4,
+        similarity_fn: Callable[[Tensor, Tensor], Tensor] = box_iou,  # type: ignore
+        center_in_gt: bool = True,
+        debug: bool = False,
+    ):
+        """
+        Compute matching based on ATSS https://arxiv.org/abs/1912.02424
+        `Bridging the Gap Between Anchor-based and Anchor-free Detection
+        via Adaptive Training Sample Selection`
+
+        Args:
+            num_candidates: number of positions to select candidates from.
+                Smaller value will result in a higher matcher threshold and less matched candidates.
+            similarity_fn: function for similarity computation between boxes and anchors
+            center_in_gt: If False (default), matched anchor center points do not need
+                to lie withing the ground truth box. Recommend False for small objects.
+                If True, will result in a strict matcher and less matched candidates.
+            debug: if True, will print the matcher threshold in order to
+                tune ``num_candidates`` and ``center_in_gt``.
+        """
+        super().__init__(similarity_fn=similarity_fn)
+        self.num_candidates = num_candidates
+        self.min_dist = 0.01
+        self.center_in_gt = center_in_gt
+        self.debug = debug
+        logging.info(
+            f"Running ATSS Matching with num_candidates={self.num_candidates} and center_in_gt {self.center_in_gt}."
+        )
+
+    def compute_matches(
+        self, boxes: torch.Tensor, anchors: torch.Tensor, num_anchors_per_level: Sequence[int], num_anchors_per_loc: int
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Compute matches according to ATTS for a single image
+        Adapted from
+        (https://github.com/sfzhang15/ATSS/blob/79dfb28bd1/atss_core/modeling/rpn/atss/loss.py#L180-L184)
+
+        Args:
+            boxes: bounding boxes, Nx4 or Nx6 torch tensor or ndarray. The box mode is assumed to be ``StandardMode``
+            anchors: anchors to match Mx4 or Mx6, also assumed to be ``StandardMode``.
+            num_anchors_per_level: number of anchors per feature pyramid level
+            num_anchors_per_loc: number of anchors per position
+
+        Returns:
+            - matrix which contains the similarity from each boxes to each anchor [N, M]
+            - vector which contains the matched box index for all
+              anchors (if background `BELOW_LOW_THRESHOLD` is used
+              and if it should be ignored `BETWEEN_THRESHOLDS` is used) [M]
+
+        Note:
+            ``StandardMode`` = :class:`~monai.data.box_utils.CornerCornerModeTypeA`,
+            also represented as "xyxy" ([xmin, ymin, xmax, ymax]) for 2D
+            and "xyzxyz" ([xmin, ymin, zmin, xmax, ymax, zmax]) for 3D.
+        """
+        num_gt = boxes.shape[0]
+        num_anchors = anchors.shape[0]
+
+        distances_, _, anchors_center = boxes_center_distance(boxes, anchors)  # num_boxes x anchors
+        distances = convert_to_tensor(distances_)
+
+        # select candidates based on center distance
+        candidate_idx_list = []
+        start_idx = 0
+        for _, apl in enumerate(num_anchors_per_level):
+            end_idx = start_idx + apl * num_anchors_per_loc
+
+            # topk: total number of candidates per position
+            topk = min(self.num_candidates * num_anchors_per_loc, apl)
+            # torch.topk() does not support float16 cpu, need conversion to float32 or float64
+            _, idx = distances[:, start_idx:end_idx].to(COMPUTE_DTYPE).topk(topk, dim=1, largest=False)
+            # idx: shape [num_boxes x topk]
+            candidate_idx_list.append(idx + start_idx)
+
+            start_idx = end_idx
+        # [num_boxes x num_candidates] (index of candidate anchors)
+        candidate_idx = torch.cat(candidate_idx_list, dim=1)
+
+        match_quality_matrix = self.similarity_fn(boxes, anchors)  # [num_boxes x anchors]
+        candidate_ious = match_quality_matrix.gather(1, candidate_idx)  # [num_boxes, n_candidates]
+
+        # corner case, n_candidates<=1 will make iou_std_per_gt NaN
+        if candidate_idx.shape[1] <= 1:
+            matches = -1 * torch.ones((num_anchors,), dtype=torch.long, device=boxes.device)
+            matches[candidate_idx] = 0
+            return match_quality_matrix, matches
+
+        # compute adaptive iou threshold
+        iou_mean_per_gt = candidate_ious.mean(dim=1)  # [num_boxes]
+        iou_std_per_gt = candidate_ious.std(dim=1)  # [num_boxes]
+        iou_thresh_per_gt = iou_mean_per_gt + iou_std_per_gt  # [num_boxes]
+        is_pos = candidate_ious >= iou_thresh_per_gt[:, None]  # [num_boxes x n_candidates]
+        if self.debug:
+            print(f"Anchor matcher threshold: {iou_thresh_per_gt}")
+
+        if self.center_in_gt:  # can discard all candidates in case of very small objects :/
+            # center point of selected anchors needs to lie within the ground truth
+            boxes_idx = (
+                torch.arange(num_gt, device=boxes.device, dtype=torch.long)[:, None]
+                .expand_as(candidate_idx)
+                .contiguous()
+            )  # [num_boxes x n_candidates]
+            is_in_gt_ = centers_in_boxes(
+                anchors_center[candidate_idx.view(-1)], boxes[boxes_idx.view(-1)], eps=self.min_dist
+            )
+            is_in_gt = convert_to_tensor(is_in_gt_)
+            is_pos = is_pos & is_in_gt.view_as(is_pos)  # [num_boxes x n_candidates]
+
+        # in case on anchor is assigned to multiple boxes, use box with highest IoU
+        # TODO: think about a better way to do this
+        for ng in range(num_gt):
+            candidate_idx[ng, :] += ng * num_anchors
+        ious_inf = torch.full_like(match_quality_matrix, -INF).view(-1)
+        index = candidate_idx.view(-1)[is_pos.view(-1)]
+        ious_inf[index] = match_quality_matrix.view(-1)[index]
+        ious_inf = ious_inf.view_as(match_quality_matrix)
+
+        matched_vals, matches = ious_inf.to(COMPUTE_DTYPE).max(dim=0)
+        matches[matched_vals == -INF] = self.BELOW_LOW_THRESHOLD
+        return match_quality_matrix, matches
+
+
+MatcherType = TypeVar("MatcherType", bound=Matcher)

source_code/SegMamba/monai/apps/detection/utils/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/detection/utils/anchor_utils.py

@@ -0,0 +1,410 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/pytorch/vision/blob/release/0.12/torchvision/models/detection/anchor_utils.py
+# which has the following license...
+# https://github.com/pytorch/vision/blob/main/LICENSE
+
+# BSD 3-Clause License
+
+# Copyright (c) Soumith Chintala 2016,
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+"""
+This script is adapted from
+https://github.com/pytorch/vision/blob/release/0.12/torchvision/models/detection/anchor_utils.py
+"""
+
+from __future__ import annotations
+
+from typing import List, Sequence
+
+import torch
+from torch import Tensor, nn
+
+from monai.utils import ensure_tuple
+from monai.utils.misc import issequenceiterable
+from monai.utils.module import look_up_option
+
+
+class AnchorGenerator(nn.Module):
+    """
+    This module is modified from torchvision to support both 2D and 3D images.
+
+    Module that generates anchors for a set of feature maps and
+    image sizes.
+
+    The module support computing anchors at multiple sizes and aspect ratios
+    per feature map.
+
+    sizes and aspect_ratios should have the same number of elements, and it should
+    correspond to the number of feature maps.
+
+    sizes[i] and aspect_ratios[i] can have an arbitrary number of elements.
+    For 2D images, anchor width and height w:h = 1:aspect_ratios[i,j]
+    For 3D images, anchor width, height, and depth w:h:d = 1:aspect_ratios[i,j,0]:aspect_ratios[i,j,1]
+
+    AnchorGenerator will output a set of sizes[i] * aspect_ratios[i] anchors
+    per spatial location for feature map i.
+
+    Args:
+        sizes: base size of each anchor.
+            len(sizes) is the number of feature maps, i.e., the number of output levels for
+            the feature pyramid network (FPN).
+            Each element of ``sizes`` is a Sequence which represents several anchor sizes for each feature map.
+        aspect_ratios: the aspect ratios of anchors. ``len(aspect_ratios) = len(sizes)``.
+            For 2D images, each element of ``aspect_ratios[i]`` is a Sequence of float.
+            For 3D images, each element of ``aspect_ratios[i]`` is a Sequence of 2 value Sequence.
+        indexing: choose from {``'ij'``, ``'xy'``}, optional,
+            Matrix (``'ij'``, default and recommended) or Cartesian (``'xy'``) indexing of output.
+
+            - Matrix (``'ij'``, default and recommended) indexing keeps the original axis not changed.
+            - To use other monai detection components, please set ``indexing = 'ij'``.
+            - Cartesian (``'xy'``) indexing swaps axis 0 and 1.
+            - For 2D cases, monai ``AnchorGenerator(sizes, aspect_ratios, indexing='xy')`` and
+              ``torchvision.models.detection.anchor_utils.AnchorGenerator(sizes, aspect_ratios)`` are equivalent.
+
+
+    Reference:.
+        https://github.com/pytorch/vision/blob/release/0.12/torchvision/models/detection/anchor_utils.py
+
+    Example:
+        .. code-block:: python
+
+            # 2D example inputs for a 2-level feature maps
+            sizes = ((10,12,14,16), (20,24,28,32))
+            base_aspect_ratios = (1., 0.5,  2.)
+            aspect_ratios = (base_aspect_ratios, base_aspect_ratios)
+            anchor_generator = AnchorGenerator(sizes, aspect_ratios)
+
+            # 3D example inputs for a 2-level feature maps
+            sizes = ((10,12,14,16), (20,24,28,32))
+            base_aspect_ratios = ((1., 1.), (1., 0.5), (0.5, 1.), (2., 2.))
+            aspect_ratios = (base_aspect_ratios, base_aspect_ratios)
+            anchor_generator = AnchorGenerator(sizes, aspect_ratios)
+    """
+
+    __annotations__ = {"cell_anchors": List[torch.Tensor]}
+
+    def __init__(
+        self,
+        sizes: Sequence[Sequence[int]] = ((20, 30, 40),),
+        aspect_ratios: Sequence = (((0.5, 1), (1, 0.5)),),
+        indexing: str = "ij",
+    ) -> None:
+        super().__init__()
+
+        if not issequenceiterable(sizes[0]):
+            self.sizes = tuple((s,) for s in sizes)
+        else:
+            self.sizes = ensure_tuple(sizes)
+        if not issequenceiterable(aspect_ratios[0]):
+            aspect_ratios = (aspect_ratios,) * len(self.sizes)
+
+        if len(self.sizes) != len(aspect_ratios):
+            raise ValueError(
+                "len(sizes) and len(aspect_ratios) should be equal. \
+                It represents the number of feature maps."
+            )
+
+        spatial_dims = len(ensure_tuple(aspect_ratios[0][0])) + 1
+        spatial_dims = look_up_option(spatial_dims, [2, 3])
+        self.spatial_dims = spatial_dims
+
+        self.indexing = look_up_option(indexing, ["ij", "xy"])
+
+        self.aspect_ratios = aspect_ratios
+        self.cell_anchors = [
+            self.generate_anchors(size, aspect_ratio) for size, aspect_ratio in zip(self.sizes, aspect_ratios)
+        ]
+
+    # This comment comes from torchvision.
+    # TODO: https://github.com/pytorch/pytorch/issues/26792
+    # For every (aspect_ratios, scales) combination, output a zero-centered anchor with those values.
+    # (scales, aspect_ratios) are usually an element of zip(self.scales, self.aspect_ratios)
+    # This method assumes aspect ratio = height / width for an anchor.
+    def generate_anchors(
+        self,
+        scales: Sequence,
+        aspect_ratios: Sequence,
+        dtype: torch.dtype = torch.float32,
+        device: torch.device | None = None,
+    ) -> torch.Tensor:
+        """
+        Compute cell anchor shapes at multiple sizes and aspect ratios for the current feature map.
+
+        Args:
+            scales: a sequence which represents several anchor sizes for the current feature map.
+            aspect_ratios: a sequence which represents several aspect_ratios for the current feature map.
+                For 2D images, it is a Sequence of float aspect_ratios[j],
+                anchor width and height w:h = 1:aspect_ratios[j].
+                For 3D images, it is a Sequence of 2 value Sequence aspect_ratios[j,0] and aspect_ratios[j,1],
+                anchor width, height, and depth w:h:d = 1:aspect_ratios[j,0]:aspect_ratios[j,1]
+            dtype: target data type of the output Tensor.
+            device: target device to put the output Tensor data.
+
+            Returns:
+                For each s in scales, returns [s, s*aspect_ratios[j]] for 2D images,
+                and [s, s*aspect_ratios[j,0],s*aspect_ratios[j,1]] for 3D images.
+        """
+        scales_t = torch.as_tensor(scales, dtype=dtype, device=device)  # sized (N,)
+        aspect_ratios_t = torch.as_tensor(aspect_ratios, dtype=dtype, device=device)  # sized (M,) or (M,2)
+        if (self.spatial_dims >= 3) and (len(aspect_ratios_t.shape) != 2):
+            raise ValueError(
+                f"In {self.spatial_dims}-D image, aspect_ratios for each level should be \
+                {len(aspect_ratios_t.shape)-1}-D. But got aspect_ratios with shape {aspect_ratios_t.shape}."
+            )
+
+        if (self.spatial_dims >= 3) and (aspect_ratios_t.shape[1] != self.spatial_dims - 1):
+            raise ValueError(
+                f"In {self.spatial_dims}-D image, aspect_ratios for each level should has \
+                shape (_,{self.spatial_dims-1}). But got aspect_ratios with shape {aspect_ratios_t.shape}."
+            )
+
+        # if 2d, w:h = 1:aspect_ratios
+        if self.spatial_dims == 2:
+            area_scale = torch.sqrt(aspect_ratios_t)
+            w_ratios = 1 / area_scale
+            h_ratios = area_scale
+        # if 3d, w:h:d = 1:aspect_ratios[:,0]:aspect_ratios[:,1]
+        elif self.spatial_dims == 3:
+            area_scale = torch.pow(aspect_ratios_t[:, 0] * aspect_ratios_t[:, 1], 1 / 3.0)
+            w_ratios = 1 / area_scale
+            h_ratios = aspect_ratios_t[:, 0] / area_scale
+            d_ratios = aspect_ratios_t[:, 1] / area_scale
+
+        ws = (w_ratios[:, None] * scales_t[None, :]).view(-1)
+        hs = (h_ratios[:, None] * scales_t[None, :]).view(-1)
+        if self.spatial_dims == 2:
+            base_anchors = torch.stack([-ws, -hs, ws, hs], dim=1) / 2.0
+        elif self.spatial_dims == 3:
+            ds = (d_ratios[:, None] * scales_t[None, :]).view(-1)
+            base_anchors = torch.stack([-ws, -hs, -ds, ws, hs, ds], dim=1) / 2.0
+
+        return base_anchors.round()
+
+    def set_cell_anchors(self, dtype: torch.dtype, device: torch.device) -> None:
+        """
+        Convert each element in self.cell_anchors to ``dtype`` and send to ``device``.
+        """
+        self.cell_anchors = [cell_anchor.to(dtype=dtype, device=device) for cell_anchor in self.cell_anchors]
+
+    def num_anchors_per_location(self):
+        """
+        Return number of anchor shapes for each feature map.
+        """
+        return [c.shape[0] for c in self.cell_anchors]
+
+    def grid_anchors(self, grid_sizes: list[list[int]], strides: list[list[Tensor]]) -> list[Tensor]:
+        """
+        Every combination of (a, (g, s), i) in (self.cell_anchors, zip(grid_sizes, strides), 0:spatial_dims)
+        corresponds to a feature map.
+        It outputs g[i] anchors that are s[i] distance apart in direction i, with the same dimensions as a.
+
+        Args:
+            grid_sizes: spatial size of the feature maps
+            strides: strides of the feature maps regarding to the original image
+
+        Example:
+            .. code-block:: python
+
+                grid_sizes = [[100,100],[50,50]]
+                strides = [[torch.tensor(2),torch.tensor(2)], [torch.tensor(4),torch.tensor(4)]]
+        """
+        anchors = []
+        cell_anchors = self.cell_anchors
+        if cell_anchors is None:
+            raise AssertionError
+
+        if not (len(grid_sizes) == len(strides) == len(cell_anchors)):
+            raise ValueError(
+                "Anchors should be Tuple[Tuple[int]] because each feature "
+                "map could potentially have different sizes and aspect ratios. "
+                "There needs to be a match between the number of "
+                "feature maps passed and the number of sizes / aspect ratios specified."
+            )
+
+        for size, stride, base_anchors in zip(grid_sizes, strides, cell_anchors):
+            # for each feature map
+            device = base_anchors.device
+
+            # compute anchor centers regarding to the image.
+            # shifts_centers is [x_center, y_center] or [x_center, y_center, z_center]
+            shifts_centers = [
+                torch.arange(0, size[axis], dtype=torch.int32, device=device) * stride[axis]
+                for axis in range(self.spatial_dims)
+            ]
+
+            # to support torchscript, cannot directly use torch.meshgrid(shifts_centers).
+            shifts_centers = list(torch.meshgrid(shifts_centers[: self.spatial_dims], indexing="ij"))
+
+            for axis in range(self.spatial_dims):
+                # each element of shifts_centers is sized (HW,) or (HWD,)
+                shifts_centers[axis] = shifts_centers[axis].reshape(-1)
+
+            # Expand to [x_center, y_center, x_center, y_center],
+            # or [x_center, y_center, z_center, x_center, y_center, z_center]
+            if self.indexing == "xy":
+                # Cartesian ('xy') indexing swaps axis 0 and 1.
+                shifts_centers[1], shifts_centers[0] = shifts_centers[0], shifts_centers[1]
+            shifts = torch.stack(shifts_centers * 2, dim=1)  # sized (HW,4) or (HWD,6)
+
+            # For every (base anchor, output anchor) pair,
+            # offset each zero-centered base anchor by the center of the output anchor.
+            anchors.append(
+                (shifts.view(-1, 1, self.spatial_dims * 2) + base_anchors.view(1, -1, self.spatial_dims * 2)).reshape(
+                    -1, self.spatial_dims * 2
+                )  # each element sized (AHWD,4) or (AHWD,6)
+            )
+
+        return anchors
+
+    def forward(self, images: Tensor, feature_maps: list[Tensor]) -> list[Tensor]:
+        """
+        Generate anchor boxes for each image.
+
+        Args:
+            images: sized (B, C, W, H) or (B, C, W, H, D)
+            feature_maps: for FPN level i, feature_maps[i] is sized (B, C_i, W_i, H_i) or (B, C_i, W_i, H_i, D_i).
+                This input argument does not have to be the actual feature maps.
+                Any list variable with the same (C_i, W_i, H_i) or (C_i, W_i, H_i, D_i) as feature maps works.
+
+        Return:
+            A list with length of B. Each element represents the anchors for this image.
+            The B elements are identical.
+
+        Example:
+            .. code-block:: python
+
+                images = torch.zeros((3,1,128,128,128))
+                feature_maps = [torch.zeros((3,6,64,64,32)), torch.zeros((3,6,32,32,16))]
+                anchor_generator(images, feature_maps)
+        """
+        grid_sizes = [list(feature_map.shape[-self.spatial_dims :]) for feature_map in feature_maps]
+        image_size = images.shape[-self.spatial_dims :]
+        batchsize = images.shape[0]
+        dtype, device = feature_maps[0].dtype, feature_maps[0].device
+        strides = [
+            [
+                torch.tensor(image_size[axis] // g[axis], dtype=torch.int64, device=device)
+                for axis in range(self.spatial_dims)
+            ]
+            for g in grid_sizes
+        ]
+
+        self.set_cell_anchors(dtype, device)
+        anchors_over_all_feature_maps = self.grid_anchors(grid_sizes, strides)
+
+        anchors_per_image = torch.cat(list(anchors_over_all_feature_maps))
+        return [anchors_per_image] * batchsize
+
+
+class AnchorGeneratorWithAnchorShape(AnchorGenerator):
+    """
+    Module that generates anchors for a set of feature maps and
+    image sizes, inherited from :py:class:`~monai.apps.detection.networks.utils.anchor_utils.AnchorGenerator`
+
+    The module support computing anchors at multiple base anchor shapes
+    per feature map.
+
+    ``feature_map_scales`` should have the same number of elements with the number of feature maps.
+
+    base_anchor_shapes can have an arbitrary number of elements.
+    For 2D images, each element represents anchor width and height [w,h].
+    For 2D images, each element represents anchor width, height, and depth [w,h,d].
+
+    AnchorGenerator will output a set of ``len(base_anchor_shapes)`` anchors
+    per spatial location for feature map ``i``.
+
+    Args:
+        feature_map_scales: scale of anchors for each feature map, i.e., each output level of
+            the feature pyramid network (FPN). ``len(feature_map_scales)`` is the number of feature maps.
+            ``scale[i]*base_anchor_shapes`` represents the anchor shapes for feature map ``i``.
+        base_anchor_shapes: a sequence which represents several anchor shapes for one feature map.
+            For N-D images, it is a Sequence of N value Sequence.
+        indexing: choose from {'xy', 'ij'}, optional
+            Cartesian ('xy') or matrix ('ij', default) indexing of output.
+            Cartesian ('xy') indexing swaps axis 0 and 1, which is the setting inside torchvision.
+            matrix ('ij', default) indexing keeps the original axis not changed.
+            See also indexing in https://pytorch.org/docs/stable/generated/torch.meshgrid.html
+
+    Example:
+        .. code-block:: python
+
+            # 2D example inputs for a 2-level feature maps
+            feature_map_scales = (1, 2)
+            base_anchor_shapes = ((10, 10), (6, 12), (12, 6))
+            anchor_generator = AnchorGeneratorWithAnchorShape(feature_map_scales, base_anchor_shapes)
+
+            # 3D example inputs for a 2-level feature maps
+            feature_map_scales = (1, 2)
+            base_anchor_shapes = ((10, 10, 10), (12, 12, 8), (10, 10, 6), (16, 16, 10))
+            anchor_generator = AnchorGeneratorWithAnchorShape(feature_map_scales, base_anchor_shapes)
+    """
+
+    __annotations__ = {"cell_anchors": List[torch.Tensor]}
+
+    def __init__(
+        self,
+        feature_map_scales: Sequence[int] | Sequence[float] = (1, 2, 4, 8),
+        base_anchor_shapes: Sequence[Sequence[int]] | Sequence[Sequence[float]] = (
+            (32, 32, 32),
+            (48, 20, 20),
+            (20, 48, 20),
+            (20, 20, 48),
+        ),
+        indexing: str = "ij",
+    ) -> None:
+        nn.Module.__init__(self)
+
+        spatial_dims = len(base_anchor_shapes[0])
+        spatial_dims = look_up_option(spatial_dims, [2, 3])
+        self.spatial_dims = spatial_dims
+
+        self.indexing = look_up_option(indexing, ["ij", "xy"])
+
+        base_anchor_shapes_t = torch.Tensor(base_anchor_shapes)
+        self.cell_anchors = [self.generate_anchors_using_shape(s * base_anchor_shapes_t) for s in feature_map_scales]
+
+    @staticmethod
+    def generate_anchors_using_shape(
+        anchor_shapes: torch.Tensor, dtype: torch.dtype = torch.float32, device: torch.device | None = None
+    ) -> torch.Tensor:
+        """
+        Compute cell anchor shapes at multiple sizes and aspect ratios for the current feature map.
+
+        Args:
+            anchor_shapes: [w, h] or [w, h, d], sized (N, spatial_dims),
+                represents N anchor shapes for the current feature map.
+            dtype: target data type of the output Tensor.
+            device: target device to put the output Tensor data.
+
+        Returns:
+            For 2D images, returns [-w/2, -h/2, w/2, h/2];
+            For 3D images, returns [-w/2, -h/2, -d/2, w/2, h/2, d/2]
+        """
+        half_anchor_shapes = anchor_shapes / 2.0
+        base_anchors = torch.cat([-half_anchor_shapes, half_anchor_shapes], dim=1)
+        return base_anchors.round().to(dtype=dtype, device=device)

source_code/SegMamba/monai/apps/detection/utils/box_coder.py

@@ -0,0 +1,240 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/pytorch/vision/blob/main/torchvision/models/detection/_utils.py
+# which has the following license...
+# https://github.com/pytorch/vision/blob/main/LICENSE
+#
+# BSD 3-Clause License
+
+# Copyright (c) Soumith Chintala 2016,
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+This script is modified from torchvision to support N-D images,
+
+https://github.com/pytorch/vision/blob/main/torchvision/models/detection/_utils.py
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+
+import torch
+from torch import Tensor
+
+from monai.data.box_utils import COMPUTE_DTYPE, CenterSizeMode, StandardMode, convert_box_mode, is_valid_box_values
+from monai.utils.module import look_up_option
+
+
+def encode_boxes(gt_boxes: Tensor, proposals: Tensor, weights: Tensor) -> Tensor:
+    """
+    Encode a set of proposals with respect to some reference ground truth (gt) boxes.
+
+    Args:
+        gt_boxes: gt boxes, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+        proposals: boxes to be encoded, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+        weights: the weights for ``(cx, cy, w, h) or (cx,cy,cz, w,h,d)``
+
+    Return:
+        encoded gt, target of box regression that is used to convert proposals into gt_boxes, Nx4 or Nx6 torch tensor.
+    """
+
+    if gt_boxes.shape[0] != proposals.shape[0]:
+        raise ValueError("gt_boxes.shape[0] should be equal to proposals.shape[0].")
+    spatial_dims = look_up_option(len(weights), [4, 6]) // 2
+
+    if not is_valid_box_values(gt_boxes):
+        raise ValueError("gt_boxes is not valid. Please check if it contains empty boxes.")
+    if not is_valid_box_values(proposals):
+        raise ValueError("proposals is not valid. Please check if it contains empty boxes.")
+
+    # implementation starts here
+    ex_cccwhd: Tensor = convert_box_mode(proposals, src_mode=StandardMode, dst_mode=CenterSizeMode)  # type: ignore
+    gt_cccwhd: Tensor = convert_box_mode(gt_boxes, src_mode=StandardMode, dst_mode=CenterSizeMode)  # type: ignore
+    targets_dxyz = (
+        weights[:spatial_dims].unsqueeze(0)
+        * (gt_cccwhd[:, :spatial_dims] - ex_cccwhd[:, :spatial_dims])
+        / ex_cccwhd[:, spatial_dims:]
+    )
+    targets_dwhd = weights[spatial_dims:].unsqueeze(0) * torch.log(
+        gt_cccwhd[:, spatial_dims:] / ex_cccwhd[:, spatial_dims:]
+    )
+
+    targets = torch.cat((targets_dxyz, targets_dwhd), dim=1)
+    # torch.log may cause NaN or Inf
+    if torch.isnan(targets).any() or torch.isinf(targets).any():
+        raise ValueError("targets is NaN or Inf.")
+    return targets
+
+
+class BoxCoder:
+    """
+    This class encodes and decodes a set of bounding boxes into
+    the representation used for training the regressors.
+
+    Args:
+        weights: 4-element tuple or 6-element tuple
+        boxes_xform_clip: high threshold to prevent sending too large values into torch.exp()
+
+    Example:
+        .. code-block:: python
+
+            box_coder = BoxCoder(weights=[1., 1., 1., 1., 1., 1.])
+            gt_boxes = torch.tensor([[1,2,1,4,5,6],[1,3,2,7,8,9]])
+            proposals = gt_boxes + torch.rand(gt_boxes.shape)
+            rel_gt_boxes = box_coder.encode_single(gt_boxes, proposals)
+            gt_back = box_coder.decode_single(rel_gt_boxes, proposals)
+            # We expect gt_back to be equal to gt_boxes
+    """
+
+    def __init__(self, weights: Sequence[float], boxes_xform_clip: float | None = None) -> None:
+        if boxes_xform_clip is None:
+            boxes_xform_clip = math.log(1000.0 / 16)
+        self.spatial_dims = look_up_option(len(weights), [4, 6]) // 2
+        self.weights = weights
+        self.boxes_xform_clip = boxes_xform_clip
+
+    def encode(self, gt_boxes: Sequence[Tensor], proposals: Sequence[Tensor]) -> tuple[Tensor]:
+        """
+        Encode a set of proposals with respect to some ground truth (gt) boxes.
+
+        Args:
+            gt_boxes: list of gt boxes, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+            proposals: list of boxes to be encoded, each element is Mx4 or Mx6 torch tensor.
+                The box mode is assumed to be ``StandardMode``
+
+        Return:
+            A tuple of encoded gt, target of box regression that is used to
+                convert proposals into gt_boxes, Nx4 or Nx6 torch tensor.
+        """
+        boxes_per_image = [len(b) for b in gt_boxes]
+        # concat the lists to do computation
+        concat_gt_boxes = torch.cat(tuple(gt_boxes), dim=0)
+        concat_proposals = torch.cat(tuple(proposals), dim=0)
+        concat_targets = self.encode_single(concat_gt_boxes, concat_proposals)
+        # split to tuple
+        targets: tuple[Tensor] = concat_targets.split(boxes_per_image, 0)
+        return targets
+
+    def encode_single(self, gt_boxes: Tensor, proposals: Tensor) -> Tensor:
+        """
+        Encode proposals with respect to ground truth (gt) boxes.
+
+        Args:
+            gt_boxes: gt boxes, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+            proposals: boxes to be encoded, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+
+        Return:
+            encoded gt, target of box regression that is used to convert proposals into gt_boxes, Nx4 or Nx6 torch tensor.
+        """
+        dtype = gt_boxes.dtype
+        device = gt_boxes.device
+        weights = torch.as_tensor(self.weights, dtype=dtype, device=device)
+        targets = encode_boxes(gt_boxes, proposals, weights)
+        return targets
+
+    def decode(self, rel_codes: Tensor, reference_boxes: Sequence[Tensor]) -> Tensor:
+        """
+        From a set of original reference_boxes and encoded relative box offsets,
+
+        Args:
+            rel_codes: encoded boxes, Nx4 or Nx6 torch tensor.
+            reference_boxes: a list of reference boxes, each element is Mx4 or Mx6 torch tensor.
+                The box mode is assumed to be ``StandardMode``
+
+        Return:
+            decoded boxes, Nx1x4 or Nx1x6 torch tensor. The box mode will be ``StandardMode``
+        """
+        if not isinstance(reference_boxes, Sequence) or (not isinstance(rel_codes, torch.Tensor)):
+            raise ValueError("Input arguments wrong type.")
+        boxes_per_image = [b.size(0) for b in reference_boxes]
+        # concat the lists to do computation
+        concat_boxes = torch.cat(tuple(reference_boxes), dim=0)
+        box_sum = 0
+        for val in boxes_per_image:
+            box_sum += val
+        if box_sum > 0:
+            rel_codes = rel_codes.reshape(box_sum, -1)
+        pred_boxes = self.decode_single(rel_codes, concat_boxes)
+        if box_sum > 0:
+            pred_boxes = pred_boxes.reshape(box_sum, -1, 2 * self.spatial_dims)
+        return pred_boxes
+
+    def decode_single(self, rel_codes: Tensor, reference_boxes: Tensor) -> Tensor:
+        """
+        From a set of original boxes and encoded relative box offsets,
+
+        Args:
+            rel_codes: encoded boxes, Nx(4*num_box_reg) or Nx(6*num_box_reg) torch tensor.
+            reference_boxes: reference boxes, Nx4 or Nx6 torch tensor. The box mode is assumed to be ``StandardMode``
+
+        Return:
+            decoded boxes, Nx(4*num_box_reg) or Nx(6*num_box_reg) torch tensor. The box mode will to be ``StandardMode``
+        """
+        reference_boxes = reference_boxes.to(rel_codes.dtype)
+        offset = reference_boxes.shape[-1]
+
+        pred_boxes = []
+        boxes_cccwhd = convert_box_mode(reference_boxes, src_mode=StandardMode, dst_mode=CenterSizeMode)
+        for axis in range(self.spatial_dims):
+            whd_axis = boxes_cccwhd[:, axis + self.spatial_dims]
+            ctr_xyz_axis = boxes_cccwhd[:, axis]
+            dxyz_axis = rel_codes[:, axis::offset] / self.weights[axis]
+            dwhd_axis = rel_codes[:, self.spatial_dims + axis :: offset] / self.weights[axis + self.spatial_dims]
+            # Prevent sending too large values into torch.exp()
+            dwhd_axis = torch.clamp(dwhd_axis.to(COMPUTE_DTYPE), max=self.boxes_xform_clip)
+
+            pred_ctr_xyx_axis = dxyz_axis * whd_axis[:, None] + ctr_xyz_axis[:, None]
+            pred_whd_axis = torch.exp(dwhd_axis) * whd_axis[:, None]
+            pred_whd_axis = pred_whd_axis.to(dxyz_axis.dtype)
+
+            # When convert float32 to float16, Inf or Nan may occur
+            if torch.isnan(pred_whd_axis).any() or torch.isinf(pred_whd_axis).any():
+                raise ValueError("pred_whd_axis is NaN or Inf.")
+
+            # Distance from center to box's corner.
+            c_to_c_whd_axis = (
+                torch.tensor(0.5, dtype=pred_ctr_xyx_axis.dtype, device=pred_whd_axis.device) * pred_whd_axis
+            )
+
+            pred_boxes.append(pred_ctr_xyx_axis - c_to_c_whd_axis)
+            pred_boxes.append(pred_ctr_xyx_axis + c_to_c_whd_axis)
+
+        pred_boxes = pred_boxes[::2] + pred_boxes[1::2]
+        pred_boxes_final = torch.stack(pred_boxes, dim=2).flatten(1)
+        return pred_boxes_final

source_code/SegMamba/monai/apps/detection/utils/box_selector.py

@@ -0,0 +1,219 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/pytorch/vision/blob/main/torchvision/models/detection/retinanet.py
+# which has the following license...
+# https://github.com/pytorch/vision/blob/main/LICENSE
+
+# BSD 3-Clause License
+
+# Copyright (c) Soumith Chintala 2016,
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+"""
+Part of this script is adapted from
+https://github.com/pytorch/vision/blob/main/torchvision/models/detection/retinanet.py
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+import torch
+from torch import Tensor
+
+from monai.data.box_utils import batched_nms, box_iou, clip_boxes_to_image
+from monai.transforms.utils_pytorch_numpy_unification import floor_divide
+
+
+class BoxSelector:
+    """
+    Box selector which selects the predicted boxes.
+    The box selection is performed with the following steps:
+
+    #. For each level, discard boxes with scores less than self.score_thresh.
+    #. For each level, keep boxes with top self.topk_candidates_per_level scores.
+    #. For the whole image, perform non-maximum suppression (NMS) on boxes, with overlapping threshold nms_thresh.
+    #. For the whole image, keep boxes with top self.detections_per_img scores.
+
+    Args:
+        apply_sigmoid: whether to apply sigmoid to get scores from classification logits
+        score_thresh: no box with scores less than score_thresh will be kept
+        topk_candidates_per_level: max number of boxes to keep for each level
+        nms_thresh: box overlapping threshold for NMS
+        detections_per_img: max number of boxes to keep for each image
+
+    Example:
+
+        .. code-block:: python
+
+            input_param = {
+                "apply_sigmoid": True,
+                "score_thresh": 0.1,
+                "topk_candidates_per_level": 2,
+                "nms_thresh": 0.1,
+                "detections_per_img": 5,
+            }
+            box_selector = BoxSelector(**input_param)
+            boxes = [torch.randn([3,6]), torch.randn([7,6])]
+            logits = [torch.randn([3,3]), torch.randn([7,3])]
+            spatial_size = (8,8,8)
+            selected_boxes, selected_scores, selected_labels = box_selector.select_boxes_per_image(
+                boxes, logits, spatial_size
+            )
+    """
+
+    def __init__(
+        self,
+        box_overlap_metric: Callable = box_iou,
+        apply_sigmoid: bool = True,
+        score_thresh: float = 0.05,
+        topk_candidates_per_level: int = 1000,
+        nms_thresh: float = 0.5,
+        detections_per_img: int = 300,
+    ):
+        self.box_overlap_metric = box_overlap_metric
+
+        self.apply_sigmoid = apply_sigmoid
+        self.score_thresh = score_thresh
+        self.topk_candidates_per_level = topk_candidates_per_level
+        self.nms_thresh = nms_thresh
+        self.detections_per_img = detections_per_img
+
+    def select_top_score_idx_per_level(self, logits: Tensor) -> tuple[Tensor, Tensor, Tensor]:
+        """
+        Select indices with highest scores.
+
+        The indices selection is performed with the following steps:
+
+        #. If self.apply_sigmoid, get scores by applying sigmoid to logits. Otherwise, use logits as scores.
+        #. Discard indices with scores less than self.score_thresh
+        #. Keep indices with top self.topk_candidates_per_level scores
+
+        Args:
+            logits: predicted classification logits, Tensor sized (N, num_classes)
+
+        Return:
+            - topk_idxs: selected M indices, Tensor sized (M, )
+            - selected_scores: selected M scores, Tensor sized (M, )
+            - selected_labels: selected M labels, Tensor sized (M, )
+        """
+        num_classes = logits.shape[-1]
+
+        # apply sigmoid to classification logits if asked
+        if self.apply_sigmoid:
+            scores = torch.sigmoid(logits.to(torch.float32)).flatten()
+        else:
+            scores = logits.flatten()
+
+        # remove low scoring boxes
+        keep_idxs = scores > self.score_thresh
+        scores = scores[keep_idxs]
+        flatten_topk_idxs = torch.where(keep_idxs)[0]
+
+        # keep only topk scoring predictions
+        num_topk = min(self.topk_candidates_per_level, flatten_topk_idxs.size(0))
+        selected_scores, idxs = scores.to(torch.float32).topk(
+            num_topk
+        )  # half precision not implemented for cpu float16
+        flatten_topk_idxs = flatten_topk_idxs[idxs]
+
+        selected_labels = flatten_topk_idxs % num_classes
+
+        topk_idxs = floor_divide(flatten_topk_idxs, num_classes)
+        return topk_idxs, selected_scores, selected_labels  # type: ignore
+
+    def select_boxes_per_image(
+        self, boxes_list: list[Tensor], logits_list: list[Tensor], spatial_size: list[int] | tuple[int]
+    ) -> tuple[Tensor, Tensor, Tensor]:
+        """
+        Postprocessing to generate detection result from classification logits and boxes.
+
+        The box selection is performed with the following steps:
+
+        #. For each level, discard boxes with scores less than self.score_thresh.
+        #. For each level, keep boxes with top self.topk_candidates_per_level scores.
+        #. For the whole image, perform non-maximum suppression (NMS) on boxes, with overlapping threshold nms_thresh.
+        #. For the whole image, keep boxes with top self.detections_per_img scores.
+
+        Args:
+            boxes_list: list of predicted boxes from a single image,
+                each element i is a Tensor sized (N_i, 2*spatial_dims)
+            logits_list: list of predicted classification logits from a single image,
+                each element i is a Tensor sized (N_i, num_classes)
+            spatial_size: spatial size of the image
+
+        Return:
+            - selected boxes, Tensor sized (P, 2*spatial_dims)
+            - selected_scores, Tensor sized (P, )
+            - selected_labels, Tensor sized (P, )
+        """
+
+        if len(boxes_list) != len(logits_list):
+            raise ValueError(
+                "len(boxes_list) should equal to len(logits_list). "
+                f"Got len(boxes_list)={len(boxes_list)}, len(logits_list)={len(logits_list)}"
+            )
+
+        image_boxes = []
+        image_scores = []
+        image_labels = []
+
+        boxes_dtype = boxes_list[0].dtype
+        logits_dtype = logits_list[0].dtype
+
+        for boxes_per_level, logits_per_level in zip(boxes_list, logits_list):
+            # select topk boxes for each level
+            topk_idxs: Tensor
+            topk_idxs, scores_per_level, labels_per_level = self.select_top_score_idx_per_level(logits_per_level)
+            boxes_per_level = boxes_per_level[topk_idxs]
+
+            keep: Tensor
+            boxes_per_level, keep = clip_boxes_to_image(  # type: ignore
+                boxes_per_level, spatial_size, remove_empty=True
+            )
+            image_boxes.append(boxes_per_level)
+            image_scores.append(scores_per_level[keep])
+            image_labels.append(labels_per_level[keep])
+
+        image_boxes_t: Tensor = torch.cat(image_boxes, dim=0)
+        image_scores_t: Tensor = torch.cat(image_scores, dim=0)
+        image_labels_t: Tensor = torch.cat(image_labels, dim=0)
+
+        # non-maximum suppression on detected boxes from all levels
+        keep_t: Tensor = batched_nms(  # type: ignore
+            image_boxes_t,
+            image_scores_t,
+            image_labels_t,
+            self.nms_thresh,
+            box_overlap_metric=self.box_overlap_metric,
+            max_proposals=self.detections_per_img,
+        )
+
+        selected_boxes = image_boxes_t[keep_t].to(boxes_dtype)
+        selected_scores = image_scores_t[keep_t].to(logits_dtype)
+        selected_labels = image_labels_t[keep_t]
+
+        return selected_boxes, selected_scores, selected_labels

source_code/SegMamba/monai/apps/detection/utils/detector_utils.py

@@ -0,0 +1,213 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Sequence
+from typing import Any
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+
+from monai.data.box_utils import standardize_empty_box
+from monai.transforms.croppad.array import SpatialPad
+from monai.transforms.utils import compute_divisible_spatial_size, convert_pad_mode
+from monai.utils import PytorchPadMode, ensure_tuple_rep
+
+
+def check_input_images(input_images: list[Tensor] | Tensor, spatial_dims: int) -> None:
+    """
+    Validate the input dimensionality (raise a `ValueError` if invalid).
+
+    Args:
+        input_images: It can be 1) a tensor sized (B, C, H, W) or  (B, C, H, W, D),
+            or 2) a list of image tensors, each image i may have different size (C, H_i, W_i) or  (C, H_i, W_i, D_i).
+        spatial_dims: number of spatial dimensions of the images, 2 or 3.
+    """
+    if isinstance(input_images, Tensor):
+        if len(input_images.shape) != spatial_dims + 2:
+            raise ValueError(
+                "When input_images is a Tensor, its need to be (spatial_dims + 2)-D."
+                f"In this case, it should be a {(spatial_dims + 2)}-D Tensor, got Tensor shape {input_images.shape}."
+            )
+    elif isinstance(input_images, list):
+        for img in input_images:
+            if len(img.shape) != spatial_dims + 1:
+                raise ValueError(
+                    "When input_images is a List[Tensor], each element should have be (spatial_dims + 1)-D."
+                    f"In this case, it should be a {(spatial_dims + 1)}-D Tensor, got Tensor shape {img.shape}."
+                )
+    else:
+        raise ValueError("input_images needs to be a List[Tensor] or Tensor.")
+    return
+
+
+def check_training_targets(
+    input_images: list[Tensor] | Tensor,
+    targets: list[dict[str, Tensor]] | None,
+    spatial_dims: int,
+    target_label_key: str,
+    target_box_key: str,
+) -> list[dict[str, Tensor]]:
+    """
+    Validate the input images/targets during training (raise a `ValueError` if invalid).
+
+    Args:
+        input_images: It can be 1) a tensor sized (B, C, H, W) or  (B, C, H, W, D),
+            or 2) a list of image tensors, each image i may have different size (C, H_i, W_i) or  (C, H_i, W_i, D_i).
+        targets: a list of dict. Each dict with two keys: target_box_key and target_label_key,
+            ground-truth boxes present in the image.
+        spatial_dims: number of spatial dimensions of the images, 2 or 3.
+        target_label_key: the expected key of target labels.
+        target_box_key: the expected key of target boxes.
+    """
+    if targets is None:
+        raise ValueError("Please provide ground truth targets during training.")
+
+    if len(input_images) != len(targets):
+        raise ValueError(f"len(input_images) should equal to len(targets), got {len(input_images)}, {len(targets)}.")
+
+    for i in range(len(targets)):
+        target = targets[i]
+        if (target_label_key not in target.keys()) or (target_box_key not in target.keys()):
+            raise ValueError(
+                f"{target_label_key} and {target_box_key} are expected keys in targets. Got {target.keys()}."
+            )
+
+        boxes = target[target_box_key]
+        if not isinstance(boxes, torch.Tensor):
+            raise ValueError(f"Expected target boxes to be of type Tensor, got {type(boxes)}.")
+        if len(boxes.shape) != 2 or boxes.shape[-1] != 2 * spatial_dims:
+            if boxes.numel() == 0:
+                warnings.warn(
+                    f"Warning: Given target boxes has shape of {boxes.shape}. "
+                    f"The detector reshaped it with boxes = torch.reshape(boxes, [0, {2* spatial_dims}])."
+                )
+            else:
+                raise ValueError(
+                    f"Expected target boxes to be a tensor of shape [N, {2* spatial_dims}], got {boxes.shape}.)."
+                )
+        if not torch.is_floating_point(boxes):
+            raise ValueError(f"Expected target boxes to be a float tensor, got {boxes.dtype}.")
+        targets[i][target_box_key] = standardize_empty_box(boxes, spatial_dims=spatial_dims)  # type: ignore
+
+        labels = target[target_label_key]
+        if torch.is_floating_point(labels):
+            warnings.warn(f"Warning: Given target labels is {labels.dtype}. The detector converted it to torch.long.")
+            targets[i][target_label_key] = labels.long()
+    return targets
+
+
+def pad_images(
+    input_images: list[Tensor] | Tensor,
+    spatial_dims: int,
+    size_divisible: int | Sequence[int],
+    mode: PytorchPadMode | str = PytorchPadMode.CONSTANT,
+    **kwargs: Any,
+) -> tuple[Tensor, list[list[int]]]:
+    """
+    Pad the input images, so that the output spatial sizes are divisible by `size_divisible`.
+    It pads them at the end to create a (B, C, H, W) or (B, C, H, W, D) Tensor.
+    Padded size (H, W) or (H, W, D) is divisible by size_divisible.
+    Default padding uses constant padding with value 0.0
+
+    Args:
+        input_images: It can be 1) a tensor sized (B, C, H, W) or  (B, C, H, W, D),
+            or 2) a list of image tensors, each image i may have different size (C, H_i, W_i) or  (C, H_i, W_i, D_i).
+        spatial_dims: number of spatial dimensions of the images, 2D or 3D.
+        size_divisible: int or Sequence[int], is the expected pattern on the input image shape.
+            If an int, the same `size_divisible` will be applied to all the input spatial dimensions.
+        mode: available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.
+            One of the listed string values or a user supplied function. Defaults to ``"constant"``.
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+        kwargs: other arguments for `torch.pad` function.
+
+    Return:
+        - images, a (B, C, H, W) or (B, C, H, W, D) Tensor
+        - image_sizes, the original spatial size of each image
+    """
+    size_divisible = ensure_tuple_rep(size_divisible, spatial_dims)
+
+    # If input_images: Tensor
+    if isinstance(input_images, Tensor):
+        orig_size = list(input_images.shape[-spatial_dims:])
+        new_size = compute_divisible_spatial_size(spatial_shape=orig_size, k=size_divisible)
+        all_pad_width = [(0, max(sp_i - orig_size[i], 0)) for i, sp_i in enumerate(new_size)]
+        pt_pad_width = [val for sublist in all_pad_width for val in sublist[::-1]][::-1]
+        if max(pt_pad_width) == 0:
+            # if there is no need to pad
+            return input_images, [orig_size] * input_images.shape[0]
+        mode_: str = convert_pad_mode(dst=input_images, mode=mode)
+        return F.pad(input_images, pt_pad_width, mode=mode_, **kwargs), [orig_size] * input_images.shape[0]
+
+    # If input_images: List[Tensor])
+    image_sizes = [img.shape[-spatial_dims:] for img in input_images]
+    in_channels = input_images[0].shape[0]
+    dtype = input_images[0].dtype
+    device = input_images[0].device
+
+    # compute max_spatial_size
+    image_sizes_t = torch.tensor(image_sizes)
+    max_spatial_size_t, _ = torch.max(image_sizes_t, dim=0)
+
+    if len(max_spatial_size_t) != spatial_dims or len(size_divisible) != spatial_dims:
+        raise ValueError(" Require len(max_spatial_size_t) == spatial_dims ==len(size_divisible).")
+
+    max_spatial_size = compute_divisible_spatial_size(spatial_shape=list(max_spatial_size_t), k=size_divisible)
+
+    # allocate memory for the padded images
+    images = torch.zeros([len(image_sizes), in_channels] + list(max_spatial_size), dtype=dtype, device=device)
+
+    # Use `SpatialPad` to match sizes, padding in the end will not affect boxes
+    padder = SpatialPad(spatial_size=max_spatial_size, method="end", mode=mode, **kwargs)
+    for idx, img in enumerate(input_images):
+        images[idx, ...] = padder(img)
+
+    return images, [list(ss) for ss in image_sizes]
+
+
+def preprocess_images(
+    input_images: list[Tensor] | Tensor,
+    spatial_dims: int,
+    size_divisible: int | Sequence[int],
+    mode: PytorchPadMode | str = PytorchPadMode.CONSTANT,
+    **kwargs: Any,
+) -> tuple[Tensor, list[list[int]]]:
+    """
+    Preprocess the input images, including
+
+    - validate of the inputs
+    - pad the inputs so that the output spatial sizes are divisible by `size_divisible`.
+      It pads them at the end to create a (B, C, H, W) or (B, C, H, W, D) Tensor.
+      Padded size (H, W) or (H, W, D) is divisible by size_divisible.
+      Default padding uses constant padding with value 0.0
+
+    Args:
+        input_images: It can be 1) a tensor sized (B, C, H, W) or  (B, C, H, W, D),
+            or 2) a list of image tensors, each image i may have different size (C, H_i, W_i) or  (C, H_i, W_i, D_i).
+        spatial_dims: number of spatial dimensions of the images, 2 or 3.
+        size_divisible: int or Sequence[int], is the expected pattern on the input image shape.
+            If an int, the same `size_divisible` will be applied to all the input spatial dimensions.
+        mode: available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.
+            One of the listed string values or a user supplied function. Defaults to ``"constant"``.
+            See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html
+        kwargs: other arguments for `torch.pad` function.
+
+    Return:
+        - images, a (B, C, H, W) or (B, C, H, W, D) Tensor
+        - image_sizes, the original spatial size of each image
+    """
+    check_input_images(input_images, spatial_dims)
+    size_divisible = ensure_tuple_rep(size_divisible, spatial_dims)
+
+    return pad_images(input_images, spatial_dims, size_divisible, mode, **kwargs)

source_code/SegMamba/monai/apps/detection/utils/hard_negative_sampler.py

@@ -0,0 +1,305 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =========================================================================
+# Adapted from https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/core/boxes/sampler.py
+# which has the following license...
+# https://github.com/MIC-DKFZ/nnDetection/blob/main/LICENSE
+#
+# Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#    http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+The functions in this script are adapted from nnDetection,
+https://github.com/MIC-DKFZ/nnDetection/blob/main/nndet/core/boxes/sampler.py
+"""
+
+from __future__ import annotations
+
+import logging
+
+import torch
+from torch import Tensor
+
+
+class HardNegativeSamplerBase:
+    """
+    Base class of hard negative sampler.
+
+    Hard negative sampler is used to suppress false positive rate in classification tasks.
+    During training, it select negative samples with high prediction scores.
+
+    The training workflow is described as the follows:
+    1) forward network and get prediction scores (classification prob/logits) for all the samples;
+    2) use hard negative sampler to choose negative samples with high prediction scores and some positive samples;
+    3) compute classification loss for the selected samples;
+    4) do back propagation.
+
+    Args:
+        pool_size: when we need ``num_neg`` hard negative samples, they will be randomly selected from
+            ``num_neg * pool_size`` negative samples with the highest prediction scores.
+            Larger ``pool_size`` gives more randomness, yet selects negative samples that are less 'hard',
+            i.e., negative samples with lower prediction scores.
+    """
+
+    def __init__(self, pool_size: float = 10) -> None:
+        self.pool_size = pool_size
+
+    def select_negatives(self, negative: Tensor, num_neg: int, fg_probs: Tensor) -> Tensor:
+        """
+        Select hard negative samples.
+
+        Args:
+            negative: indices of all the negative samples, sized (P,),
+                where P is the number of negative samples
+            num_neg: number of negative samples to sample
+            fg_probs: maximum foreground prediction scores (probability) across all the classes
+                for each sample, sized (A,), where A is the number of samples.
+
+        Returns:
+            binary mask of negative samples to choose, sized (A,),
+                where A is the number of samples in one image
+        """
+        if negative.numel() > fg_probs.numel():
+            raise ValueError("The number of negative samples should not be larger than the number of all samples.")
+
+        # sample pool size is ``num_neg * self.pool_size``
+        pool = int(num_neg * self.pool_size)
+        pool = min(negative.numel(), pool)  # protect against not enough negatives
+
+        # create a sample pool of highest scoring negative samples
+        _, negative_idx_pool = fg_probs[negative].to(torch.float32).topk(pool, dim=0, sorted=True)
+        hard_negative = negative[negative_idx_pool]
+
+        # select negatives from pool
+        perm2 = torch.randperm(hard_negative.numel(), device=hard_negative.device)[:num_neg]
+        selected_neg_idx = hard_negative[perm2]
+
+        # output a binary mask with same size of fg_probs that indicates selected negative samples.
+        neg_mask = torch.zeros_like(fg_probs, dtype=torch.uint8)
+        neg_mask[selected_neg_idx] = 1
+        return neg_mask
+
+
+class HardNegativeSampler(HardNegativeSamplerBase):
+    """
+    HardNegativeSampler is used to suppress false positive rate in classification tasks.
+    During training, it selects negative samples with high prediction scores.
+
+    The training workflow is described as the follows:
+    1) forward network and get prediction scores (classification prob/logits) for all the samples;
+    2) use hard negative sampler to choose negative samples with high prediction scores and some positive samples;
+    3) compute classification loss for the selected samples;
+    4) do back propagation.
+
+    Args:
+        batch_size_per_image: number of training samples to be randomly selected per image
+        positive_fraction: percentage of positive elements in the selected samples
+        min_neg: minimum number of negative samples to select if possible.
+        pool_size: when we need ``num_neg`` hard negative samples, they will be randomly selected from
+            ``num_neg * pool_size`` negative samples with the highest prediction scores.
+            Larger ``pool_size`` gives more randomness, yet selects negative samples that are less 'hard',
+            i.e., negative samples with lower prediction scores.
+    """
+
+    def __init__(
+        self, batch_size_per_image: int, positive_fraction: float, min_neg: int = 1, pool_size: float = 10
+    ) -> None:
+        super().__init__(pool_size=pool_size)
+        self.min_neg = min_neg
+        self.batch_size_per_image = batch_size_per_image
+        self.positive_fraction = positive_fraction
+        logging.info("Sampling hard negatives on a per batch basis")
+
+    def __call__(self, target_labels: list[Tensor], concat_fg_probs: Tensor) -> tuple[list[Tensor], list[Tensor]]:
+        """
+        Select positives and hard negatives from list samples per image.
+        Hard negative sampler will be applied to each image independently.
+
+        Args:
+            target_labels: list of labels per image.
+                For image i in the batch, target_labels[i] is a Tensor sized (A_i,),
+                where A_i is the number of samples in image i.
+                Positive samples have positive labels, negative samples have label 0.
+            concat_fg_probs: concatenated maximum foreground probability for all the images, sized (R,),
+                where R is the sum of all samples inside one batch, i.e., R = A_0 + A_1 + ...
+
+        Returns:
+            - list of binary mask for positive samples
+            - list of binary mask for negative samples
+
+        Example:
+            .. code-block:: python
+
+                sampler = HardNegativeSampler(
+                    batch_size_per_image=6, positive_fraction=0.5, min_neg=1, pool_size=2
+                )
+                # two images with different number of samples
+                target_labels = [ torch.tensor([0,1]), torch.tensor([1,0,2,1])]
+                concat_fg_probs = torch.rand(6)
+                pos_idx_list, neg_idx_list = sampler(target_labels, concat_fg_probs)
+        """
+        samples_per_image = [samples_in_image.shape[0] for samples_in_image in target_labels]
+        fg_probs = concat_fg_probs.split(samples_per_image, 0)
+        return self.select_samples_img_list(target_labels, fg_probs)
+
+    def select_samples_img_list(
+        self, target_labels: list[Tensor], fg_probs: list[Tensor]
+    ) -> tuple[list[Tensor], list[Tensor]]:
+        """
+        Select positives and hard negatives from list samples per image.
+        Hard negative sampler will be applied to each image independently.
+
+        Args:
+            target_labels: list of labels per image.
+                For image i in the batch, target_labels[i] is a Tensor sized (A_i,),
+                where A_i is the number of samples in image i.
+                Positive samples have positive labels, negative samples have label 0.
+            fg_probs: list of maximum foreground probability per images,
+                For image i in the batch, target_labels[i] is a Tensor sized (A_i,),
+                where A_i is the number of samples in image i.
+
+        Returns:
+            - list of binary mask for positive samples
+            - list binary mask for negative samples
+
+        Example:
+            .. code-block:: python
+
+                sampler = HardNegativeSampler(
+                    batch_size_per_image=6, positive_fraction=0.5, min_neg=1, pool_size=2
+                )
+                # two images with different number of samples
+                target_labels = [ torch.tensor([0,1]), torch.tensor([1,0,2,1])]
+                fg_probs = [ torch.rand(2), torch.rand(4)]
+                pos_idx_list, neg_idx_list = sampler.select_samples_img_list(target_labels, fg_probs)
+        """
+        pos_idx = []
+        neg_idx = []
+
+        if len(target_labels) != len(fg_probs):
+            raise ValueError(
+                "Require len(target_labels) == len(fg_probs). "
+                f"Got len(target_labels)={len(target_labels)}, len(fg_probs)={len(fg_probs)}."
+            )
+        for labels_per_img, fg_probs_per_img in zip(target_labels, fg_probs):
+            pos_idx_per_image_mask, neg_idx_per_image_mask = self.select_samples_per_img(
+                labels_per_img, fg_probs_per_img
+            )
+            pos_idx.append(pos_idx_per_image_mask)
+            neg_idx.append(neg_idx_per_image_mask)
+
+        return pos_idx, neg_idx
+
+    def select_samples_per_img(self, labels_per_img: Tensor, fg_probs_per_img: Tensor) -> tuple[Tensor, Tensor]:
+        """
+        Select positives and hard negatives from samples.
+
+        Args:
+            labels_per_img: labels, sized (A,).
+                Positive samples have positive labels, negative samples have label 0.
+            fg_probs_per_img: maximum foreground probability, sized (A,)
+
+        Returns:
+            - binary mask for positive samples, sized (A,)
+            - binary mask for negative samples, sized (A,)
+
+        Example:
+            .. code-block:: python
+
+                sampler = HardNegativeSampler(
+                    batch_size_per_image=6, positive_fraction=0.5, min_neg=1, pool_size=2
+                )
+                # two images with different number of samples
+                target_labels = torch.tensor([1,0,2,1])
+                fg_probs = torch.rand(4)
+                pos_idx, neg_idx = sampler.select_samples_per_img(target_labels, fg_probs)
+        """
+        # for each image, find positive sample indices and negative sample indices
+        if labels_per_img.numel() != fg_probs_per_img.numel():
+            raise ValueError("labels_per_img and fg_probs_per_img should have same number of elements.")
+
+        positive = torch.where(labels_per_img >= 1)[0]
+        negative = torch.where(labels_per_img == 0)[0]
+
+        num_pos = self.get_num_pos(positive)
+        pos_idx_per_image_mask = self.select_positives(positive, num_pos, labels_per_img)
+
+        num_neg = self.get_num_neg(negative, num_pos)
+        neg_idx_per_image_mask = self.select_negatives(negative, num_neg, fg_probs_per_img)
+
+        return pos_idx_per_image_mask, neg_idx_per_image_mask
+
+    def get_num_pos(self, positive: torch.Tensor) -> int:
+        """
+        Number of positive samples to draw
+
+        Args:
+            positive: indices of positive samples
+
+        Returns:
+            number of positive sample
+        """
+        # positive sample sampling
+        num_pos = int(self.batch_size_per_image * self.positive_fraction)
+        # protect against not enough positive examples
+        num_pos = min(positive.numel(), num_pos)
+        return num_pos
+
+    def get_num_neg(self, negative: torch.Tensor, num_pos: int) -> int:
+        """
+        Sample enough negatives to fill up ``self.batch_size_per_image``
+
+        Args:
+            negative: indices of positive samples
+            num_pos: number of positive samples to draw
+
+        Returns:
+            number of negative samples
+        """
+        # always assume at least one pos sample was sampled
+        num_neg = int(max(1, num_pos) * abs(1 - 1.0 / float(self.positive_fraction)))
+        # protect against not enough negative examples and sample at least self.min_neg if possible
+        num_neg = min(negative.numel(), max(num_neg, self.min_neg))
+        return num_neg
+
+    def select_positives(self, positive: Tensor, num_pos: int, labels: Tensor) -> Tensor:
+        """
+        Select positive samples
+
+        Args:
+            positive: indices of positive samples, sized (P,),
+                where P is the number of positive samples
+            num_pos: number of positive samples to sample
+            labels: labels for all samples, sized (A,),
+                where A is the number of samples.
+
+        Returns:
+            binary mask of positive samples to choose, sized (A,),
+                where A is the number of samples in one image
+        """
+        if positive.numel() > labels.numel():
+            raise ValueError("The number of positive samples should not be larger than the number of all samples.")
+
+        perm1 = torch.randperm(positive.numel(), device=positive.device)[:num_pos]
+        pos_idx_per_image = positive[perm1]
+
+        # output a binary mask with same size of labels that indicates selected positive samples.
+        pos_idx_per_image_mask = torch.zeros_like(labels, dtype=torch.uint8)
+        pos_idx_per_image_mask[pos_idx_per_image] = 1
+        return pos_idx_per_image_mask

source_code/SegMamba/monai/apps/detection/utils/predict_utils.py

@@ -0,0 +1,141 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+from torch import Tensor, nn
+
+from monai.inferers import SlidingWindowInferer
+
+
+def ensure_dict_value_to_list_(head_outputs: dict[str, list[Tensor]], keys: list[str] | None = None) -> None:
+    """
+    An in-place function. We expect ``head_outputs`` to be Dict[str, List[Tensor]].
+    Yet if it is Dict[str, Tensor], this func converts it to Dict[str, List[Tensor]].
+    It will be modified in-place.
+
+    Args:
+        head_outputs: a Dict[str, List[Tensor]] or Dict[str, Tensor], will be modifier in-place
+        keys: the keys in head_output that need to have value type List[Tensor]. If not provided, will use head_outputs.keys().
+    """
+    if keys is None:
+        keys = list(head_outputs.keys())
+
+    for k in keys:
+        value_k = head_outputs[k]  # Tensor or List[Tensor]
+        # convert value_k to List[Tensor]
+        if isinstance(value_k, Tensor):
+            head_outputs[k] = [value_k]
+        elif isinstance(value_k[0], Tensor):
+            head_outputs[k] = list(value_k)
+        else:
+            raise ValueError("The output of network should be Dict[str, List[Tensor]] or Dict[str, Tensor].")
+
+
+def check_dict_values_same_length(head_outputs: dict[str, list[Tensor]], keys: list[str] | None = None) -> None:
+    """
+    We expect the values in ``head_outputs``: Dict[str, List[Tensor]] to have the same length.
+    Will raise ValueError if not.
+
+    Args:
+        head_outputs: a Dict[str, List[Tensor]] or Dict[str, Tensor]
+        keys: the keys in head_output that need to have values (List) with same length.
+            If not provided, will use head_outputs.keys().
+    """
+    if keys is None:
+        keys = list(head_outputs.keys())
+
+    num_output_levels_list: list[int] = [len(head_outputs[k]) for k in keys]
+    num_output_levels = torch.unique(torch.tensor(num_output_levels_list))
+    if len(num_output_levels) != 1:
+        raise ValueError(f"The values in the input dict should have the same length, Got {num_output_levels_list}.")
+
+
+def _network_sequence_output(images: Tensor, network: nn.Module, keys: list[str] | None = None) -> list[Tensor]:
+    """
+    Decompose the output of network (a dict) into a list.
+
+    Args:
+        images: input of the network
+        keys: the keys in the network output whose values will be output in this func.
+            If not provided, will use all keys.
+
+    Return:
+        network output values concat to a single List[Tensor]
+    """
+    head_outputs = network(images)
+
+    # if head_outputs is already a sequence of tensors, directly output it
+    if isinstance(head_outputs, (tuple, list)):
+        return list(head_outputs)
+
+    # if head_outputs is a dict
+    ensure_dict_value_to_list_(head_outputs, keys)
+    if keys is None:
+        keys = list(head_outputs.keys())
+    check_dict_values_same_length(head_outputs, keys)
+    head_outputs_sequence = []
+    for k in keys:
+        head_outputs_sequence += list(head_outputs[k])
+    return head_outputs_sequence
+
+
+def predict_with_inferer(
+    images: Tensor, network: nn.Module, keys: list[str], inferer: SlidingWindowInferer | None = None
+) -> dict[str, list[Tensor]]:
+    """
+    Predict network dict output with an inferer. Compared with directly output network(images),
+    it enables a sliding window inferer that can be used to handle large inputs.
+
+    Args:
+        images: input of the network, Tensor sized (B, C, H, W) or  (B, C, H, W, D)
+        network: a network that takes an image Tensor sized (B, C, H, W) or (B, C, H, W, D) as input
+            and outputs a dictionary Dict[str, List[Tensor]] or Dict[str, Tensor].
+        keys: the keys in the output dict, should be network output keys or a subset of them.
+        inferer: a SlidingWindowInferer to handle large inputs.
+
+    Return:
+        The predicted head_output from network, a Dict[str, List[Tensor]]
+
+    Example:
+        .. code-block:: python
+
+            # define a naive network
+            import torch
+            import monai
+            class NaiveNet(torch.nn.Module):
+                def __init__(self, ):
+                    super().__init__()
+
+                def forward(self, images: torch.Tensor):
+                    return {"cls": torch.randn(images.shape), "box_reg": [torch.randn(images.shape)]}
+
+            # create a predictor
+            network = NaiveNet()
+            inferer = monai.inferers.SlidingWindowInferer(
+                roi_size = (128, 128, 128),
+                overlap = 0.25,
+                cache_roi_weight_map = True,
+            )
+            network_output_keys=["cls", "box_reg"]
+            images = torch.randn((2, 3, 512, 512, 512))  # a large input
+            head_outputs = predict_with_inferer(images, network, network_output_keys, inferer)
+
+    """
+    if inferer is None:
+        raise ValueError("Please set inferer as a monai.inferers.inferer.SlidingWindowInferer(*)")
+    head_outputs_sequence = inferer(images, _network_sequence_output, network, keys=keys)
+    num_output_levels: int = len(head_outputs_sequence) // len(keys)
+    head_outputs = {}
+    for i, k in enumerate(keys):
+        head_outputs[k] = list(head_outputs_sequence[num_output_levels * i : num_output_levels * (i + 1)])
+    return head_outputs

source_code/SegMamba/monai/apps/mmars/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .mmars import download_mmar, get_model_spec, load_from_mmar
+from .model_desc import MODEL_DESC, RemoteMMARKeys

source_code/SegMamba/monai/apps/mmars/mmars.py

@@ -0,0 +1,314 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Utilities for accessing Nvidia MMARs
+
+See Also:
+    - https://docs.nvidia.com/clara/clara-train-sdk/pt/mmar.html
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import warnings
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import torch
+
+import monai.networks.nets as monai_nets
+from monai.apps.utils import download_and_extract, logger
+from monai.config.type_definitions import PathLike
+from monai.networks.utils import copy_model_state
+from monai.utils.module import optional_import
+
+from .model_desc import MODEL_DESC
+from .model_desc import RemoteMMARKeys as Keys
+
+__all__ = ["get_model_spec", "download_mmar", "load_from_mmar"]
+
+
+def get_model_spec(idx: int | str) -> dict | Any:
+    """get model specification by `idx`. `idx` could be index of the constant tuple of dict or the actual model ID."""
+    if isinstance(idx, int):
+        return MODEL_DESC[idx]
+    if isinstance(idx, str):
+        key = idx.strip().lower()
+        for cand in MODEL_DESC:
+            if str(cand.get(Keys.ID)).strip().lower() == key:
+                return cand
+    return idx
+
+
+def _get_all_ngc_models(pattern, page_index=0, page_size=50):
+    url = "https://api.ngc.nvidia.com/v2/search/catalog/resources/MODEL"
+    query_dict = {
+        "query": "",
+        "orderBy": [{"field": "score", "value": "DESC"}],
+        "queryFields": ["all", "description", "displayName", "name", "resourceId"],
+        "fields": [
+            "isPublic",
+            "attributes",
+            "guestAccess",
+            "name",
+            "orgName",
+            "teamName",
+            "displayName",
+            "dateModified",
+            "labels",
+            "description",
+        ],
+        "page": 0,
+    }
+
+    filter = [dict(field="name", value=f"*{pattern}*")]
+    query_dict["page"] = page_index
+    query_dict["pageSize"] = page_size
+    query_dict["filters"] = filter
+    query_str = json.dumps(query_dict)
+    full_url = f"{url}?q={query_str}"
+    requests_get, has_requests = optional_import("requests", name="get")
+    if has_requests:
+        resp = requests_get(full_url)
+        resp.raise_for_status()
+    else:
+        raise ValueError("NGC API requires requests package.  Please install it.")
+    model_list = json.loads(resp.text)
+    model_dict = {}
+    for result in model_list["results"]:
+        for model in result["resources"]:
+            current_res_id = model["resourceId"]
+            model_dict[current_res_id] = {"name": model["name"]}
+            for attribute in model["attributes"]:
+                if attribute["key"] == "latestVersionIdStr":
+                    model_dict[current_res_id]["latest"] = attribute["value"]
+    return model_dict
+
+
+def _get_ngc_url(model_name: str, version: str, model_prefix: str = "") -> str:
+    return f"https://api.ngc.nvidia.com/v2/models/{model_prefix}{model_name}/versions/{version}/zip"
+
+
+def _get_ngc_doc_url(model_name: str, model_prefix: str = "") -> str:
+    return f"https://ngc.nvidia.com/catalog/models/{model_prefix}{model_name}"
+
+
+def download_mmar(
+    item: str | Mapping, mmar_dir: PathLike | None = None, progress: bool = True, api: bool = True, version: int = -1
+) -> Path:
+    """
+    Download and extract Medical Model Archive (MMAR) from Nvidia Clara Train.
+
+    See Also:
+        - https://docs.nvidia.com/clara/
+        - Nvidia NGC Registry CLI
+        - https://docs.nvidia.com/clara/clara-train-sdk/pt/mmar.html
+
+    Args:
+        item: the corresponding model item from `MODEL_DESC`.
+          Or when api is True, the substring to query NGC's model name field.
+        mmar_dir: target directory to store the MMAR, default is `mmars` subfolder under `torch.hub get_dir()`.
+        progress: whether to display a progress bar.
+        api: whether to query NGC and download via api
+        version: which version of MMAR to download.  -1 means the latest from ngc.
+
+    Examples::
+        >>> from monai.apps import download_mmar
+        >>> download_mmar("clara_pt_prostate_mri_segmentation_1", mmar_dir=".")
+        >>> download_mmar("prostate_mri_segmentation", mmar_dir=".", api=True)
+
+
+    Returns:
+        The local directory of the downloaded model.
+        If api is True, a list of local directories of downloaded models.
+    """
+    if not mmar_dir:
+        get_dir, has_home = optional_import("torch.hub", name="get_dir")
+        if has_home:
+            mmar_dir = Path(get_dir()) / "mmars"
+        else:
+            raise ValueError("mmar_dir=None, but no suitable default directory computed. Upgrade Pytorch to 1.6+ ?")
+    _mmar_dir = Path(mmar_dir)
+    model_dir: Path
+    if api:
+        model_dict = _get_all_ngc_models(item.get(Keys.NAME, f"{item}") if isinstance(item, Mapping) else f"{item}")
+        if len(model_dict) == 0:
+            raise ValueError(f"api query returns no item for pattern {item}.  Please change or shorten it.")
+        model_dir_list: list[Path] = []
+        for k, v in model_dict.items():
+            ver = v["latest"] if version == -1 else str(version)
+            download_url = _get_ngc_url(k, ver)
+            model_dir = _mmar_dir / v["name"]
+            download_and_extract(
+                url=download_url,
+                filepath=_mmar_dir / f'{v["name"]}_{ver}.zip',
+                output_dir=model_dir,
+                hash_val=None,
+                hash_type="md5",
+                file_type="zip",
+                has_base=False,
+                progress=progress,
+            )
+            model_dir_list.append(model_dir)
+        if not model_dir_list:
+            raise ValueError(f"api query download no item for pattern {item}.  Please change or shorten it.")
+        return model_dir_list[0]
+
+    if not isinstance(item, Mapping):
+        item = get_model_spec(item)
+    ver = item.get(Keys.VERSION, 1)
+    if version > 0:
+        ver = str(version)
+    model_fullname = f"{item[Keys.NAME]}_{ver}"
+    model_dir = _mmar_dir / model_fullname
+    model_url = item.get(Keys.URL) or _get_ngc_url(item[Keys.NAME], version=ver, model_prefix="nvidia/med/")
+    download_and_extract(
+        url=model_url,
+        filepath=_mmar_dir / f"{model_fullname}.{item[Keys.FILE_TYPE]}",
+        output_dir=model_dir,
+        hash_val=item[Keys.HASH_VAL],
+        hash_type=item[Keys.HASH_TYPE],
+        file_type=item[Keys.FILE_TYPE],
+        has_base=False,
+        progress=progress,
+    )
+    return model_dir
+
+
+def load_from_mmar(
+    item: Mapping | str | int,
+    mmar_dir: PathLike | None = None,
+    progress: bool = True,
+    version: int = -1,
+    map_location: Any | None = None,
+    pretrained: bool = True,
+    weights_only: bool = False,
+    model_key: str = "model",
+    api: bool = True,
+    model_file: PathLike | None = None,
+) -> Any:
+    """
+    Download and extract Medical Model Archive (MMAR) model weights from Nvidia Clara Train.
+
+    Args:
+        item: the corresponding model item from `MODEL_DESC`.
+        mmar_dir: : target directory to store the MMAR, default is mmars subfolder under `torch.hub get_dir()`.
+        progress: whether to display a progress bar when downloading the content.
+        version: version number of the MMAR. Set it to `-1` to use `item[Keys.VERSION]`.
+        map_location: pytorch API parameter for `torch.load` or `torch.jit.load`.
+        pretrained: whether to load the pretrained weights after initializing a network module.
+        weights_only: whether to load only the weights instead of initializing the network module and assign weights.
+        model_key: a key to search in the model file or config file for the model dictionary.
+            Currently this function assumes that the model dictionary has
+            `{"[name|path]": "test.module", "args": {'kw': 'test'}}`.
+        api: whether to query NGC API to get model infomation.
+        model_file: the relative path to the model file within an MMAR.
+
+    Examples::
+        >>> from monai.apps import load_from_mmar
+        >>> unet_model = load_from_mmar("clara_pt_prostate_mri_segmentation_1", mmar_dir=".", map_location="cpu")
+        >>> print(unet_model)
+
+    See Also:
+        https://docs.nvidia.com/clara/
+    """
+    if api:
+        item = {Keys.NAME: get_model_spec(item)[Keys.NAME] if isinstance(item, int) else f"{item}"}
+    if not isinstance(item, Mapping):
+        item = get_model_spec(item)
+    model_dir = download_mmar(item=item, mmar_dir=mmar_dir, progress=progress, version=version, api=api)
+    if model_file is None:
+        model_file = os.path.join("models", "model.pt")
+    _model_file = model_dir / item.get(Keys.MODEL_FILE, model_file)
+    logger.info(f'\n*** "{item.get(Keys.NAME)}" available at {model_dir}.')
+
+    # loading with `torch.jit.load`
+    if _model_file.name.endswith(".ts"):
+        if not pretrained:
+            warnings.warn("Loading a ScriptModule, 'pretrained' option ignored.")
+        if weights_only:
+            warnings.warn("Loading a ScriptModule, 'weights_only' option ignored.")
+        return torch.jit.load(_model_file, map_location=map_location)
+
+    # loading with `torch.load`
+    model_dict = torch.load(_model_file, map_location=map_location)
+    if weights_only:
+        return model_dict.get(model_key, model_dict)  # model_dict[model_key] or model_dict directly
+
+    # 1. search `model_dict['train_config]` for model config spec.
+    model_config = _get_val(dict(model_dict).get("train_conf", {}), key=model_key, default={})
+    if not model_config or not isinstance(model_config, Mapping):
+        # 2. search json CONFIG_FILE for model config spec.
+        json_path = model_dir / item.get(Keys.CONFIG_FILE, os.path.join("config", "config_train.json"))
+        with open(json_path) as f:
+            conf_dict = json.load(f)
+        conf_dict = dict(conf_dict)
+        model_config = _get_val(conf_dict, key=model_key, default={})
+    if not model_config:
+        # 3. search `model_dict` for model config spec.
+        model_config = _get_val(dict(model_dict), key=model_key, default={})
+
+    if not (model_config and isinstance(model_config, Mapping)):
+        raise ValueError(
+            f"Could not load model config dictionary from config: {item.get(Keys.CONFIG_FILE)}, "
+            f"or from model file: {item.get(Keys.MODEL_FILE)}."
+        )
+
+    # parse `model_config` for model class and model parameters
+    if model_config.get("name"):  # model config section is a "name"
+        model_name = model_config["name"]
+        model_cls = monai_nets.__dict__[model_name]
+    elif model_config.get("path"):  # model config section is a "path"
+        # https://docs.nvidia.com/clara/clara-train-sdk/pt/byom.html
+        model_module, model_name = model_config.get("path", ".").rsplit(".", 1)
+        model_cls, has_cls = optional_import(module=model_module, name=model_name)
+        if not has_cls:
+            raise ValueError(
+                f"Could not load MMAR model config {model_config.get('path', '')}, "
+                f"Please make sure MMAR's sub-folders in '{model_dir}' is on the PYTHONPATH."
+                "See also: https://docs.nvidia.com/clara/clara-train-sdk/pt/byom.html"
+            )
+    else:
+        raise ValueError(f"Could not load model config {model_config}.")
+
+    logger.info(f"*** Model: {model_cls}")
+    model_kwargs = model_config.get("args", None)
+    if model_kwargs:
+        model_inst = model_cls(**model_kwargs)
+        logger.info(f"*** Model params: {model_kwargs}")
+    else:
+        model_inst = model_cls()
+    if pretrained:
+        _, changed, unchanged = copy_model_state(model_inst, model_dict.get(model_key, model_dict), inplace=True)
+        if not (changed and not unchanged):  # not all model_inst variables are changed
+            logger.warning(f"*** Loading model state -- unchanged: {len(unchanged)}, changed: {len(changed)}.")
+    logger.info("\n---")
+    doc_url = item.get(Keys.DOC) or _get_ngc_doc_url(item[Keys.NAME], model_prefix="nvidia:med:")
+    logger.info(f"For more information, please visit {doc_url}\n")
+    return model_inst
+
+
+def _get_val(input_dict: Mapping, key: str = "model", default: Any | None = None) -> Any | None:
+    """
+    Search for the item with `key` in `config_dict`.
+    Returns: the first occurrence of `key` in a breadth first search.
+    """
+    if key in input_dict:
+        return input_dict[key]
+    for sub_dict in input_dict:
+        val = input_dict[sub_dict]
+        if isinstance(val, Mapping):
+            found_val = _get_val(val, key=key, default=None)
+            if found_val is not None:
+                return found_val
+    return default

source_code/SegMamba/monai/apps/nnunet/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .nnunetv2_runner import nnUNetV2Runner
+from .utils import NNUNETMode, analyze_data, create_new_data_copy, create_new_dataset_json

source_code/SegMamba/monai/apps/nnunet/__main__.py

@@ -0,0 +1,20 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from monai.apps.nnunet.nnunetv2_runner import nnUNetV2Runner
+
+if __name__ == "__main__":
+    from monai.utils import optional_import
+
+    fire, _ = optional_import("fire")
+    fire.Fire({"nnUNetV2Runner": nnUNetV2Runner})

source_code/SegMamba/monai/apps/nnunet/nnunetv2_runner.py

@@ -0,0 +1,959 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: disable=import-error
+from __future__ import annotations
+
+import glob
+import os
+import subprocess
+from typing import Any
+
+import monai
+from monai.apps.nnunet.utils import NNUNETMode as M  # noqa: N814
+from monai.apps.nnunet.utils import analyze_data, create_new_data_copy, create_new_dataset_json
+from monai.bundle import ConfigParser
+from monai.utils import ensure_tuple, optional_import
+from monai.utils.misc import run_cmd
+
+load_pickle, _ = optional_import("batchgenerators.utilities.file_and_folder_operations", name="load_pickle")
+join, _ = optional_import("batchgenerators.utilities.file_and_folder_operations", name="join")
+tqdm, has_tqdm = optional_import("tqdm", name="tqdm")
+nib, _ = optional_import("nibabel")
+
+logger = monai.apps.utils.get_logger(__name__)
+
+__all__ = ["nnUNetV2Runner"]
+
+
+class nnUNetV2Runner:  # noqa: N801
+    """
+    ``nnUNetV2Runner`` provides an interface in MONAI to use `nnU-Net` V2 library to analyze, train, and evaluate
+    neural networks for medical image segmentation tasks.
+    A version of nnunetv2 higher than 2.2 is needed for this class.
+
+    ``nnUNetV2Runner`` can be used in two ways:
+
+    #. with one line of code to execute the complete pipeline.
+    #. with a series of commands to run each modules in the pipeline.
+
+    The output of the interface is a directory that contains:
+
+    #. converted dataset met the requirement of nnU-Net V2
+    #. data analysis results
+    #. checkpoints from the trained U-Net models
+    #. validation accuracy in each fold of cross-validation
+    #. the predictions on the testing datasets from the final algorithm ensemble and potential post-processing
+
+    Args:
+        input_config: the configuration dictionary or the file path to the configuration in the form of YAML.
+            The keys required in the configuration are:
+            - ``"datalist"``: File path to the datalist for the train/testing splits
+            - ``"dataroot"``: File path to the dataset
+            - ``"modality"``: Imaging modality, e.g. "CT", ["T2", "ADC"]
+            Currently, the configuration supports these optional keys:
+            - ``"nnunet_raw"``: File path that will be written to env variable for nnU-Net
+            - ``"nnunet_preprocessed"``: File path that will be written to env variable for nnU-Net
+            - ``"nnunet_results"``: File path that will be written to env variable for nnU-Net
+            - ``"nnUNet_trained_models"``
+            - ``"dataset_name_or_id"``: Name or Integer ID of the dataset
+            If an optional key is not specified, then the pipeline will use the default values.
+        trainer_class_name: the trainer class names offered by nnUNetV2 exhibit variations in training duration.
+            Default: "nnUNetTrainer". Other options: "nnUNetTrainer_Xepoch". X could be one of 1,5,10,20,50,100,
+            250,2000,4000,8000.
+        export_validation_probabilities: True to save softmax predictions from final validation as npz
+            files (in addition to predicted segmentations). Needed for finding the best ensemble.
+            Default: True.
+        work_dir: working directory to save the intermediate and final results.
+
+    Examples:
+        - Use the one-liner to start the nnU-Net workflow
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner run --input_config ./input.yaml
+
+        - Use `convert_dataset` to prepare the data to meet nnU-Net requirements, generate dataset JSON file,
+            and copy the dataset to a location specified by ``nnunet_raw`` in the input config file
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner convert_dataset --input_config="./input.yaml"
+
+        - `convert_msd_dataset` is an alternative option to prepare the data if the dataset is MSD.
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner convert_msd_dataset \\
+                --input_config "./input.yaml" --data_dir "/path/to/Task09_Spleen"
+
+        - experiment planning and data pre-processing
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner plan_and_process --input_config "./input.yaml"
+
+        - training all 20 models using all GPUs available.
+            "CUDA_VISIBLE_DEVICES" environment variable is not supported.
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner train --input_config "./input.yaml"
+
+        - training a single model on a single GPU for 5 epochs. Here ``config`` is used to specify the configuration.
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner train_single_model --input_config "./input.yaml" \\
+                --config "3d_fullres" \\
+                --fold 0 \\
+                --gpu_id 0 \\
+                --trainer_class_name "nnUNetTrainer_5epochs" \\
+                --export_validation_probabilities True
+
+        - training for all 20 models (4 configurations by 5 folds) on 2 GPUs
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner train --input_config "./input.yaml" --gpu_id_for_all "0,1"
+
+        - 5-fold training for a single model on 2 GPUs. Here ``configs`` is used to specify the configurations.
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner train --input_config "./input.yaml" \\
+                --configs "3d_fullres" \\
+                --trainer_class_name "nnUNetTrainer_5epochs" \\
+                --export_validation_probabilities True \\
+                --gpu_id_for_all "0,1"
+
+        - find the best configuration
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner find_best_configuration --input_config "./input.yaml"
+
+        - predict, ensemble, and post-process
+
+        .. code-block:: bash
+
+            python -m monai.apps.nnunet nnUNetV2Runner predict_ensemble_postprocessing --input_config "./input.yaml"
+
+    """
+
+    def __init__(
+        self,
+        input_config: Any,
+        trainer_class_name: str = "nnUNetTrainer",
+        work_dir: str = "work_dir",
+        export_validation_probabilities: bool = True,
+    ) -> None:
+        self.input_info: dict = {}
+        self.input_config_or_dict = input_config
+        self.trainer_class_name = trainer_class_name
+        self.export_validation_probabilities = export_validation_probabilities
+        self.work_dir = work_dir
+
+        if isinstance(self.input_config_or_dict, dict):
+            self.input_info = self.input_config_or_dict
+        elif isinstance(self.input_config_or_dict, str) and os.path.isfile(self.input_config_or_dict):
+            self.input_info = ConfigParser.load_config_file(self.input_config_or_dict)
+        else:
+            raise ValueError(f"{input_config} is not a valid file or dict")
+
+        self.nnunet_raw = self.input_info.pop("nnunet_raw", os.path.join(".", self.work_dir, "nnUNet_raw_data_base"))
+        self.nnunet_preprocessed = self.input_info.pop(
+            "nnunet_preprocessed", os.path.join(".", self.work_dir, "nnUNet_preprocessed")
+        )
+        self.nnunet_results = self.input_info.pop(
+            "nnunet_results", os.path.join(".", self.work_dir, "nnUNet_trained_models")
+        )
+
+        if not os.path.exists(self.nnunet_raw):
+            os.makedirs(self.nnunet_raw)
+
+        if not os.path.exists(self.nnunet_preprocessed):
+            os.makedirs(self.nnunet_preprocessed)
+
+        if not os.path.exists(self.nnunet_results):
+            os.makedirs(self.nnunet_results)
+
+        # claim environment variable
+        os.environ["nnUNet_raw"] = self.nnunet_raw
+        os.environ["nnUNet_preprocessed"] = self.nnunet_preprocessed
+        os.environ["nnUNet_results"] = self.nnunet_results
+        os.environ["OMP_NUM_THREADS"] = str(1)
+
+        # dataset_name_or_id has to be a string
+        self.dataset_name_or_id = str(self.input_info.pop("dataset_name_or_id", 1))
+
+        try:
+            from nnunetv2.utilities.dataset_name_id_conversion import maybe_convert_to_dataset_name
+
+            self.dataset_name = maybe_convert_to_dataset_name(int(self.dataset_name_or_id))
+        except BaseException:
+            logger.warning(
+                f"Dataset with name/ID: {self.dataset_name_or_id} cannot be found in the record. "
+                "Please ignore the message above if you are running the pipeline from a fresh start. "
+                "But if the dataset is expected to be found, please check your input_config."
+            )
+
+        from nnunetv2.configuration import default_num_processes
+
+        self.default_num_processes = default_num_processes
+
+        self.num_folds = 5
+        self.best_configuration: dict = {}
+
+    def convert_dataset(self):
+        """Convert and make a copy the dataset to meet the requirements of nnU-Net workflow."""
+        try:
+            raw_data_foldername_prefix = str(int(self.dataset_name_or_id) + 1000)
+            raw_data_foldername_prefix = "Dataset" + raw_data_foldername_prefix[-3:]
+
+            # check if the dataset is created
+            subdirs = glob.glob(f"{self.nnunet_raw}/*")
+            dataset_ids = [_item.split(os.sep)[-1] for _item in subdirs]
+            dataset_ids = [_item.split("_")[0] for _item in dataset_ids]
+            if raw_data_foldername_prefix in dataset_ids:
+                logger.warning("Dataset with the same ID exists!")
+                return
+
+            data_dir = self.input_info.pop("dataroot")
+            if data_dir[-1] == os.sep:
+                data_dir = data_dir[:-1]
+
+            raw_data_foldername = raw_data_foldername_prefix + "_" + data_dir.split(os.sep)[-1]
+            raw_data_foldername = os.path.join(self.nnunet_raw, raw_data_foldername)
+            if not os.path.exists(raw_data_foldername):
+                os.makedirs(raw_data_foldername)
+
+            from nnunetv2.utilities.dataset_name_id_conversion import maybe_convert_to_dataset_name
+
+            self.dataset_name = maybe_convert_to_dataset_name(int(self.dataset_name_or_id))
+
+            datalist_json = ConfigParser.load_config_file(self.input_info.pop("datalist"))
+
+            if "training" in datalist_json:
+                os.makedirs(os.path.join(raw_data_foldername, "imagesTr"))
+                os.makedirs(os.path.join(raw_data_foldername, "labelsTr"))
+            else:
+                logger.error("The datalist file has incorrect format: the `training` key is not found.")
+                return
+
+            test_key = None
+            if "test" in datalist_json or "testing" in datalist_json:
+                os.makedirs(os.path.join(raw_data_foldername, "imagesTs"))
+                test_key = "test" if "test" in datalist_json else "testing"
+                if isinstance(datalist_json[test_key][0], dict) and "label" in datalist_json[test_key][0]:
+                    os.makedirs(os.path.join(raw_data_foldername, "labelsTs"))
+
+            num_input_channels, num_foreground_classes = analyze_data(datalist_json=datalist_json, data_dir=data_dir)
+
+            modality = self.input_info.pop("modality")
+            if not isinstance(modality, list):
+                modality = [modality]
+
+            create_new_dataset_json(
+                modality=modality,
+                num_foreground_classes=num_foreground_classes,
+                num_input_channels=num_input_channels,
+                num_training_data=len(datalist_json["training"]),
+                output_filepath=os.path.join(raw_data_foldername, "dataset.json"),
+            )
+
+            create_new_data_copy(
+                test_key=test_key,  # type: ignore
+                datalist_json=datalist_json,
+                data_dir=data_dir,
+                num_input_channels=num_input_channels,
+                output_datafolder=raw_data_foldername,
+            )
+        except BaseException as err:
+            logger.warning(f"Input config may be incorrect. Detail info: error/exception message is:\n {err}")
+            return
+
+    def convert_msd_dataset(self, data_dir: str, overwrite_id: str | None = None, n_proc: int = -1) -> None:
+        """
+        Convert and make a copy the MSD dataset to meet requirements of nnU-Net workflow.
+
+        Args:
+            data_dir: downloaded and extracted MSD dataset folder. CANNOT be nnUNetv1 dataset!
+                Example: "/workspace/downloads/Task05_Prostate".
+            overwrite_id: Overwrite the dataset id. If not set then use the id of the MSD task (inferred from
+                the folder name). Only use this if you already have an equivalently numbered dataset!
+            n_proc: Number of processes used.
+        """
+        from nnunetv2.dataset_conversion.convert_MSD_dataset import convert_msd_dataset
+
+        num_processes = None if n_proc < 0 else self.default_num_processes
+        convert_msd_dataset(data_dir, overwrite_id, num_processes)
+
+    def extract_fingerprints(
+        self,
+        fpe: str = "DatasetFingerprintExtractor",
+        npfp: int = -1,
+        verify_dataset_integrity: bool = False,
+        clean: bool = False,
+        verbose: bool = False,
+    ) -> None:
+        """
+        Extracts the dataset fingerprint used for experiment planning.
+
+        Args:
+            fpe: [OPTIONAL] Name of the Dataset Fingerprint Extractor class that should be used. Default is
+                "DatasetFingerprintExtractor".
+            npfp: [OPTIONAL] Number of processes used for fingerprint extraction.
+            verify_dataset_integrity: [RECOMMENDED] set this flag to check the dataset integrity. This is
+                useful and should be done once for each dataset!
+            clean: [OPTIONAL] Set this flag to overwrite existing fingerprints. If this flag is not set and a
+                fingerprint already exists, the fingerprint extractor will not run.
+            verbose: set this to print a lot of stuff. Useful for debugging. Will disable progress bar!
+                Recommended for cluster environments.
+        """
+        from nnunetv2.experiment_planning.plan_and_preprocess_api import extract_fingerprints
+
+        npfp = self.default_num_processes if npfp < 0 else npfp
+
+        logger.info("Fingerprint extraction...")
+        extract_fingerprints([int(self.dataset_name_or_id)], fpe, npfp, verify_dataset_integrity, clean, verbose)
+
+    def plan_experiments(
+        self,
+        pl: str = "ExperimentPlanner",
+        gpu_memory_target: float = 8,
+        preprocessor_name: str = "DefaultPreprocessor",
+        overwrite_target_spacing: Any = None,
+        overwrite_plans_name: str = "nnUNetPlans",
+    ) -> None:
+        """
+        Generate a configuration file that specifies the details of the experiment.
+
+        Args:
+            pl: [OPTIONAL] Name of the Experiment Planner class that should be used. Default is "ExperimentPlanner".
+                Note: There is no longer a distinction between 2d and 3d planner. It's an all-in-one solution now.
+            gpu_memory_target: [OPTIONAL] DANGER ZONE! Sets a custom GPU memory target. Default: 8 [GB].
+                Changing this will affect patch and batch size and will definitely affect your models' performance!
+                Only use this if you really know what you are doing and NEVER use this without running the
+                default nnU-Net first (as a baseline).
+            preprocessor_name: [OPTIONAL] DANGER ZONE! Sets a custom preprocessor class. This class must be located in
+                nnunetv2.preprocessing. Default: "DefaultPreprocessor". Changing this may affect your models'
+                performance! Only use this if you really know what you are doing and NEVER use this without running the
+                default nnU-Net first (as a baseline).
+            overwrite_target_spacing: [OPTIONAL] DANGER ZONE! Sets a custom target spacing for the 3d_fullres
+                and 3d_cascade_fullres configurations. Default: None [no changes]. Changing this will affect
+                image size and potentially patch and batch size. This will definitely affect your models' performance!
+                Only use this if you really know what you are doing and NEVER use this without running the
+                default nnU-Net first (as a baseline). Changing the target spacing for the other configurations
+                is currently not implemented. New target spacing must be a list of three numbers!
+            overwrite_plans_name: [OPTIONAL] DANGER ZONE! If you used -gpu_memory_target, -preprocessor_name or
+                -overwrite_target_spacing it is best practice to use -overwrite_plans_name to generate
+                a differently named plans file such that the nnunet default plans are not overwritten.
+                You will then need to specify your custom plan.
+        """
+        from nnunetv2.experiment_planning.plan_and_preprocess_api import plan_experiments
+
+        logger.info("Experiment planning...")
+        plan_experiments(
+            [int(self.dataset_name_or_id)],
+            pl,
+            gpu_memory_target,
+            preprocessor_name,
+            overwrite_target_spacing,
+            overwrite_plans_name,
+        )
+
+    def preprocess(
+        self,
+        c: tuple = (M.N_2D, M.N_3D_FULLRES, M.N_3D_LOWRES),
+        n_proc: tuple = (8, 8, 8),
+        overwrite_plans_name: str = "nnUNetPlans",
+        verbose: bool = False,
+    ) -> None:
+        """
+        Apply a set of preprocessing operations to the input data before the training.
+
+        Args:
+            overwrite_plans_name: [OPTIONAL] You can use this to specify a custom plans file that you may have
+                generated.
+            c: [OPTIONAL] Configurations for which the preprocessing should be run. Default: 2d 3f_fullres
+                3d_lowres. 3d_cascade_fullres does not need to be specified because it uses the data
+                from 3f_fullres. Configurations that do not exist for some datasets will be skipped).
+            n_proc: [OPTIONAL] Use this to define how many processes are to be used. If this is just one number then
+                this number of processes is used for all configurations specified with -c. If it's a
+                list of numbers this list must have as many elements as there are configurations. We
+                then iterate over zip(configs, num_processes) to determine the number of processes
+                used for each configuration. More processes are always faster (up to the number of
+                threads your PC can support, so 8 for a 4-core CPU with hyperthreading. If you don't
+                know what that is then don't touch it, or at least don't increase it!). DANGER: More
+                often than not the number of processes that can be used is limited by the amount of
+                RAM available. Image resampling takes up a lot of RAM. MONITOR RAM USAGE AND
+                DECREASE -n_proc IF YOUR RAM FILLS UP TOO MUCH! Default: 8 4 8 (=8 processes for 2d, 4
+                for 3d_fullres and 8 for 3d_lowres if -c is at its default).
+            verbose: Set this to print a lot of stuff. Useful for debugging. Will disable the progress bar!
+                Recommended for cluster environments.
+        """
+        from nnunetv2.experiment_planning.plan_and_preprocess_api import preprocess
+
+        logger.info("Preprocessing...")
+        preprocess(
+            [int(self.dataset_name_or_id)],
+            overwrite_plans_name,
+            configurations=c,
+            num_processes=n_proc,
+            verbose=verbose,
+        )
+
+    def plan_and_process(
+        self,
+        fpe: str = "DatasetFingerprintExtractor",
+        npfp: int = 8,
+        verify_dataset_integrity: bool = False,
+        no_pp: bool = False,
+        clean: bool = False,
+        pl: str = "ExperimentPlanner",
+        gpu_memory_target: int = 8,
+        preprocessor_name: str = "DefaultPreprocessor",
+        overwrite_target_spacing: Any = None,
+        overwrite_plans_name: str = "nnUNetPlans",
+        c: tuple = (M.N_2D, M.N_3D_FULLRES, M.N_3D_LOWRES),
+        n_proc: tuple = (8, 8, 8),
+        verbose: bool = False,
+    ) -> None:
+        """
+        Performs experiment planning and preprocessing before the training.
+
+        Args:
+            fpe: [OPTIONAL] Name of the Dataset Fingerprint Extractor class that should be used. Default is
+                "DatasetFingerprintExtractor".
+            npfp: [OPTIONAL] Number of processes used for fingerprint extraction. Default: 8.
+            verify_dataset_integrity: [RECOMMENDED] set this flag to check the dataset integrity.
+                This is useful and should be done once for each dataset!
+            no_pp: [OPTIONAL] Set this to only run fingerprint extraction and experiment planning (no
+                preprocessing). Useful for debugging.
+            clean:[OPTIONAL] Set this flag to overwrite existing fingerprints. If this flag is not set and a
+                fingerprint already exists, the fingerprint extractor will not run. REQUIRED IF YOU
+                CHANGE THE DATASET FINGERPRINT EXTRACTOR OR MAKE CHANGES TO THE DATASET!
+            pl: [OPTIONAL] Name of the Experiment Planner class that should be used. Default is "ExperimentPlanner".
+                Note: There is no longer a distinction between 2d and 3d planner. It's an all-in-one solution now.
+            gpu_memory_target: [OPTIONAL] DANGER ZONE! Sets a custom GPU memory target. Default: 8 [GB].
+                Changing this will affect patch and batch size and will
+                definitely affect your models' performance! Only use this if you really know what you
+                are doing and NEVER use this without running the default nnU-Net first (as a baseline).
+            preprocessor_name: [OPTIONAL] DANGER ZONE! Sets a custom preprocessor class. This class must be located in
+                nnunetv2.preprocessing. Default: "DefaultPreprocessor". Changing this may affect your
+                models' performance! Only use this if you really know what you
+                are doing and NEVER use this without running the default nnU-Net first (as a baseline).
+            overwrite_target_spacing: [OPTIONAL] DANGER ZONE! Sets a custom target spacing for the 3d_fullres and
+                3d_cascade_fullres configurations. Default: None [no changes]. Changing this will affect image size and
+                potentially patch and batch size. This will definitely affect your models performance!
+                Only use this if you really know what you are doing and NEVER use this without running the
+                default nnU-Net first (as a baseline). Changing the target spacing for the other
+                configurations is currently not implemented. New target spacing must be a list of three numbers!
+            overwrite_plans_name: [OPTIONAL] USE A CUSTOM PLANS IDENTIFIER. If you used -gpu_memory_target,
+                -preprocessor_name or -overwrite_target_spacing it is best practice to use -overwrite_plans_name to
+                generate a differently named plans file such that the nnunet default plans are not
+                overwritten. You will then need to specify your custom plans file with -p whenever
+                running other nnunet commands (training, inference, etc)
+            c: [OPTIONAL] Configurations for which the preprocessing should be run. Default: 2d 3f_fullres
+                3d_lowres. 3d_cascade_fullres does not need to be specified because it uses the data
+                from 3f_fullres. Configurations that do not exist for some datasets will be skipped.
+            n_proc: [OPTIONAL] Use this to define how many processes are to be used. If this is just one number then
+                this number of processes is used for all configurations specified with -c. If it's a
+                list of numbers this list must have as many elements as there are configurations. We
+                then iterate over zip(configs, num_processes) to determine the number of processes
+                used for each configuration. More processes are always faster (up to the number of
+                threads your PC can support, so 8 for a 4-core CPU with hyperthreading. If you don't
+                know what that is then don't touch it, or at least don't increase it!). DANGER: More
+                often than not the number of processes that can be used is limited by the amount of
+                RAM available. Image resampling takes up a lot of RAM. MONITOR RAM USAGE AND
+                DECREASE -n_proc IF YOUR RAM FILLS UP TOO MUCH! Default: 8 4 8 (=8 processes for 2d, 4
+                for 3d_fullres and 8 for 3d_lowres if -c is at its default).
+            verbose: Set this to print a lot of stuff. Useful for debugging. Will disable progress bar!
+                (Recommended for cluster environments).
+        """
+        self.extract_fingerprints(fpe, npfp, verify_dataset_integrity, clean, verbose)
+        self.plan_experiments(pl, gpu_memory_target, preprocessor_name, overwrite_target_spacing, overwrite_plans_name)
+
+        if not no_pp:
+            self.preprocess(c, n_proc, overwrite_plans_name, verbose)
+
+    def train_single_model(self, config: Any, fold: int, gpu_id: tuple | list | int = 0, **kwargs: Any) -> None:
+        """
+        Run the training on a single GPU with one specified configuration provided.
+        Note: this will override the environment variable `CUDA_VISIBLE_DEVICES`.
+
+        Args:
+            config: configuration that should be trained. Examples: "2d", "3d_fullres", "3d_lowres".
+            fold: fold of the 5-fold cross-validation. Should be an int between 0 and 4.
+            gpu_id: an integer to select the device to use, or a tuple/list of GPU device indices used for multi-GPU
+                training (e.g., (0,1)). Default: 0.
+            kwargs: this optional parameter allows you to specify additional arguments in
+                ``nnunetv2.run.run_training.run_training_entry``.
+
+                Currently supported args are:
+
+                - p: custom plans identifier. Default: "nnUNetPlans".
+                - pretrained_weights: path to nnU-Net checkpoint file to be used as pretrained model. Will only be
+                    used when actually training. Beta. Use with caution. Default: False.
+                - use_compressed: True to use compressed data for training. Reading compressed data is much
+                    more CPU and (potentially) RAM intensive and should only be used if you know what you are
+                    doing. Default: False.
+                - c: continue training from latest checkpoint. Default: False.
+                - val: True to run the validation only. Requires training to have finished.
+                    Default: False.
+                - disable_checkpointing: True to disable checkpointing. Ideal for testing things out and you
+                    don't want to flood your hard drive with checkpoints. Default: False.
+        """
+        if "num_gpus" in kwargs:
+            kwargs.pop("num_gpus")
+            logger.warning("please use gpu_id to set the GPUs to use")
+
+        if "tr" in kwargs:
+            kwargs.pop("tr")
+            logger.warning("please specify the `trainer_class_name` in the __init__ of `nnUNetV2Runner`.")
+
+        if "npz" in kwargs:
+            kwargs.pop("npz")
+            logger.warning("please specify the `export_validation_probabilities` in the __init__ of `nnUNetV2Runner`.")
+
+        cmd = self.train_single_model_command(config, fold, gpu_id, kwargs)
+        run_cmd(cmd, shell=True)
+
+    def train_single_model_command(self, config, fold, gpu_id, kwargs):
+        if isinstance(gpu_id, (tuple, list)):
+            if len(gpu_id) > 1:
+                gpu_ids_str = ""
+                for _i in range(len(gpu_id)):
+                    gpu_ids_str += f"{gpu_id[_i]},"
+                device_setting = f"CUDA_VISIBLE_DEVICES={gpu_ids_str[:-1]}"
+            else:
+                device_setting = f"CUDA_VISIBLE_DEVICES={gpu_id[0]}"
+        else:
+            device_setting = f"CUDA_VISIBLE_DEVICES={gpu_id}"
+        num_gpus = 1 if isinstance(gpu_id, int) or len(gpu_id) == 1 else len(gpu_id)
+
+        cmd = (
+            f"{device_setting} nnUNetv2_train "
+            + f"{self.dataset_name_or_id} {config} {fold} "
+            + f"-tr {self.trainer_class_name} -num_gpus {num_gpus}"
+        )
+        if self.export_validation_probabilities:
+            cmd += " --npz"
+        for _key, _value in kwargs.items():
+            if _key == "p" or _key == "pretrained_weights":
+                cmd += f" -{_key} {_value}"
+            else:
+                cmd += f" --{_key} {_value}"
+        return cmd
+
+    def train(
+        self,
+        configs: tuple | str = (M.N_3D_FULLRES, M.N_2D, M.N_3D_LOWRES, M.N_3D_CASCADE_FULLRES),
+        gpu_id_for_all: tuple | list | int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Run the training for all the models specified by the configurations.
+        Note: to set the number of GPUs to use, use ``gpu_id_for_all`` instead of the `CUDA_VISIBLE_DEVICES`
+        environment variable.
+
+        Args:
+            configs: configurations that should be trained.
+                Default: ("2d", "3d_fullres", "3d_lowres", "3d_cascade_fullres").
+            gpu_id_for_all: a tuple/list/integer of GPU device ID(s) to use for the training. Default:
+                None (all available GPUs).
+            kwargs: this optional parameter allows you to specify additional arguments defined in the
+                ``train_single_model`` method.
+        """
+        if gpu_id_for_all is None:
+            result = subprocess.run(["nvidia-smi", "--list-gpus"], stdout=subprocess.PIPE)
+            output = result.stdout.decode("utf-8")
+            num_gpus = len(output.strip().split("\n"))
+            gpu_id_for_all = tuple(range(num_gpus))
+        elif isinstance(gpu_id_for_all, int):
+            gpu_id_for_all = ensure_tuple(gpu_id_for_all)
+        logger.info(f"number of GPUs is {len(gpu_id_for_all)}, device ids are {gpu_id_for_all}")
+        if len(gpu_id_for_all) > 1:
+            self.train_parallel(configs=ensure_tuple(configs), gpu_id_for_all=gpu_id_for_all, **kwargs)
+        else:
+            for cfg in ensure_tuple(configs):
+                for _fold in range(self.num_folds):
+                    self.train_single_model(config=cfg, fold=_fold, gpu_id=gpu_id_for_all, **kwargs)
+
+    def train_parallel_cmd(
+        self,
+        configs: tuple | str = (M.N_3D_FULLRES, M.N_2D, M.N_3D_LOWRES, M.N_3D_CASCADE_FULLRES),
+        gpu_id_for_all: tuple | list | int | None = None,
+        **kwargs: Any,
+    ) -> list:
+        """
+        Create the line command for subprocess call for parallel training.
+
+        Args:
+            configs: configurations that should be trained.
+                Default: ("2d", "3d_fullres", "3d_lowres", "3d_cascade_fullres").
+            gpu_id_for_all: a tuple/list/integer of GPU device ID(s) to use for the training. Default:
+                None (all available GPUs).
+            kwargs: this optional parameter allows you to specify additional arguments defined in the
+                ``train_single_model`` method.
+        """
+        # unpack compressed files
+        folder_names = []
+        for root, _, files in os.walk(os.path.join(self.nnunet_preprocessed, self.dataset_name)):
+            if any(file.endswith(".npz") for file in files):
+                folder_names.append(root)
+
+        from nnunetv2.training.dataloading.utils import unpack_dataset
+
+        for folder_name in folder_names:
+            logger.info(f"unpacking '{folder_name}'...")
+            unpack_dataset(
+                folder=folder_name,
+                unpack_segmentation=True,
+                overwrite_existing=False,
+                num_processes=self.default_num_processes,
+            )
+
+        # model training
+        kwargs = kwargs or {}
+        devices = ensure_tuple(gpu_id_for_all)
+        n_devices = len(devices)
+        _configs = [[M.N_3D_FULLRES, M.N_2D, M.N_3D_LOWRES], [M.N_3D_CASCADE_FULLRES]]
+        all_cmds: list = []
+        for _stage in range(len(_configs)):
+            all_cmds.append({_j: [] for _j in devices})
+            _index = 0
+
+            for _config in _configs[_stage]:
+                if _config in ensure_tuple(configs):
+                    for _i in range(self.num_folds):
+                        the_device = gpu_id_for_all[_index % n_devices]  # type: ignore
+                        cmd = self.train_single_model_command(_config, _i, the_device, kwargs)
+                        all_cmds[-1][the_device].append(cmd)
+                        _index += 1
+        return all_cmds
+
+    def train_parallel(
+        self,
+        configs: tuple | str = (M.N_3D_FULLRES, M.N_2D, M.N_3D_LOWRES, M.N_3D_CASCADE_FULLRES),
+        gpu_id_for_all: tuple | list | int | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Create the line command for subprocess call for parallel training.
+        Note: to set the number of GPUs to use, use ``gpu_id_for_all`` instead of the `CUDA_VISIBLE_DEVICES`
+        environment variable.
+
+        Args:
+            configs: configurations that should be trained.
+                default: ("2d", "3d_fullres", "3d_lowres", "3d_cascade_fullres").
+            gpu_id_for_all: a tuple/list/integer of GPU device ID(s) to use for the training. Default:
+                None (all available GPUs).
+            kwargs: this optional parameter allows you to specify additional arguments defined in the
+                ``train_single_model`` method.
+        """
+        all_cmds = self.train_parallel_cmd(configs=configs, gpu_id_for_all=gpu_id_for_all, **kwargs)
+        for s, cmds in enumerate(all_cmds):
+            for gpu_id, gpu_cmd in cmds.items():
+                if not gpu_cmd:
+                    continue
+                logger.info(
+                    f"training - stage {s + 1}:\n"
+                    f"for gpu {gpu_id}, commands: {gpu_cmd}\n"
+                    f"log '.txt' inside '{os.path.join(self.nnunet_results, self.dataset_name)}'"
+                )
+        for stage in all_cmds:
+            processes = []
+            for device_id in stage:
+                if not stage[device_id]:
+                    continue
+                cmd_str = "; ".join(stage[device_id])
+                logger.info(f"Current running command on GPU device {device_id}:\n{cmd_str}\n")
+                processes.append(subprocess.Popen(cmd_str, shell=True, stdout=subprocess.DEVNULL))
+            # finish this stage first
+            for p in processes:
+                p.wait()
+
+    def validate_single_model(self, config: str, fold: int, **kwargs: Any) -> None:
+        """
+        Perform validation on single model.
+
+        Args:
+            config: configuration that should be trained.
+            fold: fold of the 5-fold cross-validation. Should be an int between 0 and 4.
+            kwargs: this optional parameter allows you to specify additional arguments defined in the
+                ``train_single_model`` method.
+        """
+        self.train_single_model(config=config, fold=fold, only_run_validation=True, **kwargs)
+
+    def validate(
+        self, configs: tuple = (M.N_3D_FULLRES, M.N_2D, M.N_3D_LOWRES, M.N_3D_CASCADE_FULLRES), **kwargs: Any
+    ) -> None:
+        """
+        Perform validation in all models defined by the configurations over 5 folds.
+
+        Args:
+            configs: configurations that should be trained.
+                default: ("2d", "3d_fullres", "3d_lowres", "3d_cascade_fullres").
+            kwargs: this optional parameter allows you to specify additional arguments defined in the
+                ``train_single_model`` method.
+        """
+        for cfg in ensure_tuple(configs):
+            for _fold in range(self.num_folds):
+                self.validate_single_model(config=cfg, fold=_fold, **kwargs)
+
+    def find_best_configuration(
+        self,
+        plans: tuple | str = "nnUNetPlans",
+        configs: tuple | str = (M.N_2D, M.N_3D_FULLRES, M.N_3D_LOWRES, M.N_3D_CASCADE_FULLRES),
+        trainers: tuple | str | None = None,
+        allow_ensembling: bool = True,
+        num_processes: int = -1,
+        overwrite: bool = True,
+        folds: list[int] | tuple[int, ...] = (0, 1, 2, 3, 4),
+        strict: bool = False,
+    ) -> None:
+        """
+        Find the best model configurations.
+
+        Args:
+            plans: list of plan identifiers. Default: nnUNetPlans.
+            configs: list of configurations. Default: ["2d", "3d_fullres", "3d_lowres", "3d_cascade_fullres"].
+            trainers: list of trainers. Default: nnUNetTrainer.
+            allow_ensembling: set this flag to enable ensembling.
+            num_processes: number of processes to use for ensembling, postprocessing, etc.
+            overwrite: if set we will overwrite already ensembled files etc. May speed up consecutive
+                runs of this command (not recommended) at the risk of not updating outdated results.
+            folds: folds to use. Default: (0, 1, 2, 3, 4).
+            strict: a switch that triggers RunTimeError if the logging folder cannot be found. Default: False.
+        """
+        from nnunetv2.evaluation.find_best_configuration import (
+            dumb_trainer_config_plans_to_trained_models_dict,
+            find_best_configuration,
+        )
+
+        configs = ensure_tuple(configs)
+        plans = ensure_tuple(plans)
+
+        if trainers is None:
+            trainers = self.trainer_class_name
+        trainers = ensure_tuple(trainers)
+
+        models = dumb_trainer_config_plans_to_trained_models_dict(trainers, configs, plans)
+        num_processes = self.default_num_processes if num_processes < 0 else num_processes
+        find_best_configuration(
+            int(self.dataset_name_or_id),
+            models,
+            allow_ensembling=allow_ensembling,
+            num_processes=num_processes,
+            overwrite=overwrite,
+            folds=folds,
+            strict=strict,
+        )
+
+    def predict(
+        self,
+        list_of_lists_or_source_folder: str | list[list[str]],
+        output_folder: str | None | list[str],
+        model_training_output_dir: str,
+        use_folds: tuple[int, ...] | str | None = None,
+        tile_step_size: float = 0.5,
+        use_gaussian: bool = True,
+        use_mirroring: bool = True,
+        perform_everything_on_gpu: bool = True,
+        verbose: bool = True,
+        save_probabilities: bool = False,
+        overwrite: bool = True,
+        checkpoint_name: str = "checkpoint_final.pth",
+        folder_with_segs_from_prev_stage: str | None = None,
+        num_parts: int = 1,
+        part_id: int = 0,
+        num_processes_preprocessing: int = -1,
+        num_processes_segmentation_export: int = -1,
+        gpu_id: int = 0,
+    ) -> None:
+        """
+        Use this to run inference with nnU-Net. This function is used when you want to manually specify a folder containing
+            a trained nnU-Net model. This is useful when the nnunet environment variables (nnUNet_results) are not set.
+
+        Args:
+            list_of_lists_or_source_folder: input folder. Remember to use the correct channel numberings for
+                your files (_0000 etc). File endings must be the same as the training dataset!
+            output_folder: Output folder. If it does not exist it will be created. Predicted segmentations will
+                have the same name as their source images.
+            model_training_output_dir: folder in which the trained model is. Must have subfolders fold_X for the
+                different folds you trained.
+            use_folds: specify the folds of the trained model that should be used for prediction
+                Default: (0, 1, 2, 3, 4).
+            tile_step_size: step size for sliding window prediction. The larger it is the faster but less accurate
+                the prediction. Default: 0.5. Cannot be larger than 1. We recommend the default.
+            use_gaussian: use Gaussian smoothing as test-time augmentation.
+            use_mirroring: use mirroring/flipping as test-time augmentation.
+            verbose: set this if you like being talked to. You will have to be a good listener/reader.
+            save_probabilities: set this to export predicted class "probabilities". Required if you want to ensemble
+                multiple configurations.
+            overwrite: overwrite an existing previous prediction (will not overwrite existing files)
+            checkpoint_name: name of the checkpoint you want to use. Default: checkpoint_final.pth.
+            folder_with_segs_from_prev_stage: folder containing the predictions of the previous stage.
+                Required for cascaded models.
+            num_parts: number of separate nnUNetv2_predict call that you will be making. Default: 1 (= this one
+                call predicts everything).
+            part_id: if multiple nnUNetv2_predict exist, which one is this? IDs start with 0 can end with
+                num_parts - 1. So when you submit 5 nnUNetv2_predict calls you need to set -num_parts
+                5 and use -part_id 0, 1, 2, 3 and 4.
+            num_processes_preprocessing: out-of-RAM issues.
+            num_processes_segmentation_export: Number of processes used for segmentation export.
+                More is not always better. Beware of out-of-RAM issues.
+            gpu_id: which GPU to use for prediction.
+        """
+        os.environ["CUDA_VISIBLE_DEVICES"] = f"{gpu_id}"
+
+        from nnunetv2.inference.predict_from_raw_data import nnUNetPredictor
+
+        n_processes_preprocessing = (
+            self.default_num_processes if num_processes_preprocessing < 0 else num_processes_preprocessing
+        )
+        n_processes_segmentation_export = (
+            self.default_num_processes if num_processes_segmentation_export < 0 else num_processes_segmentation_export
+        )
+        predictor = nnUNetPredictor(
+            tile_step_size=tile_step_size,
+            use_gaussian=use_gaussian,
+            use_mirroring=use_mirroring,
+            perform_everything_on_device=perform_everything_on_gpu,
+            verbose=verbose,
+        )
+        predictor.initialize_from_trained_model_folder(
+            model_training_output_dir=model_training_output_dir, use_folds=use_folds, checkpoint_name=checkpoint_name
+        )
+        predictor.predict_from_files(
+            list_of_lists_or_source_folder=list_of_lists_or_source_folder,
+            output_folder_or_list_of_truncated_output_files=output_folder,
+            save_probabilities=save_probabilities,
+            overwrite=overwrite,
+            num_processes_preprocessing=n_processes_preprocessing,
+            num_processes_segmentation_export=n_processes_segmentation_export,
+            folder_with_segs_from_prev_stage=folder_with_segs_from_prev_stage,
+            num_parts=num_parts,
+            part_id=part_id,
+        )
+
+    def predict_ensemble_postprocessing(
+        self,
+        folds: tuple = (0, 1, 2, 3, 4),
+        run_ensemble: bool = True,
+        run_predict: bool = True,
+        run_postprocessing: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Run prediction, ensemble, and/or postprocessing optionally.
+
+        Args:
+            folds: which folds to use
+            run_ensemble: whether to run ensembling.
+            run_predict: whether to predict using trained checkpoints
+            run_postprocessing: whether to conduct post-processing
+            kwargs: this optional parameter allows you to specify additional arguments defined in the
+                ``predict`` method.
+        """
+        from nnunetv2.ensembling.ensemble import ensemble_folders
+        from nnunetv2.postprocessing.remove_connected_components import apply_postprocessing_to_folder
+        from nnunetv2.utilities.file_path_utilities import get_output_folder
+
+        source_dir = join(self.nnunet_raw, self.dataset_name, "imagesTs")
+        target_dir_base = join(self.nnunet_results, self.dataset_name)
+
+        self.best_configuration = ConfigParser.load_config_file(
+            os.path.join(self.nnunet_results, self.dataset_name, "inference_information.json")
+        )
+
+        run_ensemble = (
+            run_ensemble and len(self.best_configuration["best_model_or_ensemble"]["selected_model_or_models"]) > 1
+        )
+
+        used_folds = folds
+        output_folders = []
+        for im in self.best_configuration["best_model_or_ensemble"]["selected_model_or_models"]:
+            output_dir = join(target_dir_base, f"pred_{im['configuration']}")
+            output_folders.append(output_dir)
+
+            if run_predict:
+                model_folder = get_output_folder(
+                    int(self.dataset_name_or_id), im["trainer"], im["plans_identifier"], im["configuration"]
+                )
+                self.predict(
+                    list_of_lists_or_source_folder=source_dir,
+                    output_folder=output_dir,
+                    model_training_output_dir=model_folder,
+                    use_folds=used_folds,
+                    save_probabilities=run_ensemble,
+                    verbose=False,
+                    overwrite=True,
+                    **kwargs,
+                )
+
+        # if we have an ensemble, we need to ensemble the results
+        if run_ensemble:
+            ensemble_folders(
+                output_folders, join(target_dir_base, "ensemble_predictions"), save_merged_probabilities=False
+            )
+            if run_postprocessing:
+                folder_for_pp = join(target_dir_base, "ensemble_predictions")
+        elif run_postprocessing:
+            folder_for_pp = output_folders[0]
+
+        # apply postprocessing
+        if run_postprocessing:
+            pp_fns, pp_fn_kwargs = load_pickle(self.best_configuration["best_model_or_ensemble"]["postprocessing_file"])
+            apply_postprocessing_to_folder(
+                folder_for_pp,
+                join(target_dir_base, "ensemble_predictions_postprocessed"),
+                pp_fns,
+                pp_fn_kwargs,
+                plans_file_or_dict=self.best_configuration["best_model_or_ensemble"]["some_plans_file"],
+            )
+
+    def run(
+        self,
+        run_convert_dataset: bool = True,
+        run_plan_and_process: bool = True,
+        run_train: bool = True,
+        run_find_best_configuration: bool = True,
+        run_predict_ensemble_postprocessing: bool = True,
+    ) -> None:
+        """
+        Run the nnU-Net pipeline.
+
+        Args:
+            run_convert_dataset: whether to convert datasets, defaults to True.
+            run_plan_and_process: whether to preprocess and analyze the dataset, defaults to True.
+            run_train: whether to train models, defaults to True.
+            run_find_best_configuration: whether to find the best model (ensemble) configurations, defaults to True.
+            run_predict_ensemble_postprocessing: whether to make predictions on test datasets, defaults to True.
+        """
+        if run_convert_dataset:
+            self.convert_dataset()
+
+        if run_plan_and_process:
+            self.plan_and_process()
+
+        if run_train:
+            self.train()
+
+        if run_find_best_configuration:
+            self.find_best_configuration()
+
+        if run_predict_ensemble_postprocessing:
+            self.predict_ensemble_postprocessing()
+
+        return

source_code/SegMamba/monai/apps/nnunet/utils.py

@@ -0,0 +1,178 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import copy
+import os
+
+import numpy as np
+
+import monai
+from monai.bundle import ConfigParser
+from monai.utils import StrEnum, ensure_tuple, optional_import
+
+tqdm, has_tqdm = optional_import("tqdm", name="tqdm")
+nib, _ = optional_import("nibabel")
+
+logger = monai.apps.utils.get_logger(__name__)
+
+__all__ = ["analyze_data", "create_new_data_copy", "create_new_dataset_json", "NNUNETMode"]
+
+
+class NNUNETMode(StrEnum):
+    N_2D = "2d"
+    N_3D_FULLRES = "3d_fullres"
+    N_3D_LOWRES = "3d_lowres"
+    N_3D_CASCADE_FULLRES = "3d_cascade_fullres"
+
+
+def analyze_data(datalist_json: dict, data_dir: str) -> tuple[int, int]:
+    """
+    Analyze (training) data
+
+    Args:
+        datalist_json: original data list .json (required by most monai tutorials).
+        data_dir: raw data directory.
+    """
+    img = monai.transforms.LoadImage(image_only=True, ensure_channel_first=True, simple_keys=True)(
+        os.path.join(data_dir, datalist_json["training"][0]["image"])
+    )
+    num_input_channels = img.size()[0] if img.dim() == 4 else 1
+    logger.info(f"num_input_channels: {num_input_channels}")
+
+    num_foreground_classes = 0
+    for _i in range(len(datalist_json["training"])):
+        seg = monai.transforms.LoadImage(image_only=True, ensure_channel_first=True, simple_keys=True)(
+            os.path.join(data_dir, datalist_json["training"][_i]["label"])
+        )
+        num_foreground_classes = max(num_foreground_classes, int(seg.max()))
+    logger.info(f"num_foreground_classes: {num_foreground_classes}")
+
+    return num_input_channels, num_foreground_classes
+
+
+def create_new_data_copy(
+    test_key: str, datalist_json: dict, data_dir: str, num_input_channels: int, output_datafolder: str
+) -> None:
+    """
+    Create and organize a new copy of data to meet the requirements of nnU-Net V2
+
+    Args:
+        test_key: key for test data in the data list .json.
+        datalist_json: original data list .json (required by most monai tutorials).
+        data_dir: raw data directory.
+        num_input_channels: number of input (image) channels.
+        output_datafolder: output folder.
+    """
+    _index = 0
+    new_datalist_json: dict = {"training": [], test_key: []}
+
+    for _key, _folder, _label_folder in list(
+        zip(["training", test_key], ["imagesTr", "imagesTs"], ["labelsTr", "labelsTs"])
+    ):
+        if _key is None:
+            continue
+
+        logger.info(f"converting data section: {_key}...")
+        for _k in tqdm(range(len(datalist_json[_key]))) if has_tqdm else range(len(datalist_json[_key])):
+            orig_img_name = (
+                datalist_json[_key][_k]["image"]
+                if isinstance(datalist_json[_key][_k], dict)
+                else datalist_json[_key][_k]
+            )
+            img_name = f"case_{_index}"
+            _index += 1
+
+            # copy image
+            nda = monai.transforms.LoadImage(image_only=True, ensure_channel_first=True, simple_keys=True)(
+                os.path.join(data_dir, orig_img_name)
+            )
+            affine = nda.meta["original_affine"]
+            nda = nda.numpy()
+            for _l in range(num_input_channels):
+                outimg = nib.Nifti1Image(nda[_l, ...], affine)
+                index = "_" + str(_l + 10000)[-4:]
+                nib.save(outimg, os.path.join(output_datafolder, _folder, img_name + index + ".nii.gz"))
+
+            # copy label
+            if isinstance(datalist_json[_key][_k], dict) and "label" in datalist_json[_key][_k]:
+                nda = monai.transforms.LoadImage(image_only=True, ensure_channel_first=True, simple_keys=True)(
+                    os.path.join(data_dir, datalist_json[_key][_k]["label"])
+                )
+                affine = nda.meta["original_affine"]
+                nda = nda.numpy().astype(np.uint8)
+                nda = nda[0, ...] if nda.ndim == 4 and nda.shape[0] == 1 else nda
+                nib.save(
+                    nib.Nifti1Image(nda, affine), os.path.join(output_datafolder, _label_folder, img_name + ".nii.gz")
+                )
+
+            if isinstance(datalist_json[_key][_k], dict):
+                _val = copy.deepcopy(datalist_json[_key][_k])
+                _val["new_name"] = img_name
+                new_datalist_json[_key].append(_val)
+            else:
+                new_datalist_json[_key].append({"image": datalist_json[_key][_k], "new_name": img_name})
+
+            ConfigParser.export_config_file(
+                config=new_datalist_json,
+                filepath=os.path.join(output_datafolder, "datalist.json"),
+                fmt="json",
+                sort_keys=True,
+                indent=4,
+                ensure_ascii=False,
+            )
+
+    return
+
+
+def create_new_dataset_json(
+    modality: str, num_foreground_classes: int, num_input_channels: int, num_training_data: int, output_filepath: str
+) -> None:
+    """
+    Create a new copy of dataset .json to meet the requirements of nnU-Net V2
+
+    Args:
+        modality: image modality, could a string or a list of strings.
+        num_foreground_classes: number of foreground classes.
+        num_input_channels: number of input (image) channels.
+        num_training_data: number of training data.
+        output_filepath: output file path/name.
+    """
+    new_json_data: dict = {}
+
+    # modality = self.input_info.pop("modality")
+    modality = ensure_tuple(modality)  # type: ignore
+
+    new_json_data["channel_names"] = {}
+    for _j in range(num_input_channels):
+        new_json_data["channel_names"][str(_j)] = modality[_j]
+
+    new_json_data["labels"] = {}
+    new_json_data["labels"]["background"] = 0
+    for _j in range(num_foreground_classes):
+        new_json_data["labels"][f"class{_j + 1}"] = _j + 1
+
+    # new_json_data["numTraining"] = len(datalist_json["training"])
+    new_json_data["numTraining"] = num_training_data
+    new_json_data["file_ending"] = ".nii.gz"
+
+    ConfigParser.export_config_file(
+        config=new_json_data,
+        # filepath=os.path.join(raw_data_foldername, "dataset.json"),
+        filepath=output_filepath,
+        fmt="json",
+        sort_keys=True,
+        indent=4,
+        ensure_ascii=False,
+    )
+
+    return

source_code/SegMamba/monai/apps/nuclick/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

source_code/SegMamba/monai/apps/nuclick/transforms.py

@@ -0,0 +1,641 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+import torch
+
+from monai.config import KeysCollection, NdarrayOrTensor
+from monai.networks.layers import GaussianFilter
+from monai.transforms import MapTransform, Randomizable, SpatialPad
+from monai.utils import StrEnum, convert_to_numpy, optional_import
+
+measure, _ = optional_import("skimage.measure")
+morphology, _ = optional_import("skimage.morphology")
+distance_transform_cdt, _ = optional_import("scipy.ndimage.morphology", name="distance_transform_cdt")
+
+
+class NuclickKeys(StrEnum):
+    """
+    Keys for nuclick transforms.
+    """
+
+    IMAGE = "image"
+    LABEL = "label"
+    OTHERS = "others"  # key of other labels from the binary mask which are not being used for training
+    FOREGROUND = "foreground"
+
+    CENTROID = "centroid"  # key where the centroid values are stored
+    MASK_VALUE = "mask_value"
+    LOCATION = "location"
+
+    NUC_POINTS = "nuc_points"
+    BOUNDING_BOXES = "bounding_boxes"
+    IMG_HEIGHT = "img_height"
+    IMG_WIDTH = "img_width"
+    PRED_CLASSES = "pred_classes"
+
+
+class FlattenLabeld(MapTransform):
+    """
+    FlattenLabeld creates labels per closed object contour (defined by a connectivity). For e.g if there are
+    12 small regions of 1's it will delineate them into 12 different label classes
+
+    Args:
+        connectivity: Max no. of orthogonal hops to consider a pixel/voxel as a neighbor. Refer skimage.measure.label
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    def __init__(self, keys: KeysCollection, connectivity: int = 1, allow_missing_keys: bool = False):
+        super().__init__(keys, allow_missing_keys)
+        self.connectivity = connectivity
+
+    def __call__(self, data):
+        d = dict(data)
+        for key in self.keys:
+            img = convert_to_numpy(d[key]) if isinstance(d[key], torch.Tensor) else d[key]
+            d[key] = measure.label(img, connectivity=self.connectivity).astype(np.uint8)
+        return d
+
+
+class ExtractPatchd(MapTransform):
+    """
+    Extracts a patch from the given image and label, however it is based on the centroid location.
+    The centroid location is a 2D coordinate (H, W). The extracted patch is extracted around the centroid,
+    if the centroid is towards the edge, the centroid will not be the center of the image as the patch will be
+    extracted from the edges onwards
+
+    Args:
+        keys: image, label
+        centroid_key: key where the centroid values are stored, defaults to ``"centroid"``
+        patch_size: size of the extracted patch
+        allow_missing_keys: don't raise exception if key is missing.
+        pad_kwargs: other arguments for the SpatialPad transform
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        centroid_key: str = NuclickKeys.CENTROID,
+        patch_size: tuple[int, int] | int = 128,
+        allow_missing_keys: bool = False,
+        **kwargs: Any,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.centroid_key = centroid_key
+        self.patch_size = patch_size
+        self.kwargs = kwargs
+
+    def __call__(self, data):
+        d = dict(data)
+
+        centroid = d[self.centroid_key]  # create mask based on centroid (select nuclei based on centroid)
+        roi_size = (self.patch_size, self.patch_size)
+
+        for key in self.keys:
+            img = d[key]
+            x_start, x_end, y_start, y_end = self.bbox(self.patch_size, centroid, img.shape[-2:])
+            cropped = img[:, x_start:x_end, y_start:y_end]
+            d[key] = SpatialPad(spatial_size=roi_size, **self.kwargs)(cropped)
+        return d
+
+    def bbox(self, patch_size, centroid, size):
+        x, y = centroid
+        m, n = size
+
+        x_start = int(max(x - patch_size / 2, 0))
+        y_start = int(max(y - patch_size / 2, 0))
+        x_end = x_start + patch_size
+        y_end = y_start + patch_size
+        if x_end > m:
+            x_end = m
+            x_start = m - patch_size
+        if y_end > n:
+            y_end = n
+            y_start = n - patch_size
+        return x_start, x_end, y_start, y_end
+
+
+class SplitLabeld(MapTransform):
+    """
+    Extracts a single label from all the given classes, the single label is defined by mask_value, the remaining
+    labels are kept in others
+
+    Args:
+        label: key of the label source
+        others: other labels storage key, defaults to ``"others"``
+        mask_value: the mask_value that will be kept for binarization of the label, defaults to ``"mask_value"``
+        min_area: The smallest allowable object size.
+        others_value: Value/class for other nuclei;  Use this to separate core nuclei vs others.
+        to_binary_mask: Convert mask to binary;  Set it false to restore original class values
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        others: str = NuclickKeys.OTHERS,
+        mask_value: str | None = NuclickKeys.MASK_VALUE,
+        min_area: int = 5,
+        others_value: int = 0,
+        to_binary_mask: bool = True,
+    ):
+        super().__init__(keys, allow_missing_keys=False)
+        self.others = others
+        self.mask_value = mask_value
+        self.min_area = min_area
+        self.others_value = others_value
+        self.to_binary_mask = to_binary_mask
+
+    def __call__(self, data):
+        d = dict(data)
+
+        if len(self.keys) > 1:
+            print("Only 'label' key is supported, more than 1 key was found")
+            return None
+
+        for key in self.keys:
+            label = d[key] if isinstance(d[key], torch.Tensor) else torch.from_numpy(d[key])
+
+            mask = torch.clone(label)
+            if self.mask_value:
+                mask_value = d[self.mask_value]
+                mask[label != mask_value] = 0
+            else:
+                mask[label >= self.others_value] = 0
+                mask_value = int(torch.max(mask))
+
+            if self.to_binary_mask:
+                mask[mask > 0] = 1
+
+            others = torch.clone(label)
+            others[label == mask_value] = 0
+            others[others > 0] = 1
+            if torch.count_nonzero(others):
+                others = measure.label(convert_to_numpy(others)[0], connectivity=1)
+                others = torch.from_numpy(others)[None]
+
+            label = mask.type(torch.uint8) if isinstance(mask, torch.Tensor) else mask
+            others = others.type(torch.uint8) if isinstance(others, torch.Tensor) else others
+
+            d[key] = label if isinstance(d[key], torch.Tensor) else convert_to_numpy(label)
+            d[self.others] = others if isinstance(d[key], torch.Tensor) else convert_to_numpy(others)
+
+        return d
+
+
+class FilterImaged(MapTransform):
+    """
+    Filters Green and Gray channel of the image using an allowable object size, this pre-processing transform
+    is specific towards NuClick training process. More details can be referred in this paper Koohbanani,
+    Navid Alemi, et al. "NuClick: a deep learning framework for interactive segmentation of microscopic images."
+    Medical Image Analysis 65 (2020): 101771.
+
+    Args:
+        min_size: The smallest allowable object size
+        allow_missing_keys: don't raise exception if key is missing.
+    """
+
+    def __init__(self, keys: KeysCollection, min_size: int = 500, allow_missing_keys: bool = False):
+        super().__init__(keys, allow_missing_keys)
+        self.min_size = min_size
+
+    def __call__(self, data):
+        d = dict(data)
+        for key in self.keys:
+            img = convert_to_numpy(d[key]) if isinstance(d[key], torch.Tensor) else d[key]
+            d[key] = self.filter(img)
+        return d
+
+    def filter(self, rgb):
+        mask_not_green = self.filter_green_channel(rgb)
+        mask_not_gray = self.filter_grays(rgb)
+        mask_gray_green = mask_not_gray & mask_not_green
+        mask = (
+            self.filter_remove_small_objects(mask_gray_green, min_size=self.min_size)
+            if self.min_size
+            else mask_gray_green
+        )
+
+        return rgb * np.dstack([mask, mask, mask])
+
+    def filter_green_channel(
+        self, img_np, green_thresh=200, avoid_overmask=True, overmask_thresh=90, output_type="bool"
+    ):
+        g = img_np[:, :, 1]
+        gr_ch_mask = (g < green_thresh) & (g > 0)
+        mask_percentage = self.mask_percent(gr_ch_mask)
+        if (mask_percentage >= overmask_thresh) and (green_thresh < 255) and (avoid_overmask is True):
+            new_green_thresh = math.ceil((255 - green_thresh) / 2 + green_thresh)
+            gr_ch_mask = self.filter_green_channel(
+                img_np, new_green_thresh, avoid_overmask, overmask_thresh, output_type
+            )
+        return gr_ch_mask
+
+    def filter_grays(self, rgb, tolerance=15):
+        rg_diff = abs(rgb[:, :, 0] - rgb[:, :, 1]) <= tolerance
+        rb_diff = abs(rgb[:, :, 0] - rgb[:, :, 2]) <= tolerance
+        gb_diff = abs(rgb[:, :, 1] - rgb[:, :, 2]) <= tolerance
+        return ~(rg_diff & rb_diff & gb_diff)
+
+    def mask_percent(self, img_np):
+        if (len(img_np.shape) == 3) and (img_np.shape[2] == 3):
+            np_sum = img_np[:, :, 0] + img_np[:, :, 1] + img_np[:, :, 2]
+            mask_percentage = 100 - np.count_nonzero(np_sum) / np_sum.size * 100
+        else:
+            mask_percentage = 100 - np.count_nonzero(img_np) / img_np.size * 100
+        return mask_percentage
+
+    def filter_remove_small_objects(self, img_np, min_size=3000, avoid_overmask=True, overmask_thresh=95):
+        rem_sm = morphology.remove_small_objects(img_np.astype(bool), min_size=min_size)
+        mask_percentage = self.mask_percent(rem_sm)
+        if (mask_percentage >= overmask_thresh) and (min_size >= 1) and (avoid_overmask is True):
+            new_min_size = round(min_size / 2)
+            rem_sm = self.filter_remove_small_objects(img_np, new_min_size, avoid_overmask, overmask_thresh)
+        return rem_sm
+
+
+class AddPointGuidanceSignald(Randomizable, MapTransform):
+    """
+    Adds Guidance Signal to the input image
+
+    Args:
+        image: key of source image, defaults to ``"image"``
+        label: key of source label, defaults to ``"label"``
+        others: source others (other labels from the binary mask which are not being used for training)
+            defaults to ``"others"``
+        drop_rate: probability of dropping the signal, defaults to ``0.5``
+        jitter_range: noise added to the points in the point mask for exclusion mask, defaults to ``3``
+        gaussian: add gaussian
+        sigma: sigma value for gaussian
+        truncated: spreads how many stds for gaussian
+        add_exclusion_map: add exclusion map/signal
+    """
+
+    def __init__(
+        self,
+        image: str = NuclickKeys.IMAGE,
+        label: str = NuclickKeys.LABEL,
+        others: str = NuclickKeys.OTHERS,
+        drop_rate: float = 0.5,
+        jitter_range: int = 0,
+        gaussian: bool = False,
+        sigma: float = 1.0,
+        truncated: float = 2.0,
+        add_exclusion_map: bool = True,
+        use_distance: bool = False,
+    ):
+        MapTransform.__init__(self, image)
+
+        self.image = image
+        self.label = label
+        self.others = others
+        self.drop_rate = drop_rate
+        self.jitter_range = jitter_range
+        self.gaussian = gaussian
+        self.sigma = sigma
+        self.truncated = truncated
+        self.add_exclusion_map = add_exclusion_map
+        self.use_distance = use_distance
+
+    def __call__(self, data):
+        d = dict(data)
+
+        image = d[self.image] if isinstance(d[self.image], torch.Tensor) else torch.from_numpy(d[self.image])
+        mask = d[self.label] if isinstance(d[self.label], torch.Tensor) else torch.from_numpy(d[self.label])
+
+        inc_sig = self.inclusion_map(mask[0], dtype=image.dtype)
+        inc_sig = self._apply_gaussian(inc_sig)
+        if self.add_exclusion_map:
+            others = d[self.others] if isinstance(d[self.others], torch.Tensor) else torch.from_numpy(d[self.others])
+            exc_sig = self.exclusion_map(
+                others[0], dtype=image.dtype, drop_rate=self.drop_rate, jitter_range=self.jitter_range
+            )
+            exc_sig = self._apply_gaussian(exc_sig)
+            image = torch.cat((image, inc_sig[None], exc_sig[None]), dim=0)
+        else:
+            image = torch.cat((image, inc_sig[None]), dim=0)
+
+        d[self.image] = image if isinstance(d[self.image], torch.Tensor) else convert_to_numpy(image)
+        return d
+
+    def _apply_gaussian(self, t):
+        if not self.gaussian or torch.count_nonzero(t) == 0:
+            return t
+        x = GaussianFilter(spatial_dims=2, truncated=self.truncated, sigma=self.sigma)(t.unsqueeze(0).unsqueeze(0))
+        return x.squeeze(0).squeeze(0)
+
+    def _seed_point(self, label):
+        if distance_transform_cdt is None or not self.use_distance:
+            indices: NdarrayOrTensor
+            if hasattr(torch, "argwhere"):
+                indices = torch.argwhere(label > 0)
+            else:
+                indices = np.argwhere(convert_to_numpy(label) > 0)
+
+            if len(indices) > 0:
+                index = self.R.randint(0, len(indices))
+                return indices[index, 0], indices[index, 1]
+            return None
+
+        distance = distance_transform_cdt(label).flatten()
+        probability = np.exp(distance) - 1.0
+
+        idx = np.where(label.flatten() > 0)[0]
+        seed = self.R.choice(idx, size=1, p=probability[idx] / np.sum(probability[idx]))
+        g = np.asarray(np.unravel_index(seed, label.shape)).transpose().tolist()[0]
+        return g[-2], g[-1]
+
+    def inclusion_map(self, mask, dtype):
+        point_mask = torch.zeros_like(mask, dtype=dtype)
+        pt = self._seed_point(mask)
+        if pt is not None:
+            point_mask[pt[0], pt[1]] = 1
+
+        return point_mask
+
+    def exclusion_map(self, others, dtype, jitter_range, drop_rate):
+        point_mask = torch.zeros_like(others, dtype=dtype)
+        if np.random.choice([True, False], p=[drop_rate, 1 - drop_rate]):
+            return point_mask
+
+        max_x = point_mask.shape[0] - 1
+        max_y = point_mask.shape[1] - 1
+        stats = measure.regionprops(convert_to_numpy(others))
+        for stat in stats:
+            if np.random.choice([True, False], p=[drop_rate, 1 - drop_rate]):
+                continue
+
+            # random jitter
+            x, y = stat.centroid
+            x = int(math.floor(x))
+            y = int(math.floor(y))
+            if jitter_range:
+                x = x + self.R.randint(low=-jitter_range, high=jitter_range)
+                y = y + self.R.randint(low=-jitter_range, high=jitter_range)
+                x = min(max(0, x), max_x)
+                y = min(max(0, y), max_y)
+            point_mask[x, y] = 1
+
+        return point_mask
+
+
+class AddClickSignalsd(MapTransform):
+    """
+    Adds Click Signal to the input image
+
+    Args:
+        image: source image, defaults to ``"image"``
+        foreground: 2D click indices as list, defaults to ``"foreground"``
+        bb_size: single integer size, defines a bounding box like (bb_size, bb_size)
+        gaussian: add gaussian
+        sigma: sigma value for gaussian
+        truncated: spreads how many stds for gaussian
+        add_exclusion_map: add exclusion map/signal
+    """
+
+    def __init__(
+        self,
+        image: str = NuclickKeys.IMAGE,
+        foreground: str = NuclickKeys.FOREGROUND,
+        bb_size: int = 128,
+        gaussian: bool = False,
+        sigma: float = 1.0,
+        truncated: float = 2.0,
+        add_exclusion_map: bool = True,
+    ):
+        self.image = image
+        self.foreground = foreground
+        self.bb_size = bb_size
+        self.gaussian = gaussian
+        self.sigma = sigma
+        self.truncated = truncated
+        self.add_exclusion_map = add_exclusion_map
+
+    def __call__(self, data):
+        d = dict(data)
+
+        img = d[self.image] if isinstance(d[self.image], torch.Tensor) else torch.from_numpy(d[self.image])
+        x = img.shape[-2]
+        y = img.shape[-1]
+
+        location = d.get(NuclickKeys.LOCATION.value, (0, 0))
+        tx, ty = location[0], location[1]
+        pos = d.get(self.foreground)
+        pos = (np.array(pos) - (tx, ty)).astype(int).tolist() if pos else []
+
+        cx = [xy[0] for xy in pos]
+        cy = [xy[1] for xy in pos]
+
+        click_map, bounding_boxes = self.get_clickmap_boundingbox(img, cx=cx, cy=cy, x=x, y=y, bb=self.bb_size)
+        if not bounding_boxes:
+            raise ValueError("Failed to create patches from given click points")
+
+        patches = self.get_patches_and_signals(
+            img=img, click_map=click_map, bounding_boxes=bounding_boxes, cx=cx, cy=cy, x=x, y=y
+        )
+
+        d[NuclickKeys.BOUNDING_BOXES.value] = bounding_boxes
+        d[NuclickKeys.IMG_WIDTH.value] = x
+        d[NuclickKeys.IMG_HEIGHT.value] = y
+
+        d[self.image] = patches if isinstance(d[self.image], torch.Tensor) else convert_to_numpy(patches)
+        return d
+
+    def get_clickmap_boundingbox(self, img, cx, cy, x, y, bb=128):
+        click_map = torch.zeros_like(img[0])
+
+        x_del_indices = {i for i in range(len(cx)) if cx[i] >= x or cx[i] < 0}
+        y_del_indices = {i for i in range(len(cy)) if cy[i] >= y or cy[i] < 0}
+        del_indices = list(x_del_indices.union(y_del_indices))
+        cx = np.delete(cx, del_indices)
+        cy = np.delete(cy, del_indices)
+
+        click_map[cx, cy] = 1
+        bounding_boxes = []
+        for i in range(len(cx)):
+            x_start = max(0, cx[i] - bb // 2)
+            y_start = max(0, cy[i] - bb // 2)
+            x_end = min(x_start + bb, x)
+            y_end = min(y_start + bb, y)
+
+            if x_end - x_start != bb:
+                x_start = x_end - bb
+            if y_end - y_start != bb:
+                y_start = y_end - bb
+            if x_end - x_start == bb and y_end - y_start == bb:
+                bounding_boxes.append([x_start, y_start, x_end, y_end])
+            else:
+                print(f"Ignore smaller sized bbox ({x_start}, {y_start}, {x_end}, {y_end}) (Min size: {bb}x{bb})")
+        return click_map, bounding_boxes
+
+    def get_patches_and_signals(self, img, click_map, bounding_boxes, cx, cy, x, y):
+        patches = []
+
+        x_del_indices = {i for i in range(len(cx)) if cx[i] >= x or cx[i] < 0}
+        y_del_indices = {i for i in range(len(cy)) if cy[i] >= y or cy[i] < 0}
+        del_indices = list(x_del_indices.union(y_del_indices))
+        cx = np.delete(cx, del_indices)
+        cy = np.delete(cy, del_indices)
+
+        for i, bounding_box in enumerate(bounding_boxes):
+            x_start = bounding_box[0]
+            y_start = bounding_box[1]
+            x_end = bounding_box[2]
+            y_end = bounding_box[3]
+
+            patch = img[:, x_start:x_end, y_start:y_end]
+
+            this_click_map = torch.zeros_like(img[0])
+            this_click_map[cx[i], cy[i]] = 1
+
+            nuc_points = this_click_map[x_start:x_end, y_start:y_end]
+            nuc_points = self._apply_gaussian(nuc_points)
+
+            if self.add_exclusion_map:
+                others_click_map = ((click_map - this_click_map) > 0).type(img.dtype)
+                other_points = others_click_map[x_start:x_end, y_start:y_end]
+                other_points = self._apply_gaussian(other_points)
+                patches.append(torch.cat([patch, nuc_points[None], other_points[None]]))
+            else:
+                patches.append(torch.cat([patch, nuc_points[None]]))
+
+        return torch.stack(patches)
+
+    def _apply_gaussian(self, t):
+        if not self.gaussian or torch.count_nonzero(t) == 0:
+            return t
+        x = GaussianFilter(spatial_dims=2, truncated=self.truncated, sigma=self.sigma)(t.unsqueeze(0).unsqueeze(0))
+        return x.squeeze(0).squeeze(0)
+
+
+class PostFilterLabeld(MapTransform):
+    """
+    Performs Filtering of Labels on the predicted probability map
+
+    Args:
+        thresh: probability threshold for classifying a pixel as a mask
+        min_size: min_size objects that will be removed from the image, refer skimage remove_small_objects
+        min_hole: min_hole that will be removed from the image, refer skimage remove_small_holes
+        do_reconstruction: Boolean Flag, Perform a morphological reconstruction of an image, refer skimage
+        allow_missing_keys: don't raise exception if key is missing.
+        pred_classes: List of Predicted class for each instance
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        nuc_points: str = NuclickKeys.NUC_POINTS,
+        bounding_boxes: str = NuclickKeys.BOUNDING_BOXES,
+        img_height: str = NuclickKeys.IMG_HEIGHT,
+        img_width: str = NuclickKeys.IMG_WIDTH,
+        thresh: float = 0.33,
+        min_size: int = 10,
+        min_hole: int = 30,
+        do_reconstruction: bool = False,
+        allow_missing_keys: bool = False,
+        pred_classes: str = NuclickKeys.PRED_CLASSES,
+    ):
+        super().__init__(keys, allow_missing_keys)
+        self.nuc_points = nuc_points
+        self.bounding_boxes = bounding_boxes
+        self.img_height = img_height
+        self.img_width = img_width
+
+        self.thresh = thresh
+        self.min_size = min_size
+        self.min_hole = min_hole
+        self.do_reconstruction = do_reconstruction
+        self.pred_classes = pred_classes
+
+    def __call__(self, data):
+        d = dict(data)
+
+        pred_classes = d.get(self.pred_classes)
+        bounding_boxes = d[self.bounding_boxes]
+        x = d[self.img_width]
+        y = d[self.img_height]
+
+        for key in self.keys:
+            label = d[key].astype(np.uint8)
+            masks = self.post_processing(label, self.thresh, self.min_size, self.min_hole)
+            d[key] = self.gen_instance_map(masks, bounding_boxes, x, y, pred_classes=pred_classes).astype(np.uint8)
+        return d
+
+    def post_processing(self, preds, thresh=0.33, min_size=10, min_hole=30):
+        masks = preds > thresh
+        for i in range(preds.shape[0]):
+            masks[i] = morphology.remove_small_objects(masks[i], min_size=min_size)
+            masks[i] = morphology.remove_small_holes(masks[i], area_threshold=min_hole)
+        return masks
+
+    def gen_instance_map(self, masks, bounding_boxes, x, y, flatten=True, pred_classes=None):
+        instance_map = np.zeros((x, y), dtype=np.uint16)
+        for i, mask in enumerate(masks):
+            bb = bounding_boxes[i]
+            c = pred_classes[i] if pred_classes and i < len(pred_classes) else 1
+            c = c if flatten else i + 1
+
+            this_map = instance_map[bb[0] : bb[2], bb[1] : bb[3]]
+            this_map = np.where(mask > 0, c, this_map)
+            instance_map[bb[0] : bb[2], bb[1] : bb[3]] = this_map
+
+        return instance_map
+
+
+class AddLabelAsGuidanced(MapTransform):
+    """
+    Add Label as new guidance channel
+
+    Args:
+        source: label/source key which gets added as additional guidance channel
+    """
+
+    def __init__(self, keys: KeysCollection, source: str = "label") -> None:
+        super().__init__(keys, allow_missing_keys=False)
+        self.source = source
+
+    def __call__(self, data):
+        d = dict(data)
+        for key in self.keys:
+            image = d[key] if isinstance(d[key], torch.Tensor) else torch.from_numpy(d[key])
+            label = d[self.source] if isinstance(d[self.source], torch.Tensor) else torch.from_numpy(d[self.source])
+
+            label = label > 0
+            if len(label.shape) < len(image.shape):
+                label = label[None]
+            image = torch.cat([image, label.type(image.dtype)], dim=len(label.shape) - 3)
+            d[key] = image if isinstance(d[key], torch.Tensor) else convert_to_numpy(image)
+        return d
+
+
+class SetLabelClassd(MapTransform):
+    """
+    Assign class value from the labelmap.  This converts multi-dimension tensor to single scalar tensor.
+
+    Args:
+        offset: offset value to be added to the mask value to determine the final class
+    """
+
+    def __init__(self, keys: KeysCollection, offset: int = -1) -> None:
+        super().__init__(keys, allow_missing_keys=False)
+        self.offset = offset
+
+    def __call__(self, data):
+        d = dict(data)
+        for key in self.keys:
+            label = d[key] if isinstance(d[key], torch.Tensor) else torch.from_numpy(d[key])
+            mask_value = int(torch.max(label))
+            d[key] = mask_value + self.offset
+        return d

source_code/SegMamba/monai/apps/pathology/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .losses import HoVerNetLoss
+from .metrics import LesionFROC
+from .transforms.stain.array import ExtractHEStains, NormalizeHEStains
+from .transforms.stain.dictionary import (
+    ExtractHEStainsd,
+    ExtractHEStainsD,
+    ExtractHEStainsDict,
+    NormalizeHEStainsd,
+    NormalizeHEStainsD,
+    NormalizeHEStainsDict,
+)
+from .utils import PathologyProbNMS, compute_isolated_tumor_cells, compute_multi_instance_mask

source_code/SegMamba/monai/apps/pathology/engines/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .utils import PrepareBatchHoVerNet

source_code/SegMamba/monai/apps/pathology/engines/utils.py

@@ -0,0 +1,56 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+import torch
+
+from monai.engines import PrepareBatch, PrepareBatchExtraInput
+from monai.utils import ensure_tuple
+from monai.utils.enums import HoVerNetBranch
+
+__all__ = ["PrepareBatchHoVerNet"]
+
+
+class PrepareBatchHoVerNet(PrepareBatch):
+    """
+    Customized prepare batch callable for trainers or evaluators which support label to be a dictionary.
+    Extra items are specified by the `extra_keys` parameter and are extracted from the input dictionary (ie. the batch).
+    This assumes label is a dictionary.
+
+    Args:
+        extra_keys: If a sequence of strings is provided, values from the input dictionary are extracted from
+            those keys and passed to the network as extra positional arguments.
+    """
+
+    def __init__(self, extra_keys: Sequence[str]) -> None:
+        if len(ensure_tuple(extra_keys)) != 2:
+            raise ValueError(f"length of `extra_keys` should be 2, get {len(ensure_tuple(extra_keys))}")
+        self.prepare_batch = PrepareBatchExtraInput(extra_keys)
+
+    def __call__(
+        self,
+        batchdata: dict[str, torch.Tensor],
+        device: str | torch.device | None = None,
+        non_blocking: bool = False,
+        **kwargs: Any,
+    ) -> tuple[torch.Tensor, dict[HoVerNetBranch, torch.Tensor]]:
+        """
+        Args `batchdata`, `device`, `non_blocking` refer to the ignite API:
+        https://pytorch.org/ignite/v0.4.8/generated/ignite.engine.create_supervised_trainer.html.
+        `kwargs` supports other args for `Tensor.to()` API.
+        """
+        image, _label, extra_label, _ = self.prepare_batch(batchdata, device, non_blocking, **kwargs)
+        label = {HoVerNetBranch.NP: _label, HoVerNetBranch.NC: extra_label[0], HoVerNetBranch.HV: extra_label[1]}
+
+        return image, label

source_code/SegMamba/monai/apps/pathology/handlers/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations

source_code/SegMamba/monai/apps/pathology/handlers/utils.py

@@ -0,0 +1,55 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from collections.abc import Callable, Hashable
+from typing import Any
+
+from monai.config import KeysCollection
+from monai.utils import ensure_tuple
+
+
+def from_engine_hovernet(keys: KeysCollection, nested_key: str) -> Callable[[Any], Any]:
+    """
+    Since the output of HoVerNet is a dictionary, this function is to extend `monai.handlers.from_engine`
+    to work with HoVerNet.
+
+    If data is a list of nested dictionaries after decollating, extract nested value with expected keys and
+    construct lists respectively, for example,
+    if data is `[{"A": {"C": 1, "D": 2}, "B": {"C": 2, "D": 2}}, {"A":  {"C": 3, "D": 2}, "B":  {"C": 4, "D": 2}}]`,
+    from_engine_hovernet(["A", "B"], "C"): `([1, 3], [2, 4])`.
+
+    Here is a simple example::
+
+        from monai.handlers import MeanDice, from_engine_hovernet
+
+        metric = MeanDice(
+            include_background=False,
+            output_transform=from_engine_hovernet(keys=["pred", "label"], nested_key=HoVerNetBranch.NP.value)
+        )
+
+    Args:
+        keys: specified keys to extract data from dictionary or decollated list of dictionaries.
+        nested_key: specified key to extract nested data from dictionary or decollated list of dictionaries.
+
+    """
+    _keys: tuple[Hashable, ...] = ensure_tuple(keys)
+
+    def _wrapper(data):
+        if isinstance(data, dict):
+            return tuple(data[k][nested_key] for k in _keys)
+        if isinstance(data, list) and isinstance(data[0], dict):
+            # if data is a list of dictionaries, extract expected keys and construct lists,
+            ret = [[i[k][nested_key] for i in data] for k in _keys]
+            return tuple(ret) if len(ret) > 1 else ret[0]
+
+    return _wrapper

source_code/SegMamba/monai/apps/pathology/losses/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .hovernet_loss import HoVerNetLoss

source_code/SegMamba/monai/apps/pathology/losses/hovernet_loss.py

@@ -0,0 +1,165 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+from torch.nn import CrossEntropyLoss
+from torch.nn import functional as F
+from torch.nn.modules.loss import _Loss
+
+from monai.losses import DiceLoss
+from monai.transforms import SobelGradients
+from monai.utils.enums import HoVerNetBranch
+
+
+class HoVerNetLoss(_Loss):
+    """
+    Loss function for HoVerNet pipeline, which is combination of losses across the three branches.
+    The NP (nucleus prediction) branch uses Dice + CrossEntropy.
+    The HV (Horizontal and Vertical) distance from centroid branch uses MSE + MSE of the gradient.
+    The NC (Nuclear Class prediction) branch uses Dice + CrossEntropy
+    The result is a weighted sum of these losses.
+
+    Args:
+        lambda_hv_mse: Weight factor to apply to the HV regression MSE part of the overall loss
+        lambda_hv_mse_grad: Weight factor to apply to the MSE of the HV gradient part of the overall loss
+        lambda_np_ce: Weight factor to apply to the nuclei prediction CrossEntropyLoss part
+            of the overall loss
+        lambda_np_dice: Weight factor to apply to the nuclei prediction DiceLoss part of overall loss
+        lambda_nc_ce: Weight factor to apply to the nuclei class prediction CrossEntropyLoss part
+            of the overall loss
+        lambda_nc_dice: Weight factor to apply to the nuclei class prediction DiceLoss part of the
+            overall loss
+
+    """
+
+    def __init__(
+        self,
+        lambda_hv_mse: float = 2.0,
+        lambda_hv_mse_grad: float = 1.0,
+        lambda_np_ce: float = 1.0,
+        lambda_np_dice: float = 1.0,
+        lambda_nc_ce: float = 1.0,
+        lambda_nc_dice: float = 1.0,
+    ) -> None:
+        self.lambda_hv_mse = lambda_hv_mse
+        self.lambda_hv_mse_grad = lambda_hv_mse_grad
+        self.lambda_np_ce = lambda_np_ce
+        self.lambda_np_dice = lambda_np_dice
+        self.lambda_nc_ce = lambda_nc_ce
+        self.lambda_nc_dice = lambda_nc_dice
+        super().__init__()
+
+        self.dice = DiceLoss(softmax=True, smooth_dr=1e-03, smooth_nr=1e-03, reduction="sum", batch=True)
+        self.ce = CrossEntropyLoss(reduction="mean")
+        self.sobel_v = SobelGradients(kernel_size=5, spatial_axes=0)
+        self.sobel_h = SobelGradients(kernel_size=5, spatial_axes=1)
+
+    def _compute_sobel(self, image: torch.Tensor) -> torch.Tensor:
+        """Compute the Sobel gradients of the horizontal vertical map (HoVerMap).
+        More specifically, it will compute horizontal gradient of the input horizontal gradient map (channel=0) and
+        vertical gradient of the input vertical gradient map (channel=1).
+
+        Args:
+            image: a tensor with the shape of BxCxHxW representing HoVerMap
+
+        """
+        result_h = self.sobel_h(image[:, 0])
+        result_v = self.sobel_v(image[:, 1])
+        return torch.stack([result_h, result_v], dim=1)
+
+    def _mse_gradient_loss(self, prediction: torch.Tensor, target: torch.Tensor, focus: torch.Tensor) -> torch.Tensor:
+        """Compute the MSE loss of the gradients of the horizontal and vertical centroid distance maps"""
+
+        pred_grad = self._compute_sobel(prediction)
+        true_grad = self._compute_sobel(target)
+
+        loss = pred_grad - true_grad
+
+        # The focus constrains the loss computation to the detected nuclear regions
+        # (i.e. background is excluded)
+        focus = focus[:, None, ...]
+        focus = torch.cat((focus, focus), 1)
+
+        loss = focus * (loss * loss)
+        loss = loss.sum() / (focus.sum() + 1.0e-8)
+
+        return loss
+
+    def forward(self, prediction: dict[str, torch.Tensor], target: dict[str, torch.Tensor]) -> torch.Tensor:
+        """
+        Args:
+            prediction: dictionary of predicted outputs for three branches,
+                each of which should have the shape of BNHW.
+            target: dictionary of ground truths for three branches,
+                each of which should have the shape of BNHW.
+        """
+
+        if not (HoVerNetBranch.NP.value in prediction and HoVerNetBranch.HV.value in prediction):
+            raise ValueError(
+                "nucleus prediction (NP) and horizontal_vertical (HV) branches must be "
+                "present for prediction and target parameters"
+            )
+        if not (HoVerNetBranch.NP.value in target and HoVerNetBranch.HV.value in target):
+            raise ValueError(
+                "nucleus prediction (NP) and horizontal_vertical (HV) branches must be "
+                "present for prediction and target parameters"
+            )
+        if HoVerNetBranch.NC.value not in target and HoVerNetBranch.NC.value in target:
+            raise ValueError(
+                "type_prediction (NC) must be present in both or neither of the prediction and target parameters"
+            )
+        if HoVerNetBranch.NC.value in target and HoVerNetBranch.NC.value not in target:
+            raise ValueError(
+                "type_prediction (NC) must be present in both or neither of the prediction and target parameters"
+            )
+
+        # Compute the NP branch loss
+        dice_loss_np = (
+            self.dice(prediction[HoVerNetBranch.NP.value], target[HoVerNetBranch.NP.value]) * self.lambda_np_dice
+        )
+        # convert to target class indices
+        argmax_target = target[HoVerNetBranch.NP.value].argmax(dim=1)
+        ce_loss_np = self.ce(prediction[HoVerNetBranch.NP.value], argmax_target) * self.lambda_np_ce
+        loss_np = dice_loss_np + ce_loss_np
+
+        # Compute the HV branch loss
+        loss_hv_mse = (
+            F.mse_loss(prediction[HoVerNetBranch.HV.value], target[HoVerNetBranch.HV.value]) * self.lambda_hv_mse
+        )
+
+        # Use the nuclei class, one hot encoded, as the mask
+        loss_hv_mse_grad = (
+            self._mse_gradient_loss(
+                prediction[HoVerNetBranch.HV.value],
+                target[HoVerNetBranch.HV.value],
+                target[HoVerNetBranch.NP.value][:, 1],
+            )
+            * self.lambda_hv_mse_grad
+        )
+        loss_hv = loss_hv_mse_grad + loss_hv_mse
+
+        # Compute the NC branch loss
+        loss_nc = 0
+        if HoVerNetBranch.NC.value in prediction:
+            dice_loss_nc = (
+                self.dice(prediction[HoVerNetBranch.NC.value], target[HoVerNetBranch.NC.value]) * self.lambda_nc_dice
+            )
+            # Convert to target class indices
+            argmax_target = target[HoVerNetBranch.NC.value].argmax(dim=1)
+            ce_loss_nc = self.ce(prediction[HoVerNetBranch.NC.value], argmax_target) * self.lambda_nc_ce
+            loss_nc = dice_loss_nc + ce_loss_nc
+
+        # Sum the losses from each branch
+        loss: torch.Tensor = loss_hv + loss_np + loss_nc
+
+        return loss

source_code/SegMamba/monai/apps/pathology/metrics/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .lesion_froc import LesionFROC

source_code/SegMamba/monai/apps/pathology/metrics/lesion_froc.py

@@ -0,0 +1,176 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Iterable
+
+import numpy as np
+
+from monai.apps.pathology.utils import PathologyProbNMS, compute_isolated_tumor_cells, compute_multi_instance_mask
+from monai.config import NdarrayOrTensor
+from monai.data.wsi_reader import WSIReader
+from monai.metrics import compute_fp_tp_probs, compute_froc_curve_data, compute_froc_score
+from monai.utils import min_version, optional_import
+
+if TYPE_CHECKING:
+    from tqdm import tqdm
+
+    has_tqdm = True
+else:
+    tqdm, has_tqdm = optional_import("tqdm", "4.47.0", min_version, "tqdm")
+
+if not has_tqdm:
+
+    def tqdm(x):
+        return x
+
+
+class LesionFROC:
+    """
+    Evaluate with Free Response Operating Characteristic (FROC) score.
+
+    Args:
+        data: either the list of dictionaries containing probability maps (inference result) and
+            tumor mask (ground truth), as below, or the path to a json file containing such list.
+            `{
+            "prob_map": "path/to/prob_map_1.npy",
+            "tumor_mask": "path/to/ground_truth_1.tiff",
+            "level": 6,
+            "pixel_spacing": 0.243
+            }`
+        grow_distance: Euclidean distance (in micrometer) by which to grow the label the ground truth's tumors.
+            Defaults to 75, which is the equivalent size of 5 tumor cells.
+        itc_diameter: the maximum diameter of a region (in micrometer) to be considered as an isolated tumor cell.
+            Defaults to 200.
+        eval_thresholds: the false positive rates for calculating the average sensitivity.
+            Defaults to (0.25, 0.5, 1, 2, 4, 8) which is the same as the CAMELYON 16 Challenge.
+        nms_sigma: the standard deviation for gaussian filter of non-maximal suppression. Defaults to 0.0.
+        nms_prob_threshold: the probability threshold of non-maximal suppression. Defaults to 0.5.
+        nms_box_size: the box size (in pixel) to be removed around the pixel for non-maximal suppression.
+        image_reader_name: the name of library to be used for loading whole slide imaging, either CuCIM or OpenSlide.
+            Defaults to CuCIM.
+
+    Note:
+        For more info on `nms_*` parameters look at monai.utils.prob_nms.ProbNMS`.
+
+    """
+
+    def __init__(
+        self,
+        data: list[dict],
+        grow_distance: int = 75,
+        itc_diameter: int = 200,
+        eval_thresholds: tuple = (0.25, 0.5, 1, 2, 4, 8),
+        nms_sigma: float = 0.0,
+        nms_prob_threshold: float = 0.5,
+        nms_box_size: int = 48,
+        image_reader_name: str = "cuCIM",
+    ) -> None:
+        self.data = data
+        self.grow_distance = grow_distance
+        self.itc_diameter = itc_diameter
+        self.eval_thresholds = eval_thresholds
+        self.image_reader = WSIReader(image_reader_name)
+        self.nms = PathologyProbNMS(sigma=nms_sigma, prob_threshold=nms_prob_threshold, box_size=nms_box_size)
+
+    def prepare_inference_result(self, sample: dict) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Prepare the probability map for detection evaluation.
+
+        """
+        # load the probability map (the result of model inference)
+        prob_map = np.load(sample["prob_map"])
+
+        # apply non-maximal suppression
+        nms_outputs = self.nms(probs_map=prob_map, resolution_level=sample["level"])
+
+        # separate nms outputs
+        probs: Iterable[Any]
+        x_coord: Iterable[Any]
+        y_coord: Iterable[Any]
+        if nms_outputs:
+            probs, x_coord, y_coord = zip(*nms_outputs)
+        else:
+            probs, x_coord, y_coord = [], [], []
+
+        return np.array(probs), np.array(x_coord), np.array(y_coord)
+
+    def prepare_ground_truth(self, sample):
+        """
+        Prepare the ground truth for evaluation based on the binary tumor mask
+
+        """
+        # load binary tumor masks
+        img_obj = self.image_reader.read(sample["tumor_mask"])
+        tumor_mask = self.image_reader.get_data(img_obj, level=sample["level"])[0][0]
+
+        # calculate pixel spacing at the mask level
+        mask_pixel_spacing = sample["pixel_spacing"] * pow(2, sample["level"])
+
+        # compute multi-instance mask from a binary mask
+        grow_pixel_threshold = self.grow_distance / (mask_pixel_spacing * 2)
+        tumor_mask = compute_multi_instance_mask(mask=tumor_mask, threshold=grow_pixel_threshold)
+
+        # identify isolated tumor cells
+        itc_threshold = (self.itc_diameter + self.grow_distance) / mask_pixel_spacing
+        itc_labels = compute_isolated_tumor_cells(tumor_mask=tumor_mask, threshold=itc_threshold)
+
+        return tumor_mask, itc_labels
+
+    def compute_fp_tp(self):
+        """
+        Compute false positive and true positive probabilities for tumor detection,
+        by comparing the model outputs with the prepared ground truths for all samples
+
+        """
+        total_fp_probs: list[NdarrayOrTensor] = []
+        total_tp_probs: list[NdarrayOrTensor] = []
+        total_num_targets = 0
+        num_images = len(self.data)
+
+        for sample in tqdm(self.data):
+            probs, y_coord, x_coord = self.prepare_inference_result(sample)
+            ground_truth, itc_labels = self.prepare_ground_truth(sample)
+            # compute FP and TP probabilities for a pair of an image and an ground truth mask
+            fp_probs, tp_probs, num_targets = compute_fp_tp_probs(
+                probs=probs,
+                y_coord=y_coord,
+                x_coord=x_coord,
+                evaluation_mask=ground_truth,
+                labels_to_exclude=itc_labels,
+                resolution_level=sample["level"],
+            )
+            total_fp_probs.extend(fp_probs)
+            total_tp_probs.extend(tp_probs)
+            total_num_targets += num_targets
+
+        return np.array(total_fp_probs), np.array(total_tp_probs), total_num_targets, num_images
+
+    def evaluate(self):
+        """
+        Evaluate the detection performance of a model based on the model probability map output,
+        the ground truth tumor mask, and their associated metadata (e.g., pixel_spacing, level)
+        """
+        # compute false positive (FP) and true positive (TP) probabilities for all images
+        fp_probs, tp_probs, num_targets, num_images = self.compute_fp_tp()
+
+        # compute FROC curve given the evaluation of all images
+        fps_per_image, total_sensitivity = compute_froc_curve_data(
+            fp_probs=fp_probs, tp_probs=tp_probs, num_targets=num_targets, num_images=num_images
+        )
+
+        # compute FROC score give specific evaluation threshold
+        froc_score = compute_froc_score(
+            fps_per_image=fps_per_image, total_sensitivity=total_sensitivity, eval_thresholds=self.eval_thresholds
+        )
+
+        return froc_score

source_code/SegMamba/monai/apps/pathology/transforms/__init__.py

@@ -0,0 +1,70 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from .post.array import (
+    GenerateDistanceMap,
+    GenerateInstanceBorder,
+    GenerateInstanceCentroid,
+    GenerateInstanceContour,
+    GenerateInstanceType,
+    GenerateSuccinctContour,
+    GenerateWatershedMarkers,
+    GenerateWatershedMask,
+    HoVerNetInstanceMapPostProcessing,
+    HoVerNetNuclearTypePostProcessing,
+    Watershed,
+)
+from .post.dictionary import (
+    GenerateDistanceMapD,
+    GenerateDistanceMapd,
+    GenerateDistanceMapDict,
+    GenerateInstanceBorderD,
+    GenerateInstanceBorderd,
+    GenerateInstanceBorderDict,
+    GenerateInstanceCentroidD,
+    GenerateInstanceCentroidd,
+    GenerateInstanceCentroidDict,
+    GenerateInstanceContourD,
+    GenerateInstanceContourd,
+    GenerateInstanceContourDict,
+    GenerateInstanceTypeD,
+    GenerateInstanceTyped,
+    GenerateInstanceTypeDict,
+    GenerateSuccinctContourD,
+    GenerateSuccinctContourd,
+    GenerateSuccinctContourDict,
+    GenerateWatershedMarkersD,
+    GenerateWatershedMarkersd,
+    GenerateWatershedMarkersDict,
+    GenerateWatershedMaskD,
+    GenerateWatershedMaskd,
+    GenerateWatershedMaskDict,
+    HoVerNetInstanceMapPostProcessingD,
+    HoVerNetInstanceMapPostProcessingd,
+    HoVerNetInstanceMapPostProcessingDict,
+    HoVerNetNuclearTypePostProcessingD,
+    HoVerNetNuclearTypePostProcessingd,
+    HoVerNetNuclearTypePostProcessingDict,
+    WatershedD,
+    Watershedd,
+    WatershedDict,
+)
+from .stain.array import ExtractHEStains, NormalizeHEStains
+from .stain.dictionary import (
+    ExtractHEStainsd,
+    ExtractHEStainsD,
+    ExtractHEStainsDict,
+    NormalizeHEStainsd,
+    NormalizeHEStainsD,
+    NormalizeHEStainsDict,
+)