Here we provide some sample prototypes of an interactive video tool designed to allow the user to navigate extended video recordings with greater ease, hopefully leading to better learning.
In this webinar we provide recipes for transitioning scientific workloads that currently run on traditional batch systems to Kubernetes systems. Kubernetes is batch-like in nature, but there are some differences that science users should be aware of. We will also briefly describe capabilities that are not found in traditional batch systems that can improve the effectiveness of scientific computing.
In this webinar, we demonstrate how to transition your Jupyter Notebooks from a local machine to the Expanse HPC system using command-line tools and the Expanse Portal. We cover creating transferable software environments, scaling up calculations to large datasets, parallel processing, and running Jupyter Notebooks in batch mode.
This webinar will briefly introduce how to build Singularity images and how to run them on the SDSC supercomputer clusters. We will also share some insider knowledge of best practices and pitfalls to avoid while working with Singularity.
This webinar will be a quick introduction and overview of neural networks, convolution networks, and demonstration of executing deep learning models in an HPC environment.
Managing data efficiently on a supercomputer is important from both users' and system's perspectives. In this webinar, we will cover a few basic data management techniques and I/O best practices in the context of the Expanse system at SDSC.
Learn how to write your first batch job script and submit it to a Slurm batch job scheduler. We discuss best practices on how to structure your batch job scripts, teach you how to leverage Slurm environment variables, and provide you with some tips on how to request resources from the scheduler to get your work done faster. We also introduce you to some advanced features like Slurm job arrays and job dependencies for more structured computational workflows.
In this webinar we cover supercomputer architectures, the differences between threads and processes, implementations of parallelism (e.g., OpenMP and MPI), strong and weak scaling, limitations on scalability (Amdahl’s and Gustafson’s Laws) and benchmarking.
In this webinar we provide recipes for transitioning scientific workloads that currently run on traditional batch systems to Kubernetes systems. Kubernetes is batch-like in nature, but there are some differences that science users should be aware of. We will also briefly describe capabilities that are not found in traditional batch systems that can improve the effectiveness of scientific computing.
In this webinar, Yuwu Chen from TSCC User Services will show how to build Singularity images and then run them on the SDSC supercomputer clusters such as TSCC. Yuwu will also be sharing his insider knowledge of best practices along with pitfalls to avoid while working with Singularity.
In this webinar we cover supercomputer architectures, the differences between threads and processes, implementations of parallelism (e.g., OpenMP and MPI), strong and weak scaling, limitations on scalability (Amdahl’s and Gustafson’s Laws) and benchmarking.
The Application Deadline has passed. The HPC and Data Science Summer Institute is a week-long workshop focusing on a broad spectrum of introductory-to-intermediate topics in High Performance Computing and Data Science. The program is aimed at researchers in academia and industry, especially in domains not traditionally engaged in supercomputing, who have problems that cannot typically be solved using local computing resources.
*APPLICATION CLOSED* The CIML Summer Institute will involve introducing ML researchers, developers and educators to the techniques and methods needed to migrate their ML applications from smaller, locally run resources, such as laptops and workstations, to large-scale HPC systems, such as the SDSC Expanse supercomputer.
In this webinar we demonstrate how to transition your Jupyter Notebooks from a local machine to the Expanse HPC system using command-line tools and the Expanse Portal. We cover creating transferable software environments, scaling up calculations to large datasets, parallel processing, and running Jupyter Notebooks in batch mode.
This webinar will be a quick introduction and overview of neural networks, convolution networks, and deep learning on Expanse.
The first in a recurring webinar series on using Expanse and other SDSC HPC resources securely. This webinar will cover security and security-related topics relevant to researchers and the trustworthiness of their work produced on these resources.
Come learn all about Singularity containers. In this webinar, we'll provide an overview of Singularity and how you might incorporate the use of containers in your own research. We'll also show you how to access and use some of the containerized applications that we make available to users on Expanse at SDSC.
This webinar covers the basics of accessing SDSC's Expanse supercomputer, managing the user environment, compiling and running jobs using Slurm, where to run them, and how to run batch jobs. We will also cover interactive computing using applications such as Jupyter Notebooks and how to run them via the command line or from the Expanse portal. It is assumed that you have mastered the basic skills of logging onto HPC systems using SSH and running basic Unix commands on these systems.
In this webinar we cover supercomputer architectures, the differences between threads and processes, implementations of parallelism (e.g., OpenMP and MPI), strong and weak scaling, limitations on scalability (Amdahl’s and Gustafson’s Laws) and benchmarking.
Come learn how to launch your Jupyter notebook sessions on Expanse in a simple, secure way.
Managing data efficiently on a supercomputer is very important from both users' and system's perspectives. In this webinar, we will cover some of the basic data management techniques, I/O best practices in the context of the Expanse system at SDSC.
This webinar covers the basics of accessing SDSC's Expanse supercomputer, managing the user environment, compiling and running jobs using Slurm, where to run them, and how to run batch jobs.
This workshop will focus on providing guidelines for setting up customized Python environments, how to install and manage packages using Miniconda/pip, and how to run secure Jupyter notebooks on Triton Shared Computing Cluster (TSCC) HPC system.
*Application deadline: Sunday, May 16 (EXTENDED)* This year’s Summer Institute continues SDSC’s strategy of bringing HPC to the “long tail of science,” i.e., providing resources to a larger number of modest-sized computational research projects that represent, in aggregate, a tremendous amount of scientific research and discovery.
*APPLICATION CLOSED* The CIML Summer Institute will involve introducing ML researchers, developers and educators to the techniques and methods needed to migrate their ML applications from smaller, locally run resources, such as laptops and workstations, to large-scale HPC systems, such as the SDSC Expanse supercomputer.
This webinar will give a brief introduction to GPU computing and programming on Expanse. We will cover the GPU architecture, programming with the NVIDIA HPC SDK via libraries, OpenACC compiler directives, CUDA, profiling and debugging, and submitting GPU enabled jobs on Expanse.
This free webinar will introduce HPCShare, a web-based resource for users of SDSC’s high-performance computing resources, including Expanse, to easily share small-to medium-scale datasets in an efficient and organized manner. Attendees will learn about using HPCShare and SDSC’s SeedMeLab scientific data management system. Hosted by SDSC Visualization Group Lead Amit Chourasia.
This event will help users to make the most effective use of Expanse’s AMD EPYC processors. Topics include an introduction to the EPYC architecture, AMD compilers and math libraries, strategies for mapping processes and tasks to compute cores, Slurm, application tuning and profiling tools.
This webinar will present the approach and the architecture of the composable systems component of Expanse. We will also summarize scientific case studies that demonstrate the application of this new infrastructure and its federation with Nautilus, a Kubernetes-based GPU geo-distributed cluster.
This tutorial is intended for all current users of Comet who intend to make the transition to Expanse. Topics will include an overview of the system, batch job submission, modules, compilation, job charging, basic optimization, interactive computing and data transfer.
Presentation will cover cache-level optimizations and other techniques for achieving optimal software performance. We will also cover AMD specific compiler options, libraries and performance tools.
SDSC supports the training of its user community, including students, in all aspects of High-performance computing (HPC). The goal of the training is to prepare new HPC users to run jobs on HPC systems. Students who successfully complete the HPC Training program will receive an SDSC Certificate of Completion in HPC Training and UCSD Co-Curricular Record Credit (for students).
Come learn about Singularity containers and how you might use them in your own work.
In this webinar, we will present SDSC’s multitiered approach to running notebooks more securely: hosting Jupyter services on Expanse using SSH Tunneling or using the SDSC Jupyter Reverse Proxy Service (JRPS), which connects the user over an HTTPS connection. The JRPS will launch a batch script that creates a securely hosted HTTPS access point for the user, resulting in a safer, more secure notebook environment.
This tutorial is intended for all current users of Comet who intend to make the transition to Expanse. Topics will include an overview of the system, batch job submission, modules, compilation, job charging, basic optimization, interactive computing and data transfer.
This webinar covers the basics of accessing the SDSC Expanse supercomputer, managing the user environment, compiling and running jobs on Expanse.
This webinar will highlight security-related topics that can improve the trustworthiness of your research. The topics covered include logging in to SDSC's HPC resources, file and directory permissions, and common practices that may create trouble.
The goal of this webinar is to provide an overview of Expanse, an upcoming NSF funded HPC resource at SDSC. Expanse will have nearly double the performance compared to the Comet supercomputer. With innovations in cloud integration and composable systems, as well as continued support for science gateways and distributed computing via the Open Science Grid, Expanse will allow researchers to push the boundaries of computing.
In this webinar, we will present SDSC’s multitiered approach to running notebooks more securely: running notebooks in the usual way using the insecure HTTP connections; hosting Jupyter services on Comet using HTTP over SSH Tunneling; and the SDSC Reverse Proxy Service (RPS) which connects the user over an HTTPS connection. When used, the RPS will launch a batch script that creates a securely hosted HTTPS access point for the user, resulting in a safer, more secure notebook environment.
This webinar covers the basics of accessing the SDSC Comet supercomputer, managing the user environment, compiling and running jobs on Comet, where to run them, and how to run batch jobs. It is assumed that you have mastered the basics skills of logging onto Comet and running basic Unix commands. The webinar will include access to training material.
This webinar introduces users to Numba and RAPIDS for GPU programming in Python. Numba allows us to write just-in-time compiled CUDA code in Python, giving us easy access to the power of GPUs from a powerful high-level language. RAPIDS is a suite of tools with a Python interface for machine learning and dataframe operations.
In this webinar we will show how to use RAPIDS to accelerate your data science applications utilizing libraries like cuDF (GPU-enabled Pandas-like dataframes) and cuML (GPU-accelerated machine learning algorithms).
Python is rapidly becoming the programming language of choice for scientific research, and Jupyter Notebooks provide a user-friendly way of writing and running python code and of teaching and learning how to program. Visual analytics is playing an increasingly important role in data science by allowing researchers to explore massive amounts of data for patterns which may not be obvious using other methods.
Deep learning has seen tremendous growth and success in the past few years. Deep learning techniques have achieved state-of-the-art performance across many domains, including image classification, speech recognition, and biomedical applications.
In this webinar we start by describing how to obtain hardware and system information such as CPU specifications, memory quantity, cache configuration, mounted file systems and their usage, peripheral storage devices and GPU properties. This information is useful for anyone who is interested in how hardware specs influence performance or who needs to report benchmarking data.
This webinar provides an introduction to distributed computing with Python, we will show how to modify a standard Python script to use multiple CPU cores using the concurrent.futures module from the Python standard library and then the dask package.
This webinar covers the basics of accessing the SDSC Comet supercomputer, managing the user environment, compiling and running jobs on Comet, where to run them, and how to run batch jobs. It is assumed that you have mastered the basics skills of logging onto Comet and running basic Unix commands. The webinar will include access to training material.