DEV Community: Lawson Dong

Managing My First AI Experiment: Checkpoints, Logs, and Python Virtual Environments

Lawson Dong — Sun, 11 Oct 2026 20:46:07 +0000

In my previous note, I set up Ubuntu with WSL 2, created a Python virtual environment, trained a small XOR neural network with PyTorch, and saved its parameters.

This time, I wanted to make that experiment easier to manage: organize the model files, save the training output, and understand what actually changes when I activate a virtual environment.

This is a hands-on continuation using the same project, ~/research/first-neural-network. You will need the existing train.py, .venv, and xor_model.pth from the previous tutorial.

1. Open Ubuntu and return to the project

Start a new Windows Command Prompt. It may initially look like this:

Enter:

wsl -d Ubuntu

The prompt now belongs to Ubuntu:

Notice that WSL may initially open in a mounted Windows directory, such as /mnt/c/Users/linxi. Navigate to the Linux project explicitly:

cd ~/research/first-neural-network
pwd
ls -la

cd changes the current working directory.
pwd prints its absolute path.
ls -la lists the directory contents in detail, including hidden entries such as .venv.

2. Organize the model files

I wanted to separate the Python environment, model parameters, and training logs:

Create two directories and copy the existing model file:

mkdir -p checkpoints logs      # Create both directories if they do not exist
cp xor_model.pth checkpoints/  # Copy the saved parameters into checkpoints/
ls checkpoints                # List the files in checkpoints/

Seeing xor_model.pth in the output confirms that the file is present in checkpoints/. In this project, it stores the trained model's parameters, including weights and biases, saved by PyTorch. The .pth extension alone does not tell us what every PyTorch file contains; that depends on what the training script saved.

Because I used cp, the original file is still in the project root:

These are two separate files. If train.py saves a new xor_model.pth in the project root later, the copy in checkpoints/ will not update automatically. For now, that copy is a snapshot of the earlier run.

Inspect the file sizes

ls -lh xor_model.pth checkpoints/xor_model.pth

You can write -lh as -l -h:

-l uses the long listing format, showing permissions, owner, size, modification time, and filename.
-h displays sizes in human-readable units, such as K, M, and G.

The size is one field in a longer line of file information:

Here are the two files side by side:

Matching displayed sizes are a useful quick check, although they do not prove that two files have identical contents.

3. Activate the Python environment

Before running the training script, activate the project's existing environment:

source .venv/bin/activate

source executes the activation script in the current shell. Activation puts .venv/bin at the beginning of the shell's PATH, so commands such as python and pip use the project's environment.

Install NumPy if the project needs it

NumPy is a Python package, not a separate environment. To install it into this virtual environment and check its version:

python -m pip install numpy
python -c "import numpy; print(numpy.__version__)"

The version attribute is __version__, with two underscores on each side. Using python -m pip runs pip with the same Python interpreter selected by python.

Installing NumPy may resolve a missing-NumPy warning from PyTorch, but NumPy is not required to read a text log. We will use Linux commands for that.

4. Save the training output to a log

Run the training script and capture its output:

python train.py > logs/training.log 2>&1

There are two main output streams:

Standard output (stdout, descriptor 1): ordinary output, such as printed epoch numbers and losses.
Standard error (stderr, descriptor 2): errors, warnings, and other diagnostic output.

> logs/training.log sends standard output to the file. Then 2>&1 sends standard error to the same destination as standard output. The order matters: redirect standard output first, then make standard error follow it.

The terminal may appear quiet while training runs because the output is going into the file. The command returns to the shell prompt when the script finishes.

Each run with > overwrites the existing log. To append instead, use:

python train.py >> logs/training.log 2>&1

A log records what the program writes; it does not automatically save the trained model. Model saving still depends on the code in train.py.

5. Read and monitor the training log

After training finishes, display the log:

cat logs/training.log

cat is short for concatenate. It can combine files, and when given a single file, it prints that file's contents directly in the terminal.

For longer logs, these commands are useful:

head logs/training.log       # Show the first 10 lines
tail -n 5 logs/training.log # Show the last 5 lines
less logs/training.log       # Browse the file interactively; press q to quit

Here is a screenshot from my session, showing a NumPy installation followed by the training log:

Installing a package after a run does not change a warning already recorded in that run's log. To capture a new run with the updated environment, run the training command again.

Follow a longer training run

For a long experiment, use a second terminal to watch new log lines arrive.

In the first terminal, start training with unbuffered Python output:

cd ~/research/first-neural-network
source .venv/bin/activate
python -u train.py > logs/training.log 2>&1

-u makes Python's output unbuffered, which helps printed progress appear promptly in a redirected log.

In a second Windows Command Prompt, enter Ubuntu and follow the file:

wsl -d Ubuntu
cd ~/research/first-neural-network
tail -f logs/training.log

tail -f displays the last 10 lines and continues showing newly appended content. Press Ctrl+C in the monitoring terminal to stop following the log; training in the first terminal continues.

6. Understand the virtual environment and the file system

