Skip to main content

Tutorial #1 - Basic Usage

This document will guide you through the process of setting up a new project on the Rhino Health Federated Computing Platform (FCP).

By following the step-by-step instructions in this document, you will learn how to:

  1. Set up a new project.
  2. Prepare data, import it as a Dataset, and explore data metrics.
  3. Containerize your code and run it using our distributed computing platform.
  4. Produce visualizations of the results and create a report within the project.

We are excited to see what you will do with the platform, so let’s get started!

Step 1: Getting Started

FCP Credentials

You will need your FCP credentials (email and password) to log in to the Rhino FCP platform using this link: Rhino FCP Platform.

If you have not received those credentials - please contact support@rhinohealth.com .

Important Concepts to Understand:

  • Container: A container is a lightweight and portable software package that encapsulates an application, its dependencies, and its runtime environment. Containers provide a consistent and isolated environment for applications to run, ensuring that they can run consistently across different computing environments. They offer a standardized way to package, deploy, and manage software applications, making it easier to build, ship, and scale applications across different platforms and infrastructures.   
    • Why is this important? In many cases, you will need to build a container to execute code on the FCP.
  • Container Image: A container image is a standalone, executable package that includes everything needed to run a piece of software within a container. It contains the application code, runtime environment, libraries, and dependencies required for the application to function properly. Container images are typically built from a base image and can be easily shared, replicated, and deployed across different containerization platforms, allowing for consistent and reproducible application deployments.
    • Why is this important? Container images are what the FCP will execute in order to run your code on your FCP client or remote FCP clients.
  • Docker: Docker is an open-source platform that enables developers to automate the deployment and management of applications within containers. It provides a simple and efficient way to package applications and their dependencies into portable container images. Docker allows for easy and consistent deployment across different environments, ensuring that applications run reliably and consistently regardless of the underlying infrastructure. It has become a widely adopted tool in the software development industry, simplifying application deployment and promoting scalability and flexibility.
    • Why is this important? The FCP uses Docker to help build your containers in your development environment and then run your containers locally, on your FCP client, or other remote FCP clients
  • AWS Elastic Container Registry (ECR): ECR is a fully managed container registry service provided by Amazon Web Services (AWS). It allows users to store, manage, and deploy container images, making it easier to run containerized applications on AWS. It provides secure and scalable storage for Docker container images and supports private repositories, access control, and image lifecycle management. Developers and organizations can use Amazon ECR to build, store, and share container images to streamline their container-based workflows.
    • Why is this important? The ECR is where you will push your container images to be run within the FCP.

  • AWS S3 Bucket: An AWS S3 Bucket is a scalable and secure cloud storage resource provided by Amazon Web Services (AWS). It serves as a container for storing and organizing data objects, including files, images, videos, and structured datasets. S3 buckets allow users to store and retrieve data over the internet with high durability, availability, and security. They support various storage classes, versioning, and access control mechanisms to optimize cost and performance.

    • Why is this important? AWS S3 Buckets are commonly used to store and manage large datasets, backups, and application assets. In the context of FCP, an S3 bucket may be used to store input datasets, container images, or processed results, ensuring efficient data sharing and accessibility across distributed environments.
  • Secure File Transfer Protocol (SFTP): SFTP is a network protocol that provides a secure and encrypted method for transferring files between remote systems. SFTP is commonly used as a secure alternative to FTP (File Transfer Protocol) and allows for secure file transfers over SSH (Secure Shell) connections. It ensures data confidentiality and integrity during file transfers, making it suitable for secure file exchange and remote file management.
    • Why is this important? SFTP will be used to move data from your local computer to your FCP client to be imported by the system for exploitation by your containerized code.
  • Data Schema: A Data Schema is a structure or blueprint that defines the organization, format, and relationships of data within a database or data system. It defines the rules and constraints for how data is organized and represented, including the data types, fields, and their relationships. A Data Schema provides a standardized framework for data storage, retrieval, and manipulation, ensuring the consistency and integrity of the data.
    • Why is this important? Data Schemas are used to describe the structure and format of the data you will import into your FCP client as Datasets.

