Python Code Objects
Elevating Your Workflow with Python Code Objects on FCP
In the Rhino Health Federated Computing Platform (FCP), Python Code Objects offer a powerful way to execute Python code scripts effortlessly, eliminating the need to locally containerize your code. Building and deploying code becomes a seamless process, with FCP handling container image creation and storage on your workgroup's ECR (Elastic Container Registry).
Seamless Code Execution
With Python Code Objects, FCP streamlines code deployment process, allowing you to concentrate on code development and analysis. Whether you're performing sophisticated data manipulations or running custom algorithms, Python Code Objects empower you to leverage the full capabilities of Python while benefiting from FCP's containerization and deployment efficiency.
Summary
Python Code Objects on FCP bring simplicity and power to your code development endeavors. By offering options for both code snippets and standalone files, FCP adapts to your needs, allowing you to focus on creating impactful software. Embrace the convenience of executing Python code directly within the platform, while FCP takes care of the intricate details of containerization, image creation, and deployment. Elevate your workflow and unlock new dimensions of development possibilities with Rhino Health FCP.
Key Components of a Python Code Object
Attributes
- Name: The name of the defined Code Object
- Description (Optional): The description of the Python Code Code Object
- Version(s): The version of the Code Object. After creating the initial Code Object you are able to edit the existing Code Object and create a new version instead of creating a whole new Code Object
- Date Created: The date the Code Object version was created
- Runs: The number of times the Code Object version has been run and produced a Code Object Result. Note: If you delete a Code Object Result for a Code Object, the number of runs will also be reduced by the number of Code Object results you delete
- Latest Run (UTC): The timestamp of the latest run in the UTC timezone fDatasetor the particular Code Object version
- Input Schema: The input schema that was defined when creating the particular Code Object version
- Output Schema: The output schema that was defined when creating the particular Code Object version
- Source: The creator of the Code Object version
- UUID: The unique identifier for a specific Code Object version within the Rhino FCP
- Code Object Type: The type of Code Object that has been defined during creation—a Python Code Code Object
- Python Code Object Type: The type of Python Code Object, either a Code Snippet or a Standalone File
- Python Code: The Python code that you will be executing during your runs of the Code Object
- Requirements File: The Python dependencies required to run your previously specified Python Code
- Container Base Image: The Docker container base image that will serve as the Python environment in which your code will be run
Actions
- Creating a New Python Code Object or Code Object Version: Create a new Python Code Object or new version of an existing Code Object
- Viewing a Python Code Object's Configuration: Viewing the configuration that was provided while creating a specific Python Code Object
- Running a Python Code Object: Running a specific version of a certain Python Code Object
- Deleting a Python Code Object or Code Object Version: Delete a single version or a whole Python Code Object
Interfaces
Below are a series of screenshots that detail how you can interact with Python Code Objects (Formerly Models) within the Rhino FCP
Main Code (formerly Models) Page
The main interface for initiating the creation of a Python Code Object.
Creating a New Code Snippet Python Code Object
For more information about creating a new code snippet Python Code Object, please refer to Creating a New Python Code Object or Code Object Version.
Creating a New Standalone File Python Code Object
For more information about creating a new code snippet Python Code Object, please refer to Creating a New Python Code Object or Object Version.
Running a Python Code Object
For more information about running a Python Code Object, please refer to Running a Python Code Object.
Generalized Compute Code Objects
Understanding Generalized Compute
In the Rhino Health Federated Computing Platform (FCP), the Generalized Compute (GC) Code Object represents a versatile and powerful way to execute pre-built container images within the FCP environment. This Code type enables you to run custom code, computations, or processes that are encapsulated within container images. With GC, you can harness the full potential of distributed computing while tailoring your computations to suit your specific needs.
Key Features of Generalized Compute:
- Flexible Container Execution: GC empowers you to execute container images containing diverse computational tasks, irrespective of programming language or complexity. This allows you to leverage existing tools, libraries, and applications within the FCP ecosystem.
- Batch Processing: Ideal for tasks that do not require real-time interactivity, GC excels at batch processing scenarios. You can execute computationally intensive tasks, data transformations, or complex analyses efficiently across distributed datasets.
-
Secure Data Access: GC can only access data provided via the FCP, with no external internet connectivity. GC accesses input Datasets located under the
/input
directory and generates output Datasets under the/output
directory. This ensures secure data access and maintains the privacy of sensitive healthcare information.
Use Cases for Generalized Compute:
- Data Transformation: Execute data transformation and normalization tasks across distributed healthcare datasets.
- Custom Analytics: Run complex statistical analyses, machine learning processes, or custom algorithms on distributed data.
- Scientific Simulations: Perform large-scale scientific simulations or simulations requiring substantial computational resources.
- Resource-Intensive Tasks: Process resource-intensive tasks, such as image processing, signal analysis, or simulations.
Benefits of Generalized Compute:
- Adaptability: Leverage various programming languages and tools within your container, ensuring flexibility in your computational tasks.
- Distributed Processing: Distribute computation tasks across multiple sites, enhancing efficiency and reducing processing time.
- Customization: Craft computations tailored to your project's unique requirements, enhancing the depth of insights you can derive.
In summary, Generalized Compute empowers you to harness the versatility and power of containerized computations within the Rhino Health FCP. By executing custom code across distributed datasets, you can streamline tasks, gain valuable insights, and contribute to advanced healthcare research in a secure and privacy-preserving manner
Key Components of a Generalized Compute
Attributes
- Name: The name of the defined Code
- Description (Optional): The description of the Code
- Version(s): The version of the Code. After creating the initial Code Object you can edit the existing Code and create a new version instead of creating a whole new Code Object
- Date Created: The date the Code version was created
- Runs: The number of times the Code version has been run and produced a Code Run. Note: If you delete a Code Run for a Code Object, the number of runs will also be reduced by the number of Code Runs you delete
- Latest Run (UTC): The timestamp of the latest run in the UTC timezone for the particular Code version
- Input Data Schema: The input data schema that was defined when creating the particular Code version
- Output Data Schema: The output data schema that was defined when creating the particular Code version
- Creator: The creator of the Code version
- UUID: The unique identifier for a specific Code version within the Rhino FCP
- Code Type: The type of Code that has been defined during creation—Generalized Compute
- Container: The Docker container used when creating the Code. This could come from under the section Workgroup Images if you pushed to your workgroups ECR or under the section Rhino Health Images if you are using a stock Rhino Health provided container image
Actions
- Creating a New Generalized Compute Code or Code Version: Create a new Generalized Compute Code or new version of existing Generalized Compute Code
- Viewing a Generalized Compute Code's Configuration: Viewing the configuration that was provided while creating specific Generalized Compute Code
- Running Generalized Compute Code: Running a specific version of a certain Generalized Compute Code Object
- Deleting a Generalized Compute Code or Code Version: Delete a single version or a whole Generalized Compute Code Object
Interfaces
Below are a series of screenshots that detail how you can interact with Generalized Compute Code within the Rhino FCP
Main Code Page
The main interface for initiating the creation of Generalized Compute Code .
Creating New Generalized Compute Code
For more information about creating new Generalized Compute Code, please refer to Creating New Generalized Compute Code or Code Versions.
Creating New Generalized Compute Code - Selecting Your Container Image
For more information about selecting your container image while creating new Generalized Compute Code, please refer to Creating New Generalized Compute Code or Code Versions.
Running Generalized Compute Code
For more information about running Generalized Compute Code, please refer to Running Generalized Compute Code.
NVFlare Code Objects
NVFlare: Redefining Collaborative Federated Training
The FCP includes a seamless integration of NVIDIA's Federated Learning framework (NVFlare), enabling you to train machine learning models collaboratively across distributed health data sources. This revolutionary approach brings privacy-preserving training to the forefront, allowing healthcare organizations to pool their insights without compromising the security of sensitive data.
Key Aspects and Advantages
- Secure Distributed Training: NVFlare empowers users to conduct Federated Training across a network of healthcare institutions, each contributing their data insights without sharing raw data. This distributed approach ensures that sensitive patient information remains secure behind institutional firewalls.
- NVIDIA GPU Acceleration: NVFlare taps into the computational prowess of NVIDIA GPUs, expediting model training and optimization. This acceleration is a game-changer, reducing training time and enhancing the accuracy of models trained on massive healthcare datasets.
- Versatility Across ML Frameworks: NVFlare's framework compatibility extends to major machine learning frameworks such as PyTorch and TensorFlow. Adapt your existing machine learning code to NVFlare, ensuring seamless integration into the Federated Learning ecosystem.
Unlocking Secure Federated Training
To harness the capabilities of NVFlare Code Objects within Rhino Health FCP, follow these steps:
- Adaptation to NVFlare Framework: Align your machine learning code with NVFlare's Federated Learning framework. This step ensures your models are primed to operate collaboratively across distributed data. (see our Rhino Health "user resources" GitHub repository for examples)
- Container Image Integration: Build a container image that encapsulates your adapted NVFlare code, along with the required dependencies. These images are the vessels for efficient, privacy-preserving training across distributed health data.
- ECR Repository Integration: Push your container images to your workgroup's Elastic Container Registry (ECR) repository. This makes the NVFlare images available within the FCP ecosystem for execution via NVFlare Code Objects.
- Create and Collaborate: Access the Code Objects view within your project on the FCP Dashboard. Create an NVFlare Code Object, specifying your container image and configurations. Collaborate securely across institutions to train ML models and/or run model inference.
- Elevate Federated Training: Launch Federated Training using NVFlare Code Objects, and the FCP takes care of orchestrating the federated network and communication aspects. You can even simulate federated training using multiple datasets from your workgroup.
Championing Secure Insights and Collaborative Progress
NVFlare Code Objects redefine the paradigm of Federated Training, emphasizing secure and collaborative healthcare insights. By utilizing the power of NVIDIA GPUs and preserving data privacy, NVFlare empowers healthcare organizations to collaborate, innovate, and drive transformative advancements in predictive modeling.
Summary
NVFlare Code Objects within Rhino Health FCP signify a groundbreaking approach to Federated Training. Embrace the synergy of distributed health data, NVIDIA GPU acceleration, and Federated Learning framework compatibility to unlock secure, efficient, and impactful insights. Experience the future of collaborative healthcare research with NVFlare Objects, as you safeguard sensitive data while unlocking the full potential of Federated Training in the digital health landscape.
Key Components of an NVFlare Code Object
Attributes
- Name: The name of the defined Code Object
- Description (Optional): The description of the NVFlare Code Object
- Version(s): The version of the Code Object. After creating the initial Code Object you are able to edit the existing Code Object and create a new version instead of creating a whole new Code Object
- Date Created: The date the Code Object version was created
- Runs: The number of times the Code Object version has been run and produced a Code Object Result. Note: If you delete a Code Object Result for a Code Object, the number of runs will also be reduced by the number of Code Object results you delete
- Latest Run (UTC): The timestamp of the latest run in the UTC timezone for the particular Code Object version
- Input Schema: The input schema that was defined when creating the particular Code Object version
- Output Schema: The output schema that was defined when creating the particular Code Object version
- Source: The creator of the Code Object version
- UUID: The unique identifier for a specific Code Object version within the Rhino FCP
- Code Object Type: The type of Code Object that has been defined during creation - an NVFlare 2.0, NVFlare 2.2, NVFlare 2.3, or NVFlare 2.4
- Container: The Docker container, under the section Workgroup Images, which you pushed to your workgroups ECR or the stock container image within the Rhino Health Images
Actions
- Creating a New NVFlare Code Object or Code Object Version: Create a new NVFlare Code Object or new version of an existing Code Object
- Viewing an NVFlare Code Object Configuration: Viewing the configuration that was provided while creating a specific NVFlare Code Object
- Running an NVFlare Code Object: Running a specific version of a certain NVFlare Code Object
- Deleting an NVFlare Code Object or Code Object Version: Delete a single version or a whole NVFlare Code Object
Interfaces
Below are a series of screenshots that detail how you can interact with NVFlare Code Objects within the Rhino FCP
Main Code Object (formerly Models) Page
The main interface for initiating the creation of an NVFlare Code Object.
Creating a New NVFlare Code Object
Make sure to choose the appropriate version of NVFlare used in the "Type" drop-down.
For more information about creating a new NVFlare Code Object, please refer to Creating a New NVFlare Code Object or Code Object Version.
Running an NVFlare Code Object
For more information about running an NVFlare Code Object, please refer to Running an NVFlare Code Object.
Interactive Container Code Objects
Exploring Interactive Container Code
In the realm of the Rhino Health Federated Computing Platform (FCP), Interactive Container Code opens the door to a unique dimension of computation. This Code Object type empowers you to run pre-built container images that include interactive graphical user interfaces (GUIs) or applications. With Interactive Containers, you can execute third-party tools, visualizations, and even Jupyter Notebooks directly on your on-premises data, enhancing interactivity while preserving data security.
Key Attributes of Interactive Container Code:
- Interactive GUIs: Unlike other Code Objects, Interactive Containers enable you to execute containers with interactive graphical user interfaces. This facilitates real-time interaction and data visualization within the FCP environment.
- On-Premises Interaction: Interactive Containers offer the capability to interact with on-premises data while leveraging the computational power of the FCP. This integration is particularly useful for scenarios where data remains within internal networks.
-
Third-Party Applications: With Interactive Container Code Objects, you can run third-party applications that are containerized and can be executed within the FCP ecosystem, with no need to install them at each site.
Important note: This capability is limited to third-party applications that can run within a single Linux-based container with no internet connectivity.
Use Cases of Interactive Containers:
- Real-Time Data Exploration: Utilize interactive visualizations and tools to explore and analyze on-premises healthcare data within the FCP ecosystem.
- Third-Party Applications: Run containerized third-party applications such as medical image annotation tools or specialized analysis software.
- Collaborative Workshops: Conduct collaborative workshops or training sessions that involve hands-on exercises and interactive activities.
Benefits of Interactive Containers:
- Interactive Experience: Gain the ability to interact with GUIs and applications in real-time, fostering dynamic exploration of your data.
- On-Premises Compatibility: Execute containerized applications on your on-premises data while utilizing the computational resources of the FCP.
- Secure Collaboration: Enable secure collaboration by running third-party tools and applications within the FCP environment, ensuring data privacy.
Summary
In summary, Interactive Containers offer an innovative pathway to engage with interactive graphical interfaces and applications within the Rhino Health FCP. By merging on-premises data with containerized interactivity, you can delve deeper into data exploration, collaboration, and visualization while maintaining the highest levels of security and privacy.
Key Components of an Interactive Container
Attributes
- Name: The name of the defined Interactive Container
- Description (Optional): The description of the Interactive Container
- Version(s): The version of the Code. After creating the initial Code Object you can edit the existing Code and create a new version instead of creating a whole new Code
- Date Created: The date the Code version was created
- Runs: The number of times the Code version has been run and produced a Code Run. Note: If you delete a Code Run for a Code Object, the number of runs will also be reduced by the number of Code Runs you delete
- Latest Run (UTC): The timestamp of the latest run in the UTC timezone for the particular Code version
- Input Data Schema: The input data schema that was defined when creating the particular Code version
- Output Data Schema: The output data schema that was defined when creating the particular Code version
- Creator: The creator of the Code version
- UUID: The unique identifier for a specific Code version within the Rhino FCP
- Code Type: The type of Code that has been defined during creation—Interactive Container
- Container: The Docker container used when creating the Code. This could come from under the section Workgroup Images if you pushed to your workgroups ECR or under the section Rhino Health Images if you are using a stock Rhino Health provided container image
Actions
- Creating New Interactive Container Code or Code Version: Create a new Interactive Container Code or new version of an existing Code Object
- Viewing an Interactive Container's Configuration: Viewing the configuration that was provided while creating a specific Interactive Container
- Running Interactive Containers: Running a specific version of a certain Interactive Container
- Removing an Interactive Container or Interactive Container Version: Delete a single version or an entire Interactive Container
Interfaces
Below are a series of screenshots that detail how you can interact with Interactive Container within the Rhino FCP
Main Code Page
The main interface for initiating the creation of an Interactive Container.
Creating a New Interactive Container
For more information about creating a new interactive container, please refer to Creating a New Interactive Container or Version.
Creating a New Interactive Container - Selecting Your Container Image
For more information about selecting your container image while creating a new interactive container, please refer to Creating a New Interactive Container or Version.
Running an Interactive Container
For more information about running an interactive container, please refer to Running Interactive Containers.
A Running Interactive Container Example of the 3D Slicer Container
For more information about what a running an Interactive Container, please refer to Running Interactive Containers.