Release Notes

Release notes for Rhino FCP.

Rhino Federated Computing Platform (FCP) ships monthly updates that include new features, bug fixes, and platform improvements.

This page provides an overview of each release, highlights key changes, and links to related documentation when available. We typically publish release notes for the previous month around the middle of the following month.

We welcome feedback on all aspects of the platform and encourage you to share your questions, suggestions, and experiences with us.

2026 Release Notes

The following contains the release notes for 2026, in descending date order.

August 2026

Multiple VM Pools per Code Object

A code object can now be associated with more than one pre-allocated VM pool, and agents are linked directly to VM pools rather than to individual reservations. This gives compute-intensive workloads more scheduling flexibility across available capacity.

Fallback Behavior for VM Pool Runs

Runs targeting a pre-allocated VM pool can now fall back to an ad hoc VM when no pooled capacity is available. A default fallback strategy is applied automatically, and the behavior is exposed as a checkbox when configuring a run, so a busy pool no longer blocks a job from starting. Code run details now also show the VM pools that were requested, not only the one that was claimed.

Documentation Has Moved

Rhino documentation now lives at docs.rhinofcp.com. Existing links to docs.rhinohealth.com have been updated across the platform, including the per-transformation "See documentation" links in Syntactic Mapping, which now point to the specific page for each transformation type.

Quality of Life Improvements

• Faster-feeling page loads: Pages now render a content skeleton while loading instead of a full-page spinner, so you can see the structure of a page immediately.

• Search in Target ValueSet selection: The Target Domain / Target ValueSet field in Semantic Mapping transformations is now searchable, which makes finding the right value set much quicker in large vocabularies.

• TensorBoard sessions clean up automatically: TensorBoard jobs now terminate after a period of inactivity rather than running indefinitely, which also prevents them from blocking client agent updates.

Deprecations

Support for NVFlare v2.0 has been retired. Contact your Rhino representative if you have a code object that needs migrating.

July 2026

AI-Assisted OMOP Mapping

Syntactic mappings that target OMOP can now be generated automatically. The AutoMapper populates source fields and suggests transformations for OMOP target schemas, giving you a reviewable starting point instead of an empty mapping table. AutoMapper behavior is now consistent between OMOP and custom syntactic mappings, and when an AutoMapper action is unavailable — for example the syntactic mapping is locked because it’s in use — you can create a new version of Syntactic Mapping and continue with the Automapper.

FHIR Vocabularies in Semantic Mapping

Semantic mapping now supports FHIR vocabularies. IL-HDP Encounter ValueSets derived from FHIR bindings are available as built-in Standard Vocabularies, so you can map to them directly without first loading them as custom vocabularies.

Support for Larger Tabular Datasets

Import, export, and Generalized Compute runs now handle substantially larger tabular datasets. Operations that previously failed or timed out on large tables now complete.

TensorBoard Log Access for Code Runs

TensorBoard logs for a code run are now discoverable directly from the run. When no logs are available, the platform says so instead of directing you to the TensorBoard project page.

Vault-Brokered Cloud Credentials for On-Premises Deployments

On-premises deployments can now broker cloud credentials through Vault rather than holding long-lived credentials on the client. To enable this, contact [e-mail].

Quality of Life Improvements

• Named output datasets from harmonization runs: When running a Harmonization Code Object, you can now specify the name of the output dataset instead of accepting a system-generated one, making outputs easier to identify in busy projects.

• Table view, filters, and pagination on the Projects page: Projects can now be viewed as a table in addition to cards, with filtering, a clear-filters action, and pagination for large project lists.

• Collaborator information hidden in code runs: When Hide Collaborators is enabled for a project, site logs and collaborator information are now also hidden within code runs, closing a gap where collaborator identity could be inferred from run detail.

• Clearer syntactic mapping headers: The target title header now reflects whether you are mapping to OMOP, FHIR or to a custom schema.

• Filters on the Workgroup object: Workgroups can now be filtered through the API and SDK, matching the filtering already available on other platform objects.

• Interface refresh across the dashboard: Modals and info icons have been standardized to the current design, the in-app notification component was updated for readability, search bars were added and standardized across object listing pages, and an unnecessary horizontal scrollbar was removed from the Projects page.

June 2026

Support for Hierarchical Schemas (e.g., FHIR) in Syntactic Mapping

Syntactic Mapping now supports hierarchical target schemas such as FHIR, in addition to flat tabular schemas. You can map source data into nested, grouped structures with field-grouping — making it possible to harmonize directly to standards like FHIR IL-HDP without leaving the low-code mapping experience.

Built-in FHIR IL-HDP Selected Profiles and Value Sets/Vocabularies (Encounter Profile)

Syntactic Mapping now presents pre-defined FHIR IL-HDP profiles, and Semantic Mapping supports the corresponding FHIR IL-HDP Encounter value sets. You can map directly against the standard's built-in profiles and vocabularies instead of defining them yourself, speeding up harmonization to FHIR IL-HDP. More Value Sets coming!

Pre-allocated VM Pools for Compute Runs (Rhino-managed)

You can now run jobs on a reserved pool of VMs instead of provisioning hardware on demand. Multiple pools can be configured (for example, a CPU pool and a GPU pool), jobs queue automatically when a pool is busy, and utilization and queue-time metrics support capacity planning — guaranteeing hardware availability and giving more predictable costs. Initial availability is on Rhino-managed GCP for Generalized Compute runs. Currently available in GCP, other Cloud Providers coming soon!

Quality of Life Improvements

• Consistent confirmation before deleting mappings and vocabularies: Deleting a Syntactic Mapping, Semantic Mapping, or Custom Vocabulary now always asks for confirmation, whether you delete from the bulk-select action or the row-level menu — removing a long-standing inconsistency and reducing the risk of accidental data loss.

• Safer behavior when the Rhino Client is offline: Generalized Compute, NVFlare, and Interactive Container runs are now prevented while the relevant client is offline, and the offline warning correctly clears once the client reconnects so the run button is no longer left disabled.

• Clearer Code Object details: Improved visibility and layout of the Code Object information modal.

• Faster dataset analytics with many datasets: Performance improvements to the dataset analytics page for workgroups with a large number of datasets.

• Accessibility: Accessibility improvements to the project creation dialog.

May 2026

Built-in FHIR IL-HDP Profiles in Syntactic Mapping

Syntactic Mapping now supports FHIR IL-HDP as a target schema directly in the UI. When creating a mapping, you can select from predefined IL-HDP profiles — the platform handles the conversion of FHIR JSON profiles into Rhino-compatible flat schemas automatically. Multi-choice field names now include proper datatype support, and required fields are clearly indicated throughout the mapping process.

MCP Server Improvements

The Rhino MCP Server now includes a rhino_project_summary tool that surfaces a project's full flow and timeline in a single call — useful for AI assistants navigating complex projects. Vocabulary creation is also now available via both MCP and the SDK, including CSV file upload support.

Admin Control: Lock Site-Level Permissions Mid-Project

Rhino admins can now disable the ability to change site-level permissions once a project is underway. This gives organizations tighter control over access governance in active collaborations, preventing unintended permission changes mid-study.

Rhino Health Now Available on Azure Marketplace

Rhino Health FCP is now listed on the Azure Marketplace, making it easier for organizations already operating in the Azure ecosystem to discover, procure, and deploy the platform through their existing cloud agreements.

Quality of Life Improvements

• Dashboard sticky tabs: Navigation tabs in the dashboard now stay visible while scrolling, so you can switch views without scrolling back to the top.

• Semantic Mapping term count: The approval page now shows the term count for each mapping, giving reviewers a quick summary before diving into individual entries.

• Custom Vocabulary sticky controls: The header and footer on the Custom Vocabulary page are now sticky, keeping key actions accessible while scrolling through large vocabularies.

• Dataset Analytics layout: Column widths in the data completeness table have been adjusted for better readability.

• Improved Not Found page: The 404 / object not found page has been redesigned with clearer messaging, better layout, and more helpful next steps.

• Accordion open state: Accordion components now have a clearer visual indicator when expanded, reducing ambiguity about their state.

• Semantic Mapping column resize: Columns on the approval page can now be resized, making it easier to review wider content.

• Light/dark mode toggle: The platform now includes a toggle to switch between light and dark mode.

April 2026

Configurable Usage Tracking and Limits

Projects can be configured to track usage and enforce usage limits for different actions, e.g., limiting the total number of code runs allowed in a specific time window, total number of code runs of specific code objects, etc. This provides more granular control over resource utilization as well as increasing security (e.g., protection against model distillation attacks). To learn more about usage limits, reach out to [e-mail] and/or read What is a Code Run?

Data Harmonization UX Improvements