Configuring Your Environment

To configure your environment, please follow the steps on this page. Once you have completed those steps, please return here and continue the tutorial.

Tutorial 1: Project Resources

Click here to access the GitHub repository that holds a whole host of resources that will be helpful on your journey with the Rhino FCP.  It also hosts all the external files you will need for this tutorial. Download or clone the repository on your local computer.

For this tutorial, you will be using the resources inside this folder:

user-resources/tutorials/tutorial_1/ 

This folder includes:

  • containers/ - This folder contains all the containers that you will push to your ECR repository to be used within the FCP during this tutorial.
  • data/ - This folder contains all the data that will be used in this tutorial.  The folder is structured in a way that will become more familiar to you as you become more comfortable using various parts of the system, such as creating custom containers.
    • input/ - This folder is part of the system's structure as you utilize the FCP features mentioned above. It contains the input data for the tutorial.
      • dataset.csv - This file defines the dataset you will use as input for this project. Each row in this file represents a case (meaning a study or patient). For each case, there is a DICOM series UID, which is similar to a file path, and the related metadata as described in the Data Schema.
      • dicom_data/ - This folder contains the DICOM imaging files, specifically chest X-ray (CXR) images, referenced in the dataset.csv file. When using files as input for your project, it is best practice to keep the files in a dedicated folder separate from the dataset.csv file.

Another important directory is this folder:

user-resources/rhino-utils/

This folder contains several utility scripts the Rhino Health team has created to help simplify the process of pushing your containers to the platform, testing your containers locally, and simulating training and inference in a local simulated FL environment.  A subset of these scripts will be used in both Step 5: Running Python Code with Custom Dependencies via the FCP UI and Step 6: Running Federated Training with NVFlare on the FCP UI.

Step 2: Preparing Your Data

For your data to be available to the FCP, you will first need to transfer the data located within the data/ folder to be able to utilize it within the FCP UI.  If you are new to using SFTP and would like to learn more, please refer to the following support article: How can I move data from my local environment to my Rhino Health client using SFTP?

For this tutorial, you are going to move the following two resources from your local machine to your Rhino Health client:

  1. user-resources/tutorials/tutorial_1/data/input/dataset.csv
  2. user-resources/tutorials/tutorial_1/data/input/dicom_data/

Connecting to your SFTP Server for MacOS, Linux & Windows 10+

  1. Open a terminal or command prompt on your respective operating system, navigate to the folder user-resources/tutorials/tutorial_1/data/input/.  
  2. Connect to your client via SFTP using the following command:
    sftp rhinosftp@RHINO_CLIENT_IP_ADDRESS
  3. Copy the dataset.csv and dicom_data/ files from your local machine into a new folder you create on your Rhino Health client by running the commands below: 
    sftp> mkdir tutorial_1
    sftp> cd tutorial_1
    sftp> put dataset.csv
    sftp> put -r dicom_data/
    sftp> exit

Other Operating Systems

  1. If you have downloaded and configured your SFTP client, skip to the next step. Otherwise, please follow steps 1 and 2 outlined in the following support article under the heading Connecting to your Rhino Health Client via SFTP from Other Operating Systems
  2. Open your SFTP client and connect to your Rhino Client
  3. Using the SFTP client to upload your data:
    • On the local machine file system panel, navigate to the folder user-resources/tutorials/tutorial_1/data/input/.
    • On your Rhino Health client file system panel, create a new folder called tutorial_1 and navigate inside of it
  4. Drag the dataset.csv and dicom_data/ files from your local machine file system panel to the Rhino Health client file system panel in order to upload them to your Rhino Health client.

Wait until your files have successfully been uploaded to the Rhino Health client before proceeding to the next step.

Step 3: Set Up Your Project on the FCP UI

Creating a New Project within the FCP UI

