Jupyter and PyTorch on an Hourly GPU: Files and Checkpoints

Select Jupyter on the hourly GPU service for notebooks, data analysis and model experiments. This is different from Python web hosting or a full VPS: access uses the app HTTPS endpoint, local disk is temporary and publishing arbitrary ports is not guaranteed.

Plan resources separately

Estimate model VRAM, dataset RAM and disk space for models and checkpoints separately. A model file’s size is not its training memory requirement; the optimizer, batch and numeric precision also matter. Use only the compatible card and app combinations available in the configurator. Check the current hourly rate and starting credit before ordering. Unavailable capacity has no guaranteed allocation time.

1. Open your environment

1. Choose a card and Jupyter, submit the request and follow allocation and app readiness in Console.
2. After delivery, use the Open Jupyter button on that service page to reach the correct HTTPS endpoint.
3. If Jupyter requests a token, use the application token from the panel, not your ServerNet account password. Gateway and application tokens can have different roles; use the values shown for this service.
4. Create a project directory in the Jupyter file browser, upload your data and open a Python notebook.

2. Check CUDA and create a small checkpoint

This performs one small training step to check the environment. It is not a benchmark or a useful trained model. It stops when CUDA is unavailable instead of silently falling back to the CPU.

from pathlib import Path
import torch

if not torch.cuda.is_available():
    raise RuntimeError("CUDA is unavailable; check the assigned GPU and environment")
print(torch.cuda.get_device_name(0))
model = torch.nn.Linear(8, 1).cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
x, y = torch.randn(16, 8, device="cuda"), torch.randn(16, 1, device="cuda")
optimizer.zero_grad()
loss = torch.nn.functional.mse_loss(model(x), y)
loss.backward()
optimizer.step()
torch.save({"step": 1, "model": model.state_dict(),
            "optimizer": optimizer.state_dict()}, "checkpoint.pt")
print(Path("checkpoint.pt").stat().st_size)

3. Keep an external copy

Save the notebook. In the file browser, right-click the ipynb and checkpoint.pt files and select Download. Saving a notebook on local disk is not an external backup. For long jobs, regularly copy checkpoints to private external storage and test restoring a sample before relying on it. Load only trusted checkpoints; notebooks and untrusted model files can execute code.

Troubleshooting and access boundaries

• CUDA unavailable: check the assigned app and GPU. Send non-sensitive diagnostic output in a support ticket. Installing several unrelated CUDA versions is not a reliable repair.
• Out of memory: reduce batch size, inputs or model size. Training and inference have different memory requirements.
• Browser disconnected: reopen the app from Console and check the kernel and last checkpoint. Browser disconnection does not establish that execution or billing stopped.
• FastAPI or a worker: running uvicorn on a local port does not expose a public HTTPS API. Confirm the external route and timeout limits with support before designing around them.
• Disk space: remove old outputs only after verifying an external copy. Recreating the environment can lose local data.

Finish and choose the appropriate product

Download your files, use the panel’s stop or cancel action and verify its result. For Django or Flask websites, compare Python hosting. For full operating-system and port control, consider an hourly VPS. For the ready-made image-generation package, read the ComfyUI guide.

The example uses the standard PyTorch API. Live GPU execution and external checkpoint transfer have not been tested for this guide; no runtime or cost is claimed. File interface reference: JupyterLab documentation.