Common Dependencies in Runtime Environments

HyperAI includes a large number of basic dependencies in the runtime environment by default to reduce the consumption of runtime resources for downloading and installing dependencies each time a container starts.

The information below is based on a live runtime instance (verified as of March 2026):

• Ubuntu 22.04.5 LTS
• Conda Root Environment: Located at /usr/local
• Python 3.10.13
• JupyterLab 4.5.5
• Notebook 7.5.3
• CUDA Driver 13.0
• nvcc 12.9

To verify the actual environment inside your current container, it is recommended to run the following commands in the terminal:

python --version
pip list
conda list
jupyter --version
nvidia-smi

Pre-installed dependencies can be categorized into the following areas by purpose:

1. General Machine Learning Libraries

• scikit-learn General machine learning library containing numerous machine learning models, data analysis, data mining algorithms, and visualization tools.
• ONNX Deep learning model conversion library.
• ONNX Runtime ONNX model inference runtime.
• PyTorch Deep learning framework. Certain runtime environments include pre-installed versions of both torchvision and torchaudio.

2. Image Processing Tools

Commonly used graphics processing libraries

• OpenCV Powerful image processing tool
• Pillow Commonly used image processing tool in Python

3. Data Analysis Libraries

• pandas
• SciPy
• Matplotlib
• NumPy

In addition to the libraries listed above, some runtimes may also include other scientific computing or inference-related dependencies. However, it is recommended to always rely on the actual contents of the current container as the authoritative source.

How to Add Dependencies Not in the List

The default HyperAI runtime environment has already installed a large number of dependencies for machine learning scenarios. If you still need additional dependencies, you can install them through the following methods.

Installing Python Libraries

If you need some additional dependencies when uploading code and running it in "Python script execution" mode, you can define a file named hyperai_requirements.txt or requirements.txt in the root directory of the uploaded code, add the required dependencies, and upload it along with other files. Before the code runs, the system will first install these dependencies before executing the "Python script".

The format of this file's content is consistent with Python's requirements.txt format. A typical hyperai_requirements.txt file content is as follows:

jieba
tqdm==4.11.2

Where jieba and tqdm are two libraries that can be installed via pip. Using the above format will install these libraries first before executing the "Python script". The == after tqdm==4.11.2 specifies the specific version to be installed.

Dependency Management via Conda

For the "Workspace" section, see Managing Dependencies with Conda.

For "Python Script Execution", you can provide a file named conda-packages.txt in the root directory of the uploaded code. The file format follows:

[channel::]package[=version[=buildid]]

Here is an example:

conda-forge::rdkit
conda-forge::pygpu

If requirements.txt, hyperai_requirements.txt, and conda-packages.txt exist simultaneously, dependencies in conda-packages.txt will be installed first, followed by dependencies in hyperai_requirements.txt and requirements.txt.

Installing Other Dependencies

If you are in a "Jupyter Workspace", please refer to the next section. For "Python Script Execution" scenarios, you can install additional non-Python dependencies using the following methods:

1. Include dependency installation commands in the "Execution Command".

   For example, if you want to download necessary git repositories before running the program, you can use the following "Execution Command":

   $ git clone https://github.com/tensorflow/models.git && cd models && python ...

2. Prepare a dependencies.sh script.

   For dependencies that are not from Conda or PyPI, you can provide a file named dependencies.sh in the root directory. It will be executed by bash when "Python Script Execution" starts, and its execution will occur before the installation of dependencies from hyperai_requirements.txt, requirements.txt, and conda-packages.txt.

   Here is a dependencies.sh script example with the following content:

   git clone https://github.com/tensorflow/models.git
   cd models
   pip install -r requirements.txt

Installing Dependencies in Jupyter Workspace

In the “Jupyter Workspace,” you can install any dependencies you need, including both Python packages and system-level dependencies via apt.

It is recommended to use %pip install jieba first. Compared with !pip install jieba , it is better suited for Notebook environments because it explicitly installs the package into the Python environment used by the current kernel.

If you need to install system packages, you can run apt-get update && apt-get install -y <package>in the terminal, or execute !apt-get update && apt-get install -y <package>directly in the Notebook.

Persisting pip Dependencies

By default, dependencies installed via pip are usually stored in the system environment. After a container restart, they often need to be reinstalled.

If you install packages using the --user flag, the dependencies will be saved in the corresponding user directory. In the current runtime, PYTHONUSERBASE typically points to /output/.pylibs; and /hyperai/home is usually linked to /output, so you can think of it as being stored in the workspace. When the “workspace” is closed and later reopened, these dependencies are generally preserved along with the workspace.

1. Removing Unnecessary Dependencies

If you do not want to keep these dependencies, you can add the command rm -rf /output/.pylibs in the “run command” section. Since /hyperai/home is usually linked to /output, deleting /hyperai/home/.pylibs will achieve the same effect.

2. Requiring Different Python Versions

If you need a different Python version, you can create a new isolated environment under the /hyperai/home directory and install the full set of dependencies there. Please choose the appropriate documentation based on your runtime type:

• Conda-based runtimes (Ubuntu 22.04 and earlier): Dependency Management with Conda
• uv-based runtimes (Ubuntu 24.04 and newer, such as vllm 0.20 and later): Managing Python environments with uv

If you are not sure which runtime you are using, run conda --version in the terminal: if it returns a version number, it is a Conda runtime; if it shows command not found, it is a uv runtime.

The Python version in the current HyperAI runtime is not fixed. The example checked in this document shows Python 3.10.13, but your selected runtime may differ, so it is recommended to verify it using python --version.

Installing Jupyter Workspace Extensions

“Jupyter Workspace” supports installing extensions, but the installation method varies depending on the JupyterLab major version. Newer runtimes typically use JupyterLab 4, and many extensions have been migrated to Python package distribution. Installation methods commonly used in older versions, such as jupyter labextension install ..., may no longer be applicable.

It is recommended to first check the current environment:

jupyter --version
jupyter labextension list

If the official documentation of the target extension clearly states that it supports the current JupyterLab version, then install it using the corresponding method. For JupyterLab 4, it is more common to install the extension directly as a Python package, for example:

pip install <extension-package>

After installation, you can run jupyter labextension list again to verify the extension status.

Open a .ipynb file again, and you can see the "Table of Contents" tab appears on the left side. Click it to see the directory of the current file.