Several improvements ship this month across the data harmonization experience. Column headers in syntactic mapping, semantic approval, and vocabulary tables now stay fixed while scrolling, so you always know which column you're working in. The overall DHE interface has been refreshed with a cleaner layout and more consistent visual hierarchy. Within semantic mapping, rows now highlight on hover for easier tracking in long lists, and the Create Semantic Mapping modal includes searchable dropdowns for dataset and schema selection.

Quality of Life Improvements

• Extended startup window for container images: Code runs using large container images or on slower networks can now start reliably on Rhino Clients. The startup timeout has been extended from 1 hour to 24 hours, eliminating failures caused by lengthy image pull times and/or slower networks.

• Column search in the data schema editor: You can now search for specific columns directly within the schema edit view - useful when working with wide schemas.

• Project step navigation: Clicking a step in the Project Overview now navigates directly to the relevant tab, removing the need to manually switch tabs.

• Dashboard design refresh: Buttons, tables, project cards, and the color system across the FCP dashboard have been updated to match the latest design standards.

March 2026

Persistent Workspace in Interactive Containers

Interactive container runs now include a dedicated Workspace folder that persists across sessions, giving users a stable location for scripts, models, and intermediate outputs between runs. See more detail in the Creating and Running Interactive Container Code article.

NVFlare v2.7 Support

The platform now supports NVIDIA FLARE v2.7, including its latest federated learning features, performance improvements, and security updates.

Semantic Mapping for Custom Vocabulary Versions

You can now target specific versions of a custom vocabulary when configuring semantic mappings, enabling version-aware, reproducible data standardization. The active vocabulary version is displayed inline so there's no ambiguity about what's applied.

Snappy-Compressed Parquet Import

Datasets in Parquet format using Snappy compression can now be imported directly - a common output format in modern data pipelines.

Quality of Life Improvements

• In-App Feedback: Users can now submit feedback and report errors directly from within the platform.

• Edit Extra Data in Configuration Modals: The extra_data field can now be edited directly from code run configuration modals.

• Breadcrumb Navigation: Page breadcrumbs no longer trigger a full page reload, making in-app navigation faster.

• Project Search Shortcut: Cmd+F on the project page now immediately focuses the search field.

• Custom Vocabulary Version Visibility: The semantic mapping UI now shows which custom vocabulary version is in use.

February 2026

Extra Data Field for Extensible Platform Objects

FCP supports a new extra_data JSON field for data schemas, datasets, code objects, and code runs, enabling teams to store additional structured metadata alongside these resources. This flexible field can be updated by authorized users without creating a new version and is available through the API for integration with external workflows and tooling.

Semantic Mapping to Large Custom Vocabularies

Rhino FCP now supports semantic mapping to large custom vocabularies (up to 1 million terms). This allows for mapping to large FHIR ValueSets or large coding systems. The system maintains fast response times, even with large vocabularies.

Map to Array Transformation in Syntactic Mapping

FCP supports a new Map to Array transformation in Syntactic Mapping, allowing users to group multiple source fields into a single array-formatted output at runtime. This simplifies working with variable-cardinality data (such as diagnoses or addresses) and reduces schema and mapping complexity.

Schema Evolution Support in Syntactic Mapping

FCP supports schema evolution in Syntactic Mapping, enabling users to create new mapping versions that automatically preserve existing mappings when source or target schemas are updated. This allows teams to incrementally maintain mappings as schemas evolve, reducing effort for large or frequently updated datasets.

Quality of Life Improvements

• Transposed view for Edit Data Schema

  On the Edit Data Schema page, you can now toggle a “Transposed” view. This flips the layout of fields, making very wide schemas much easier to scan and edit.

• Version Support for Custom Vocabularies

  FCP supports versioning for Custom Vocabularies, allowing users to create new versions by uploading an updated CSV file. This enables controlled and auditable vocabulary updates while maintaining stability for existing mappings and workflows.

• Show version of Harmonization Objects

  When editing harmonization objects (semantic/syntactic mapping objects, and/or custom vocabularies), the object version is displayed right next to the name to inform the user.

• Improved project privacy settings organization

  FCP groups key project-level controls, including Closed-Membership Collaborators, Hide Collaborators, and Require Confidential Computing, under the Privacy Parameters section in project settings, making it easier to understand and configure a project’s privacy model.

January 2026

AI-Assisted Syntactic Mapping Generation

FCP supports AI-assisted generation of syntactic mappings, allowing users to automatically generate initial mapping recommendations between source and target schemas. Using an LLM, the platform can populate source fields and suggested transformations for empty mapping rows, helping users quickly initialize large or complex mappings while retaining full control to review, edit, or refine the results before saving.

NVFlare Server Scaling Support

We’ve added a dedicated section in the Code Object modal to scale server compute resources. This update ensures you have the flexibility to handle large-scale Federated Learning models and high-RAM/CPU requirements on the Federated Server.

Improved Hebrew support for Semantic Mapping

Custom vocabularies in Hebrew are now indexed with a Hebrew-specific embedding model, and any associated Semantic Mappings use the same model during pre-filtering. This alignment improves the accuracy and consistency of Hebrew-language matching across vocabularies and Semantic Mapping.

Editable site permissions for Workgroup Admins

Workgroup Admins can now modify their own site-level permissions from within an active project. These changes are fully audited and appear in Recent Activities and the audit log, combining flexibility with compliance.

Quality of Life Improvements

• Resizable Transformation Panel in Syntactic Mapping

  Users can resize the Transformation side panel to comfortably view and edit long row-level transformation code (especially, long Python code).

• Improved search in Code Objects, Code Runs, and Datasets

  We’ve enhanced search for Code Objects, Code Runs, and Datasets so you can more quickly narrow down to the items you need, even in busy environments with many runs and assets.

2025 Release Notes

The following contains the release notes for 2025, in descending date order.

December 2025

Rhino Client Auto-scaling for GC and Python Code

Code Objects of type "Generalized Compute" (GC) and "Python Code" can now be configured with Compute Resource Specs, which specify compute requirements like CPU, RAM, and GPU. When a code object with Compute Resource Specs is run, instead of running on the same VM on which the Rhino Client is running, a new ad-hoc VM will be spun up with resources matching the compute requirements, the code will be executed on this VM, and after completion, the VM will be spun down.

Paginated Results

Pagination is being introduced for the Datasets, Data Schemas, Code Objects, and Code Runs functionality across the platform. This includes changes to the REST API endpoints, the FCP GUI, and the Rhino SDK methods for retrieving these objects.

This makes it easier to work with projects that have heavy FCP usage, generating a high volume of objects, improving the responsiveness and load time of the Datasets and Code Runs pages and corresponding retrieval API/SDK methods.

Geo-based Access

Organizations can enable geo-based access control to limit FCP login for their team members to specific countries. If you try to sign in from an unsupported country, you’ll see a clear message explaining that your location is not allowed. To enable this feature, please contact us at [e-mail].

Closed Membership Workgroups

Projects can now be configured to allow only "closed membership workgroups" to participate in the project. When enabled, only workgroups that are configured as ones with "closed membership" can participate in the project. Closed membership workgroups have a fixed set of users (members) and cannot have additional users added to them. To configure a workgroup as having closed membership, please contact us at [e-mail].

Run Params in NVFlare Inference

Run params and secret run params can now be passed into NVFlare inference runs, just like they can be passed into other types of code runs. NVFlare inference runs also support reading secrets from a customer-hosted Secrets Manager via the Enterprise Secrets Manager integration. See more information in Creating and Running NVFlare Code and Running Inference

Quality of Life Improvements

• View in-progress Semantic Mappings

  The UI now supports viewing a Semantic Mapping that is in progress, so you can inspect the current state and start mapping reviews while mappings are still being built or refined.

November 2025

Dataset Publishing

We have launched support for enhanced intra-project privacy settings, enabling more secure collaborations with external collaborators. You can now set Datasets and Data Schemas to be visible only to your team by default, and then publish the desired Datasets and/or Data Schemas to be accessible to all project participants. This provides you with more control over which versions of your Datasets and Data Schemas other project participants will be able to see and interact with.

In addition, there is a new “Hidden Collaborators” privacy setting, making each collaborator in the project hidden from all other collaborators, with the exception of the Project Lead. This enables projects where collaborators can work together and with the project lead, without knowing who the other project participants are, or seeing any information related to these participants.

For more information about how to set this up see Publishing Datasets or reach out to Rhino support.

Private Collaboration Permissions

We have launched support for enhanced intra-project privacy settings, enabling more secure collaborations with external collaborators. You can now set Datasets and Data Schemas to be visible only to your team by default, and then publish the desired Datasets and/or Data Schemas to be accessible to all project participants. This provides you with more control over which versions of your Datasets and Data Schemas other project participants will be able to see and interact with.