In this section of the tutorial, you will create a new Project within the Rhino FCP UI that will host your tutorial.  If you are interested in learning more about Projects within the context of the Rhino FCP, please follow one of the links to the Projects section of our User Guides.

  1. Log in at https://dashboard.rhinohealth.com/login. If this is your first time logging in, you will be required to change your initial password and sign the EULA.
  2. Create a new project by clicking on the Add New Project button in the top-right corner.
  3. Fill in the following fields within the new modal window:
    1. Name: Tutorial 1 - YOUR_NAME
    2. Description: This is my first project on the Rhino Health FCP
    3. Permissions Policy: Expand this section to explore the various configurable permission policies and personas that are available to you.  For this tutorial, you can leave the default Permissions Policy.
  4. Click the Create Project button to create your project. Once clicked, you will be navigated back to the project screen, where you will see your newly created project.

Importing a New Dataset within the FCP UI

In this section of the tutorial, you will import a new Dataset within your Project that will contain the data you will use with other aspects of your Project.  If you are interested in learning more about Datasets within the context of the Rhino FCP, please follow one of the links to the Datasets section of our User Guides.

  1. Click the Datasets menu item within the left-hand navigation menu.
  2. Import a new Dataset by clicking on the Import New Dataset button in the top-right corner.
  3. Fill in the following fields within the new modal window: 
    1. Name: Site 1 Dataset
    2. Description: Pneumonia Site 1 Dataset
    3. Select Workgroup: Do not modify the default option, Current workgroup, is correct for this tutorial
    4. Data Schema: [Auto-generate Data Schema from Data] - Do not modify
    5. Tabular Data File Location: /rhino_data/tutorial_1/dataset.csv
    6. DICOM Data Location: /rhino_data/tutorial_1/dicom_data
      1. Import method: Do not modify. The default option, Filesystem, is correct for this tutorial
    7. File Data Location: Do not modify. You have no file data to import in this tutorial since the Data Schema and accompanying dataset.csv only define DICOM data. So you only need to fill in the DICOM Data Path.
    8. Is Data Deidentified?: Yes
  4. Finally, click the Import New Dataset button to import your new dataset
  5. Within the Datasets page, you should now have a new dataset object defined with the message "Importing New Dataset". Once the Dataset has been imported completely, your Datasets page should look similar to the screenshot shown below:


Step 4: Running Simple Python Code via the FCP UI

The FCP provides an easy way to perform simple data operations that require only basic Python code and standard libraries such as NumPy and Pandas. In this step, you will use this functionality to produce a new Dataset with a new derived feature (or Schema Field in the FCP) from your previously imported Dataset.

Creating a New Data Schema with the Definition of the New Field

  1. Click the Data Schemas menu item within the left-hand navigation menu.
  2. Place your mouse anywhere within the bounds of the white box surrounding the Site 1 Dataset schema you created within the last step; this should reveal a new button in the top-right corner labeled + New Version.
  3. Click the + New Version button to create a new version of the Data Schema in which you will define the new field you would like to derive.
  4. Within the new dialog, ensure that the radio button Edit Latest Schema is checked. Leaving all other fields untouched.
  5. Click the Create New Schema Version button; this will take you to the FCP's Data Schema editing tool. Here you should see a tabular format of the Data Schema that you defined in the previous step.
  6. To add the new field's definition, click the + Add Field button next to the __Notes__ Schema field column.
  7. Fill in the following inputs within the new Schema Field column:
    1. Schema Field: BMI
    2. Identifier: Leave blank
    3. Description: Weight / Height**2
    4. Role: Do not modify. The default option, input, is correct for this tutorial
    5. Type: Float
    6. Type Params: Leave blank
    7. Units: Leave Blank
    8. May Contain PHI: No
    9. Permissions: Do not modify. The default option, Default, is correct for this tutorial
  8. Once you have completed entering all your details for the new BMI field, click Save in the top right corner. You should now have two versions of your Data Schema, and your Data Schemas page should look similar to the screenshot below:

