code: def main(args):
      print(args)
  
      if not isinstance(args.workers, int):
          args.workers = min(16, mp.cpu_count())
  
      system_available_memory = int(
          psutil.virtual_memory().available / 1024**3
      )
  
      # AMP
      if args.amp:
          mixed_precision.set_global_policy("mixed_float16")
  
      input_shape = (
          (args.size, args.size, 3)
          if isinstance(args.size, int)
          else None
      )
  
      # Load docTR model
      model = detection.__dict__[args.arch](
          pretrained=not isinstance(args.resume, str),
          assume_straight_pages=not args.rotation,
          input_shape=input_shape,
      )
  
      # Resume weights
      if isinstance(args.resume, str):
          print(f"Resuming {args.resume}")
          model.load_weights(args.resume).expect_partial()
  
      input_shape = (
          model.cfg["input_shape"]
          if input_shape is None
          else input_shape
      )
      mean, std = model.cfg["mean"], model.cfg["std"]
  
      st = time.time()
      ds = datasets.__dict__[args.dataset](
          train=True,
          download=True,
          use_polygons=args.rotation,
          sample_transforms=T.Resize(input_shape[:2]),
      )
      # Monkeypatch
      subfolder = ds.root.split("/")[-2:]
      ds.root = str(Path(ds.root).parent.parent)
      ds.data = [
          (os.path.join(*subfolder, name), target)
          for name, target in ds.data
      ]
      _ds = datasets.__dict__[args.dataset](
          train=False,
          download=True,
          use_polygons=args.rotation,
          sample_transforms=T.Resize(input_shape[:2]),
      )
      subfolder = _ds.root.split("/")[-2:]
      ds.data.extend(
          [
              (os.path.join(*subfolder, name), target)
              for name, target in _ds.data
          ]
      )
  
      test_loader = DataLoader(
          ds,
          batch_size=args.batch_size,
          drop_last=False,
          num_workers=args.workers,
          shuffle=False,
      )
      print(
          f"Test set loaded in {time.time() - st:.4}s ({len(ds)} samples in "
          f"{len(test_loader)} batches)"
      )
  
      batch_transforms = T.Normalize(mean=mean, std=std)
  
      # Metrics
      metric = LocalizationConfusion(
          use_polygons=args.rotation,
          mask_shape=input_shape[:2],
          use_broadcasting=True
          if system_available_memory > 62
          else False,
      )
  
      print("Running evaluation")
      val_loss, recall, precision, mean_iou = evaluate(
          model, test_loader, batch_transforms, metric
      )
      print(
          f"Validation loss: {val_loss:.6} (Recall: {recall:.2%} | Precision: {precision:.2%} | "
          f"Mean IoU: {mean_iou:.2%})"
      )
  
file_path: doctr/references/detection/evaluate_tensorflow.py
imports: import os
  from doctr.file_utils import CLASS_NAME
  import multiprocessing
  import time
  from pathlib import Path
  import psutil
  import tensorflow
  from tensorflow.keras import mixed_precision
  from tqdm import tqdm
  from doctr import datasets
  from doctr import transforms
  from doctr.datasets import DataLoader
  from doctr.models import detection
  from doctr.utils.metrics import LocalizationConfusion
label_desc: Use image node_id 2 for calling a global function with example usage: main(args) without return types