In this document, you can see how to launch different software in the Open OnDemand (OOD) Remote Desktop app (available at rcood.rc.fas.harvard.edu)

Step 1: Connect to the FASRC VPN (see VPN setup documentation)

Step 2: Launch the Remote Desktop app

• Cannon cluster
• FASSE cluster

Step 3: When the Remote Desktop app opens, click the terminal icon to launch a terminal (or click Applications -> Terminal Emulator).

Step 4: Below, you can follow the instructions to launch various software.

Keep in mind that, for the most part, the terminal window must remain open. If the terminal window is closed, the software launched via the terminal will also be closed.

Training Session: FASRC Open On Demand Users Training

Remote Desktop login

To comply with Harvard’s security policy, if the Remote Desktop session becomes idle, the Remote Desktop session will lock. You need to enter your FASRC password to log back in.

Abaqus

In the terminal, type the commands to load the modules and launch Abaqus

[jharvard@holy7c24102 ~]$ module load abaqus
[jharvard@holy7c24102 ~]$ export LANG=en_US
[jharvard@holy7c24102 ~]$ abaqus cae -mesa cpus=$SLURM_CPUS_PER_TASK &

You can see all versions of Abaqus with module spider abaqus. For more details, see the modules page.

The Abaqus license is restricted to SEAS. For more information, see our Abaqus docs.

Comsol

In the terminal, type the commands to load the modules and launch Comsol

[jharvard@holy7c24102 ~]$ module load comsol
[jharvard@holy7c24102 ~]$ export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
[jharvard@holy7c24102 ~]$ comsol -3drend sw -np $SLURM_CPUS_PER_TASK &

You can see all versions of Comsol with module spider comsol. For more details, see the modules page.

The Comsol license is restricted to SEAS. For more information, see our Comsol docs.

For how to set the Comsol temporary directory, see our Comsol Troubleshooting doc.

Jupyter Notebook

(optional) Creating and loading a mamba/conda environment

Note: this is a one-time setup to ensure that your conda environment can be loaded in Jupyter Notebook.

See our Python documentation on how to create a conda environment.

Then, in order to see your conda environment in Jupyter Notebook, ensure that you have installed the packages ipykernel and nb_conda_kernels. To do so, launch a terminal in the Remote Desktop and type the commands:

[jharvard@holy7c24102 ~]$ module load python
[jharvard@holy7c24102 ~]$ source activate my_conda_environment
[jharvard@holy7c24102 ~]$ mamba install ipykernel
[jharvard@holy7c24102 ~]$ mamba install nb_conda_kernels

For more information on creating conda environments for TensorFlow and PyTorch, see our GitHub documentation:

• TensorFlow
• PyTorch

You can see all versions of Python with module spider python. For more details, see the modules page.

Launching Jupyter Notebook

In the Remote Desktop terminal, type the commands to load the modules and launch Jupyter Notebook:

[jharvard@holy7c24102 ~]$ module load python
# (optional) load conda environment
[jharvard@holy7c24102 ~]$ source activate my_conda_environment
# launch jupyter notebook
[jharvard@holy7c24102 ~]$ jupyter notebook

After the jupyter notebook command, it may hang for a few seconds. Be patient, a Firefox window will open soon after.

To select my_conda_environment as the kernel, go to Kernel -> Change kernel, and select the kernel (i.e. conda environment) of your choice.

Note: If you prefer to launch Jupyter Lab, note that conda environments cannot be loaded when using Jupyter Lab. Only the base environment is available.

Cleanly close Jupyter Notebook

These are instructions to kill your Jupyter server and so you can exit the job cleanly.

First, close each Jupyter Notebook you have open: click on File -> Close and Halt.

Then, from the Jupyter Notebook Home Page (where you can browse files and folders), on the top right corner, click on “Quit”. Close the Firefox window.

KNIME

In the terminal, type the following commands to load the module and launch Knime.

[jharvard@holy7c24102 ~]$ module load knime
[jharvard@holy7c24102 ~]$ knime &