In addition, there is a new “Hidden Collaborators” privacy setting, making each collaborator in the project hidden from all other collaborators, with the exception of the Project Lead. This enables projects where collaborators can work together and with the project lead, without knowing who the other project participants are, or seeing any information related to these participants.

For more information about how to set this up see Hide Collaborators in the Permissions article or reach out to Rhino support.

Quality of Life Improvements

• Open Interactive Containers in the same tab

  Interactive Containers now open in the same browser tab by default, simplifying workflow and avoiding extra tab clutter when iterating on experiments.

• Clearer messaging for Analytics permissions

  If a user doesn’t have the right permissions to view Analytics for a Dataset, Rhino now shows a clearer, more helpful message explaining why access is restricted and what to do next.

October 2025

Dataset Navigation Improvements

We've simplified dataset navigation for greater consistency and easier exploration. This makes it easier to review output datasets with results directly in the FCP GUI, provided you have the necessary permissions.

Limit AWS Region for Dataset Import

For AWS S3 client-mounted storage, users can now specify the region in client mounted storage. When specified, access to the bucket is allowed only from that region.

Quality of Life Improvements

• User can resize columns from Syntactic Mapping view page.

• When defining a SetValue transformation in a Syntactic Mapping, it is no longer mandatory to define a source field.

September 2025

Import from SQL in the FCP GUI

We have extended the SQL Database data import to be available in the GUI in addition to the SDK. For more details, see Importing a Dataset.

Rhino DHE - CSV Upload of Custom Vocabularies

Custom Vocabularies defined as part of Rhino DHE (f.k.a. Copilot or Automapper) can now be uploaded from a CSV file and not just copy-pasted into the FCP UI. The vocabulary term view was also improved to support pagination, sorting, and filtering.

Model Personalization via Local Fine Tuning

Local fine-tuning in personalized federated learning allows each client to further train the globally aggregated model on its unique local data for a few steps, creating a customized version. This is useful because it helps the model overcome data heterogeneity (non-IID data) among clients, ensuring that the model performs optimally for each individual site while still leveraging the general knowledge shared across the entire network.

Rhino FCP now support model personalization by allowing a local model at each site to be stored as part of the federated training process, e.g., as a follow-up step after the global model has been trained.

Quality of Life Improvements

• Allow passing runtime parameters and runtime secrets in on NVFlare inference. See more details in Creating and Running NVFlare Code and Running Inference.

August 2025

Differential Privacy in Dataset Analytics

Added support for Differential Privacy (DP) in Dataset Analytics, which aligns this feature with the DP support in the Federated Metrics via the SDK. Combined with the DP support via NVFlare, this allows DP to be used as a privacy enhancing mechanism across all parts of Rhino FCP.

Client-Offline Notifications

Added notifications about offline Rhino Clients across all relevant pages in the Rhino FCP GUI. Now users will see that their Rhino Client is offline in all relevant pages and modals (e.g., dataset import, schema creation, collaborator page). Also, users are now not allowed to import or run code objects when the relevant Rhino Client is offline.

FHIR as a Target Data Model in Rhino DHE

The Rhino Data Harmonization Engine (RhinoDHE, f.k.a. Copilot or Automapper) now allows you to select FHIR R4 as a target data model in Syntactic Mappings. This is another step along the path to full FHIR support across different versions of the standard.

As part of the support for FHIR, FCP can now import datasets from the Intersystems IRIS database as one of the SQL DB formats support by the platform.

Quality of Life Improvements

• When exporting a dataset, the metadata.json file includes the type for each field.

July 2025

Confidential Computing Support: Hardware Attestation for Rhino Clients

Rhino FCP now supports hardware attestation for Rhino Clients. The combination of federated learning and confidential computing is considered the best in class combination for enabling training on remote data while protecting data privacy. As part of the Confidential Computing support, Rhino FCP now supports hardware attestation of Rhino Client hardware in addition to the previously supported software attestation. This ensures that only approved hardware is being used when running confidential workloads. To learn more about it, please reach out to Rhino support.

Integration with Azure Blob Storage

Client-mounted storage now support Azure Blob Storage, in addition to AWS S3, GCS, and SMB. See more information in Mounting Storage to Your Rhino Client.

Publishing/Unpublishing Code Objects and Code Runs

By default, all participants in a Project can view all Code Objects and Code Runs in the Project. However in some cases you may want to limit which Code Objects/Runs other collaborators see. For example, if you are testing out your code, and are iterating with different Code Objects, and want to make only the final working version available to others.

This can now be configured in Rhino FCP. When you set up your project, specify in the permissions who you want to be able to View Code Objects and Code Runs for your site's objects. If you limit access (e.g. to allow only your workgroup's members to be able to view these), then by default visibility to your Code Objects/Runs will be limited. You can then "publish" a Code Object or Code Run to make it visible to all project participants.

This capability was previously available only via the Rhino SDK, and is now also available in the Rhino Web UI.

Improved Accuracy of Semantic Mapping

The Rhino Harmonization Copilot now has an improved Semantic Mapping model with improved accuracy. The new model uses embeddings to better identify terms with similar meaning. This embedding model was fine tuned on mappings of clinical terms to improve its accuracy for common terminologies.

SDK Support for Data Harmonization

To support automation and integration into ETLs and production systems, data harmonization Code Objects can now be run directly via the Rhino SDK. Syntactic Mappings, Semantic Mappings, and Custom Vocabularies can now also be read, created, and updated via the Rhino SDK, allowing to automate the mapping creation using Rhino Harmonization Copilot.

Example Terraform for Rhino Client Provisioning

In order to simplify provisioning of hardware for Rhino Clients, we now have example terraform modules for GCP, AWS, and Azure. Check them out here.

June 2025

Confidential Computing Support: Rhino Cloud on GCP

Rhino FCP has extended functionality for Confidential Computing. The combination of Federated Computing and Confidential Computing is the state of the art in security. In addition to the previously supported Confidential Computing support for Rhino Clients, the GCP Rhino Cloud can now be run on Confidential VMs such that all workloads running on them will be executed in a Trusted Execution Environment (TEE). This extends the protection to workloads to Rhino Cloud workloads such as Federated Server workloads. Protecting our customers' data and IP is of utmost important to us, so we are committed to utilizing the best tools to ensure this protection.

Project Permission Templates

When creating a new project on Rhino FCP you can specify the project permissions governing the Role-Based Access Control (RBAC) policy for the project. You can now add custom project permission templates to make this process simpler and less error prone. Reach out to Rhino support to try this out.

Purge Unused Data from Rhino Client Storage

Data from datasets marked as "Removed" can now be deleted at your request from the Rhino Client file system, freeing up internal storage. Any tabular data from removed datasets will be deleted, as will any associated files or DICOM data that isn't being used by any active dataset. This feature is designed to help you maximize the utilization of your Rhino Client Storage. Please contact us to enable and utilize this functionality.

Improved SSO Login Re-direct

This release enhances the login redirect mechanism to also work for users logging in via Single Sign-On (SSO). Now, similar to username/password login flows, users authenticating through SSO will be redirected to their target page via a deep-link or to their last accessed page, ensuring a seamless continuation of their workflow.

Publishing Run-time Files

We've enhanced Run-time Files in Rhino FCP for better collaboration and utility. They now include model parameters from federated training (alongside Code Artifacts) and can be used in any Code Run, expanding beyond Inference Code Runs.

Workgroup members can now "publish" Run-time Files, making them available to all project collaborators for use in Code Runs while maintaining data security by preventing direct download or access. This capability streamlines workflows for scenarios like fine-tuning models or integrating shared packages into your code.

Publishing and unpublishing is currently managed with the Rhino SDK, with Rhino Web UI support on the way.

May 2025

Confidential Computing Support: Rhino Clients

Rhino FCP now supports Confidential Computing. The combination of Federated Computing and Confidential Computing is the state of the art in security. Rhino Clients can now be run on Confidential VMs across GCP, AWS, and Azure such that all workloads running on them will be executed in a Trusted Execution Environment (TEE). This helps protect workloads while they are being processed, in addition to the protection available in Rhino FCP for container images at rest and in transit. Protecting our customers' data and IP is of utmost important to us, so we are committed to utilizing the best tools to ensure this protection.

Enterprise Secrets Manager Integration

With the new Enterprise Secrets Manager Integration, organizations can run encrypted code with additional security. This integration allows Rhino FCP to read secrets for a Code Object from your organization's AWS Secrets Manager, and inject them directly into the Code Run's secrets. This means containers can be encrypted with keys that are stored in your Secrets Manager, and decryption keys can be provided automatically to the Code Object during run-time without user intervention or manual copy-pasting of keys. Contact us for more information.

Support for NVIDIA FLARE 2.6

Rhino works closely with NVIDIA and has added support for running FL training with NVFlare 2.6 within Rhino FCP within weeks of the release of this version. All workloads that are implemented with NVFlare 2.6 can be seamlessly run on Rhino FCP. For a full list of NVFlare 2.6 updates see NVIDIA's release notes page.

