first

.gitignore

@@ -0,0 +1,61 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python/
+build/
+develop-eggs/
+dist/
+egg-info/
+.eggs/
+lib/
+lib64/
+parts/
+sbin/
+share/
+venv/
+.venv/
+*.egg
+.coverage
+.tox/
+.mypy_cache/
+.pytest_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# React / Node.js
+node_modules/
+dist/
+build/
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+.parcel-cache/
+.vite/
+
+# macOS
+.DS_Store
+.Trashes
+._*
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# IDEs
+.idea/
+.vscode/
+*.iml
+
+# Database
+*.db
+reports/*

Dockerfile

@@ -0,0 +1,47 @@
+# Use an official Python runtime as a parent image.
+# The "slim" variant is a good choice as it's smaller than the full version.
+FROM python:3.11-slim
+
+# Set environment variables to prevent Python from writing pyc files to disc
+# and to prevent it from buffering stdout and stderr.
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set the working directory in the container to /app.
+# This is where your application's code will live.
+WORKDIR /app
+
+# Copy the requirements file into the container at /app.
+# This is done as a separate step to take advantage of Docker's layer caching.
+# If your requirements don't change, this layer won't be rebuilt, speeding up future builds.
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt.
+# --no-cache-dir disables the pip cache, which helps keep the image size down.
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of your application's code into the container at /app.
+COPY . .
+
+# Expose a port to the outside world.
+# Replace 8000 with the port your application listens on (e.g., 5000 for Flask, 8000 for FastAPI).
+EXPOSE 8000
+
+# Define the command to run your application.
+# The command is broken into a list of strings for best practice.
+# ---
+# UNCOMMENT THE ONE YOU NEED AND EDIT IT ---
+# ---
+
+# For a generic Python script:
+# CMD ["python", "main.py"]
+
+# For a FastAPI application with uvicorn:
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+# For a Flask application (using the development server):
+# NOTE: For production, you should use a proper WSGI server like Gunicorn.
+# CMD ["flask", "run", "--host=0.0.0.0", "--port=8000"]
+
+# For a Flask application with Gunicorn:
+# CMD ["gunicorn", "--bind", "0.0.0.0:7860", "main:app"]

draft_computation/__init__.py

@@ -0,0 +1,9 @@
+import sys
+
+sys.path.append('./draft_computation')
+sys.path.append('./draft_computation/models')
+sys.path.append('./draft_computation/draft_computation_app')
+sys.path.append('./draft_computation/ocr')
+from .endpoint import run
+
+__all__ = ['run']

draft_computation/draft_computation_app/__init__.py

@@ -0,0 +1,3 @@
+from .app import calculate_draft
+
+__all__ = ["calculate_draft"]

draft_computation/draft_computation_app/app.py

@@ -0,0 +1,164 @@
+import logging
+import numpy as np
+import cv2
+import os
+from datetime import datetime
+import uuid
+from . import constants
+from . import utils
+from . import ocr_placeholder
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def calculate_draft(pose_results, segment_data, original_image):
+    # Ensure original_image is a NumPy array
+    if not isinstance(original_image, np.ndarray):
+        original_image = np.array(original_image) # Attempt to convert if not already
+    
+    # Create the segment mask internally
+    mask = np.zeros(original_image.shape[:2], dtype=np.uint8)
+    if len(segment_data)>1:
+        r = [len(i) for i in segment_data]
+        segment_data = segment_data[np.argmax(r)]
+    pts = np.array(segment_data, dtype=np.int32)
+    cv2.fillPoly(mask, [pts], 1)
+    segment_mask = mask
+    """
+    Calculates the draft measurement.
+    """
+    mark_names = ["meter mark", "80cm mark", "60cm mark", "40cm mark", "20cm mark"]
+
+    def find_lowest_mark_group(pose_results):
+        lowest_mark_group = None
+        max_y = -1
+
+        for mark_group in pose_results:
+            last_valid_keypoint = None
+            for keypoint in reversed(mark_group):
+                if keypoint[2] >= constants.CONF_THRESHOLD:
+                    last_valid_keypoint = keypoint
+                    break
+            
+            if last_valid_keypoint is not None:
+                _, y, _ = last_valid_keypoint
+                if y > max_y:
+                    max_y = y
+                    lowest_mark_group = mark_group
+
+        return lowest_mark_group
+
+    def extract_meter_mark(image, mark_group, group_index):
+        first_keypoint = mark_group[0]
+        x, y, _ = first_keypoint
+
+        twenty_cm_in_pixels = utils.calc_distance(mark_group[0], mark_group[1])
+        square_size = utils.calc_sqr_size(constants.DEFAULT_SQUARE_SIZE_CM, twenty_cm_in_pixels)
+        square_size *= 1.2
+
+        half_size = int(square_size / 2)
+        
+        h, w, _ = image.shape
+
+        x1 = int(x - half_size - (square_size * 0.2))
+        y1 = int(y - half_size)
+        x2 = int(x + half_size)
+        y2 = int(y + half_size)
+
+        if x1 < 0: x1 = 0
+        if y1 < 0: y1 = 0
+        if x2 > w: x2 = w
+        if y2 > h: y2 = h
+
+        cropped_image = image[y1:y2, x1:x2]
+
+        if constants.SAVE_CROPPED_IMAGE:
+            output_folder = os.path.join(os.path.dirname(__file__), constants.CROP_OUTPUT_FOLDER)
+            if not os.path.exists(output_folder):
+                os.makedirs(output_folder)
+            
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+            filename = f"{timestamp}_{group_index}_{uuid.uuid4()}.png"
+            cv2.imwrite(os.path.join(output_folder, filename), cropped_image)
+
+        return cropped_image
+
+    # Crop and save meter marks for all groups with high confidence
+    for i, mark_group in enumerate(pose_results):
+        if mark_group[0][2] >= constants.CONF_THRESHOLD:
+            extract_meter_mark(original_image, mark_group, i)
+
+    lowest_mark_group = find_lowest_mark_group(pose_results)
+    if lowest_mark_group is None:
+        logging.error("No lowest mark group found.")
+        return -1
+    logging.info(f"Lowest mark group found: {lowest_mark_group}")
+
+    meter_mark_image = extract_meter_mark(original_image, lowest_mark_group, -1)
+    meter_value_str = ocr_placeholder.perform_ocr(meter_mark_image)
+    meter_value = int(meter_value_str.replace('m', ''))
+    logging.info(f"Meter value from OCR: {meter_value}m")
+
+    last_valid_keypoint = None
+    last_valid_keypoint_index = -1
+    for i, keypoint in reversed(list(enumerate(lowest_mark_group))):
+        if keypoint[2] >= constants.CONF_THRESHOLD:
+            last_valid_keypoint = keypoint
+            last_valid_keypoint_index = i
+            break
+
+    if last_valid_keypoint is None:
+        logging.error("No last valid keypoint found.")
+        return -1
+    logging.info(f"Last valid keypoint found: {mark_names[last_valid_keypoint_index]} ({last_valid_keypoint_index}) at coordinates {last_valid_keypoint[:2]}")
+
+    x, y, _ = last_valid_keypoint
+
+    # Find the water line in the segment mask
+    column = segment_mask[:, int(x)]
+    water_line_indices = np.where(column > 0)
+    
+    if len(water_line_indices[0]) > 0:
+        water_line_top_y = water_line_indices[0][0]
+        water_line_bottom_y = water_line_indices[0][-1]
+        
+        # Define the waterline segment as a vertical line in the column of the keypoint
+        segment_start = (x, water_line_top_y)
+        segment_end = (x, water_line_bottom_y)
+        
+        pixel_distance = utils.distance_point_to_segment((x, y), segment_start, segment_end)
+    else:
+        logging.error("No water line found.")
+        return -1
+    
+    logging.info(f"Pixel distance between keypoint and water line: {pixel_distance}")
+
+    distances = []
+    for i in range(len(lowest_mark_group) - 1):
+        if lowest_mark_group[i][2] >= constants.CONF_THRESHOLD and lowest_mark_group[i+1][2] >= constants.CONF_THRESHOLD:
+            distances.append(utils.calc_distance(lowest_mark_group[i], lowest_mark_group[i+1]))
+    if not distances:
+        logging.error("No valid consecutive keypoints found to calculate 20cm in pixels.")
+        return -1
+    twenty_cm_in_pixels = np.mean(distances)
+    logging.info(f"20cm in pixels: {twenty_cm_in_pixels}")
+
+    cm_distance = (pixel_distance / twenty_cm_in_pixels) * 20
+    logging.info(f"Distance in cm between keypoint and water line: {cm_distance}")
+
+    last_valid_keypoint_cm = (100 - (last_valid_keypoint_index * 20))
+    logging.info(f"Last valid keypoint cm value: {last_valid_keypoint_cm}")
+
+    final_draft_cm = (last_valid_keypoint_cm + 5) - cm_distance
+    logging.info(f"Final draft cm value: {final_draft_cm}")
+
+    final_draft = (meter_value - 1) + (final_draft_cm / 100)
+    logging.info(f"Final calculated draft: {final_draft}")
+
+    mid_results = {
+        'meter_value': meter_value,
+        'last_valid_keypoint_cm': last_valid_keypoint_cm,
+        'cm_distance': cm_distance,
+        'final_draft_cm': final_draft_cm,
+    }
+
+    return final_draft, mid_results

draft_computation/draft_computation_app/constants.py

@@ -0,0 +1,4 @@
+CONF_THRESHOLD = 0.25
+DEFAULT_SQUARE_SIZE_CM = 17
+CROP_OUTPUT_FOLDER = "output"
+SAVE_CROPPED_IMAGE = False

draft_computation/draft_computation_app/dummy_data/results.py

@@ -0,0 +1,127 @@
+import numpy as np
+pose = np.array([[[6.5433e+02, 5.8361e+02, 9.9946e-01],
+         [6.8423e+02, 6.5411e+02, 9.9998e-01],
+         [6.9117e+02, 7.2399e+02, 9.9999e-01],
+         [6.9718e+02, 7.9327e+02, 9.9987e-01],
+         [7.0293e+02, 8.5917e+02, 9.3761e-01]],
+
+        [[6.3452e+02, 2.8308e+02, 9.9482e-01],
+         [6.5906e+02, 3.4467e+02, 9.9938e-01],
+         [6.5794e+02, 4.0197e+02, 1.0000e+00],
+         [6.6237e+02, 4.6714e+02, 9.9999e-01],
+         [6.6390e+02, 5.2631e+02, 9.9611e-01]],
+
+        [[6.3164e+02, 4.3033e+00, 9.6437e-01],
+         [6.4993e+02, 5.6203e+01, 9.9290e-01],
+         [6.5003e+02, 1.1126e+02, 9.9973e-01],
+         [6.5038e+02, 1.6832e+02, 9.9971e-01],
+         [6.4932e+02, 2.2213e+02, 9.7749e-01]],
+
+        [[6.9001e+02, 9.0983e+02, 9.5246e-01],
+         [7.1195e+02, 9.7251e+02, 9.9073e-01],
+         [7.1940e+02, 1.0361e+03, 9.9944e-01],
+         [7.2875e+02, 1.1032e+03, 9.9775e-01],
+         [7.3482e+02, 1.1613e+03, 2.4290e-01]],
+
+        [[6.9527e+02, 8.9296e+02, 9.9578e-01],
+         [7.2340e+02, 9.6668e+02, 9.9980e-01],
+         [7.2624e+02, 1.0355e+03, 9.9973e-01],
+         [7.3433e+02, 1.1097e+03, 9.9814e-01],
+         [7.4265e+02, 1.1769e+03, 5.6901e-01]]])
+
+segment = np.array(
+    [[    0.22812,      1159.4],
+        [    0.22812,      1366.9],
+        [       1224,      1366.9],
+        [       1224,      1257.8],
+        [     1217.4,      1257.8],
+        [     1215.2,      1255.6],
+        [     1200.2,      1255.6],
+        [     1198.1,      1253.5],
+        [     1183.1,      1253.5],
+        [       1181,      1251.4],
+        [     1163.9,      1251.4],
+        [     1161.7,      1249.2],
+        [     1144.6,      1249.2],
+        [     1142.5,      1247.1],
+        [     1121.1,      1247.1],
+        [       1119,      1244.9],
+        [     1116.8,      1247.1],
+        [     1110.4,      1247.1],
+        [     1108.3,      1244.9],
+        [     1069.8,      1244.9],
+        [     1067.6,      1242.8],
+        [     1044.1,      1242.8],
+        [       1042,      1240.7],
+        [       1027,      1240.7],
+        [     1024.8,      1238.5],
+        [     1009.9,      1238.5],
+        [     1007.7,      1236.4],
+        [     994.89,      1236.4],
+        [     992.75,      1234.2],
+        [     975.64,      1234.2],
+        [      973.5,      1232.1],
+        [     952.11,      1232.1],
+        [     949.97,        1230],
+        [      924.3,        1230],
+        [     922.16,      1227.8],
+        [     902.91,      1227.8],
+        [     900.77,      1225.7],
+        [     883.66,      1225.7],
+        [     881.52,      1223.5],
+        [     860.13,      1223.5],
+        [     857.99,      1221.4],
+        [     843.02,      1221.4],
+        [     840.88,      1219.3],
+        [     825.91,      1219.3],
+        [     823.77,      1217.1],
+        [      798.1,      1217.1],
+        [     795.96,        1215],
+        [     751.04,        1215],
+        [      748.9,      1212.8],
+        [     714.68,      1212.8],
+        [     712.54,      1210.7],
+        [     706.12,      1210.7],
+        [     703.98,      1208.6],
+        [     697.56,      1208.6],
+        [     695.42,      1206.4],
+        [     678.31,      1206.4],
+        [     676.17,      1204.3],
+        [     663.34,      1204.3],
+        [      661.2,      1202.2],
+        [     639.81,      1202.2],
+        [     637.67,        1200],
+        [     603.44,        1200],
+        [      601.3,      1197.9],
+        [     590.61,      1197.9],
+        [     588.47,      1195.7],
+        [     577.78,      1195.7],
+        [     575.64,      1193.6],
+        [      562.8,      1193.6],
+        [     560.66,      1191.5],
+        [     547.83,      1191.5],
+        [     545.69,      1189.3],
+        [     532.85,      1189.3],
+        [     530.72,      1187.2],
+        [     479.38,      1187.2],
+        [     477.24,        1185],
+        [     447.29,        1185],
+        [     445.15,      1182.9],
+        [     406.65,      1182.9],
+        [     404.51,      1180.8],
+        [     357.45,      1180.8],
+        [     355.31,      1178.6],
+        [     323.23,      1178.6],
+        [     321.09,      1176.5],
+        [     306.11,      1176.5],
+        [     303.98,      1174.3],
+        [        289,      1174.3],
+        [     286.86,      1172.2],
+        [     269.75,      1172.2],
+        [     267.61,      1170.1],
+        [     244.08,      1170.1],
+        [     241.94,      1167.9],
+        [     233.39,      1167.9],
+        [     231.25,      1165.8],
+        [     231.25,      1159.4]]
+)

draft_computation/draft_computation_app/dummy_data/results2.py

@@ -0,0 +1,164 @@
+import numpy as np
+pose = np.array(
+    [[[2.6978e+02, 5.4799e+01, 9.9702e-01],
+         [2.7735e+02, 8.0360e+01, 9.9991e-01],
+         [2.7792e+02, 1.0644e+02, 9.9998e-01],
+         [2.7866e+02, 1.3190e+02, 9.9988e-01],
+         [2.8056e+02, 1.5711e+02, 8.7975e-01]],
+
+        [[2.7160e+02, 1.8630e+02, 9.9943e-01],
+         [2.7907e+02, 2.1047e+02, 9.9792e-01],
+         [2.7965e+02, 2.3873e+02, 9.4452e-01],
+         [2.8155e+02, 2.6565e+02, 9.4245e-02],
+         [2.8508e+02, 2.8900e+02, 4.7978e-05]],
+
+        [[2.7191e+02, 1.8308e+02, 9.7766e-01],
+         [2.7931e+02, 2.0942e+02, 9.9106e-01],
+         [2.8075e+02, 2.3690e+02, 9.9677e-01],
+         [2.8196e+02, 2.6651e+02, 8.2379e-01],
+         [2.8113e+02, 2.8766e+02, 6.3545e-05]]]
+)
+segment = np.array(
+    [[     81.934,      247.37],
+        [     81.934,      248.93],
+        [     80.369,       250.5],
+        [     79.847,       250.5],
+        [     79.325,      251.02],
+        [     78.803,      251.02],
+        [     78.281,      251.54],
+        [     77.759,      251.54],
+        [     77.238,      252.07],
+        [     76.194,      252.07],
+        [     75.672,      252.59],
+        [     74.106,      252.59],
+        [     73.584,      253.11],
+        [     72.541,      253.11],
+        [     72.019,      253.63],
+        [     70.975,      253.63],
+        [     70.453,      254.15],
+        [     69.409,      254.15],
+        [     68.888,      254.68],
+        [     68.366,      254.68],
+        [     67.844,       255.2],
+        [     65.756,       255.2],
+        [     65.234,      255.72],
+        [     64.191,      255.72],
+        [     63.669,      256.24],
+        [     61.581,      256.24],
+        [     61.059,      256.76],
+        [      58.45,      256.76],
+        [     57.928,      257.28],
+        [     55.319,      257.28],
+        [     54.797,      257.81],
+        [     52.188,      257.81],
+        [     51.666,      258.33],
+        [     48.534,      258.33],
+        [     48.013,      258.85],
+        [     44.881,      258.85],
+        [     44.359,      259.37],
+        [     38.097,      259.37],
+        [     37.575,      259.89],
+        [     1.0438,      259.89],
+        [     1.0438,      333.48],
+        [     333.48,      333.48],
+        [     333.48,      269.29],
+        [     332.43,      269.29],
+        [     331.91,      268.77],
+        [     322.52,      268.77],
+        [        322,      268.24],
+        [     315.21,      268.24],
+        [     314.69,      267.72],
+        [     311.04,      267.72],
+        [     310.52,      268.24],
+        [     302.69,      268.24],
+        [     302.17,      268.77],
+        [      288.6,      268.77],
+        [     288.08,      268.24],
+        [     284.42,      268.24],
+        [      283.9,      267.72],
+        [     280.77,      267.72],
+        [     280.25,       267.2],
+        [     278.16,       267.2],
+        [     277.64,      266.68],
+        [     276.07,      266.68],
+        [     275.55,      266.16],
+        [     274.51,      266.16],
+        [     273.98,      265.63],
+        [     270.85,      265.63],
+        [     270.33,      265.11],
+        [     264.59,      265.11],
+        [     264.07,      264.59],
+        [     258.33,      264.59],
+        [     257.81,      264.07],
+        [     254.68,      264.07],
+        [     254.15,      263.55],
+        [     251.54,      263.55],
+        [     251.02,      263.02],
+        [     249.46,      263.02],
+        [     248.93,       262.5],
+        [     246.85,       262.5],
+        [     246.33,      261.98],
+        [     244.76,      261.98],
+        [     244.24,      261.46],
+        [     237.45,      261.46],
+        [     236.93,      260.94],
+        [     236.41,      261.46],
+        [     231.71,      261.46],
+        [     231.19,      261.98],
+        [     228.06,      261.98],
+        [     227.54,       262.5],
+        [     223.36,       262.5],
+        [     222.84,      263.02],
+        [      217.1,      263.02],
+        [     216.58,       262.5],
+        [      212.4,       262.5],
+        [     211.88,      261.98],
+        [     210.84,      261.98],
+        [     210.32,      261.46],
+        [     208.75,      261.46],
+        [     208.23,      260.94],
+        [     206.66,      260.94],
+        [     206.14,      260.42],
+        [     203.53,      260.42],
+        [     203.01,      259.89],
+        [     198.31,      259.89],
+        [     197.79,      259.37],
+        [     192.05,      259.37],
+        [     191.53,      258.85],
+        [     187.88,      258.85],
+        [     187.35,      258.33],
+        [     185.79,      258.33],
+        [     185.27,      257.81],
+        [      183.7,      257.81],
+        [     183.18,      257.28],
+        [     180.57,      257.28],
+        [     180.05,      256.76],
+        [     174.83,      256.76],
+        [     174.31,      256.24],
+        [     165.96,      256.24],
+        [     165.43,      255.72],
+        [     158.13,      255.72],
+        [     157.61,       255.2],
+        [     152.39,       255.2],
+        [     151.87,      254.68],
+        [     130.99,      254.68],
+        [     130.47,       255.2],
+        [     129.95,      254.68],
+        [     125.25,      254.68],
+        [     124.73,      254.15],
+        [     123.16,      254.15],
+        [     122.64,      253.63],
+        [     122.12,      253.63],
+        [      121.6,      253.11],
+        [     120.55,      253.11],
+        [     120.03,      252.59],
+        [     119.51,      252.59],
+        [     118.99,      252.07],
+        [     118.47,      252.07],
+        [     117.94,      251.54],
+        [     117.42,      251.54],
+        [     115.86,      249.98],
+        [     115.33,      249.98],
+        [     114.81,      249.46],
+        [     114.81,      247.37]]
+)

draft_computation/draft_computation_app/dummy_test/test2_app.py

@@ -0,0 +1,34 @@
+
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+import numpy as np
+import cv2
+from draft_computation_app import calculate_draft
+from draft_computation_app.dummy_data import results2 as results
+
+def test_calculate_draft():
+    pose_results = results.pose
+    segment_data = results.segment
+
+    # Load the test image
+    image_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "dummy_data", "test2.jpg")
+    original_image = cv2.imread(image_path)
+
+    # Set the ocr placeholder to return a specific value for the test
+    from draft_computation_app import ocr_placeholder
+    ocr_placeholder.perform_ocr = lambda image: "12m"
+
+    draft = calculate_draft(pose_results, segment_data, original_image)
+
+    print(f"The calculated draft is: {draft}")
+
+    # Add an assertion to check if the result is within a reasonable range
+    # This expected value is just a placeholder and should be adjusted
+    # based on the actual expected output.
+    expected_draft = 11.41
+    assert abs(draft - expected_draft) < 0.1
+
+if __name__ == "__main__":
+    test_calculate_draft()

draft_computation/draft_computation_app/dummy_test/test_app.py

@@ -0,0 +1,34 @@
+
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+
+import numpy as np
+import cv2
+from draft_computation_app import calculate_draft
+from draft_computation_app.dummy_data import results
+
+def test_calculate_draft():
+    pose_results = results.pose
+    segment_data = results.segment
+
+    # Load the test image
+    image_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "dummy_data", "test.jpg")
+    original_image = cv2.imread(image_path)
+
+    # Set the ocr placeholder to return a specific value for the test
+    from draft_computation_app import ocr_placeholder
+    ocr_placeholder.perform_ocr = lambda image: "7m"
+
+    draft = calculate_draft(pose_results, segment_data, original_image)
+
+    print(f"The calculated draft is: {draft}")
+
+    # Add an assertion to check if the result is within a reasonable range
+    # This expected value is just a placeholder and should be adjusted
+    # based on the actual expected output.
+    expected_draft = 6.15
+    assert abs(draft - expected_draft) < 0.1
+
+if __name__ == "__main__":
+    test_calculate_draft()

draft_computation/draft_computation_app/main.py

@@ -0,0 +1,29 @@
+
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import numpy as np
+import cv2
+from draft_computation_app import calculate_draft
+
+def create_dummy_data():
+    """
+    Creates dummy data for testing.
+    """
+    pose_results = np.array([
+        [[100, 200, 1], [100, 220, 1], [100, 240, 1], [100, 260, 1], [100, 280, 1]],
+        [[200, 300, 1], [200, 320, 1], [200, 340, 1], [200, 360, 1], [200, 380, 1]],
+    ])
+
+    segment_mask = np.zeros((500, 500), dtype=np.uint8)
+    segment_mask[400:, :] = 1  # Water line at y=400
+
+    original_image = np.zeros((500, 500, 3), dtype=np.uint8)
+
+    return pose_results, segment_mask, original_image
+
+if __name__ == "__main__":
+    pose_results, segment_mask, original_image = create_dummy_data()
+    draft = calculate_draft(pose_results, segment_mask, original_image)
+    print(f"The draft is: {draft} meters")

draft_computation/draft_computation_app/ocr_placeholder.py

@@ -0,0 +1,31 @@
+from ocr.inference import OCRInference
+import os
+
+# Determine the absolute path to the model
+# Assuming the script is run from the root of draft_computation
+# or that the ocr_placeholder.py is called in a way that its parent directory is in sys.path
+# For direct import from draft_computation_app, the path needs to be relative to the project root.
+# The model path in ocr/inference.py is "./ocr_model_output/checkpoint-441"
+# Relative to draft_computation_app, this would be "../ocr/ocr_model_output/checkpoint-441"
+# Let's make it absolute for robustness.
+# Get the directory of the current script (ocr_placeholder.py)
+current_script_dir = os.path.dirname(os.path.abspath(__file__))
+# Navigate up to the project root (c:\Users\dev-n\OneDrive\Desktop\draft_computation)
+project_root = os.path.abspath(os.path.join(current_script_dir, ".."))
+# Construct the absolute path to the OCR model
+OCR_MODEL_PATH = os.path.join(project_root, "ocr", "ocr_model_output", "checkpoint-441")
+
+print(f"OCR Model Path: {OCR_MODEL_PATH}")
+# Initialize the OCRInference engine globally or as a singleton if preferred
+# For simplicity, initializing here. Consider lazy loading or a proper singleton pattern for production.
+ocr_engine = OCRInference(model_path=OCR_MODEL_PATH)
+
+def perform_ocr(image_input):
+    """
+    Performs OCR using the integrated OCRInference engine.
+    Args:
+        image_input: Path to the image file or a NumPy array representing the image.
+    Returns:
+        The predicted text from the image.
+    """
+    return ocr_engine.perform_inference(image_input)

draft_computation/draft_computation_app/utils.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+def calc_distance(a, b=None, c=None):
+    if b is None and c is None:
+        raise ValueError("At least one of 'b' or 'c' must be provided.")
+    
+    distances = []
+    if b is not None:
+        distances.append(np.linalg.norm(np.array(a) - np.array(b)))
+    if c is not None:
+        distances.append(np.linalg.norm(np.array(a) - np.array(c)))
+    
+    return np.mean(distances)
+
+def calc_sqr_size(cm_size, twenty_cm_in_pixels):
+    return (cm_size / 20) * twenty_cm_in_pixels
+
+def distance_point_to_segment(point, segment_start, segment_end):
+    point = np.array(point)
+    segment_start = np.array(segment_start)
+    segment_end = np.array(segment_end)
+
+    # Vector from segment_start to segment_end
+    segment_vector = segment_end - segment_start
+    
+    # Vector from segment_start to point
+    point_vector = point - segment_start
+
+    # Project point_vector onto segment_vector
+    segment_len_sq = np.dot(segment_vector, segment_vector)
+    if segment_len_sq == 0: # Segment is a point
+        return np.linalg.norm(point - segment_start)
+
+    t = np.dot(point_vector, segment_vector) / segment_len_sq
+    t = max(0, min(1, t)) # Clamp t to [0, 1]
+
+    # Closest point on the line segment
+    closest_point = segment_start + t * segment_vector
+
+    return np.linalg.norm(point - closest_point)

draft_computation/endpoint.py

@@ -0,0 +1,49 @@
+from .draft_computation_app import calculate_draft
+import os
+import cv2
+
+from ultralytics import YOLO
+
+model1 = YOLO("./draft_computation/models/pose.pt")
+model2 = YOLO("./draft_computation/models/seg.pt")
+
+def combine_plots(original_image, plot1, plot2):
+    combined_image_1 = cv2.addWeighted(original_image, 0.7, plot1, 0.3, 0)
+    final_image = cv2.addWeighted(combined_image_1, 0.7, plot2, 0.3, 0)
+    return final_image
+
+def run(img_path_or_array):
+
+    # image_filename = "create_ocr_dataset/images/IMG_0044_01_jpg.rf.c4e4413436401ee76e86bd92e736b908.jpg"
+
+    results1 = model1(img_path_or_array)
+    results2 = model2(img_path_or_array, conf=0.15)
+
+    try: 
+        pose_results = results1[0].keypoints.data
+        segment_results = results2[0].masks.xy
+
+        draft, mid_results = calculate_draft(pose_results, segment_results, results1[0].orig_img)
+        print(draft)
+    except Exception as e:
+        print(f"Error processing image: {e}")
+        return
+    
+    output = {
+        "draft": draft,
+        "pose_results": pose_results,
+        "segment_results": segment_results,
+        "original_image": results1[0].orig_img,
+        "pose_image_result": results1[0].plot(),
+        "segment_image_result": results2[0].plot(),
+    }
+    output['final_image_result'] = combine_plots(output['original_image'],
+                                                 output['pose_image_result'],
+                                                 output['segment_image_result']
+                                                 )
+    output.update(mid_results)
+    return output
+
+if __name__ == "__main__":
+    print(run("create_ocr_dataset/images/IMG_0044_01_jpg.rf.c4e4413436401ee76e86bd92e736b908.jpg"))
+

draft_computation/models/pose.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ddeff68ebdcb7399594c7b9527bee099ecd8f62f3ac068af1d98cd628db102e
+size 5697217

draft_computation/models/seg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c09bf2df17498bf258f26584fa5442ecad621a9f187e3472b8bf43cf83df2db6
+size 6052445

draft_computation/ocr/0.26.0

@@ -0,0 +1,27 @@
+Collecting accelerate
+  Downloading accelerate-1.10.1-py3-none-any.whl.metadata (19 kB)
+Requirement already satisfied: numpy<3.0.0,>=1.17 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from accelerate) (2.2.6)
+Requirement already satisfied: packaging>=20.0 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from accelerate) (25.0)
+Requirement already satisfied: psutil in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from accelerate) (7.0.0)
+Requirement already satisfied: pyyaml in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from accelerate) (6.0.2)
+Requirement already satisfied: torch>=2.0.0 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from accelerate) (2.8.0)
+Requirement already satisfied: huggingface_hub>=0.21.0 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from accelerate) (0.34.4)
+Requirement already satisfied: safetensors>=0.4.3 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from accelerate) (0.6.2)
+Requirement already satisfied: filelock in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from huggingface_hub>=0.21.0->accelerate) (3.19.1)
+Requirement already satisfied: fsspec>=2023.5.0 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from huggingface_hub>=0.21.0->accelerate) (2025.7.0)
+Requirement already satisfied: requests in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from huggingface_hub>=0.21.0->accelerate) (2.32.5)
+Requirement already satisfied: tqdm>=4.42.1 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from huggingface_hub>=0.21.0->accelerate) (4.67.1)
+Requirement already satisfied: typing-extensions>=3.7.4.3 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from huggingface_hub>=0.21.0->accelerate) (4.14.1)
+Requirement already satisfied: sympy>=1.13.3 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from torch>=2.0.0->accelerate) (1.14.0)
+Requirement already satisfied: networkx in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from torch>=2.0.0->accelerate) (3.5)
+Requirement already satisfied: jinja2 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from torch>=2.0.0->accelerate) (3.1.6)
+Requirement already satisfied: mpmath<1.4,>=1.1.0 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from sympy>=1.13.3->torch>=2.0.0->accelerate) (1.3.0)
+Requirement already satisfied: colorama in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from tqdm>=4.42.1->huggingface_hub>=0.21.0->accelerate) (0.4.6)
+Requirement already satisfied: MarkupSafe>=2.0 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from jinja2->torch>=2.0.0->accelerate) (3.0.2)
+Requirement already satisfied: charset_normalizer<4,>=2 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from requests->huggingface_hub>=0.21.0->accelerate) (3.4.3)
+Requirement already satisfied: idna<4,>=2.5 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from requests->huggingface_hub>=0.21.0->accelerate) (3.10)
+Requirement already satisfied: urllib3<3,>=1.21.1 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from requests->huggingface_hub>=0.21.0->accelerate) (2.5.0)
+Requirement already satisfied: certifi>=2017.4.17 in c:\users\dev-n\miniconda3\envs\dji-ml\lib\site-packages (from requests->huggingface_hub>=0.21.0->accelerate) (2025.8.3)
+Downloading accelerate-1.10.1-py3-none-any.whl (374 kB)
+Installing collected packages: accelerate
+Successfully installed accelerate-1.10.1

draft_computation/ocr/inference.py

@@ -0,0 +1,113 @@
+import torch
+from PIL import Image
+from transformers import VisionEncoderDecoderModel, AutoImageProcessor, AutoTokenizer
+import os
+import numpy as np
+from typing import Union
+
+# --- Configuration ---
+MODEL_PATH = "./ocr_model_output/checkpoint-441"
+
+class OCRInference:
+    """A class to perform OCR inference using a trained model."""
+
+    def __init__(self, model_path: str, encoder_id: str = "google/vit-base-patch16-224-in21k", decoder_id: str = "prajjwal1/bert-tiny"):
+        """
+        Initializes the OCRInference class by loading the model, image processor, and tokenizer.
+
+        Args:
+            model_path (str): The path to the trained model checkpoint.
+            encoder_id (str): The encoder ID to load the image processor from.
+            decoder_id (str): The decoder ID to load the tokenizer from.
+        """
+        print(f"Loading model from: {model_path}")
+        self.model = VisionEncoderDecoderModel.from_pretrained(model_path)
+        
+        # Load image processor and save it if not present
+        try:
+            self.image_processor = AutoImageProcessor.from_pretrained(model_path)
+        except OSError:
+            print("Image processor not found locally. Loading from encoder ID and saving.")
+            self.image_processor = AutoImageProcessor.from_pretrained(encoder_id)
+            self.image_processor.save_pretrained(model_path)
+            
+        # Load tokenizer and save it if not present
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+        except (KeyError, OSError):
+            print("Tokenizer not found locally. Loading from decoder ID and saving.")
+            self.tokenizer = AutoTokenizer.from_pretrained(decoder_id)
+            self.tokenizer.save_pretrained(model_path)
+
+        # --- Set special tokens and generation parameters ---
+        self.model.config.decoder_start_token_id = self.tokenizer.cls_token_id
+        self.model.config.pad_token_id = self.tokenizer.pad_token_id
+        self.model.config.vocab_size = self.tokenizer.vocab_size
+
+        self.model.config.eos_token_id = self.tokenizer.sep_token_id
+        self.model.config.max_length = 64
+        self.model.config.early_stopping = True
+        self.model.config.no_repeat_ngram_size = 3
+        self.model.config.length_penalty = 2.0
+        self.model.config.num_beams = 4
+
+        print("Model, image processor, and tokenizer loaded.")
+
+    def perform_inference(self, image_input: Union[str, np.ndarray]) -> str:
+        """
+        Performs inference on a single image, which can be a file path or a NumPy array.
+
+        Args:
+            image_input (Union[str, np.ndarray]): Path to the input image or a NumPy array representing the image.
+
+        Returns:
+            str: The predicted text.
+        """
+        if isinstance(image_input, str):
+            if not os.path.exists(image_input):
+                raise FileNotFoundError(f"Image file not found at: {image_input}")
+            image = Image.open(image_input).convert("RGB")
+        elif isinstance(image_input, np.ndarray):
+            image = Image.fromarray(image_input).convert("RGB")
+        else:
+            raise TypeError("image_input must be a file path (str) or a NumPy array.")
+
+        # Process the image
+        pixel_values = self.image_processor(images=image, return_tensors="pt").pixel_values
+
+        # Generate text
+        with torch.no_grad():
+            output_ids = self.model.generate(pixel_values, max_length=64, num_beams=4, early_stopping=True)
+
+        # Decode the generated ids to text
+        preds = self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
+        return preds
+
+if __name__ == '__main__':
+    # Provide a path to an image for inference
+    # Using an example image from the dataset
+    image_path = "../ai_augment_output/20250901_115123_336458_ccd9d646-fc99-4d27-8076-0c17d0dba784.png"
+
+    # --- Initialize the Inference Class ---
+    ocr_engine = OCRInference(model_path=MODEL_PATH)
+
+    # --- Perform Inference from a file path ---
+    try:
+        predicted_text = ocr_engine.perform_inference(image_path)
+        print(f"\n--- Inference from file path ---")
+        print(f"Image: {image_path}")
+        print(f"Predicted Text: {predicted_text}")
+    except FileNotFoundError as e:
+        print(e)
+        print("Please update the 'image_path' variable in the script with a valid image path.")
+
+    # --- Perform Inference from a NumPy array (example) ---
+    try:
+        # Create a dummy numpy array for demonstration
+        if os.path.exists(image_path):
+            dummy_image_array = np.array(Image.open(image_path))
+            predicted_text_from_array = ocr_engine.perform_inference(dummy_image_array)
+            print(f"\n--- Inference from NumPy array ---")
+            print(f"Predicted Text: {predicted_text_from_array}")
+    except Exception as e:
+        print(f"An error occurred during inference from NumPy array: {e}")

draft_computation/ocr/ocr_model_output/checkpoint-441/config.json

@@ -0,0 +1,65 @@
+{
+  "architectures": [
+    "VisionEncoderDecoderModel"
+  ],
+  "decoder": {
+    "_name_or_path": "prajjwal1/bert-tiny",
+    "add_cross_attention": true,
+    "attention_probs_dropout_prob": 0.1,
+    "classifier_dropout": null,
+    "dtype": "float32",
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.1,
+    "hidden_size": 128,
+    "initializer_range": 0.02,
+    "intermediate_size": 512,
+    "is_decoder": true,
+    "layer_norm_eps": 1e-12,
+    "max_position_embeddings": 512,
+    "model_type": "bert",
+    "num_attention_heads": 2,
+    "num_hidden_layers": 2,
+    "position_embedding_type": "absolute",
+    "type_vocab_size": 2,
+    "use_cache": true,
+    "vocab_size": 30522
+  },
+  "decoder_start_token_id": 101,
+  "dtype": "float32",
+  "early_stopping": null,
+  "encoder": {
+    "_name_or_path": "google/vit-base-patch16-224-in21k",
+    "architectures": [
+      "ViTModel"
+    ],
+    "attention_probs_dropout_prob": 0.0,
+    "dtype": "float32",
+    "encoder_stride": 16,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.0,
+    "hidden_size": 768,
+    "image_size": 224,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "layer_norm_eps": 1e-12,
+    "model_type": "vit",
+    "num_attention_heads": 12,
+    "num_channels": 3,
+    "num_hidden_layers": 12,
+    "patch_size": 16,
+    "pooler_act": "tanh",
+    "pooler_output_size": 768,
+    "qkv_bias": true
+  },
+  "eos_token_id": 102,
+  "is_encoder_decoder": true,
+  "length_penalty": null,
+  "max_length": null,
+  "model_type": "vision-encoder-decoder",
+  "no_repeat_ngram_size": null,
+  "num_beams": null,
+  "pad_token_id": 0,
+  "tie_word_embeddings": false,
+  "transformers_version": "4.56.0",
+  "vocab_size": 30522
+}

draft_computation/ocr/ocr_model_output/checkpoint-441/generation_config.json

@@ -0,0 +1,10 @@
+{
+  "_from_model_config": true,
+  "early_stopping": true,
+  "length_penalty": 2.0,
+  "max_length": 64,
+  "no_repeat_ngram_size": 3,
+  "num_beams": 4,
+  "pad_token_id": 0,
+  "transformers_version": "4.56.0"
+}

draft_computation/ocr/ocr_model_output/checkpoint-441/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03e0036a9723a25ce80e9d3194ccc557b38644b508aa539aa17fcf1db56abde8
+size 364179888

draft_computation/ocr/ocr_model_output/checkpoint-441/preprocessor_config.json

@@ -0,0 +1,23 @@
+{
+  "do_convert_rgb": null,
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "ViTImageProcessor",
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 224,
+    "width": 224
+  }
+}

draft_computation/ocr/ocr_model_output/checkpoint-441/rng_state.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b51fe74d1587712e04878e1f3aaa0d29dc3d63c924734ddb29bd9d7ceb8928f
+size 14645

draft_computation/ocr/ocr_model_output/checkpoint-441/scheduler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05d65119eb0fddac420e99f8c71db31930fb82a064e4c445ec9ba3b643474893
+size 1465

draft_computation/ocr/ocr_model_output/checkpoint-441/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

draft_computation/ocr/ocr_model_output/checkpoint-441/tokenizer_config.json

@@ -0,0 +1,58 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

draft_computation/ocr/ocr_model_output/checkpoint-441/trainer_state.json

@@ -0,0 +1,2828 @@
+{
+  "best_global_step": 2793,
+  "best_metric": 0.2159090909090909,
+  "best_model_checkpoint": "./ocr_model_output/checkpoint-2793",
+  "epoch": 25.0,
+  "eval_steps": 500,
+  "global_step": 3675,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 0.06802721088435375,
+      "grad_norm": 65.23433685302734,
+      "learning_rate": 4.9877551020408165e-05,
+      "loss": 8.6208,
+      "step": 10
+    },
+    {
+      "epoch": 0.1360544217687075,
+      "grad_norm": 70.44102478027344,
+      "learning_rate": 4.974149659863946e-05,
+      "loss": 4.5903,
+      "step": 20
+    },
+    {
+      "epoch": 0.20408163265306123,
+      "grad_norm": 35.348358154296875,
+      "learning_rate": 4.960544217687075e-05,
+      "loss": 1.9034,
+      "step": 30
+    },
+    {
+      "epoch": 0.272108843537415,
+      "grad_norm": 22.223546981811523,
+      "learning_rate": 4.9469387755102045e-05,
+      "loss": 1.3092,
+      "step": 40
+    },
+    {
+      "epoch": 0.3401360544217687,
+      "grad_norm": 35.46092987060547,
+      "learning_rate": 4.933333333333334e-05,
+      "loss": 1.0594,
+      "step": 50
+    },
+    {
+      "epoch": 0.40816326530612246,
+      "grad_norm": 22.021345138549805,
+      "learning_rate": 4.9197278911564624e-05,
+      "loss": 1.0721,
+      "step": 60
+    },
+    {
+      "epoch": 0.47619047619047616,
+      "grad_norm": 16.65888214111328,
+      "learning_rate": 4.9061224489795924e-05,
+      "loss": 0.825,
+      "step": 70
+    },
+    {
+      "epoch": 0.54421768707483,
+      "grad_norm": 13.323294639587402,
+      "learning_rate": 4.892517006802722e-05,
+      "loss": 0.8588,
+      "step": 80
+    },
+    {
+      "epoch": 0.6122448979591837,
+      "grad_norm": 16.98369598388672,
+      "learning_rate": 4.87891156462585e-05,
+      "loss": 0.6796,
+      "step": 90
+    },
+    {
+      "epoch": 0.6802721088435374,
+      "grad_norm": 14.879609107971191,
+      "learning_rate": 4.8653061224489796e-05,
+      "loss": 0.715,
+      "step": 100
+    },
+    {
+      "epoch": 0.7482993197278912,
+      "grad_norm": 13.820905685424805,
+      "learning_rate": 4.8517006802721096e-05,
+      "loss": 0.6773,
+      "step": 110
+    },
+    {
+      "epoch": 0.8163265306122449,
+      "grad_norm": 14.802565574645996,
+      "learning_rate": 4.838095238095238e-05,
+      "loss": 0.6992,
+      "step": 120
+    },
+    {
+      "epoch": 0.8843537414965986,
+      "grad_norm": 15.70506763458252,
+      "learning_rate": 4.8244897959183675e-05,
+      "loss": 0.7254,
+      "step": 130
+    },
+    {
+      "epoch": 0.9523809523809523,
+      "grad_norm": 16.910625457763672,
+      "learning_rate": 4.810884353741497e-05,
+      "loss": 0.8015,
+      "step": 140
+    },
+    {
+      "epoch": 1.0,
+      "eval_cer": 0.8118686868686869,
+      "eval_loss": 0.8795642256736755,
+      "eval_runtime": 3.4405,
+      "eval_samples_per_second": 85.161,
+      "eval_steps_per_second": 42.726,
+      "step": 147
+    },
+    {
+      "epoch": 1.0204081632653061,
+      "grad_norm": 12.733670234680176,
+      "learning_rate": 4.797278911564626e-05,
+      "loss": 0.6511,
+      "step": 150
+    },
+    {
+      "epoch": 1.08843537414966,
+      "grad_norm": 13.70749568939209,
+      "learning_rate": 4.7836734693877554e-05,
+      "loss": 0.7377,
+      "step": 160
+    },
+    {
+      "epoch": 1.1564625850340136,
+      "grad_norm": 15.44306468963623,
+      "learning_rate": 4.770068027210885e-05,
+      "loss": 0.6797,
+      "step": 170
+    },
+    {
+      "epoch": 1.2244897959183674,
+      "grad_norm": 19.31881332397461,
+      "learning_rate": 4.756462585034014e-05,
+      "loss": 0.6719,
+      "step": 180
+    },
+    {
+      "epoch": 1.2925170068027212,
+      "grad_norm": 12.049680709838867,
+      "learning_rate": 4.742857142857143e-05,
+      "loss": 0.6491,
+      "step": 190
+    },
+    {
+      "epoch": 1.3605442176870748,
+      "grad_norm": 14.28982925415039,
+      "learning_rate": 4.729251700680272e-05,
+      "loss": 0.7678,
+      "step": 200
+    },
+    {
+      "epoch": 1.4285714285714286,
+      "grad_norm": 25.51521110534668,
+      "learning_rate": 4.715646258503402e-05,
+      "loss": 0.7534,
+      "step": 210
+    },
+    {
+      "epoch": 1.4965986394557822,
+      "grad_norm": 14.158224105834961,
+      "learning_rate": 4.7020408163265306e-05,
+      "loss": 0.5653,
+      "step": 220
+    },
+    {
+      "epoch": 1.564625850340136,
+      "grad_norm": 10.563309669494629,
+      "learning_rate": 4.68843537414966e-05,
+      "loss": 0.6038,
+      "step": 230
+    },
+    {
+      "epoch": 1.6326530612244898,
+      "grad_norm": 14.436025619506836,
+      "learning_rate": 4.67482993197279e-05,
+      "loss": 0.5794,
+      "step": 240
+    },
+    {
+      "epoch": 1.7006802721088436,
+      "grad_norm": 14.293322563171387,
+      "learning_rate": 4.6612244897959185e-05,
+      "loss": 0.6102,
+      "step": 250
+    },
+    {
+      "epoch": 1.7687074829931972,
+      "grad_norm": 6.588962078094482,
+      "learning_rate": 4.647619047619048e-05,
+      "loss": 0.6853,
+      "step": 260
+    },
+    {
+      "epoch": 1.836734693877551,
+      "grad_norm": 16.505081176757812,
+      "learning_rate": 4.634013605442177e-05,
+      "loss": 0.554,
+      "step": 270
+    },
+    {
+      "epoch": 1.9047619047619047,
+      "grad_norm": 16.433975219726562,
+      "learning_rate": 4.6204081632653064e-05,
+      "loss": 0.5481,
+      "step": 280
+    },
+    {
+      "epoch": 1.9727891156462585,
+      "grad_norm": 14.68355655670166,
+      "learning_rate": 4.606802721088436e-05,
+      "loss": 0.4728,
+      "step": 290
+    },
+    {
+      "epoch": 2.0,
+      "eval_cer": 0.571969696969697,
+      "eval_loss": 0.6962071061134338,
+      "eval_runtime": 3.8738,
+      "eval_samples_per_second": 75.637,
+      "eval_steps_per_second": 37.948,
+      "step": 294
+    },
+    {
+      "epoch": 2.0408163265306123,
+      "grad_norm": 9.795095443725586,
+      "learning_rate": 4.593197278911564e-05,
+      "loss": 0.4635,
+      "step": 300
+    },
+    {
+      "epoch": 2.108843537414966,
+      "grad_norm": 17.107149124145508,
+      "learning_rate": 4.579591836734694e-05,
+      "loss": 0.4794,
+      "step": 310
+    },
+    {
+      "epoch": 2.17687074829932,
+      "grad_norm": 11.940792083740234,
+      "learning_rate": 4.5659863945578236e-05,
+      "loss": 0.677,
+      "step": 320
+    },
+    {
+      "epoch": 2.2448979591836733,
+      "grad_norm": 8.351872444152832,
+      "learning_rate": 4.552380952380952e-05,
+      "loss": 0.6732,
+      "step": 330
+    },
+    {
+      "epoch": 2.312925170068027,
+      "grad_norm": 2.6622140407562256,
+      "learning_rate": 4.538775510204082e-05,
+      "loss": 0.3907,
+      "step": 340
+    },
+    {
+      "epoch": 2.380952380952381,
+      "grad_norm": 10.555298805236816,
+      "learning_rate": 4.5251700680272115e-05,
+      "loss": 0.5443,
+      "step": 350
+    },
+    {
+      "epoch": 2.4489795918367347,
+      "grad_norm": 7.857567310333252,
+      "learning_rate": 4.51156462585034e-05,
+      "loss": 0.5688,
+      "step": 360
+    },
+    {
+      "epoch": 2.5170068027210886,
+      "grad_norm": 15.215005874633789,
+      "learning_rate": 4.4979591836734694e-05,
+      "loss": 0.5548,
+      "step": 370
+    },
+    {
+      "epoch": 2.5850340136054424,
+      "grad_norm": 8.438752174377441,
+      "learning_rate": 4.484353741496599e-05,
+      "loss": 0.3828,
+      "step": 380
+    },
+    {
+      "epoch": 2.6530612244897958,
+      "grad_norm": 9.824787139892578,
+      "learning_rate": 4.470748299319728e-05,
+      "loss": 0.3945,
+      "step": 390
+    },
+    {
+      "epoch": 2.7210884353741496,
+      "grad_norm": 13.708135604858398,
+      "learning_rate": 4.4571428571428574e-05,
+      "loss": 0.3751,
+      "step": 400
+    },
+    {
+      "epoch": 2.7891156462585034,
+      "grad_norm": 10.32359790802002,
+      "learning_rate": 4.4435374149659867e-05,
+      "loss": 0.4604,
+      "step": 410
+    },
+    {
+      "epoch": 2.857142857142857,
+      "grad_norm": 4.256906509399414,
+      "learning_rate": 4.429931972789116e-05,
+      "loss": 0.4558,
+      "step": 420
+    },
+    {
+      "epoch": 2.925170068027211,
+      "grad_norm": 12.131647109985352,
+      "learning_rate": 4.416326530612245e-05,
+      "loss": 0.4292,
+      "step": 430
+    },
+    {
+      "epoch": 2.9931972789115644,
+      "grad_norm": 14.156941413879395,
+      "learning_rate": 4.4027210884353746e-05,
+      "loss": 0.3713,
+      "step": 440
+    },
+    {
+      "epoch": 3.0,
+      "eval_cer": 0.5454545454545454,
+      "eval_loss": 0.5351251363754272,
+      "eval_runtime": 3.9015,
+      "eval_samples_per_second": 75.099,
+      "eval_steps_per_second": 37.678,
+      "step": 441
+    },
+    {
+      "epoch": 3.061224489795918,
+      "grad_norm": 5.429965496063232,
+      "learning_rate": 4.389115646258504e-05,
+      "loss": 0.6159,
+      "step": 450
+    },
+    {
+      "epoch": 3.129251700680272,
+      "grad_norm": 11.695433616638184,
+      "learning_rate": 4.3755102040816325e-05,
+      "loss": 0.4156,
+      "step": 460
+    },
+    {
+      "epoch": 3.197278911564626,
+      "grad_norm": 14.333072662353516,
+      "learning_rate": 4.361904761904762e-05,
+      "loss": 0.4372,
+      "step": 470
+    },
+    {
+      "epoch": 3.2653061224489797,
+      "grad_norm": 14.760481834411621,
+      "learning_rate": 4.348299319727892e-05,
+      "loss": 0.4279,
+      "step": 480
+    },
+    {
+      "epoch": 3.3333333333333335,
+      "grad_norm": 12.052332878112793,
+      "learning_rate": 4.3346938775510204e-05,
+      "loss": 0.3854,
+      "step": 490
+    },
+    {
+      "epoch": 3.4013605442176873,
+      "grad_norm": 14.331747055053711,
+      "learning_rate": 4.32108843537415e-05,
+      "loss": 0.3839,
+      "step": 500
+    },
+    {
+      "epoch": 3.4693877551020407,
+      "grad_norm": 21.911863327026367,
+      "learning_rate": 4.307482993197279e-05,
+      "loss": 0.4815,
+      "step": 510
+    },
+    {
+      "epoch": 3.5374149659863945,
+      "grad_norm": 6.438183307647705,
+      "learning_rate": 4.293877551020408e-05,
+      "loss": 0.2597,
+      "step": 520
+    },
+    {
+      "epoch": 3.6054421768707483,
+      "grad_norm": 13.568741798400879,
+      "learning_rate": 4.2802721088435376e-05,
+      "loss": 0.3735,
+      "step": 530
+    },
+    {
+      "epoch": 3.673469387755102,
+      "grad_norm": 0.18484297394752502,
+      "learning_rate": 4.266666666666667e-05,
+      "loss": 0.3343,
+      "step": 540
+    },
+    {
+      "epoch": 3.741496598639456,
+      "grad_norm": 0.7180817127227783,
+      "learning_rate": 4.253061224489796e-05,
+      "loss": 0.1867,
+      "step": 550
+    },
+    {
+      "epoch": 3.8095238095238093,
+      "grad_norm": 0.15185348689556122,
+      "learning_rate": 4.2394557823129255e-05,
+      "loss": 0.4185,
+      "step": 560
+    },
+    {
+      "epoch": 3.877551020408163,
+      "grad_norm": 10.095551490783691,
+      "learning_rate": 4.225850340136054e-05,
+      "loss": 0.1698,
+      "step": 570
+    },
+    {
+      "epoch": 3.945578231292517,
+      "grad_norm": 15.650616645812988,
+      "learning_rate": 4.212244897959184e-05,
+      "loss": 0.4307,
+      "step": 580
+    },
+    {
+      "epoch": 4.0,
+      "eval_cer": 0.4911616161616162,
+      "eval_loss": 0.4221580922603607,
+      "eval_runtime": 3.8592,
+      "eval_samples_per_second": 75.922,
+      "eval_steps_per_second": 38.091,
+      "step": 588
+    },
+    {
+      "epoch": 4.01360544217687,
+      "grad_norm": 8.345415115356445,
+      "learning_rate": 4.1986394557823134e-05,
+      "loss": 0.2111,
+      "step": 590
+    },
+    {
+      "epoch": 4.081632653061225,
+      "grad_norm": 4.688040256500244,
+      "learning_rate": 4.185034013605442e-05,
+      "loss": 0.3211,
+      "step": 600
+    },
+    {
+      "epoch": 4.149659863945578,
+      "grad_norm": 19.075292587280273,
+      "learning_rate": 4.1714285714285714e-05,
+      "loss": 0.3103,
+      "step": 610
+    },
+    {
+      "epoch": 4.217687074829932,
+      "grad_norm": 7.607833385467529,
+      "learning_rate": 4.1578231292517014e-05,
+      "loss": 0.2308,
+      "step": 620
+    },
+    {
+      "epoch": 4.285714285714286,
+      "grad_norm": 8.69675350189209,
+      "learning_rate": 4.14421768707483e-05,
+      "loss": 0.2981,
+      "step": 630
+    },
+    {
+      "epoch": 4.35374149659864,
+      "grad_norm": 2.994023323059082,
+      "learning_rate": 4.130612244897959e-05,
+      "loss": 0.2922,
+      "step": 640
+    },
+    {
+      "epoch": 4.421768707482993,
+      "grad_norm": 6.535342693328857,
+      "learning_rate": 4.1170068027210886e-05,
+      "loss": 0.3441,
+      "step": 650
+    },
+    {
+      "epoch": 4.489795918367347,
+      "grad_norm": 0.3404290974140167,
+      "learning_rate": 4.103401360544218e-05,
+      "loss": 0.3523,
+      "step": 660
+    },
+    {
+      "epoch": 4.557823129251701,
+      "grad_norm": 10.70188045501709,
+      "learning_rate": 4.089795918367347e-05,
+      "loss": 0.4148,
+      "step": 670
+    },
+    {
+      "epoch": 4.625850340136054,
+      "grad_norm": 14.900300979614258,
+      "learning_rate": 4.0761904761904765e-05,
+      "loss": 0.4041,
+      "step": 680
+    },
+    {
+      "epoch": 4.6938775510204085,
+      "grad_norm": 14.758822441101074,
+      "learning_rate": 4.062585034013606e-05,
+      "loss": 0.2453,
+      "step": 690
+    },
+    {
+      "epoch": 4.761904761904762,
+      "grad_norm": 0.7187572717666626,
+      "learning_rate": 4.048979591836735e-05,
+      "loss": 0.3703,
+      "step": 700
+    },
+    {
+      "epoch": 4.829931972789115,
+      "grad_norm": 9.603391647338867,
+      "learning_rate": 4.035374149659864e-05,
+      "loss": 0.3354,
+      "step": 710
+    },
+    {
+      "epoch": 4.8979591836734695,
+      "grad_norm": 1.358739972114563,
+      "learning_rate": 4.021768707482994e-05,
+      "loss": 0.3297,
+      "step": 720
+    },
+    {
+      "epoch": 4.965986394557823,
+      "grad_norm": 0.37522122263908386,
+      "learning_rate": 4.008163265306122e-05,
+      "loss": 0.2072,
+      "step": 730
+    },
+    {
+      "epoch": 5.0,
+      "eval_cer": 0.5921717171717171,
+      "eval_loss": 0.358783096075058,
+      "eval_runtime": 3.5411,
+      "eval_samples_per_second": 82.742,
+      "eval_steps_per_second": 41.512,
+      "step": 735
+    },
+    {
+      "epoch": 5.034013605442177,
+      "grad_norm": 3.8917222023010254,
+      "learning_rate": 3.9945578231292516e-05,
+      "loss": 0.2488,
+      "step": 740
+    },
+    {
+      "epoch": 5.1020408163265305,
+      "grad_norm": 16.159465789794922,
+      "learning_rate": 3.9809523809523816e-05,
+      "loss": 0.3769,
+      "step": 750
+    },
+    {
+      "epoch": 5.170068027210885,
+      "grad_norm": 17.226072311401367,
+      "learning_rate": 3.96734693877551e-05,
+      "loss": 0.2559,
+      "step": 760
+    },
+    {
+      "epoch": 5.238095238095238,
+      "grad_norm": 0.8567410707473755,
+      "learning_rate": 3.9537414965986396e-05,
+      "loss": 0.248,
+      "step": 770
+    },
+    {
+      "epoch": 5.3061224489795915,
+      "grad_norm": 1.5087652206420898,
+      "learning_rate": 3.940136054421769e-05,
+      "loss": 0.2737,
+      "step": 780
+    },
+    {
+      "epoch": 5.374149659863946,
+      "grad_norm": 3.331455945968628,
+      "learning_rate": 3.926530612244898e-05,
+      "loss": 0.1665,
+      "step": 790
+    },
+    {
+      "epoch": 5.442176870748299,
+      "grad_norm": 11.933197021484375,
+      "learning_rate": 3.9129251700680275e-05,
+      "loss": 0.322,
+      "step": 800
+    },
+    {
+      "epoch": 5.510204081632653,
+      "grad_norm": 13.032449722290039,
+      "learning_rate": 3.899319727891156e-05,
+      "loss": 0.239,
+      "step": 810
+    },
+    {
+      "epoch": 5.578231292517007,
+      "grad_norm": 5.0442047119140625,
+      "learning_rate": 3.885714285714286e-05,
+      "loss": 0.157,
+      "step": 820
+    },
+    {
+      "epoch": 5.646258503401361,
+      "grad_norm": 1.6076925992965698,
+      "learning_rate": 3.8721088435374154e-05,
+      "loss": 0.1926,
+      "step": 830
+    },
+    {
+      "epoch": 5.714285714285714,
+      "grad_norm": 22.085569381713867,
+      "learning_rate": 3.858503401360544e-05,
+      "loss": 0.3699,
+      "step": 840
+    },
+    {
+      "epoch": 5.782312925170068,
+      "grad_norm": 10.831768989562988,
+      "learning_rate": 3.844897959183674e-05,
+      "loss": 0.291,
+      "step": 850
+    },
+    {
+      "epoch": 5.850340136054422,
+      "grad_norm": 0.5946142077445984,
+      "learning_rate": 3.831292517006803e-05,
+      "loss": 0.2154,
+      "step": 860
+    },
+    {
+      "epoch": 5.918367346938775,
+      "grad_norm": 1.5171136856079102,
+      "learning_rate": 3.817687074829932e-05,
+      "loss": 0.212,
+      "step": 870
+    },
+    {
+      "epoch": 5.986394557823129,
+      "grad_norm": 18.592945098876953,
+      "learning_rate": 3.804081632653061e-05,
+      "loss": 0.2963,
+      "step": 880
+    },
+    {
+      "epoch": 6.0,
+      "eval_cer": 0.5151515151515151,
+      "eval_loss": 0.2578863501548767,
+      "eval_runtime": 3.7328,
+      "eval_samples_per_second": 78.493,
+      "eval_steps_per_second": 39.38,
+      "step": 882
+    },
+    {
+      "epoch": 6.054421768707483,
+      "grad_norm": 0.10681638866662979,
+      "learning_rate": 3.7904761904761905e-05,
+      "loss": 0.1761,
+      "step": 890
+    },
+    {
+      "epoch": 6.122448979591836,
+      "grad_norm": 7.661993503570557,
+      "learning_rate": 3.77687074829932e-05,
+      "loss": 0.2027,
+      "step": 900
+    },
+    {
+      "epoch": 6.190476190476191,
+      "grad_norm": 12.70997428894043,
+      "learning_rate": 3.763265306122449e-05,
+      "loss": 0.1828,
+      "step": 910
+    },
+    {
+      "epoch": 6.258503401360544,
+      "grad_norm": 0.06931126117706299,
+      "learning_rate": 3.7496598639455784e-05,
+      "loss": 0.1242,
+      "step": 920
+    },
+    {
+      "epoch": 6.326530612244898,
+      "grad_norm": 17.21261215209961,
+      "learning_rate": 3.736054421768708e-05,
+      "loss": 0.3785,
+      "step": 930
+    },
+    {
+      "epoch": 6.394557823129252,
+      "grad_norm": 0.10957188904285431,
+      "learning_rate": 3.722448979591837e-05,
+      "loss": 0.1184,
+      "step": 940
+    },
+    {
+      "epoch": 6.462585034013605,
+      "grad_norm": 14.104228019714355,
+      "learning_rate": 3.7088435374149663e-05,
+      "loss": 0.2253,
+      "step": 950
+    },
+    {
+      "epoch": 6.530612244897959,
+      "grad_norm": 0.2823491394519806,
+      "learning_rate": 3.6952380952380956e-05,
+      "loss": 0.1337,
+      "step": 960
+    },
+    {
+      "epoch": 6.598639455782313,
+      "grad_norm": 0.17527176439762115,
+      "learning_rate": 3.681632653061224e-05,
+      "loss": 0.1745,
+      "step": 970
+    },
+    {
+      "epoch": 6.666666666666667,
+      "grad_norm": 12.178832054138184,
+      "learning_rate": 3.6680272108843536e-05,
+      "loss": 0.3322,
+      "step": 980
+    },
+    {
+      "epoch": 6.73469387755102,
+      "grad_norm": 18.27240753173828,
+      "learning_rate": 3.6544217687074836e-05,
+      "loss": 0.245,
+      "step": 990
+    },
+    {
+      "epoch": 6.802721088435375,
+      "grad_norm": 8.510261535644531,
+      "learning_rate": 3.640816326530612e-05,
+      "loss": 0.2928,
+      "step": 1000
+    },
+    {
+      "epoch": 6.870748299319728,
+      "grad_norm": 8.47603988647461,
+      "learning_rate": 3.6272108843537415e-05,
+      "loss": 0.2048,
+      "step": 1010
+    },
+    {
+      "epoch": 6.938775510204081,
+      "grad_norm": 9.21681022644043,
+      "learning_rate": 3.6136054421768715e-05,
+      "loss": 0.1416,
+      "step": 1020
+    },
+    {
+      "epoch": 7.0,
+      "eval_cer": 0.4166666666666667,
+      "eval_loss": 0.1848345547914505,
+      "eval_runtime": 4.0307,
+      "eval_samples_per_second": 72.692,
+      "eval_steps_per_second": 36.47,
+      "step": 1029
+    },
+    {
+      "epoch": 7.006802721088436,
+      "grad_norm": 8.593953132629395,
+      "learning_rate": 3.6e-05,
+      "loss": 0.1307,
+      "step": 1030
+    },
+    {
+      "epoch": 7.074829931972789,
+      "grad_norm": 6.022789001464844,
+      "learning_rate": 3.5863945578231294e-05,
+      "loss": 0.1292,
+      "step": 1040
+    },
+    {
+      "epoch": 7.142857142857143,
+      "grad_norm": 10.953206062316895,
+      "learning_rate": 3.572789115646259e-05,
+      "loss": 0.0853,
+      "step": 1050
+    },
+    {
+      "epoch": 7.210884353741497,
+      "grad_norm": 5.332366943359375,
+      "learning_rate": 3.559183673469388e-05,
+      "loss": 0.112,
+      "step": 1060
+    },
+    {
+      "epoch": 7.27891156462585,
+      "grad_norm": 12.159287452697754,
+      "learning_rate": 3.545578231292517e-05,
+      "loss": 0.1007,
+      "step": 1070
+    },
+    {
+      "epoch": 7.346938775510204,
+      "grad_norm": 0.3854842483997345,
+      "learning_rate": 3.531972789115646e-05,
+      "loss": 0.2318,
+      "step": 1080
+    },
+    {
+      "epoch": 7.414965986394558,
+      "grad_norm": 11.151751518249512,
+      "learning_rate": 3.518367346938776e-05,
+      "loss": 0.1768,
+      "step": 1090
+    },
+    {
+      "epoch": 7.482993197278912,
+      "grad_norm": 20.415531158447266,
+      "learning_rate": 3.504761904761905e-05,
+      "loss": 0.1839,
+      "step": 1100
+    },
+    {
+      "epoch": 7.551020408163265,
+      "grad_norm": 0.7234401106834412,
+      "learning_rate": 3.491156462585034e-05,
+      "loss": 0.2944,
+      "step": 1110
+    },
+    {
+      "epoch": 7.619047619047619,
+      "grad_norm": 0.522950291633606,
+      "learning_rate": 3.477551020408164e-05,
+      "loss": 0.087,
+      "step": 1120
+    },
+    {
+      "epoch": 7.687074829931973,
+      "grad_norm": 8.606940269470215,
+      "learning_rate": 3.463945578231293e-05,
+      "loss": 0.1253,
+      "step": 1130
+    },
+    {
+      "epoch": 7.755102040816326,
+      "grad_norm": 22.922000885009766,
+      "learning_rate": 3.450340136054422e-05,
+      "loss": 0.2799,
+      "step": 1140
+    },
+    {
+      "epoch": 7.8231292517006805,
+      "grad_norm": 21.035017013549805,
+      "learning_rate": 3.436734693877551e-05,
+      "loss": 0.1441,
+      "step": 1150
+    },
+    {
+      "epoch": 7.891156462585034,
+      "grad_norm": 5.825491905212402,
+      "learning_rate": 3.4231292517006804e-05,
+      "loss": 0.0218,
+      "step": 1160
+    },
+    {
+      "epoch": 7.959183673469388,
+      "grad_norm": 12.801454544067383,
+      "learning_rate": 3.40952380952381e-05,
+      "loss": 0.2319,
+      "step": 1170
+    },
+    {
+      "epoch": 8.0,
+      "eval_cer": 0.42424242424242425,
+      "eval_loss": 0.13813678920269012,
+      "eval_runtime": 4.039,
+      "eval_samples_per_second": 72.542,
+      "eval_steps_per_second": 36.395,
+      "step": 1176
+    },
+    {
+      "epoch": 8.02721088435374,
+      "grad_norm": 1.3456509113311768,
+      "learning_rate": 3.395918367346939e-05,
+      "loss": 0.1622,
+      "step": 1180
+    },
+    {
+      "epoch": 8.095238095238095,
+      "grad_norm": 0.21156376600265503,
+      "learning_rate": 3.382312925170068e-05,
+      "loss": 0.0447,
+      "step": 1190
+    },
+    {
+      "epoch": 8.16326530612245,
+      "grad_norm": 0.08529641479253769,
+      "learning_rate": 3.3687074829931976e-05,
+      "loss": 0.3241,
+      "step": 1200
+    },
+    {
+      "epoch": 8.231292517006803,
+      "grad_norm": 8.225408554077148,
+      "learning_rate": 3.355102040816327e-05,
+      "loss": 0.1136,
+      "step": 1210
+    },
+    {
+      "epoch": 8.299319727891156,
+      "grad_norm": 0.0486108660697937,
+      "learning_rate": 3.341496598639456e-05,
+      "loss": 0.2109,
+      "step": 1220
+    },
+    {
+      "epoch": 8.36734693877551,
+      "grad_norm": 0.3150612413883209,
+      "learning_rate": 3.3278911564625855e-05,
+      "loss": 0.0678,
+      "step": 1230
+    },
+    {
+      "epoch": 8.435374149659864,
+      "grad_norm": 2.7837414741516113,
+      "learning_rate": 3.314285714285714e-05,
+      "loss": 0.0582,
+      "step": 1240
+    },
+    {
+      "epoch": 8.503401360544217,
+      "grad_norm": 0.08137867599725723,
+      "learning_rate": 3.3006802721088434e-05,
+      "loss": 0.2023,
+      "step": 1250
+    },
+    {
+      "epoch": 8.571428571428571,
+      "grad_norm": 0.12031784653663635,
+      "learning_rate": 3.2870748299319734e-05,
+      "loss": 0.2334,
+      "step": 1260
+    },
+    {
+      "epoch": 8.639455782312925,
+      "grad_norm": 0.7248769998550415,
+      "learning_rate": 3.273469387755102e-05,
+      "loss": 0.0562,
+      "step": 1270
+    },
+    {
+      "epoch": 8.70748299319728,
+      "grad_norm": 9.878806114196777,
+      "learning_rate": 3.259863945578231e-05,
+      "loss": 0.1711,
+      "step": 1280
+    },
+    {
+      "epoch": 8.775510204081632,
+      "grad_norm": 11.397530555725098,
+      "learning_rate": 3.2462585034013606e-05,
+      "loss": 0.2418,
+      "step": 1290
+    },
+    {
+      "epoch": 8.843537414965986,
+      "grad_norm": 13.183833122253418,
+      "learning_rate": 3.23265306122449e-05,
+      "loss": 0.056,
+      "step": 1300
+    },
+    {
+      "epoch": 8.91156462585034,
+      "grad_norm": 0.8917256593704224,
+      "learning_rate": 3.219047619047619e-05,
+      "loss": 0.0436,
+      "step": 1310
+    },
+    {
+      "epoch": 8.979591836734693,
+      "grad_norm": 7.448833465576172,
+      "learning_rate": 3.2054421768707485e-05,
+      "loss": 0.0476,
+      "step": 1320
+    },
+    {
+      "epoch": 9.0,
+      "eval_cer": 0.37752525252525254,
+      "eval_loss": 0.11764977127313614,
+      "eval_runtime": 3.9588,
+      "eval_samples_per_second": 74.013,
+      "eval_steps_per_second": 37.133,
+      "step": 1323
+    },
+    {
+      "epoch": 9.047619047619047,
+      "grad_norm": 7.476083278656006,
+      "learning_rate": 3.191836734693878e-05,
+      "loss": 0.098,
+      "step": 1330
+    },
+    {
+      "epoch": 9.115646258503402,
+      "grad_norm": 0.2827729880809784,
+      "learning_rate": 3.178231292517007e-05,
+      "loss": 0.1332,
+      "step": 1340
+    },
+    {
+      "epoch": 9.183673469387756,
+      "grad_norm": 1.02791166305542,
+      "learning_rate": 3.164625850340136e-05,
+      "loss": 0.0211,
+      "step": 1350
+    },
+    {
+      "epoch": 9.251700680272108,
+      "grad_norm": 14.376386642456055,
+      "learning_rate": 3.151020408163266e-05,
+      "loss": 0.1141,
+      "step": 1360
+    },
+    {
+      "epoch": 9.319727891156463,
+      "grad_norm": 0.9921436309814453,
+      "learning_rate": 3.137414965986395e-05,
+      "loss": 0.0931,
+      "step": 1370
+    },
+    {
+      "epoch": 9.387755102040817,
+      "grad_norm": 0.1799956113100052,
+      "learning_rate": 3.123809523809524e-05,
+      "loss": 0.0095,
+      "step": 1380
+    },
+    {
+      "epoch": 9.45578231292517,
+      "grad_norm": 0.05473727360367775,
+      "learning_rate": 3.110204081632653e-05,
+      "loss": 0.1565,
+      "step": 1390
+    },
+    {
+      "epoch": 9.523809523809524,
+      "grad_norm": 0.5269390344619751,
+      "learning_rate": 3.096598639455782e-05,
+      "loss": 0.0674,
+      "step": 1400
+    },
+    {
+      "epoch": 9.591836734693878,
+      "grad_norm": 2.706407070159912,
+      "learning_rate": 3.0829931972789116e-05,
+      "loss": 0.0966,
+      "step": 1410
+    },
+    {
+      "epoch": 9.65986394557823,
+      "grad_norm": 0.16416242718696594,
+      "learning_rate": 3.069387755102041e-05,
+      "loss": 0.0667,
+      "step": 1420
+    },
+    {
+      "epoch": 9.727891156462585,
+      "grad_norm": 15.035467147827148,
+      "learning_rate": 3.05578231292517e-05,
+      "loss": 0.1272,
+      "step": 1430
+    },
+    {
+      "epoch": 9.795918367346939,
+      "grad_norm": 0.19053949415683746,
+      "learning_rate": 3.0421768707482995e-05,
+      "loss": 0.2847,
+      "step": 1440
+    },
+    {
+      "epoch": 9.863945578231293,
+      "grad_norm": 0.12774477899074554,
+      "learning_rate": 3.0285714285714288e-05,
+      "loss": 0.1103,
+      "step": 1450
+    },
+    {
+      "epoch": 9.931972789115646,
+      "grad_norm": 0.474401593208313,
+      "learning_rate": 3.0149659863945578e-05,
+      "loss": 0.0972,
+      "step": 1460
+    },
+    {
+      "epoch": 10.0,
+      "grad_norm": 0.0236662644892931,
+      "learning_rate": 3.0013605442176874e-05,
+      "loss": 0.0626,
+      "step": 1470
+    },
+    {
+      "epoch": 10.0,
+      "eval_cer": 0.4305555555555556,
+      "eval_loss": 0.09693024307489395,
+      "eval_runtime": 4.1253,
+      "eval_samples_per_second": 71.025,
+      "eval_steps_per_second": 35.633,
+      "step": 1470
+    },
+    {
+      "epoch": 10.068027210884354,
+      "grad_norm": 0.03369349241256714,
+      "learning_rate": 2.987755102040816e-05,
+      "loss": 0.0542,
+      "step": 1480
+    },
+    {
+      "epoch": 10.136054421768707,
+      "grad_norm": 0.2802339792251587,
+      "learning_rate": 2.9741496598639457e-05,
+      "loss": 0.1356,
+      "step": 1490
+    },
+    {
+      "epoch": 10.204081632653061,
+      "grad_norm": 0.48600488901138306,
+      "learning_rate": 2.960544217687075e-05,
+      "loss": 0.1529,
+      "step": 1500
+    },
+    {
+      "epoch": 10.272108843537415,
+      "grad_norm": 2.2791683673858643,
+      "learning_rate": 2.946938775510204e-05,
+      "loss": 0.1232,
+      "step": 1510
+    },
+    {
+      "epoch": 10.34013605442177,
+      "grad_norm": 6.162140369415283,
+      "learning_rate": 2.9333333333333336e-05,
+      "loss": 0.1948,
+      "step": 1520
+    },
+    {
+      "epoch": 10.408163265306122,
+      "grad_norm": 1.365488886833191,
+      "learning_rate": 2.919727891156463e-05,
+      "loss": 0.0417,
+      "step": 1530
+    },
+    {
+      "epoch": 10.476190476190476,
+      "grad_norm": 14.345423698425293,
+      "learning_rate": 2.906122448979592e-05,
+      "loss": 0.0859,
+      "step": 1540
+    },
+    {
+      "epoch": 10.54421768707483,
+      "grad_norm": 0.1597384810447693,
+      "learning_rate": 2.892517006802721e-05,
+      "loss": 0.0376,
+      "step": 1550
+    },
+    {
+      "epoch": 10.612244897959183,
+      "grad_norm": 0.24928878247737885,
+      "learning_rate": 2.87891156462585e-05,
+      "loss": 0.5477,
+      "step": 1560
+    },
+    {
+      "epoch": 10.680272108843537,
+      "grad_norm": 0.3629794418811798,
+      "learning_rate": 2.8653061224489798e-05,
+      "loss": 0.0102,
+      "step": 1570
+    },
+    {
+      "epoch": 10.748299319727892,
+      "grad_norm": 17.98668098449707,
+      "learning_rate": 2.851700680272109e-05,
+      "loss": 0.0821,
+      "step": 1580
+    },
+    {
+      "epoch": 10.816326530612244,
+      "grad_norm": 5.073668479919434,
+      "learning_rate": 2.838095238095238e-05,
+      "loss": 0.053,
+      "step": 1590
+    },
+    {
+      "epoch": 10.884353741496598,
+      "grad_norm": 12.528962135314941,
+      "learning_rate": 2.8244897959183673e-05,
+      "loss": 0.0463,
+      "step": 1600
+    },
+    {
+      "epoch": 10.952380952380953,
+      "grad_norm": 1.0358648300170898,
+      "learning_rate": 2.810884353741497e-05,
+      "loss": 0.0124,
+      "step": 1610
+    },
+    {
+      "epoch": 11.0,
+      "eval_cer": 0.39646464646464646,
+      "eval_loss": 0.08722148090600967,
+      "eval_runtime": 3.8388,
+      "eval_samples_per_second": 76.326,
+      "eval_steps_per_second": 38.293,
+      "step": 1617
+    },
+    {
+      "epoch": 11.020408163265307,
+      "grad_norm": 0.19600285589694977,
+      "learning_rate": 2.797278911564626e-05,
+      "loss": 0.118,
+      "step": 1620
+    },
+    {
+      "epoch": 11.08843537414966,
+      "grad_norm": 26.618637084960938,
+      "learning_rate": 2.7836734693877553e-05,
+      "loss": 0.3147,
+      "step": 1630
+    },
+    {
+      "epoch": 11.156462585034014,
+      "grad_norm": 0.05680645629763603,
+      "learning_rate": 2.7700680272108842e-05,
+      "loss": 0.2198,
+      "step": 1640
+    },
+    {
+      "epoch": 11.224489795918368,
+      "grad_norm": 13.787897109985352,
+      "learning_rate": 2.7564625850340135e-05,
+      "loss": 0.2091,
+      "step": 1650
+    },
+    {
+      "epoch": 11.29251700680272,
+      "grad_norm": 1.339880108833313,
+      "learning_rate": 2.742857142857143e-05,
+      "loss": 0.0221,
+      "step": 1660
+    },
+    {
+      "epoch": 11.360544217687075,
+      "grad_norm": 0.18231110274791718,
+      "learning_rate": 2.729251700680272e-05,
+      "loss": 0.0567,
+      "step": 1670
+    },
+    {
+      "epoch": 11.428571428571429,
+      "grad_norm": 0.15762682259082794,
+      "learning_rate": 2.7156462585034014e-05,
+      "loss": 0.0118,
+      "step": 1680
+    },
+    {
+      "epoch": 11.496598639455783,
+      "grad_norm": 0.19339053332805634,
+      "learning_rate": 2.702040816326531e-05,
+      "loss": 0.0082,
+      "step": 1690
+    },
+    {
+      "epoch": 11.564625850340136,
+      "grad_norm": 11.242050170898438,
+      "learning_rate": 2.6884353741496597e-05,
+      "loss": 0.0398,
+      "step": 1700
+    },
+    {
+      "epoch": 11.63265306122449,
+      "grad_norm": 0.104960598051548,
+      "learning_rate": 2.6748299319727893e-05,
+      "loss": 0.0745,
+      "step": 1710
+    },
+    {
+      "epoch": 11.700680272108844,
+      "grad_norm": 0.4059283137321472,
+      "learning_rate": 2.6612244897959187e-05,
+      "loss": 0.0854,
+      "step": 1720
+    },
+    {
+      "epoch": 11.768707482993197,
+      "grad_norm": 0.11370517313480377,
+      "learning_rate": 2.6476190476190476e-05,
+      "loss": 0.084,
+      "step": 1730
+    },
+    {
+      "epoch": 11.83673469387755,
+      "grad_norm": 6.6930365562438965,
+      "learning_rate": 2.6340136054421773e-05,
+      "loss": 0.082,
+      "step": 1740
+    },
+    {
+      "epoch": 11.904761904761905,
+      "grad_norm": 0.035495854914188385,
+      "learning_rate": 2.620408163265306e-05,
+      "loss": 0.0704,
+      "step": 1750
+    },
+    {
+      "epoch": 11.972789115646258,
+      "grad_norm": 0.19433455169200897,
+      "learning_rate": 2.6068027210884355e-05,
+      "loss": 0.0755,
+      "step": 1760
+    },
+    {
+      "epoch": 12.0,
+      "eval_cer": 0.4090909090909091,
+      "eval_loss": 0.06354419887065887,
+      "eval_runtime": 3.8826,
+      "eval_samples_per_second": 75.466,
+      "eval_steps_per_second": 37.862,
+      "step": 1764
+    },
+    {
+      "epoch": 12.040816326530612,
+      "grad_norm": 0.22618860006332397,
+      "learning_rate": 2.593197278911565e-05,
+      "loss": 0.0842,
+      "step": 1770
+    },
+    {
+      "epoch": 12.108843537414966,
+      "grad_norm": 0.2526053786277771,
+      "learning_rate": 2.5795918367346938e-05,
+      "loss": 0.0257,
+      "step": 1780
+    },
+    {
+      "epoch": 12.17687074829932,
+      "grad_norm": 5.3073649406433105,
+      "learning_rate": 2.5659863945578234e-05,
+      "loss": 0.0723,
+      "step": 1790
+    },
+    {
+      "epoch": 12.244897959183673,
+      "grad_norm": 0.07300838083028793,
+      "learning_rate": 2.5523809523809527e-05,
+      "loss": 0.0447,
+      "step": 1800
+    },
+    {
+      "epoch": 12.312925170068027,
+      "grad_norm": 1.9569120407104492,
+      "learning_rate": 2.5387755102040817e-05,
+      "loss": 0.0437,
+      "step": 1810
+    },
+    {
+      "epoch": 12.380952380952381,
+      "grad_norm": 4.616933822631836,
+      "learning_rate": 2.525170068027211e-05,
+      "loss": 0.0802,
+      "step": 1820
+    },
+    {
+      "epoch": 12.448979591836734,
+      "grad_norm": 0.09218256920576096,
+      "learning_rate": 2.51156462585034e-05,
+      "loss": 0.0345,
+      "step": 1830
+    },
+    {
+      "epoch": 12.517006802721088,
+      "grad_norm": 0.10980120301246643,
+      "learning_rate": 2.4979591836734696e-05,
+      "loss": 0.0167,
+      "step": 1840
+    },
+    {
+      "epoch": 12.585034013605442,
+      "grad_norm": 1.9402213096618652,
+      "learning_rate": 2.4843537414965986e-05,
+      "loss": 0.0189,
+      "step": 1850
+    },
+    {
+      "epoch": 12.653061224489797,
+      "grad_norm": 0.28110960125923157,
+      "learning_rate": 2.4707482993197282e-05,
+      "loss": 0.0939,
+      "step": 1860
+    },
+    {
+      "epoch": 12.72108843537415,
+      "grad_norm": 14.07165813446045,
+      "learning_rate": 2.4571428571428572e-05,
+      "loss": 0.1164,
+      "step": 1870
+    },
+    {
+      "epoch": 12.789115646258503,
+      "grad_norm": 0.09300262480974197,
+      "learning_rate": 2.4435374149659865e-05,
+      "loss": 0.0511,
+      "step": 1880
+    },
+    {
+      "epoch": 12.857142857142858,
+      "grad_norm": 0.08766383677721024,
+      "learning_rate": 2.4299319727891158e-05,
+      "loss": 0.0821,
+      "step": 1890
+    },
+    {
+      "epoch": 12.92517006802721,
+      "grad_norm": 4.915824890136719,
+      "learning_rate": 2.416326530612245e-05,
+      "loss": 0.0425,
+      "step": 1900
+    },
+    {
+      "epoch": 12.993197278911564,
+      "grad_norm": 0.25317126512527466,
+      "learning_rate": 2.4027210884353744e-05,
+      "loss": 0.048,
+      "step": 1910
+    },
+    {
+      "epoch": 13.0,
+      "eval_cer": 0.43813131313131315,
+      "eval_loss": 0.044823333621025085,
+      "eval_runtime": 3.9907,
+      "eval_samples_per_second": 73.42,
+      "eval_steps_per_second": 36.835,
+      "step": 1911
+    },
+    {
+      "epoch": 13.061224489795919,
+      "grad_norm": 11.498345375061035,
+      "learning_rate": 2.3891156462585034e-05,
+      "loss": 0.0573,
+      "step": 1920
+    },
+    {
+      "epoch": 13.129251700680273,
+      "grad_norm": 9.521465301513672,
+      "learning_rate": 2.3755102040816327e-05,
+      "loss": 0.0186,
+      "step": 1930
+    },
+    {
+      "epoch": 13.197278911564625,
+      "grad_norm": 5.737509250640869,
+      "learning_rate": 2.361904761904762e-05,
+      "loss": 0.0189,
+      "step": 1940
+    },
+    {
+      "epoch": 13.26530612244898,
+      "grad_norm": 0.3337570130825043,
+      "learning_rate": 2.3482993197278913e-05,
+      "loss": 0.0249,
+      "step": 1950
+    },
+    {
+      "epoch": 13.333333333333334,
+      "grad_norm": 0.21208225190639496,
+      "learning_rate": 2.3346938775510206e-05,
+      "loss": 0.0266,
+      "step": 1960
+    },
+    {
+      "epoch": 13.401360544217686,
+      "grad_norm": 0.034205980598926544,
+      "learning_rate": 2.3210884353741495e-05,
+      "loss": 0.0062,
+      "step": 1970
+    },
+    {
+      "epoch": 13.46938775510204,
+      "grad_norm": 6.113767623901367,
+      "learning_rate": 2.3074829931972792e-05,
+      "loss": 0.1134,
+      "step": 1980
+    },
+    {
+      "epoch": 13.537414965986395,
+      "grad_norm": 1.1116629838943481,
+      "learning_rate": 2.293877551020408e-05,
+      "loss": 0.0873,
+      "step": 1990
+    },
+    {
+      "epoch": 13.60544217687075,
+      "grad_norm": 8.336064338684082,
+      "learning_rate": 2.2802721088435375e-05,
+      "loss": 0.0285,
+      "step": 2000
+    },
+    {
+      "epoch": 13.673469387755102,
+      "grad_norm": 0.6493708491325378,
+      "learning_rate": 2.2666666666666668e-05,
+      "loss": 0.0107,
+      "step": 2010
+    },
+    {
+      "epoch": 13.741496598639456,
+      "grad_norm": 4.806843280792236,
+      "learning_rate": 2.253061224489796e-05,
+      "loss": 0.0163,
+      "step": 2020
+    },
+    {
+      "epoch": 13.80952380952381,
+      "grad_norm": 0.049966610968112946,
+      "learning_rate": 2.2394557823129254e-05,
+      "loss": 0.01,
+      "step": 2030
+    },
+    {
+      "epoch": 13.877551020408163,
+      "grad_norm": 0.1961314082145691,
+      "learning_rate": 2.2258503401360543e-05,
+      "loss": 0.107,
+      "step": 2040
+    },
+    {
+      "epoch": 13.945578231292517,
+      "grad_norm": 0.04836405813694,
+      "learning_rate": 2.2122448979591836e-05,
+      "loss": 0.0518,
+      "step": 2050
+    },
+    {
+      "epoch": 14.0,
+      "eval_cer": 0.37752525252525254,
+      "eval_loss": 0.04542345553636551,
+      "eval_runtime": 3.7709,
+      "eval_samples_per_second": 77.701,
+      "eval_steps_per_second": 38.983,
+      "step": 2058
+    },
+    {
+      "epoch": 14.013605442176871,
+      "grad_norm": 0.12112589925527573,
+      "learning_rate": 2.1986394557823133e-05,
+      "loss": 0.007,
+      "step": 2060
+    },
+    {
+      "epoch": 14.081632653061224,
+      "grad_norm": 0.18053178489208221,
+      "learning_rate": 2.1850340136054422e-05,
+      "loss": 0.1291,
+      "step": 2070
+    },
+    {
+      "epoch": 14.149659863945578,
+      "grad_norm": 0.2066822201013565,
+      "learning_rate": 2.1714285714285715e-05,
+      "loss": 0.0257,
+      "step": 2080
+    },
+    {
+      "epoch": 14.217687074829932,
+      "grad_norm": 0.11014904081821442,
+      "learning_rate": 2.1578231292517005e-05,
+      "loss": 0.0535,
+      "step": 2090
+    },
+    {
+      "epoch": 14.285714285714286,
+      "grad_norm": 12.59344482421875,
+      "learning_rate": 2.14421768707483e-05,
+      "loss": 0.1287,
+      "step": 2100
+    },
+    {
+      "epoch": 14.353741496598639,
+      "grad_norm": 0.045586470514535904,
+      "learning_rate": 2.1306122448979595e-05,
+      "loss": 0.0348,
+      "step": 2110
+    },
+    {
+      "epoch": 14.421768707482993,
+      "grad_norm": 0.16031715273857117,
+      "learning_rate": 2.1170068027210884e-05,
+      "loss": 0.0664,
+      "step": 2120
+    },
+    {
+      "epoch": 14.489795918367347,
+      "grad_norm": 2.561408281326294,
+      "learning_rate": 2.1034013605442177e-05,
+      "loss": 0.04,
+      "step": 2130
+    },
+    {
+      "epoch": 14.5578231292517,
+      "grad_norm": 0.2670551538467407,
+      "learning_rate": 2.089795918367347e-05,
+      "loss": 0.0092,
+      "step": 2140
+    },
+    {
+      "epoch": 14.625850340136054,
+      "grad_norm": 0.12540097534656525,
+      "learning_rate": 2.0761904761904763e-05,
+      "loss": 0.0111,
+      "step": 2150
+    },
+    {
+      "epoch": 14.693877551020408,
+      "grad_norm": 1.2808445692062378,
+      "learning_rate": 2.0625850340136056e-05,
+      "loss": 0.0595,
+      "step": 2160
+    },
+    {
+      "epoch": 14.761904761904763,
+      "grad_norm": 0.03977341949939728,
+      "learning_rate": 2.0489795918367346e-05,
+      "loss": 0.0437,
+      "step": 2170
+    },
+    {
+      "epoch": 14.829931972789115,
+      "grad_norm": 0.40472060441970825,
+      "learning_rate": 2.0353741496598642e-05,
+      "loss": 0.0268,
+      "step": 2180
+    },
+    {
+      "epoch": 14.89795918367347,
+      "grad_norm": 0.08766451478004456,
+      "learning_rate": 2.0217687074829932e-05,
+      "loss": 0.0072,
+      "step": 2190
+    },
+    {
+      "epoch": 14.965986394557824,
+      "grad_norm": 0.34755828976631165,
+      "learning_rate": 2.0081632653061225e-05,
+      "loss": 0.0482,
+      "step": 2200
+    },
+    {
+      "epoch": 15.0,
+      "eval_cer": 0.38257575757575757,
+      "eval_loss": 0.03393391892313957,
+      "eval_runtime": 3.9624,
+      "eval_samples_per_second": 73.945,
+      "eval_steps_per_second": 37.098,
+      "step": 2205
+    },
+    {
+      "epoch": 15.034013605442176,
+      "grad_norm": 0.07853918522596359,
+      "learning_rate": 1.9945578231292518e-05,
+      "loss": 0.0218,
+      "step": 2210
+    },
+    {
+      "epoch": 15.10204081632653,
+      "grad_norm": 0.08187614381313324,
+      "learning_rate": 1.980952380952381e-05,
+      "loss": 0.0059,
+      "step": 2220
+    },
+    {
+      "epoch": 15.170068027210885,
+      "grad_norm": 0.5369409918785095,
+      "learning_rate": 1.9673469387755104e-05,
+      "loss": 0.0105,
+      "step": 2230
+    },
+    {
+      "epoch": 15.238095238095237,
+      "grad_norm": 0.46228042244911194,
+      "learning_rate": 1.9537414965986394e-05,
+      "loss": 0.0028,
+      "step": 2240
+    },
+    {
+      "epoch": 15.306122448979592,
+      "grad_norm": 0.1829945147037506,
+      "learning_rate": 1.940136054421769e-05,
+      "loss": 0.0355,
+      "step": 2250
+    },
+    {
+      "epoch": 15.374149659863946,
+      "grad_norm": 0.08586379885673523,
+      "learning_rate": 1.926530612244898e-05,
+      "loss": 0.0096,
+      "step": 2260
+    },
+    {
+      "epoch": 15.4421768707483,
+      "grad_norm": 0.13552436232566833,
+      "learning_rate": 1.9129251700680273e-05,
+      "loss": 0.1455,
+      "step": 2270
+    },
+    {
+      "epoch": 15.510204081632653,
+      "grad_norm": 0.3371906876564026,
+      "learning_rate": 1.8993197278911566e-05,
+      "loss": 0.0229,
+      "step": 2280
+    },
+    {
+      "epoch": 15.578231292517007,
+      "grad_norm": 0.03920818492770195,
+      "learning_rate": 1.885714285714286e-05,
+      "loss": 0.0224,
+      "step": 2290
+    },
+    {
+      "epoch": 15.646258503401361,
+      "grad_norm": 0.8000497817993164,
+      "learning_rate": 1.8721088435374152e-05,
+      "loss": 0.0681,
+      "step": 2300
+    },
+    {
+      "epoch": 15.714285714285714,
+      "grad_norm": 0.15928244590759277,
+      "learning_rate": 1.8585034013605442e-05,
+      "loss": 0.0338,
+      "step": 2310
+    },
+    {
+      "epoch": 15.782312925170068,
+      "grad_norm": 2.3006467819213867,
+      "learning_rate": 1.8448979591836735e-05,
+      "loss": 0.0085,
+      "step": 2320
+    },
+    {
+      "epoch": 15.850340136054422,
+      "grad_norm": 0.3312649726867676,
+      "learning_rate": 1.8312925170068028e-05,
+      "loss": 0.0015,
+      "step": 2330
+    },
+    {
+      "epoch": 15.918367346938776,
+      "grad_norm": 11.605361938476562,
+      "learning_rate": 1.817687074829932e-05,
+      "loss": 0.0616,
+      "step": 2340
+    },
+    {
+      "epoch": 15.986394557823129,
+      "grad_norm": 0.06783591210842133,
+      "learning_rate": 1.8040816326530614e-05,
+      "loss": 0.0061,
+      "step": 2350
+    },
+    {
+      "epoch": 16.0,
+      "eval_cer": 0.36742424242424243,
+      "eval_loss": 0.01737603358924389,
+      "eval_runtime": 3.7608,
+      "eval_samples_per_second": 77.91,
+      "eval_steps_per_second": 39.088,
+      "step": 2352
+    },
+    {
+      "epoch": 16.05442176870748,
+      "grad_norm": 0.03763847053050995,
+      "learning_rate": 1.7904761904761904e-05,
+      "loss": 0.018,
+      "step": 2360
+    },
+    {
+      "epoch": 16.122448979591837,
+      "grad_norm": 1.681272268295288,
+      "learning_rate": 1.77687074829932e-05,
+      "loss": 0.0158,
+      "step": 2370
+    },
+    {
+      "epoch": 16.19047619047619,
+      "grad_norm": 0.31114622950553894,
+      "learning_rate": 1.763265306122449e-05,
+      "loss": 0.0045,
+      "step": 2380
+    },
+    {
+      "epoch": 16.258503401360546,
+      "grad_norm": 3.3073906898498535,
+      "learning_rate": 1.7496598639455783e-05,
+      "loss": 0.0266,
+      "step": 2390
+    },
+    {
+      "epoch": 16.3265306122449,
+      "grad_norm": 0.05872774124145508,
+      "learning_rate": 1.7360544217687076e-05,
+      "loss": 0.0094,
+      "step": 2400
+    },
+    {
+      "epoch": 16.39455782312925,
+      "grad_norm": 0.36872556805610657,
+      "learning_rate": 1.722448979591837e-05,
+      "loss": 0.0031,
+      "step": 2410
+    },
+    {
+      "epoch": 16.462585034013607,
+      "grad_norm": 0.18953841924667358,
+      "learning_rate": 1.7088435374149662e-05,
+      "loss": 0.0072,
+      "step": 2420
+    },
+    {
+      "epoch": 16.53061224489796,
+      "grad_norm": 0.053531669080257416,
+      "learning_rate": 1.695238095238095e-05,
+      "loss": 0.0214,
+      "step": 2430
+    },
+    {
+      "epoch": 16.598639455782312,
+      "grad_norm": 0.9419485926628113,
+      "learning_rate": 1.6816326530612244e-05,
+      "loss": 0.0311,
+      "step": 2440
+    },
+    {
+      "epoch": 16.666666666666668,
+      "grad_norm": 0.10363417118787766,
+      "learning_rate": 1.668027210884354e-05,
+      "loss": 0.0145,
+      "step": 2450
+    },
+    {
+      "epoch": 16.73469387755102,
+      "grad_norm": 11.27441692352295,
+      "learning_rate": 1.654421768707483e-05,
+      "loss": 0.0174,
+      "step": 2460
+    },
+    {
+      "epoch": 16.802721088435373,
+      "grad_norm": 0.07533001154661179,
+      "learning_rate": 1.6408163265306124e-05,
+      "loss": 0.0043,
+      "step": 2470
+    },
+    {
+      "epoch": 16.87074829931973,
+      "grad_norm": 0.09791432321071625,
+      "learning_rate": 1.6272108843537413e-05,
+      "loss": 0.0192,
+      "step": 2480
+    },
+    {
+      "epoch": 16.93877551020408,
+      "grad_norm": 1.773054838180542,
+      "learning_rate": 1.613605442176871e-05,
+      "loss": 0.0846,
+      "step": 2490
+    },
+    {
+      "epoch": 17.0,
+      "eval_cer": 0.22853535353535354,
+      "eval_loss": 0.016882039606571198,
+      "eval_runtime": 3.9198,
+      "eval_samples_per_second": 74.749,
+      "eval_steps_per_second": 37.502,
+      "step": 2499
+    },
+    {
+      "epoch": 17.006802721088434,
+      "grad_norm": 0.08635395020246506,
+      "learning_rate": 1.6000000000000003e-05,
+      "loss": 0.0117,
+      "step": 2500
+    },
+    {
+      "epoch": 17.07482993197279,
+      "grad_norm": 0.04216604679822922,
+      "learning_rate": 1.5863945578231292e-05,
+      "loss": 0.0075,
+      "step": 2510
+    },
+    {
+      "epoch": 17.142857142857142,
+      "grad_norm": 0.3129735589027405,
+      "learning_rate": 1.5727891156462585e-05,
+      "loss": 0.0024,
+      "step": 2520
+    },
+    {
+      "epoch": 17.2108843537415,
+      "grad_norm": 0.0337909497320652,
+      "learning_rate": 1.559183673469388e-05,
+      "loss": 0.0032,
+      "step": 2530
+    },
+    {
+      "epoch": 17.27891156462585,
+      "grad_norm": 0.3642733097076416,
+      "learning_rate": 1.545578231292517e-05,
+      "loss": 0.1344,
+      "step": 2540
+    },
+    {
+      "epoch": 17.346938775510203,
+      "grad_norm": 0.06059624254703522,
+      "learning_rate": 1.5319727891156464e-05,
+      "loss": 0.0039,
+      "step": 2550
+    },
+    {
+      "epoch": 17.41496598639456,
+      "grad_norm": 0.5465549826622009,
+      "learning_rate": 1.5183673469387754e-05,
+      "loss": 0.0395,
+      "step": 2560
+    },
+    {
+      "epoch": 17.482993197278912,
+      "grad_norm": 0.048258326947689056,
+      "learning_rate": 1.5047619047619049e-05,
+      "loss": 0.0226,
+      "step": 2570
+    },
+    {
+      "epoch": 17.551020408163264,
+      "grad_norm": 0.5764261484146118,
+      "learning_rate": 1.4911564625850342e-05,
+      "loss": 0.0348,
+      "step": 2580
+    },
+    {
+      "epoch": 17.61904761904762,
+      "grad_norm": 1.802079439163208,
+      "learning_rate": 1.4775510204081633e-05,
+      "loss": 0.004,
+      "step": 2590
+    },
+    {
+      "epoch": 17.687074829931973,
+      "grad_norm": 0.03979931399226189,
+      "learning_rate": 1.4639455782312925e-05,
+      "loss": 0.004,
+      "step": 2600
+    },
+    {
+      "epoch": 17.755102040816325,
+      "grad_norm": 0.25388839840888977,
+      "learning_rate": 1.450340136054422e-05,
+      "loss": 0.0039,
+      "step": 2610
+    },
+    {
+      "epoch": 17.82312925170068,
+      "grad_norm": 0.44963565468788147,
+      "learning_rate": 1.436734693877551e-05,
+      "loss": 0.006,
+      "step": 2620
+    },
+    {
+      "epoch": 17.891156462585034,
+      "grad_norm": 0.0887552797794342,
+      "learning_rate": 1.4231292517006804e-05,
+      "loss": 0.0042,
+      "step": 2630
+    },
+    {
+      "epoch": 17.959183673469386,
+      "grad_norm": 0.11289983987808228,
+      "learning_rate": 1.4095238095238095e-05,
+      "loss": 0.0034,
+      "step": 2640
+    },
+    {
+      "epoch": 18.0,
+      "eval_cer": 0.24242424242424243,
+      "eval_loss": 0.013762996532022953,
+      "eval_runtime": 3.9761,
+      "eval_samples_per_second": 73.691,
+      "eval_steps_per_second": 36.971,
+      "step": 2646
+    },
+    {
+      "epoch": 18.027210884353742,
+      "grad_norm": 0.06268062442541122,
+      "learning_rate": 1.395918367346939e-05,
+      "loss": 0.0031,
+      "step": 2650
+    },
+    {
+      "epoch": 18.095238095238095,
+      "grad_norm": 0.03095332533121109,
+      "learning_rate": 1.3823129251700681e-05,
+      "loss": 0.0356,
+      "step": 2660
+    },
+    {
+      "epoch": 18.163265306122447,
+      "grad_norm": 0.6670628786087036,
+      "learning_rate": 1.3687074829931972e-05,
+      "loss": 0.004,
+      "step": 2670
+    },
+    {
+      "epoch": 18.231292517006803,
+      "grad_norm": 0.09079564362764359,
+      "learning_rate": 1.3551020408163265e-05,
+      "loss": 0.0036,
+      "step": 2680
+    },
+    {
+      "epoch": 18.299319727891156,
+      "grad_norm": 0.17814789712429047,
+      "learning_rate": 1.3414965986394558e-05,
+      "loss": 0.0016,
+      "step": 2690
+    },
+    {
+      "epoch": 18.367346938775512,
+      "grad_norm": 0.053088486194610596,
+      "learning_rate": 1.3278911564625852e-05,
+      "loss": 0.0037,
+      "step": 2700
+    },
+    {
+      "epoch": 18.435374149659864,
+      "grad_norm": 0.05287722125649452,
+      "learning_rate": 1.3142857142857143e-05,
+      "loss": 0.0031,
+      "step": 2710
+    },
+    {
+      "epoch": 18.503401360544217,
+      "grad_norm": 0.22168047726154327,
+      "learning_rate": 1.3006802721088434e-05,
+      "loss": 0.003,
+      "step": 2720
+    },
+    {
+      "epoch": 18.571428571428573,
+      "grad_norm": 0.2615916430950165,
+      "learning_rate": 1.2870748299319729e-05,
+      "loss": 0.0022,
+      "step": 2730
+    },
+    {
+      "epoch": 18.639455782312925,
+      "grad_norm": 0.04484458267688751,
+      "learning_rate": 1.273469387755102e-05,
+      "loss": 0.083,
+      "step": 2740
+    },
+    {
+      "epoch": 18.707482993197278,
+      "grad_norm": 0.4530847370624542,
+      "learning_rate": 1.2598639455782313e-05,
+      "loss": 0.0034,
+      "step": 2750
+    },
+    {
+      "epoch": 18.775510204081634,
+      "grad_norm": 0.11792109161615372,
+      "learning_rate": 1.2462585034013606e-05,
+      "loss": 0.0295,
+      "step": 2760
+    },
+    {
+      "epoch": 18.843537414965986,
+      "grad_norm": 0.049426767975091934,
+      "learning_rate": 1.2326530612244898e-05,
+      "loss": 0.0019,
+      "step": 2770
+    },
+    {
+      "epoch": 18.91156462585034,
+      "grad_norm": 0.04500193893909454,
+      "learning_rate": 1.219047619047619e-05,
+      "loss": 0.0134,
+      "step": 2780
+    },
+    {
+      "epoch": 18.979591836734695,
+      "grad_norm": 0.14980462193489075,
+      "learning_rate": 1.2054421768707484e-05,
+      "loss": 0.0032,
+      "step": 2790
+    },
+    {
+      "epoch": 19.0,
+      "eval_cer": 0.2159090909090909,
+      "eval_loss": 0.012968610972166061,
+      "eval_runtime": 3.6907,
+      "eval_samples_per_second": 79.389,
+      "eval_steps_per_second": 39.83,
+      "step": 2793
+    },
+    {
+      "epoch": 19.047619047619047,
+      "grad_norm": 0.5596031546592712,
+      "learning_rate": 1.1918367346938777e-05,
+      "loss": 0.004,
+      "step": 2800
+    },
+    {
+      "epoch": 19.1156462585034,
+      "grad_norm": 0.09450047463178635,
+      "learning_rate": 1.178231292517007e-05,
+      "loss": 0.0176,
+      "step": 2810
+    },
+    {
+      "epoch": 19.183673469387756,
+      "grad_norm": 0.030270878225564957,
+      "learning_rate": 1.1646258503401361e-05,
+      "loss": 0.0031,
+      "step": 2820
+    },
+    {
+      "epoch": 19.25170068027211,
+      "grad_norm": 0.5096073746681213,
+      "learning_rate": 1.1510204081632654e-05,
+      "loss": 0.0231,
+      "step": 2830
+    },
+    {
+      "epoch": 19.31972789115646,
+      "grad_norm": 0.2736698389053345,
+      "learning_rate": 1.1374149659863946e-05,
+      "loss": 0.0016,
+      "step": 2840
+    },
+    {
+      "epoch": 19.387755102040817,
+      "grad_norm": 0.06535348296165466,
+      "learning_rate": 1.1238095238095239e-05,
+      "loss": 0.0013,
+      "step": 2850
+    },
+    {
+      "epoch": 19.45578231292517,
+      "grad_norm": 0.0859360322356224,
+      "learning_rate": 1.1102040816326532e-05,
+      "loss": 0.003,
+      "step": 2860
+    },
+    {
+      "epoch": 19.523809523809526,
+      "grad_norm": 0.037795525044202805,
+      "learning_rate": 1.0965986394557825e-05,
+      "loss": 0.0026,
+      "step": 2870
+    },
+    {
+      "epoch": 19.591836734693878,
+      "grad_norm": 1.3488638401031494,
+      "learning_rate": 1.0829931972789116e-05,
+      "loss": 0.004,
+      "step": 2880
+    },
+    {
+      "epoch": 19.65986394557823,
+      "grad_norm": 0.05746370553970337,
+      "learning_rate": 1.0693877551020409e-05,
+      "loss": 0.0192,
+      "step": 2890
+    },
+    {
+      "epoch": 19.727891156462587,
+      "grad_norm": 0.025979384779930115,
+      "learning_rate": 1.05578231292517e-05,
+      "loss": 0.0091,
+      "step": 2900
+    },
+    {
+      "epoch": 19.79591836734694,
+      "grad_norm": 4.972421646118164,
+      "learning_rate": 1.0421768707482993e-05,
+      "loss": 0.0082,
+      "step": 2910
+    },
+    {
+      "epoch": 19.86394557823129,
+      "grad_norm": 0.49525704979896545,
+      "learning_rate": 1.0285714285714286e-05,
+      "loss": 0.0034,
+      "step": 2920
+    },
+    {
+      "epoch": 19.931972789115648,
+      "grad_norm": 0.02950323186814785,
+      "learning_rate": 1.014965986394558e-05,
+      "loss": 0.07,
+      "step": 2930
+    },
+    {
+      "epoch": 20.0,
+      "grad_norm": 0.047243040055036545,
+      "learning_rate": 1.001360544217687e-05,
+      "loss": 0.0019,
+      "step": 2940
+    },
+    {
+      "epoch": 20.0,
+      "eval_cer": 0.30176767676767674,
+      "eval_loss": 0.011288419365882874,
+      "eval_runtime": 4.0348,
+      "eval_samples_per_second": 72.618,
+      "eval_steps_per_second": 36.433,
+      "step": 2940
+    },
+    {
+      "epoch": 20.068027210884352,
+      "grad_norm": 8.58004093170166,
+      "learning_rate": 9.877551020408164e-06,
+      "loss": 0.02,
+      "step": 2950
+    },
+    {
+      "epoch": 20.13605442176871,
+      "grad_norm": 0.2544482946395874,
+      "learning_rate": 9.741496598639455e-06,
+      "loss": 0.0156,
+      "step": 2960
+    },
+    {
+      "epoch": 20.20408163265306,
+      "grad_norm": 0.5715163350105286,
+      "learning_rate": 9.60544217687075e-06,
+      "loss": 0.0027,
+      "step": 2970
+    },
+    {
+      "epoch": 20.272108843537413,
+      "grad_norm": 0.134610116481781,
+      "learning_rate": 9.469387755102041e-06,
+      "loss": 0.0394,
+      "step": 2980
+    },
+    {
+      "epoch": 20.34013605442177,
+      "grad_norm": 0.23469507694244385,
+      "learning_rate": 9.333333333333334e-06,
+      "loss": 0.0142,
+      "step": 2990
+    },
+    {
+      "epoch": 20.408163265306122,
+      "grad_norm": 0.19277207553386688,
+      "learning_rate": 9.197278911564626e-06,
+      "loss": 0.0214,
+      "step": 3000
+    },
+    {
+      "epoch": 20.476190476190474,
+      "grad_norm": 0.04216855764389038,
+      "learning_rate": 9.061224489795919e-06,
+      "loss": 0.0014,
+      "step": 3010
+    },
+    {
+      "epoch": 20.54421768707483,
+      "grad_norm": 0.02860959619283676,
+      "learning_rate": 8.925170068027212e-06,
+      "loss": 0.0049,
+      "step": 3020
+    },
+    {
+      "epoch": 20.612244897959183,
+      "grad_norm": 0.38055145740509033,
+      "learning_rate": 8.789115646258505e-06,
+      "loss": 0.0193,
+      "step": 3030
+    },
+    {
+      "epoch": 20.68027210884354,
+      "grad_norm": 0.034134916961193085,
+      "learning_rate": 8.653061224489796e-06,
+      "loss": 0.0015,
+      "step": 3040
+    },
+    {
+      "epoch": 20.74829931972789,
+      "grad_norm": 0.6501132845878601,
+      "learning_rate": 8.517006802721089e-06,
+      "loss": 0.003,
+      "step": 3050
+    },
+    {
+      "epoch": 20.816326530612244,
+      "grad_norm": 0.26927316188812256,
+      "learning_rate": 8.38095238095238e-06,
+      "loss": 0.0064,
+      "step": 3060
+    },
+    {
+      "epoch": 20.8843537414966,
+      "grad_norm": 0.308063805103302,
+      "learning_rate": 8.244897959183674e-06,
+      "loss": 0.0171,
+      "step": 3070
+    },
+    {
+      "epoch": 20.952380952380953,
+      "grad_norm": 0.0912749320268631,
+      "learning_rate": 8.108843537414967e-06,
+      "loss": 0.0034,
+      "step": 3080
+    },
+    {
+      "epoch": 21.0,
+      "eval_cer": 0.23863636363636365,
+      "eval_loss": 0.009314554743468761,
+      "eval_runtime": 3.7562,
+      "eval_samples_per_second": 78.005,
+      "eval_steps_per_second": 39.135,
+      "step": 3087
+    },
+    {
+      "epoch": 21.020408163265305,
+      "grad_norm": 0.031063944101333618,
+      "learning_rate": 7.97278911564626e-06,
+      "loss": 0.0025,
+      "step": 3090
+    },
+    {
+      "epoch": 21.08843537414966,
+      "grad_norm": 0.45678919553756714,
+      "learning_rate": 7.836734693877551e-06,
+      "loss": 0.0017,
+      "step": 3100
+    },
+    {
+      "epoch": 21.156462585034014,
+      "grad_norm": 0.06373850256204605,
+      "learning_rate": 7.700680272108844e-06,
+      "loss": 0.0203,
+      "step": 3110
+    },
+    {
+      "epoch": 21.224489795918366,
+      "grad_norm": 0.04051206260919571,
+      "learning_rate": 7.564625850340136e-06,
+      "loss": 0.0028,
+      "step": 3120
+    },
+    {
+      "epoch": 21.292517006802722,
+      "grad_norm": 0.20778831839561462,
+      "learning_rate": 7.428571428571429e-06,
+      "loss": 0.0032,
+      "step": 3130
+    },
+    {
+      "epoch": 21.360544217687075,
+      "grad_norm": 0.23982657492160797,
+      "learning_rate": 7.292517006802721e-06,
+      "loss": 0.0097,
+      "step": 3140
+    },
+    {
+      "epoch": 21.428571428571427,
+      "grad_norm": 0.30359897017478943,
+      "learning_rate": 7.1564625850340144e-06,
+      "loss": 0.002,
+      "step": 3150
+    },
+    {
+      "epoch": 21.496598639455783,
+      "grad_norm": 0.844930112361908,
+      "learning_rate": 7.020408163265306e-06,
+      "loss": 0.064,
+      "step": 3160
+    },
+    {
+      "epoch": 21.564625850340136,
+      "grad_norm": 0.2660425305366516,
+      "learning_rate": 6.884353741496599e-06,
+      "loss": 0.011,
+      "step": 3170
+    },
+    {
+      "epoch": 21.632653061224488,
+      "grad_norm": 0.1279953122138977,
+      "learning_rate": 6.748299319727891e-06,
+      "loss": 0.0027,
+      "step": 3180
+    },
+    {
+      "epoch": 21.700680272108844,
+      "grad_norm": 0.05603710934519768,
+      "learning_rate": 6.612244897959184e-06,
+      "loss": 0.0012,
+      "step": 3190
+    },
+    {
+      "epoch": 21.768707482993197,
+      "grad_norm": 0.05168928578495979,
+      "learning_rate": 6.476190476190476e-06,
+      "loss": 0.0176,
+      "step": 3200
+    },
+    {
+      "epoch": 21.836734693877553,
+      "grad_norm": 0.046198636293411255,
+      "learning_rate": 6.340136054421769e-06,
+      "loss": 0.0013,
+      "step": 3210
+    },
+    {
+      "epoch": 21.904761904761905,
+      "grad_norm": 0.042502377182245255,
+      "learning_rate": 6.2040816326530614e-06,
+      "loss": 0.0015,
+      "step": 3220
+    },
+    {
+      "epoch": 21.972789115646258,
+      "grad_norm": 0.24547749757766724,
+      "learning_rate": 6.0680272108843545e-06,
+      "loss": 0.0023,
+      "step": 3230
+    },
+    {
+      "epoch": 22.0,
+      "eval_cer": 0.23106060606060605,
+      "eval_loss": 0.009045995771884918,
+      "eval_runtime": 3.8812,
+      "eval_samples_per_second": 75.492,
+      "eval_steps_per_second": 37.875,
+      "step": 3234
+    },
+    {
+      "epoch": 22.040816326530614,
+      "grad_norm": 1.8699299097061157,
+      "learning_rate": 5.931972789115647e-06,
+      "loss": 0.0095,
+      "step": 3240
+    },
+    {
+      "epoch": 22.108843537414966,
+      "grad_norm": 0.028658084571361542,
+      "learning_rate": 5.795918367346939e-06,
+      "loss": 0.002,
+      "step": 3250
+    },
+    {
+      "epoch": 22.17687074829932,
+      "grad_norm": 0.11185970157384872,
+      "learning_rate": 5.659863945578232e-06,
+      "loss": 0.0139,
+      "step": 3260
+    },
+    {
+      "epoch": 22.244897959183675,
+      "grad_norm": 0.08078885078430176,
+      "learning_rate": 5.523809523809524e-06,
+      "loss": 0.0093,
+      "step": 3270
+    },
+    {
+      "epoch": 22.312925170068027,
+      "grad_norm": 0.033784542232751846,
+      "learning_rate": 5.387755102040816e-06,
+      "loss": 0.0035,
+      "step": 3280
+    },
+    {
+      "epoch": 22.38095238095238,
+      "grad_norm": 0.04999591037631035,
+      "learning_rate": 5.251700680272109e-06,
+      "loss": 0.0158,
+      "step": 3290
+    },
+    {
+      "epoch": 22.448979591836736,
+      "grad_norm": 0.47869572043418884,
+      "learning_rate": 5.1156462585034015e-06,
+      "loss": 0.002,
+      "step": 3300
+    },
+    {
+      "epoch": 22.517006802721088,
+      "grad_norm": 0.5939333438873291,
+      "learning_rate": 4.9795918367346945e-06,
+      "loss": 0.0025,
+      "step": 3310
+    },
+    {
+      "epoch": 22.58503401360544,
+      "grad_norm": 0.02597820572555065,
+      "learning_rate": 4.843537414965987e-06,
+      "loss": 0.017,
+      "step": 3320
+    },
+    {
+      "epoch": 22.653061224489797,
+      "grad_norm": 0.06343343108892441,
+      "learning_rate": 4.707482993197279e-06,
+      "loss": 0.0414,
+      "step": 3330
+    },
+    {
+      "epoch": 22.72108843537415,
+      "grad_norm": 0.40962278842926025,
+      "learning_rate": 4.571428571428572e-06,
+      "loss": 0.0114,
+      "step": 3340
+    },
+    {
+      "epoch": 22.7891156462585,
+      "grad_norm": 0.29765334725379944,
+      "learning_rate": 4.435374149659864e-06,
+      "loss": 0.0023,
+      "step": 3350
+    },
+    {
+      "epoch": 22.857142857142858,
+      "grad_norm": 0.17841386795043945,
+      "learning_rate": 4.299319727891156e-06,
+      "loss": 0.0016,
+      "step": 3360
+    },
+    {
+      "epoch": 22.92517006802721,
+      "grad_norm": 0.44667163491249084,
+      "learning_rate": 4.163265306122449e-06,
+      "loss": 0.0021,
+      "step": 3370
+    },
+    {
+      "epoch": 22.993197278911566,
+      "grad_norm": 0.19756975769996643,
+      "learning_rate": 4.0272108843537416e-06,
+      "loss": 0.0073,
+      "step": 3380
+    },
+    {
+      "epoch": 23.0,
+      "eval_cer": 0.23737373737373738,
+      "eval_loss": 0.008361349813640118,
+      "eval_runtime": 3.9088,
+      "eval_samples_per_second": 74.958,
+      "eval_steps_per_second": 37.607,
+      "step": 3381
+    },
+    {
+      "epoch": 23.06122448979592,
+      "grad_norm": 4.8710503578186035,
+      "learning_rate": 3.891156462585034e-06,
+      "loss": 0.0383,
+      "step": 3390
+    },
+    {
+      "epoch": 23.12925170068027,
+      "grad_norm": 0.05327881500124931,
+      "learning_rate": 3.7551020408163268e-06,
+      "loss": 0.0026,
+      "step": 3400
+    },
+    {
+      "epoch": 23.197278911564627,
+      "grad_norm": 0.4828534722328186,
+      "learning_rate": 3.619047619047619e-06,
+      "loss": 0.0024,
+      "step": 3410
+    },
+    {
+      "epoch": 23.26530612244898,
+      "grad_norm": 0.03481818363070488,
+      "learning_rate": 3.4829931972789116e-06,
+      "loss": 0.0068,
+      "step": 3420
+    },
+    {
+      "epoch": 23.333333333333332,
+      "grad_norm": 0.19071730971336365,
+      "learning_rate": 3.346938775510204e-06,
+      "loss": 0.0171,
+      "step": 3430
+    },
+    {
+      "epoch": 23.401360544217688,
+      "grad_norm": 0.08115135878324509,
+      "learning_rate": 3.210884353741497e-06,
+      "loss": 0.0015,
+      "step": 3440
+    },
+    {
+      "epoch": 23.46938775510204,
+      "grad_norm": 0.13966763019561768,
+      "learning_rate": 3.074829931972789e-06,
+      "loss": 0.0309,
+      "step": 3450
+    },
+    {
+      "epoch": 23.537414965986393,
+      "grad_norm": 0.08014482259750366,
+      "learning_rate": 2.9387755102040816e-06,
+      "loss": 0.0028,
+      "step": 3460
+    },
+    {
+      "epoch": 23.60544217687075,
+      "grad_norm": 0.7266091108322144,
+      "learning_rate": 2.8027210884353742e-06,
+      "loss": 0.0019,
+      "step": 3470
+    },
+    {
+      "epoch": 23.6734693877551,
+      "grad_norm": 0.763943076133728,
+      "learning_rate": 2.666666666666667e-06,
+      "loss": 0.0029,
+      "step": 3480
+    },
+    {
+      "epoch": 23.741496598639454,
+      "grad_norm": 0.20366428792476654,
+      "learning_rate": 2.5306122448979594e-06,
+      "loss": 0.0077,
+      "step": 3490
+    },
+    {
+      "epoch": 23.80952380952381,
+      "grad_norm": 0.06424231082201004,
+      "learning_rate": 2.394557823129252e-06,
+      "loss": 0.0048,
+      "step": 3500
+    },
+    {
+      "epoch": 23.877551020408163,
+      "grad_norm": 0.0471784844994545,
+      "learning_rate": 2.2585034013605447e-06,
+      "loss": 0.0027,
+      "step": 3510
+    },
+    {
+      "epoch": 23.94557823129252,
+      "grad_norm": 0.6746675968170166,
+      "learning_rate": 2.122448979591837e-06,
+      "loss": 0.0022,
+      "step": 3520
+    },
+    {
+      "epoch": 24.0,
+      "eval_cer": 0.2702020202020202,
+      "eval_loss": 0.008024842478334904,
+      "eval_runtime": 3.9491,
+      "eval_samples_per_second": 74.195,
+      "eval_steps_per_second": 37.224,
+      "step": 3528
+    },
+    {
+      "epoch": 24.01360544217687,
+      "grad_norm": 0.248748779296875,
+      "learning_rate": 1.9863945578231295e-06,
+      "loss": 0.0013,
+      "step": 3530
+    },
+    {
+      "epoch": 24.081632653061224,
+      "grad_norm": 5.284445762634277,
+      "learning_rate": 1.8503401360544219e-06,
+      "loss": 0.0097,
+      "step": 3540
+    },
+    {
+      "epoch": 24.14965986394558,
+      "grad_norm": 0.07442311942577362,
+      "learning_rate": 1.7142857142857145e-06,
+      "loss": 0.011,
+      "step": 3550
+    },
+    {
+      "epoch": 24.217687074829932,
+      "grad_norm": 0.1644800305366516,
+      "learning_rate": 1.5782312925170069e-06,
+      "loss": 0.0014,
+      "step": 3560
+    },
+    {
+      "epoch": 24.285714285714285,
+      "grad_norm": 0.05962975695729256,
+      "learning_rate": 1.4421768707482995e-06,
+      "loss": 0.0018,
+      "step": 3570
+    },
+    {
+      "epoch": 24.35374149659864,
+      "grad_norm": 0.039682451635599136,
+      "learning_rate": 1.306122448979592e-06,
+      "loss": 0.0025,
+      "step": 3580
+    },
+    {
+      "epoch": 24.421768707482993,
+      "grad_norm": 0.0817071795463562,
+      "learning_rate": 1.1700680272108845e-06,
+      "loss": 0.0032,
+      "step": 3590
+    },
+    {
+      "epoch": 24.489795918367346,
+      "grad_norm": 0.07747264206409454,
+      "learning_rate": 1.034013605442177e-06,
+      "loss": 0.015,
+      "step": 3600
+    },
+    {
+      "epoch": 24.5578231292517,
+      "grad_norm": 0.04547140747308731,
+      "learning_rate": 8.979591836734694e-07,
+      "loss": 0.0015,
+      "step": 3610
+    },
+    {
+      "epoch": 24.625850340136054,
+      "grad_norm": 0.04727374389767647,
+      "learning_rate": 7.619047619047619e-07,
+      "loss": 0.0023,
+      "step": 3620
+    },
+    {
+      "epoch": 24.693877551020407,
+      "grad_norm": 0.14271779358386993,
+      "learning_rate": 6.258503401360544e-07,
+      "loss": 0.0025,
+      "step": 3630
+    },
+    {
+      "epoch": 24.761904761904763,
+      "grad_norm": 0.4749351441860199,
+      "learning_rate": 4.897959183673469e-07,
+      "loss": 0.0026,
+      "step": 3640
+    },
+    {
+      "epoch": 24.829931972789115,
+      "grad_norm": 10.92783260345459,
+      "learning_rate": 3.537414965986395e-07,
+      "loss": 0.0217,
+      "step": 3650
+    },
+    {
+      "epoch": 24.897959183673468,
+      "grad_norm": 0.14225248992443085,
+      "learning_rate": 2.1768707482993197e-07,
+      "loss": 0.0016,
+      "step": 3660
+    },
+    {
+      "epoch": 24.965986394557824,
+      "grad_norm": 0.06080883741378784,
+      "learning_rate": 8.16326530612245e-08,
+      "loss": 0.0391,
+      "step": 3670
+    },
+    {
+      "epoch": 25.0,
+      "eval_cer": 0.26515151515151514,
+      "eval_loss": 0.007971594110131264,
+      "eval_runtime": 3.9963,
+      "eval_samples_per_second": 73.317,
+      "eval_steps_per_second": 36.784,
+      "step": 3675
+    }
+  ],
+  "logging_steps": 10,
+  "max_steps": 3675,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 25,
+  "save_steps": 500,
+  "stateful_callbacks": {
+    "TrainerControl": {
+      "args": {
+        "should_epoch_stop": false,
+        "should_evaluate": false,
+        "should_log": false,
+        "should_save": true,
+        "should_training_stop": true
+      },
+      "attributes": {}
+    }
+  },
+  "total_flos": 5.759922930951168e+17,
+  "train_batch_size": 2,
+  "trial_name": null,
+  "trial_params": null
+}

draft_computation/ocr/ocr_model_output/checkpoint-441/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8d8686ca1447cb934c17499be896c358a24d6e284b3ea5081fb360b7d8be171
+size 5713

draft_computation/ocr/text_dataset/annotations.json

@@ -0,0 +1,295 @@
+{
+    "20250901_110721_523742_0_77883344-c895-435f-ad6a-d53f4e90fdcd.png": "14m",
+    "20250901_110721_523742_1_d135a15f-406a-41e1-aa2e-1075310998f1.png": "13m",
+    "20250901_110721_531767_2_62f4702c-e9a8-461d-9bf0-33141bc68dc5.png": "12m",
+    "20250901_110721_539904_-1_7e51008c-1efe-474e-9622-bb7bc67faf22.png": "12m",
+    "20250901_110722_323657_0_e4f10b40-1499-4797-8231-4d473f96e6d7.png": "14m",
+    "20250901_110722_327428_1_8f722716-1f47-43ed-9699-af34b59b02ea.png": "13m",
+    "20250901_110722_327428_3_ea8bf041-6248-4211-81b7-0b0fcfe66c60.png": "12m",
+    "20250901_110722_335742_-1_278ac5a9-360a-400f-b90d-a5ed8720e5c8.png": "12m",
+    "20250901_110723_106464_0_671f5b06-ea61-4772-887f-3c877568a98c.png": "14m",
+    "20250901_110723_106464_1_ddf150d8-c885-44cd-a263-006516f56810.png": "13m",
+    "20250901_110723_114490_2_7fba45f1-6a56-423d-b26c-3e5f510e8fcc.png": "12m",
+    "20250901_110723_122149_-1_8d6f8f16-712b-422b-93e1-0a2f01f6bd34.png": "12m",
+    "20250901_110724_038727_0_097ae6d1-966c-48c5-a4d0-5dbc565defc1.png": "14m",
+    "20250901_110724_046664_1_7aa3f37d-abc6-44db-a7c1-d572c0568842.png": "13m",
+    "20250901_110724_048915_3_65c67748-4408-481f-9570-4665ac851578.png": "12m",
+    "20250901_110724_057310_-1_7add8a33-51be-46bb-be74-eb5d763f6b53.png": "12m",
+    "20250901_110724_910973_0_5808a60e-a0cc-497a-9fad-4720aa3e06a9.png": "14m",
+    "20250901_110724_910973_1_f867928e-3317-4123-a48d-3966489eefac.png": "13m",
+    "20250901_110724_919454_2_0184cc25-dd62-4505-ae21-aacfe8e60661.png": "12m",
+    "20250901_110724_927618_-1_c8be306e-7800-49c8-b237-2704f9f68dca.png": "12m",
+    "20250901_110725_861849_0_277ca2b6-7962-48a4-a7b1-a81f0c1aaa66.png": "14m",
+    "20250901_110725_868310_1_17f2e9ed-ec58-4c28-ab78-96dd5952bed5.png": "13m",
+    "20250901_110725_872233_2_34a6cee8-67a5-44a5-9a57-f0eedd987627.png": "12m",
+    "20250901_110725_876757_-1_56cdf980-683e-4068-b9a5-38b253addc2b.png": "12m",
+    "20250901_110726_631739_0_be1d9991-2c0e-4681-a7de-db23c3807ef5.png": "13m",
+    "20250901_110726_631739_1_cb01fdd1-0590-4e74-81e3-494c2164652c.png": "14m",
+    "20250901_110726_640094_2_ac70a2c8-e23c-44bb-8ca9-1e3a49016ee5.png": "12m",
+    "20250901_110726_650578_-1_f55a4311-325a-4c2c-93b4-ad5a5312795b.png": "12m",
+    "20250901_110727_472075_0_ace3d469-c961-4b01-811b-2a1ee3cc5c21.png": "14m",
+    "20250901_110727_474716_1_68403705-fd34-4d6e-8130-525080aee7ef.png": "13m",
+    "20250901_110727_474716_2_31822346-99d4-4a9a-bd59-c14986f9bf2f.png": "12m",
+    "20250901_110727_488163_-1_4e5bbe3e-eaca-4275-88b7-74065bafc709.png": "12m",
+    "20250901_110728_317026_0_151a2d4b-c0ba-43f1-9d77-733b861d681b.png": "14m",
+    "20250901_110728_322467_1_147b49c5-0542-4f33-bbd0-41891793af34.png": "13m",
+    "20250901_110728_325279_-1_9cb3fc8e-e496-4db2-ae3f-11bb06b247a1.png": "12m",
+    "20250901_110728_325279_3_115476a8-52be-4b71-bcfd-d2b22754690f.png": "12m",
+    "20250901_110729_197626_0_5aee19e2-4c3f-4b91-8d78-8c4ef826d486.png": "14m",
+    "20250901_110729_203715_1_0f33f548-1612-4829-ba0b-c5f0bcb17fc1.png": "13m",
+    "20250901_110729_209774_3_4884ac53-ec55-4041-a74c-3fca9521dc4d.png": "12m",
+    "20250901_110729_215945_-1_951127a0-b8dd-44d9-92ca-2ea54ae0786f.png": "12m",
+    "20250901_110730_092452_0_08be0e55-6bca-4f07-8922-b6b78d1ec9e9.png": "13m",
+    "20250901_110730_101845_1_762d8228-85ee-473f-8801-e21c98d942c7.png": "14m",
+    "20250901_110730_102862_3_4353ff04-9147-4a9b-aa9c-c9175fc5f124.png": "12m",
+    "20250901_110730_110994_-1_f6a9c263-67ea-421c-9e78-e287a4f965fc.png": "12m",
+    "20250901_110731_050376_0_03785b0d-806e-4340-a594-3ea44eb51765.png": "11m",
+    "20250901_110731_055882_1_7e50c5eb-bba9-4c3d-99ef-c0ebe6756f21.png": "12m",
+    "20250901_110731_060667_2_73483a9e-7ea8-4968-a6bb-842c7c2de02b.png": "4m",
+    "20250901_110731_060667_3_e3641cdd-124b-4be5-9a66-45cc7544d3c4.png": "4m",
+    "20250901_110731_066292_4_c86b169c-37a8-4738-938e-5384059a9e36.png": "3m",
+    "20250901_110731_074607_-1_c4bb3843-7c38-4462-8789-a7524182768a.png": "11m",
+    "20250901_110732_049485_0_5856ece6-24a7-4722-a1e0-e0c6de8392bc.png": "11m",
+    "20250901_110732_049485_1_1335e62c-2aca-44d9-97a4-e29ef27a09c9.png": "15m",
+    "20250901_110732_059977_2_49015f80-4a95-4ddb-983b-f3177896e083.png": "12m",
+    "20250901_110732_061995_3_c1fe47d1-6b42-4000-b862-11cfe103eb0a.png": "4m",
+    "20250901_110732_064019_4_c3f4bb89-6746-413a-a9ba-b3193d5a1b0c.png": "13m",
+    "20250901_110732_066048_-1_19231220-cfd3-4216-a917-5e04001ece6a.png": "11m",
+    "20250901_110732_883670_0_c4970682-dd5e-4a53-bfa9-2ef91828b6c9.png": "11m",
+    "20250901_110732_891787_1_cd09526a-b768-4436-8b29-fc3c06b31521.png": "15m",
+    "20250901_110732_895838_2_a89e56a5-5576-4a42-9da5-172f72912d31.png": "12m",
+    "20250901_110732_900155_3_e02f7adc-0d0d-44ec-9409-0add9ddfd08e.png": "4m",
+    "20250901_110732_908363_4_f61656b8-71dc-4638-8302-45e7626ac3bb.png": "13m",
+    "20250901_110732_916488_-1_c9cceaf7-3a72-4fe4-ba73-f9c86e88ec1d.png": "11m",
+    "20250901_110733_715690_0_482373d1-79f0-4322-bdcb-1c55a8e7e4a8.png": "11m",
+    "20250901_110733_715690_1_2181016f-9bbf-40bc-ab56-9a2286bbd48f.png": "15m",
+    "20250901_110733_715690_2_648ea41d-2391-4624-a83c-1894b98a8b7f.png": "12m",
+    "20250901_110733_723931_-1_d28f13f7-f986-4478-a4ed-2e7c45086446.png": "11m",
+    "20250901_110733_723931_3_a951ad78-ad8b-49bc-aa1e-d179ec1aefae.png": "4m",
+    "20250901_110733_723931_4_1265c702-15f3-44eb-ab8e-cb9683ac3d7c.png": "13m",
+    "20250901_110734_562670_0_02c7bad7-b6e6-472d-b0ac-9d393675753a.png": "11m",
+    "20250901_110734_562670_1_2557caa2-fb93-4e3b-b3a7-c5f7076026e9.png": "5m",
+    "20250901_110734_566582_2_be069710-3d9c-4630-bd66-e282928835a4.png": "12m",
+    "20250901_110734_571028_3_473e0d35-954d-4a19-a834-a0f478f3744b.png": "4m",
+    "20250901_110734_579119_-1_3d97881b-e5e9-40d2-be5a-3dfa8626e5e5.png": "11m",
+    "20250901_110734_579119_4_eccd3c39-a2e7-48b4-91b7-6584e3b9ef04.png": "13m",
+    "20250901_110735_466481_0_d5a6eddf-9059-423b-a041-87ec3a0e549f.png": "11m",
+    "20250901_110735_474821_1_07da98c0-1a04-45f0-919e-74fe522136b7.png": "5m",
+    "20250901_110735_483069_2_cbba91c1-48b3-48a8-8dde-a7c147aa8119.png": "12m",
+    "20250901_110735_483069_3_1d0c150e-91a4-4071-8de2-5de551ec6b61.png": "4m",
+    "20250901_110735_483069_4_dc7ceb73-593d-4026-8f54-c06cec3b32fd.png": "13m",
+    "20250901_110735_495264_-1_79c11c6a-9045-45ae-b526-8c09eef652e4.png": "11m",
+    "20250901_110736_257943_0_c175b9a1-6373-4ac2-9938-77a77d0aacb4.png": "11m",
+    "20250901_110736_261137_1_8ffe93ed-d02a-456e-9b4b-95777d963bfc.png": "12m",
+    "20250901_110736_272241_2_39fe9e71-a6f8-4e42-b89b-62f07a43f981.png": "5m",
+    "20250901_110736_274783_3_96acee8a-182d-4129-949a-924c4ec1b540.png": "4m",
+    "20250901_110736_279880_4_4e61a14c-7778-4e4e-acea-72b95b43bae6.png": "3m",
+    "20250901_110736_286713_-1_72fc2f51-8f5a-4674-8dd2-794fbab658b4.png": "11m",
+    "20250901_110737_058311_0_23958389-f9cc-4faf-862d-ab5cd4a29487.png": "11m",
+    "20250901_110737_072241_1_63a9f873-4d8b-4737-b349-1d6c31fb9f8d.png": "5m",
+    "20250901_110737_074415_2_7cb9cbfa-2385-4841-b665-569e37bbd043.png": "12m",
+    "20250901_110737_074415_3_684107d2-7dd5-453d-bc2f-0cba2d152a2c.png": "4m",
+    "20250901_110737_074415_4_782a3de6-9aea-4b81-a892-1126fb64dfdc.png": "3m",
+    "20250901_110737_082811_-1_62b596ba-3d33-45ea-bb66-cca17068c7b1.png": "11m",
+    "20250901_110738_032886_0_5b96512a-bcb1-4a13-9bbe-4e8b53148c3f.png": "11m",
+    "20250901_110738_036560_1_2cb56eed-8eea-46fd-9c61-e83ff108eeb4.png": "15m",
+    "20250901_110738_040963_2_09032b3c-3ab1-4d3b-a190-00e0afcda277.png": "12m",
+    "20250901_110738_040963_3_bdbb4222-19e9-4326-a8dd-f3cf571fdf97.png": "4m",
+    "20250901_110738_040963_4_1e9d31de-2c6c-43f0-aef1-9d900c2a0606.png": "3m",
+    "20250901_110738_049420_-1_fbcfb155-c160-4ebc-a331-4b5e2d9d0197.png": "11m",
+    "20250901_110738_995134_0_d094f29b-fee1-4118-b269-4f7c6f276d19.png": "11m",
+    "20250901_110738_996909_1_1fa69b29-db32-4aca-84b3-710b0b5c8fdc.png": "5m",
+    "20250901_110739_005168_2_57b87de9-30d6-44cc-ae02-f767ddee7e97.png": "12m",
+    "20250901_110739_009221_3_90c1e27d-b575-4446-b7f4-f2b10c57ad61.png": "4m",
+    "20250901_110739_014821_4_41e19b85-c195-442d-9b28-75fe69dfedde.png": "3m",
+    "20250901_110739_023831_-1_31e43da7-5488-4cfe-a255-c074c19e20b2.png": "11m",
+    "20250901_110740_242363_0_fe93b4fb-10b1-4154-98e5-6c595c996121.png": "11m",
+    "20250901_110740_252412_1_35de4ee5-140b-4074-a5ba-2a18ba46f88d.png": "5m",
+    "20250901_110740_262564_2_a9ef2bdb-5e44-46ac-bf8c-b53dcfb5b68a.png": "12m",
+    "20250901_110740_266621_3_0e892df9-b216-4541-99f0-cffde487de6a.png": "4m",
+    "20250901_110740_276833_4_a3960e53-a8fd-4be5-8df4-1788a5082817.png": "13m",
+    "20250901_110740_289309_-1_22ee6f80-6913-40e9-b15c-622ec319c9c3.png": "11m",
+    "20250901_110741_527428_0_58c1774c-b1d1-4b79-a897-fa1112427abe.png": "11m",
+    "20250901_110741_531483_1_737e89d4-0422-47b7-8c9a-01f40c3772f4.png": "5m",
+    "20250901_110741_533503_2_70c58d86-1339-424d-8464-21e4bc1284c0.png": "12m",
+    "20250901_110741_539589_3_d234e321-048d-4257-af42-ecbb1145f8ec.png": "4m",
+    "20250901_110741_543639_4_5ff6b8ed-6972-4313-9b62-1cfa3a06ff7d.png": "13m",
+    "20250901_110741_553778_-1_27d2a153-40a5-4ebf-a487-2e70a1e07bdc.png": "11m",
+    "20250901_110742_724929_0_9569b0f3-0701-42f8-a815-f46b106c0eb5.png": "11m",
+    "20250901_110742_733425_1_a39c72a4-c2e3-4a48-9101-5a0aacf3f0a0.png": "12m",
+    "20250901_110742_737468_2_a0894a4d-c879-4597-8f60-979fc66fab15.png": "5m",
+    "20250901_110742_741507_3_f7da96f6-7075-4fdf-8c1d-f0192edaa2b0.png": "4m",
+    "20250901_110742_745549_4_8a62a416-6687-42f0-991f-474ce04e9fcd.png": "13m",
+    "20250901_110742_753624_-1_298c0eaa-89dd-4881-b137-a2819e1f30d5.png": "11m",
+    "20250901_110743_957712_0_cee9d66c-0b90-4574-86d3-7a3265ed8f3e.png": "11m",
+    "20250901_110743_968174_1_ad9fee8b-0227-4bca-b66e-8e7573a5fd71.png": "5m",
+    "20250901_110743_973070_2_7f7149cc-94d5-42e3-a39d-7f2f7f60938a.png": "12m",
+    "20250901_110743_979304_3_7e513aae-0002-45f1-a01d-9008e04d7bb5.png": "4m",
+    "20250901_110743_985974_4_4380849d-c89e-4fa9-9da9-826b7918d9bf.png": "13m",
+    "20250901_110743_997815_-1_832af38e-3c09-4be9-b5bf-d0735d86ce99.png": "11m",
+    "20250901_110745_110026_0_2c37ea99-dd7e-4299-8d0b-cc3894158feb.png": "11m",
+    "20250901_110745_110026_1_bd0308da-537d-4d2e-8cc6-998f9942c5f9.png": "12m",
+    "20250901_110745_120117_2_4fa422cf-658b-46f9-99f3-b0e88a026495.png": "5m",
+    "20250901_110745_125193_3_bcd6e997-b0e7-46dc-8aad-03da74a0d20e.png": "4m",
+    "20250901_110745_130276_4_53b8e4a7-3caf-423f-ba98-a25a18118256.png": "3m",
+    "20250901_110745_142766_-1_32d5cccd-9b18-4f3f-bbb5-dfad403ad1c6.png": "11m",
+    "20250901_110746_148180_0_381d9ce6-ecc6-41c5-9e3d-9ba805095218.png": "11m",
+    "20250901_110746_148180_1_37296257-866e-4548-82bf-54acc1956f47.png": "12m",
+    "20250901_110746_156314_2_dfafce54-5ff2-49e0-a0d5-2b4e078a8f05.png": "5m",
+    "20250901_110746_157033_3_3c855392-6bc8-48b1-9008-ed0f0da699e9.png": "4m",
+    "20250901_110746_157033_4_d5f421b5-ea01-430f-ac5a-6ae5a8ee44d2.png": "3m",
+    "20250901_110746_164717_-1_4b96ef1a-dde1-4f16-a363-7e7c3d5ed87c.png": "11m",
+    "20250901_110747_166409_0_58fa60a7-6120-42fa-be42-d5f940301762.png": "11m",
+    "20250901_110747_166409_1_5d7f9bfe-7cb0-48cb-8caa-6c4e9347c602.png": "5m",
+    "20250901_110747_174983_2_b262a5e5-8638-4d6e-a7ec-cfeec75037db.png": "12m",
+    "20250901_110747_181051_3_e44ec2af-62c1-4b43-9896-f3974952fb54.png": "4m",
+    "20250901_110747_185094_4_cbf92ded-dd6c-4773-9948-b22b9e272c8c.png": "13m",
+    "20250901_110747_191153_-1_021b9c8e-4860-4977-975e-fe1360a0a881.png": "11m",
+    "20250901_110748_127606_0_ded1fddb-fd17-478c-9f9f-b3b701d418ed.png": "11m",
+    "20250901_110748_132370_1_e1afb38f-5df9-4d13-bf35-385ecfd75679.png": "5m",
+    "20250901_110748_142259_2_327bef8a-9e8a-44c8-8198-39db8b0d0b9d.png": "12m",
+    "20250901_110748_142259_3_b4facba1-5774-4434-949c-069a950050d2.png": "4m",
+    "20250901_110748_149489_4_335e6a53-9e14-4589-a70f-7c9b3c902d6f.png": "3m",
+    "20250901_110748_158347_-1_5a393b1d-6ce6-493f-ba84-d44ec3a46b0c.png": "11m",
+    "20250901_110749_140486_0_1af9b7de-62e4-4363-b23a-f15ae4985be9.png": "11m",
+    "20250901_110749_192045_1_a2290d9e-453a-4908-8017-d2d13a93cfbc.png": "5m",
+    "20250901_110749_204155_2_abe40318-0e1e-43b9-ba43-b06a27c19566.png": "12m",
+    "20250901_110749_208427_3_b2d8e0a0-7f14-4cec-a795-17b948ef2b9d.png": "4m",
+    "20250901_110749_214215_4_3fcdc32a-ba64-4eac-94d4-fd75bdb93652.png": "13m",
+    "20250901_110749_233420_-1_35ed8eb0-e649-4c28-9d17-38a9fe7eb676.png": "11m",
+    "20250901_110750_453401_0_341855af-1896-4416-a8d0-7050eec096d6.png": "11m",
+    "20250901_110750_459457_1_78799c59-d8ff-46e7-9261-db89745437ac.png": "12m",
+    "20250901_110750_463490_2_724a2147-98c5-49bf-80c8-b2d570de7780.png": "5m",
+    "20250901_110750_463490_3_f14a3e50-231d-4d8f-8cdb-0954b99bae7f.png": "4m",
+    "20250901_110750_478548_4_6c6d9317-befe-46b0-aa52-e1bc565c816b.png": "13m",
+    "20250901_110750_488132_-1_2025df41-fd2f-4aac-bb2e-b79e6d019067.png": "11m",
+    "20250901_110751_593471_0_d3ab5357-f24c-4d59-b055-21f422d31a77.png": "11m",
+    "20250901_110751_593471_1_e85b8e3c-606f-45af-82e7-1fbd1cf6ef4d.png": "12m",
+    "20250901_110752_763214_-1_63e934d0-29b5-4507-afdc-b1088f76935f.png": "11m",
+    "20250901_110753_607346_0_f0da8e18-1b5b-43ce-8d7f-737e4a5bc733.png": "12m",
+    "20250901_110753_622867_-1_a5122d01-1269-47c7-84b1-5dc3081861c1.png": "12m",
+    "20250901_110755_181386_0_da01b9dd-6b80-4aaa-b799-d7c9f394cb14.png": "12m",
+    "20250901_110755_193684_-1_54562da4-15d0-420f-b46a-0afb6f1b65f0.png": "12m",
+    "20250901_110756_024068_0_6d8377c0-000e-4aed-931d-bd57fb66fc98.png": "12m",
+    "20250901_110756_031124_-1_aaebd6fa-a7e7-455e-86c4-b3e49107bbe3.png": "12m",
+    "20250901_110756_842576_-1_2f0ead39-678f-4894-a53f-62c5c51f9d6f.png": "12m",
+    "20250901_110756_842576_0_d2b1cbd6-9769-4f78-abff-dc8c81b0a080.png": "12m",
+    "20250901_110757_624176_0_3b696edd-e970-4bc4-84e7-e30ad65e9540.png": "12m",
+    "20250901_110757_632413_-1_ee80972b-3c66-44a7-93dd-d2a396cbb87d.png": "12m",
+    "20250901_110758_418102_0_c469f442-c7a0-447b-90ea-d8bcc00f5813.png": "12m",
+    "20250901_110758_426280_-1_b4925713-b825-4d58-8275-7dfe3becc2f4.png": "12m",
+    "20250901_110759_190922_0_2f075c68-b503-4810-b031-9eaa2328cf4a.png": "12m",
+    "20250901_110759_201042_-1_8cd71c1d-fcd8-4e4b-8262-8e809bb14cf7.png": "12m",
+    "20250901_115122_737088_b60ca42b-e36a-4857-b291-f4ab2706bbff.png": "4m",
+    "20250901_115122_737088_e30cc112-520f-4b23-a4a8-06ceebf40210.png": "2m",
+    "20250901_115122_757359_5b96e73f-08e9-4652-8a16-bc821dd834cf.png": "6m",
+    "20250901_115122_757359_6ba69a37-718f-4655-b385-3a24784c8117.png": "5m",
+    "20250901_115122_773083_af85514c-974e-4843-82ad-c101c7dc8846.png": "6m",
+    "20250901_115122_784786_239a3775-551a-4245-9092-aa4a182a0cd5.png": "9m",
+    "20250901_115122_784786_45b77755-762b-4d73-8992-16687c18ec58.png": "12m",
+    "20250901_115122_800586_67f0c472-8644-4961-bf4a-e4a4d9edc6a7.png": "15m",
+    "20250901_115122_803834_c5fe9435-dc49-4627-9e16-5913ba6386d2.png": "10m",
+    "20250901_115122_816423_21d2435f-32ea-4059-ad79-9a9b09a597b7.png": "18m",
+    "20250901_115122_816423_cf4f837a-c885-401f-b1be-5c3f7d3c76d1.png": "11m",
+    "20250901_115122_837783_03e39e3c-65ad-4605-8e08-78732a58a92d.png": "19m",
+    "20250901_115122_837783_fcd4612d-9e10-47d6-9f9f-f8e589716830.png": "10m",
+    "20250901_115122_880373_79086f98-b512-4fbf-b5d7-fda77a55297b.png": "20m",
+    "20250901_115122_888832_3378a1b0-3663-4007-8479-c1a05d63b7cf.png": "21m",
+    "20250901_115122_905730_ca2407dd-3139-4fd8-8958-b7bf520cb892.png": "24m",
+    "20250901_115122_966748_65d3c518-ae86-4e0b-af9e-ec3a140aab25.png": "2m",
+    "20250901_115122_976855_0235186d-74a8-4bf5-8be8-d019f11d4da1.png": "4m",
+    "20250901_115122_985780_c1426c76-02d6-4ad4-81fe-17af6b419e11.png": "6m",
+    "20250901_115122_993430_374dcfc5-34fd-4632-bdba-ae556e7ec6e2.png": "5m",
+    "20250901_115123_004276_14ed5806-472a-4922-b34f-a02c160d5e5e.png": "9m",
+    "20250901_115123_004276_a0f76936-e44d-47b0-89bc-4afbbdcac4d1.png": "6m",
+    "20250901_115123_017493_09be0601-d644-4f68-8915-d0ffaa4b005d.png": "15m",
+    "20250901_115123_017493_cb933601-78bf-401a-b8b8-c330304ba62b.png": "12m",
+    "20250901_115123_033463_6726df96-8aab-47d7-b328-987c162b5def.png": "10m",
+    "20250901_115123_049374_3384425a-99c7-4230-944b-172ff6cbc2d0.png": "18m",
+    "20250901_115123_049374_eb973787-0bbc-4592-a690-971b781a8f4f.png": "11m",
+    "20250901_115123_065175_00f6a787-a457-4752-8c87-1be56d27345d.png": "10m",
+    "20250901_115123_065175_07db25ae-5b31-4dfe-a6b2-435e750bbc1f.png": "9m",
+    "20250901_115123_104291_d1a8a407-1a73-408f-b22a-ed280be1c3c6.png": "22m",
+    "20250901_115123_112956_addbafda-8e4e-421a-8f98-d4bbd21015e5.png": "20m",
+    "20250901_115123_112956_ca4bdd2d-a486-4d65-bbd9-b6575642af2f.png": "21m",
+    "20250901_115123_129022_0c442bb8-e30f-442e-8d6a-700b3ba8a838.png": "24m",
+    "20250901_115123_185798_f22a9190-2e38-4127-87de-26ab2759101f.png": "2m",
+    "20250901_115123_203280_bcfc599b-bc34-4d7a-aa2c-ae8e071afa17.png": "4m",
+    "20250901_115123_211439_d6776585-3c03-469c-adf1-525674511898.png": "6m",
+    "20250901_115123_218436_a8760228-8a47-4ecd-bc0c-0e49afad6a9c.png": "5m",
+    "20250901_115123_229794_5496edda-37c3-4a5e-95fa-1ad243e57426.png": "6m",
+    "20250901_115123_241536_137e093b-436c-4504-b5f1-5e5e116e0024.png": "12m",
+    "20250901_115123_241536_67dda1c8-665c-447d-803e-c986c46b2633.png": "9m",
+    "20250901_115123_257521_4e8af324-5ed5-413d-b768-c356a9f74505.png": "10m",
+    "20250901_115123_257521_eae41e7c-3f17-4458-ba13-5c57655d6168.png": "15m",
+    "20250901_115123_273307_d86e7a9e-ba57-4ddb-bd69-6e6a9076df3e.png": "11m",
+    "20250901_115123_289126_3341f07a-fcdd-40a0-8a92-6833323b8ee8.png": "18m",
+    "20250901_115123_289126_a4ad73e9-404e-4e85-9974-d6fc09328a14.png": "9m",
+    "20250901_115123_304293_666ca2a2-3c9a-4208-838a-311b7d72b5a6.png": "10m",
+    "20250901_115123_336458_ccd9d646-fc99-4d27-8076-0c17d0dba784.png": "20m",
+    "20250901_115123_352471_eb97e5c2-d7a9-430b-8d27-991b279f45aa.png": "21m",
+    "20250901_115123_370505_07463c4d-b6d3-4097-ba93-07bd0688e660.png": "24m",
+    "20250901_115123_439065_a90eb93a-3cfa-4719-a9a9-e2604f15e30d.png": "2m",
+    "20250901_115123_451797_1e34678b-34dc-4069-8c38-cdf5bd64ffd0.png": "4m",
+    "20250901_115123_464998_8ef984aa-c0cb-4994-972b-ddd59f9ea102.png": "6m",
+    "20250901_115123_474046_fded311f-f5c6-409b-a475-7dc4fdecd9a1.png": "5m",
+    "20250901_115123_489859_2675e9d2-ba97-43ac-96d3-a936b4cc5dd4.png": "6m",
+    "20250901_115123_504456_9c24ae1b-8ea8-4f08-86e4-28ffd2a78e59.png": "9m",
+    "20250901_115123_524380_5ad58da2-1dee-4170-952b-41ecbbed99e0.png": "12m",
+    "20250901_115123_543594_8c8665a1-87ec-479b-a220-5e86bbb64796.png": "15m",
+    "20250901_115123_556927_b39709ae-1050-48b1-afd3-c0104153e96b.png": "10m",
+    "20250901_115123_568476_27577bae-79f9-4b00-9372-961cb4884adf.png": "11m",
+    "20250901_115123_589175_39e9b685-3465-4694-afd8-7d906047916d.png": "18m",
+    "20250901_115123_604957_a8075d2a-a7a9-415c-8da8-f532d64b9b78.png": "19m",
+    "20250901_115123_621023_88ad3804-c7bf-4d68-998b-900f6227a7dd.png": "10m",
+    "20250901_115123_667595_546e7b12-116b-43c9-aeca-2fc12d679b93.png": "20m",
+    "20250901_115123_681572_210448b8-0a07-4db7-8ae3-ac78a17c1a98.png": "21m",
+    "20250901_115123_705358_aa484c23-6785-4769-8a2c-2c6de1e41aa0.png": "24m",
+    "20250901_115123_785623_be871ea8-2775-4dbc-a375-a4ee3d2bd1fc.png": "3m",
+    "20250901_115123_797630_632e0e57-5dfe-4bd6-a46e-8f07e72c8603.png": "17m",
+    "20250901_115123_805521_6b001405-a652-47a2-a103-e3e693fedc4f.png": "9m",
+    "20250901_115123_821506_8e8a254d-6ee9-4854-a8c2-d21596a8422c.png": "5m",
+    "20250901_115123_835334_ac8a0fbd-635f-4696-9e47-a8840c6351ae.png": "6m",
+    "20250901_115123_849150_1b48853e-9379-4495-98db-4db823ec0500.png": "9m",
+    "20250901_115123_864830_20a63037-fce4-40dc-b7b4-0b47c1be4bea.png": "12m",
+    "20250901_115123_870854_3b9dff5f-fcea-4757-8cba-82c39a3b126a.png": "20m",
+    "20250901_115123_886502_3d8a48e5-fc90-4c44-97f0-e6ecf61be99e.png": "111m",
+    "20250901_115123_905675_fb46adf9-ba37-4f99-8cc6-9c0a92072476.png": "5m",
+    "20250901_115123_919629_a3d629b2-de72-4732-87ed-3830b8a21ad2.png": "18m",
+    "20250901_115123_937797_8b4b1164-2c09-41aa-9268-07667de40944.png": "10m",
+    "20250901_115123_987695_1746c889-9414-44ac-8e91-9102538abe22.png": "22m",
+    "20250901_115124_005885_8f7a730c-38a5-41d5-bee7-f5e7775a33fd.png": "20m",
+    "20250901_115124_021137_847c1e86-a2d6-4a78-a13b-0a5b879cbfd9.png": "11m",
+    "20250901_115124_052035_412f7fdb-91d8-427b-a8c6-1b99e3e4ae72.png": "24m",
+    "20250901_115124_127127_ac246a2e-df6d-4816-bcb2-e63b47c483e2.png": "2m",
+    "20250901_115124_141403_d5304ac9-c1ea-4a9b-949f-b684417ee1fe.png": "4m",
+    "20250901_115124_160100_a4ae6720-11dd-4a1e-9078-1b6d859b010d.png": "6m",
+    "20250901_115124_172402_09e4467c-fba4-466c-a223-69dc9a76fc86.png": "5m",
+    "20250901_115124_190034_1ccd5c91-e282-415d-805a-d8e75eef9f1d.png": "6m",
+    "20250901_115124_206181_e17ce8f6-2187-44aa-94ba-08d428a1e29c.png": "9m",
+    "20250901_115124_222412_720b86b9-f3b6-4c15-897e-8b6342b877f8.png": "12m",
+    "20250901_115124_239513_c7883dd5-9bd6-48e4-83f3-5f33f46d39c4.png": "15m",
+    "20250901_115124_257685_6f98bb03-0f37-4fab-a431-375a583d392e.png": "10m",
+    "20250901_115124_273432_c40866ae-8972-4aaa-8fae-578a0be1d079.png": "11m",
+    "20250901_115124_300408_8111398a-cfe2-44a6-8664-97c997c236c3.png": "18m",
+    "20250901_115124_316275_183f3d54-e669-4a95-9114-232bc02e204c.png": "19m",
+    "20250901_115124_338303_69e2d01b-0c08-450e-9f67-c289f2e65601.png": "10m",
+    "20250901_115124_444477_300fb1ba-4091-41bc-b50b-3e600ecdd5ff.png": "20m",
+    "20250901_115124_469974_96d323c0-2fee-4232-abbf-27f3a02397ff.png": "21m",
+    "20250901_115124_535793_32ef3807-daea-4133-8e9c-3b1834af5edb.png": "25m",
+    "20250901_115124_662183_957fb87b-31e1-429c-9b30-74c6fd0b33ae.png": "3m",
+    "20250901_115124_688589_873184fb-08eb-4e86-8a4f-19a21cb4200b.png": "17m",
+    "20250901_115124_706491_8121ff6c-059e-4cfd-88ce-78ed85b81d77.png": "9m",
+    "20250901_115124_736644_adf67776-b838-4122-9389-1fb2809a20c5.png": "5m",
+    "20250901_115124_759518_086d9708-c195-4195-ba8b-4f2a2a192b12.png": "6m",
+    "20250901_115124_778600_d6cc87d2-c3a1-4b46-9cf8-ac7b6566c623.png": "9m",
+    "20250901_115124_805454_96ca12ed-f023-4699-ba55-16046056a449.png": "12m",
+    "20250901_115124_828357_ebe93008-d691-4ebc-ae57-dd81dd9779e5.png": "20m",
+    "20250901_115124_878237_96f48286-1f16-4f23-b1fd-054d26918d54.png": "5m",
+    "20250901_115124_910340_979f06e1-7cf9-4858-900a-e519ca70fe7d.png": "18m",
+    "20250901_115124_958182_f9045a1a-0c12-427c-863a-f3dbcdf1d1a4.png": "10m",
+    "20250901_115125_035647_f1277afb-e842-4f15-b028-e9333d6613fb.png": "22m",
+    "20250901_115125_070685_0aacbb16-ea5c-4965-b36b-fdbbecdc801f.png": "20m",
+    "20250901_115125_081033_4353bcf3-a3d0-41d3-8e5e-bd486b8170fa.png": "11m",
+    "20250901_115125_153835_f2fb5958-5e82-4481-9f4b-377b0441f0cd.png": "24m"
+}

draft_computation/ocr/train_ocr.py

@@ -0,0 +1,162 @@
+
+import os
+import json
+from PIL import Image
+import torch
+from torch.utils.data import Dataset, DataLoader
+import math # For ceil in input_lengths calculation
+import shutil # For cleaning up dummy data
+import logging
+import numpy as np
+
+from transformers import VisionEncoderDecoderModel, AutoImageProcessor, AutoTokenizer, TrainingArguments, Trainer
+from jiwer import cer # For CER calculation
+
+# --- Setup Logging ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- OCRDataset (Adapted for Hugging Face) ---
+class OCRDataset(Dataset):
+    def __init__(self, root_dir):
+        self.root_dir = root_dir
+        self.image_dir = os.path.join(root_dir, "images")
+
+        # Load the JSON mapping file
+        mapping_file_path = os.path.join(root_dir, "annotations.json") # Assuming the JSON is named annotations.json
+        logging.info(f"Loading mapping file from: {mapping_file_path}")
+        with open(mapping_file_path, 'r', encoding='utf-8') as f:
+            self.data = json.load(f)
+        logging.info(f"Loaded {len(self.data)} entries from mapping file.")
+
+        # Store image filenames and their corresponding texts
+        self.image_filenames = list(self.data.keys())
+
+    def __len__(self):
+        return len(self.image_filenames)
+
+    def __getitem__(self, idx):
+        image_filename = self.image_filenames[idx]
+        text = self.data[image_filename]
+
+        image_path = os.path.join(self.image_dir, image_filename)
+        image = Image.open(image_path).convert("RGB") # Ensure image is in RGB format
+
+        # Return raw PIL Image and text string
+        return image, text
+
+# --- Custom Collate Function for Hugging Face Processors ---
+# This function will be passed to the DataLoader
+def collate_fn_hf(batch, image_processor, tokenizer):
+    images, texts = zip(*batch)
+
+    # Process images using AutoImageProcessor
+    # This handles resizing, normalization, and converting to tensor
+    pixel_values = image_processor(images=list(images), return_tensors="pt").pixel_values
+
+    # Tokenize texts using AutoTokenizer
+    # This handles tokenization, padding, and converting to tensor
+    labels = tokenizer(text=list(texts), padding="longest", return_tensors="pt").input_ids
+
+    # Return a dictionary expected by the Hugging Face Trainer
+    return {"pixel_values": pixel_values, "labels": labels}
+
+# --- Define compute_metrics for Trainer ---
+def compute_metrics(pred):
+    labels_ids = pred.label_ids
+    pred_logits = pred.predictions[0]
+    pred_ids = np.argmax(pred_logits, axis=-1)
+
+    # Replace -100 in labels as we can't decode them (they are padding tokens)
+    labels_ids[labels_ids == -100] = tokenizer.pad_token_id
+
+    pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
+    label_str = tokenizer.batch_decode(labels_ids, skip_special_tokens=True)
+
+    # Calculate CER
+    cer_score = cer(label_str, pred_str)
+    logging.info(f"Validation CER: {cer_score}")
+    return {"cer": cer_score}
+
+# --- Main Training Script ---
+if __name__ == '__main__':
+    logging.info("Starting OCR training script.")
+    data_root_dir = "text_dataset"
+    logging.info(f"Using dataset at: {os.path.abspath(data_root_dir)}")
+
+    # --- Hugging Face Model and Processor Loading ---
+    #encoder_id = "google/mobilenet_v3_small_100_224"
+    encoder_id = "google/vit-base-patch16-224-in21k"
+    decoder_id = "prajjwal1/bert-tiny"
+
+    logging.info(f"Loading encoder: {encoder_id}")
+    logging.info(f"Loading decoder: {decoder_id}")
+
+    model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
+        encoder_pretrained_model_name_or_path=encoder_id,
+        decoder_pretrained_model_name_or_path=decoder_id,
+    )
+
+    image_processor = AutoImageProcessor.from_pretrained(encoder_id)
+    tokenizer = AutoTokenizer.from_pretrained(decoder_id)
+    logging.info("Model, image processor, and tokenizer loaded.")
+
+    # --- Set special tokens and generation parameters ---
+    model.config.decoder_start_token_id = tokenizer.cls_token_id
+    model.config.pad_token_id = tokenizer.pad_token_id
+    model.config.vocab_size = tokenizer.vocab_size # Ensure model knows decoder vocab size
+
+    model.config.eos_token_id = tokenizer.sep_token_id
+    model.config.max_length = 64
+    model.config.early_stopping = True
+    model.config.no_repeat_ngram_size = 3
+    model.config.length_penalty = 2.0
+    model.config.num_beams = 4
+    logging.info("Model configuration set.")
+
+    # --- Dataset and DataLoader Setup ---
+    logging.info("Setting up datasets.")
+    train_dataset = OCRDataset(root_dir=data_root_dir)
+    # For a real project, you'd split your data into train/val/test
+    # For this example, we'll use the same dummy data for simplicity
+    val_dataset = OCRDataset(root_dir=data_root_dir)
+    logging.info(f"Training dataset size: {len(train_dataset)}")
+    logging.info(f"Validation dataset size: {len(val_dataset)}")
+
+    # --- Training Arguments ---
+    training_args = TrainingArguments(
+        output_dir="./ocr_model_output", # Output directory for checkpoints and logs
+        per_device_train_batch_size=2,
+        per_device_eval_batch_size=2,
+        num_train_epochs=3, # Small number for quick demo
+        logging_dir="./logs",
+        logging_steps=10,
+        # save_steps=500, # Save checkpoint every 500 steps
+        eval_strategy ="epoch", # Evaluate at the end of each epoch
+        save_strategy ="epoch", # Evaluate at the end of each epoch
+        save_total_limit=2, # Only keep the last 2 checkpoints
+        report_to="none", # Disable reporting to W&B, MLflow etc. for simplicity
+        # predict_with_generate=True, # Crucial for generation tasks (uses model.generate() for eval)
+        load_best_model_at_end=True, # Load the best model based on eval_loss at the end of training
+        metric_for_best_model="cer", # Metric to monitor for best model
+        greater_is_better=False, # Lower CER is better
+    )
+    logging.info("Training arguments set.")
+
+    # --- Trainer Initialization ---
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset,
+        # Pass image_processor and tokenizer to collate_fn using a lambda
+        data_collator=lambda batch: collate_fn_hf(batch, image_processor, tokenizer),
+        compute_metrics=compute_metrics,
+    )
+    logging.info("Trainer initialized.")
+
+    # --- Start Training ---
+    logging.info("--- Starting Training ---")
+    trainer.train()
+    logging.info("--- Training finished! ---")
+
+    

integration_test.py

@@ -0,0 +1,86 @@
+import requests
+import json
+import random
+import os
+from datetime import datetime, timedelta
+
+# --- Configuration ---
+API_URL = "http://127.0.0.1:8000/measure"
+IMAGE_DIR = "test_data"
+IMAGE_NAME = "test1_post.png"  # The name of the image file you will provide
+
+# --- Pre-defined list of sample metadata ---
+METADATA_SAMPLES = [
+    {
+        "ship_id": "IMO9321483",
+        "timestamp": (datetime.utcnow() - timedelta(hours=2)).isoformat() + "Z",
+        "latitude": 1.2646,
+        "longitude": 103.8357,
+        "camera_id": "CAM-04"
+    },
+    {
+        "ship_id": "IMO9839272",
+        "timestamp": (datetime.utcnow() - timedelta(minutes=45)).isoformat() + "Z",
+        "latitude": 51.9432,
+        "longitude": 4.1497,
+        "camera_id": "JETTY-7B"
+    },
+    {
+        "ship_id": "IMO9450259",
+        "timestamp": (datetime.utcnow() - timedelta(days=1)).isoformat() + "Z",
+        "latitude": 31.2244,
+        "longitude": 121.4737,
+        "camera_id": "FIXED-PIER-3"
+    },
+    {
+        "ship_id": "IMO9226788",
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+        "latitude": 33.7542,
+        "longitude": -118.2165,
+        "camera_id": "DRONE-ALPHA"
+    }
+]
+
+def run_test():
+    """Runs a single integration test against the API."""
+    image_path = os.path.join(IMAGE_DIR, IMAGE_NAME)
+
+    # 1. Check if the image file exists
+    if not os.path.exists(image_path):
+        print(f"Error: Test image not found at '{image_path}'")
+        print("Please place your test image there before running the script.")
+        return
+
+    # 2. Randomly select a metadata object
+    metadata = random.choice(METADATA_SAMPLES)
+    print(f"Selected metadata for this test run:\n{json.dumps(metadata, indent=2)}\n")
+
+    # 3. Open the image file and send the request
+    try:
+        with open(image_path, "rb") as image_file:
+            files = {"image": (IMAGE_NAME, image_file, "image/png")}
+            form_data = {"metadata_json": json.dumps(metadata)}
+
+            print(f"Sending request to {API_URL}...")
+            response = requests.post(API_URL, files=files, data=form_data)
+
+            # 4. Print the server's response
+            print(f"\n--- Server Response ---")
+            print(f"Status Code: {response.status_code}")
+            if response.status_code == 200:
+                print("Response JSON:")
+                print(response.json())
+            else:
+                print("Error Response Text:")
+                print(response.text)
+            print("-----------------------")
+
+    except requests.exceptions.ConnectionError as e:
+        print(f"\nError: Connection to the API server failed.")
+        print("Please ensure the main application is running (`python main.py`).")
+        print(f"Details: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+if __name__ == "__main__":
+    run_test()

main.py

@@ -0,0 +1,125 @@
+from fastapi import FastAPI, File, UploadFile, Form, Depends
+import uvicorn
+import json
+from contextlib import asynccontextmanager
+from fastapi.staticfiles import StaticFiles # Add this import
+from PIL import Image
+import io
+
+from services.measurement_service import MeasurementService
+from services.pdf_service import PdfService
+from services.persistence_service import PersistenceService
+from models.schemas import MeasurementMetadata
+from models.database import create_db_and_tables
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # create database and tables on startup
+    create_db_and_tables()
+    yield
+
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(title="Ship Draft Measurement API", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Mount static files directory
+app.mount("/static", StaticFiles(directory="./reports"), name="static") # Add this line
+
+# Initialize services
+measurement_service = MeasurementService()
+pdf_service = PdfService()
+persistence_service = PersistenceService()
+
+@app.get("/", tags=["Health Check"])
+def read_root():
+    """A simple endpoint to check if the API is running."""
+    return {"status": "API is running"}
+
+@app.post("/measure", tags=["Measurement"])
+async def measure_draft(
+    image: UploadFile = File(...),
+    metadata_json: str = Form(...)
+):
+    """
+    Receives an image and metadata, performs draft measurement,
+    generates a PDF report, and saves it.
+    """
+    # 1. Read image content
+    image_bytes = await image.read()
+
+    # 2. Deserialize and validate metadata
+    metadata_dict = json.loads(metadata_json)
+    metadata = MeasurementMetadata(**metadata_dict)
+
+    # 3. Perform measurement (using placeholder service)
+    image_pil = Image.open(io.BytesIO(image_bytes))
+    measurement_results, ml_results = measurement_service.measure(image_pil)
+
+    # 4. Generate PDF report
+    pdf_report_bytes = pdf_service.create_report(
+        image_bytes=image_bytes,
+        metadata=metadata,
+        results=measurement_results,
+        ml_results=ml_results
+    )
+
+    # 5. Persist the report
+    report_path = persistence_service.save_to_disk(pdf_report_bytes, metadata)
+    persistence_service.save_to_db(
+        report_path,
+        metadata,
+        measurement_results.draft_measurement,
+        measurement_results.confidence_score,
+        image_bytes
+    )
+    
+    # Optional: Send email
+    persistence_service.send_by_email(report_path, "pfnfcat@gmail.com")
+
+    return {
+        "message": "Measurement complete and report generated.",
+        "report_path": report_path,
+        "results": measurement_results
+    }
+
+from datetime import datetime
+from typing import Optional
+
+@app.get("/reports", tags=["Reports"])
+def get_reports(
+    skip: int = 0,
+    limit: int = 10,
+    search: Optional[str] = None,
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None,
+):
+    """Returns a list of all reports."""
+    return persistence_service.get_all_reports(
+        skip=skip,
+        limit=limit,
+        search=search,
+        start_date=start_date,
+        end_date=end_date,
+    )
+
+
+@app.get("/reports/{report_id}", tags=["Reports"])
+def get_report(report_id: int):
+    """Returns a single report by its ID."""
+    report = persistence_service.get_report_by_id(report_id)
+    if report is None:
+        return {"error": "Report not found"}
+    return report
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

models/database.py

@@ -0,0 +1,35 @@
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, LargeBinary
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+# Define the database connection URL
+DATABASE_URL = "sqlite:///./ship_draft_reports.db"
+
+# Create the SQLAlchemy engine
+engine = create_engine(
+    DATABASE_URL, connect_args={"check_same_thread": False} # check_same_thread is for SQLite only
+)
+
+# Create a session factory
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Create a base class for declarative models
+Base = declarative_base()
+
+# Define the Report model
+class Report(Base):
+    __tablename__ = "reports"
+
+    id = Column(Integer, primary_key=True, index=True)
+    ship_id = Column(String, index=True)
+    timestamp = Column(DateTime)
+    latitude = Column(Float)
+    longitude = Column(Float)
+    draft_measurement = Column(Float)
+    confidence_score = Column(Float) # New field
+    pdf_path = Column(String, unique=True)
+    image_bytes = Column(LargeBinary) # New field
+
+def create_db_and_tables():
+    """Function to create the database and tables."""
+    Base.metadata.create_all(bind=engine)

models/schemas.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from datetime import datetime
+from typing import Optional
+
+class MeasurementMetadata(BaseModel):
+    """Schema for the metadata received with the image."""
+    ship_id: str
+    timestamp: datetime
+    latitude: float
+    longitude: float
+    camera_id: Optional[str] = None
+
+class MeasurementResult(BaseModel):
+    """Schema for the results from the measurement service."""
+    draft_measurement: float # The measured draft in meters
+    confidence_score: float

requirements.txt

@@ -0,0 +1,74 @@
+fastapi
+uvicorn[standard]
+python-multipart
+SQLAlchemy
+reportlab
+Pillow
+accelerate==1.10.1
+annotated-types==0.7.0
+anyio==4.10.0
+av==15.0.0
+certifi==2025.8.3
+charset-normalizer==3.4.3
+click==8.2.1
+colorama==0.4.6
+contourpy==1.3.3
+cycler==0.12.1
+fastapi==0.116.1
+filelock==3.19.1
+fonttools==4.59.2
+fsspec==2025.7.0
+greenlet==3.2.4
+grpcio==1.74.0
+grpcio-tools==1.74.0
+h11==0.16.0
+hf-xet==1.1.9
+httptools==0.6.4
+huggingface-hub==0.34.4
+idna==3.10
+Jinja2==3.1.6
+jiwer==4.0.0
+kiwisolver==1.4.9
+MarkupSafe==3.0.2
+matplotlib==3.10.5
+mpmath==1.3.0
+networkx==3.5
+numpy==2.2.6
+opencv-python==4.12.0.88
+packaging==25.0
+pillow==11.3.0
+polars==1.32.3
+protobuf==6.32.0
+psutil==7.0.0
+py-cpuinfo==9.0.0
+pydantic==2.11.7
+pydantic_core==2.33.2
+pyparsing==3.2.3
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+python-multipart==0.0.20
+PyYAML==6.0.2
+RapidFuzz==3.14.0
+regex==2025.8.29
+reportlab==4.4.3
+requests==2.32.5
+safetensors==0.6.2
+scipy==1.16.1
+six==1.17.0
+sniffio==1.3.1
+SQLAlchemy==2.0.43
+starlette==0.47.3
+sympy==1.14.0
+tokenizers==0.22.0
+torch==2.8.0
+torchvision==0.23.0
+tqdm==4.67.1
+transformers==4.56.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+ultralytics==8.3.189
+ultralytics-thop==2.0.16
+urllib3==2.5.0
+uvicorn==0.35.0
+watchfiles==1.1.0
+websockets==15.0.1

services/measurement_service.py

@@ -0,0 +1,30 @@
+from models.schemas import MeasurementResult
+import time
+
+from draft_computation import run
+
+class MeasurementService:
+    """
+    A service to handle the draft measurement logic.
+    This is a placeholder that simulates a PyTorch model's output.
+    """
+    def measure(self, image_bytes: bytes) -> MeasurementResult:
+        """
+        Simulates running a deep learning model on the image.
+
+        Args:
+            image_bytes: The raw bytes of the image file.
+
+        Returns:
+            A MeasurementResult object with simulated data.
+        """
+        # Simulate model processing time
+        time.sleep(2) # Simulate a 2-second processing time
+
+        results = run(image_bytes)
+        print(results)
+
+        return MeasurementResult(
+            draft_measurement=7.85, # Example measurement in meters
+            confidence_score=0.958
+        ), results

services/ml_results_example.txt

@@ -0,0 +1,724 @@
+{'draft': np.float64(11.85), 'pose_results': tensor([[[3.8799e+02, 2.3064e+02, 9.9727e-01],
+         [4.3032e+02, 2.9595e+02, 9.9999e-01],
+         [4.5217e+02, 3.5503e+02, 1.0000e+00],
+         [4.7843e+02, 4.1626e+02, 1.0000e+00],
+         [5.0423e+02, 4.7074e+02, 9.9908e-01]],
+
+        [[5.1116e+02, 5.2845e+02, 9.9898e-01],
+         [5.5497e+02, 5.8498e+02, 1.0000e+00],
+         [5.8281e+02, 6.3961e+02, 1.0000e+00],
+         [6.1391e+02, 6.9308e+02, 1.0000e+00],
+         [6.4442e+02, 7.4322e+02, 9.9942e-01]],
+
+        [[3.3734e+02, 0.0000e+00, 1.9305e-03],
+         [3.5891e+02, 2.2499e+01, 6.0478e-03],
+         [3.4428e+02, 4.3506e+01, 9.6756e-01],
+         [3.6704e+02, 1.1002e+02, 9.9514e-01],
+         [3.8660e+02, 1.7183e+02, 9.8539e-01]],
+
+        [[6.5912e+02, 7.8940e+02, 9.9636e-01],
+         [7.1144e+02, 8.3895e+02, 9.9728e-01],
+         [6.7609e+02, 8.3011e+02, 1.3168e-04],
+         [6.7713e+02, 8.5438e+02, 5.6889e-07],
+         [6.6890e+02, 8.6667e+02, 4.8566e-10]]]), 'segment_results': [array([[     666.56,      698.62],
+       [     666.56,      705.38],
+       [     669.94,      708.75],
+       [     681.75,      708.75],
+       [     685.12,      712.12],
+       [     683.44,      713.81],
+       [     669.94,      713.81],
+       [     666.56,      717.19],
+       [     668.25,      718.88],
+       [     676.69,      718.88],
+       [     678.38,      720.56],
+       [     685.12,      720.56],
+       [     686.81,      722.25],
+       [      688.5,      722.25],
+       [     690.19,      723.94],
+       [     691.88,      723.94],
+       [     693.56,      725.62],
+       [     696.94,      725.62],
+       [     700.31,         729],
+       [        702,         729],
+       [     703.69,      730.69],
+       [     707.06,      730.69],
+       [     708.75,      732.38],
+       [      715.5,      732.38],
+       [     717.19,      734.06],
+       [     722.25,      734.06],
+       [     723.94,      735.75],
+       [     727.31,      735.75],
+       [        729,      737.44],
+       [     739.12,      737.44],
+       [     740.81,      739.12],
+       [     749.25,      739.12],
+       [     750.94,      737.44],
+       [     754.31,      737.44],
+       [        756,      739.12],
+       [     762.75,      739.12],
+       [     764.44,      737.44],
+       [     767.81,      737.44],
+       [      769.5,      739.12],
+       [     772.88,      739.12],
+       [     774.56,      737.44],
+       [     776.25,      737.44],
+       [     777.94,      735.75],
+       [     781.31,      735.75],
+       [     784.69,      732.38],
+       [      796.5,      732.38],
+       [      796.5,      730.69],
+       [     794.81,      730.69],
+       [     793.12,         729],
+       [     789.75,         729],
+       [     788.06,      730.69],
+       [     784.69,      730.69],
+       [        783,         729],
+       [     781.31,         729],
+       [     779.62,      727.31],
+       [      769.5,      727.31],
+       [     766.12,      723.94],
+       [     767.81,      722.25],
+       [     781.31,      722.25],
+       [        783,      720.56],
+       [     806.62,      720.56],
+       [     808.31,      722.25],
+       [     815.06,      722.25],
+       [     818.44,      725.62],
+       [     816.75,      727.31],
+       [     815.06,      727.31],
+       [     813.38,         729],
+       [     804.94,         729],
+       [     803.25,      730.69],
+       [     801.56,      730.69],
+       [     803.25,      732.38],
+       [     813.38,      732.38],
+       [     815.06,      734.06],
+       [     828.56,      734.06],
+       [     830.25,      735.75],
+       [        837,      735.75],
+       [     840.38,      739.12],
+       [     838.69,      740.81],
+       [     835.31,      740.81],
+       [     833.62,       742.5],
+       [     831.94,       742.5],
+       [     830.25,      744.19],
+       [     831.94,      745.88],
+       [     838.69,      745.88],
+       [     840.38,      747.56],
+       [     843.75,      747.56],
+       [     845.44,      749.25],
+       [     848.81,      749.25],
+       [      850.5,      750.94],
+       [     852.19,      750.94],
+       [     853.88,      752.62],
+       [     853.88,      754.31],
+       [     855.56,         756],
+       [     855.56,      757.69],
+       [     857.25,      759.38],
+       [     862.31,      759.38],
+       [        864,      761.06],
+       [     874.12,      761.06],
+       [     875.81,      762.75],
+       [     879.19,      762.75],
+       [     880.88,      764.44],
+       [     887.62,      764.44],
+       [     889.31,      766.12],
+       [     892.69,      766.12],
+       [     894.38,      767.81],
+       [     901.12,      767.81],
+       [     902.81,       769.5],
+       [     906.19,       769.5],
+       [     907.88,      771.19],
+       [     911.25,      771.19],
+       [     912.94,      772.88],
+       [     919.69,      772.88],
+       [     921.38,      774.56],
+       [     926.44,      774.56],
+       [     928.12,      776.25],
+       [     934.88,      776.25],
+       [     936.56,      777.94],
+       [     943.31,      777.94],
+       [        945,      779.62],
+       [     956.81,      779.62],
+       [      958.5,      781.31],
+       [     970.31,      781.31],
+       [        972,         783],
+       [     975.38,         783],
+       [     977.06,      784.69],
+       [     983.81,      784.69],
+       [      985.5,      786.38],
+       [     995.62,      786.38],
+       [     997.31,      788.06],
+       [     1024.3,      788.06],
+       [       1026,      789.75],
+       [     1039.5,      789.75],
+       [     1041.2,      791.44],
+       [     1044.6,      791.44],
+       [     1046.2,      789.75],
+       [       1053,      789.75],
+       [     1054.7,      791.44],
+       [     1056.4,      791.44],
+       [     1058.1,      789.75],
+       [     1059.8,      789.75],
+       [     1061.4,      788.06],
+       [     1066.5,      788.06],
+       [     1068.2,      786.38],
+       [     1069.9,      786.38],
+       [     1069.9,      784.69],
+       [     1064.8,      779.62],
+       [     1064.8,      776.25],
+       [     1066.5,      774.56],
+       [     1066.5,       769.5],
+       [     1064.8,      767.81],
+       [     1064.8,      762.75],
+       [     1066.5,      761.06],
+       [     1066.5,      759.38],
+       [     1068.2,      757.69],
+       [     1068.2,      747.56],
+       [     1069.9,      745.88],
+       [     1068.2,      744.19],
+       [     1068.2,       742.5],
+       [     1066.5,      740.81],
+       [     1066.5,      739.12],
+       [     1064.8,      737.44],
+       [     1064.8,      734.06],
+       [     1063.1,      732.38],
+       [     1063.1,      730.69],
+       [     1061.4,         729],
+       [     1061.4,      725.62],
+       [     1058.1,      722.25],
+       [     1056.4,      722.25],
+       [     1054.7,      720.56],
+       [     1041.2,      720.56],
+       [     1039.5,      718.88],
+       [     1029.4,      718.88],
+       [     1027.7,      717.19],
+       [       1026,      717.19],
+       [     1022.6,      713.81],
+       [     1019.2,      713.81],
+       [     1017.6,      712.12],
+       [     1014.2,      712.12],
+       [     1012.5,      710.44],
+       [     1012.5,      708.75],
+       [     1010.8,      708.75],
+       [     1005.8,      703.69],
+       [     1005.8,      698.62],
+       [     666.56,      698.62],
+       [     631.12,      698.62],
+       [     631.12,      703.69],
+       [     629.44,      705.38],
+       [     627.75,      703.69],
+       [     627.75,      698.62],
+       [     617.62,      707.06],
+       [     615.94,      707.06],
+       [     614.25,      708.75],
+       [     612.56,      708.75],
+       [     610.88,      710.44],
+       [      607.5,      710.44],
+       [     605.81,      708.75],
+       [     595.69,      708.75],
+       [        594,      707.06],
+       [     588.94,      707.06],
+       [     587.25,      705.38],
+       [     575.44,      705.38],
+       [     573.75,      703.69],
+       [     573.75,      698.62],
+       [     545.06,       823.5],
+       [        540,       823.5],
+       [     538.31,      821.81],
+       [     533.25,      821.81],
+       [     531.56,      820.12],
+       [      526.5,      820.12],
+       [     524.81,      818.44],
+       [     518.06,      818.44],
+       [     516.38,      816.75],
+       [     509.62,      816.75],
+       [     507.94,      815.06],
+       [     501.19,      815.06],
+       [      499.5,      813.38],
+       [     494.44,      813.38],
+       [     492.75,      811.69],
+       [     487.69,      811.69],
+       [        486,         810],
+       [     480.94,         810],
+       [     479.25,      808.31],
+       [     474.19,      808.31],
+       [      472.5,      806.62],
+       [     467.44,      806.62],
+       [     465.75,      804.94],
+       [     460.69,      804.94],
+       [        459,      803.25],
+       [     452.25,      803.25],
+       [     450.56,      801.56],
+       [     443.81,      801.56],
+       [     442.12,      799.88],
+       [     433.69,      799.88],
+       [        432,      798.19],
+       [     425.25,      798.19],
+       [     423.56,       796.5],
+       [      418.5,       796.5],
+       [     416.81,      794.81],
+       [     410.06,      794.81],
+       [     408.38,      793.12],
+       [     401.62,      793.12],
+       [     399.94,      791.44],
+       [     394.88,      791.44],
+       [     393.19,      789.75],
+       [     389.81,      789.75],
+       [     388.12,      788.06],
+       [     381.38,      788.06],
+       [     379.69,      786.38],
+       [     376.31,      786.38],
+       [     374.62,      784.69],
+       [     369.56,      784.69],
+       [     367.88,         783],
+       [     362.81,         783],
+       [     361.12,      781.31],
+       [     357.75,      781.31],
+       [     356.06,      779.62],
+       [     352.69,      779.62],
+       [        351,      777.94],
+       [     344.25,      777.94],
+       [     342.56,      776.25],
+       [      337.5,      776.25],
+       [     335.81,      774.56],
+       [     329.06,      774.56],
+       [     327.38,      772.88],
+       [     322.31,      772.88],
+       [     320.62,      771.19],
+       [     315.56,      771.19],
+       [     313.88,       769.5],
+       [      310.5,       769.5],
+       [     308.81,      767.81],
+       [     303.75,      767.81],
+       [     302.06,      766.12],
+       [        297,      766.12],
+       [     295.31,      764.44],
+       [     290.25,      764.44],
+       [     288.56,      762.75],
+       [     285.19,      762.75],
+       [      283.5,      761.06],
+       [     278.44,      761.06],
+       [     276.75,      759.38],
+       [     271.69,      759.38],
+       [        270,      757.69],
+       [     264.94,      757.69],
+       [     263.25,         756],
+       [      256.5,         756],
+       [     254.81,      754.31],
+       [     249.75,      754.31],
+       [     248.06,      752.62],
+       [        243,      752.62],
+       [     241.31,      750.94],
+       [     234.56,      750.94],
+       [     232.88,      749.25],
+       [     226.12,      749.25],
+       [     224.44,      747.56],
+       [     217.69,      747.56],
+       [        216,      745.88],
+       [     210.94,      745.88],
+       [     209.25,      744.19],
+       [     204.19,      744.19],
+       [      202.5,       742.5],
+       [     197.44,       742.5],
+       [     195.75,      740.81],
+       [        189,      740.81],
+       [     187.31,      739.12],
+       [     180.56,      739.12],
+       [     178.88,      737.44],
+       [     173.81,      737.44],
+       [     172.12,      735.75],
+       [     168.75,      735.75],
+       [     167.06,      734.06],
+       [        162,      734.06],
+       [     160.31,      732.38],
+       [     153.56,      732.38],
+       [     151.88,      730.69],
+       [     146.81,      730.69],
+       [     145.12,         729],
+       [     140.06,         729],
+       [     138.38,      727.31],
+       [     133.31,      727.31],
+       [     131.62,      725.62],
+       [     126.56,      725.62],
+       [     124.88,      723.94],
+       [     119.81,      723.94],
+       [     118.12,      722.25],
+       [     113.06,      722.25],
+       [     111.38,      720.56],
+       [        108,      720.56],
+       [     106.31,      718.88],
+       [     101.25,      718.88],
+       [     99.562,      717.19],
+       [       94.5,      717.19],
+       [     92.812,       715.5],
+       [     89.438,       715.5],
+       [      87.75,      713.81],
+       [     84.375,      713.81],
+       [     82.688,      712.12],
+       [     79.312,      712.12],
+       [     77.625,      710.44],
+       [      74.25,      710.44],
+       [     72.562,      708.75],
+       [     70.875,      708.75],
+       [     69.188,      707.06],
+       [     65.812,      707.06],
+       [     64.125,      705.38],
+       [     62.438,      705.38],
+       [      60.75,      703.69],
+       [      60.75,      698.62],
+       [     10.125,      698.62],
+       [     10.125,      1078.3],
+       [     1078.3,      1078.3],
+       [     1078.3,      936.56],
+       [     1066.5,      936.56],
+       [     1064.8,      934.88],
+       [     1056.4,      934.88],
+       [     1054.7,      933.19],
+       [     1049.6,      933.19],
+       [     1047.9,       931.5],
+       [     1042.9,       931.5],
+       [     1041.2,      929.81],
+       [     1034.4,      929.81],
+       [     1032.8,      928.12],
+       [     1027.7,      928.12],
+       [       1026,      926.44],
+       [     1017.6,      926.44],
+       [     1015.9,      924.75],
+       [     1007.4,      924.75],
+       [     1005.8,      923.06],
+       [        999,      923.06],
+       [     997.31,      921.38],
+       [     992.25,      921.38],
+       [     990.56,      919.69],
+       [      985.5,      919.69],
+       [     983.81,         918],
+       [     978.75,         918],
+       [     977.06,      916.31],
+       [        972,      916.31],
+       [     970.31,      914.62],
+       [     963.56,      914.62],
+       [     961.88,      912.94],
+       [     955.12,      912.94],
+       [     953.44,      911.25],
+       [     941.62,      911.25],
+       [     939.94,      909.56],
+       [     929.81,      909.56],
+       [     928.12,      907.88],
+       [     919.69,      907.88],
+       [        918,      906.19],
+       [     912.94,      906.19],
+       [     911.25,       904.5],
+       [     907.88,       904.5],
+       [     906.19,      902.81],
+       [     902.81,      902.81],
+       [     901.12,      901.12],
+       [     896.06,      901.12],
+       [     894.38,      899.44],
+       [     889.31,      899.44],
+       [     887.62,      897.75],
+       [     879.19,      897.75],
+       [      877.5,      896.06],
+       [     872.44,      896.06],
+       [     870.75,      894.38],
+       [        864,      894.38],
+       [     862.31,      892.69],
+       [     855.56,      892.69],
+       [     853.88,         891],
+       [     848.81,         891],
+       [     847.12,      889.31],
+       [     843.75,      889.31],
+       [     842.06,      887.62],
+       [        837,      887.62],
+       [     835.31,      885.94],
+       [     826.88,      885.94],
+       [     825.19,      884.25],
+       [     818.44,      884.25],
+       [     816.75,      882.56],
+       [        810,      882.56],
+       [     808.31,      880.88],
+       [     801.56,      880.88],
+       [     799.88,      879.19],
+       [     794.81,      879.19],
+       [     793.12,       877.5],
+       [     788.06,       877.5],
+       [     786.38,      875.81],
+       [     779.62,      875.81],
+       [     777.94,      874.12],
+       [      769.5,      874.12],
+       [     767.81,      872.44],
+       [     759.38,      872.44],
+       [     757.69,      870.75],
+       [     752.62,      870.75],
+       [     750.94,      869.06],
+       [     744.19,      869.06],
+       [      742.5,      867.38],
+       [     737.44,      867.38],
+       [     735.75,      865.69],
+       [     732.38,      865.69],
+       [     730.69,         864],
+       [     727.31,         864],
+       [     725.62,      862.31],
+       [     722.25,      862.31],
+       [     720.56,      860.62],
+       [      715.5,      860.62],
+       [     713.81,      858.94],
+       [     703.69,      858.94],
+       [        702,      857.25],
+       [     691.88,      857.25],
+       [     690.19,      855.56],
+       [     685.12,      855.56],
+       [     683.44,      853.88],
+       [     676.69,      853.88],
+       [        675,      852.19],
+       [     669.94,      852.19],
+       [     668.25,       850.5],
+       [      661.5,       850.5],
+       [     659.81,      848.81],
+       [     653.06,      848.81],
+       [     651.38,      847.12],
+       [     646.31,      847.12],
+       [     644.62,      845.44],
+       [     639.56,      845.44],
+       [     637.88,      843.75],
+       [     632.81,      843.75],
+       [     631.12,      842.06],
+       [     627.75,      842.06],
+       [     626.06,      840.38],
+       [        621,      840.38],
+       [     619.31,      838.69],
+       [     615.94,      838.69],
+       [     614.25,         837],
+       [     609.19,         837],
+       [      607.5,      835.31],
+       [     602.44,      835.31],
+       [     600.75,      833.62],
+       [        594,      833.62],
+       [     592.31,      831.94],
+       [      580.5,      831.94],
+       [     578.81,      830.25],
+       [     568.69,      830.25],
+       [        567,      828.56],
+       [     560.25,      828.56],
+       [     558.56,      826.88],
+       [      553.5,      826.88],
+       [     551.81,      825.19],
+       [     546.75,      825.19],
+       [     545.06,       823.5],
+       [     573.75,      698.62],
+       [        621,      698.62],
+       [        621,      703.69],
+       [     617.62,      707.06],
+       [     627.75,      698.62],
+       [     631.12,      698.62]], dtype=float32)], 'original_image': array([[[255, 236,  71],
+        [251, 229,  63],
+        [233, 207,  41],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       [[255, 235,  70],
+        [251, 229,  63],
+        [237, 210,  42],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       [[255, 231,  65],
+        [253, 229,  63],
+        [243, 214,  46],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       ...,
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 61,  81,  28],
+        [ 61,  81,  28],
+        [ 61,  81,  28]],
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 61,  81,  28],
+        [ 61,  81,  28],
+        [ 61,  81,  28]],
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 61,  81,  28],
+        [ 61,  81,  28],
+        [ 61,  81,  28]]], shape=(1080, 1080, 3), dtype=uint8), 'pose_image_result': array([[[255, 236,  71],
+        [251, 229,  63],
+        [233, 207,  41],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       [[255, 235,  70],
+        [251, 229,  63],
+        [237, 210,  42],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       [[255, 231,  65],
+        [253, 229,  63],
+        [243, 214,  46],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       ...,
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 61,  81,  28],
+        [ 61,  81,  28],
+        [ 61,  81,  28]],
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 61,  81,  28],
+        [ 61,  81,  28],
+        [ 61,  81,  28]],
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 61,  81,  28],
+        [ 61,  81,  28],
+        [ 61,  81,  28]]], shape=(1080, 1080, 3), dtype=uint8), 'segment_image_result': array([[[253, 232,  67],
+        [245, 222,  56],
+        [232, 206,  39],
+        ...,
+        [241, 184,   0],
+        [241, 184,   0],
+        [241, 184,   0]],
+
+       [[253, 231,  65],
+        [247, 222,  56],
+        [237, 209,  42],
+        ...,
+        [241, 184,   0],
+        [241, 184,   0],
+        [241, 184,   0]],
+
+       [[254, 229,  63],
+        [250, 223,  56],
+        [243, 213,  45],
+        ...,
+        [241, 184,   0],
+        [241, 184,   0],
+        [241, 184,   0]],
+
+       ...,
+
+       [[ 88, 115,  49],
+        [ 88, 115,  49],
+        [ 88, 115,  49],
+        ...,
+        [158,  61,  15],
+        [158,  61,  15],
+        [158,  61,  15]],
+
+       [[ 88, 115,  49],
+        [ 88, 115,  49],
+        [ 88, 115,  49],
+        ...,
+        [158,  61,  15],
+        [158,  61,  15],
+        [158,  61,  15]],
+
+       [[ 88, 115,  49],
+        [ 88, 115,  49],
+        [ 88, 115,  49],
+        ...,
+        [158,  61,  15],
+        [158,  61,  15],
+        [158,  61,  15]]], shape=(1080, 1080, 3), dtype=uint8), 'final_image_result': array([[[254, 235,  70],
+        [249, 227,  61],
+        [233, 207,  40],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       [[254, 234,  68],
+        [250, 227,  61],
+        [237, 210,  42],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       [[255, 230,  64],
+        [252, 227,  61],
+        [243, 214,  46],
+        ...,
+        [241, 184,   1],
+        [241, 184,   1],
+        [241, 184,   1]],
+
+       ...,
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 90,  75,  24],
+        [ 90,  75,  24],
+        [ 90,  75,  24]],
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 90,  75,  24],
+        [ 90,  75,  24],
+        [ 90,  75,  24]],
+
+       [[ 88, 116,  50],
+        [ 88, 116,  50],
+        [ 88, 116,  50],
+        ...,
+        [ 90,  75,  24],
+        [ 90,  75,  24],
+        [ 90,  75,  24]]], shape=(1080, 1080, 3), dtype=uint8), 'meter_value': 12, 'last_valid_keypoint_cm': 80, 'cm_distance': np.float64(0.0), 'final_draft_cm': np.float64(85.0)}  
+        ...,
+        [ 90,  75,  24],
+        [ 90,  75,  24],
+        ...,
+        [ 90,  75,  24],
+        ...,
+        [ 90,  75,  24],
+        ...,
+        ...,
+        ...,
+        ...,
+        [ 90,  75,  24],
+        ...,
+        [ 90,  75,  24],
+        ...,
+        [ 90,  75,  24],
+        [ 90,  75,  24],
+        [ 90,  75,  24],
+        [ 90,  75,  24]]], shape=(1080, 1080, 3), dtype=uint8), 'meter_value': 12, 'last_valid_keypoint_cm': 80, 'cm_distance': np.float64(0.0), 'final_draft_cm': np.float64(85.0)} 

services/pdf_service.py

@@ -0,0 +1,128 @@
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from reportlab.lib.utils import ImageReader
+from io import BytesIO
+from models.schemas import MeasurementMetadata, MeasurementResult
+from PIL import Image, ImageDraw
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class PdfService:
+    """
+    A service to generate PDF reports.
+    """
+    def create_report(
+        self, 
+        image_bytes: bytes, 
+        metadata: MeasurementMetadata, 
+        results: MeasurementResult,
+        ml_results: dict
+    ) -> bytes:
+        """
+        Generates a PDF report with the measurement data.
+        """
+        logger.info(f"Creating PDF with metadata: {metadata}")
+        logger.info(f"Creating PDF with results: {results}")
+
+        buffer = BytesIO()
+        p = canvas.Canvas(buffer, pagesize=letter)
+        width, height = letter
+
+        # Title
+        p.setFont("Helvetica-Bold", 16)
+        p.drawString(72, height - 72, "Ship Draft Measurement Report")
+
+        # Metadata
+        p.setFont("Helvetica", 12)
+        p.drawString(72, height - 108, f"Ship ID: {metadata.ship_id}")
+        p.drawString(72, height - 126, f"Timestamp: {metadata.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
+        p.drawString(72, height - 144, f"Latitude: {metadata.latitude}")
+        p.drawString(72, height - 162, f"Longitude: {metadata.longitude}")
+
+        # # Measurement Results
+        # p.setFont("Helvetica-Bold", 14)
+        # p.drawString(72, height - 198, "Measurement Results")
+        # p.setFont("Helvetica", 12)
+        # p.drawString(90, height - 218, f"Draft Measurement: {results.draft_measurement:.1f} meters")
+        # p.drawString(90, height - 236, f"Confidence Score: {results.confidence_score:.2%}")
+
+        # ML Results
+        p.setFont("Helvetica-Bold", 14)
+        y_position = height - 270
+        p.drawString(72, y_position, "ML Results")
+        y_position -= 18
+        p.setFont("Helvetica", 12)
+
+        # Highlight draft from ML results
+        if 'draft' in ml_results:
+            p.setFont("Helvetica-Bold", 12) # Highlight
+            p.drawString(90, y_position, f"ML Draft: {ml_results['draft']:.2f} meters")
+            p.setFont("Helvetica", 12) # Reset font
+            y_position -= 18
+
+        # Add other ML results (excluding arrays and images)
+        for key, value in ml_results.items():
+            if key in ['pose_results', 'segment_results', 'original_image', 'pose_image_result', 'segment_image_result', 'final_image_result']:
+                continue
+            p.drawString(90, y_position, f"{key.replace('_', ' ').title()}: {value}")
+            y_position -= 18
+
+        # Images
+        p.setFont("Helvetica-Bold", 14)
+        y_position -= 18
+        p.drawString(72, y_position, "Images")
+        y_position -= 18
+        p.setFont("Helvetica", 12)
+
+        # Convert numpy arrays to PIL Image and then to bytes for ReportLab
+        def get_image_bytes(np_array):
+            if np_array is None:
+                return None
+            img = Image.fromarray(np_array.astype('uint8'))
+            img_byte_arr = BytesIO()
+            img.save(img_byte_arr, format='PNG')
+            return img_byte_arr.getvalue()
+
+        # Define starting positions and dimensions for horizontal layout
+        x_start = 72
+        image_width = 150
+        image_height = 150 # Assuming square or adjust as needed
+        y_image_row = y_position - image_height - 20 # Position for the bottom of the images
+
+        current_x = x_start
+
+        # Draw original image
+        if 'original_image' in ml_results and ml_results['original_image'] is not None:
+            original_img_bytes = get_image_bytes(ml_results['original_image'])
+            if original_img_bytes:
+                p.drawString(current_x, y_image_row + image_height + 5, "Original Image:") # Label above image
+                p.drawImage(ImageReader(BytesIO(original_img_bytes)), current_x, y_image_row, width=image_width, height=image_height, preserveAspectRatio=True)
+                current_x += image_width + 20 # Move x for next image
+
+        # Draw pose image result
+        if 'pose_image_result' in ml_results and ml_results['pose_image_result'] is not None:
+            pose_img_bytes = get_image_bytes(ml_results['pose_image_result'])
+            if pose_img_bytes:
+                p.drawString(current_x, y_image_row + image_height + 5, "Pose Image Result:")
+                p.drawImage(ImageReader(BytesIO(pose_img_bytes)), current_x, y_image_row, width=image_width, height=image_height, preserveAspectRatio=True)
+                current_x += image_width + 20
+
+        # Draw segment image result
+        if 'segment_image_result' in ml_results and ml_results['segment_image_result'] is not None:
+            segment_img_bytes = get_image_bytes(ml_results['segment_image_result'])
+            if segment_img_bytes:
+                p.drawString(current_x, y_image_row + image_height + 5, "Segment Image Result:")
+                p.drawImage(ImageReader(BytesIO(segment_img_bytes)), current_x, y_image_row, width=image_width, height=image_height, preserveAspectRatio=True)
+                # No need to update current_x as it's the last image in the row
+
+        # Update y_position for content after images
+        y_position = y_image_row - 20 # Adjust y_position to be below the images
+
+        p.showPage()
+        p.save()
+
+        pdf_bytes = buffer.getvalue()
+        buffer.close()
+        return pdf_bytes

services/persistence_service.py

@@ -0,0 +1,148 @@
+import base64
+import os
+from models.database import SessionLocal, Report
+from models.schemas import MeasurementMetadata
+import smtplib
+from email.mime.multipart import MIMEMultipart
+from email.mime.base import MIMEBase
+from email import encoders
+
+from typing import Optional
+from datetime import datetime
+
+
+REPORTS_DIR = "reports"
+
+class PersistenceService:
+    """
+    A service to handle the persistence of the report.
+    """
+    def __init__(self):
+        if not os.path.exists(REPORTS_DIR):
+            os.makedirs(REPORTS_DIR)
+
+    def save_to_disk(self, pdf_bytes: bytes, metadata: MeasurementMetadata) -> str:
+        """Saves the PDF report to the disk."""
+        filename = f"report_{metadata.ship_id}_{metadata.timestamp.strftime('%Y%m%d%H%M%S')}.pdf"
+        file_path = os.path.join(REPORTS_DIR, filename)
+        with open(file_path, "wb") as f:
+            f.write(pdf_bytes)
+        return file_path # Return the full file_path
+
+    def save_to_db(self, file_path: str, metadata: MeasurementMetadata, draft_measurement: float, confidence_score: float, image_bytes: bytes):
+        """Saves the report metadata to the database."""
+        db = SessionLocal()
+        db_report = Report(
+            ship_id=metadata.ship_id,
+            timestamp=metadata.timestamp,
+            latitude=metadata.latitude,
+            longitude=metadata.longitude,
+            draft_measurement=draft_measurement,
+            confidence_score=confidence_score,
+            pdf_path=file_path,
+            image_bytes=image_bytes
+        )
+        db.add(db_report)
+        db.commit()
+        db.refresh(db_report)
+        db.close()
+
+    def get_all_reports(
+        self,
+        skip: int = 0,
+        limit: int = 10,
+        search: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+    ):
+        """Retrieves all reports from the database with pagination and filtering."""
+        db = SessionLocal()
+        # Explicitly select columns including image_bytes
+        query = db.query(
+            Report.id,
+            Report.ship_id,
+            Report.timestamp,
+            Report.latitude,
+            Report.longitude,
+            Report.draft_measurement,
+            Report.confidence_score,
+            Report.pdf_path,
+            Report.image_bytes # Include image_bytes
+        )
+
+        if search:
+            query = query.filter(Report.ship_id.contains(search))
+
+        if start_date:
+            query = query.filter(Report.timestamp >= start_date)
+
+        if end_date:
+            query = query.filter(Report.timestamp <= end_date)
+
+        reports = query.offset(skip).limit(limit).all()
+        db.close()
+
+        # Convert SQLAlchemy Row objects to dictionaries and Base64 encode image_bytes
+        column_names = [
+            "id", "ship_id", "timestamp", "latitude", "longitude",
+            "draft_measurement", "confidence_score", "pdf_path", "image_bytes" # Add image_bytes
+        ]
+        reports_as_dicts = []
+        for report_row in reports:
+            report_dict = {name: value for name, value in zip(column_names, report_row)}
+            if report_dict["image_bytes"]:
+                # Base64 encode the image bytes
+                report_dict["image_bytes"] = base64.b64encode(report_dict["image_bytes"]).decode('utf-8')
+            reports_as_dicts.append(report_dict)
+
+        return reports_as_dicts
+
+    def get_report_by_id(self, report_id: int):
+        """Retrieves a single report by its ID."""
+        db = SessionLocal()
+        report = db.query(Report).filter(Report.id == report_id).first()
+        db.close()
+        return report
+
+    def send_by_email(self, file_path: str, recipient_email: str):
+        """
+        Sends the PDF report as an email attachment.
+        NOTE: This is a placeholder and requires real SMTP configuration.
+        """
+        # In a real application, these would come from a config file
+        smtp_server = "smtp.gmail.com"
+        smtp_port = 587
+        sender_email = "copfnf@gmail.com"
+        sender_password = "@26484295may"
+        recipient_email = "pfnfcat@gmail.com"
+        msg = MIMEMultipart()
+        msg["From"] = sender_email
+        msg["To"] = recipient_email
+        msg["Subject"] = f"Ship Draft Report: {os.path.basename(file_path)}"
+
+        with open(file_path, "rb") as attachment:
+            part = MIMEBase("application", "octet-stream")
+            part.set_payload(attachment.read())
+        
+        encoders.encode_base64(part)
+        part.add_header(
+            "Content-Disposition",
+            f"attachment; filename= {os.path.basename(file_path)}",
+        )
+        msg.attach(part)
+
+        print(f"\n--- EMAIL SIMULATION ---")
+        print(f"Sending email to {recipient_email} from {sender_email}")
+        print(f"Attaching file: {file_path}")
+        print(f"--- END EMAIL SIMULATION ---")
+
+        # The following code would send the email
+        try:
+            server = smtplib.SMTP(smtp_server, smtp_port)
+            server.starttls()
+            server.login(sender_email, sender_password)
+            server.sendmail(sender_email, recipient_email, msg.as_string())
+            server.quit()
+            print("Email sent successfully!")
+        except Exception as e:
+            print(f"Failed to send email: {e}")