You can see all versions of KNIME with module spider knime. For more details, see the modules page.

LibreOffice

LibreOffice is a free and open source suite that is compatible with a wide range of formats, including those from Microsoft Word (.doc, .docx), Excel (.xls, .xlsx), PowerPoint (.ppt, .pptx) and Publisher.

LibreOffice is available in the FASRC cluster (both Cannon and FASSE) through a Singularity image. Therefore, LibreOffice is only available through the Remote Desktop app. LibreOffice does not work in the Containerized Remote Desktop app.

In the terminal type the commands to pull and create a singularity image with LibreOffice installed within the container. This command is only needed once.

[jharvard@holy7c24102 ~]$ singularity pull docker://linuxserver/libreoffice

To launch LibreOffice, in the terminal, run the command

[jharvard@holy7c24102 ~]$ singularity exec --cleanenv --env DISPLAY=$DISPLAY libreoffice_latest.sif soffice

Lumerical

In the terminal, type the commands to load the modules and launch Lumerical

[jharvard@holy7c24102 ~]$ module load lumerical-seas
[jharvard@holy7c24102 ~]$ launcher

The Lumerical license is restricted to SEAS. For more information, see our Lumerical docs.

You can see all versions of Lumerical with module spider lumerical. For more details, see the modules page.

Mathematica

In the terminal, type the commands to load the modules and launch Mathematica

[jharvard@holy7c24102 ~]$ module load mathematica
[jharvard@holy7c24102 ~]$ mathematica

You can see all versions of Mathematica with module spider mathematica. For more details, see the modules page.

Matlab

In the terminal, type the commands to load the modules and launch Matlab

[jharvard@holy7c24102 ~]$ module load matlab
[jharvard@holy7c24102 ~]$ matlab -desktop -softwareopengl

You can see all versions of Matlab with module spider matlab . For more details, see the modules page.

MOE

In the terminal, type the commands to load the modules and launch MOE

[jharvard@holy7c24102 ~]$ module load moe
[jharvard@holy7c24102 ~]$ moe

You can see all versions of MOE with module spider moe . For more details, see the modules page.

MOE databases

FASRC has MOE databases available in two locations:

1. Most of the MOE Auxiliary Databases are available to everyone with cluster access in /n/holylabs/rc_admin/Everyone/moe_databases:
2. Databases are also available in the $MOE/project folder. You can open them in File -> Open -> Type in the address bar $MOE/project.

RStudio Desktop

In the terminal, type the commands to load modules

[jharvard@holy7c24102 ~]$ module load R
[jharvard@holy7c24102 ~]$ module load rstudio

Set environmental variables

[jharvard@holy7c24102 ~]$ unset R_LIBS_SITE
[jharvard@holy7c24102 ~]$ mkdir -p $HOME/apps/R_version
[jharvard@holy7c24102 ~]$ export R_LIBS_USER=$HOME/apps/R_version:$R_LIBS_USER

Launch RStudio Desktop

[jharvard@holy7c24102 ~]$ rstudio

# vanilla option (combines --no-save, --no-restore, --no-site-file, --no-init-file and --no-environ)
[jharvard@holy7c24102 ~]$ rstudio --vanila

You can see all versions of R and RStudio with module spider R and module spider rstudio, respectively. For more details, see the modules page.

Remoteviz Partition

If you have used the “FAS-RC Remote Visualization” Open OnDemand (or VDI) app, we have decommissioned it.

SageMath

You can use sage wither in a interactive shell using command line interface or by launching a Jupyter Notebook with the SageMath kernel. To launch a Jupyter Notebook, in the terminal, type the commands to load the modules and launch Jupyter

[jharvard@holy7c24102 ~]$ module load sage
[jharvard@holy7c24102 ~]$ sage -n jupyter

Ensure that you have “SageMath” kernel selected. If not, go to Kernel -> Change kernel, and select SageMath.

For example, see Sage documentation:

• interactive shell examples
• Jupyter Notebook examples

You can see all versions of SageMath with module spider sage. For more details, see the modules page.

SAS