Unlisted Workgroups and Approved Collaborators

By default, all teams ("workgroups") working with Rhino FCP are listed as collaborators that can be invited to projects by others (joining a project requires someone from the invited workgroup to review and approve the permissions policy for the project and accept the invitation). For workgroups that do not wish to be listed as potential invitees by others, there is now an option to become "unlisted". Workgroups that are unlisted can provide a specific set of collaborators that are allowed to see them and invite them to projects. If you'd like to unlist your workgroup, please contact us.

Limiting Image Repository Access

Rhino FCP provides a secure container image repository for each workgroup. This image repository is used to store any container images that users want to run via Rhino FCP. By default, all users within a workgroup have access to this image repository and are allowed to push container images to this repository. Some workgroups may want to limit this, and allow only specific users to push images to this repo. We've added support for limiting the set of users who have access to a workgroup's image repo. If you'd like to limit access to your workgroup's image repository, please contact us.

April 2025

Enhanced Federated Computing on Sensitive Data

The Rhino FCP now has enhanced capabilities for processing sensitive data securely. Your datasets with sensitive data (e.g. PII, PHI) can be imported into the FCP and then be processed using all of the existing capabilities on FCP, like being used as input for containerized code, being used for federated training, undergoing transformation using Harmonization Copilot, etc. You can also use the FCP for custom de-identification workflows. In addition to the already supported HIPAA safe harbor de-identification, you can now run custom de-identification code or even interactive applications to de-identify data. All of this happens without ever moving your data outside of your network, adhering to the strict privacy principles of FCP. For further information, in the Sensitive Datasets article.

Renaming Objects

Rhino FCP now supports renaming objects (e.g. Projects, Datasets, Code Objects). Did you accidentally create a Project with a typo and want to fix it? No problem - now you can easily rename it. Do you want to update the name of a Dataset to better distinguish it from other Datasets? No problem - now you can easily rename it. Hover over the name of an object and a pencil icon will appear. Clicking on this icon will make the object's name editable. When you're done editing the name of the object simply click anywhere else on the screen and the object will be renamed.

Publishing/Unpublishing Code Objects and Code Runs

By default, all participants in a Project can view all Code Objects and Code Runs in the Project. However in some cases you may want to limit which Code Objects/Runs other collaborators see. For example, if you are testing out your code, and are iterating with different Code Objects, and want to make only the final working version available to others.

This can now be configured in Rhino FCP. When you set up your project, specify in the permissions who you want to be able to View Code Objects and Code Runs for your site's objects. If you limit access (e.g. to allow only your workgroup's members to be able to view these), then by default visibility to your Code Objects/Runs will be limited. You can then "publish" a Code Object or Code Run to make it visible to all project participants.

Publishing/unpublishing is currently supported only via the Rhino SDK. Support in the Rhino Web UI is under way.

Semantic Mapping to OMOP - Search by Concept ID

When reviewing a Semantic Mapping to an OMOP domain, you can select one of the terms recommended by Rhino's Semantic Mapping AI model, or you can enter text to search for a specific term from the selected target domain. Now you can search not just by the concept name, but also by the concept ID of the relevant term, making it easier to find the exact term that you are looking for as part of the semantic mapping.

March 2025

Self-Service User Management

Workgroup Admins can now view and manage Rhino user accounts for their workgroup directly in the Rhino FCP GUI. This new functionality makes it easier to add and remove users to workgroups, simplifying setup and ongoing account maintenance on FCP. Go to Settings > User Management to check it out today! To learn more abou this feature, see Managing User Accounts in Your Workgroup.

Data Harmonization to FHIR and to Custom Data Models

The Harmonization Copilot now supports creating Syntactic Mapping transformations to custom data models with a low-code GUI. This expands the ability to use the easy to use GUI to create transformations beyond OMOP, to any data model. This can also be used to perform transformations to FHIR with different specifications.

We believe that this functionality will significantly simplify data harmonization and are very excited to hear about your feedback! Please see About the Harmonization Copilot for more information.

Removed Dependency on SSM in Rhino Clients

Rhino Clients previously required installation of AWS Systems Manager (SSM) for ongoing operation (e.g. for credential rotation and for software updates). This dependency has been removed, and it is now possible to install Rhino Clients without installing or activating SSM. By default, SSM is still installed to be used as a troubleshooting mechanism, but this isn't required. If you'd like to install a Rhino Client without SSM enabled (or remove SSM from an existing Rhino Client installation), please reach out to the Rhino team.

Enhanced Support for Homomorphic Encryption

Homomorphic Encryption can be used in concert with Federated Learning to protect the underlying data from being exposed in the Federated Server. Rhino FCP now allows users to configure Homomorphic Encryption directly within the Rhino FCP GUI and Rhino SDK, which enables this mechanism in the underlying NVIDIA Flare FL training tasks.

Organization-Specific Password Length Requirements

If your organization has specific security requirements regarding minimum password length, these can now be configured into Rhino FCP and enforced for all users within the organization. In order to configure this for your organization, please reach out to the Rhino team.

February 2025

Simplified Client-Mounted Storage Integration

Workgroup admins can now mount storage on their Rhino Client directly from the settings page in the Rhino FCP GUI. As it was supported before, the storage can be mounted from site-owned cloud object storage (AWS S3 or Google Cloud Storage) or SMB network shares. In addition, users can view Client-Mounted Storage configurations and copy their mount path to ease importing and exporting data to FCP. They can also test the connection to aid troubleshooting. This new functionality makes it easier to work with existing storage, simplifying starting projects and collaborations on FCP. Go to Settings > Client Mounted Storage to check it out today!

AWS Marketplace

Rhino Federated Computing Platform can now be purchased directly on AWS Marketplace. See more information directly in Rhino's listing on the AWS Marketplace.

New Rhino SDK Getting Started Guide

The Rhino SDK has a new getting started guide to help you get up and running quickly and easily. It provides an overview of what the SDK is, how to install it, and what you can do with it, including some easy to follow examples.

Fewer Outbound Ports Used by Rhino Clients

The Rhino Client has been updated to only require a single outbound port (tcp/443), vs. the previous 5 outbound ports that were needed. This makes the Rhino Client installation simpler and more secure.

January 2025

Harmonization Copilot V2 launch!

The Rhino Federated Computing Platform now supports full ETL to OMOP v5.4. Building on top of the novel Gen-AI semantic mapping functionality existing in FCP, now FCP users can create syntactic mappings to OMOP with a low-code GUI and harmonize datasets imported to FCP directly to OMOP without having to write ETL code. The Copilot supports multiple data transformations without the need to write code such as custom mapping or date formatting, while also allowing to add your code transformations in Python when needed.

We believe that this functionality will significantly simplify data harmonization and are very excited to hear about your feedback! Please see About the Harmonization Copilot for more information.

New Settings Page

We have enhanced the former Profile Page into a Settings Page with better feature grouping and more context, including links to the documentation. Please see Viewing Your Account, SFTP, Container and Artifact Settings for more information.

Custom Vocabularies support multiple languages

Users can now create Custom Vocabularies using UTF-8 characters, unlocking Semantic Mapping to languages that use non-ASCII alphabets. Please see Creating, Editing, and Removing a Custom Vocabulary for more information.

More notifications when your Rhino Client is offline

FCP has now an expanded set of Notifications when Rhino Client is Offline to handle most common actions that otherwise would result in an error. Those include:

• When creating a Semantic Mapping

• When running a Code Object

• When importing a Dataset

2024 Release Notes

The following contains the release notes for 2024, in descending date order.

December 2024

NVFlare 2.5 support

Rhino FCP now supports NVIDIA’s latest version of FLARE - version 2.5. There are many enhancements that have been added to this release, see a detailed list in NVFlare documentation. With Rhino FCP, you should be ready to use these new functionality today. To get started, see the NVFlare examples in the user resources.

Re-use your Semantic Mappings with new data with the Harmonization Copilot

The Rhino FCP now allows users to expand Semantic Mappings with incremental data by creating new versions. The new version of the Semantic Mapping will persist any existing mappings, and will generate mapping recommendations for any new values that don’t appear in the original Semantic Mapping. This enables you to re-use existing Semantic Mappings and update them as your data updates over time, or to create Semantic Mappings from data across multiple source tables/fields. See "Creating a New Version of a Semantic Mapping" within the Creating, Reviewing, Editing, and Removing a Semantic Mapping article for more information.

More flexible and versatile Code Objects

The Rhino FCP now gives you more control when creating Code Objects:

1

Optional inputs and outputs

You can write your code to adapt its behavior based on the presence of optional inputs and choose whether to produce optional outputs.

2

List inputs and outputs