Creating a New Python Code Object within the FCP UI

In this section of the tutorial, you will create a new Python Code Object within your Project to process the Dataset you imported.  If you are interested in learning more about Python Code Objects within the context of the Rhino FCP, please follow one of the links to the Python Code sub-section in the Code section of our User Guides.

  1. Click the Code menu item within the left-hand navigation menu.
  2. Create a new Code Object by clicking on the Create New Code Object button in the top-left corner.
  3. Fill in the following fields within the new modal window:
    1. Type: Python Code
    2. Name: My First Code
    3. Description: Python code for computing BMI
    4. Inputs: Site 1 Dataset schema (V.0)
    5. Outputs: Site 1 Dataset schema (V.1)
    6. Container: Do not modify. Keep Select Python and CUDA Versions selected with
      1. Python: 3.9
      2. CUDA: NONE
    7. Code: Keep Code Snippet selected and enter the BMI calculation in the text box: 
      df['BMI'] = df.Weight / (df.Height ** 2)
    8. Requirements: Keep PIP selected as well as the defaults in the text box
    9. Next, click the Create New Code Object button to create your new Code Object within your project. Once the Code Object creation is complete, your Code page should now look similar to the screenshot below:

Running your New Python Code within the FCP UI

In this section of the tutorial, you will run the newly created Python Code which will produce a Code Run after running.  If you are interested in learning more about Code Runs within the context of the Rhino FCP, please follow one of the links to the Code Runs section of our User Guides.

  1. Navigate to the Code Object you created in the last step, and click the Run button in the row corresponding to Version 0 of My First Code
  2. Fill in the following fields within the new modal window:
    1. Input Datasets: Site 1 Dataset (v0)
    2. Output Dataset Name Template: Append '_addBMI' to the existing value, so it looks like: 
      {{ input_dataset_names.0 }}_addBMI
    3. Additional Parameters: Do not modify
  3. Once you have completed entering all the details of your Code Run, click the Run button to send your code to be run on your Rhino Health client.
  4. To monitor your Code Run's progress, click the Code Runs menu item within the left-hand navigation menu.
  5. Click on the Code Runs link in the left menu. You should now see a new Code Run entitled My First Code with a single row in it showing a status of "Running".  Once your Code Run has completed running, you should see a green checkmark and the words "Completed: Success" next to it.  Your Code Runs page should look similar to the screenshot shown below:


Reviewing the Code:

To review the output of your Code Run, click on the link entitled 1 Dataset under the Output Datasets heading within the first row of the My First Code card.  This link will take you back to the Datasets page, but now on the Analytics tab.  There you will see summary statistics about your newly created Dataset, Site 1 Dataset_addBMI, produced by the latest run of My First Code.

    • A few things of note on the Dataset analytics page:
      • The new field, BMI, is present and has been calculated using the code you provided during the creation of My First Code.
      • The table under the Data Completeness heading shows that the new field, BMI, has a comparatively low data completeness score, only 64%.  This is because it was created using other fields with missing values.

Step 5: Running Python Code with Custom Dependencies via the FCP UI

After discovering new insights about the output Dataset in Step 4: Running Simple Python code via the FCP UI, you would like to improve your data completeness metric by adding a preliminary data imputation step. Additionally, you would like to convert the DICOM CXR images into JPEG versions. As data preparation becomes more and more complex it is often better to collect all the steps in a single script that can be run on the platform, rather than perform a series of smaller steps.

We have provided such a script in the user-resources/tutorials/tutorial_1/containers/data-prep folder named dataprep_gc.py This script has a few additional dependencies which are included in the requirements.txt file, go ahead and take a look now.

In order to be able to run this code on the FCP, you will need to include some additional dependencies in your Python Code by following the instructions below:

Create a New Data Schema Version that Includes your New Output Schema Fields

  1. Return to the FCP to create another new version of the original Site 1 Dataset schema.  This new Data Schema will serve as the output of your newly created container.  You will do this by repeating Steps 1-6 in Step 4: Running Simple Python Code via the FCP UI.
  2. Fill in the following inputs within the new Schema Field column:
    NOTE: Schema Field values are case-sensitive and must match what is in your code.
    1. Schema Field: JPG file
    2. Identifier: Leave blank
    3. Description: JPG representation of the input DICOM image
    4. Role: Do not modify. The default option, Input, is correct for this tutorial
    5. Type: Filename
    6. Type Parameters: Leave blank
    7. Units: Leave Blank
    8. May Contain PHI: No
    9. Permissions: Do not modify. The default option, Default, is correct for this tutorial
  3. Once you have completed entering all your details for the new JPG file field, click Save in the top right corner. You should now have three versions of your Data Schema, and your Data Schemas page should look similar to the screenshot below: 

Creating a New Python Code Object with Custom Dependencies

  1. Click the Code menu item within the left-hand navigation menu.
  2. Create a new Code Object by clicking on the Create New Code Object button in the top left corner.
  3. Fill in the following fields within the new modal window:
    1. Type: Python Code
    2. Name: Data Prep
    3. Description: Data Imputation, BMI Calculation, & DICOM file conversion to JPG
    4. Inputs: Site 1 Dataset schema (v0)
    5. Outputs: Site 1 Dataset schema (v2)
    6. Container: Select Input Container Base Image and enter: 
      python:3.9.7-slim-bullseye
    7. Code: Select Standalone file and paste the entire contents of the dataprep_gc.py script into the input field
    8. Requirements: Keep Pip selected and paste the entire contents of the requirements.txt file into the input field
  4. Next, click the Create New Code Object button to create your new Code Object within your project. Once the Code Object creation is complete, your Code page should now look similar to the screenshot below:

Running your New Python Code Object to Prepare the Data

  1. Navigate to the Code Object you created in the last step, and click the Run button in the row corresponding to Version 0 of Data Prep.
  2. Fill in the following fields within the new modal window:
    1. Input Datasets: Site 1 Dataset (v0)
    2. Output Dataset Name Template: Append '_complete' to the existing value, so it looks like: 
      {{ input_dataset_names.0 }}_complete
    3. Additional Parameters: Do not modify
  3. Once you have completed entering all the details of your Code Run, click the Run button to send your code to be run on your Rhino Health client.
  4. To monitor your Code Run's progress, click the Code Runs menu item within the left-hand navigation menu.
  5. On the Code Runs page, you should now see a new Code Run entitled Data Prep with a single row in it showing a status of "Running".  Once your Code Run has completed running, you should see a green checkmark and the words "Completed: Success" next to it.
  6. To review the output of your Code Run, click the Datasets menu item within the left-hand navigation menu.
  7. You should now have a new Dataset listed on the page with the name Site 1 Dataset_complete.  Your Datasets page should now look similar to the screenshot below:
  8. Click on the row representing Version 0 within the Site 1 Dataset_complete Dataset card to view the new Dataset analytics after we have successfully run our Data Prep Python Code. Your Dataset Analytics tab within the Datasets page should now look similar to the screenshot below:
    • A few things of note on the Analytics tab within the Datasets page:
      • The Data Prep Code has added 2 new fields to the Dataset - BMI, and JPG file.
      • The Code performed data imputation so your Data Completeness metrics for all fields should now be 100%.
      • If you navigate to the Data tab, you can directly access the tabular data within the Dataset. Your Dataset Data tab within the Datasets page should now look similar to the screenshot below: 
         
  • Permission Note: You are permitted to view this data in this way because you have imported this Dataset from your workgroup’s client. When working with Datasets from other workgroups, the other workgroups will need to grant you explicit permission to be able to access their data at this level. For more information, please refer to Secure Access Lists within the User Guides.

Step 6: Running Federated Training with NVFlare on the FCP UI

Create a New Data Schema for the Output of your NVFlare Code