In the terminal, type the commands to load the modules and launch SAS

[jharvard@holy7c24102 ~]$ module load sas
[jharvard@holy7c24102 ~]$ sas &

Stata

In the terminal, type the commands to load the module and launch Stata

[jharvard@holy7c24102 ~]$ module load stata/17.0-fasrc01

# if you are using single-core jobs
[jharvard@holy7c24102 ~]$ xstata-se

# if you are using multi-core jobs
[jharvard@holy7c24102 ~]$ xstata-mp "set processors $SLURM_CPUS_PER_TASK"

TensorBoard

For TensorBoard, you will first need to create a conda environment (Step 1). You only need to create a conda environment once. If you have created one, you can skip to Step 2. Or, if you have your own environment, make sure you install the TensorBoard package, and then you can skip to Step 2.

Step 1: Create conda environment

In a terminal, load Mambaforge or Python module, create a mamba environment, activate it, and install TensorBoard inside the mamba environment

[jharvard@holy7c24102 ~]$ module load python
[jharvard@holy7c24102 ~]$ module load cuda/11.7.1-fasrc01
[jharvard@holy7c24102 ~]$ module load cudnn/8.5.0.96_cuda11-fasrc01
[jharvard@holy7c24102 ~]$ conda create -n tb_tf2.10_cuda11 python=3.10 pip numpy six wheel scipy pandas matplotlib seaborn h5py jupyterlab
[jharvard@holy7c24102 ~]$ source activate tb_tf2.10_cuda11
[jharvard@holy7c24102 ~]$ conda install -c conda-forge tensorboard
[jharvard@holy7c24102 ~]$ conda install -c conda-forge tensorflow

You can see different versions of Mambaforge or Python in our modules page.

Step 2: Activate conda environment and launch TensorBoard

In a terminal, setup variables for TensorBoard. Make sure that the data you need to visualize in Tensorboard is located in the log directory MY_TB_LOGDIR. You can either use the suggested path below or use somewhere else that better suits your workflow.

# Find available port to run server on (does not output anything to screen)
[jharvard@holy7c24102 ~]$ for myport in {6818..11845}; do ! nc -z localhost ${myport} && break; done

# setup tensorboard environmental variables
[jharvard@holy7c24102 ~]$ export MY_TB_PORT=${myport}
[jharvard@holy7c24102 ~]$ export MY_TB_BASEURL=/node/${host}/${myport}/
[jharvard@holy7c24102 ~]$ export MY_TB_LOGDIR=$HOME/.tensorboard/log/$SLURM_JOBID
[jharvard@holy7c24102 ~]$ mkdir -p $MY_TB_LOGDIR

# load module, activate conda environment, and launch tensorboard
[jharvard@holy7c24102 ~]$ module load python
[jharvard@holy7c24102 ~]$ module load cuda/11.7.1-fasrc01
[jharvard@holy7c24102 ~]$ module load cudnn/8.5.0.96_cuda11-fasrc01
[jharvard@holy7c24102 ~]$ source activate tb_tf2.10_cuda11 
(tb_tf2.10_cuda11) tensorboard --host localhost --port ${MY_TB_PORT} --logdir ${MY_TB_LOGDIR} --path_prefix ${MY_TB_BASEURL}

You can see different versions of Mambaforge or Python in our modules page.

Right-click on the link that starts with “http://localhost” and click on “Open Link”. This will open a Firefox browser, where you can view your results.

Example

Using the environment created in Step 1, run the small program tb_test.py in a directory of your choice and visualize its results.

Source code of tb_test.py:

import os
import tensorflow as tf
import datetime

def create_model():
    return tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(512, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax')
    ])

mnist = tf.keras.datasets.mnist
(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = create_model()
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

logdir = os.getenv('MY_TB_LOGDIR')
print(logdir)

tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir, histogram_freq=1)
model.fit(x=x_train, 
          y=y_train, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])

Setup variables and run tb_test.py

# Find available port to run server on (does not output anything to screen)
[jharvard@holy7c24102 tb_example]$ for myport in {6818..11845}; do ! nc -z localhost ${myport} && break; done