Your code objects can now accept inputs or create outputs that are lists containing an arbitrary number of datasets, you decide at run time! When creating a Code Object, now you can set your inputs and outputs to accept a single dataset (as before) or a list of datasets without predefining their number. This can be useful when you want your code to work with inputs that have an arbitrary number of datasets (e.g. code that merges all inputs datasets into a single output dataset, and can operate on any number of input datasets), or when you want your code to generate an arbitrary number of datasets that is defined at run time (e.g. code the splits your dataset into different parts with the number of parts defined at run time).

These enhancements make your Code Objects more versatile and reusable, reducing the need for multiple definitions and improving your efficiency. See What is a Code Object? for more information.

We've added some examples to the user-resources Github repo:

• Merging an arbitrary number of input datasets

• Splitting a dataset into a number of parts defined at run-time

November 2024

Notifications when Rhino Client is Offline

We have added contextual alerts when the Rhino Client is offline. Some functionality requires the Rhino Client to be online to work as expected, for example importing datasets. These alerts are reported within context:

• When viewing the profile page.

• When viewing the collaborators page.

If your Rhino Client is offline, please contact your IT admin or Project Lead to make sure that the Rhino Client is operational. If one of your Collaborators' Rhino Client is offline, please contact us directly and we'll let them know.

Improved Intellectual Property Protection for AI Model Weights

The permissions "Manage Code Run" has been moved to the project level allowing to manage not only who can modify and remove code runs, but also who can download model weights at the project level. This allows to use AI Models for inference while protecting at the same time their IP. See more information in the Permissions documentation article.

Run-Time Files on the Federated Server

When running Code Objects via GC, Python Auto-Containers, or Interactive Containers, Run-Time files are now also accessible in the Federated Server without having to include them in the Code Object. See Managing Run Time Files. This makes it easier to perform tasks like federated fine tuning of LLMs or other models. Run-Time files are still accessible on the Federated Clients (e.g., to access model weights for inference).

Usability Improvements

• Dataset Analytics page now has the filter enabled by default.

• Model weights download is recorded in the activity log.

• Multiple improvements/fixes for OMOP semantic mapping.

• When creating Semantic Mappings

  • Added OMOP Units domain for OMOP mappings

  • Show only datasets that imported successfully

• Added validation to prevent duplicates and missing identifiers when creating Custom Vocabularies

• Improved error messaging when creating datasets with existing name.

October 2024

Harmonization Copilot Semantic Mapping enhancements

Quality of life improvements to enhance Creating, Reviewing, Editing, and Removing a Semantic Mapping, export semantic mappings, and provide deployment guidance, including:

• Added support for searching for values to override recommendations from the system. The search results are constrained to custom vocabulary target terms or OMOP domain terms to expedite finding the right target term.

• Added a bulk action to set the target value of several entries.

• Added more information about a Semantic Mapping in a detailed tooltip.

• When exporting a Semantic Mapping, include the top recommended term in the export for mappings in review.

• Added hardware benchmarks/recommendations for Rhino Clients for Harmonization Copilot usage.

Harmonization Copilot Syntactic Mapping preliminary release

We are adding exciting new functionality that will allow creating syntactic mappings and transforming data to OMOP v5.4 with a low-code experience. As a step towards that goal, we have released an initial low-code data transformation that can be configured with a JSON file. We are working in maturing this functionality and building the GUI. If you are interested to learn more, feel free to contact us directly.

EU based orchestration layer

We have deployed an orchestration layer (aka Rhino Cloud) in the EU so customers that have EU data residency requirements can keep all operations with Rhino within EU. If you would like to learn more how to set up your projects in this new EU based infrastructure, please contact us.

Additional options for Client Mounted Storage

FCP now supports a few additional options for Client-Mounted Storage:

• S3 access within the VPC without specific IAM credentials

• Region-specific S3 bucket access

For further information, visit the following documentation article: Client Mounted Storage: How to access data in AWS S3, GCP CS or the SMB network files?

Added metadata when exporting datasets

When working with Datasets in GC code (especially with multi-dataset GC, and even more so with the new “Any” input schema capability) you sometimes want to know some more information about the Datasets in order to decide how to handle them in your code. For example: you may want to handle Datasets from different schemas or workgroups differently, or if you have multiple input Datasets, you might want to handle them in chronological order based on creation time.

In order to make this simpler, we’ve added a new metadata.json file that is exported alongside the dataset.csv and any file_data and/or dicom_data in the Dataset. This metadata file contains the following information:

dataset_uid: str
dataset_name: str
dataset_version: int
data_schema_uid: str
data_schema_name: str
workgroup_uid: str
workgroup_name: str
creation_time: str
num_rows: int
num_fields: int
fields: List[str]

The metadata.json file is created any time a Dataset is exported - manually to /rhino_data, within GC, and in NVFlare. See example below of metadata.json

{
  "dataset_uid": "a186342e-7a0d-46cd-819d-b751f361108d",
  "dataset_name": "Clinic Dataset",
  "dataset_version": 0,
  "data_schema_uid": "51ee196b-f978-4ca9-9583-6c0309bc3a4a",
  "data_schema_name": "Diabetes Schema",
  "workgroup_uid": "5a2eee3b-dbf2-492d-93fa-1175ae2ad7a9",
  "workgroup_name": "Clinic",
  "creation_time": "2022-09-28 11:51:57.070000+00:00",
  "num_rows": 275,
  "num_fields": 10,
  "fields": [\
    "Pregnancies",\
    "Age",\
    "Height",\
    "Weight",\
    "Glucose",\
    "BloodPressure",\
    "SkinThickness",\
    "Insulin",\
    "DiabetesPedigreeFunction",\
    "Outcome"\
  ]
}

September 2024

Improvements with Interactive Containers

We have done some major upgrading behind the scenes of Creating and Running Interactive Container Code to increase stability with interactive sessions, support TCP connection for compliance with enterprise network security, and improve the user experience.

The user experience improvements include:

• Added a "initializing" status while the container is being initialized, preventing users from prematurely opening the interactive session and ending in an error state

• Fixed an intermittent issue where "Import + Terminate" would not successfully import output datasets prior terminating the interactive session

Added option to create Code Objects without having to determine the schema

The Rhino FCP now enables users to create Code Objects without specifying an input Data Schema. This allows creation of Code Objects that can operate more generically across different types of Datasets, improving code reuse and reducing the number of Code Objects needed on FCP.

See more details in What is a Code Object?.

Updated GUI Design

We have been updating the GUI to improve the user experience and match the company brand. We like the new colors' pop, we hope that you do too! :)

August 2024

Harmonization Copilot for Semantic Mapping

We are excited to introduce a preliminary release of the Harmonization Copilot, a Gen-AI Federated Application for Data Harmonization. In this release, Rhino users can harmonize their data to an OMOP v5.4 Domain, or to a user-defined Custom Vocabulary. The Copilot automatically generates top recommendations for semantic mapping of clinical terms based on natural language, and efficiently allows revision by Clinical Experts. Check it out directly on your FCP account. We are looking forward to hearing your feedback!

For further information, please visit the documentation: About the Harmonization Copilot.

Integration with Microsoft SQL Server

We have added support to directly import data from Microsoft SQL Server via SQL using the Rhino SDK. For further details, please visit Using SQL to Extract Metrics and Import Data From a Database.

July 2024

New Interactive Containers Support for LibreOffice and RStudio

In addition to the existing set of applications available via Rhino FCP such as Jupyter Notebook, 3D Slicer, or QuPath, we have added support to run Interactive Containers with LibreOffice and RStudio.

Users can use these tools directly on FCP to analyze and develop code with real world data within the security and privacy protecting perimeter that FCP provides. The user just needs to create and run an Interactive Container with a container image that has those software packages installed. Check out the User-resources Repo for an example container for LibreOffice. For RStudio, please contact us for support.

See more info in Pushing Containers to the ECR to make your Containers available to FCP, and in Creating and Running Interactive Container Code to learn how to use Interactive Containers.

LLM Fine-tuning Example

We have added an example of federated fine-tuning of an LLM trained for drug discovery. The example shows how to fine-tune with NVIDIA FLARE 2.4 and BioNeMo an ESM-style model on FCP. See more information in the User Resources Repo.

Improved Default for Output Datasets

To reduce the number of inadvertently generated datasets, we have changed the default output dataset naming template from "{{ input_dataset.0 }}-out" to "{{ input_dataset.0 }}". This will result in creating a new version of the input dataset unless the user explicitly requests a different name for the output dataset. In case of a mistake, the user can always refer to the previous version. This will help with dataset annotation, and also in other use cases. Let us know what you think. See more about output dataset naming templates in Running a Code Object.

Additional Configuration Formats for NVFlare 2.4 (YAML, HOCON)