For this tutorial, you can either:

  • Create a Blank Data Schema using the details outlined below, or
  • Upload from File using the provided file: user-resources/tutorials/tutorial_1/schemas/Pneumonia Output Schema.csv.

For creating a new Schema you can follow the steps in Creating a New Data Schema within the FCP UI within Step 3: Set Up Your Project on the FCP UI to create a new Data Schema called "Pneumonia Results Schema". 

The schema looks like this:

Field Name SeriesUID Height Weight Gender Pneumonia BMI JPG file Model Score __Notes__
Identifier                  
Description DICOM Series UID of the CXR Patient Height Patient Weight Patient Gender Whether or not the patient had pneumonia Patient BMI CXR JPG image Model score on validation set System generated column for user notes
Role Input Input Input Metadata Output Input Input Output Input
Type DicomSeriesUID ConstrainedFloat PositiveFloat Enum Boolean NonNegativeFloat Filename Float String
Type Parameters   {"gt": 0, "le": 2.3}   {"choices": ["M", "F"]}          
Units   m kg     kg/m^2      
May Contain PHI? False False False False False False False False False
Permissions Default Default Default Default Default Default Default Default Default

Creating a New NVFlare Code Object Using the Autocontainer Feature

In this section of the tutorial, you will create a new NVFlare Code Object within your Project to train and validate a model to predict the likelihood of pneumonia in the Dataset you imported and then preprocessed.  If you are interested in learning more about NVFlare Code Objects within the context of the Rhino FCP, please follow one of the links to the NVFlare Code sub-section with the Code section of our User Guides.

  1. Click the Code menu item within the left-hand navigation menu.
  2. Create a new code model by clicking on the Create New Code Object button in the top left corner.
  3. Fill in the following fields within the new modal window:
    1. Type: NVIDIA Flare
    2. NVFLARE Version: 2.5 (Ensure compatibility with your Python version; NVFlare 2.5 requires Python 3.10. or later)
    3. Name: Prediction Model
    4. Description: PyTorch Classification Model for Predicting Pneumonia within Patients
    5. Input Data Schema: Site 1 Dataset Schema (v2)
    6. Output Data Schema: Pneumonia Results Schema (v0)
    7. Container: Select the New container image button
      1. Python: 3.11 (Ensure compatibility with your NVFLARE version; NVFlare 2.5 requires Python 3.10 or later.)
      2. CUDA: NONE

      3. Code: The order and method of selecting the files is important as it must maintain the directory structure

        1. Select browse files and navigate to
          user-resources/tutorials/tutorial_1/containers/prediction-model
        2. Select the infer.py file and click Open
        3. Click the + Add more button on the top right of the pane 
        4. Select browse files and in the same folder select meta.json and upload it.
        5. Now select browse folders

          Note:

          • If you use NVFlare NVFlare 2.4 and above, these directories were moved inside the app folder, so they should now be structured as app/config and app/custom.
          • If you use NVFlare 2.3 and earlier, the configuration required two separate directories: config and custom.
        6. Select the config directory and click Upload
        7. A pop-up window asking to upload all files. Click Upload.
        8. Again, click the + Add more button
        9. Select browse folders
        10. Select the custom directory and click Upload.
        11. Click Upload again on the popup.
        12. Finally, below the pane of files, click the Upload Files button
  4. In the Requirements pane, click the Upload File button
  5. Select the requirements.txt file from
    user-resources/tutorials/tutorial_1/containers/prediction-model
    and click Open
  6. Finally, click the Create New Code Object button to create your new Code Object within your project. 