# go to the directory that you have your tb_test.py file
[jharvard@holy7c24102 ~]$ cd tb_example

# setup tensorboard environmental variables
[jharvard@holy7c24102 tb_example]$ export MY_TB_PORT=${myport}
[jharvard@holy7c24102 tb_example]$ export MY_TB_BASEURL=/node/${host}/${myport}/

# this command will set MY_TB_LOGDIR to your current working directory
[jharvard@holy7c24102 tb_example]$ export MY_TB_LOGDIR=$PWD

# load modules and activate conda environment
[jharvard@holy7c24102 tb_example]$ module load python
[jharvard@holy7c24102 tb_example]$ module load cuda/11.7.1-fasrc01
[jharvard@holy7c24102 tb_example]$ module load cudnn/8.5.0.96_cuda11-fasrc01
[jharvard@holy7c24102 tb_example]$ source activate tb_tf2.10_cuda11

# run python code
(tb_tf2.10_cuda11) python tb_test.py

# launch tensorboard
(tb_tf2.10_cuda11) tensorboard --host localhost --port ${MY_TB_PORT} --logdir ${MY_TB_LOGDIR} --path_prefix ${MY_TB_BASEURL}

Right click on the link that starts with “http://localhost” and click on “Open Link”. This will open a Firefox browser where you will be able to see your results.

TotalView

TotalView is a debugging tool particularly suitable for parallel applications. The modules you need to load depend on the compilers used in the code you are trying to debug. Due to this compiler dependency, we refer you to a more elaborate TotalView documentation.

Visual Studio Code

In the terminal, type the commands to load the modules and launch Visual Studio Code

[jharvard@holy7c24102 ~]$ module load vscode
[jharvard@holy7c24102 ~]$ code --user-data-dir $HOME/.vscode/data/ &

You can see all versions of Visual Studio Code with module spider vscode. For more details, see the modules page.

Spyder is available through Anaconda Navigator on the FAS-RC Remote Desktop application on the Open OnDemand dashboard. To access it:

• go to the VDI dashboard at https://vdi.rc.fas.harvard.edu/pun/sys/dashboard/ (or https://fasseood.rc.fas.harvard.edu/pun/sys/dashboard if you are working on FASSE)
• start a new Remote Desktop session
• connect to the Remote Desktop session
• open a Terminal in the Remote Desktop session and load the relevant Anaconda module. Check https://portal.rc.fas.harvard.edu/p3/build-reports/ for the most up-to-date modules.
  • Examples:
  • if you’re working with Python 2, type the following:
    • module load Anaconda/5.0.1-fasrc02
  • if you’re working with Python 3, type the following:
    • module load Anaconda3/2020.11
• type the following:
  • anaconda-navigator
• when Anaconda Navigator loads, you may choose to remain in the “base” environment, or load your preferred environment from the “Applications on” dropdown, or create a new environment using the Environments tab to the left.
• when you are in the environment you need, click the Launch button under the icon for Spyder.

Screenshots of the process:

The Interactive Apps currently supported on the Open OnDemand include:

• Remote Desktop: This app schedules a Remote Desktop session on a compute nodeand opens a new tab to connect to it. You can open multiple applications at the same time. Also see How to open software on Remote Desktop.
• Jupyter notebook: The app schedules a Jupyter Notebook session on a compute node and opens a new tab to connect to it. You can open multiple Jupyter Notebooks, but you cannot open other apps.
• RStudio Server: The app schedules an RStudio Server session on a compute node and opens a new tab to connect to it.
• Matlab: The app schedules a Matlab session on a compute node and opens a new tab to connect to it. You can run single-node codes in parallel using the parallel pool. See our Github User_Codes page for an Matlab parallel example on Open OnDemand.
• Other: Additionally, we offer SAS, Stata, KNIME, and HeavyAI.  Also, see How to open software on Remote Desktop for apps not listed here.
  

Remote Desktop

