Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,593 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/Costa_Rica_Red_Honey_Don_Oscar-green-prediction.png filter=lfs diff=lfs merge=lfs -text
+data/Costa_Rica_Red_Honey_Don_Oscar-green.png filter=lfs diff=lfs merge=lfs -text
+data/Costa_Rica_Zarcero_Monte_Brisas-roasted.png filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libavif.16.3.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libbrotlicommon.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libbrotlidec.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libfreetype.6.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libharfbuzz.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libjpeg.62.4.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/liblcms2.2.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/liblzma.5.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libopenjp2.2.5.3.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libpng16.16.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libtiff.6.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libwebp.7.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libwebpmux.3.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libxcb.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/.dylibs/libz.1.3.1.zlib-ng.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/__pycache__/Image.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/__pycache__/TiffImagePlugin.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/_imaging.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/PIL/_imagingft.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/__pycache__/typing_extensions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/contourpy/_contourpy.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libSvtAv1Enc.3.0.2.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libX11.6.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libaom.3.12.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libaribb24.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libavcodec.61.19.101.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libavformat.61.7.100.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libavif.16.3.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libavutil.59.39.100.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libbluray.2.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libbrotlicommon.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libbrotlidec.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libbrotlienc.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libcrypto.3.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libdav1d.7.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libfontconfig.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libfreetype.6.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libgmp.10.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libgnutls.30.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libhogweed.6.10.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libidn2.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libintl.8.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libjxl.0.11.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libjxl_cms.0.11.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/liblcms2.2.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/liblzma.5.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libmbedcrypto.3.6.3.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libmp3lame.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libnettle.8.10.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libopencore-amrnb.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libopencore-amrwb.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libopenjp2.2.5.3.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libopus.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libp11-kit.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libpng16.16.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/librav1e.0.8.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/librist.4.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libsodium.26.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libsoxr.0.1.2.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libspeex.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libsrt.1.5.4.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libssh.4.10.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libssl.3.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libswresample.5.3.100.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libswscale.8.3.100.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libtasn1.6.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libtheoradec.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libtheoraenc.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libunistring.5.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libvmaf.3.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libvorbis.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libvorbisenc.2.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libvpx.11.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libwebp.7.1.10.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libx264.164.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libx265.215.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libxcb.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/.dylibs/libzmq.5.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/cv2/cv2.abi3.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/__pycache__/agl.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/cffLib/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/cu2qu/cu2qu.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/designspaceLib/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/feaLib/__pycache__/ast.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/feaLib/__pycache__/parser.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/feaLib/lexer.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/misc/bezierTools.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/otlLib/__pycache__/builder.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/pens/momentsPen.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/qu2cu/qu2cu.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/subset/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/ttLib/tables/__pycache__/otConverters.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/ttLib/tables/__pycache__/otTables.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/fontTools/varLib/iup.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/functorch/_C.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/jinja2/__pycache__/compiler.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/kiwisolver/_cext.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/_cm_listed.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/_mathtext.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/axis.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/backend_bases.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/collections.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/colors.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/figure.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/patches.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/pyplot.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/ticker.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/transforms.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/__pycache__/widgets.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/_c_internal_utils.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/_image.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/_path.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/_qhull.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/_tri.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/axes/__pycache__/_axes.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/axes/__pycache__/_base.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/backends/__pycache__/backend_pdf.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/backends/_backend_agg.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/backends/_macosx.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/backends/_tkagg.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/ft2font.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans-BoldOblique.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans-Oblique.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSans.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-BoldOblique.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono-Oblique.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSansMono.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-BoldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/DejaVuSerif.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneral.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralBol.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralBolIta.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/mpl-data/fonts/ttf/STIXGeneralItalic.ttf filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/tests/__pycache__/test_axes.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/tests/__pycache__/test_figure.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/tests/__pycache__/test_image.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/matplotlib/tests/__pycache__/test_ticker.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/mpl_toolkits/mplot3d/__pycache__/axes3d.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/mpl_toolkits/mplot3d/tests/__pycache__/test_axes3d.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/mpmath/__pycache__/function_docs.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/mpmath/tests/__pycache__/test_fp.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/mpmath/tests/__pycache__/test_functions2.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/networkx/drawing/__pycache__/nx_pylab.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/networkx/drawing/tests/baseline/test_display_complex.png filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/__pycache__/_add_newdocs.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/__pycache__/fromnumeric.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/_multiarray_tests.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/_multiarray_umath.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/_simd.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_datetime.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_dtype.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_multiarray.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_nditer.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_numeric.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_regression.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_ufunc.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/_core/tests/__pycache__/test_umath.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/f2py/__pycache__/crackfortran.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/fft/_pocketfft_umath.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/lib/__pycache__/_function_base_impl.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/lib/tests/__pycache__/test_function_base.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/lib/tests/__pycache__/test_io.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/linalg/__pycache__/_linalg.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/linalg/_umath_linalg.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/linalg/tests/__pycache__/test_linalg.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/ma/__pycache__/core.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/ma/tests/__pycache__/test_core.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/ma/tests/__pycache__/test_extras.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/_bounded_integers.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/_common.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/_generator.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/_mt19937.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/_pcg64.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/_philox.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/bit_generator.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/mtrand.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/tests/__pycache__/test_generator_mt19937.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/tests/__pycache__/test_random.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/random/tests/__pycache__/test_randomstate.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/testing/_private/__pycache__/utils.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/numpy/testing/tests/__pycache__/test_utils.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/algos.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/arrays.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/groupby.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/hashing.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/hashtable.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/index.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/internals.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/interval.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/join.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/lib.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/missing.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/ops.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/parsers.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/reshape.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/sas.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/sparse.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/testing.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslib.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/conversion.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/dtypes.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/fields.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/nattype.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/np_datetime.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/offsets.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/parsing.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/period.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/strptime.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/timedeltas.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/timestamps.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/timezones.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/tzconversion.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/tslibs/vectorized.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/window/aggregations.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/window/indexers.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/_libs/writers.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/__pycache__/frame.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/__pycache__/generic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/__pycache__/indexing.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/__pycache__/series.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/arrays/__pycache__/categorical.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/arrays/arrow/__pycache__/array.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/groupby/__pycache__/groupby.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/indexes/__pycache__/base.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/indexes/__pycache__/multi.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/reshape/__pycache__/merge.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/core/strings/__pycache__/accessor.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/io/__pycache__/pytables.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/io/__pycache__/sql.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/io/__pycache__/stata.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/io/formats/__pycache__/style.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/__pycache__/test_algos.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/arithmetic/__pycache__/test_datetime64.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/arithmetic/__pycache__/test_timedelta64.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/computation/__pycache__/test_eval.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/dtypes/__pycache__/test_inference.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/extension/__pycache__/test_arrow.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/frame/__pycache__/test_arithmetic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/frame/__pycache__/test_constructors.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/frame/__pycache__/test_reductions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/frame/__pycache__/test_stack_unstack.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/frame/indexing/__pycache__/test_indexing.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/groupby/__pycache__/test_groupby.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/indexing/__pycache__/test_loc.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/io/__pycache__/test_sql.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/io/__pycache__/test_stata.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/io/formats/__pycache__/test_format.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/io/json/__pycache__/test_pandas.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/plotting/__pycache__/test_datetimelike.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/plotting/frame/__pycache__/test_frame.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/resample/__pycache__/test_datetime_index.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/reshape/__pycache__/test_pivot.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/reshape/merge/__pycache__/test_merge.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/series/__pycache__/test_constructors.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pandas/tests/tools/__pycache__/test_to_datetime.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/distlib/t64-arm.exe filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/distlib/t64.exe filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/distlib/w64.exe filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pip/_vendor/rich/__pycache__/console.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pkg_resources/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/pyparsing/__pycache__/core.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/safetensors/_safetensors_rust.abi3.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/.dylibs/libgcc_s.1.1.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/.dylibs/libgfortran.5.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/.dylibs/libquadmath.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/_cyutility.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/_lib/_ccallback_c.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/_lib/_uarray/_uarray.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/cluster/__pycache__/hierarchy.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/cluster/_hierarchy.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/cluster/_optimal_leaf_ordering.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/cluster/_vq.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/constants/__pycache__/_codata.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/fft/_pocketfft/pypocketfft.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/fftpack/convolve.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/integrate/__pycache__/_lebedev.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/integrate/_dop.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/integrate/_lsoda.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/integrate/_odepack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/integrate/_quadpack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/integrate/_test_odeint_banded.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/integrate/_vode.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/_dfitpack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/_fitpack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/_interpnd.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/_ppoly.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/_rbfinterp_pythran.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/_rgi_cython.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/tests/__pycache__/test_bsplines.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/interpolate/tests/__pycache__/test_interpolate.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/io/_fast_matrix_market/_fmm_core.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/io/matlab/_mio5_utils.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/io/matlab/_streams.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_cythonized_array_utils.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_decomp_interpolative.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_decomp_lu_cython.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_decomp_update.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_fblas.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_flapack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_linalg_pythran.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_matfuncs_expm.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_matfuncs_sqrtm_triu.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/_solve_toeplitz.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/cython_blas.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/cython_lapack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/tests/__pycache__/test_basic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/tests/__pycache__/test_decomp.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/tests/__pycache__/test_decomp_update.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/linalg/tests/__pycache__/test_lapack.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/ndimage/_nd_image.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/ndimage/_ni_label.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/ndimage/tests/__pycache__/test_filters.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/ndimage/tests/__pycache__/test_morphology.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/odr/__odrpack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/__pycache__/_optimize.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/_bglu_dense.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/_highspy/_core.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/_highspy/_highs_options.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/_minpack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/_moduleTNC.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/_pava_pybind.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/_trlib/_trlib.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/cython_optimize/_zeros.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/tests/__pycache__/test_linprog.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/optimize/tests/__pycache__/test_optimize.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/__pycache__/_filter_design.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/__pycache__/_ltisys.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/__pycache__/_short_time_fft.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/__pycache__/_signaltools.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/_peak_finding_utils.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/_sigtools.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/_sosfilt.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/_upfirdn_apply.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/tests/__pycache__/test_filter_design.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/tests/__pycache__/test_signaltools.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/signal/tests/__pycache__/test_spectral.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/_csparsetools.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/_sparsetools.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/csgraph/_flow.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/csgraph/_matching.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/csgraph/_min_spanning_tree.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/csgraph/_reordering.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/csgraph/_shortest_path.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/csgraph/_tools.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/csgraph/_traversal.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/linalg/_dsolve/_superlu.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/linalg/_eigen/arpack/_arpack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/linalg/_propack/_cpropack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/linalg/_propack/_dpropack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/linalg/_propack/_spropack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/linalg/_propack/_zpropack.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/sparse/tests/__pycache__/test_base.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/__pycache__/distance.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/_ckdtree.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/_distance_pybind.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/_distance_wrap.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/_hausdorff.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/_qhull.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/tests/__pycache__/test_distance.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/transform/_rigid_transform.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/transform/_rotation.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/spatial/transform/tests/__pycache__/test_rotation.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/__pycache__/_add_newdocs.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/__pycache__/_basic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/_ellip_harm_2.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/_gufuncs.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/_specfun.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/_special_ufuncs.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/_test_internal.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/_ufuncs.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/_ufuncs_cxx.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/cython_special.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/tests/__pycache__/test_basic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/tests/__pycache__/test_legendre.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/special/tests/__pycache__/test_mpmath.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_continuous_distns.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_distn_infrastructure.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_distribution_infrastructure.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_morestats.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_mstats_basic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_multivariate.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_qmc.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_resampling.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/__pycache__/_stats_py.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_ansari_swilk_statistics.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_biasedurn.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_qmc_cy.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_qmvnt_cy.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_rcont/rcont.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_sobol.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_stats.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_stats_pythran.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/_unuran/unuran_wrapper.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/tests/__pycache__/test_continuous.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/tests/__pycache__/test_distributions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/tests/__pycache__/test_morestats.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/tests/__pycache__/test_mstats_basic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/tests/__pycache__/test_multivariate.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/tests/__pycache__/test_resampling.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/scipy/stats/tests/__pycache__/test_stats.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/seaborn/__pycache__/categorical.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/setuptools/_vendor/__pycache__/typing_extensions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/setuptools/_vendor/backports/tarfile/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/setuptools/_vendor/inflect/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/setuptools/_vendor/more_itertools/__pycache__/more.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/assumptions/tests/__pycache__/test_query.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/concrete/tests/__pycache__/test_sums_products.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/__pycache__/expr.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/__pycache__/function.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/__pycache__/numbers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/tests/__pycache__/test_args.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/tests/__pycache__/test_expr.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/tests/__pycache__/test_function.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/tests/__pycache__/test_numbers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/crypto/__pycache__/crypto.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/combinatorial/__pycache__/numbers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_numbers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/elementary/__pycache__/hyperbolic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/elementary/__pycache__/trigonometric.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/elementary/tests/__pycache__/test_hyperbolic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/elementary/tests/__pycache__/test_piecewise.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/elementary/tests/__pycache__/test_trigonometric.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/special/__pycache__/error_functions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/special/tests/__pycache__/test_bessel.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/functions/special/tests/__pycache__/test_error_functions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/holonomic/__pycache__/holonomic.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/integrals/__pycache__/laplace.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/integrals/__pycache__/manualintegrate.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/integrals/__pycache__/meijerint.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/integrals/tests/__pycache__/test_integrals.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/logic/__pycache__/boolalg.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/logic/tests/__pycache__/test_boolalg.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/matrices/__pycache__/common.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/matrices/__pycache__/matrixbase.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/matrices/tests/__pycache__/test_matrices.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/parsing/autolev/__pycache__/_listener_autolev_antlr.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/parsing/autolev/_antlr/__pycache__/autolevparser.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/parsing/latex/_antlr/__pycache__/latexparser.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/parsing/tests/__pycache__/test_c_parser.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/__pycache__/secondquant.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/biomechanics/tests/__pycache__/test_curve.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/continuum_mechanics/__pycache__/beam.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/control/__pycache__/lti.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/control/tests/__pycache__/test_lti.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/mechanics/tests/__pycache__/test_joint.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/quantum/__pycache__/spin.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/physics/quantum/tests/__pycache__/test_spin.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/plotting/__pycache__/series.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/plotting/tests/__pycache__/test_series.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/__pycache__/compatibility.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/__pycache__/polyclasses.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/__pycache__/polyquinticconst.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/__pycache__/polytools.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/__pycache__/rings.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/benchmarks/__pycache__/bench_solvers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/domains/tests/__pycache__/test_domains.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/matrices/__pycache__/domainmatrix.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/matrices/tests/__pycache__/test_domainmatrix.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/numberfields/__pycache__/resolvent_lookup.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/tests/__pycache__/test_polytools.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/polys/tests/__pycache__/test_rings.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/printing/__pycache__/latex.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/printing/__pycache__/mathml.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/printing/pretty/__pycache__/pretty.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/printing/pretty/tests/__pycache__/test_pretty.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/printing/tests/__pycache__/test_latex.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/printing/tests/__pycache__/test_mathml.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/series/tests/__pycache__/test_limits.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/sets/__pycache__/sets.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/sets/tests/__pycache__/test_fancysets.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/sets/tests/__pycache__/test_sets.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/__pycache__/solvers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/__pycache__/solveset.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/diophantine/__pycache__/diophantine.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/ode/__pycache__/ode.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/ode/__pycache__/single.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/ode/tests/__pycache__/test_ode.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/ode/tests/__pycache__/test_single.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/ode/tests/__pycache__/test_systems.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/tests/__pycache__/test_solvers.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/solvers/tests/__pycache__/test_solveset.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/stats/__pycache__/crv_types.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/stats/__pycache__/stochastic_process_types.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/stats/tests/__pycache__/test_continuous_rv.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/tensor/__pycache__/tensor.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/tensor/array/expressions/__pycache__/array_expressions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/tensor/tests/__pycache__/test_tensor.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/utilities/__pycache__/iterables.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/utilities/tests/__pycache__/test_lambdify.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/sympy/utilities/tests/__pycache__/test_wester.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/__pycache__/_meta_registrations.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/__pycache__/_tensor_docs.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/__pycache__/_torch_docs.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/__pycache__/overrides.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_decomp/__pycache__/decompositions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/__pycache__/guards.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/__pycache__/output_graph.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/__pycache__/symbolic_convert.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/__pycache__/trace_rules.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/__pycache__/utils.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/variables/__pycache__/builder.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/variables/__pycache__/builtin.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/variables/__pycache__/functions.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_dynamo/variables/__pycache__/higher_order_ops.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_export/serde/__pycache__/serialize.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_functorch/__pycache__/partitioners.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/codecache.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/compile_fx.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/cudagraph_trees.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/graph.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/ir.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/lowering.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/pattern_matcher.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/scheduler.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/select_algorithm.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/__pycache__/utils.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/codegen/__pycache__/common.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/codegen/__pycache__/cpp.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/codegen/__pycache__/cpp_wrapper_cpu.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/codegen/__pycache__/simd.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/codegen/__pycache__/triton.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/codegen/__pycache__/wrapper.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/fx_passes/__pycache__/quantization.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/fx_passes/__pycache__/split_cat.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/kernel/__pycache__/flex_attention.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_inductor/runtime/__pycache__/triton_heuristics.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_refs/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/_subclasses/__pycache__/fake_tensor.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/backends/_nnapi/__pycache__/serializer.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/bin/protoc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/bin/protoc-3.13.0.0 filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/distributed/__pycache__/distributed_c10d.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/distributed/fsdp/__pycache__/_flat_param.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/distributed/pipelining/__pycache__/schedules.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/fx/experimental/__pycache__/proxy_tensor.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/fx/experimental/__pycache__/symbolic_shapes.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/lib/libc10.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/lib/libomp.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/lib/libtorch_cpu.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/lib/libtorch_python.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/linalg/__pycache__/__init__.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/nested/_internal/__pycache__/ops.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/nn/__pycache__/functional.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/nn/modules/__pycache__/module.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/nn/parallel/__pycache__/distributed.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/onnx/__pycache__/symbolic_opset9.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/sparse/__pycache__/_triton_ops_meta.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/__pycache__/common_methods_invocations.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/__pycache__/common_modules.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/__pycache__/common_nn.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/__pycache__/common_quantization.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/__pycache__/common_utils.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/distributed/__pycache__/distributed_test.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/distributed/rpc/__pycache__/dist_autograd_test.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/distributed/rpc/__pycache__/rpc_test.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/generated/__pycache__/annotated_fn_args.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/testing/_internal/opinfo/__pycache__/core.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/utils/__pycache__/cpp_extension.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torch/utils/hipify/__pycache__/cuda_to_hip_mappings.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchgen/__pycache__/gen.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchgen/__pycache__/model.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/.dylibs/libc++.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/.dylibs/libjpeg.8.2.2.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/.dylibs/libpng16.16.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/.dylibs/libwebp.7.1.8.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/.dylibs/libz.1.2.13.dylib filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/_C.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/image.so filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/transforms/__pycache__/transforms.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/torchvision/transforms/v2/functional/__pycache__/_geometry.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text
+venv/lib/python3.13/site-packages/yaml/_yaml.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text

.ipynb_checkpoints/README-checkpoint.md

