Set up for Unit 3: neural network tools and an SAP BTP trial

#The 60-second version

Unit 3 moves from classic machine learning to neural networks and embeddings. A neural network is a model built from many small, adjustable pieces. An embedding is a list of numbers that captures what a piece of text means, so a computer can tell that "order on credit hold" and "sales order blocked for credit" are about the same thing.

Learners need two new free Python libraries for this. PyTorch builds and trains neural networks. Sentence Transformers turns text into embeddings with a small ready-made model.

Learners also create a free SAP BTP trial account. SAP Business Technology Platform (BTP) is where SAP customers build and run their own extensions and AI services. The last topic of Unit 3 explains how it is organized, and later units build on it. As of September 2026 the trial is free for up to 90 days, and anyone can sign up with an email address. Your company may still have its own rules about that.

Setup takes 45 to 60 minutes, mostly downloads and waiting for the trial to be created.

#Why it matters to the business

Embeddings are behind most enterprise AI that "understands" text: searching product master data by meaning, finding similar past tickets, and giving a chatbot the right documents. Unit 3 builds a small semantic search over SAP-style master data. Later units grow that into grounded assistants.

The BTP trial matters for a different reason. Almost every SAP AI service a team will buy or build on sits in a BTP account. People who have clicked through a BTP account understand quotes, architecture diagrams and project plans faster. Terms such as global account, subaccount and entitlement stop being abstract.

Two points for a leader:

• The trial is for learning only. SAP's documentation says a trial account must not be used for production or team development. It is deleted after 90 days, with everything in it.
• Company data stays out. Everything in Unit 3 uses made-up data. Nothing from your SAP systems should go into a personal trial.

#How SAP does it

The open tools in this unit are the same kind SAP's own data scientists use. SAP BTP offers two ways to try the platform, and they are often confused:

• Trial account: free, time-limited, for individuals exploring the platform. As of September 2026 it lasts up to 90 days. Anyone can sign up at sap.com.
• Free tier: free service plans inside a paid BTP contract (Pay-As-You-Go or an enterprise agreement, CPEA). It has no time limit and projects can move to production.

This course uses the trial, because it needs no contract. Later units check, at the time they are written, which AI services each option includes.

#What this unit adds

#Time and money

• Time: 45 to 60 minutes. PyTorch is a large download. The trial account takes a few minutes to be created.
• Money: nothing. No credit card is part of the trial steps SAP describes.
• Disk space: plan for a few gigabytes free. On Linux, installing PyTorch the default way pulls a much larger GPU build; the deep layer shows the smaller CPU command.
• The trial clock: 90 days from sign-up. If a learner doesn't sign in for 30 days, the account is suspended. A learner who pauses the course for months can simply create a new trial later.

#Questions to ask IT

• Can learners download from pypi.org, download.pytorch.org and huggingface.co, or is there an internal mirror?
• May learners sign up for an SAP BTP trial, and with a personal or a work email address?
• Does the company network allow the SAP BTP trial sites (*.hanatrial.ondemand.com)?
• Do learner laptops have a few gigabytes of free disk space?
• If the company already has a BTP contract, is there a free-tier or sandbox subaccount learners could use later instead of a trial?

#Common misconceptions

• "Neural networks need a GPU." Not for this course. Unit 3's networks and the small embedding model run on any recent laptop. Unit 4's setup explains when a GPU helps.
• "The BTP trial is the same as the free tier." No. The trial is time-limited and for individuals. The free tier sits inside a paid contract and can go to production.
• "We can pilot on the trial." SAP's documentation rules out production use and team development. Use it to learn, then pilot in a proper account.
• "The embedding model sends our text to a cloud service." Not here. The model is downloaded once and runs on the laptop.

#Key terms

• Neural network: a model made of layers of simple units whose weights are adjusted during training.
• Embedding: a list of numbers that represents the meaning of a text, so similar meanings get similar numbers.
• SAP BTP: SAP Business Technology Platform, where SAP customers build and run extensions and AI services.
• Global account: your contract with SAP in BTP. In a trial, SAP creates one for you.
• Subaccount: a space inside the global account, in one region, where services actually run.
• Entitlement: the right to use a service in a subaccount; the basis of billing in a paid account.