The Remote Desktop app will schedule a job on a compute node, start a vnc server (TurboVNC), and provide a link to connect to it via the browser-based app noVNC.  No client is needed to connect to it, but if instead of using the web based client you prefer to use a traditional VNC client to connect to your session, please see Using a VNC Client to Connect at the bottom of this page.  To launch the session:

1. Go to the Cannon or FASSE dashboard
2. In the “Interactive Apps” menu, select the “Remote Desktop”
3. Fill in the following form. In the form you will be able to select:
   • partition – To see the available resources of each partition, refer to the Slurm Partitions documentation.
   • memory
   • number of cores
   • number of GPUs – use this only if selecting a GPU-enabled partition, see Slurm Partitions documentation.
   • allocated time
   • (optional) Selecting the checkbox “Custom Desktop Folder” will create a job-specific desktop
   • (optional) Email for status notification: enter a valid email to be notified when the job starts. Also, select the checkbox.
4. Once you have completed your sections,  press the “Launch” button
5. Allow a few seconds for the system to process your submission form, and you will be redirected to the “My Interactive Sessions” page
6. Click on the blue button “Launch Remote Desktop“. A new tab will open with the Remote Desktop session.
   
7. Once the Remote Desktop starts, you can open a terminal, load the modules you need, and start the software from the command line — see Remote Desktop: How to open software for more details.
8. When you are done running your computation, you can stop the job using the “Delete” red button in the section for that particular job in the  “My Interactive Sessions” page.

Performance and usability within a remote desktop type session

• When running a Remote Desktop or app that uses the desktop (ex. Matlab), the noVNC client does not support sharing clipboard and direct “Copy and paste” between your computer and the remote session in noVNC. noVNC provides a “staging clipboard” that you can use to copy to and from the remote session.  Copy things to that clipboard first, and then you can copy to your remote session.
  
• The default resolution of the remote session is 1024×768 and by default the resolution will not adjust to client display size. That is to avoid to resize the remote server to very large resolution in case you are connected to a large screen external display, and avoid performance degradation. If you chose to, you can rescale the remote clicking on the setting “wheel” and select “scaling mode = remote resizing”
  
• The noVNC web client is very convenient as it does not require you to install a client to connect, but it does not support all features in terms of compression and performance optimization that TurboVNC client or another client would. If instead of using the web based client you prefer to use a traditional VNC client to connect to your session, please see later in this doc.
• If you close the noVNC tab or the connection times out due to long inactivity, you will be always able to reconnect to your session clicking again on the “Launch noVNC in new Tab” in the “My Interactive Sessions” page . Your job is controlled by Slurm and will keep running until the allocated time, or until you cancel the job.
• If you want to terminate your job and your Remote Desktop session, you can simply click the “Delete” button on the “My Interactive Sessions”  tab in the section corresponding to that particular job.

Jupyter Notebook

This App allows you to submit a job which starts a Jupyter notebook on a compute node and provides a link to connect to it on a new browser tab. To launch the notebook, please select the “Jupyter notebook” entry from the “Interactive Apps” menu, and fill the form.  In the form you will be able to select :

1. Go to the Cannon or FASSE dashboard
2. In the “Interactive Apps” menu, select the “Jupyter notebook/ Jupyterlab”
3. Fill in the following form. In the form, you will be able to select:
   • partition – to see the available resources of each partition, refer to the Slurm Partitions documentation.
   • memory
   • number of cores
   • number of GPUs – use this only if selecting a GPU-enabled partition, see Slurm Partitions documentation.
   • allocated time
   • (optional) Working Directory: enter a path if you would like to start Jupyter in a diferent directory (e.g. /n/netscratch/jharvard_lab)
   • (optional) Extra Modules: enter modules necessary to run your code (e.g. cuda/12.9.1-fasrc01)
   • (optional) Reservation: Use this if you have an active reservation and would like to use it to run your job
   • (optional) Additional slurm options: must use slurm’s long format option (e.g., --nodelist=holy7c24502 instead of -w holy7c24502)
   • (optional) Slurm Account: specify which lab account you want to charge in terms of FairShare for this particular job.  If you are only affiliated with one lab, please ignore that entry, as it will default to your primary group.
   • (optional) Email for status notification: enter a valid email to be notified when the job starts. Also, select the checkbox.
     