A Python virtual environment gives a project its own installed packages and access to a Python interpreter through the environment's executables. In this project, .venv is simply a directory inside first-neural-network.

The important paths are:

Path	Purpose
`.venv/bin/python`	Python interpreter executable, which may be a copy or symbolic link
`.venv/bin/pip`	Python package installer entry point
`.venv/bin/activate`	Shell script used to activate the environment
`.venv/lib/pythonX.Y/site-packages/`	Installed Python packages; `X.Y` depends on the Python version
`train.py`	Neural network training script
`xor_model.pth`	Model parameter file originally saved in the project root
`checkpoints/xor_model.pth`	Separate copy of that parameter file
`logs/training.log`	Recorded training output

Activating .venv does not change your working directory or prevent Python and the shell from accessing the rest of the project. It is not a separate Linux file system or a file-access sandbox.

Experiment: check what activation changes

Start with a fresh Ubuntu shell, or run deactivate first if the environment is already active. Then execute this block:

# Step 1: Navigate to the project directory
cd ~/research/first-neural-network

# Step 2: Check the current directory and Python executable
pwd
which python3

# Step 3: Activate the virtual environment
source .venv/bin/activate

# Step 4: Check the directory, Python executable, and model file again
pwd
which python
ls xor_model.pth

Observations:

pwd prints the same path before and after activation, showing that the current working directory has not changed.
which python now points to the executable inside the project's .venv/bin/ directory.
ls xor_model.pth still finds the model file in the project root.

Conclusion: Activating a Python virtual environment changes which Python executable and project packages are used. It does not create a separate Linux file system or change the current working directory.

To exit the environment:

deactivate

The project files and saved logs remain where they were.

References

Training My First Neural Network on Windows with WSL 2 and PyTorch

Lawson Dong — Sun, 11 Oct 2026 05:13:48 +0000

As a physics undergraduate beginning to explore AI research, I wanted to understand the practical workflow behind a neural network experiment: where the code lives, how the environment works, how to run training, and what gets saved afterward.

This tutorial brings together my setup notes and first PyTorch experiment. We will build a small network for XOR, starting from a Windows computer and ending with a saved model file. The focus is on getting the workflow running; the mathematics can come later.

You need a supported Windows 10 or Windows 11 installation, permission to install WSL, and an internet connection. A GPU is unnecessary for this four-example experiment.

1. Understand the tools before installing them

The workflow is Windows terminal → WSL 2 → Ubuntu → project folder → Python virtual environment → PyTorch → training results.

Tool	Role in this experiment
CMD / PowerShell	Launches WSL from Windows
WSL 2	Runs a Linux kernel using lightweight virtualization
Ubuntu	Provides the Linux operating environment
APT	Installs Ubuntu system packages
Python	Executes our training script
venv	Isolates the project's Python dependencies
pip	Installs packages inside that environment
PyTorch	Provides tensors, neural network layers, and automatic differentiation

Docker is an optional next step for packaging environments. Ordinary Ubuntu and PyTorch development works without Docker Desktop running.

2. Install and launch Ubuntu

Run these commands in Windows CMD or PowerShell:

wsl -l -v

On my machine, the only listed distribution was initially docker-desktop. That did not mean I already had an Ubuntu development environment.

To install Ubuntu, open PowerShell as administrator and run:

wsl --install -d Ubuntu

Restart Windows if prompted. On Ubuntu's first launch, create a Linux username and password. The password input displays no characters or asterisks.

Check the installation from Windows:

wsl -l -v

Confirm that Ubuntu is listed with VERSION 2. If it uses version 1, run:

wsl --set-version Ubuntu 2

Optionally make Ubuntu the default, then launch it:

wsl --set-default Ubuntu
wsl -d Ubuntu

For installation requirements and troubleshooting, see Microsoft's WSL installation guide.

3. Find your Linux home directory

From this point onward, commands run inside Ubuntu, unless explicitly labeled otherwise.

A terminal prompt might look like:

lawson@computer:~$

lawson is the Linux username, computer is the hostname, and ~ means the user's home directory. Do not copy the prompt itself when running commands.

Your Linux home directory is typically /home/<username>. Windows drives are accessible through paths such as /mnt/c/. For this experiment, keep the project in your Linux home directory.

cd ~
pwd
ls

Command	What it does
`pwd`	Prints the current working directory
`ls`	Lists directory contents
`cd`	Changes directories
`mkdir`	Creates directories
`touch`	Creates an empty file or updates its timestamps
`cat`	Displays or combines file contents
`sudo`	Runs a command as another user, usually root

4. Install system tools with APT

APT manages Ubuntu packages. Refresh its package information and install the tools we need:

sudo apt update
sudo apt install -y git python3 python3-pip python3-venv nano

Then check:

python3 --version
git --version

APT handles system software; pip handles Python packages. In the following steps, pip installs packages into our project environment.

5. Create a project and virtual environment

cd ~
mkdir -p research/first-neural-network
cd research/first-neural-network
pwd

The path should end with research/first-neural-network.