#Check yourself

#Mental model: two new libraries on your laptop, one new account in the cloud

Your course folder stays the same: one .venv, one requirements.txt, one Git repository. This unit adds two libraries to that folder and one thing outside it: an SAP BTP trial account that lives in SAP's cloud and that you reach through a web page called the cockpit.

flowchart LR
  T[PyTorch CPU build] --> V[.venv<br/>course Python]
  S[sentence-transformers] --> V
  V --> H[hello_torch.py]
  M[Embedding model<br/>downloaded once] --> H
  B[SAP BTP trial<br/>in SAP's cloud] --> N[btp_trial_notes.md]
  H --> C[check_unit03.py]
  N --> C

Nothing on your laptop talks to the BTP trial in this unit. You explore the trial in the browser and write down what you find. The Unit 3 topic on BTP foundations uses those notes.

#How it works

#PyTorch and the CPU build

PyTorch comes in two kinds of builds. A GPU build (also called a CUDA build) can use an NVIDIA graphics card to train faster. A CPU build uses only the normal processor. The CPU build is much smaller, and it is all this course needs until Unit 4.

Which build you get depends on your system and where pip downloads from:

As of September 2026 the latest PyTorch release is 2.14.0 and needs Python 3.10 or newer. Your course Python from Unit 2 (3.11 or newer) meets that. PyPI lists macOS wheels only for Apple silicon Macs on macOS 14 or newer.

The --index-url option tells pip to download from PyTorch's own server instead of PyPI. That server has a separate copy of each release built for CPU only.

#Sentence Transformers and the model download

Sentence Transformers is a library that loads a ready-made embedding model and turns texts into vectors with one call: model.encode(texts). It depends on PyTorch and on Hugging Face's transformers library, and pip installs those for you.

The library itself contains no model. The first time you ask for one, it downloads it from Hugging Face, a public site that hosts open models. This course uses all-MiniLM-L6-v2, the model in the library's own quick-start example. It turns each text into 384 numbers. After the first download, the copy on your computer is used, so it also works offline.

#The SAP BTP trial account model

A paid SAP BTP account and a trial account use the same structure. SAP Learning describes it like this:

• A global account represents your contract with SAP. In the trial, SAP creates one for you.
• Directories (optional) group subaccounts, for example by department or region.
• A subaccount runs in exactly one region (a data center location). Services and apps live here. Your trial gets one subaccount, named trial.
• Entitlements say which services, and how much of each, a subaccount may use.

Inside the trial subaccount, SAP also sets up the Cloud Foundry environment, a runtime for apps. It has one org, linked one-to-one to the subaccount, and one space named dev where apps are deployed.

You find services in the Service Marketplace. Creating one gives you either a service instance (used by an app you deploy) or a subscription (a ready-made application that runs on its own). Both then appear under Instances and Subscriptions.

As of September 2026, SAP's documentation sets these trial rules:

#Build it yourself: add the Unit 3 tools and open your BTP trial

You will install PyTorch and Sentence Transformers, run a short script that trains one "neuron" and compares SAP-style texts by meaning, then create your SAP BTP trial and tour its cockpit. A check script confirms everything at the end.

Before you start: complete Set up your computer for this course and Set up for Unit 2. They install Python, VS Code and Git, create your orchestrate-course folder with its .venv, and add the data libraries. This walkthrough doesn't repeat those steps.

#What you need

• Your course folder from Units 1 and 2.
• About 45 to 60 minutes and an internet connection.
• A few gigabytes of free disk space.
• An email address for the SAP account. The trial is free; no payment details are part of SAP's trial steps.

#Step 1: Open your course folder and turn on the virtual environment

1. Open VS Code, choose File > Open Folder, and open orchestrate-course.

2. Open a terminal: Terminal > New Terminal.

3. If the prompt doesn't start with (.venv), turn it on:

   • Windows (PowerShell):

     Copy

     .venv\Scripts\Activate.ps1

   • macOS / Linux:

     Copy

     source .venv/bin/activate

#Step 2: Install PyTorch (CPU build)

Run the one command for your system, with (.venv) showing:

• Windows (PowerShell):

  Copy

  pip install torch

• macOS:

  Copy

  pip install torch

• Linux:

  Copy

  pip install torch --index-url https://download.pytorch.org/whl/cpu

Wait for a line starting Successfully installed. This is a large download and can take several minutes.

#Step 3: Add Sentence Transformers and update requirements.txt

1. In VS Code, open requirements.txt and add these two lines below the existing ones:

   Copy

   torch
   sentence-transformers

2. Save the file (Ctrl+S, or Cmd+S on Mac).

3. Run:

   Copy

   pip install -r requirements.txt

4. Wait for Successfully installed. Lines saying Requirement already satisfied for torch and the Unit 2 libraries are expected: the CPU build from Step 2 is kept.

#Step 4: Make the Unit 3 folder

From your course folder:

• Windows (PowerShell):

  Copy

  New-Item -ItemType Directory -Force unit03
  cd unit03

• macOS / Linux:

  Copy

  mkdir -p unit03
  cd unit03

#Step 5: Run the PyTorch smoke test

The script trains the smallest possible neural network, one neuron, to learn the rule y = 2x + 1 from 20 noisy made-up points. It is the gradient descent you did by hand in Unit 2, but PyTorch works out the gradients for you. With --embed, it also compares SAP-style texts by meaning.

1. In VS Code's file list, right-click unit03, choose New File and name it hello_torch.py.

2. Paste the code below and save.

3. In the terminal, inside unit03, run:

   Copy

   python hello_torch.py

"""Unit 3 smoke test: train a one-neuron network with PyTorch, then (optionally) compare
SAP-style texts with an embedding model.

How to run (from the unit03 folder, with the course .venv turned on):
    python hello_torch.py            # PyTorch only, no download, no account
    python hello_torch.py --embed    # also download a small embedding model (one time) and compare texts

All data is made up.
"""
import argparse

import torch

QUERY = "Sales order blocked: customer over credit limit"
CANDIDATES = [  # made-up texts, shaped like notes on SAP documents
    "Order on credit hold until finance releases it",
    "Purchase order price differs from the invoice",
    "Planned order is late because a component is missing",
    "Pallet of M8 screws, zinc plated",
]


def train_one_neuron(steps: int = 500) -> None:
    """Learn y = 2x + 1 from 20 noisy points with gradient descent, the PyTorch way."""
    torch.manual_seed(0)                          # same "random" numbers every run
    x = torch.linspace(0, 1, 20).unsqueeze(1)     # 20 inputs, shape (20, 1)
    y = 2 * x + 1 + 0.05 * torch.randn(x.shape)   # true rule plus a little noise

    model = torch.nn.Linear(1, 1)                 # one neuron: y = w*x + b
    optimizer = torch.optim.SGD(model.parameters(), lr=0.5)
    loss_fn = torch.nn.MSELoss()

    for step in range(steps + 1):
        optimizer.zero_grad()                     # forget last step's gradients
        loss = loss_fn(model(x), y)               # how wrong are we?
        loss.backward()                           # PyTorch works out the gradients
        optimizer.step()                          # nudge w and b downhill
        if step % 100 == 0:
            print(f"  step {step:3d}  loss {loss.item():.4f}")

    w, b = model.weight.item(), model.bias.item()
    print(f"Learned w = {w:.2f}, b = {b:.2f}  (the true rule was w = 2, b = 1)")


def compare_texts(model_name: str) -> None:
    """Turn texts into embeddings (lists of numbers) and rank them by similarity to QUERY."""
    from sentence_transformers import SentenceTransformer  # imported here so the default run skips it

    print(f"\nLoading embedding model {model_name} (downloads once, then uses the copy on disk)...")
    model = SentenceTransformer(model_name)
    vectors = model.encode([QUERY] + CANDIDATES)
    print(f"Each text became {vectors.shape[1]} numbers.")
    scores = model.similarity(vectors[:1], vectors[1:])[0]  # QUERY against each candidate
    print(f"\nMost similar to: '{QUERY}'")
    for score, text in sorted(zip(scores.tolist(), CANDIDATES), reverse=True):
        print(f"  {score:5.2f}  {text}")


def main() -> None:
    parser = argparse.ArgumentParser(description="Unit 3 smoke test: PyTorch and embeddings.")
    parser.add_argument("--embed", action="store_true", help="also run the embedding comparison")
    parser.add_argument("--model", default="sentence-transformers/all-MiniLM-L6-v2",
                        help="embedding model to use with --embed")
    args = parser.parse_args()

    print(f"PyTorch {torch.__version__}, running on: CPU")
    print("Training one neuron on made-up points:")
    train_one_neuron()
    if args.embed:
        compare_texts(args.model)
    else:
        print("\nSkipped the embedding test. Run with --embed to try it.")


if __name__ == "__main__":
    main()

What success looks like:

PyTorch 2.14.0+cpu, running on: CPU
Training one neuron on made-up points:
  step   0  loss 2.7650
  step 100  loss 0.0019
  step 200  loss 0.0019
  step 300  loss 0.0019
  step 400  loss 0.0019
  step 500  loss 0.0019
Learned w = 2.10, b = 0.97  (the true rule was w = 2, b = 1)

Skipped the embedding test. Run with --embed to try it.

The loss drops quickly and then stays flat: the neuron has learned as much as the noisy points allow. That is why w is 2.10, not exactly 2. The version text after PyTorch differs by system, for example 2.14.0 on Windows and macOS or 2.14.0+cpu on Linux. The loss numbers may differ slightly between versions and systems; what matters is that the loss falls and w and b end near 2 and 1.

#Step 6: Run the embedding test

1. Still inside unit03, run:

   Copy

   python hello_torch.py --embed

2. The first run downloads the model from Hugging Face. You may see progress bars. No account or key is needed.

What success looks like (after the PyTorch lines):

Loading embedding model sentence-transformers/all-MiniLM-L6-v2 (downloads once, then uses the copy on disk)...
Each text became 384 numbers.

Most similar to: 'Sales order blocked: customer over credit limit'
  0.xx  Order on credit hold until finance releases it
  0.xx  ...
  0.xx  ...
  0.xx  Pallet of M8 screws, zinc plated

Your scores are real numbers in place of 0.xx, sorted from most to least similar. Expect the credit-hold text at or near the top and the screws at the bottom: the first is about the same business problem, the last is product master data. Run it a second time; it starts faster because the model is already on disk.

If the download fails (for example, a company network blocks Hugging Face), Step 5 still proves PyTorch works. Try Step 6 again on another network. The Unit 3 embeddings topic needs it.

What each part of the script does:

#Step 7: Create your SAP BTP trial account

1. If you don't have an SAP account yet: open https://www.sap.com, click Log On in the upper-right corner, then Register. Fill in the required fields and click Submit.
2. Open your email and click the activation link SAP sent you.
3. Open the trial page: https://www.sap.com/products/technology-platform/trial.html. Click Try Now and follow the instructions on screen.
4. When sign-up is complete, open the trial cockpit: https://cockpit.hanatrial.ondemand.com/trial/. Bookmark it; this is how you get back.
5. The cockpit asks you to choose a region. Pick one near you from the list it shows.
6. Click Create Account. A dialog shows progress while SAP sets up your trial. This can take a few minutes.
7. When it finishes, click Continue.
8. You now see your trial global account. Click the tile named trial to open your subaccount.

#Step 8: Tour the cockpit and write your notes

You will look around your trial and write down what you find in a notes file. None of this is secret, but it is personal to your account, so keep it in your course folder.

1. In VS Code, create btp_trial_notes.md inside unit03 and paste this template:

   Copy

   # My SAP BTP trial
   
   - Created on:
   - Region:
   - Global account name:
   - Subaccount name: trial
   - Cloud Foundry API endpoint:
   - Cloud Foundry org name:
   - Space(s):
   - Three services in the Service Marketplace that mention AI or machine learning:
   - Anything in Instances and Subscriptions already:

2. In the cockpit, on the subaccount page (Overview), find the Cloud Foundry section. Copy the API endpoint and the org name into your notes.

3. Find the Spaces section. You should see one space named dev. Write it down.

4. Note the region shown for the subaccount.

5. In the left menu, open Services > Service Marketplace. Type AI in the search box. Write down up to three service names you see. If none appear, write "none found"; that is a valid result too.

6. Open Services > Instances and Subscriptions. In a new trial it may be empty; write "empty" if so.

7. Look at the breadcrumbs at the top of the page. Click Trial Home or the global account name to go up a level, then open the trial tile again. This is how you move between the global account and the subaccount.

8. Don't click Enable Kyma, Delete Trial or anything that creates services yet. Later units tell you when to.

9. Save the notes file.

#Step 9: Run the Unit 3 check

1. Go back to your course folder in the terminal:

   Copy

   cd ..

2. In VS Code, create a new file in the course folder (not in unit03), paste the script below and save it as check_unit03.py.

3. Run it:

   Copy

   python check_unit03.py

"""Check that your computer is ready for Unit 3 (neural networks and embeddings).

Run it from your course folder:  python check_unit03.py
It only reads your setup and opens two web pages to test your network.
It installs nothing and sends none of your files or keys anywhere.
"""
import importlib.metadata
import importlib.util
import os
import subprocess
import sys
import urllib.error
import urllib.request

problems = 0


def report(ok: bool, label: str, fix: str = "", optional: bool = False) -> None:
    """Print one line: OK, MISSING (must fix) or LATER (optional for now)."""
    global problems
    if ok:
        print(f"  OK       {label}")
    elif optional:
        print(f"  LATER    {label}  ->  {fix}")
    else:
        problems += 1
        print(f"  MISSING  {label}  ->  {fix}")


def version_of(package: str) -> str:
    try:
        return importlib.metadata.version(package)
    except importlib.metadata.PackageNotFoundError:
        return ""


def reachable(url: str) -> bool:
    """True if the site answers at all (any HTTP status counts; we only test the network)."""
    try:
        urllib.request.urlopen(urllib.request.Request(url, method="HEAD"), timeout=15)
        return True
    except urllib.error.HTTPError:
        return True   # the site answered, even if with an error page
    except Exception:
        return False


print("\n1. Python")
v = sys.version_info
report(v >= (3, 11), f"Python {v.major}.{v.minor}.{v.micro}",
       "the course needs Python 3.11 or newer (see Set up for Unit 2, Step 1)")
report(sys.prefix != sys.base_prefix, "virtual environment is active", "activate .venv (Step 1)")

print("\n2. Libraries")
for module, package in [("torch", "torch"), ("sentence_transformers", "sentence-transformers")]:
    found = importlib.util.find_spec(module) is not None
    label = f"{package} {version_of(package)}".strip()
    report(found, label, "install it (Steps 2 and 3)")

print("\n3. PyTorch works")
# Run a tiny calculation with gradients in a fresh Python. This catches broken installs.
test = (
    "import torch;"
    "w = torch.tensor(3.0, requires_grad=True);"
    "(w * w).backward();"
    "assert abs(w.grad.item() - 6.0) < 1e-6;"
    "print(torch.version.cuda or '')"
)
try:
    result = subprocess.run([sys.executable, "-c", test], capture_output=True, text=True, timeout=180)
    ok = result.returncode == 0
    detail = (result.stderr.strip().splitlines() or ["unknown error"])[-1] if not ok else ""
    gpu_build = ok and bool(result.stdout.strip())
except subprocess.TimeoutExpired:
    ok, detail, gpu_build = False, "timed out", False
report(ok, "tensor maths and gradients", f"{detail}; reinstall PyTorch (Step 2)")
if ok:
    report(not gpu_build, "CPU build of PyTorch",
           "you have the larger GPU (CUDA) build; it works, but the CPU build saves gigabytes (Step 2)",
           optional=True)

print("\n4. Network")
report(reachable("https://huggingface.co"), "can reach huggingface.co (embedding model download)",
       "ask IT to allow huggingface.co, or use another network", optional=True)
report(reachable("https://cockpit.hanatrial.ondemand.com"), "can reach the SAP BTP trial site",
       "ask IT to allow *.hanatrial.ondemand.com, or use another network", optional=True)

print("\n5. Course folder")
report(os.path.isdir("unit03"), "unit03 folder", "create it (Step 4)", optional=True)
report(os.path.exists(os.path.join("unit03", "hello_torch.py")), "unit03/hello_torch.py",
       "create it (Step 5)", optional=True)
report(os.path.exists(os.path.join("unit03", "btp_trial_notes.md")), "unit03/btp_trial_notes.md",
       "write it during the cockpit tour (Step 8)", optional=True)

print()
if problems:
    print(f"{problems} item(s) to fix. Fix them in order, then run this again.")
    sys.exit(1)
print("All set. Your computer is ready for Unit 3.")

What success looks like:

1. Python
  OK       Python 3.11.15
  OK       virtual environment is active

2. Libraries
  OK       torch 2.14.0
  OK       sentence-transformers 6.1.0

3. PyTorch works
  OK       tensor maths and gradients
  OK       CPU build of PyTorch

4. Network
  OK       can reach huggingface.co (embedding model download)
  OK       can reach the SAP BTP trial site

5. Course folder
  OK       unit03 folder
  OK       unit03/hello_torch.py
  OK       unit03/btp_trial_notes.md

All set. Your computer is ready for Unit 3.

Your version numbers may differ; that is fine as long as each line says OK. A LATER line doesn't stop you:

• LATER CPU build of PyTorch means you have the GPU build. It works; it only uses more disk. To switch on Linux, run pip uninstall torch, then the Step 2 command.
• LATER can reach ... means your network blocked that site when the check ran. Try another network, or ask IT.

What each part of the check does:

Like the earlier checks, it uses only Python's built-in modules and changes nothing.

#Step 10: Save your work in Git

From the course folder:

git add requirements.txt check_unit03.py unit03/hello_torch.py unit03/btp_trial_notes.md
git commit -m "Set up Unit 3: PyTorch, embeddings, BTP trial"

The downloaded model is not in your course folder, so nothing large goes into Git.

#If something goes wrong

#Where this shows up in SAP

The trial account you created has the same shape as a customer's paid BTP account: a global account, subaccounts in regions, entitlements, and services from the marketplace. When a customer's architect says "we'll provision it in the AI subaccount in the EU region", you now know what that means and where it lives in the cockpit.

The difference is the contract. A trial is free, isolated and deleted after 90 days. A customer's account is a contract with SAP, where entitlements drive the bill. SAP also offers a free tier: free service plans inside a Pay-As-You-Go or CPEA contract, with no time limit and a path to production. When a project needs to go past learning, ask whether the customer's account has free-tier plans for the service in question before anyone buys a paid plan.

Embeddings show up in SAP too. Units 5 and 7 look at SAP's own options for embedding models and vector search, and compare them with the open model you downloaded here.

#Pitfalls

• The GPU build by accident. On Linux, a plain pip install torch, or recreating .venv from requirements.txt alone, fetches the large GPU build. Run the CPU command first.
• Letting the trial lapse. Thirty days without signing in suspends the trial. Sign in now and then, and keep your notes, so a new trial is quick to set up.
• Treating the trial as a team sandbox. SAP's rules exclude team development and production use. Share what you learn, not the account.
• Company data in the trial or the model. Everything in Unit 3 is made up. Keep it that way in a personal account.
• Forgetting the daily stop. Apps in the trial stop around midnight in your region. If something you deployed "disappeared" the next day, restart it.
• Assuming the embedding model knows SAP terms. It is a general-purpose model. It knows that "credit hold" and "blocked for credit" are close, but not your company's own codes. The embeddings topic tests where it breaks.

#Exercise: write your own SAP texts and read your trial

1. Copy hello_torch.py to my_texts.py in unit03.

2. Change QUERY to a problem from a process you know, for example a three-way match exception: "Invoice quantity higher than goods receipt".

3. Replace CANDIDATES with five made-up texts: two that describe the same problem in other words, two about other processes, and one piece of product master data.

4. Run python my_texts.py --embed. Check that your two rewordings rank highest.

5. If one of them doesn't, write one sentence in btp_trial_notes.md under a new heading ## Embedding surprises, saying which text ranked where and why you think so.

6. Complete every line of the notes template from Step 8.

7. Save your work in Git:

   Copy

   git add unit03/my_texts.py unit03/btp_trial_notes.md
   git commit -m "Add my own embedding test and BTP trial notes"

Done when: check_unit03.py prints All set, my_texts.py --embed prints your five texts ranked by similarity, btp_trial_notes.md has every line filled in, and git log shows the commit. Keep both files: the embeddings topic reuses your texts, and the SAP BTP foundations topic starts from your trial notes.

#Check yourself