4. Press the “Launch” button
5. Allow a few seconds for the system to process your submission form, and you will be redirected to the “My Interactive Sessions” page
6. Click on the blue button “Connect to Jupyter“. A new tab will open with the Jupyter Notebook session
   
7. When you are done running your computation, you can stop the job using the “Delete” red button in the section for that particular job in the  “My Interactive Sessions” page.

How do I access the Python and R kernels installed in my conda environments?

Jupyter can see your local mamba/conda environments that include the ipykernel and nb_conda_kernels packages (note that Jupyter calls conda/mamba environments “kernels”). To change to a specific conda/mamba environment:

1. Open a Jupyter Notebook
2. On the top right corner, click “Python 3 (ipykernel)”. If you already have a kernel selected, it may be a different name
   
3. Choose the kernel
   
4. Click the “Select” blue button
   
5. At the top right corner, you will see the selected kernel

How do I access a conda environment located in a lab share from Jupyter notebook app?

Warning: When sharing conda environment, we highly recommend that only one person install/uninstall/update packages because the environment may break if multiple users change the conda environment.

When a conda environment is created, its path is added to the the file ~/.conda/environments.txt. People that would like to use a conda environment created by someone else need to add the conda environment path to ~/.conda/environments.txt.

For example, jharvard creates an environment in a shared lab space and installs ipykernel:

# request interactive node
[jharvard@boslogin01 conda_envs]$ salloc -p test --time=1:00:00 --mem=4000

# load modules
[jharvard@holy7c24604 conda_envs]$ module load Anaconda3/2020.11

# create shared conda environment
[jharvard@holy7c24604 conda_envs]$ conda create --prefix /n/holylabs/jharvard_lab/Lab/conda_envs/my_shared_env python=3.10

# launch conda environment and install ipykernel
[jharvard@holy7c24604 conda_envs]$ source activate /n/holylabs/jharvard_lab/Lab/conda_envs/my_shared_env
(/n/holylabs/jharvard_lab/Lab/conda_envs/my_shared_env) [jharvard@holy7c24604 conda_envs]$ conda install ipykernel

# environment path is automatically added to ~/.conda/environments.txt
(/n/holylabs/jharvard_lab/Lab/conda_envs/my_shared_env) [jharvard@holy7c24604 conda_envs]$ cat ~/.conda/environments.txt
/n/holylabs/jharvard_lab/Lab/conda_envs/my_shared_env

Now, user1 has to add the same environment path to their ~/.conda/environments.txt file:

[user1@boslogin01 ~]$ echo "/n/holylabs/jharvard_lab/Lab/conda_envs/my_shared_env" >> ~/.conda/environments.txt
[user1@boslogin01 ~]$ cat ~/.conda/environments.txt
/n/holylabs/jharvard_lab/Lab/conda_envs/my_shared_env

Now, user1 will be able to select my_shared_env in Jupyter notebook VDI app as explained above.

Troubleshooting

I don’t see my conda/mamba environment in Jupyter

If you don’t see your conda/mamba environment in the list, you must install the packages ipykernel and nb_conda_kernels packages in your environment. For step-by-step instructions, see Use mamba environment in Jupyter Notebooks documentation.

After those packages are installed in your conda/mamba environment, you should see the environment in new Jupyter sessions.

I no longer can use my Python packages in Jupyter

If you were affected by the Jupyter app update in Jan/Feb 2026, you may have inadvertently installed packages in ~/.local. FASRC discourages the installation of Python packages in ~/.local because pip, mamba, and conda cannot track package dependencies properly in ~/.local.

We recommend that you create a new mamba/conda environment and install the packages the Python packages that you need. To do so, follow the instructions in the Python Package Installation documentation:

1. Section “Environments“
2. Section “Use mamba environment in Jupyter Notebooks“

Jupyter notebook VDI session is terminated right after it starts