@@ -0,0 +1,258 @@
+---
+license: mit
+tags:
+- vision
+- image-segmentation
+- instance-segmentation
+- object-detection
+- pytorch
+- mask-rcnn
+- coffee
+- quality-control
+datasets:
+- custom
+metrics:
+- iou
+- precision
+- recall
+- mAP
+model-index:
+- name: coffee-bean-maskrcnn
+  results:
+  - task:
+      type: instance-segmentation
+      name: Instance Segmentation
+    dataset:
+      name: Coffee Bean Dataset
+      type: custom
+    metrics:
+    - type: precision
+      value: 99.92
+      name: Precision
+    - type: recall
+      value: 96.71
+      name: Recall
+    - type: iou
+      value: 90.93
+      name: Average IoU
+    - type: detection-rate
+      value: 96.71
+      name: Detection Rate
+library_name: pytorch
+pipeline_tag: image-segmentation
+---
+
+# Coffee Bean Detection - Fine-tuned Mask R-CNN
+
+## Model Details
+
+### Model Description
+
+This is a fine-tuned Mask R-CNN model specialized for detecting and segmenting individual coffee beans in images. The model performs instance segmentation, providing precise pixel-level masks and bounding boxes for each detected coffee bean.
+
+- **Developed by:** Mark Kunitomi
+- **Model type:** Instance Segmentation (Mask R-CNN)
+- **Architecture:** ResNet-50 FPN backbone
+- **Language:** Not applicable
+- **License:** MIT
+
+### Model Sources
+
+- **Repository:** [GitHub - Bean Vision](https://github.com/Markkunitomi/bean-vision)
+- **Paper:** Based on [Mask R-CNN](https://arxiv.org/abs/1703.06870)
+
+## Uses
+
+### Direct Use
+
+This model is designed for:
+
+- Bean size and shape analysis for roasting optimization
+- Research in agricultural computer vision
+- Educational purposes in computer vision applications
+
+### Downstream Use
+
+The model can be fine-tuned for:
+- Specific coffee varieties or roast levels
+- Other small object detection tasks
+- Agricultural produce sorting and grading
+- Industrial quality inspection tasks
+
+### Out-of-Scope Use
+
+This model is not suitable for:
+- Medical imaging or diagnosis
+- Security or surveillance applications
+- Real-time applications requiring < 100ms latency
+- Detection of objects other than coffee beans without fine-tuning
+
+## Bias, Risks, and Limitations
+
+### Limitations
+- Trained specifically on coffee beans; limited generalization to other objects
+- Best performance on top-down views of beans on flat surfaces
+- May struggle with heavily occluded or stacked beans
+- Performance varies with extreme roast levels (very light or charred beans)
+
+### Recommendations
+- Use confidence threshold of 0.5 or higher for production applications
+- Validate on your specific bean varieties before deployment
+- Consider additional fine-tuning for specialized use cases
+- Implement human verification for critical applications
+
+## Example Results
+
+![Coffee Bean Detection Example](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/hub/coffee-beans-detection-example.png)
+
+*Example showing detection and segmentation of coffee beans with confidence scores. The model accurately identifies individual beans even when they are touching or partially overlapping.*
+
+## How to Get Started with the Model
+
+### Quick Start with Jupyter Notebook
+
+A complete inference notebook (`inference_demo.ipynb`) is included with this model. It provides:
+- Step-by-step setup instructions
+- Complete BeanPredictor class implementation
+- Visualization tools
+- Batch processing capabilities
+- Performance analysis utilities
+
+### Basic Usage
+
+```python
+import torch
+from torchvision.models.detection import maskrcnn_resnet50_fpn
+from torchvision.transforms import functional as F
+from PIL import Image
+import numpy as np
+
+# Load the model
+model = maskrcnn_resnet50_fpn(num_classes=2)  # background + bean
+state_dict = torch.load('maskrcnn_coffeebeans_v1.safetensors', map_location='cpu')
+model.load_state_dict(state_dict)
+model.eval()
+
+# Prepare image
+image = Image.open('your_coffee_beans.jpg').convert('RGB')
+image_tensor = F.to_tensor(image).unsqueeze(0)
+
+# Run inference
+with torch.no_grad():
+    predictions = model(image_tensor)[0]
+
+# Filter predictions by confidence
+threshold = 0.5
+mask = predictions['scores'] > threshold
+filtered_predictions = {
+    'boxes': predictions['boxes'][mask],
+    'labels': predictions['labels'][mask],
+    'scores': predictions['scores'][mask],
+    'masks': predictions['masks'][mask]
+}
+
+print(f"Detected {len(filtered_predictions['boxes'])} coffee beans")
+```
+
+## Training Details
+
+### Training Data
+
+The model was trained on a custom dataset of coffee bean images:
+- 128 training images with detailed COCO-format annotations
+- Multiple coffee varieties and roast levels
+- Various lighting conditions and backgrounds
+- Manually annotated polygon masks for each bean
+- Data augmentation: rotation, scaling, color jittering, horizontal/vertical flips
+
+### Training Procedure
+
+#### Base Model
+This model was fine-tuned from `model_128img_25ep_25-09-13.pth`, which was itself trained on 128 coffee bean images for 25 epochs. The base model provided a strong foundation for coffee bean detection, and this fine-tuned version specifically optimizes mask quality and detection accuracy.
+
+#### Preprocessing
+- Images resized to maintain aspect ratio
+- Normalization with ImageNet statistics
+- Random augmentations during training
+
+#### Training Hyperparameters
+- **Training regime:** Mixed precision (fp16/fp32)
+- **Epochs:** 10 (best checkpoint at epoch 9)
+- **Batch size:** 2
+- **Optimizer:** AdamW
+- **Learning rates:**
+  - Base: 1e-4
+  - Mask head: 5e-4 (higher for mask optimization)
+  - Backbone: 1e-5 (lower for stability)
+- **Scheduler:** CosineAnnealingWarmRestarts (T_0=3, T_mult=2)
+- **Weight decay:** 1e-4
+- **Gradient clipping:** 1.0
+- **Mask loss weight:** 2.0 (emphasized for better segmentation)
+
+### Evaluation
+
+#### Testing Data
+Evaluated on a held-out validation set:
+- 4,952 ground truth bean instances
+- Diverse bean arrangements and densities
+- Various roast levels and lighting conditions
+
+#### Metrics
+
+| Metric | Value |
+|--------|-------|
+| **Precision** | 99.92% |
+| **Recall** | 96.71% |
+| **Average IoU** | 90.93% |
+| **Detection Rate** | 96.71% |
+| **Average Confidence** | 99.82% |
+| **Mask Loss** | 0.1333 |
+| **Validation Loss** | 0.2464 |
+
+## Environmental Impact
+
+Carbon emissions were not tracked for this training. The model was trained on a single GPU for approximately 2 hours.
+
+## Technical Specifications
+
+### Model Architecture and Objective
+
+- **Architecture:** Mask R-CNN with ResNet-50 Feature Pyramid Network
+- **Input:** RGB images (any size)
+- **Output:** Instance masks, bounding boxes, class labels, confidence scores
+- **Objective:** Minimize combined classification, box regression, and mask segmentation losses
+- **Model Size:** 176.1 MB (SafeTensors format)
+
+### Compute Infrastructure
+
+#### Hardware
+- GPU: Single GPU training
+- Training time: ~2 hours for fine-tuning
+
+#### Software
+- PyTorch 2.0+
+- TorchVision 0.15+
+- CUDA 11.8+
+- Python 3.8+
+
+## Citation
+
+**BibTeX:**
+```bibtex
+@misc{coffee_bean_maskrcnn_2025,
+  author = {Bean Vision Team},
+  title = {Coffee Bean Detection - Fine-tuned Mask R-CNN},
+  year = {2025},
+  publisher = {Hugging Face},
+  journal = {Hugging Face Model Hub},
+  howpublished = {\url{https://huggingface.co/[your-username]/coffee-bean-maskrcnn}}
+}
+```
+
+## Model Card Authors
+
+Bean Vision Team
+
+## Model Card Contact
+
+Please open an issue on the [GitHub repository](https://github.com/Markkunitomi/bean-vision) for questions or feedback.

README.md

@@ -1,3 +1,173 @@
 ---
 license: apache-2.0
+tags:
+- vision
+- image-segmentation
+- instance-segmentation
+- object-detection
+- pytorch
+- mask-rcnn
+- coffee
+datasets:
+- custom
+metrics:
+- iou
+- precision
+- recall
+- mAP
+model-index:
+- name: coffee-bean-maskrcnn
+  results:
+  - task:
+      type: instance-segmentation
+      name: Instance Segmentation
+    dataset:
+      name: Coffee Bean Dataset
+      type: custom
+    metrics:
+    - type: precision
+      value: 99.92
+      name: Precision
+    - type: recall
+      value: 96.71
+      name: Recall
+    - type: iou
+      value: 90.93
+      name: Average IoU
+    - type: detection-rate
+      value: 96.71
+      name: Detection Rate
+library_name: pytorch
+pipeline_tag: image-segmentation
 ---
+
+# Coffee Bean Detection - Fine-tuned Mask R-CNN
+
+## Model Details
+
+### Model Description
+
+This is a fine-tuned Mask R-CNN model specialized for detecting and segmenting individual coffee beans in images. The model performs instance segmentation, providing precise pixel-level masks and bounding boxes for each detected coffee bean.
+
+- **Developed by:** Mark Kunitomi
+- **Model type:** Instance Segmentation (Mask R-CNN)
+- **Architecture:** ResNet-50 FPN backbone
+- **License:** apache-2.0
+
+
+
+
+## Example Results
+
+<div align="center">
+  <img src="./data/Costa_Rica_Red_Honey_Don_Oscar-green.png" alt="Original Green Beans" width="45%" style="margin-right: 10px;"/>
+  <img src="./data/Costa_Rica_Red_Honey_Don_Oscar-green-prediction.png" alt="Detection Results" width="45%"/>
+</div>
+
+*Left: Original green coffee beans image. Right: Detection and segmentation results showing individual bean masks with confidence scores.*
+
+## How to Get Started with the Model
+
+### Quick Start with Jupyter Notebook
+
+A complete inference notebook (`inference_demo.ipynb`) is included with this model.
+
+### Command Line Interface
+
+For quick inference, use the included `predict_beans.py` script:
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Basic inference on a single image
+python predict_beans.py --model maskrcnn_coffeebeans_v1.safetensors --images your_image.jpg
+
+# Process multiple images with custom settings
+python predict_beans.py --model maskrcnn_coffeebeans_v1.safetensors \
+  --images *.jpg \
+  --confidence 0.5 \
+  --nms_threshold 0.3 \
+  --smooth_polygons \
+  --filter_edge_beans \
+  --output_dir results \
+  --export_format coco
+
+# For all available options
+python predict_beans.py --help
+```
+
+**Key CLI Options:**
+- `--confidence`: Detection confidence threshold (default: 0.5)
+- `--nms_threshold`: Non-maximum suppression threshold (default: 0.3)
+- `--smooth_polygons`: Apply polygon smoothing for cleaner masks
+- `--filter_edge_beans`: Remove beans touching image edges
+- `--export_format`: Output format (json, coco, labelme, all)
+
+
+
+### Recommendations
+- Use confidence threshold of 0.5 or higher for production applications
+- Validate on your specific bean varieties before deployment
+- Consider additional fine-tuning for specialized use cases
+- Implement human verification for critical applications
+
+## Training Details
+
+### Training Data
+
+The model was trained on a custom dataset of coffee bean images:
+- 128 training images with detailed COCO-format annotations
+- Multiple coffee varieties and roast levels
+- Various lighting conditions and backgrounds
+- Manually annotated polygon masks for each bean
+- Data augmentation: rotation, scaling, color jittering, horizontal/vertical flips
+
+#### Preprocessing
+- Images resized to maintain aspect ratio
+- Normalization with ImageNet statistics
+- Random augmentations during training
+
+
+### Evaluation
+
+#### Testing Data
+Evaluated on a held-out validation set:
+- 4,952 ground truth bean instances
+- Diverse bean arrangements and densities
+- Various roast levels and lighting conditions
+
+#### Metrics
+
+| Metric | Value |
+|--------|-------|
+| **Precision** | 99.92% |
+| **Recall** | 96.71% |
+| **Average IoU** | 90.93% |
+| **Detection Rate** | 96.71% |
+| **Average Confidence** | 99.82% |
+| **Mask Loss** | 0.1333 |
+| **Validation Loss** | 0.2464 |
+
+
+## Technical Specifications
+
+### Model Architecture and Objective
+
+- **Architecture:** Mask R-CNN with ResNet-50 Feature Pyramid Network
+- **Input:** RGB images (any size)
+- **Output:** Instance masks, bounding boxes, class labels, confidence scores
+- **Objective:** Minimize combined classification, box regression, and mask segmentation losses
+- **Model Size:** 176.1 MB (SafeTensors format)
+
+### Compute Infrastructure
+
+#### Hardware
+- CPU: Mac Mini M2 with 8GB RAM
+- Training time: ~2 hours for fine-tuning
+
+#### Software
+- PyTorch 2.0+
+- TorchVision 0.15+
+- CUDA 11.8+
+- Python 3.8+

config.json

@@ -0,0 +1,79 @@
+{
+  "architectures": ["MaskRCNN"],
+  "model_type": "maskrcnn_resnet50_fpn",
+  "framework": "pytorch",
+  "task": "instance-segmentation",
+  "num_classes": 2,
+  "backbone": "resnet50",
+  "fpn": true,
+  "pretrained": false,
+  "model_config": {
+    "box_score_thresh": 0.5,
+    "box_nms_thresh": 0.5,
+    "box_detections_per_img": 1000,
+    "box_fg_iou_thresh": 0.5,
+    "box_bg_iou_thresh": 0.5,
+    "box_batch_size_per_image": 512,
+    "box_positive_fraction": 0.25,
+    "bbox_reg_weights": null,
+    "rpn_anchor_generator": {
+      "sizes": [[32], [64], [128], [256], [512]],
+      "aspect_ratios": [[0.5, 1.0, 2.0]]
+    },
+    "rpn_pre_nms_top_n_train": 2000,
+    "rpn_pre_nms_top_n_test": 1000,
+    "rpn_post_nms_top_n_train": 2000,
+    "rpn_post_nms_top_n_test": 1000,
+    "rpn_nms_thresh": 0.7,
+    "rpn_fg_iou_thresh": 0.7,
+    "rpn_bg_iou_thresh": 0.3,
+    "rpn_batch_size_per_image": 256,
+    "rpn_positive_fraction": 0.5
+  },
+  "training_config": {
+    "base_model": "model_128img_25ep_25-09-13.pth",
+    "epochs": 10,
+    "best_epoch": 9,
+    "batch_size": 2,
+    "learning_rate": 0.0001,
+    "learning_rate_mask": 0.0005,
+    "learning_rate_backbone": 0.00001,
+    "optimizer": "AdamW",
+    "scheduler": "CosineAnnealingWarmRestarts",
+    "weight_decay": 0.0001,
+    "gradient_clipping": 1.0,
+    "mask_loss_weight": 2.0
+  },
+  "performance_metrics": {
+    "precision": 0.9991654496140204,
+    "recall": 0.9670840064620355,
+    "detection_rate": 0.9670840064620355,
+    "avg_iou": 0.909326434135437,
+    "avg_confidence": 0.9982164825598233,
+    "best_mask_loss": 0.13330359986195198,
+    "val_loss": 0.24638879069915184
+  },
+  "dataset_info": {
+    "train_images": 128,
+    "val_ground_truth_instances": 4952,
+    "val_detected_instances": 4789,
+    "annotation_format": "COCO"
+  },
+  "input_specs": {
+    "image_format": "RGB",
+    "normalization": "ImageNet",
+    "min_size": null,
+    "max_size": null
+  },
+  "output_specs": {
+    "boxes": "Bounding boxes [N, 4] in xyxy format",
+    "labels": "Class labels [N] (0=background, 1=bean)",
+    "scores": "Confidence scores [N] range 0-1",
+    "masks": "Binary masks [N, 1, H, W]"
+  },
+  "model_size_mb": 176.1,
+  "format": "safetensors",
+  "version": "1.0.0",
+  "created_date": "2025-09-21",
+  "license": "MIT"
+}

maskrcnn_coffeebeans_v1.safetensors

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

predict_beans.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Bean detection prediction script
+"""
+
+# Standard library imports
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+# Local imports
+from bean_vision.export import COCOExporter, LabelMeExporter
+from bean_vision.inference import BeanPredictor
+from bean_vision.visualization.detection_viz import DetectionVisualizer
+
+# ANSI escape codes for terminal formatting
+BOLD = '\033[1m'
+RESET = '\033[0m'
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Bean detection using trained MaskR-CNN')
+    
+    # Model and input arguments
+    parser.add_argument('--model', type=str, required=True,
+                       help='Path to trained model checkpoint')
+    parser.add_argument('--images', nargs='+', required=True,
+                       help='Input image paths (can use wildcards)')
+    
+    # Detection parameters
+    parser.add_argument('--confidence', '--threshold', type=float, default=0.5, 
+                       dest='confidence',
+                       help='Confidence threshold for detections')
+    parser.add_argument('--max_detections', type=int, default=500,
+                       help='Maximum detections per image')
+    parser.add_argument('--mask_threshold', type=float, default=0.5,
+                       help='Threshold for mask binarization')
+    parser.add_argument('--device', type=str, default='cpu',
+                       help='Device to use (cpu or cuda)')
+    
+    # NMS parameters
+    parser.add_argument('--apply_nms', action='store_true', default=True,
+                       help='Apply Non-Maximum Suppression to remove overlapping detections (default: True)')
+    parser.add_argument('--no_nms', dest='apply_nms', action='store_false',
+                       help='Disable NMS')
+    parser.add_argument('--nms_type', choices=['box', 'mask'], default='box',
+                       help='Type of NMS to apply (default: box - faster, mask - more accurate)')
+    parser.add_argument('--nms_threshold', type=float, default=0.3,
+                       help='IoU threshold for NMS (lower = more aggressive)')
+    
+    # Edge and size filtering
+    parser.add_argument('--filter_edge_beans', action='store_true', default=True,
+                       help='Filter out partial beans at image edges (default: True)')
+    parser.add_argument('--no_edge_filter', dest='filter_edge_beans', action='store_false',
+                       help='Disable edge bean filtering')
+    parser.add_argument('--edge_threshold', type=int, default=10,
+                       help='Pixel distance from edge to consider for filtering')
+    parser.add_argument('--min_bean_area', type=float, default=500,
+                       help='Minimum bean area in pixels')
+    parser.add_argument('--max_bean_area', type=float, default=30000,
+                       help='Maximum bean area in pixels')
+    
+    # Output options
+    parser.add_argument('--output_dir', type=str, default='results',
+                       help='Directory to save outputs (default: results)')
+    parser.add_argument('--visualize', action='store_true', default=True,
+                       help='Create visualization images (default: True)')
+    parser.add_argument('--no_visualize', dest='visualize', action='store_false',
+                       help='Disable visualization')
+    parser.add_argument('--vis_type', choices=['masks', 'polygons', 'both'], 
+                       default='both', help='Visualization type (default: both)')
+    parser.add_argument('--export_format', choices=['json', 'coco', 'labelme', 'all'],
+                       default='json', help='Export format for predictions (default: json)')
+    parser.add_argument('--include_polygons', action='store_true', default=True,
+                       help='Convert masks to polygons (default: True)')
+    
+    # Polygon smoothing options
+    parser.add_argument('--smooth_polygons', action='store_true', default=True,
+                       help='Apply smoothing to polygons to reduce jaggedness (default: True)')
+    parser.add_argument('--no_smooth', dest='smooth_polygons', action='store_false',
+                       help='Disable polygon smoothing')
+    parser.add_argument('--smoothing_factor', type=float, default=0.1,
+                       help='Smoothing factor (0.0-1.0, 0=no smoothing, 1=maximum smoothing, default: 0.1)')
+    
+    # Legacy compatibility
+    parser.add_argument('--save_json', action='store_true',
+                       help='Save predictions as JSON (legacy, use --export_format json)')
+    
+    args = parser.parse_args()
+    
+    # Handle legacy save_json flag
+    if args.save_json and not args.export_format:
+        args.export_format = 'json'
+    
+    # Create output directory if needed
+    if args.output_dir:
+        output_dir = Path(args.output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        output_dir = None
+    
+    # Print header
+    print('\n' + '='*80)
+    print(f'{BOLD}BEAN DETECTION{RESET}')
+    print('='*80)
+    
+    # Initialize predictor
+    print(f'\n{BOLD}Model:{RESET} {Path(args.model).name}')
+    
+    predictor = BeanPredictor(
+        model_path=Path(args.model),
+        device=args.device,
+        max_detections=args.max_detections,
+        confidence_threshold=args.confidence,
+        mask_threshold=args.mask_threshold,
+        nms_threshold=args.nms_threshold,
+        smooth_polygons=args.smooth_polygons or args.smoothing_factor > 0,
+        smoothing_factor=args.smoothing_factor,
+        apply_nms=args.apply_nms,
+        nms_type=args.nms_type,
+        filter_edge_beans=args.filter_edge_beans,
+        edge_threshold=args.edge_threshold,
+        min_bean_area=args.min_bean_area,
+        max_bean_area=args.max_bean_area
+    )
+    
+    # Initialize visualizer if needed
+    if args.visualize:
+        visualizer = DetectionVisualizer(confidence_threshold=args.confidence)
+    
+    # Initialize exporters if needed
+    coco_exporter = COCOExporter("bean_predictions") if args.export_format in ['coco', 'all'] else None
+    labelme_exporter = LabelMeExporter() if args.export_format in ['labelme', 'all'] else None
+    
+    # Process images
+    all_results = []
+    total_beans = 0
+    total_time = 0
+    
+    # Print processing header
+    if len(args.images) > 1:
+        print(f'\n{BOLD}Processing {len(args.images)} images...{RESET}')
+    else:
+        print(f'\n{BOLD}Processing image...{RESET}')
+    
+    for image_path in args.images:
+        image_path = Path(image_path)
+        
+        if not image_path.exists():
+            print(f"  [!] {image_path.name}: not found")
+            continue
+        
+        # Run prediction - always include polygons for better analysis
+        result = predictor.predict(
+            image_path,
+            return_polygons=True,  # Always return polygons
+            return_masks=True
+        )
+        
+        # Print results
+        if len(args.images) == 1:
+            print(f'\n{BOLD}Results:{RESET}')
+            print(f'  Image: {image_path.name}')
+            print(f'  Beans detected: {result["bean_count"]}')
+            print(f'  Inference time: {result["inference_time"]:.2f}s')
+        else:
+            print(f'  {image_path.name}: {result["bean_count"]} beans ({result["inference_time"]:.1f}s)')
+        
+        total_beans += result['bean_count']
+        total_time += result['inference_time']
+        
+        # Visualize if requested (silent)
+        if args.visualize and output_dir:
+            if args.vis_type in ['masks', 'both']:
+                # Use legacy naming for backward compatibility
+                mask_vis_path = output_dir / f"{image_path.stem}_prediction.png"
+                visualizer.visualize_masks_with_confidence(
+                    image_path,
+                    result,
+                    mask_vis_path,
+                    mask_threshold=args.mask_threshold
+                )
+            
+            if args.vis_type in ['polygons', 'both'] and 'polygons' in result:
+                poly_vis_path = output_dir / f"{image_path.stem}_poly_vis.png"
+                visualizer.visualize_polygons(
+                    image_path,
+                    result,
+                    poly_vis_path
+                )
+        
+        # Add to exporters
+        if coco_exporter:
+            img_id = coco_exporter.add_image(
+                image_path,
+                result['image_size'][0],
+                result['image_size'][1]
+            )
+            coco_exporter.add_predictions(result, img_id)
+        
+        if labelme_exporter and output_dir:
+            labelme_path = output_dir / f"{image_path.stem}_labelme.json"
+            labelme_exporter.save(image_path, result, labelme_path)
+            # Silent save
+        
+        # Store result (without tensor data for JSON export)
+        json_result = {
+            'image_path': result['image_path'],
+            'image_size': result['image_size'],
+            'inference_time': result['inference_time'],
+            'bean_count': result['bean_count'],
+            'confidence_threshold': result['confidence_threshold'],
+            'total_detections': result['total_detections'],
+            'filtered_detections': result['filtered_detections'],
+            'predictions': {
+                'boxes': result['boxes'],
+                'scores': result['scores'],
+                'labels': result['labels']
+            }
+        }
+        
+        # Rename for backward compatibility
+        json_result['inference_time_seconds'] = json_result.pop('inference_time')
+        
+        if 'polygons' in result:
+            # Keep polygons in their original format for proper COCO export
+            # The format is: List[List[List[Tuple[float, float]]]]
+            # Each detection has a list of polygons (usually just one)
+            json_result['predictions']['polygons'] = result['polygons']
+        
+        all_results.append(json_result)
+    
+    # Save exports (silent)
+    if output_dir:
+        if coco_exporter:
+            coco_path = output_dir / "predictions_coco.json"
+            coco_exporter.save(coco_path)
+        
+        if args.export_format in ['json', 'all']:
+            json_path = output_dir / "predictions.json"
+            with open(json_path, 'w') as f:
+                json.dump(all_results, f, indent=2)
+    
+    # Print summary
+    if len(all_results) > 0:
+        if len(all_results) > 1:
+            print(f'\n{BOLD}Summary:{RESET}')
+            avg_beans = total_beans / len(all_results)
+            print(f'  Total images: {len(all_results)}')
+            print(f'  Total beans: {total_beans}')
+            print(f'  Average per image: {avg_beans:.0f}')
+            print(f'  Total time: {total_time:.1f}s')
+        
+        # Show output directory
+        if output_dir:
+            print(f'\n{BOLD}Output directory:{RESET} {output_dir}/')
+    
+    print('\n' + '='*80)
+    print()  # Add final newline
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,8 @@
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+numpy>=1.21.0
+opencv-python>=4.5.0
+matplotlib>=3.5.0
+safetensors>=0.3.0
+tqdm>=4.65.0

src/bean_vision.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: bean-vision
+Version: 1.0.0
+Summary: Production-grade coffee bean segmentation with MaskR-CNN
+Author: Bean Vision Team
+License: MIT
+Project-URL: Homepage, https://github.com/Markkunitomi/bean-vision
+Project-URL: Repository, https://github.com/Markkunitomi/bean-vision
+Project-URL: Documentation, https://github.com/Markkunitomi/bean-vision#readme
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: pycocotools>=2.0.6
+Requires-Dist: albumentations>=1.3.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: seaborn>=0.12.0
+Requires-Dist: scikit-image>=0.21.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: tensorboard>=2.13.0
+Requires-Dist: jupyter>=1.0.0
+Requires-Dist: notebook>=7.0.0
+Requires-Dist: labelme>=5.3.0
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100.0; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.20.0; extra == "api"
+Requires-Dist: python-multipart>=0.0.6; extra == "api"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+
+# Bean Vision
+
+Coffee bean detection and segmentation using Mask R-CNN.
+
+## Installation
+
+```bash
+git clone https://github.com/Markkunitomi/bean-vision.git
+cd bean-vision
+
+python -m venv .venv
+source .venv/bin/activate
+
+uv pip install -e .
+```
+
+## Usage
+
+### Command Line
+
+```bash
+# Basic prediction
+python predict_beans.py models/beans_101img_20ep.pth data/sample.png
+
+# With options
+python predict_beans.py models/beans_101img_20ep.pth data/sample.png \
+  --smooth_polygons --filter_edge_beans \
+  --threshold 0.5 --nms_threshold 0.5
+```
+
+### Python API
+
+```python
+from src.bean_vision.inference import BeanPredictor
+
+predictor = BeanPredictor(model_path="models/beans_101img_20ep.pth")
+results = predictor.predict("image.jpg", threshold=0.5)
+predictor.visualize(results, "output.png")
+```
+
+## Training
+
+```bash
+python scripts/train.py \
+    --dataset_path coco_datasets/dataset_101_images/ \
+    --epochs 20 \
+    --batch_size 2 \
+    --output models/my_model.pth
+```
+
+## Models
+
+| Model | Training Images | mAP@0.5 |
+|-------|----------------|---------|
+| beans_101img_20ep.pth | 101 | 98.9% |
+| beans_60img_20ep.pth | 60 | 94.7% |
+| beans_30img_20ep.pth | 30 | 89.1% |
+| beans_10img_20ep.pth | 10 | 78.3% |
+
+## Dataset Preparation
+
+1. Annotate with LabelMe:
+```bash
+labelme data/ --labels bean
+```
+
+2. Convert to COCO:
+```bash
+labelme2coco data/ coco_datasets/dataset/ --labels bean
+```
+
+## License
+
+MIT

src/bean_vision.egg-info/SOURCES.txt

@@ -0,0 +1,39 @@
+README.md
+pyproject.toml
+src/bean_vision/__init__.py
+src/bean_vision/config.py
+src/bean_vision.egg-info/PKG-INFO
+src/bean_vision.egg-info/SOURCES.txt
+src/bean_vision.egg-info/dependency_links.txt
+src/bean_vision.egg-info/entry_points.txt
+src/bean_vision.egg-info/requires.txt
+src/bean_vision.egg-info/top_level.txt
+src/bean_vision/data/__init__.py
+src/bean_vision/data/dataset.py
+src/bean_vision/data/transforms.py
+src/bean_vision/evaluation/__init__.py
+src/bean_vision/evaluation/evaluator.py
+src/bean_vision/evaluation/metrics.py
+src/bean_vision/export/__init__.py
+src/bean_vision/export/coco_exporter.py
+src/bean_vision/export/labelme_exporter.py
+src/bean_vision/export/polygon_utils.py
+src/bean_vision/inference/__init__.py
+src/bean_vision/inference/mask_converter.py
+src/bean_vision/inference/postprocessing.py
+src/bean_vision/inference/predictor.py
+src/bean_vision/models/__init__.py
+src/bean_vision/models/model.py
+src/bean_vision/training/__init__.py
+src/bean_vision/training/logging.py
+src/bean_vision/training/metrics.py
+src/bean_vision/training/timing.py
+src/bean_vision/training/trainer.py
+src/bean_vision/utils/__init__.py
+src/bean_vision/utils/io.py
+src/bean_vision/utils/logging.py
+src/bean_vision/utils/misc.py
+src/bean_vision/visualization/__init__.py
+src/bean_vision/visualization/detection_viz.py
+tests/test_predict_beans.py
+tests/test_train_beans.py

src/bean_vision.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/bean_vision.egg-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+bean-api = bean_vision.cli.api:main
+bean-predict = bean_vision.cli.predict:main
+bean-train = bean_vision.cli.train:main

src/bean_vision.egg-info/requires.txt

@@ -0,0 +1,30 @@
+torch>=2.0.0
+torchvision>=0.15.0
+opencv-python>=4.8.0
+Pillow>=10.0.0
+numpy>=1.24.0
+scipy>=1.10.0
+pycocotools>=2.0.6
+albumentations>=1.3.0
+pandas>=2.0.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+scikit-image>=0.21.0
+tqdm>=4.65.0
+tensorboard>=2.13.0
+jupyter>=1.0.0
+notebook>=7.0.0
+labelme>=5.3.0
+
+[api]
+fastapi>=0.100.0
+uvicorn[standard]>=0.20.0
+python-multipart>=0.0.6
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=22.0.0
+isort>=5.0.0
+flake8>=5.0.0
+mypy>=1.0.0

src/bean_vision.egg-info/top_level.txt

@@ -0,0 +1 @@
+bean_vision

src/bean_vision/__init__.py

@@ -0,0 +1,65 @@
+"""Bean Vision - Production-grade coffee bean segmentation."""
+
+__version__ = "2.0.0"
+__author__ = "Bean Vision Team"
+
+# Import main components for easier access
+# Note: Using safe imports to avoid breaking if modules are missing
+try:
+    from .models.model import BeanModel
+    BeanDetector = BeanModel  # Alias for compatibility
+    create_model = None  # This function might not exist in the restored version
+    load_model_checkpoint = None  # This function might not exist in the restored version
+except ImportError:
+    BeanModel = None
+    BeanDetector = None
+    create_model = None
+    load_model_checkpoint = None
+
+try:
+    from .data.dataset import BeanDataset
+    from .data.transforms import get_train_transforms, get_val_transforms
+except ImportError:
+    BeanDataset = None
+    get_train_transforms = None
+    get_val_transforms = None
+try:
+    from .inference.predictor import BeanPredictor
+except ImportError:
+    BeanPredictor = None
+
+try:
+    from .evaluation.evaluator import BeanEvaluator
+except ImportError:
+    BeanEvaluator = None
+
+try:
+    from .export import COCOExporter, LabelMeExporter
+except ImportError:
+    COCOExporter = None
+    LabelMeExporter = None
+
+__all__ = [
+    # Models
+    'BeanDetector',
+    'create_model', 
+    'load_model_checkpoint',
+    
+    # Data
+    'BeanDataset',
+    'get_train_transforms',
+    'get_val_transforms',
+    
+    # Inference  
+    'BeanPredictor',
+    
+    # Evaluation
+    'BeanEvaluator',
+    
+    # Export
+    'COCOExporter',
+    'LabelMeExporter',
+    
+    # Version
+    '__version__'
+]

src/bean_vision/config.py

@@ -0,0 +1,575 @@
+#!/usr/bin/env python3
+"""
+Production-grade configuration management system for bean color analysis.
+
+Supports environment-specific configurations, validation, and hot-reloading.
+"""
+
+import os
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional, Union, List
+from dataclasses import dataclass, field
+import yaml
+from functools import lru_cache
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelConfig:
+    """Model configuration parameters."""
+    num_classes: int
+    checkpoint_path: str
+    device: str
+
+
+@dataclass
+class ImageConfig:
+    """Image processing configuration."""
+    resize_width: int
+    resize_height: int
+    imagenet_mean: List[float]
+    imagenet_std: List[float]
+
+
+@dataclass
+class TrainingConfig:
+    """Training configuration parameters."""
+    epochs: int
+    batch_size: int
+    learning_rate: float
+    weight_decay: float
+    momentum: float
+    lr_scheduler_step: int
+    lr_scheduler_gamma: float
+    gradient_clip_max_norm: float
+    backbone_freeze_epochs: int
+
+
+@dataclass
+class AugmentationConfig:
+    """Data augmentation configuration."""
+    random_rotate90_prob: float
+    rotate_limit: int
+    rotate_prob: float
+    horizontal_flip_prob: float
+    vertical_flip_prob: float
+    brightness_limit: float
+    contrast_limit: float
+    brightness_contrast_prob: float
+
+
+@dataclass
+class InferenceConfig:
+    """Inference configuration parameters."""
+    confidence_threshold: float
+    nms_threshold: float
+    min_contour_area: int
+
+
+@dataclass
+class PathsConfig:
+    """File and directory paths."""
+    data_dir: str
+    coco_json: str
+    log_dir: str
+    output_dir: str
+
+
+@dataclass
+class LoggingConfig:
+    """Logging configuration."""
+    level: str
+    format: str
+    file_logging: bool
+    console_logging: bool
+
+
+@dataclass
+class APIConfig:
+    """API configuration parameters."""
+    title: str
+    description: str
+    version: str
+    host: str
+    port: int
+    debug: bool
+    reload: bool
+    workers: int
+    max_file_size_mb: int
+    max_batch_size: int
+    request_timeout_seconds: int
+    rate_limit_enabled: bool
+    rate_limit_requests: int
+    rate_limit_window_minutes: int
+    cors_enabled: bool
+    cors_origins: List[str]
+    cors_methods: List[str]
+    cors_headers: List[str]
+    auth_enabled: bool
+    api_key_header: str
+    admin_api_key: str
+    include_model_info: bool
+    include_processing_time: bool
+    default_return_polygons: bool
+    cache_enabled: bool
+    cache_ttl_seconds: int
+    cache_max_size: int
+
+
+@dataclass
+class BeanVisionConfig:
+    """Main configuration class for Bean Vision."""
+    model: ModelConfig
+    image: ImageConfig
+    training: TrainingConfig
+    augmentation: AugmentationConfig
+    inference: InferenceConfig
+    paths: PathsConfig
+    logging: LoggingConfig
+    api: Optional[APIConfig] = None
+
+    @classmethod
+    def from_yaml(cls, config_path: str) -> 'BeanVisionConfig':
+        """Load configuration from YAML file."""
+        config_path = Path(config_path)
+        
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+        
+        try:
+            with open(config_path, 'r') as f:
+                config_dict = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML configuration: {e}")
+        
+        try:
+            # API config is optional
+            api_config = None
+            if 'api' in config_dict:
+                api_config = APIConfig(**config_dict['api'])
+            
+            return cls(
+                model=ModelConfig(**config_dict['model']),
+                image=ImageConfig(**config_dict['image']),
+                training=TrainingConfig(**config_dict['training']),
+                augmentation=AugmentationConfig(**config_dict['augmentation']),
+                inference=InferenceConfig(**config_dict['inference']),
+                paths=PathsConfig(**config_dict['paths']),
+                logging=LoggingConfig(**config_dict['logging']),
+                api=api_config
+            )
+        except (KeyError, TypeError) as e:
+            raise ValueError(f"Invalid configuration structure: {e}")
+
+    def validate(self) -> None:
+        """Validate configuration values."""
+        # Validate model config
+        if self.model.num_classes < 2:
+            raise ValueError("num_classes must be >= 2")
+        
+        # Validate image config
+        if self.image.resize_width <= 0 or self.image.resize_height <= 0:
+            raise ValueError("Image dimensions must be positive")
+        
+        if len(self.image.imagenet_mean) != 3 or len(self.image.imagenet_std) != 3:
+            raise ValueError("ImageNet mean and std must have 3 values")
+        
+        # Validate training config
+        if self.training.epochs <= 0:
+            raise ValueError("epochs must be positive")
+        if self.training.batch_size <= 0:
+            raise ValueError("batch_size must be positive")
+        if self.training.learning_rate <= 0:
+            raise ValueError("learning_rate must be positive")
+        
+        # Validate inference config
+        if not 0 <= self.inference.confidence_threshold <= 1:
+            raise ValueError("confidence_threshold must be between 0 and 1")
+        if not 0 <= self.inference.nms_threshold <= 1:
+            raise ValueError("nms_threshold must be between 0 and 1")
+        
+        # Validate paths
+        for path_attr in ['data_dir', 'log_dir', 'output_dir']:
+            path = getattr(self.paths, path_attr)
+            if not path or not isinstance(path, str):
+                raise ValueError(f"{path_attr} must be a non-empty string")
+
+
+@dataclass
+class AnalysisThresholds:
+    """Analysis threshold configuration."""
+    median_delta_e2000_max: float = 3.0
+    p95_delta_e2000_max: float = 5.0
+    std_L_max: float = 2.0
+    center_edge_L_max: float = 2.0
+    cv_L_max: float = 8.0
+    p95_pairwise_delta_e2000_max: float = 6.0
+    tolerance_percent_min: float = 90.0
+    defect_delta_e2000_max: float = 10.0
+    defect_std_L_max: float = 5.0
+
+
+@dataclass
+class PerformanceConfig:
+    """Performance optimization configuration."""
+    multiprocessing_enabled: bool = True
+    max_workers: Optional[int] = None
+    chunk_size: int = 10
+    lab_conversion_cache_size: int = 1000
+    enable_lru_cache: bool = True
+    use_numpy_vectorized: bool = True
+    kdtree_enabled: bool = True
+    kdtree_leaf_size: int = 30
+    kdtree_sample_size: int = 1000
+
+
+@dataclass
+class UIConfig:
+    """User interface configuration."""
+    verbosity: str = "normal"  # quiet, normal, verbose, debug
+    show_progress_bars: bool = True
+    update_frequency: int = 10
+    use_color: bool = True
+    show_warnings: bool = True
+    max_error_lines: int = 5
+
+
+@dataclass
+class BusinessConfig:
+    """Business metrics configuration."""
+    cost_analysis_enabled: bool = True
+    cost_per_defective_bean: float = 0.05
+    cost_per_uneven_bean: float = 0.02
+    labor_cost_per_hour: float = 25.0
+    baseline_defect_rate: float = 0.15
+    target_defect_rate: float = 0.05
+    batch_value_usd: float = 500.0
+
+
+@dataclass
+class CalibrationProfile:
+    """Color calibration profile."""
+    name: str
+    description: str
+    illuminant: str
+    viewing_angle: int
+    background_gray: int
+    lab_tolerance_factor: float = 1.0
+    delta_e_threshold_factor: float = 1.0
+    color_correction_matrix: Optional[List[List[float]]] = None
+
+
+class ConfigurationManager:
+    """
+    Production-grade configuration manager with validation and environment support.
+    """
+    
+    def __init__(self, config_dir: Union[str, Path] = None, environment: str = None):
+        """
+        Initialize configuration manager.
+        
+        Args:
+            config_dir: Directory containing configuration files
+            environment: Environment name (dev, staging, prod)
+        """
+        self.config_dir = Path(config_dir) if config_dir else Path(__file__).parent.parent.parent / "config"
+        self.environment = environment or os.getenv("BEAN_VISION_ENV", "development")
+        
+        # Configuration cache
+        self._config_cache: Dict[str, Any] = {}
+        self._file_mtimes: Dict[str, float] = {}
+        
+        # Load main configurations
+        self._load_all_configs()
+        
+    def _load_all_configs(self) -> None:
+        """Load all configuration files."""
+        try:
+            # Load main analysis config
+            self._config_cache["analysis"] = self._load_yaml_config("analysis_config.yaml")
+            
+            # Load calibration profiles
+            self._config_cache["calibration"] = self._load_yaml_config("calibration_profiles.yaml")
+            
+            # Apply environment-specific overrides
+            self._apply_environment_overrides()
+            
+            logger.info(f"Loaded configuration for environment: {self.environment}")
+            
+        except Exception as e:
+            logger.error(f"Failed to load configuration: {e}")
+            raise
+    
+    def _load_yaml_config(self, filename: str) -> Dict[str, Any]:
+        """Load a YAML configuration file with caching."""
+        filepath = self.config_dir / filename
+        
+        if not filepath.exists():
+            raise FileNotFoundError(f"Configuration file not found: {filepath}")
+        
+        # Check if file has been modified
+        mtime = filepath.stat().st_mtime
+        if filename in self._file_mtimes and self._file_mtimes[filename] == mtime:
+            return self._config_cache.get(filename.replace(".yaml", ""), {})
+        
+        # Load the file
+        with open(filepath, 'r', encoding='utf-8') as f:
+            config = yaml.safe_load(f)
+        
+        self._file_mtimes[filename] = mtime
+        logger.debug(f"Loaded configuration from {filepath}")
+        
+        return config
+    
+    def _apply_environment_overrides(self) -> None:
+        """Apply environment-specific configuration overrides."""
+        analysis_config = self._config_cache.get("analysis", {})
+        env_overrides = analysis_config.get("environments", {}).get(self.environment, {})
+        
+        if env_overrides:
+            self._deep_merge_dict(analysis_config, env_overrides)
+            logger.info(f"Applied {len(env_overrides)} environment overrides for {self.environment}")
+    
+    def _deep_merge_dict(self, base: Dict[str, Any], override: Dict[str, Any]) -> None:
+        """Deep merge override dictionary into base dictionary."""
+        for key, value in override.items():
+            if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                self._deep_merge_dict(base[key], value)
+            else:
+                base[key] = value
+    
+    @lru_cache(maxsize=128)
+    def get_analysis_thresholds(self, bean_type: str) -> AnalysisThresholds:
+        """Get analysis thresholds for specified bean type."""
+        config = self._config_cache["analysis"]["analysis"]
+        
+        if bean_type == "roasted":
+            thresholds = config["roasted_thresholds"]
+        elif bean_type == "green":
+            thresholds = config["green_thresholds"]
+        else:
+            raise ValueError(f"Unknown bean type: {bean_type}")
+        
+        return AnalysisThresholds(**thresholds)
+    
+    @lru_cache(maxsize=32)
+    def get_performance_config(self) -> PerformanceConfig:
+        """Get performance optimization configuration."""
+        config = self._config_cache["analysis"]["performance"]
+        
+        return PerformanceConfig(
+            multiprocessing_enabled=config["multiprocessing"]["enabled"],
+            max_workers=config["multiprocessing"]["max_workers"],
+            chunk_size=config["multiprocessing"]["chunk_size"],
+            lab_conversion_cache_size=config["caching"]["lab_conversion_cache_size"],
+            enable_lru_cache=config["caching"]["enable_lru_cache"],
+            use_numpy_vectorized=config["vectorization"]["use_numpy_vectorized"],
+            kdtree_enabled=config["kdtree"]["enabled"],
+            kdtree_leaf_size=config["kdtree"]["leaf_size"],
+            kdtree_sample_size=config["kdtree"]["sample_size"]
+        )
+    
+    @lru_cache(maxsize=32)
+    def get_ui_config(self) -> UIConfig:
+        """Get user interface configuration."""
+        config = self._config_cache["analysis"]["ui"]
+        
+        return UIConfig(
+            verbosity=config["verbosity"],
+            show_progress_bars=config["progress"]["show_progress_bars"],
+            update_frequency=config["progress"]["update_frequency"],
+            use_color=config["terminal"]["use_color"],
+            show_warnings=config["terminal"]["show_warnings"],
+            max_error_lines=config["terminal"]["max_error_lines"]
+        )
+    
+    @lru_cache(maxsize=32)
+    def get_business_config(self) -> BusinessConfig:
+        """Get business metrics configuration."""
+        config = self._config_cache["analysis"]["business"]
+        
+        return BusinessConfig(
+            cost_analysis_enabled=config["cost_analysis"]["enabled"],
+            cost_per_defective_bean=config["cost_analysis"]["cost_per_defective_bean"],
+            cost_per_uneven_bean=config["cost_analysis"]["cost_per_uneven_bean"],
+            labor_cost_per_hour=config["cost_analysis"]["labor_cost_per_hour"],
+            baseline_defect_rate=config["roi"]["baseline_defect_rate"],
+            target_defect_rate=config["roi"]["target_defect_rate"],
+            batch_value_usd=config["roi"]["batch_value_usd"]
+        )
+    
+    def get_calibration_profile(self, profile_name: str) -> CalibrationProfile:
+        """Get calibration profile by name."""
+        profiles = self._config_cache["calibration"]["profiles"]
+        
+        if profile_name not in profiles:
+            available = list(profiles.keys())
+            raise ValueError(f"Unknown calibration profile: {profile_name}. Available: {available}")
+        
+        profile_data = profiles[profile_name]
+        
+        return CalibrationProfile(
+            name=profile_data["name"],
+            description=profile_data["description"],
+            illuminant=profile_data["illuminant"],
+            viewing_angle=profile_data["viewing_angle"],
+            background_gray=profile_data["background_gray"],
+            lab_tolerance_factor=profile_data.get("analysis_adjustments", {}).get("lab_tolerance_factor", 1.0),
+            delta_e_threshold_factor=profile_data.get("analysis_adjustments", {}).get("delta_e_threshold_factor", 1.0),
+            color_correction_matrix=profile_data.get("color_correction", {}).get("matrix")
+        )
+    
+    def get_available_calibration_profiles(self) -> List[str]:
+        """Get list of available calibration profile names."""
+        return list(self._config_cache["calibration"]["profiles"].keys())
+    
+    def get_colorchecker_patches(self) -> Dict[str, List[float]]:
+        """Get X-Rite ColorChecker reference patch values."""
+        return self._config_cache["calibration"]["colorchecker"]["reference_patches"]
+    
+    def get_config_value(self, path: str, default: Any = None) -> Any:
+        """
+        Get configuration value by dot-notation path.
+        
+        Args:
+            path: Dot-notation path (e.g., "analysis.roasted_thresholds.std_L_max")
+            default: Default value if path not found
+            
+        Returns:
+            Configuration value
+        """
+        keys = path.split(".")
+        current = self._config_cache
+        
+        try:
+            for key in keys:
+                current = current[key]
+            return current
+        except KeyError:
+            logger.warning(f"Configuration path not found: {path}")
+            return default
+    
+    def reload_config(self) -> None:
+        """Reload configuration from files."""
+        logger.info("Reloading configuration...")
+        
+        # Clear caches
+        self._config_cache.clear()
+        self._file_mtimes.clear()
+        self.get_analysis_thresholds.cache_clear()
+        self.get_performance_config.cache_clear()
+        self.get_ui_config.cache_clear()
+        self.get_business_config.cache_clear()
+        
+        # Reload all configs
+        self._load_all_configs()
+    
+    def validate_config(self) -> List[str]:
+        """
+        Validate configuration and return list of issues.
+        
+        Returns:
+            List of validation error messages
+        """
+        issues = []
+        
+        try:
+            # Validate analysis config
+            analysis_config = self._config_cache.get("analysis", {})
+            if not analysis_config:
+                issues.append("Missing analysis configuration")
+            
+            # Validate required sections
+            required_sections = ["analysis", "performance", "ui", "logging", "output"]
+            for section in required_sections:
+                if section not in analysis_config:
+                    issues.append(f"Missing required section: {section}")
+            
+            # Validate calibration profiles
+            calibration_config = self._config_cache.get("calibration", {})
+            if not calibration_config.get("profiles"):
+                issues.append("No calibration profiles defined")
+            
+            # Validate threshold values
+            for bean_type in ["roasted", "green"]:
+                try:
+                    thresholds = self.get_analysis_thresholds(bean_type)
+                    if thresholds.tolerance_percent_min < 0 or thresholds.tolerance_percent_min > 100:
+                        issues.append(f"{bean_type} tolerance_percent_min must be 0-100")
+                except Exception as e:
+                    issues.append(f"Invalid {bean_type} thresholds: {e}")
+            
+            # Validate performance config
+            try:
+                perf_config = self.get_performance_config()
+                if perf_config.chunk_size <= 0:
+                    issues.append("Performance chunk_size must be positive")
+            except Exception as e:
+                issues.append(f"Invalid performance config: {e}")
+            
+        except Exception as e:
+            issues.append(f"Configuration validation error: {e}")
+        
+        return issues
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Export entire configuration as dictionary."""
+        return {
+            "environment": self.environment,
+            "config_dir": str(self.config_dir),
+            "analysis": self._config_cache.get("analysis", {}),
+            "calibration": self._config_cache.get("calibration", {})
+        }
+
+
+# Global configuration instance
+_config_manager: Optional[ConfigurationManager] = None
+
+
+def get_config_manager() -> ConfigurationManager:
+    """Get global configuration manager instance."""
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = ConfigurationManager()
+    return _config_manager
+
+
+def initialize_config(config_dir: Union[str, Path] = None, environment: str = None) -> None:
+    """Initialize global configuration manager."""
+    global _config_manager
+    _config_manager = ConfigurationManager(config_dir, environment)
+
+
+# Convenience functions
+def get_analysis_thresholds(bean_type: str) -> AnalysisThresholds:
+    """Get analysis thresholds for bean type."""
+    return get_config_manager().get_analysis_thresholds(bean_type)
+
+
+def get_performance_config() -> PerformanceConfig:
+    """Get performance configuration."""
+    return get_config_manager().get_performance_config()
+
+
+def get_ui_config() -> UIConfig:
+    """Get UI configuration."""
+    return get_config_manager().get_ui_config()
+
+
+def get_business_config() -> BusinessConfig:
+    """Get business configuration."""
+    return get_config_manager().get_business_config()
+
+
+def get_calibration_profile(profile_name: str) -> CalibrationProfile:
+    """Get calibration profile by name."""
+    return get_config_manager().get_calibration_profile(profile_name)
+
+
+def load_config(config_path: str = "config.yaml") -> BeanVisionConfig:
+    """Load and validate configuration."""
+    config = BeanVisionConfig.from_yaml(config_path)
+    config.validate()
+    return config

src/bean_vision/data/__init__.py

@@ -0,0 +1,6 @@
+"""Data handling modules for Bean Vision."""
+
+from .dataset import BeanDataset
+from .transforms import get_transforms
+
+__all__ = ["BeanDataset", "get_transforms"]

src/bean_vision/data/dataset.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python
+"""Dataset module for Bean Vision project."""
+
+import gzip
+import os
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import albumentations as A
+import cv2
+import numpy as np
+import torch
+from pycocotools.coco import COCO
+from torch.utils.data import Dataset
+
+from bean_vision.config import BeanVisionConfig
+from bean_vision.utils.logging import get_logger
+from bean_vision.utils.misc import ValidationError
+from bean_vision.utils.paths import safe_load_image, validate_coco_json
+from typing import Dict, Any, Tuple
+
+# Type aliases
+DatasetItem = Tuple[torch.Tensor, Dict[str, Any]]
+ImageArray = np.ndarray
+TensorDict = Dict[str, torch.Tensor]
+
+
+class BeanDataset(Dataset):
+    """COCO-format dataset with polygon-to-mask conversion and transforms."""
+    
+    def __init__(self, 
+                 coco_json: str, 
+                 data_dir: str, 
+                 config: BeanVisionConfig,
+                 transforms: Optional[A.Compose] = None, 
+                 is_train: bool = True) -> None:
+        self.logger = get_logger(self.__class__.__name__)
+        self.config = config
+        self.transforms = transforms
+        self.is_train = is_train
+        
+        # Validate inputs
+        coco_path = validate_coco_json(coco_json)
+        self.data_dir = Path(data_dir)
+        
+        if not self.data_dir.exists():
+            raise FileNotFoundError(f"Data directory not found: {self.data_dir}")
+        
+        # Load COCO data
+        try:
+            self.coco = self._load_coco_data(coco_path)
+            self.image_ids = list(self.coco.imgs.keys())
+            self.logger.info(f"Loaded {len(self.image_ids)} images from {coco_path}")
+        except Exception as e:
+            raise ValidationError(f"Failed to load COCO data: {e}")
+    
+    def _load_coco_data(self, coco_path: Path) -> COCO:
+        """Load COCO data, handling compressed files."""
+        if coco_path.suffix == '.gz':
+            self.logger.info("Loading compressed COCO file")
+            with gzip.open(coco_path, 'rt') as f_in:
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f_out:
+                    f_out.write(f_in.read())
+                    temp_json = f_out.name
+            
+            try:
+                coco = COCO(temp_json)
+                return coco
+            finally:
+                os.unlink(temp_json)
+        else:
+            return COCO(str(coco_path))
+    
+    def __len__(self) -> int:
+        return len(self.image_ids)
+    
+    def __getitem__(self, idx: int) -> DatasetItem:
+        """Get dataset item with error handling."""
+        try:
+            return self._get_item_safe(idx)
+        except Exception as e:
+            self.logger.error(f"Error loading item {idx}: {e}")
+            return self._get_dummy_item()
+    
+    def _get_item_safe(self, idx: int) -> DatasetItem:
+        """Safely get dataset item."""
+        img_id = self.image_ids[idx]
+        img_info = self.coco.imgs[img_id]
+        
+        # Load image with fallback
+        image, original_size = self._load_image(img_info)
+        
+        # Get annotations
+        ann_ids = self.coco.getAnnIds(imgIds=img_id)
+        anns = self.coco.loadAnns(ann_ids)
+        
+        # Process masks and boxes
+        masks, boxes, labels = self._process_annotations(anns, img_info)
+        
+        # Apply transforms
+        if self.transforms:
+            image, masks, boxes, labels = self._apply_transforms(
+                image, masks, boxes, labels, img_info
+            )
+        
+        # Convert to tensors
+        image_tensor = self._image_to_tensor(image)
+        target = self._create_target_dict(masks, boxes, labels, img_id, anns)
+        
+        return image_tensor, target
+    
+    def _load_image(self, img_info: dict) -> Tuple[ImageArray, Tuple[int, int]]:
+        """Load image with proper error handling."""
+        file_name = img_info['file_name']
+        if file_name.startswith('data/'):
+            file_name = file_name[5:]
+        
+        img_path = self.data_dir / file_name
+        return safe_load_image(img_path)
+    
+    def _process_annotations(self, anns: List[dict], img_info: dict) -> Tuple[List[np.ndarray], List[List[float]], List[int]]:
+        """Process COCO annotations into masks, boxes, and labels."""
+        masks = []
+        boxes = []
+        labels = []
+        
+        for ann in anns:
+            mask = self._polygon_to_mask(ann['segmentation'], img_info['height'], img_info['width'])
+            if mask.sum() == 0:
+                continue
+                
+            masks.append(mask)
+            x, y, w, h = ann['bbox']
+            boxes.append([x, y, x + w, y + h])
+            labels.append(1)  # Bean class
+        
+        return masks, boxes, labels
+    
+    def _polygon_to_mask(self, segmentation: List[List[float]], height: int, width: int) -> np.ndarray:
+        """Convert polygon segmentation to binary mask."""
+        mask = np.zeros((height, width), dtype=np.uint8)
+        
+        if isinstance(segmentation, list):
+            for poly in segmentation:
+                if len(poly) >= 6:
+                    poly_array = np.array(poly).reshape(-1, 2)
+                    cv2.fillPoly(mask, [poly_array.astype(np.int32)], 1)
+        
+        return mask
+    
+    def _apply_transforms(self, image: ImageArray, masks: List[np.ndarray], 
+                         boxes: List[List[float]], labels: List[int],
+                         img_info: dict) -> Tuple[ImageArray, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """Apply augmentation transforms to image and masks."""
+        if len(masks) == 0:
+            transformed = self.transforms(image=image)
+            image = transformed['image']
+            return (image, 
+                   torch.zeros((0, image.shape[0], image.shape[1]), dtype=torch.uint8),
+                   torch.zeros((0, 4), dtype=torch.float32),
+                   torch.zeros((0,), dtype=torch.int64))
+        
+        # Apply transforms to image and masks together
+        transform_with_masks = A.Compose(
+            self.transforms.transforms,
+            additional_targets={f'mask{i}': 'mask' for i in range(len(masks))}
+        )
+        
+        transform_input = {'image': image}
+        for i, mask in enumerate(masks):
+            transform_input[f'mask{i}'] = mask.astype(np.uint8)
+        
+        transformed = transform_with_masks(**transform_input)
+        image = transformed['image']
+        
+        # Extract transformed masks
+        transformed_masks = [transformed[f'mask{i}'] for i in range(len(masks))]
+        
+        # Update bounding boxes based on transformed masks
+        updated_boxes, updated_labels, updated_masks = self._update_boxes_from_masks(
+            transformed_masks, labels
+        )
+        
+        # Convert to tensors
+        masks_tensor = torch.as_tensor(np.stack(updated_masks), dtype=torch.uint8) if updated_masks else torch.zeros((0, image.shape[0], image.shape[1]), dtype=torch.uint8)
+        boxes_tensor = torch.as_tensor(updated_boxes, dtype=torch.float32) if updated_boxes else torch.zeros((0, 4), dtype=torch.float32)
+        labels_tensor = torch.as_tensor(updated_labels, dtype=torch.int64) if updated_labels else torch.zeros((0,), dtype=torch.int64)
+        
+        return image, masks_tensor, boxes_tensor, labels_tensor
+    
+    def _update_boxes_from_masks(self, masks: List[np.ndarray], 
+                               labels: List[int]) -> Tuple[List[List[float]], List[int], List[np.ndarray]]:
+        """Update bounding boxes based on mask contours after transformation."""
+        updated_boxes = []
+        updated_labels = []
+        updated_masks = []
+        
+        for i, mask in enumerate(masks):
+            contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            if len(contours) > 0:
+                largest_contour = max(contours, key=cv2.contourArea)
+                if cv2.contourArea(largest_contour) > self.config.inference.min_contour_area:
+                    x, y, w, h = cv2.boundingRect(largest_contour)
+                    updated_boxes.append([x, y, x + w, y + h])
+                    updated_labels.append(labels[i] if i < len(labels) else 1)
+                    updated_masks.append(mask)
+        
+        return updated_boxes, updated_labels, updated_masks
+    
+    def _image_to_tensor(self, image: ImageArray) -> torch.Tensor:
+        """Convert image to normalized tensor."""
+        image_tensor = torch.tensor(image, dtype=torch.float32).permute(2, 0, 1) / 255.0
+        mean = torch.tensor(self.config.image.imagenet_mean).view(3, 1, 1)
+        std = torch.tensor(self.config.image.imagenet_std).view(3, 1, 1)
+        return (image_tensor - mean) / std
+    
+    def _create_target_dict(self, masks: torch.Tensor, boxes: torch.Tensor, 
+                          labels: torch.Tensor, img_id: int, anns: List[dict]) -> TensorDict:
+        """Create target dictionary for model training."""
+        return {
+            'boxes': boxes,
+            'labels': labels,
+            'masks': masks,
+            'image_id': torch.tensor([img_id]),
+            'area': torch.tensor([ann['area'] for ann in anns]) if anns else torch.tensor([]),
+            'iscrowd': torch.tensor([ann['iscrowd'] for ann in anns]) if anns else torch.tensor([])
+        }
+    
+    def _get_dummy_item(self) -> DatasetItem:
+        """Create dummy item for error cases."""
+        dummy_image = torch.zeros((3, self.config.image.resize_height, self.config.image.resize_width))
+        dummy_target = {
+            'boxes': torch.zeros((0, 4), dtype=torch.float32),
+            'labels': torch.zeros((0,), dtype=torch.int64),
+            'masks': torch.zeros((0, self.config.image.resize_height, self.config.image.resize_width), dtype=torch.uint8),
+            'image_id': torch.tensor([0]),
+            'area': torch.tensor([]),
+            'iscrowd': torch.tensor([])
+        }
+        return dummy_image, dummy_target
+
+

src/bean_vision/data/transforms.py

@@ -0,0 +1,30 @@
+"""Image transforms for Bean Vision dataset."""
+
+import albumentations as A
+from bean_vision.config import BeanVisionConfig
+
+
+def get_transforms(config: BeanVisionConfig, is_train: bool = True) -> A.Compose:
+    """Get Albumentations transforms pipeline from configuration."""
+    if is_train:
+        return A.Compose([
+            A.Resize(config.image.resize_height, config.image.resize_width),
+            A.RandomRotate90(p=config.augmentation.random_rotate90_prob),
+            A.Rotate(limit=config.augmentation.rotate_limit, p=config.augmentation.rotate_prob),
+            A.HorizontalFlip(p=config.augmentation.horizontal_flip_prob),
+            A.VerticalFlip(p=config.augmentation.vertical_flip_prob),
+            A.RandomBrightnessContrast(
+                brightness_limit=config.augmentation.brightness_limit,
+                contrast_limit=config.augmentation.contrast_limit,
+                p=config.augmentation.brightness_contrast_prob
+            ),
+        ])
+    else:
+        return A.Compose([
+            A.Resize(config.image.resize_height, config.image.resize_width),
+        ])
+
+
+def collate_fn(batch):
+    """Custom collate function for DataLoader."""
+    return tuple(zip(*batch))

src/bean_vision/evaluation/__init__.py

@@ -0,0 +1,8 @@
+"""Evaluation modules for bean detection and segmentation."""
+
+from .metrics import BeanMetrics, DetectionMetrics, SegmentationMetrics, SizeBasedMetrics
+from .evaluator import BeanEvaluator
+from .report_generator import ReportGenerator
+
+__all__ = ['BeanMetrics', 'DetectionMetrics', 'SegmentationMetrics', 'SizeBasedMetrics', 
+           'BeanEvaluator', 'ReportGenerator']

src/bean_vision/evaluation/evaluator.py

@@ -0,0 +1,460 @@
+"""Main evaluation pipeline for bean detection models."""
+
+import json
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+
+from .metrics import BeanMetrics, DetectionMetrics, SegmentationMetrics, SizeBasedMetrics
+
+
+class BeanEvaluator:
+    """Main evaluator for bean detection and segmentation models."""
+    
+    def __init__(self, model: torch.nn.Module, device: torch.device,
+                 confidence_threshold: float = 0.5,
+                 iou_thresholds: List[float] = None):
+        """Initialize evaluator.
+        
+        Args:
+            model: PyTorch model to evaluate
+            device: Device to run evaluation on
+            confidence_threshold: Minimum confidence for valid detection
+            iou_thresholds: IoU thresholds for mAP calculation
+        """
+        self.model = model
+        self.device = device
+        self.confidence_threshold = confidence_threshold
+        self.metrics_calculator = BeanMetrics(
+            confidence_threshold=confidence_threshold,
+            iou_thresholds=iou_thresholds
+        )
+        
+    def evaluate_detection(self, dataloader: DataLoader, 
+                         save_predictions: bool = False,
+                         output_dir: Optional[Path] = None) -> DetectionMetrics:
+        """Evaluate detection performance on dataset.
+        
+        Args:
+            dataloader: DataLoader for evaluation dataset
+            save_predictions: Whether to save predictions to file
+            output_dir: Directory to save results
+            
+        Returns:
+            DetectionMetrics with computed metrics
+        """
+        self.model.eval()
+        all_predictions = []
+        all_ground_truths = []
+        
+        print(f"Evaluating detection on {len(dataloader)} batches...")
+        
+        with torch.no_grad():
+            for batch_idx, (images, targets) in enumerate(dataloader):
+                print(f"Processing batch {batch_idx+1}/{len(dataloader)}")
+                
+                # Move to device
+                images = [img.to(self.device) for img in images]
+                
+                # Get predictions
+                outputs = self.model(images)
+                
+                # Process each image in batch
+                for i, (output, target) in enumerate(zip(outputs, targets)):
+                    pred_dict = {
+                        'boxes': output['boxes'].cpu(),
+                        'scores': output['scores'].cpu(),
+                        'labels': output['labels'].cpu()
+                    }
+                    
+                    gt_dict = {
+                        'boxes': target['boxes'],
+                        'labels': target['labels']
+                    }
+                    
+                    all_predictions.append(pred_dict)
+                    all_ground_truths.append(gt_dict)
+        
+        # Compute detection metrics
+        print("Computing detection metrics...")
+        detection_metrics = self.metrics_calculator.compute_detection_metrics(
+            all_predictions, all_ground_truths
+        )
+        
+        # Save predictions if requested
+        if save_predictions and output_dir:
+            self._save_predictions(all_predictions, all_ground_truths, output_dir)
+        
+        return detection_metrics
+    
+    def evaluate_segmentation(self, dataloader: DataLoader,
+                            output_dir: Optional[Path] = None) -> SegmentationMetrics:
+        """Evaluate segmentation performance on dataset.
+        
+        Args:
+            dataloader: DataLoader for evaluation dataset
+            output_dir: Directory to save results
+            
+        Returns:
+            SegmentationMetrics with computed metrics
+        """
+        self.model.eval()
+        all_predictions = []
+        all_ground_truths = []
+        
+        print(f"Evaluating segmentation on {len(dataloader)} batches...")
+        
+        with torch.no_grad():
+            for batch_idx, (images, targets) in enumerate(dataloader):
+                print(f"Processing batch {batch_idx+1}/{len(dataloader)}")
+                
+                images = [img.to(self.device) for img in images]
+                outputs = self.model(images)
+                
+                for i, (output, target) in enumerate(zip(outputs, targets)):
+                    pred_masks = output.get('masks', torch.tensor([]))
+                    gt_masks = target.get('masks', torch.tensor([]))
+                    
+                    # Convert masks to binary
+                    if len(pred_masks) > 0:
+                        pred_masks = (pred_masks > 0.5).float()
+                    
+                    pred_dict = {'masks': pred_masks.cpu()}
+                    gt_dict = {'masks': gt_masks}
+                    
+                    all_predictions.append(pred_dict)
+                    all_ground_truths.append(gt_dict)
+        
+        # Compute segmentation metrics
+        print("Computing segmentation metrics...")
+        seg_metrics = self.metrics_calculator.compute_segmentation_metrics(
+            all_predictions, all_ground_truths
+        )
+        
+        return seg_metrics
+    
+    def evaluate_by_size(self, dataloader: DataLoader) -> SizeBasedMetrics:
+        """Evaluate performance by object size categories.
+        
+        Args:
+            dataloader: DataLoader for evaluation dataset
+            
+        Returns:
+            SizeBasedMetrics with size-specific performance
+        """
+        self.model.eval()
+        all_predictions = []
+        all_ground_truths = []
+        
+        print("Evaluating performance by object size...")
+        
+        with torch.no_grad():
+            for batch_idx, (images, targets) in enumerate(dataloader):
+                images = [img.to(self.device) for img in images]
+                outputs = self.model(images)
+                
+                for output, target in zip(outputs, targets):
+                    pred_dict = {
+                        'boxes': output['boxes'].cpu(),
+                        'scores': output['scores'].cpu(),
+                        'labels': output['labels'].cpu()
+                    }
+                    
+                    gt_dict = {
+                        'boxes': target['boxes'],
+                        'labels': target['labels']
+                    }
+                    
+                    all_predictions.append(pred_dict)
+                    all_ground_truths.append(gt_dict)
+        
+        size_metrics = self.metrics_calculator.compute_size_based_metrics(
+            all_predictions, all_ground_truths
+        )
+        
+        return size_metrics
+    
+    def full_evaluation(self, dataloader: DataLoader,
+                       output_dir: Optional[Path] = None,
+                       save_predictions: bool = True) -> Dict[str, Union[DetectionMetrics, SegmentationMetrics, SizeBasedMetrics]]:
+        """Run complete evaluation suite.
+        
+        Args:
+            dataloader: DataLoader for evaluation dataset
+            output_dir: Directory to save results
+            save_predictions: Whether to save predictions
+            
+        Returns:
+            Dictionary with all computed metrics
+        """
+        if output_dir:
+            output_dir.mkdir(parents=True, exist_ok=True)
+        
+        print("Starting full evaluation...")
+        start_time = time.time()
+        
+        # Detection evaluation
+        detection_metrics = self.evaluate_detection(
+            dataloader, save_predictions=save_predictions, output_dir=output_dir
+        )
+        
+        # Segmentation evaluation
+        segmentation_metrics = self.evaluate_segmentation(dataloader, output_dir)
+        
+        # Size-based evaluation
+        size_metrics = self.evaluate_by_size(dataloader)
+        
+        evaluation_time = time.time() - start_time
+        
+        results = {
+            'detection': detection_metrics,
+            'segmentation': segmentation_metrics,
+            'size_based': size_metrics,
+            'evaluation_time': evaluation_time
+        }
+        
+        # Save results to file
+        if output_dir:
+            self._save_results(results, output_dir)
+        
+        print(f"Evaluation completed in {evaluation_time:.2f} seconds")
+        return results
+    
+    def compare_models(self, model_paths: List[Path], dataloader: DataLoader,
+                      output_dir: Path) -> Dict[str, Dict]:
+        """Compare multiple models on same dataset.
+        
+        Args:
+            model_paths: List of paths to model checkpoints
+            dataloader: DataLoader for evaluation dataset
+            output_dir: Directory to save comparison results
+            
+        Returns:
+            Dictionary with results for each model
+        """
+        output_dir.mkdir(parents=True, exist_ok=True)
+        comparison_results = {}
+        
+        original_model = self.model
+        
+        for model_path in model_paths:
+            print(f"Evaluating model: {model_path.name}")
+            
+            # Load model checkpoint
+            checkpoint = torch.load(model_path, map_location=self.device)
+            if 'model_state_dict' in checkpoint:
+                self.model.load_state_dict(checkpoint['model_state_dict'])
+            else:
+                self.model.load_state_dict(checkpoint)
+            
+            # Run evaluation
+            model_results = self.full_evaluation(
+                dataloader, 
+                output_dir=output_dir / model_path.stem,
+                save_predictions=False
+            )
+            
+            comparison_results[model_path.stem] = model_results
+        
+        # Restore original model
+        self.model = original_model
+        
+        # Save comparison results
+        self._save_model_comparison(comparison_results, output_dir)
+        
+        return comparison_results
+    
+    def confidence_analysis(self, dataloader: DataLoader,
+                           thresholds: List[float] = None) -> Dict[str, List[float]]:
+        """Analyze performance across different confidence thresholds.
+        
+        Args:
+            dataloader: DataLoader for evaluation dataset
+            thresholds: List of confidence thresholds to test
+            
+        Returns:
+            Dictionary with metrics at each threshold
+        """
+        if thresholds is None:
+            thresholds = np.arange(0.1, 1.0, 0.1).tolist()
+        
+        print("Analyzing performance across confidence thresholds...")
+        
+        # Get all predictions first
+        all_predictions = []
+        all_ground_truths = []
+        
+        self.model.eval()
+        with torch.no_grad():
+            for images, targets in dataloader:
+                images = [img.to(self.device) for img in images]
+                outputs = self.model(images)
+                
+                for output, target in zip(outputs, targets):
+                    pred_dict = {
+                        'boxes': output['boxes'].cpu(),
+                        'scores': output['scores'].cpu(),
+                        'labels': output['labels'].cpu()
+                    }
+                    
+                    gt_dict = {
+                        'boxes': target['boxes'],
+                        'labels': target['labels']
+                    }
+                    
+                    all_predictions.append(pred_dict)
+                    all_ground_truths.append(gt_dict)
+        
+        # Evaluate at different thresholds
+        results = {
+            'thresholds': thresholds,
+            'precision': [],
+            'recall': [],
+            'f1_score': [],
+            'ap_50': []
+        }
+        
+        original_threshold = self.metrics_calculator.confidence_threshold
+        
+        for threshold in thresholds:
+            print(f"Evaluating at threshold {threshold:.2f}")
+            self.metrics_calculator.confidence_threshold = threshold
+            
+            metrics = self.metrics_calculator.compute_detection_metrics(
+                all_predictions, all_ground_truths
+            )
+            
+            results['precision'].append(metrics.precision)
+            results['recall'].append(metrics.recall)
+            results['f1_score'].append(metrics.f1_score)
+            results['ap_50'].append(metrics.ap_50)
+        
+        # Restore original threshold
+        self.metrics_calculator.confidence_threshold = original_threshold
+        
+        return results
+    
+    def _save_predictions(self, predictions: List[Dict], ground_truths: List[Dict],
+                         output_dir: Path) -> None:
+        """Save predictions and ground truth to JSON file."""
+        output_file = output_dir / 'predictions.json'
+        
+        # Convert tensors to lists for JSON serialization
+        serializable_preds = []
+        for pred in predictions:
+            pred_dict = {}
+            for k, v in pred.items():
+                if torch.is_tensor(v):
+                    pred_dict[k] = v.tolist()
+                else:
+                    pred_dict[k] = v
+            serializable_preds.append(pred_dict)
+        
+        serializable_gts = []
+        for gt in ground_truths:
+            gt_dict = {}
+            for k, v in gt.items():
+                if torch.is_tensor(v):
+                    gt_dict[k] = v.tolist()
+                else:
+                    gt_dict[k] = v
+            serializable_gts.append(gt_dict)
+        
+        with open(output_file, 'w') as f:
+            json.dump({
+                'predictions': serializable_preds,
+                'ground_truths': serializable_gts
+            }, f, indent=2)
+        
+        print(f"Predictions saved to {output_file}")
+    
+    def _save_results(self, results: Dict, output_dir: Path) -> None:
+        """Save evaluation results to JSON file."""
+        output_file = output_dir / 'evaluation_results.json'
+        
+        # Convert dataclasses to dictionaries
+        serializable_results = {}
+        for key, value in results.items():
+            if hasattr(value, '__dict__'):
+                serializable_results[key] = value.__dict__
+            else:
+                serializable_results[key] = value
+        
+        with open(output_file, 'w') as f:
+            json.dump(serializable_results, f, indent=2, default=str)
+        
+        print(f"Results saved to {output_file}")
+    
+    def _save_model_comparison(self, comparison_results: Dict, output_dir: Path) -> None:
+        """Save model comparison results."""
+        output_file = output_dir / 'model_comparison.json'
+        
+        # Convert dataclasses to dictionaries
+        serializable_results = {}
+        for model_name, results in comparison_results.items():
+            serializable_results[model_name] = {}
+            for key, value in results.items():
+                if hasattr(value, '__dict__'):
+                    serializable_results[model_name][key] = value.__dict__
+                else:
+                    serializable_results[model_name][key] = value
+        
+        with open(output_file, 'w') as f:
+            json.dump(serializable_results, f, indent=2, default=str)
+        
+        print(f"Model comparison saved to {output_file}")
+    
+    def print_metrics_summary(self, metrics: Union[DetectionMetrics, Dict]) -> None:
+        """Print a formatted summary of metrics."""
+        if isinstance(metrics, dict):
+            detection_metrics = metrics.get('detection')
+            if detection_metrics:
+                self._print_detection_metrics(detection_metrics)
+            
+            segmentation_metrics = metrics.get('segmentation')
+            if segmentation_metrics:
+                self._print_segmentation_metrics(segmentation_metrics)
+                
+            size_metrics = metrics.get('size_based')
+            if size_metrics:
+                self._print_size_metrics(size_metrics)
+        elif isinstance(metrics, DetectionMetrics):
+            self._print_detection_metrics(metrics)
+    
+    def _print_detection_metrics(self, metrics: DetectionMetrics) -> None:
+        """Print detection metrics in formatted table."""
+        print("\n" + "="*60)
+        print("DETECTION METRICS SUMMARY")
+        print("="*60)
+        print(f"{'Metric':<25} {'Value':<15}")
+        print("-"*40)
+        print(f"{'mAP@0.5':<25} {metrics.ap_50:<15.4f}")
+        print(f"{'mAP@0.75':<25} {metrics.ap_75:<15.4f}")
+        print(f"{'mAP@0.5:0.95':<25} {metrics.ap_50_95:<15.4f}")
+        print(f"{'Precision':<25} {metrics.precision:<15.4f}")
+        print(f"{'Recall':<25} {metrics.recall:<15.4f}")
+        print(f"{'F1 Score':<25} {metrics.f1_score:<15.4f}")
+        print(f"{'Mean Confidence':<25} {metrics.confidence_mean:<15.4f}")
+        print(f"{'Mean IoU':<25} {metrics.iou_mean:<15.4f}")
+        print(f"{'Total Detections':<25} {metrics.total_detections:<15}")
+        print(f"{'Valid Detections':<25} {metrics.valid_detections:<15}")
+        print(f"{'False Positives':<25} {metrics.false_positives:<15}")
+        print(f"{'False Negatives':<25} {metrics.false_negatives:<15}")
+    
+    def _print_segmentation_metrics(self, metrics: SegmentationMetrics) -> None:
+        """Print segmentation metrics."""
+        print(f"\nSegmentation AP@0.5: {metrics.mask_ap_50:.4f}")
+        print(f"Dice Coefficient: {metrics.dice_coefficient:.4f}")
+        print(f"Jaccard Index: {metrics.jaccard_index:.4f}")
+        print(f"Pixel Accuracy: {metrics.pixel_accuracy:.4f}")
+    
+    def _print_size_metrics(self, metrics: SizeBasedMetrics) -> None:
+        """Print size-based metrics."""
+        print(f"\nSize-based Performance:")
+        print(f"Small objects AP: {metrics.small_ap:.4f}")
+        print(f"Medium objects AP: {metrics.medium_ap:.4f}")
+        print(f"Large objects AP: {metrics.large_ap:.4f}")
+        print(f"Size distribution: {metrics.size_distribution}")

src/bean_vision/evaluation/metrics.py

@@ -0,0 +1,423 @@
+"""Core metrics for bean detection and segmentation evaluation."""
+
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Optional
+import numpy as np
+import torch
+from pycocotools.coco import COCO
+from pycocotools.cocoeval import COCOeval
+import pycocotools.mask as mask_utils
+import warnings
+from sklearn.metrics import precision_recall_curve, average_precision_score
+# Suppress sklearn warnings about no positive class during early training
+warnings.filterwarnings('ignore', category=UserWarning, module='sklearn.metrics._ranking')
+
+
+@dataclass
+class DetectionMetrics:
+    """Detection performance metrics."""
+    ap_50: float  # Average Precision at IoU 0.5
+    ap_75: float  # Average Precision at IoU 0.75
+    ap_50_95: float  # Average Precision at IoU 0.5:0.95
+    precision: float  # Overall precision
+    recall: float  # Overall recall
+    f1_score: float  # F1 score
+    confidence_mean: float  # Mean confidence score
+    confidence_std: float  # Confidence standard deviation
+    total_detections: int  # Total number of detections
+    valid_detections: int  # Detections above threshold
+    false_positives: int  # Number of false positives
+    false_negatives: int  # Number of false negatives
+    iou_mean: float  # Mean IoU of matched detections
+    iou_std: float  # IoU standard deviation
+
+
+@dataclass
+class SegmentationMetrics:
+    """Segmentation performance metrics."""
+    mask_ap_50: float  # Mask Average Precision at IoU 0.5
+    mask_ap_75: float  # Mask Average Precision at IoU 0.75
+    mask_ap_50_95: float  # Mask Average Precision at IoU 0.5:0.95
+    dice_coefficient: float  # Dice coefficient for masks
+    jaccard_index: float  # Jaccard index (IoU) for masks
+    pixel_accuracy: float  # Pixel-wise accuracy
+    mask_quality_mean: float  # Mean mask quality score
+    mask_quality_std: float  # Mask quality standard deviation
+
+
+@dataclass
+class SizeBasedMetrics:
+    """Performance metrics by object size."""
+    small_ap: float  # AP for small objects
+    medium_ap: float  # AP for medium objects
+    large_ap: float  # AP for large objects
+    size_distribution: Dict[str, int]  # Count by size category
+
+
+class BeanMetrics:
+    """Comprehensive metrics calculator for bean detection."""
+    
+    def __init__(self, confidence_threshold: float = 0.5, 
+                 iou_thresholds: List[float] = None,
+                 size_thresholds: Tuple[int, int] = (32, 96)):
+        """Initialize metrics calculator.
+        
+        Args:
+            confidence_threshold: Minimum confidence for valid detection
+            iou_thresholds: IoU thresholds for mAP calculation
+            size_thresholds: (small_max, medium_max) area thresholds
+        """
+        self.confidence_threshold = confidence_threshold
+        self.iou_thresholds = iou_thresholds or [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]
+        self.size_thresholds = size_thresholds
+        
+    def compute_detection_metrics(self, predictions: List[Dict], 
+                                ground_truths: List[Dict]) -> DetectionMetrics:
+        """Compute detection metrics comparing predictions to ground truth.
+        
+        Args:
+            predictions: List of prediction dicts with 'boxes', 'scores', 'labels'
+            ground_truths: List of GT dicts with 'boxes', 'labels'
+            
+        Returns:
+            DetectionMetrics object with computed metrics
+        """
+        all_pred_boxes_filtered = []  # Boxes after confidence filtering
+        all_pred_scores_filtered = []  # Scores after confidence filtering
+        all_pred_boxes_raw = []  # ALL boxes before filtering
+        all_pred_scores_raw = []  # ALL scores before filtering
+        all_gt_boxes = []
+        ious = []
+        matched_ious = []
+        
+        tp_count = 0
+        fp_count = 0
+        fn_count = 0
+        
+        for pred, gt in zip(predictions, ground_truths):
+            pred_boxes = pred['boxes'].cpu().numpy() if torch.is_tensor(pred['boxes']) else np.array(pred['boxes'])
+            pred_scores = pred['scores'].cpu().numpy() if torch.is_tensor(pred['scores']) else np.array(pred['scores'])
+            gt_boxes = gt['boxes'].cpu().numpy() if torch.is_tensor(gt['boxes']) else np.array(gt['boxes'])
+            
+            # Store ALL raw predictions (before filtering)
+            all_pred_boxes_raw.extend(pred_boxes)
+            all_pred_scores_raw.extend(pred_scores)
+            
+            # Debug: Log raw predictions before filtering
+            if len(pred_boxes) > 0:
+                print(f"      Raw predictions: {len(pred_boxes)} boxes, scores range [{pred_scores.min():.4f}, {pred_scores.max():.4f}]")
+            
+            # Filter predictions by confidence
+            valid_mask = pred_scores >= self.confidence_threshold
+            pred_boxes_valid = pred_boxes[valid_mask]
+            pred_scores_valid = pred_scores[valid_mask]
+            
+            all_pred_boxes_filtered.extend(pred_boxes_valid)
+            all_pred_scores_filtered.extend(pred_scores_valid)
+            all_gt_boxes.extend(gt_boxes)
+            
+            # Compute IoU matrix and match predictions to ground truth
+            if len(pred_boxes_valid) > 0 and len(gt_boxes) > 0:
+                iou_matrix = self._compute_iou_matrix(pred_boxes_valid, gt_boxes)
+                matches = self._match_predictions(iou_matrix, iou_threshold=0.5)
+                
+                for pred_idx, gt_idx in matches:
+                    if iou_matrix[pred_idx, gt_idx] >= 0.5:
+                        tp_count += 1
+                        matched_ious.append(iou_matrix[pred_idx, gt_idx])
+                    else:
+                        fp_count += 1
+                        
+                # Unmatched predictions are false positives
+                unmatched_preds = len(pred_boxes_valid) - len(matches)
+                fp_count += unmatched_preds
+                
+                # Unmatched ground truths are false negatives
+                matched_gt_indices = set(gt_idx for _, gt_idx in matches)
+                fn_count += len(gt_boxes) - len(matched_gt_indices)
+            else:
+                # Handle edge cases explicitly
+                if len(pred_boxes_valid) == 0 and len(gt_boxes) > 0:
+                    # No predictions but ground truth exists = all false negatives
+                    fn_count += len(gt_boxes)
+                elif len(pred_boxes_valid) > 0 and len(gt_boxes) == 0:
+                    # Predictions but no ground truth = all false positives
+                    fp_count += len(pred_boxes_valid)
+                # If both are 0, nothing to count
+        
+        # Debug print for false negatives
+        if len(all_pred_boxes_filtered) == 0 and len(all_gt_boxes) > 0:
+            print(f"    DEBUG: No valid predictions (after filtering), {len(all_gt_boxes)} GT boxes, FN={fn_count}")
+            print(f"    DEBUG: Total raw predictions before filtering: {len(all_pred_boxes_raw)}")
+        
+        # Compute overall metrics
+        precision = tp_count / max(tp_count + fp_count, 1)
+        recall = tp_count / max(tp_count + fn_count, 1)
+        f1_score = 2 * precision * recall / max(precision + recall, 1e-8)
+        
+        # Confidence statistics (from filtered scores)
+        all_pred_scores_np = np.array(all_pred_scores_filtered) if all_pred_scores_filtered else np.array([0.0])
+        confidence_mean = float(np.mean(all_pred_scores_np))
+        confidence_std = float(np.std(all_pred_scores_np))
+        
+        # IoU statistics
+        matched_ious = np.array(matched_ious) if matched_ious else np.array([0.0])
+        iou_mean = float(np.mean(matched_ious))
+        iou_std = float(np.std(matched_ious))
+        
+        # Compute AP at different IoU thresholds
+        ap_50 = self._compute_average_precision(predictions, ground_truths, iou_threshold=0.5)
+        ap_75 = self._compute_average_precision(predictions, ground_truths, iou_threshold=0.75)
+        ap_50_95 = np.mean([
+            self._compute_average_precision(predictions, ground_truths, iou_threshold=iou_thresh)
+            for iou_thresh in self.iou_thresholds
+        ])
+        
+        return DetectionMetrics(
+            ap_50=ap_50,
+            ap_75=ap_75,
+            ap_50_95=ap_50_95,
+            precision=precision,
+            recall=recall,
+            f1_score=f1_score,
+            confidence_mean=confidence_mean,
+            confidence_std=confidence_std,
+            total_detections=len(all_pred_boxes_raw),  # ALL predictions before filtering
+            valid_detections=len(all_pred_boxes_filtered),  # Only predictions passing threshold
+            false_positives=fp_count,
+            false_negatives=fn_count,
+            iou_mean=iou_mean,
+            iou_std=iou_std
+        )
+    
+    def compute_segmentation_metrics(self, predictions: List[Dict], 
+                                   ground_truths: List[Dict]) -> SegmentationMetrics:
+        """Compute segmentation metrics for masks.
+        
+        Args:
+            predictions: List with 'masks' key containing binary masks
+            ground_truths: List with 'masks' key containing binary masks
+            
+        Returns:
+            SegmentationMetrics object
+        """
+        all_dice_scores = []
+        all_jaccard_scores = []
+        all_pixel_accuracies = []
+        all_mask_qualities = []
+        
+        for pred, gt in zip(predictions, ground_truths):
+            pred_masks = pred.get('masks', [])
+            gt_masks = gt.get('masks', [])
+            
+            if len(pred_masks) == 0 or len(gt_masks) == 0:
+                continue
+                
+            # Convert to numpy if needed
+            if torch.is_tensor(pred_masks):
+                pred_masks = pred_masks.cpu().numpy()
+            if torch.is_tensor(gt_masks):
+                gt_masks = gt_masks.cpu().numpy()
+            
+            # Match masks based on IoU and compute metrics
+            for pred_mask in pred_masks:
+                best_dice = 0.0
+                best_jaccard = 0.0
+                best_pixel_acc = 0.0
+                
+                for gt_mask in gt_masks:
+                    dice = self._compute_dice_coefficient(pred_mask, gt_mask)
+                    jaccard = self._compute_jaccard_index(pred_mask, gt_mask)
+                    pixel_acc = self._compute_pixel_accuracy(pred_mask, gt_mask)
+                    
+                    if dice > best_dice:
+                        best_dice = dice
+                        best_jaccard = jaccard
+                        best_pixel_acc = pixel_acc
+                
+                all_dice_scores.append(best_dice)
+                all_jaccard_scores.append(best_jaccard)
+                all_pixel_accuracies.append(best_pixel_acc)
+                
+                # Mask quality score (combination of metrics)
+                mask_quality = (best_dice + best_jaccard + best_pixel_acc) / 3
+                all_mask_qualities.append(mask_quality)
+        
+        # Compute mask AP at different thresholds
+        mask_ap_50 = self._compute_mask_average_precision(predictions, ground_truths, iou_threshold=0.5)
+        mask_ap_75 = self._compute_mask_average_precision(predictions, ground_truths, iou_threshold=0.75)
+        mask_ap_50_95 = np.mean([
+            self._compute_mask_average_precision(predictions, ground_truths, iou_threshold=iou_thresh)
+            for iou_thresh in self.iou_thresholds
+        ])
+        
+        return SegmentationMetrics(
+            mask_ap_50=mask_ap_50,
+            mask_ap_75=mask_ap_75,
+            mask_ap_50_95=mask_ap_50_95,
+            dice_coefficient=float(np.mean(all_dice_scores)) if all_dice_scores else 0.0,
+            jaccard_index=float(np.mean(all_jaccard_scores)) if all_jaccard_scores else 0.0,
+            pixel_accuracy=float(np.mean(all_pixel_accuracies)) if all_pixel_accuracies else 0.0,
+            mask_quality_mean=float(np.mean(all_mask_qualities)) if all_mask_qualities else 0.0,
+            mask_quality_std=float(np.std(all_mask_qualities)) if all_mask_qualities else 0.0
+        )
+    
+    def compute_size_based_metrics(self, predictions: List[Dict], 
+                                 ground_truths: List[Dict]) -> SizeBasedMetrics:
+        """Compute metrics based on object size categories."""
+        small_preds, small_gts = [], []
+        medium_preds, medium_gts = [], []
+        large_preds, large_gts = [], []
+        size_counts = {'small': 0, 'medium': 0, 'large': 0}
+        
+        for pred, gt in zip(predictions, ground_truths):
+            pred_boxes = pred['boxes'].cpu().numpy() if torch.is_tensor(pred['boxes']) else pred['boxes']
+            gt_boxes = gt['boxes'].cpu().numpy() if torch.is_tensor(gt['boxes']) else gt['boxes']
+            
+            # Categorize predictions by size
+            pred_areas = self._compute_box_areas(pred_boxes)
+            for i, area in enumerate(pred_areas):
+                if area < self.size_thresholds[0]:
+                    small_preds.append({k: v[i:i+1] for k, v in pred.items()})
+                elif area < self.size_thresholds[1]:
+                    medium_preds.append({k: v[i:i+1] for k, v in pred.items()})
+                else:
+                    large_preds.append({k: v[i:i+1] for k, v in pred.items()})
+            
+            # Categorize ground truths by size
+            gt_areas = self._compute_box_areas(gt_boxes)
+            for i, area in enumerate(gt_areas):
+                if area < self.size_thresholds[0]:
+                    small_gts.append({k: v[i:i+1] for k, v in gt.items()})
+                    size_counts['small'] += 1
+                elif area < self.size_thresholds[1]:
+                    medium_gts.append({k: v[i:i+1] for k, v in gt.items()})
+                    size_counts['medium'] += 1
+                else:
+                    large_gts.append({k: v[i:i+1] for k, v in gt.items()})
+                    size_counts['large'] += 1
+        
+        # Compute AP for each size category
+        small_ap = self._compute_average_precision(small_preds, small_gts) if small_gts else 0.0
+        medium_ap = self._compute_average_precision(medium_preds, medium_gts) if medium_gts else 0.0
+        large_ap = self._compute_average_precision(large_preds, large_gts) if large_gts else 0.0
+        
+        return SizeBasedMetrics(
+            small_ap=small_ap,
+            medium_ap=medium_ap,
+            large_ap=large_ap,
+            size_distribution=size_counts
+        )
+    
+    def _compute_iou_matrix(self, boxes1: np.ndarray, boxes2: np.ndarray) -> np.ndarray:
+        """Compute IoU matrix between two sets of boxes."""
+        def box_area(boxes):
+            return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+        
+        area1 = box_area(boxes1)
+        area2 = box_area(boxes2)
+        
+        # Compute intersection
+        inter_x1 = np.maximum(boxes1[:, None, 0], boxes2[:, 0])
+        inter_y1 = np.maximum(boxes1[:, None, 1], boxes2[:, 1])
+        inter_x2 = np.minimum(boxes1[:, None, 2], boxes2[:, 2])
+        inter_y2 = np.minimum(boxes1[:, None, 3], boxes2[:, 3])
+        
+        inter_area = np.maximum(0, inter_x2 - inter_x1) * np.maximum(0, inter_y2 - inter_y1)
+        union_area = area1[:, None] + area2 - inter_area
+        
+        return inter_area / np.maximum(union_area, 1e-8)
+    
+    def _match_predictions(self, iou_matrix: np.ndarray, 
+                         iou_threshold: float = 0.5) -> List[Tuple[int, int]]:
+        """Match predictions to ground truth using Hungarian algorithm."""
+        from scipy.optimize import linear_sum_assignment
+        
+        # Use negative IoU for minimization
+        cost_matrix = 1 - iou_matrix
+        pred_indices, gt_indices = linear_sum_assignment(cost_matrix)
+        
+        # Filter matches by IoU threshold
+        matches = []
+        for pred_idx, gt_idx in zip(pred_indices, gt_indices):
+            if iou_matrix[pred_idx, gt_idx] >= iou_threshold:
+                matches.append((pred_idx, gt_idx))
+        
+        return matches
+    
+    def _compute_average_precision(self, predictions: List[Dict], 
+                                 ground_truths: List[Dict],
+                                 iou_threshold: float = 0.5) -> float:
+        """Compute average precision at given IoU threshold."""
+        if not predictions or not ground_truths:
+            return 0.0
+        
+        all_scores = []
+        all_labels = []
+        
+        for pred, gt in zip(predictions, ground_truths):
+            pred_boxes = pred['boxes'].cpu().numpy() if torch.is_tensor(pred['boxes']) else pred['boxes']
+            pred_scores = pred['scores'].cpu().numpy() if torch.is_tensor(pred['scores']) else pred['scores']
+            gt_boxes = gt['boxes'].cpu().numpy() if torch.is_tensor(gt['boxes']) else gt['boxes']
+            
+            if len(pred_boxes) == 0:
+                continue
+            
+            # Compute IoU and determine true/false positives
+            if len(gt_boxes) > 0:
+                iou_matrix = self._compute_iou_matrix(pred_boxes, gt_boxes)
+                matches = self._match_predictions(iou_matrix, iou_threshold)
+                matched_pred_indices = set(pred_idx for pred_idx, _ in matches)
+                
+                for i, score in enumerate(pred_scores):
+                    all_scores.append(score)
+                    all_labels.append(1 if i in matched_pred_indices else 0)
+            else:
+                # No ground truth, all predictions are false positives
+                all_scores.extend(pred_scores)
+                all_labels.extend([0] * len(pred_scores))
+        
+        if not all_scores:
+            return 0.0
+        
+        # Compute precision-recall curve and average precision
+        try:
+            ap = average_precision_score(all_labels, all_scores)
+            return float(ap)
+        except ValueError:
+            return 0.0
+    
+    def _compute_mask_average_precision(self, predictions: List[Dict], 
+                                      ground_truths: List[Dict],
+                                      iou_threshold: float = 0.5) -> float:
+        """Compute average precision for masks."""
+        # Similar to box AP but using mask IoU
+        return 0.0  # Placeholder - implement if needed
+    
+    def _compute_dice_coefficient(self, mask1: np.ndarray, mask2: np.ndarray) -> float:
+        """Compute Dice coefficient between two binary masks."""
+        # Convert to boolean arrays to ensure compatibility
+        mask1_bool = mask1.astype(bool)
+        mask2_bool = mask2.astype(bool)
+        intersection = np.sum(mask1_bool & mask2_bool)
+        union = np.sum(mask1_bool) + np.sum(mask2_bool)
+        return 2.0 * intersection / max(union, 1e-8)
+    
+    def _compute_jaccard_index(self, mask1: np.ndarray, mask2: np.ndarray) -> float:
+        """Compute Jaccard index (IoU) between two binary masks."""
+        # Convert to boolean arrays to ensure compatibility
+        mask1_bool = mask1.astype(bool)
+        mask2_bool = mask2.astype(bool)
+        intersection = np.sum(mask1_bool & mask2_bool)
+        union = np.sum(mask1_bool | mask2_bool)
+        return intersection / max(union, 1e-8)
+    
+    def _compute_pixel_accuracy(self, mask1: np.ndarray, mask2: np.ndarray) -> float:
+        """Compute pixel-wise accuracy between two binary masks."""
+        correct_pixels = np.sum(mask1 == mask2)
+        total_pixels = mask1.size
+        return correct_pixels / total_pixels
+    
+    def _compute_box_areas(self, boxes: np.ndarray) -> np.ndarray:
+        """Compute areas of bounding boxes."""
+        return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])

src/bean_vision/export/__init__.py

@@ -0,0 +1,12 @@
+"""Export utilities for detection results."""
+
+from .coco_exporter import COCOExporter
+from .labelme_exporter import LabelMeExporter
+from .polygon_utils import simplify_polygon, polygon_area
+
+__all__ = [
+    'COCOExporter',
+    'LabelMeExporter', 
+    'simplify_polygon',
+    'polygon_area'
+]

src/bean_vision/export/coco_exporter.py

@@ -0,0 +1,163 @@
+"""Export predictions to COCO format."""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+
+from .polygon_utils import polygon_area, polygon_bbox
+
+
+class COCOExporter:
+    """Export detection results to COCO format."""
+    
+    def __init__(self, dataset_name: str = "bean_detections"):
+        """Initialize COCO exporter.
+        
+        Args:
+            dataset_name: Name of the dataset
+        """
+        self.dataset_name = dataset_name
+        self.coco_data = self._initialize_coco_structure()
+        self.annotation_id = 1
+        self.image_id = 1
+    
+    def _initialize_coco_structure(self) -> Dict[str, Any]:
+        """Initialize empty COCO structure."""
+        return {
+            "info": {
+                "description": self.dataset_name,
+                "version": "1.0",
+                "year": datetime.now().year,
+                "date_created": datetime.now().isoformat()
+            },
+            "categories": [
+                {"id": 1, "name": "bean", "supercategory": "object"}
+            ],
+            "images": [],
+            "annotations": []
+        }
+    
+    def add_image(
+        self,
+        image_path: Path,
+        width: int,
+        height: int,
+        image_id: Optional[int] = None
+    ) -> int:
+        """Add image to COCO dataset.
+        
+        Args:
+            image_path: Path to image file
+            width: Image width
+            height: Image height
+            image_id: Optional specific image ID
+            
+        Returns:
+            Image ID
+        """
+        if image_id is None:
+            image_id = self.image_id
+            self.image_id += 1
+        
+        image_info = {
+            "id": image_id,
+            "file_name": image_path.name,
+            "width": width,
+            "height": height
+        }
+        
+        self.coco_data["images"].append(image_info)
+        return image_id
+    
+    def add_predictions(
+        self,
+        predictions: Dict[str, Any],
+        image_id: int
+    ) -> int:
+        """Add predictions for an image.
+        
+        Args:
+            predictions: Prediction results with polygons
+            image_id: ID of the image
+            
+        Returns:
+            Number of annotations added
+        """
+        num_added = 0
+        
+        # Handle polygon predictions
+        if 'polygons' in predictions:
+            polygons = predictions['polygons']
+            scores = predictions.get('scores', [1.0] * len(polygons))
+            
+            for polygon_list, score in zip(polygons, scores):
+                for polygon in polygon_list:
+                    if len(polygon) >= 3:
+                        # Flatten polygon
+                        segmentation = [coord for point in polygon for coord in point]
+                        
+                        # Calculate bbox and area
+                        x1, y1, x2, y2 = polygon_bbox(polygon)
+                        area = polygon_area(polygon)
+                        
+                        annotation = {
+                            "id": self.annotation_id,
+                            "image_id": image_id,
+                            "category_id": 1,  # bean
+                            "segmentation": [segmentation],
+                            "area": area,
+                            "bbox": [x1, y1, x2 - x1, y2 - y1],
+                            "iscrowd": 0,
+                            "score": float(score)
+                        }
+                        
+                        self.coco_data["annotations"].append(annotation)
+                        self.annotation_id += 1
+                        num_added += 1
+        
+        # Handle box-only predictions
+        elif 'boxes' in predictions:
+            boxes = predictions['boxes']
+            scores = predictions.get('scores', [1.0] * len(boxes))
+            
+            for box, score in zip(boxes, scores):
+                x1, y1, x2, y2 = box
+                
+                annotation = {
+                    "id": self.annotation_id,
+                    "image_id": image_id,
+                    "category_id": 1,
+                    "bbox": [x1, y1, x2 - x1, y2 - y1],
+                    "area": (x2 - x1) * (y2 - y1),
+                    "iscrowd": 0,
+                    "score": float(score)
+                }
+                
+                self.coco_data["annotations"].append(annotation)
+                self.annotation_id += 1
+                num_added += 1
+        
+        return num_added
+    
+    def save(self, output_path: Path):
+        """Save COCO data to JSON file.
+        
+        Args:
+            output_path: Path to save JSON file
+        """
+        with open(output_path, 'w') as f:
+            json.dump(self.coco_data, f, indent=2)
+        print(f"COCO format saved to {output_path}")
+    
+    def get_statistics(self) -> Dict[str, int]:
+        """Get dataset statistics.
+        
+        Returns:
+            Dictionary with counts
+        """
+        return {
+            "num_images": len(self.coco_data["images"]),
+            "num_annotations": len(self.coco_data["annotations"]),
+            "num_categories": len(self.coco_data["categories"])
+        }

src/bean_vision/export/labelme_exporter.py

@@ -0,0 +1,157 @@
+"""Export predictions to LabelMe format."""
+
+import json
+import base64
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from PIL import Image
+import io
+
+
+class LabelMeExporter:
+    """Export detection results to LabelMe format."""
+    
+    def __init__(self, version: str = "5.0.1"):
+        """Initialize LabelMe exporter.
+        
+        Args:
+            version: LabelMe version string
+        """
+        self.version = version
+    
+    def create_labelme_annotation(
+        self,
+        image_path: Path,
+        predictions: Dict[str, Any],
+        include_image_data: bool = False
+    ) -> Dict[str, Any]:
+        """Create LabelMe format annotation.
+        
+        Args:
+            image_path: Path to image file
+            predictions: Prediction results with polygons
+            include_image_data: Whether to include base64 image data
+            
+        Returns:
+            LabelMe format dictionary
+        """
+        # Load image to get dimensions
+        with Image.open(image_path) as img:
+            width, height = img.size
+            
+            # Optionally encode image data
+            image_data = None
+            if include_image_data:
+                buffer = io.BytesIO()
+                img.save(buffer, format=img.format or 'PNG')
+                image_data = base64.b64encode(buffer.getvalue()).decode('utf-8')
+        
+        # Create LabelMe structure
+        labelme_data = {
+            "version": self.version,
+            "flags": {},
+            "shapes": [],
+            "imagePath": str(image_path.name),
+            "imageData": image_data,
+            "imageHeight": height,
+            "imageWidth": width
+        }
+        
+        # Add polygon shapes
+        if 'polygons' in predictions:
+            polygons = predictions['polygons']
+            scores = predictions.get('scores', [1.0] * len(polygons))
+            
+            for polygon_list, score in zip(polygons, scores):
+                for polygon in polygon_list:
+                    if len(polygon) >= 3:
+                        shape = {
+                            "label": "bean",
+                            "points": polygon,
+                            "group_id": None,
+                            "shape_type": "polygon",
+                            "flags": {},
+                            "attributes": {
+                                "confidence": float(score)
+                            }
+                        }
+                        labelme_data["shapes"].append(shape)
+        
+        # Add boxes as rectangles if no polygons
+        elif 'boxes' in predictions:
+            boxes = predictions['boxes']
+            scores = predictions.get('scores', [1.0] * len(boxes))
+            
+            for box, score in zip(boxes, scores):
+                x1, y1, x2, y2 = box
+                
+                shape = {
+                    "label": "bean",
+                    "points": [[x1, y1], [x2, y2]],
+                    "group_id": None,
+                    "shape_type": "rectangle",
+                    "flags": {},
+                    "attributes": {
+                        "confidence": float(score)
+                    }
+                }
+                labelme_data["shapes"].append(shape)
+        
+        return labelme_data
+    
+    def save(
+        self,
+        image_path: Path,
+        predictions: Dict[str, Any],
+        output_path: Path,
+        include_image_data: bool = False
+    ):
+        """Save LabelMe annotation to JSON file.
+        
+        Args:
+            image_path: Path to image file
+            predictions: Prediction results
+            output_path: Path to save JSON file
+            include_image_data: Whether to include base64 image data
+        """
+        labelme_data = self.create_labelme_annotation(
+            image_path,
+            predictions,
+            include_image_data
+        )
+        
+        with open(output_path, 'w') as f:
+            json.dump(labelme_data, f, indent=2)
+        
+        print(f"LabelMe format saved to {output_path}")
+    
+    def save_batch(
+        self,
+        results: List[Dict[str, Any]],
+        output_dir: Path,
+        include_image_data: bool = False
+    ):
+        """Save batch of predictions to LabelMe format.
+        
+        Args:
+            results: List of prediction results with image_path
+            output_dir: Directory to save annotations
+            include_image_data: Whether to include base64 image data
+        """
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        for result in results:
+            if 'error' in result:
+                continue
+            
+            image_path = Path(result['image_path'])
+            output_path = output_dir / f"{image_path.stem}.json"
+            
+            self.save(
+                image_path,
+                result,
+                output_path,
+                include_image_data
+            )
+        
+        print(f"Saved {len(results)} LabelMe annotations to {output_dir}")

src/bean_vision/export/polygon_utils.py

@@ -0,0 +1,108 @@
+"""Polygon utility functions."""
+
+from typing import List, Tuple
+import numpy as np
+import cv2
+
+
+def simplify_polygon(
+    polygon: List[Tuple[float, float]],
+    epsilon_percent: float = 1.0
+) -> List[Tuple[float, float]]:
+    """Simplify polygon using Douglas-Peucker algorithm.
+    
+    Args:
+        polygon: List of (x, y) coordinates
+        epsilon_percent: Epsilon as percentage of perimeter
+        
+    Returns:
+        Simplified polygon
+    """
+    if len(polygon) < 3:
+        return polygon
+    
+    # Convert to numpy array
+    points = np.array(polygon, dtype=np.float32)
+    
+    # Calculate epsilon based on perimeter
+    perimeter = cv2.arcLength(points, True)
+    epsilon = epsilon_percent * perimeter / 100
+    
+    # Simplify
+    simplified = cv2.approxPolyDP(points, epsilon, True)
+    
+    # Convert back to list of tuples
+    return [(float(p[0][0]), float(p[0][1])) for p in simplified]
+
+
+def polygon_area(polygon: List[Tuple[float, float]]) -> float:
+    """Calculate area of polygon using shoelace formula.
+    
+    Args:
+        polygon: List of (x, y) coordinates
+        
+    Returns:
+        Area of polygon
+    """
+    if len(polygon) < 3:
+        return 0.0
+    
+    # Shoelace formula
+    n = len(polygon)
+    area = 0.0
+    
+    for i in range(n):
+        j = (i + 1) % n
+        area += polygon[i][0] * polygon[j][1]
+        area -= polygon[j][0] * polygon[i][1]
+    
+    return abs(area) / 2.0
+
+
+def polygon_centroid(polygon: List[Tuple[float, float]]) -> Tuple[float, float]:
+    """Calculate centroid of polygon.
+    
+    Args:
+        polygon: List of (x, y) coordinates
+        
+    Returns:
+        Centroid (x, y)
+    """
+    if not polygon:
+        return (0.0, 0.0)
+    
+    x_sum = sum(p[0] for p in polygon)
+    y_sum = sum(p[1] for p in polygon)
+    
+    return (x_sum / len(polygon), y_sum / len(polygon))
+
+
+def polygon_bbox(polygon: List[Tuple[float, float]]) -> Tuple[float, float, float, float]:
+    """Calculate bounding box of polygon.
+    
+    Args:
+        polygon: List of (x, y) coordinates
+        
+    Returns:
+        Bounding box (x1, y1, x2, y2)
+    """
+    if not polygon:
+        return (0.0, 0.0, 0.0, 0.0)
+    
+    xs = [p[0] for p in polygon]
+    ys = [p[1] for p in polygon]
+    
+    return (min(xs), min(ys), max(xs), max(ys))
+
+
+def validate_polygon(polygon: List[Tuple[float, float]], min_points: int = 3) -> bool:
+    """Validate polygon has minimum requirements.
+    
+    Args:
+        polygon: List of (x, y) coordinates
+        min_points: Minimum number of points
+        
+    Returns:
+        True if valid
+    """
+    return len(polygon) >= min_points and polygon_area(polygon) > 0

src/bean_vision/inference/__init__.py

@@ -0,0 +1,7 @@
+"""Bean detection inference module."""
+
+from .predictor import BeanPredictor
+from .mask_converter import MaskConverter
+from .postprocessing import PostProcessor
+
+__all__ = ['BeanPredictor', 'MaskConverter', 'PostProcessor']

src/bean_vision/inference/mask_converter.py

@@ -0,0 +1,326 @@
+"""Convert binary masks to polygon representations."""
+
+from typing import List, Tuple, Optional, Dict, Any
+import numpy as np
+import cv2
+import torch
+from scipy import interpolate
+
+
+class MaskConverter:
+    """Convert binary segmentation masks to polygon coordinates."""
+    
+    def __init__(
+        self,
+        simplify_epsilon: float = 0.5,
+        min_area: float = 100.0,
+        approximation_method: str = 'douglas_peucker',
+        use_detailed_contours: bool = True,
+        smooth_polygons: bool = False,
+        smoothing_factor: float = 0.0
+    ):
+        """Initialize mask converter.
+        
+        Args:
+            simplify_epsilon: Epsilon for polygon simplification (higher = fewer points)
+            min_area: Minimum contour area to keep
+            approximation_method: Method for polygon approximation
+            use_detailed_contours: Use CHAIN_APPROX_NONE for more detailed contours
+            smooth_polygons: Apply spline smoothing to polygons
+            smoothing_factor: Smoothing factor for spline interpolation (0-1, 0=no smoothing)
+        """
+        self.simplify_epsilon = simplify_epsilon
+        self.min_area = min_area
+        self.approximation_method = approximation_method
+        self.use_detailed_contours = use_detailed_contours
+        self.smooth_polygons = smooth_polygons
+        self.smoothing_factor = smoothing_factor
+    
+    def smooth_polygon_spline(
+        self,
+        polygon: List[Tuple[float, float]],
+        smoothing_factor: float = None
+    ) -> List[Tuple[float, float]]:
+        """Smooth a polygon using spline interpolation optimized for elliptical shapes.
+
+        Args:
+            polygon: List of (x, y) coordinates
+            smoothing_factor: Smoothing factor (0-1, higher = smoother)
+
+        Returns:
+            Smoothed polygon coordinates
+        """
+        if smoothing_factor is None:
+            smoothing_factor = self.smoothing_factor
+
+        if len(polygon) < 4 or smoothing_factor <= 0:
+            return polygon
+
+        # Extract x and y coordinates
+        points = np.array(polygon)
+        x = points[:, 0]
+        y = points[:, 1]
+
+        # Close the polygon by adding the first point at the end
+        x = np.append(x, x[0])
+        y = np.append(y, y[0])
+
+        try:
+            # Create parametric representation
+            t = np.linspace(0, 1, len(x))
+
+            # Determine smoothing parameter based on factor
+            # Optimized for bean-like elliptical shapes
+            # Use a more aggressive smoothing for better ellipse fitting
+            if smoothing_factor >= 0.5:
+                # Strong smoothing for elliptical shapes
+                s = max(0, len(x) * (1 - smoothing_factor * 1.5))
+            else:
+                # Gentle smoothing to preserve details
+                s = len(x) * (1 - smoothing_factor)
+
+            # Create spline interpolation with periodic boundary conditions
+            tck, _ = interpolate.splprep([x, y], s=s, per=True, k=min(3, len(x)-1))
+
+            # Generate smooth points - use fewer points for cleaner ellipses
+            if smoothing_factor >= 0.5:
+                # For strong smoothing, use optimal number of points for ellipse
+                num_points = max(20, min(60, int(len(polygon) * 0.8)))
+            else:
+                num_points = max(len(polygon), int(len(polygon) * 1.2))
+
+            t_smooth = np.linspace(0, 1, num_points, endpoint=False)
+            x_smooth, y_smooth = interpolate.splev(t_smooth, tck)
+
+            # Apply additional ellipse-fitting if high smoothing
+            if smoothing_factor >= 0.7:
+                # Fit an ellipse to the points and blend
+                from sklearn.covariance import EllipticEnvelope
+                try:
+                    # Fit ellipse parameters
+                    center_x, center_y = np.mean(x_smooth), np.mean(y_smooth)
+
+                    # Simple ellipse smoothing by filtering high-frequency variations
+                    angles = np.arctan2(y_smooth - center_y, x_smooth - center_x)
+                    distances = np.sqrt((x_smooth - center_x)**2 + (y_smooth - center_y)**2)
+
+                    # Smooth the distances to create more elliptical shape
+                    window_size = max(3, int(len(distances) * 0.1))
+                    if window_size % 2 == 0:
+                        window_size += 1
+                    smoothed_distances = np.convolve(distances,
+                                                    np.ones(window_size)/window_size,
+                                                    mode='same')
+
+                    # Blend original with smoothed based on factor
+                    blend_factor = (smoothing_factor - 0.7) / 0.3  # 0 at 0.7, 1 at 1.0
+                    final_distances = distances * (1 - blend_factor * 0.5) + smoothed_distances * blend_factor * 0.5
+
+                    # Reconstruct points
+                    x_smooth = center_x + final_distances * np.cos(angles)
+                    y_smooth = center_y + final_distances * np.sin(angles)
+                except:
+                    pass  # Keep the spline-smoothed version if ellipse fitting fails
+
+            # Combine back into polygon format
+            smooth_polygon = [(float(x_smooth[i]), float(y_smooth[i]))
+                            for i in range(len(x_smooth))]
+
+            return smooth_polygon
+
+        except Exception:
+            # If smoothing fails, return original polygon
+            return polygon
+    
+    def mask_to_polygon(
+        self,
+        mask: np.ndarray,
+        threshold: float = 0.5
+    ) -> List[List[Tuple[float, float]]]:
+        """Convert a binary mask to polygon coordinates.
+        
+        Args:
+            mask: Binary mask array (H, W) or (1, H, W)
+            threshold: Threshold for binarizing the mask
+            
+        Returns:
+            List of polygons, each polygon is a list of (x, y) tuples
+        """
+        # Handle different mask dimensions
+        if mask.ndim == 3:
+            mask = mask[0]
+        
+        # Threshold the mask
+        binary_mask = (mask > threshold).astype(np.uint8)
+        
+        # Apply morphological operations to smooth mask boundaries
+        if self.smooth_polygons and self.smoothing_factor > 0:
+            # Use elliptical kernel for bean-like shapes
+            if self.smoothing_factor > 0.5:
+                # Strong smoothing - larger elliptical kernel
+                kernel_size = int(5 + 4 * self.smoothing_factor)
+                kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
+                # Close small gaps then open to smooth boundaries
+                binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
+                binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+                # Additional Gaussian blur for ultra-smooth boundaries
+                if self.smoothing_factor > 0.7:
+                    binary_mask = cv2.GaussianBlur(binary_mask, (5, 5), 1.0)
+                    binary_mask = (binary_mask > 0.5).astype(np.uint8)
+            else:
+                # Light smoothing - smaller kernel
+                kernel_size = int(3 + 2 * self.smoothing_factor)
+                kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
+                binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
+        elif self.use_detailed_contours:
+            # Minimal smoothing for detailed contours
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+            binary_mask = cv2.morphologyEx(binary_mask, cv2.MORPH_CLOSE, kernel, iterations=1)
+        
+        # Find contours - use CHAIN_APPROX_NONE for detailed contours
+        contour_mode = cv2.CHAIN_APPROX_NONE if self.use_detailed_contours else cv2.CHAIN_APPROX_SIMPLE
+        contours, _ = cv2.findContours(
+            binary_mask,
+            cv2.RETR_EXTERNAL,
+            contour_mode
+        )
+        
+        polygons = []
+        for contour in contours:
+            # Filter by area
+            area = cv2.contourArea(contour)
+            if area < self.min_area:
+                continue
+            
+            # Convert contour to polygon points
+            polygon = [(float(point[0][0]), float(point[0][1])) 
+                      for point in contour.reshape(-1, 1, 2)]
+            
+            # Apply smoothing if requested
+            if self.smooth_polygons and self.smoothing_factor > 0:
+                polygon = self.smooth_polygon_spline(polygon, self.smoothing_factor)
+            
+            # Simplify polygon after smoothing if needed
+            if self.approximation_method == 'douglas_peucker' and not self.smooth_polygons:
+                if self.use_detailed_contours:
+                    # Very gentle simplification for detailed contours
+                    epsilon = 0.003 * cv2.arcLength(contour, True)
+                else:
+                    epsilon = self.simplify_epsilon * cv2.arcLength(contour, True) / 100
+                simplified = cv2.approxPolyDP(
+                    np.array(polygon, dtype=np.float32).reshape(-1, 1, 2), 
+                    epsilon, 
+                    True
+                )
+                polygon = [(float(point[0][0]), float(point[0][1])) 
+                          for point in simplified]
+            
+            # Ensure minimum number of points for a valid polygon
+            if len(polygon) >= 3:
+                polygons.append(polygon)
+        
+        return polygons
+    
+    def masks_to_polygons(
+        self,
+        masks: torch.Tensor,
+        threshold: float = 0.5
+    ) -> List[List[List[Tuple[float, float]]]]:
+        """Convert multiple masks to polygons.
+        
+        Args:
+            masks: Tensor of masks (N, 1, H, W)
+            threshold: Threshold for binarizing masks
+            
+        Returns:
+            List of polygon lists, one per mask
+        """
+        masks_np = masks.cpu().numpy()
+        all_polygons = []
+        
+        for mask in masks_np:
+            polygons = self.mask_to_polygon(mask, threshold)
+            all_polygons.append(polygons)
+        
+        return all_polygons
+    
+    def polygon_to_mask(
+        self,
+        polygon: List[Tuple[float, float]],
+        height: int,
+        width: int
+    ) -> np.ndarray:
+        """Convert polygon back to binary mask (for validation).
+        
+        Args:
+            polygon: List of (x, y) coordinates
+            height: Mask height
+            width: Mask width
+            
+        Returns:
+            Binary mask array
+        """
+        mask = np.zeros((height, width), dtype=np.uint8)
+        
+        if len(polygon) >= 3:
+            points = np.array(polygon, dtype=np.int32)
+            cv2.fillPoly(mask, [points], 1)
+        
+        return mask
+    
+    def calculate_iou(
+        self,
+        mask1: np.ndarray,
+        mask2: np.ndarray
+    ) -> float:
+        """Calculate IoU between two masks.
+        
+        Args:
+            mask1: First binary mask
+            mask2: Second binary mask
+            
+        Returns:
+            IoU score
+        """
+        intersection = np.logical_and(mask1, mask2).sum()
+        union = np.logical_or(mask1, mask2).sum()
+        
+        if union == 0:
+            return 0.0
+        
+        return float(intersection) / float(union)
+    
+    def validate_conversion(
+        self,
+        original_mask: np.ndarray,
+        polygons: List[List[Tuple[float, float]]],
+        threshold: float = 0.9
+    ) -> Dict[str, Any]:
+        """Validate polygon conversion quality.
+        
+        Args:
+            original_mask: Original binary mask
+            polygons: Converted polygons
+            threshold: Minimum IoU threshold for valid conversion
+            
+        Returns:
+            Validation metrics
+        """
+        height, width = original_mask.shape[-2:]
+        
+        # Reconstruct mask from polygons
+        reconstructed = np.zeros((height, width), dtype=np.uint8)
+        for polygon in polygons:
+            if len(polygon) >= 3:
+                points = np.array(polygon, dtype=np.int32)
+                cv2.fillPoly(reconstructed, [points], 1)
+        
+        # Calculate metrics
+        iou = self.calculate_iou(original_mask > 0.5, reconstructed)
+        
+        return {
+            'iou': iou,
+            'valid': iou >= threshold,
+            'num_polygons': len(polygons),
+            'total_points': sum(len(p) for p in polygons)
+        }

src/bean_vision/inference/postprocessing.py

@@ -0,0 +1,362 @@
+"""Post-processing utilities for predictions."""
+
+from typing import Dict, List, Any, Optional
+import torch
+import torchvision.ops as ops
+import numpy as np
+
+
+class PostProcessor:
+    """Post-process model predictions."""
+    
+    def __init__(
+        self,
+        confidence_threshold: float = 0.5,
+        nms_threshold: float = 0.3,
+        max_detections: Optional[int] = None
+    ):
+        """Initialize post-processor.
+        
+        Args:
+            confidence_threshold: Minimum confidence score
+            nms_threshold: IoU threshold for NMS
+            max_detections: Maximum number of detections to keep
+        """
+        self.confidence_threshold = confidence_threshold
+        self.nms_threshold = nms_threshold
+        self.max_detections = max_detections
+    
+    def filter_predictions(
+        self,
+        predictions: Dict[str, torch.Tensor],
+        confidence_threshold: Optional[float] = None
+    ) -> Dict[str, torch.Tensor]:
+        """Filter predictions by confidence threshold.
+        
+        Args:
+            predictions: Model predictions dictionary
+            confidence_threshold: Override default threshold
+            
+        Returns:
+            Filtered predictions
+        """
+        threshold = confidence_threshold or self.confidence_threshold
+        
+        # Filter by confidence
+        keep_indices = predictions['scores'] >= threshold
+        
+        filtered = {
+            'boxes': predictions['boxes'][keep_indices],
+            'labels': predictions['labels'][keep_indices],
+            'scores': predictions['scores'][keep_indices]
+        }
+        
+        # Include masks if present
+        if 'masks' in predictions:
+            filtered['masks'] = predictions['masks'][keep_indices]
+        
+        return filtered
+    
+    def apply_nms(
+        self,
+        boxes: torch.Tensor,
+        scores: torch.Tensor,
+        labels: torch.Tensor,
+        masks: Optional[torch.Tensor] = None,
+        nms_threshold: Optional[float] = None
+    ) -> Dict[str, torch.Tensor]:
+        """Apply Non-Maximum Suppression.
+        
+        Args:
+            boxes: Bounding boxes tensor
+            scores: Confidence scores
+            labels: Class labels
+            masks: Optional masks tensor
+            nms_threshold: Override default NMS threshold
+            
+        Returns:
+            NMS-filtered predictions
+        """
+        threshold = nms_threshold or self.nms_threshold
+        
+        # Apply NMS per class
+        keep_indices = []
+        unique_labels = labels.unique()
+        
+        for label in unique_labels:
+            label_mask = labels == label
+            label_boxes = boxes[label_mask]
+            label_scores = scores[label_mask]
+            
+            if len(label_boxes) > 0:
+                # Apply NMS
+                keep = ops.nms(label_boxes, label_scores, threshold)
+                
+                # Convert back to original indices
+                original_indices = torch.where(label_mask)[0]
+                keep_indices.extend(original_indices[keep].tolist())
+        
+        # Sort by score
+        keep_indices = torch.tensor(keep_indices)
+        keep_indices = keep_indices[scores[keep_indices].argsort(descending=True)]
+        
+        # Limit detections if specified
+        if self.max_detections is not None:
+            keep_indices = keep_indices[:self.max_detections]
+        
+        result = {
+            'boxes': boxes[keep_indices],
+            'labels': labels[keep_indices],
+            'scores': scores[keep_indices]
+        }
+        
+        if masks is not None:
+            result['masks'] = masks[keep_indices]
+        
+        return result
+    
+    def compute_mask_iou(self, mask1: np.ndarray, mask2: np.ndarray) -> float:
+        """Compute IoU between two binary masks."""
+        intersection = np.logical_and(mask1, mask2).sum()
+        union = np.logical_or(mask1, mask2).sum()
+        if union == 0:
+            return 0.0
+        return intersection / union
+    
+    def apply_mask_nms(
+        self,
+        boxes: torch.Tensor,
+        scores: torch.Tensor,
+        labels: torch.Tensor,
+        masks: torch.Tensor,
+        iou_threshold: float = 0.3
+    ) -> Dict[str, torch.Tensor]:
+        """Apply Non-Maximum Suppression based on mask IoU.
+        
+        This is more accurate than box NMS for overlapping beans.
+        
+        Args:
+            boxes: Bounding boxes tensor
+            scores: Confidence scores
+            labels: Class labels
+            masks: Masks tensor
+            iou_threshold: IoU threshold for suppression
+            
+        Returns:
+            NMS-filtered predictions
+        """
+        if len(masks) == 0:
+            return {'boxes': boxes, 'scores': scores, 'labels': labels, 'masks': masks}
+        
+        # Limit to top scoring detections for mask NMS (too slow otherwise)
+        MAX_MASK_NMS = 200
+        if len(masks) > MAX_MASK_NMS:
+            # Keep top scoring detections for mask NMS
+            scores_np = scores.cpu().numpy()
+            top_indices = np.argsort(scores_np)[-MAX_MASK_NMS:]
+            
+            # Apply mask NMS only to top detections
+            top_result = self._apply_mask_nms_impl(
+                boxes[top_indices],
+                scores[top_indices], 
+                labels[top_indices],
+                masks[top_indices],
+                iou_threshold
+            )
+            return top_result
+        else:
+            return self._apply_mask_nms_impl(boxes, scores, labels, masks, iou_threshold)
+    
+    def _apply_mask_nms_impl(
+        self,
+        boxes: torch.Tensor,
+        scores: torch.Tensor,
+        labels: torch.Tensor,
+        masks: torch.Tensor,
+        iou_threshold: float
+    ) -> Dict[str, torch.Tensor]:
+        """Implementation of mask NMS."""
+        # Convert to numpy for mask operations
+        masks_np = masks.cpu().numpy()
+        scores_np = scores.cpu().numpy()
+        
+        # Binarize masks
+        binary_masks = masks_np[:, 0] > 0.5
+        
+        # Sort by scores (highest first)
+        order = scores_np.argsort()[::-1]
+        
+        keep = []
+        while order.size > 0:
+            i = order[0]
+            keep.append(i)
+            
+            if order.size == 1:
+                break
+            
+            # Compute IoU of current mask with remaining masks
+            ious = np.array([
+                self.compute_mask_iou(binary_masks[i], binary_masks[j])
+                for j in order[1:]
+            ])
+            
+            # Keep only masks with IoU below threshold
+            inds = np.where(ious <= iou_threshold)[0]
+            order = order[inds + 1]
+        
+        keep_tensor = torch.tensor(keep, dtype=torch.long)
+        
+        return {
+            'boxes': boxes[keep_tensor],
+            'labels': labels[keep_tensor],
+            'scores': scores[keep_tensor],
+            'masks': masks[keep_tensor]
+        }
+    
+    def filter_edge_beans(
+        self,
+        boxes: torch.Tensor,
+        masks: torch.Tensor,
+        image_shape: tuple,
+        edge_threshold: int = 10
+    ) -> torch.Tensor:
+        """Filter out partial beans at image edges.
+        
+        Args:
+            boxes: Bounding boxes
+            masks: Binary masks
+            image_shape: (height, width) of image
+            edge_threshold: Distance from edge to consider
+            
+        Returns:
+            Indices of beans to keep
+        """
+        h, w = image_shape
+        keep = []
+        
+        boxes_np = boxes.cpu().numpy()
+        masks_np = masks.cpu().numpy()
+        
+        for i, box in enumerate(boxes_np):
+            x1, y1, x2, y2 = box
+            
+            # Check if box touches image edge
+            if (x1 <= edge_threshold or y1 <= edge_threshold or 
+                x2 >= w - edge_threshold or y2 >= h - edge_threshold):
+                
+                # For edge beans, check if mask is substantially cut off
+                mask = masks_np[i, 0] > 0.5
+                mask_area = mask.sum()
+                
+                if mask_area == 0:
+                    continue
+                
+                # Estimate if bean is complete by checking mask distribution near edges
+                edge_mask_top = mask[:edge_threshold, :].sum() if mask.shape[0] > edge_threshold else 0
+                edge_mask_bottom = mask[-edge_threshold:, :].sum() if mask.shape[0] > edge_threshold else 0
+                edge_mask_left = mask[:, :edge_threshold].sum() if mask.shape[1] > edge_threshold else 0
+                edge_mask_right = mask[:, -edge_threshold:].sum() if mask.shape[1] > edge_threshold else 0
+                
+                edge_ratio = (edge_mask_top + edge_mask_bottom + edge_mask_left + edge_mask_right) / mask_area
+                
+                # Keep if bean appears mostly complete (low edge ratio)
+                if edge_ratio < 0.15:
+                    keep.append(i)
+            else:
+                # Keep all non-edge beans
+                keep.append(i)
+        
+        return torch.tensor(keep, dtype=torch.long)
+    
+    def filter_by_size(
+        self,
+        boxes: torch.Tensor,
+        masks: torch.Tensor,
+        min_area: float = 500,
+        max_area: float = 30000
+    ) -> torch.Tensor:
+        """Filter detections by mask area to remove noise and anomalies.
+        
+        Args:
+            boxes: Bounding boxes
+            masks: Binary masks
+            min_area: Minimum mask area in pixels
+            max_area: Maximum mask area in pixels
+            
+        Returns:
+            Indices of detections to keep
+        """
+        keep = []
+        masks_np = masks.cpu().numpy()
+        
+        for i, mask in enumerate(masks_np):
+            mask_binary = mask[0] > 0.5
+            area = mask_binary.sum()
+            
+            if min_area <= area <= max_area:
+                keep.append(i)
+        
+        return torch.tensor(keep, dtype=torch.long)
+    
+    def combine_predictions(
+        self,
+        predictions_list: List[Dict[str, torch.Tensor]]
+    ) -> Dict[str, torch.Tensor]:
+        """Combine predictions from multiple models or augmentations.
+        
+        Args:
+            predictions_list: List of prediction dictionaries
+            
+        Returns:
+            Combined predictions
+        """
+        if not predictions_list:
+            return {}
+        
+        # Concatenate all predictions
+        combined = {
+            'boxes': torch.cat([p['boxes'] for p in predictions_list]),
+            'labels': torch.cat([p['labels'] for p in predictions_list]),
+            'scores': torch.cat([p['scores'] for p in predictions_list])
+        }
+        
+        if 'masks' in predictions_list[0]:
+            combined['masks'] = torch.cat([p['masks'] for p in predictions_list])
+        
+        # Apply NMS to remove duplicates
+        return self.apply_nms(
+            combined['boxes'],
+            combined['scores'],
+            combined['labels'],
+            combined.get('masks')
+        )
+    
+    def calculate_metrics(
+        self,
+        predictions: Dict[str, torch.Tensor],
+        ground_truth: Optional[Dict[str, torch.Tensor]] = None
+    ) -> Dict[str, float]:
+        """Calculate basic metrics for predictions.
+        
+        Args:
+            predictions: Model predictions
+            ground_truth: Optional ground truth for comparison
+            
+        Returns:
+            Metrics dictionary
+        """
+        metrics = {
+            'num_detections': len(predictions['scores']),
+            'avg_confidence': predictions['scores'].mean().item() if len(predictions['scores']) > 0 else 0.0,
+            'min_confidence': predictions['scores'].min().item() if len(predictions['scores']) > 0 else 0.0,
+            'max_confidence': predictions['scores'].max().item() if len(predictions['scores']) > 0 else 0.0
+        }
+        
+        # Add per-class counts
+        if 'labels' in predictions:
+            unique_labels = predictions['labels'].unique()
+            for label in unique_labels:
+                count = (predictions['labels'] == label).sum().item()
+                metrics[f'class_{label}_count'] = count
+        
+        return metrics

src/bean_vision/inference/predictor.py

@@ -0,0 +1,369 @@
+"""Main bean detection predictor class."""
+
+# Standard library imports
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+# Third-party imports
+import numpy as np
+import torch
+from PIL import Image
+from torchvision.transforms import functional as F
+
+# Local imports
+from ..models import BeanDetector
+from .mask_converter import MaskConverter
+from .postprocessing import PostProcessor
+
+
+class BeanPredictor:
+    """High-level bean detection predictor."""
+    
+    def __init__(
+        self,
+        model_path: Optional[Path] = None,
+        device: str = 'cpu',
+        max_detections: int = 500,
+        confidence_threshold: float = 0.5,
+        mask_threshold: float = 0.5,
+        nms_threshold: float = 0.3,
+        smooth_polygons: bool = False,
+        smoothing_factor: float = 0.0,
+        apply_nms: bool = True,
+        nms_type: str = 'box',
+        filter_edge_beans: bool = True,
+        edge_threshold: int = 10,
+        min_bean_area: float = 500,
+        max_bean_area: float = 30000
+    ):
+        """Initialize predictor.
+
+        Args:
+            model_path: Path to trained model checkpoint or pre-trained model name
+            device: Device to run on ('cpu' or 'cuda')
+            max_detections: Maximum detections per image
+            confidence_threshold: Minimum confidence for detections
+            mask_threshold: Threshold for mask binarization
+            nms_threshold: IoU threshold for NMS
+            smooth_polygons: Whether to apply polygon smoothing
+            smoothing_factor: Smoothing factor (0-1, 0=no smoothing)
+            apply_nms: Whether to apply Non-Maximum Suppression
+            nms_type: Type of NMS ('box' or 'mask')
+            filter_edge_beans: Whether to filter partial beans at edges
+            edge_threshold: Pixel distance from edge to check
+            min_bean_area: Minimum bean area in pixels
+            max_bean_area: Maximum bean area in pixels
+        """
+        self.device = torch.device(device)
+        if device == 'cuda' and not torch.cuda.is_available():
+            print("CUDA not available, using CPU")
+            self.device = torch.device('cpu')
+
+        self.max_detections = max_detections
+        self.confidence_threshold = confidence_threshold
+        self.mask_threshold = mask_threshold
+        self.nms_threshold = nms_threshold
+        self.apply_nms = apply_nms
+        self.nms_type = nms_type
+        self.filter_edge_beans = filter_edge_beans
+        self.edge_threshold = edge_threshold
+        self.min_bean_area = min_bean_area
+        self.max_bean_area = max_bean_area
+
+        # Check if model_path is a pre-trained model name
+        pretrained_models = ['maskrcnn_resnet50_fpn', 'maskrcnn_resnet50_fpn_v2']
+        use_pretrained = False
+
+        if model_path and str(model_path) in pretrained_models:
+            use_pretrained = True
+            print(f"Using pre-trained model: {model_path}")
+            # For pre-trained models, use num_classes=91 (COCO classes)
+            num_classes = 91
+        else:
+            # For custom trained models on beans
+            num_classes = 2
+
+        # Initialize model
+        self.model = BeanDetector(
+            num_classes=num_classes,
+            max_detections=max_detections,
+            pretrained=use_pretrained
+        )
+
+        # Load checkpoint if provided and not using pre-trained
+        if model_path and not use_pretrained:
+            self.load_model(model_path)
+        
+        self.model.to(self.device)
+        self.model.set_eval_mode()
+        
+        # Initialize converters and processors with optimized settings
+        self.mask_converter = MaskConverter(
+            simplify_epsilon=0.5,
+            use_detailed_contours=True,
+            smooth_polygons=smooth_polygons,
+            smoothing_factor=smoothing_factor
+        )
+        self.post_processor = PostProcessor(
+            confidence_threshold=confidence_threshold,
+            nms_threshold=nms_threshold
+        )
+    
+    def load_model(self, model_path: Path) -> Dict[str, Any]:
+        """Load trained model.
+
+        Args:
+            model_path: Path to model checkpoint
+
+        Returns:
+            Model metadata
+        """
+        # Check if this is a file path that exists
+        import os
+        if os.path.exists(model_path):
+            metadata = self.model.load_checkpoint(model_path, self.device)
+            # Model loaded successfully - metadata available if needed
+            return metadata
+        else:
+            print(f"Model path {model_path} not found, using default initialization")
+            return {}
+    
+    def preprocess_image(self, image: Image.Image, target_size: Tuple[int, int] = (800, 800)) -> torch.Tensor:
+        """Preprocess image for model input with padding for smaller images.
+
+        Args:
+            image: PIL Image
+            target_size: Target size (height, width) for the model
+
+        Returns:
+            Preprocessed tensor
+        """
+        # Convert to tensor first
+        image_tensor = F.to_tensor(image)
+
+        # Get current dimensions
+        c, h, w = image_tensor.shape
+        target_h, target_w = target_size
+
+        # If image is smaller than target, pad it instead of resizing
+        if h < target_h or w < target_w:
+            # Calculate padding needed
+            pad_h = max(0, target_h - h)
+            pad_w = max(0, target_w - w)
+
+            # Pad to center the image
+            pad_top = pad_h // 2
+            pad_bottom = pad_h - pad_top
+            pad_left = pad_w // 2
+            pad_right = pad_w - pad_left
+
+            # Apply padding (with gray background, value=0.5)
+            image_tensor = F.pad(
+                image_tensor,
+                padding=[pad_left, pad_top, pad_right, pad_bottom],
+                fill=0.5  # Gray padding
+            )
+
+        return image_tensor
+    
+    def predict(
+        self,
+        image_path: Path,
+        return_polygons: bool = True,
+        return_masks: bool = True
+    ) -> Dict[str, Any]:
+        """Run prediction on a single image.
+
+        Args:
+            image_path: Path to input image
+            return_polygons: Whether to return polygon representations
+            return_masks: Whether to return binary masks
+
+        Returns:
+            Prediction results dictionary
+        """
+        # Load image
+        image = Image.open(image_path).convert("RGB")
+        original_size = image.size  # (width, height)
+        image_tensor = self.preprocess_image(image)
+
+        # Track padding offsets for coordinate adjustment
+        c, padded_h, padded_w = image_tensor.shape
+        orig_w, orig_h = original_size
+        pad_left = (padded_w - orig_w) // 2 if padded_w > orig_w else 0
+        pad_top = (padded_h - orig_h) // 2 if padded_h > orig_h else 0
+
+        # Run inference
+        start_time = time.time()
+        with torch.no_grad():
+            predictions = self.model([image_tensor.to(self.device)])[0]
+        inference_time = time.time() - start_time
+        
+        # Move to CPU
+        for key in predictions:
+            predictions[key] = predictions[key].cpu()
+
+        # Adjust coordinates if padding was applied
+        if pad_left > 0 or pad_top > 0:
+            # Adjust bounding boxes
+            if 'boxes' in predictions:
+                predictions['boxes'][:, [0, 2]] -= pad_left  # x coordinates
+                predictions['boxes'][:, [1, 3]] -= pad_top   # y coordinates
+
+            # Crop masks to remove padding
+            if 'masks' in predictions:
+                # Masks shape: [N, 1, H, W]
+                masks = predictions['masks']
+                if pad_left > 0 or pad_top > 0:
+                    # Remove padding from masks
+                    masks = masks[:, :,
+                                  pad_top:pad_top + orig_h,
+                                  pad_left:pad_left + orig_w]
+                predictions['masks'] = masks
+
+        # Apply post-processing
+        filtered_predictions = self.post_processor.filter_predictions(
+            predictions,
+            self.confidence_threshold
+        )
+        
+        # Apply NMS if requested
+        if self.apply_nms and len(filtered_predictions['scores']) > 0:
+            if self.nms_type == 'mask' and 'masks' in filtered_predictions:
+                filtered_predictions = self.post_processor.apply_mask_nms(
+                    filtered_predictions['boxes'],
+                    filtered_predictions['scores'],
+                    filtered_predictions['labels'],
+                    filtered_predictions['masks'],
+                    iou_threshold=self.nms_threshold
+                )
+            else:
+                filtered_predictions = self.post_processor.apply_nms(
+                    filtered_predictions['boxes'],
+                    filtered_predictions['scores'],
+                    filtered_predictions['labels'],
+                    filtered_predictions.get('masks'),
+                    nms_threshold=self.nms_threshold
+                )
+        
+        # Apply size filtering
+        if len(filtered_predictions['scores']) > 0 and 'masks' in filtered_predictions:
+            size_keep = self.post_processor.filter_by_size(
+                filtered_predictions['boxes'],
+                filtered_predictions['masks'],
+                min_area=self.min_bean_area,
+                max_area=self.max_bean_area
+            )
+            for key in filtered_predictions:
+                filtered_predictions[key] = filtered_predictions[key][size_keep]
+        
+        # Apply edge filtering if requested
+        if self.filter_edge_beans and len(filtered_predictions['scores']) > 0 and 'masks' in filtered_predictions:
+            edge_keep = self.post_processor.filter_edge_beans(
+                filtered_predictions['boxes'],
+                filtered_predictions['masks'],
+                image.size[::-1],  # Convert (width, height) to (height, width)
+                edge_threshold=self.edge_threshold
+            )
+            for key in filtered_predictions:
+                filtered_predictions[key] = filtered_predictions[key][edge_keep]
+        
+        # Count beans (label 1)
+        bean_indices = filtered_predictions['labels'] == 1
+        bean_count = bean_indices.sum().item()
+        
+        # Prepare results
+        result = {
+            'image_path': str(image_path),
+            'image_size': image.size,
+            'inference_time': inference_time,
+            'total_detections': len(predictions['scores']),
+            'filtered_detections': len(filtered_predictions['scores']),
+            'bean_count': bean_count,
+            'confidence_threshold': self.confidence_threshold,
+            'boxes': filtered_predictions['boxes'][bean_indices].tolist(),
+            'scores': filtered_predictions['scores'][bean_indices].tolist(),
+            'labels': filtered_predictions['labels'][bean_indices].tolist()
+        }
+        
+        # Add masks if requested
+        if return_masks:
+            result['masks'] = filtered_predictions['masks'][bean_indices]
+        
+        # Convert to polygons if requested
+        if return_polygons and return_masks:
+            bean_masks = filtered_predictions['masks'][bean_indices]
+            if len(bean_masks) > 0:
+                polygons = self.mask_converter.masks_to_polygons(
+                    bean_masks,
+                    self.mask_threshold
+                )
+                result['polygons'] = polygons
+        
+        return result
+    
+    def predict_batch(
+        self,
+        image_paths: List[Path],
+        batch_size: int = 1,
+        return_polygons: bool = True,
+        return_masks: bool = True
+    ) -> List[Dict[str, Any]]:
+        """Run prediction on multiple images.
+        
+        Args:
+            image_paths: List of image paths
+            batch_size: Batch size for processing
+            return_polygons: Whether to return polygon representations
+            return_masks: Whether to return binary masks
+            
+        Returns:
+            List of prediction results
+        """
+        results = []
+        
+        for i in range(0, len(image_paths), batch_size):
+            batch_paths = image_paths[i:i + batch_size]
+            
+            # Process batch
+            for path in batch_paths:
+                try:
+                    result = self.predict(
+                        path,
+                        return_polygons=return_polygons,
+                        return_masks=return_masks
+                    )
+                    results.append(result)
+                except Exception as e:
+                    print(f"Error processing {path}: {e}")
+                    results.append({
+                        'image_path': str(path),
+                        'error': str(e)
+                    })
+        
+        return results
+    
+    def update_thresholds(
+        self,
+        confidence_threshold: Optional[float] = None,
+        mask_threshold: Optional[float] = None,
+        nms_threshold: Optional[float] = None
+    ):
+        """Update detection thresholds.
+        
+        Args:
+            confidence_threshold: New confidence threshold
+            mask_threshold: New mask threshold
+            nms_threshold: New NMS threshold
+        """
+        if confidence_threshold is not None:
+            self.confidence_threshold = confidence_threshold
+            self.post_processor.confidence_threshold = confidence_threshold
+        
+        if mask_threshold is not None:
+            self.mask_threshold = mask_threshold
+        
+        if nms_threshold is not None:
+            self.nms_threshold = nms_threshold
+            self.post_processor.nms_threshold = nms_threshold

src/bean_vision/models/__init__.py

@@ -0,0 +1,110 @@
+"""Model modules for Bean Vision."""
+
+import torch
+import torch.nn as nn
+from torchvision.models.detection import maskrcnn_resnet50_fpn
+import torchvision
+from typing import Optional
+from pathlib import Path
+
+
+class BeanDetector(nn.Module):
+    """Simple bean detector model for compatibility with inference code."""
+    
+    def __init__(self, num_classes: int = 2, max_detections: int = 500, pretrained: bool = False):
+        super().__init__()
+        
+        # Create MaskR-CNN model with modified heads
+        weights = "DEFAULT" if pretrained else None
+        self.model = maskrcnn_resnet50_fpn(
+            weights=weights,
+            rpn_pre_nms_top_n_train=6000,
+            rpn_pre_nms_top_n_test=3000,
+            rpn_post_nms_top_n_train=4000,
+            rpn_post_nms_top_n_test=2000,
+            box_detections_per_img=max_detections,
+            box_score_thresh=0.05
+        )
+        
+        # Replace classifier head
+        in_features = self.model.roi_heads.box_predictor.cls_score.in_features
+        self.model.roi_heads.box_predictor = torchvision.models.detection.faster_rcnn.FastRCNNPredictor(
+            in_features, num_classes
+        )
+        
+        # Replace mask predictor head
+        in_features_mask = self.model.roi_heads.mask_predictor.conv5_mask.in_channels
+        hidden_layer = 256
+        self.model.roi_heads.mask_predictor = torchvision.models.detection.mask_rcnn.MaskRCNNPredictor(
+            in_features_mask, hidden_layer, num_classes
+        )
+    
+    def forward(self, images, targets=None):
+        return self.model(images, targets)
+    
+    def set_eval_mode(self):
+        """Set model to evaluation mode."""
+        self.eval()
+    
+    def load_state_dict(self, state_dict, strict=True):
+        """Load state dict, handling both wrapped and unwrapped models."""
+        # Check if state dict is from the wrapper model
+        if any(k.startswith('model.') for k in state_dict.keys()):
+            # It's from our wrapper, load directly
+            super().load_state_dict(state_dict, strict=strict)
+        else:
+            # It's from the underlying model, load into self.model
+            self.model.load_state_dict(state_dict, strict=strict)
+    
+    def load_checkpoint(self, checkpoint_path, device):
+        """Load model checkpoint from .pth or .safetensors format."""
+        checkpoint_path = Path(checkpoint_path)
+
+        if checkpoint_path.suffix == '.safetensors':
+            # Load safetensors format
+            from safetensors.torch import load_file
+            state_dict = load_file(checkpoint_path)
+            self.load_state_dict(state_dict)
+
+            # Check for metadata file
+            metadata_path = checkpoint_path.with_suffix('.json')
+            if metadata_path.exists():
+                import json
+                with open(metadata_path, 'r') as f:
+                    metadata = json.load(f)
+                return {
+                    'epoch': metadata.get('epoch', 0),
+                    'best_loss': metadata.get('best_val_loss', 0.0),
+                    'config': metadata.get('config', {})
+                }
+            return {}
+        else:
+            # Load .pth format
+            checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False)
+
+            # Handle different checkpoint formats
+            if isinstance(checkpoint, dict):
+                if 'model_state_dict' in checkpoint:
+                    self.load_state_dict(checkpoint['model_state_dict'])
+                elif 'state_dict' in checkpoint:
+                    self.load_state_dict(checkpoint['state_dict'])
+                else:
+                    # Assume the dict is the state dict itself
+                    self.load_state_dict(checkpoint)
+
+                # Return metadata if available
+                return {
+                    'epoch': checkpoint.get('epoch', 0),
+                    'best_loss': checkpoint.get('best_loss', 0.0),
+                    'config': checkpoint.get('config', {})
+                }
+            else:
+                # Direct state dict
+                self.load_state_dict(checkpoint)
+                return {}
+
+
+# Keep original import for other uses
+from .model import BeanModel
+
+__all__ = ["BeanModel", "BeanDetector"]