Running your New NVFlare Code Object to Predict Pneumonia

  1. Navigate to the Code Object you created in the last step, and click the Run button in the row corresponding to Version 0 of the Prediction Model.
  2. Fill in the following fields within the new modal window:
    1. Training Datasets: Site 1 Dataset_complete (v0)
    2. Validation Datasets: Site 1 Dataset_complete(v0)
      • Note: In a real-world scenario you would not select the same Datasets for both training and validation, rather you would split the Datasets into training and validation Datasets first
    3. Output Dataset Name Suffix: _results
    4. Configuration: Do not modify.
    5. Additional Parameters: Do not modify.
  3. Once you have completed entering all the details of your Code Run, click the Run Training button to send your code to be run on your Rhino Health client.
    • Training should take between 10-30 minutes to complete (depending on your Rhino Health client’s hardware) - The training is only performing a single epoch, so model performance will likely be less than stellar
    • Once training has been completed, the system will automatically run inference with your validation Dataset and your newly trained model to produce a new output Dataset with the results of the validation.
  4. After the training and validation steps have successfully completed, you should have a new Dataset within the Datasets page entitled Site 1 Dataset_complete_results. Your Datasets page should now look similar to the screenshot below:

Screenshot 2025-03-05 at 4.35.21 PM.png

Step 7: Producing Visualizations of Your Code Run with the Rhino SDK

In this section of the tutorial, you will create a report to visualize the output of your NVFlare Code's Inference results.  If you are interested in learning more about the Rhino SDK, please follow one of the links to the Rhino SDK section of our User Guides.

  1. If you do not have Python installed with your development environment, please download and install Python here: Python
  2. If you do not have Jupyter Notebook installed within your development environment, please follow the steps outlined here: Jupyter Notebook Installation
  3. Using your terminal or command prompt, navigate to your user-resources/tutorials/tutorial_1/notebooks folder.
  4. Run the following command to start the Jupyter Notebook, Tutorial 1 - Results Analysis Notebook.ipynb: 
    jupyter notebook "Tutorial 1 - Results Analysis Notebook.ipynb"
  5. Follow the step-by-step tutorial for producing Code Run visualizations using the Rhino SDK by running each of the cells contained within the notebook.
  6. Once you have completed running the entire notebook, switch back over to the FCP.  Navigate to the Code Runs page, clicking the first row labeled V, for validation, within the Prediction Model card.  
  7. You will be taken to a new page with two tabs, Report, and Logs. Through the previous steps, we have populated the Report tab. You should now see various charts and your Reports tab within the Code Runs page should now look similar to the screenshot below:

step7.7.png

Congratulations on completing your first tutorial on the Rhino Health FCP!

You should now have a good understanding of:

  1. The important concepts of: Container, Docker, AWS ECR, AWS S3, SFTP, Data Schema.
  2. How to access the FCP and locate your credentials from your profile page
  3. How to create a new project
  4. What a Data Schema is and how to create a new Data Schema
  5. How to import new Datasets to your project
  6. How to create several different Code Objects (Python Code, Generalized Compute & NVFlare) and run them
  7. How to use the Rhino SDK to create custom reports for visualizing the output of Code Runs

Things to try next

  • Adjust the code to produce different results:
    • Change the units for Height and/or Weight
    • Extract new fields from the data
  • Check out the tabular viewer’s advanced features:
    • The tabular viewer (accessible by clicking on a Dataset you have access to, then clicking on the Data tab) includes a few advanced features, such as a fully functional DICOM viewer with annotation capabilities, an auto-generated editable __Notes__ column you can use to append free-text notes to each case, and a viewer for standard image formats such as .jpg and .png.
      You can read about these features in the Rhino Health Federated Computing Platform User Manual and test them in your Hello World project.
  • Try to break things, for example:
    • Mismatches between the Data Schema and the data in the dataset.csv file will produce validation errors when attempting to import the Dataset. We recommend you try altering the Dataset and Data Schema to see what happens. 
    • Try adding faulty code to the Python Code Object and running it. This will help you learn how the FCP produces different error messages and how you can use the platform to debug your code.

Thanks again for investing your time in learning how to use the FCP, we can't wait to see what you will do with it! If you need support at any time, feel free to contact support@rhinohealth.com.

Continue to Tutorial #2 →

Related to

Was this article helpful?