This problem is common when there is a conda initialize section in your .bashrc file located in your home directory (more about .bashrc). The conda initialize section was added when, at some point, you used the command conda init. We strongly discourage the use of conda init. Instead use source activate environment_name, for more details, refer to our Python (Anaconda) page.

To solve this problem, delete or comment out the conda initialize section of your .bashrc and create a new Jupyter notebook VDI session.

Jupyter notebook/JupyterLab VDI session starts but does not display a ‘Connect to Jupyter’ button

If this problem occurs, you may see an error, jupyter: command not found, in

 ~/.fasrcood/data/sys/dashboard/batch_connect/sys/Jupyter/output/<sessionID>/output.log

On FASSE:

~/.fasseood/data/sys/dashboard/batch_connect/sys/Jupyter/output/<sessionID>/output.log

To solve this problem, delete the line auto_activate_base: false in the file ~/.condarc.

Example Jupyter Lab Notebooks

Example Jupyter and R notebooks demonstrating machine learning techniques on the classic Iris dataset. These notebooks are used in FASRC training sessions.

• Classification pipeline in Python.ipynb: End-to-end classification pipeline using scikit-learn and pandas. Covers data exploration, visualization with PCA, feature scaling, feature selection, and training a logistic regression model.
• Data_Classification.ipynb: K-Nearest Neighbors (KNN) classification example. Demonstrates train/test splitting, feature scaling, model training, and evaluation with confusion matrices.
• Data_Clustering.ipynb: K-Means clustering example. Shows unsupervised clustering on the Iris dataset and compares predicted clusters to actual labels.
• Data_Exploration.Rmd: R Markdown notebook for data exploration. Demonstrates loading data, train/test splitting, summary statistics, and basic visualizations in R.
• iris.data: The Iris dataset used by the notebooks.

Matlab

This App allows you to submit a job which starts a Matlab session on a compute node and provides a link to connect to it on a new browser tab. To launch the notebook, select the “Matlab” entry from the “Interactive Apps” menu, and fill in the following form.

– partition (see partitions page for core, memory, and time limits on public partitions)
– memory allocated for the job
– number of cores
– number of hours

Refer to our Github User_Codes for an example on how to run a parallel code on VDI.

RStudio Server

This app allows you to submit a job which starts a RStudio Server session  on a compute node and provides a link to connect to it on a new browser tab. To launch the notebook, select the “RStudio Server” entry from the “Interactive Apps” menu, and fill in the following form.

– partition (see partitions page for core, memory, and time limits on public partitions)
– memory allocated for the job
– number of cores
– number of hours

You can then select the version of R you want to run in your Rsession in RStudio.

If you want to be notified by email when the job starts select the checkbox and include a valid email address in the form. The “Slurm Account” can be use to specify which lab account you want to charge in terms of FairShare for this particular job. If you only are affiliated to one lab you can ignore that entry as it will default to your primary group.

When you made your selection press the “Launch” button. Allow a few seconds for the system to process your submission form, and you will be redirected to the “My Interactive Sessions” page.

You will be able to use the “Connect to RStudio Server” button to open the RStudio session in a new tab on your browser.

Note: When you are done running your computation you can delete the job using the “Delete” button in the section related to that particular job in the “My Interactive Sessions” page.

FASRC also has RStudio Desktop that can be launched from the Remote Desktop app. See the following docs for more information

• How to launch RStudio Desktop
• RStudio Server vs. RStudio Desktop

Sign in to RStudio error

In very rare instances, you may come across a prompt to sign in to RStudio. If you are running RStudio Server and get a sign in prompt asking for Username and Password:

Go to the Open OnDemand dashboard (Cannon, FASSE). Then click on “Interactive Session” on the top menu and then click on the button “Connect to RStudio Server”. This will reopen the RStudio Server session.

Using a VNC Client to Connect

No client is needed to connect to to a session, but if instead of using the web based client you prefer to use a traditional VNC client (we highly recommend TurboVNC) to connect to your session, please click on My Interactive Sessions and the VNC Desktop Client tab for instructions.