In addition to JSON, we have added support in FCP to provide NVFlare federated server and federated client configuration in YAML and HOCON. These 2 additional formats are more readable, and supporting them will facilitate running NVFlare 2.4 community examples on FCP. Please find more information about these config formats in NVFlare 2.4 Documentation.

Password Reset

FCP now supports password reset for those users using username and password for authentication. Alternatively, users can still log in via SSO. For additional information please refer to the user documentation.

June 2024

Multi-dataset Computing in UI

Users can now create and run Code Objects with multiple input and/or output datasets directly in the UI. This allows users to perform useful data science tasks directly in the UI, such as splitting a dataset in train/test (see example in screenshot below) or combining datasets from different sites. We hope that this feature combined with Creating and Running a Python Code Object will bring great quality of life improvements to Rhino users.

See the documentation for more details about What is a Code Object? and running a Code Object with multiple datasets. Note that this feature is still supported via the SDK, see an example in the SDK documentation.

Providing Secrets at Run-time

When running Code Objects from the UI, users can now enter run secrets, such as encryption keys or credentials. This allows users to securely provide those secrets without having to recreate the Code Object, saving on disk storage and increasing code re-usability. This feature is supported for all Code Object types, including NVFlare. It’s now also possible to provide run-time secrets to NVFlare training runs in the UI. For security, the secrets are made available to the container only during run time, and are never persisted anywhere. See more detail in the documentation.

Notable Improvements

• Improved design and differential privacy setting dropdown when creating a project (see screenshot below)

• When running NVFlare Code Objects, the user will now be alerted with a warning if the minimum number of clients is smaller than the total number of clients (see screenshot below). If set unintentionally, this setting could result in inconsistent training results due to not all clients being required for model training (e.g., a client - and its data - is intermittently accessible for training due to networking).

GCP Marketplace Listing

Following the partnership announcement with Google Cloud, Rhino Federated Computing Platform can now be purchased directly on GCP Marketplace. See more information directly in Rhino's listing on the GCP Marketplace.

May 2024

NVFlare 2.4

Rhino FCP now support NVIDIA’s latest version of FLARE - version 2.4. There are many enhancements that have been added to this release, see a detailed list in NVFlare documentation. With Rhino FCP, you should be ready to use these new functionality today. To get started, see this example NVFlare 2.4 model in the user resources.

Datasets from external storage

Importing datasets from external storage now also supports importing from SMB, in addition to the existing AWS S3 and GCS import functionality. Additionally, Rhino FCP now also supports exporting datasets to external storage (including S3, GCS, and SMB). See more details in the documentation.

Using LLMs with Rhino FCP

We’ve added new examples to our user resources Github repo for how to use LLMs in interactive containers:

• Interactive LLM inference

• Using Jupyter Notebook, Ollama, Code Interpreter, and LLMs to explore datasets interactively

Remote annotation workflow enhancements

When using a Secure Access List (SAL) as the input for an interactive container run, the output dataset will use the original dataset’s name as its prefix by default vs. the previous default of using the SAL’s name. This makes it easier to run consecutive interactive container sessions while maintaining a consistent name for the generated datasets.

Rhino Health’s 3D Slicer interactive container now overcomes the issue of storing output files when overriding soft links.

April 2024

Import data in your cloud storage (AWS S3 or GCP Cloud Storage)

The Rhino Health FCP now provides an additional way to make data accessible to the platform for importing into your projects. If you use AWS or GCP within your environment, you can import data from one or more AWS S3 buckets or GCP Cloud Storage buckets in your network. Any data you put in these buckets will be available for importing via FCP. Since such buckets and the Rhino Client are in your environment, data always stays local to your environment and is never sent to an external location. Please contact us if you'd like to set up access to cloud storage from your Rhino Client. See more details in the documentation.

Rank-Based Federated Metrics

Spearman's Rank Correlation and Wilcoxon Signed Rank Test are now also supported on FCP. As with other federated statistical methods on the platform, these metrics can be calculated in a federated and privacy preserving manner across multiple datasets, adhering to the different privacy and permission safeguards built into the FCP. These rank-based metrics utilize a novel federated and privacy preserving ranking algorithm that was developed and implemented on FCP, and validated on a large number of datasets. See more details in the documentation.

March 2024

Run-time External Files

Large files (such as LLM parameter files) can now be accessed by Code Objects at runtime without the need to include them in the container image that is built and pushed to the FCP. Users can now upload such files to a dedicated cloud storage bucket, select which files to make accessible when running the code, and then reference them directly in the code during run time (on the Rhino Client). This feature is available in all FCP interfaces, namely API, SDK, and GUI. See more detail in Managing Run Time Files.

Additional Federated Metrics

Pearson Correlation and Intraclass Correlation are now available as federated metrics on FCP. As with other federated biostatistics on the platform, these metrics can be calculated in a federated and privacy preserving manner across multiple datasets, adhering to the different privacy and permission safeguards built into the FCP.

GUI Enhancements

Multiple UX and UI enhancements in the GUI, including:

• Improved file upload experience when creating Python Code Objects - in Standalone File mode you can now upload files directly from your local file system instead of pasting their contents into the UI

• Improved experience when creating Federated Datasets - any errors will be surfaced directly in the Federated Dataset creation dialog

• More informative messaging when adding collaborators - after adding a collaborator to a project, a message will be shown until the collaborator accepts the project permissions and joins the project

• Improved user messaging when loading TensorBoard, importing Datasets, and creating Code Objects

• Better handling of long project names in the UI

February 2024

Additional Federated Metric: Cox Proportional Hazards

After extensive research and implementation, we have added support for federated and privacy-preserving calculation of Cox Proportional Hazards. This metric can be now calculated across multiple sites without the need for centralizing the data, allowing for robust federated survival analysis. Existing privacy preservation mechanisms such as K-Anonymity and Differential Privacy are fully supported. This adds to our set of federated metrics for statistical analysis, biostatistics, and epidemiology research. To learn more, check out our documentation or reach out to us!

Platform Terminology Renaming

We have renamed concepts in FCP for better consistency with industry terms and for improved clarity. These changes are applied consistently across the graphical interface (GUI), software development kit (SDK), and backend API. The main name changes are:

• Cohorts to Datasets: We've updated "Cohorts" to "Datasets" to better align with industry standards, ensuring a more accurate representation of the datasets within Rhino Health FCP.

• Models to Code Objects: The overarching term "Models" has been rebranded as "Code Objects." This term encompasses a variety of containers, including Generalized Compute containers, Python Code / Auto-containers, Interactive Containers, and NVFlare containers. For brevity, it may be abbreviated as "Code" where suitable.

• Model Results to Code Runs: We've transitioned from "Model Results" to "Code Runs" to accurately represent the outcomes of code execution and providing a clearer understanding of the results generated.

This will help streamline the terminology and make it more intuitive for users. We have outlined all of the changes that occurred within our Documentation Center: FCP Terminology Renaming Guide.

January 2024

Facilitating Collaborative Research with Federated Datasets

The Federated Datasets (FDs) feature makes exploration of and collaboration with data distributed across multiple partners seamless. FDs allow hospitals or other data custodians to quickly allow researchers at other organizations to access curated datasets to determine if they would be useful for that researchers’ project - and then just as easily incorporate them into their projects. The hospital has complete control over what datasets are imported and who can view the summary statistics - accelerating the time to innovation while preserving the data custodian’s control.

2023 Release Notes

The following contains the release notes from 2023, in descending order.

December 2023

Auto-Containers

The Auto-Containers feature allow users to generate automatically containers of python code. This feature allows our users to:

• Upload for multiple files per container, including code and binary files. We have expanded file compatibility to containerize both textual and binary files.

• Customize Python and CUDA versions for automatically creating the right python environment for your code.

• Manage code packages not only with pip, but now also with Conda.

Enhancements in Federated Biostatistics

We have developed methods for federating more ‘traditional’ biostatistics that have not been previously amenable to federation. Supported metrics include Welch’s t-test, Chi-squared test, and ANOVA. We have also included support to calculate these metrics on Federated Datasets to easily enable reporting cross-site federated analysis on critical biostatistics.

Federated Join

New support for cross-site metrics in projects where the same patient’s data may be spread across multiple sites. This is achieved without moving the cohort data into a central location, while giving the same functional result as if these datasets were joined together in the cloud. This new capability is supported for the Count, Sum, Mean, and StandardDeviation metrics in the Rhino SDK, and works in concert with existing privacy preservation mechanisms in FCP.

October 2023

