Agml

This release introduces tools for training custom agricultural machine learning models using AgML.

Main Changes

`agml.models`

- The `agml.models` API has been extended with new features for training, namely the `run_training` method which enables quick training of image classification, semantic segmentation, and object detection models.
- Simply instantiate a model with your number of classes, build an `AgMLDataLoader` with your data preprocessing, and pass it to the `run_training` method alongside other training hyperparameters to train a model.
- Choose your level of customizability: for newer users, options like optimizers, loss, and other hyperparameters are auto-selected, but for experienced users, you can go as far as extending the `training_step`, `validation_step`, and other arguments for greater customizability over training.

Other Changes and Bugfixes

- A major bug which prevented recompliation of Helios without LiDAR has been fixed, enabling users to switch between using LiDAR-compiled Helios and standard Helios.
- A bug which caused Helios installation on basic inspection is now patched. Helios will no longer auto-install unless the `agml.synthetic` module is actively used for data generation.
- You can now correctly display image samples when using `agml.viz.show_sample` with the `image_only` option.
- Bugfixes have been done for `agml.models.metrics.Accuracy` and `agml.models.metrics.MeanAveragePrecision` to ensure that they work with training.

**Read the Full Changelog**: https://github.com/Project-AgML/AgML/compare/v0.5.2...v0.6.0

New Features and Bugfixes

- Added the ability to save and load data splits for individual datasets using `loader.save_split` and `loader.load_split`.
- Added the ability to load multiple datasets using a wildcard name instead of passing each individual dataset in a list (e.g., to load all of the apple detection datasets, use `apple_detection*`).
- Use `agml.models.get_benchmark` to get benchmark information for a certain model trained on a certain dataset.
- Fixed bugs with mAP calculation during training.
- Fixed bugs with image preprocessing for object detection and visualization of object detection predictions.


**Full Changelog**: https://github.com/Project-AgML/AgML/compare/v0.5.1...v0.5.2

Main Changes

- Added a new dataset, `ghai_strawberry_fruit_detection`.
- Added a new method `agml.io.read_image` for convenience.
- Added the ability to generate both RGB & LiDAR data using the option `agml.synthetic.SimulationType.Both`.

Bugfixes and Updates

- You can now instantiate a collection of synthetic datasets by passing a list of them to the initialization of an `AgMLDataLoader`.
- A bug which prevented the visualization of predictions when using a `SegmentationModel` has now been patched.

**Full Changelog**: https://github.com/Project-AgML/AgML/compare/v0.5.0...v0.5.1

This release introduces synthetic LiDAR data generation through Helios, a rework of the `agml.viz` module with better functionality, and a number of new available datasets, amongst other features.

Major Changes

- The **`agml.io`** module has been added, with a few convenience functions for working with file and directory structures.
- Currently available functions include `get_file_list` and `get_dir_list` which also work with nested structures, as well as `recursive_dirname`, `parent_path`, and `random_file`.

`agml.data`
- Three new datasets have been introduced:
- Object Detection: `ghai_iceberg_lettuce_detection`, `ghai_broccoli_detection`
- Image Classification: `riseholme_strawberry_classification_2021`
- The `agml.data.ImageLoader` has been added, which is essentially a simple loader designed only for images.
- Enables loading images from a nested directory structure.
- Enables easy resizing and transforms of the loaded images.
- The `AgMLDataLoader` now has a new method `show_sample` which can be used to visualize samples from the dataset directly from the loader.

`agml.synthetic`
- **LiDAR Data Generation**: You can generate LiDAR-based synthetic data now, using `opt.simulation_type = agml.synthetic.SimulationType.LiDAR`.
- You can recompile Helios with LiDAR enabled, as well as in parallel (for Linux and MacOS systems) using `recompile_helios(lidar_enabled = True)` and `recompile_helios(parallel = True)` [note that parallel compilation is enabled by default].
- A new loader `agml.synthetic.LiDARLoader` has been added, which can be used to load point clouds from a generated directory in the same format as `ImageLoader`, and can be used to get point clouds and visualize them.

`agml.viz`
- The entire `agml.viz` module has been reworked with new methods and a functional visualization backend which enables both `cv2` and `matplotlib` displays, depending on what the user desires.
- The following is a mapping of the old functions to new functions:
- `visualize_images_and_labels` -> `show_images_and_labels`
- `output_to_mask` -> `convert_mask_to_colored_image`
- `overlay_segmentation_masks` -> `annotate_semantic_segmentation`
- `visualize_image_and_mask` -> `show_image_and_mask`
- `visualize_overlaid_masks` -> `show_image_and_overlaid_mask`
- `visualize_image_mask_and_predicted` -> `show_semantic_segmentation_truth_and_prediction`
- `annotate_bboxes_on_image` -> `annotate_object_detection`
- `visualize_image_and_boxes` -> `show_image_and_boxes`
- `visualize_real_and_predicted_bboxes` -> `show_object_detection_truth_and_prediction`
- `visualize_images` -> `show_images`
- To swap between viz backends, use `get_viz_backend` and `set_viz_backend`.
- In order to simply display an image, you can use `display_image`.
- To visualize a point cloud (either in Open3D if installed, or matplotlib), use `show_point_cloud`.

Other Changes
- **Major Change for New Users**: `torch`, `torchvision`, and other related modeling packages for the `agml.models` package are no longer distributed with the AgML requirements -- you must install these on your own if you want to use them.

Minor/Functional Changes + Bugfixes
- Fixed backend swapping between TensorFlow and PyTorch when using clashing transforms.
- Added the ability to run prediction with a classification and a segmentation model without normalizing the input image using `model.predict(..., normalize = False)`.
- Images no longer auto-show as matplotlib figures when using `agml.viz.show_*` methods, instead they are returned as image arrays and can be displayed in a desired format.
- Improved access and setting of information in the backend `config.json` file, so information is not accidentally overwritten.


**Full Changelog**: https://github.com/Project-AgML/AgML/compare/v0.4.7...v0.5.0

Main Changes

- Introduced two new public object detection datasets from the Western Growers Global Harvest Automation Initiative (https://github.com/AxisAg/GHAIDatasets): `ghai_romaine_detection`, and `ghai_green_cabbage_detection`.
- Added the ability to generate multiple different types of annotations when generating synthetic datasets with Helios.

Other Changes
- Fixed errors with different visualization utilities as well as synthetic data annotation conversions.

**Full Changelog**: https://github.com/Project-AgML/AgML/compare/v0.4.6...v0.4.7

Main Changes

- You can now manually generate synthetic data with Helios using your own C++ generation file and CMake parameters/XML style file, using the method `agml.synthetic.manual_generate_data`. This allows for a greater deal of customizability and control over how Helios is compiled, as well as which methods are being used.
- A convenience method `agml.viz.show_sample` has been added which enables quick visualization of an image and its annotations: this works for all types of annotations, simply pass a loader as the argument.

Other Improvements

- If you want to overwrite files when generating synthetic data with the `HeliosDataGenerator`, you can now pass the argument `clear_existing_files = True` to the `generate` method.
- You can now compile Helios using the standard API in both the 'Release' and 'Debug' modes.

*[Read the Full Changelog Here.](https://github.com/Project-AgML/AgML/compare/v0.4.5...v0.4.6)*