The diagram's version numbers are examples: each project can manage its own dependencies independently.

Create and activate the environment:

python3 -m venv .venv
source .venv/bin/activate

Your prompt should now begin with (.venv). Closing the terminal leaves this directory on disk; you will reactivate it in the next session.

6. Install and verify PyTorch

With .venv active, install a CPU build of PyTorch and NumPy:

python -m pip install --upgrade pip
python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
python -m pip install numpy

Check PyTorch's official installation selector for supported Python versions or a GPU-specific installation command.

Verify the installation:

python -c "import torch, numpy; print('PyTorch:', torch.__version__); print('NumPy:', numpy.__version__)"
python -c "import torch; print(torch.rand(2, 2))"

The second command should print a random 2 × 2 tensor. In my original setup, tensor creation worked but PyTorch warned that NumPy was missing. Installing NumPy resolved that missing dependency.

7. Write the training script

Our task is XOR: output 1 when the two inputs differ and 0 when they match.

Input	Target
`[0, 0]`	`0`
`[0, 1]`	`1`
`[1, 0]`	`1`
`[1, 1]`	`0`

Open a new file:

nano train.py

Paste this code:

import torch
import torch.nn as nn

torch.manual_seed(42)

# 1. Training data
X = torch.tensor([
    [0., 0.],
    [0., 1.],
    [1., 0.],
    [1., 1.]
])
y = torch.tensor([[0.], [1.], [1.], [0.]])

# 2. A small network: two inputs, four hidden units, one output
model = nn.Sequential(
    nn.Linear(2, 4),
    nn.Tanh(),
    nn.Linear(4, 1)
)

# 3. Loss and optimizer
criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.05)

# 4. Training
model.train()
for epoch in range(2001):
    optimizer.zero_grad()
    logits = model(X)
    loss = criterion(logits, y)
    loss.backward()
    optimizer.step()

    if epoch % 200 == 0:
        print(f"Epoch {epoch}, Loss: {loss.item():.6f}")

# 5. Inspect predictions on the four training examples
model.eval()
with torch.no_grad():
    probabilities = torch.sigmoid(model(X))
    predicted_labels = (probabilities >= 0.5).int()
    print("\nProbabilities:")
    print(probabilities)
    print("\nPredicted labels:")
    print(predicted_labels)

# 6. Save learned parameters
torch.save(model.state_dict(), "xor_model.pth")
print("\nSaved weights to xor_model.pth")

Save with Ctrl + O, press Enter, and exit with Ctrl + X.

The loop computes predictions, measures the error, computes gradients, and updates parameters. BCEWithLogitsLoss takes the network's raw output, so the sigmoid is applied when inspecting probabilities afterward.

This is a small network with one hidden layer. It is a first neural network training exercise, rather than a large-scale deep learning experiment.

8. Run training and inspect the result

python train.py

One mistake I made was trying torch train.py. PyTorch is a Python library; Python executes the file.

You should see periodic loss reports, followed by probabilities and labels. Check that the loss trends downward and the predicted labels are:

tensor([[0],
        [1],
        [1],
        [0]], dtype=torch.int32)

Exact probabilities and loss values can vary with software versions. These predictions use the same four examples used for training, so they check that the network learned the XOR truth table; they do not measure generalization to a separate dataset.

Check the files:

ls -lh train.py xor_model.pth

xor_model.pth contains the model's parameter state dictionary. It does not contain the training script or a complete experiment checkpoint. To restore these weights later, recreate the same architecture and load the state dictionary; see PyTorch's saving and loading tutorial.

9. Resume the project next time

In Windows CMD or PowerShell:

wsl -d Ubuntu

Inside Ubuntu:

cd ~/research/first-neural-network
source .venv/bin/activate
python train.py

This runs training again from newly initialized weights. It does not resume the previously saved model automatically.

To leave the environment, run deactivate. To leave Ubuntu, run exit. An active foreground process may terminate if its terminal closes, but files already saved remain on disk.

10. Common setup mistakes

Problem	Fix
`torch: command not found`	Run `python train.py`
`No module named 'torch'`	Activate `.venv`, then install PyTorch with that environment's Python
`No module named 'numpy'`	Run `python -m pip install numpy` in `.venv`
`train.py` prints nothing	Check that the file contains and saves the code
`wsl -l -v` fails inside Ubuntu	Run it from Windows, or use `wsl.exe -l -v` inside Ubuntu
Docker Desktop is stopped	Docker is optional for this experiment
The terminal was closed	Reopen Ubuntu, return to the folder, and reactivate `.venv`

11. Where this fits in a research workflow

This diagram from my notes shows a possible later setup with Docker and GPU acceleration. Those components are optional extensions beyond the CPU workflow used here.

For larger experiments, I want to connect local development and version control with remote compute, then keep model weights, metrics, figures, and logs together. Access to university computing platforms depends on their own eligibility and allocation rules.

The useful milestone here is modest but concrete: a project directory, isolated dependencies, an executable training script, inspectable predictions, and saved parameters.

My notes and projects: GitHub · Personal website