• Rhino Health FCP Model Run Logs Redesign - Introducing a redesigned Model Run Logs view in the Rhino Health Federated Computing Platform (FCP) to enhance the debugging experience for data scientists. This improved interface empowers users to efficiently identify and resolve issues during their project workflows.

  • Key Features:

    • New “General Info” tab section: You can now access all the relevant information regarding the specific model and model run from within the Logs view.

    • Clear and Comprehensive Log Organization: The Logs view now thoughtfully organizes logs, distinguishing between FCP-generated logs and client-side logs generated by participating sites. This clear separation allows users to quickly pinpoint the source of errors and diagnose issues with ease.

    • Improved Federated Learning Monitoring: For federated learning runs, the Logs view effectively distinguishes between FCP-generated logs, FL-server logs, and individual logs for each FL-client. This detailed breakdown allows users to monitor server-side activities and individual client-side interactions, facilitating debugging and fine-tuning of models and optimizing performance in collaboration with project partners.

  • The redesigned Model Run Logs view ensures a seamless debugging flow, facilitating data scientists' work on healthcare data while preserving privacy and enabling secure collaboration. We are committed to continuously improving the Rhino Health FCP to provide you with the best distributed computing and federated learning experience in healthcare. Happy debugging!

• Additional Upgrades

  • Updated the documentation link in the dashboard to link to docs.rhinohealth.com

  • Increased the export cohort path limit from 100 to 250 characters

  • Added an indication on the cohorts pages regarding the workgroup that the cohort belongs to (which may be different from the “Source” which is the person who triggered GC, performed annotation, etc.)

  • The “(X visible)” text on the cohorts list page will only display if there is a cohort filter active

  • A new permission setting for Differential Privacy with the title “Level of enforcement of differential privacy”, accepting the values 0, 1, 2, or 3 (with 2 being the default) was created. A new tooltip contains a detailed explanation of what each value means. This will impact whether noise will be added to different metrics calculated from cohorts in the project.

  • There is a new user example within the user-resources GitHub under /examples/nvflare for Generalized Linear Models (GLM), including a notebook showing how to trigger this model and read the resulting coefficients and standard errors.

September 2023

• Federated percentiles with differential privacy - We are thrilled to announce that Rhino Health's Federated Computing Platform has undergone an exciting enhancement, now enabling the calculation of percentiles for cohorts and federated datasets. This feature empowers you to derive valuable insights from your data while preserving patient data privacy.

  • Key Features:

    • Differential Privacy Integration: To fortify patient data privacy during percentile calculations, we have integrated enhanced support for Differential Privacy into our federated analytics capabilities. This addition serves as an additional layer of protection alongside k-anonymization.

    • User-Controlled Privacy: You, our valued users, now have granular control over the enforcement of differential privacy within your projects. This means you can tailor the privacy settings according to your project's specific requirements, ensuring the utmost data security.

    • Expanded Analytical Possibilities: With this new feature, you can effortlessly compute descriptive statistics such as minimum, maximum, median, and other percentiles. Rhino Health's commitment to patient data privacy remains unwavering, even as we broaden your analytical horizons.

  • Experience the Upgrade:

    • We believe this update will significantly augment your data analysis capabilities while upholding the highest standards of data privacy. As always, we value your feedback, so please don't hesitate to reach out with any questions or comments.

August 2023

• TensorBoard Integration - We are excited to announce the latest enhancement to the Rhino Health Federated Computing Platform (FCP)! With our new integration of TensorBoard, data scientists and researchers can now seamlessly monitor their model training metrics during and after federated training runs, further enhancing the collaborative and privacy-preserving nature of the FCP ecosystem.

  • Key Features:

    • Real-time Insights: The integration with TensorBoard empowers users to gain real-time insights into their federated machine learning model training processes. Visualize crucial metrics as they evolve, enabling quicker decision-making and optimization strategies.

    • Federated Server-side Metrics: Keep a close watch on the aggregated performance metrics of the federated model across all participating institutions. Monitor how the model evolves as data from different sites contribute to its refinement.

    • Federated Client-side Metrics: Dive deep into the performance of your model at individual client sites. Compare how different institutions' data affect the training outcomes, helping you understand the nuances of multi-site data distribution.

    • Enhanced Collaboration: The integration fosters enhanced collaboration by allowing users to share training metrics and insights seamlessly with their collaborators. Discuss strategies, refine models, and drive innovation while maintaining data privacy behind hospital firewalls.

    • Performance Comparison: Easily compare model performance between different federated training runs, enabling you to track progress, identify trends, and make informed decisions about optimization techniques.

    • Streamlined Workflows: The Rhino Health FCP's integration with TensorBoard aligns seamlessly with your existing workflows. Monitor model training metrics without disrupting your established processes, making the transition smooth and intuitive.

  • This new integration is a significant step forward in expanding the capabilities of the Rhino Health FCP, reinforcing our commitment to enabling collaborative, secure, and privacy-conscious healthcare research. Whether you are fine-tuning machine learning models using data from a single site or performing federated training across multiple distributed data sets, the Rhino Health FCP's TensorBoard integration empowers you to gain deeper insights and drive transformative advancements in healthcare.

• Enhanced Inferred Schema Capability - We are delighted to introduce a significant enhancement to the existing inferred schema capability on the Rhino Health Platform. This improvement elevates your data processing experience by seamlessly integrating your files and DICOM data into your workflows, making your analysis more intuitive, efficient, and insightful.

  • Key Features:

    • Streamlined File/DICOM Data Handling: The updated inferred schema capability extends its prowess to include file and DICOM data, alongside the existing tabular data. The automated schema generation now accommodates "Filename" and "DicomInstanceUID" fields in addition to "String" and "Float" fields.

    • Simplified Cohort Imports: When importing cohorts with file or DICOM data, the platform now empowers you to bypass the need for a CSV file. By selecting the option to "Auto-generate schema from data", you can seamlessly import cohorts with a single column representing the files or DICOM instances, simplifying your data import process.

    • Effortless Schema Mapping: In cases where cohort imports involve both CSV files and file/DICOM data, the improved inferred schema capability smartly maps CSV columns to associated files or DICOM instances using actual filenames and DICOM UIDs. This automation minimizes manual mapping and ensures accurate data integration.

    • Consistent Model Output Schemas: Whether you're running Python Code/GC/iGC, training model, or running inference with NVFlare, the enhanced inferred schema capability ensures automatic schema generation for your model outputs. This eliminates the need for manual schema creation and maintains consistency across your workflow.

  • Experience the Upgrade:

    • Experience the power of the improved inferred schema capability as it seamlessly weaves file and DICOM data into your workflows. The platform's automated schema generation simplifies data handling, enabling you to focus on analysis rather than data organization.

    • From processing DICOM files to model creation, the enhanced capability offers a streamlined experience. Your output schemas accurately represent your data, guaranteeing a seamless transition from input to insightful analysis.

• Additional Upgrades

  • Increased file path length to 250 characters in Cohort import input fields

  • Renamed the exported schema file name to match the name of the schema

  • Added the ability to remove multiple cohorts or models at once

  • Added support for Ubuntu 22.04

  • Fields on the Schema page were renamed for better user clarity

  • UTC Timestamp labels were added to all pages for consistency

July 2023

• Enhanced Interactive Containers - We are thrilled to announce the latest upgrade to Rhino Health Federated Computing Platform's (FCP) powerful feature - Interactive Containers. This enhanced version brings significant improvements to your data interaction experience, empowering you to achieve more with ease.

  • Key Features:

    • Multiple Concurrent Sessions: With the enhanced Interactive Containers, you can now engage in multiple concurrent sessions per client. This upgrade unlocks a new realm of collaboration, particularly for projects that require parallel Interactive Container sessions like distributed annotation tasks. Seamlessly collaborate with your team members, leveraging the power of concurrent sessions to accelerate progress and drive results.

    • Improved Work Saving: We've listened to your feedback and made significant enhancements to the work-saving functionality in Interactive Containers. Previously, saving your work during an Interactive Containers session required terminating the session. Now, the upgraded Interactive Containers system enables you to easily save your work within the session itself. This newfound flexibility ensures that your progress is securely preserved, minimizing the risk of losing unsaved work and providing peace of mind as you work with distributed data.

  • At Rhino Health, we are committed to refining your data interaction experience and providing you with a seamless and secure environment. The enhanced Interactive Containers feature is a testament to our dedication to your success. Unlock new levels of collaboration, efficiency, and productivity as you leverage the power of Interactive Containers within the Rhino Health FCP.

  • For more information on how to use Interactive Containers, please refer to our documentation in Creating and Running Interactive Container Code. We hope you find this new feature helpful and welcome any feedback you may have.

• Data Ingestion from SQL - We're excited to announce the latest addition to Rhino Health Federated Computing Platform's (FCP) capabilities - Data Ingestion from SQL. With this feature, data scientists can now seamlessly access and import data from on-prem SQL databases external to the platform, streamlining their workflows and opening up a world of new possibilities for collaborations.

  • Key Features:

    • Rhino SDK SQL Connector: The initial release includes an SDK connector that allows users to connect to an on-prem SQL database securely. The connector facilitates data retrieval without the need to move data outside of the firewall.

    • Query and Aggregate Statistics: Data scientists can run queries on the remote SQL database, perform actions such as calculating summary statistics (e.g., count, mean, standard deviation) in a privacy-preserving manner, and explore the data to identify the exact parameters needed for their cohort.

    • Import Cohorts with Ease: Once the desired cohort is identified, the Rhino SDK function enables effortless data extraction and seamless import of the cohort into FCP, either using a pre-defined schema or an inferred one.

  • Unlock the potential of your on-prem SQL data and collaborate with confidence. Try out Data Ingestion from SQL today!

• NVFlare Enhancements - We are excited to announce two powerful enhancements to the Rhino Health Federated Computing Platform's NVFlare integration. With the support for multiple model weight checkpoint files during training and the new Inference workflow, data scientists can now take their machine learning model development to new heights.

  • Key Features:

    • Multiple Model Weight Support: Train your models with confidence by saving multiple model weight checkpoint files during the training process. This enhancement ensures you capture optimal model performance at various training iterations, allowing for robust single-site or federated learning (FL) training scenarios.

    • Inference Workflow: Seamlessly run inference using any of the saved model weight checkpoints through our intuitive GUI and SDK. Analyze and compare the performance of your models with ease, empowering multi-site development and hyperparameter tuning experiments.

  • Take control of your model development and fine-tune it with precision. Embrace the power of NVFlare enhancements on the Rhino Health Federated Computing Platform today!

  • For more detailed information, we encourage you to refer to the user documentation in Creating and Running NVFlare Code and Running Inference & the RH FCP SDK documentation

• Squashed some bugs

June 2023

• Enhanced Python Containers - We are excited to announce a new feature on the Rhino Health FCP - "Enhance Python Containers". This latest functionality allows users to easily create working models on the platform by simply providing a .py file and a requirements.txt file. The system will then automatically create and push the container image and make the model available for immediate use on the FCP.

• Halting Model Training through the SDK and GUI - We are excited to announce a new feature on the Rhino Health FCP - “Halt model training”. This latest functionality enhances the FCP's support for the end-to-end data science workflow by allowing users to easily halt ongoing federated training runs via the Rhino Health GUI with a single click or via a simple SDK call.

  • For more detailed information, we encourage you to refer to the user documentation at Creating and Running NVFlare Code and Running Inference & SDK Documentation

• Squashed some bugs

May 2023

• Interactive Permissions Setting - We are pleased to introduce a new enhancement to the Permissions on the Rhino Health FCP - This latest enhancement enables project leads to define the fine-grained permissions policy for the project and for their site when creating a new project, without the need to request changes from the Rhino Health support team.

  • How does this work?

  • As a Project Owner - Watch our Video Tutorial

    When creating a new project, you will see a new “Permissions Policy” section in the project creation dialog where you can set the project-level and site-level permissions for the lead site.

  • As a Collaborator on a Project - Watch our Video Tutorial

    When a new collaborator is invited to the project, they will now receive an email invitation with a link to the project.

    

    When the new collaborator logs into the project for the first time, they will be able to set their site-level permissions on the project and will need to approve the project-level permissions policy in order to gain full access to the project.

  • Please note that changing the permissions policy after the initial setting is currently only possible by contacting [e-mail].

  • For more information on how permissions work on FCP, please refer to our Rhino Health Federated Computing Platform User Manual. We hope you find this new feature helpful and welcome any feedback you may have.

• Squashed some bugs

April 2023

• Interactive Containers - Rhino Health FCP is pleased to announce the launch of a new feature - Interactive Containers. This powerful and versatile capability serves as a secure remote desktop, allowing users to interact with distributed data in their projects via remote, interactive graphical user interfaces (GUIs) such as Jupyter Notebook and 3D Slicer.

  • With Interactive Containers, users can define their own custom Interactive Containers to use their preferred third-party tools, such as annotation tools. This new feature offers users increased flexibility and efficiency when working with distributed data and tools while maintaining high levels of security. We are thrilled to offer Interactive Containers as a valuable addition to the Rhino Health FCP.

  • For more information on how to use Interactive Containers, please refer to our documentation in Creating and Running Interactive Container Code. We hope you find this new feature helpful and welcome any feedback you may have.

• Data Exploration Dashboard - We're thrilled to introduce our latest enhancement to the Cohort Analytics view on the Rhino Health FCP. With this new feature, users can interactively explore their project's data with greater granularity by defining filters on the values to be presented. The charts are updated automatically in the GUI, providing greater insights into the data.

  • We appreciate your continued support and hope you enjoy this new addition to the Rhino Health FCP. Try out the new Data Exploration Dashboard today and take your data exploration to the next level!

• Permissions UI - Our permissions system has been designed to be highly flexible, allowing project owners to define permissions down to the individual activity level. This means that users can specify exactly which features each participant is allowed to access, ensuring that your project data remains secure and protected from unauthorized access.

  • To make it easier for project participants to manage their permissions, we have introduced the first phase of a new Permissions UI on the Collaborators Page. With this interface, users can quickly view the permissions that have been granted to each persona, helping to prevent errors and mistakes that could compromise your project data.

  • We believe that this new permissions UI represents a significant first step forward in project management and collaboration, and we are confident that our users will appreciate the added visibility it provides. If you have any questions or feedback, please don't hesitate to reach out to our support team at [e-mail].

• Minor Feature Releases/Bug Fixes - In the latest version of the NVFlare docker-run.sh script, we have implemented a new feature to disable networking on the running container. This is designed to replicate the behavior of the container when running within FCP, effectively blocking any attempts to access the internet.

  • We have introduced a new feature to filter out repetitive NVFlare SSL_ERROR messages. This is aimed at reducing the amount of log clutter caused by these messages, making it easier to identify and address other issues in the logs. With this update, users can now enjoy a cleaner and more streamlined logging experience, with only the most relevant messages being displayed.

  • We have made improvements to our built-in OHIF viewer, including enhanced support for multiple annotations in a single instance. Additionally, we have streamlined the workflow for adding annotations and textual notes, making the process faster and more intuitive for users.

March 2023

• Credentials via the GUI - Users can now access their credentials to additional tools/systems utilized alongside FCP (e.g. SFTP, ECR) via the Profile page in the FCP GUI.

  • We found our users often found it challenging to keep track of the various credentials needed for different parts of the workflow (SFTP to transfer files into the on-prem client, ECR to push model containers to the cloud).

  • With this new release, users can easily access their credentials on the GUI at any time.

• MFA-gated access - We are pleased to announce the release of a new feature on the Rhino Health FCP - MFA-gated access. With this feature, institutions can now ensure an additional layer of security for their data by requiring external collaborators to have Multi-Factor Authentication (MFA) defined on their FCP account before accessing the institution's data.

  • We believe that the new MFA-gated access feature on the Rhino Health FCP provides healthcare institutions with added peace of mind regarding the security of their data. By requiring external collaborators to have MFA defined on their FCP account, institutions can ensure that only trusted parties are able to access their data, thus adding an extra layer of security to the platform. This feature further strengthens the Rhino Health FCP's position as a reliable and secure option for healthcare institutions.

  • To enable this feature for your institution, please contact our support team at [e-mail]. Our team will assist you in configuring MFA-gated access and ensuring seamless collaboration between your institution and external collaborators.

• K-per project - We are excited to announce the release of “K-per project”, a new feature now available on the Rhino Health FCP. With this latest enhancement, project leads can now set the K-anonymization parameter explicitly while creating a new project, providing greater control over privacy requirements.

  • Previously, the K parameter was hard-coded as a constant for all FCP projects, but with the new K-per-project feature, our customers can easily adjust the K-anonymization setting based on their specific needs. By setting K-anonymization, subgroup summary statistics will only be provided on the FCP for groups with greater than or equal to K items. The K-per project feature allows for greater flexibility and can be disabled by setting K=1.

  • We believe that the K-per project feature will help our customers maintain a higher level of privacy control and meet their unique data privacy needs on the Rhino Health FCP.

• GUI Usability Improvements - We are delighted to announce the release of a set of usability enhancements to our Rhino Health FCP GUI. The new features are designed to simplify user workflows and improve the overall user experience.

  • Cohort View Filters: For projects containing a large number of cohorts, locating a specific cohort or group of cohorts can be a daunting task. With our new cohort view filters, users can easily limit their search by Schema and the cohort's Source, making it easier to find the desired information.

  • Cohort Analytics: To facilitate searching within the cohorts filter, we have integrated search functionality into the GUI. This feature will enable users to efficiently search and display the desired cohort(s) they are looking for.

  • Cohort Import Dialog: In our efforts to improve user experience, we have added a pre-populated base path /rhino_data/ to the cohort import dialog box. This new hint will assist users in placing their files correctly on their on-premises clients, making it easier to import cohorts into the platform.