OCIComputeintermediate

OCI Data Science Platform

Build, train, deploy, and manage ML models with OCI Data Science notebooks, model catalog, deployment endpoints, and pipelines.

CloudToolStack Team25 min readPublished Mar 14, 2026

Prerequisites

OCI account with Data Science service permissions
Basic understanding of machine learning concepts

Introduction to OCI Data Science

Oracle Cloud Infrastructure (OCI) Data Science is a fully managed, serverless platform designed for data science teams to build, train, deploy, and manage machine learning models. Unlike cobbling together individual services, OCI Data Science provides an integrated environment with JupyterLab notebooks, model catalog, model deployment infrastructure, and ML pipelines all accessible from a single service.

The platform supports popular frameworks including TensorFlow, PyTorch, scikit-learn, XGBoost, and Oracle's own AutoML libraries through the Accelerated Data Science (ADS) SDK. Whether you are building a simple regression model or training a large-scale deep learning model across multiple GPUs, OCI Data Science provides the compute flexibility and tooling to streamline every phase of the ML lifecycle.

This guide covers the complete workflow from setting up your first notebook session to deploying a production model behind a REST endpoint. You will learn how to manage environments with conda, use the ADS SDK for feature engineering and model evaluation, store models in the model catalog with provenance metadata, deploy models as HTTP endpoints, and orchestrate multi-step workflows with ML pipelines.

OCI Data Science Pricing

OCI Data Science charges only for the underlying compute and storage you use. There is no additional charge for the notebook sessions, model catalog, or pipeline orchestration service itself. Notebook sessions use standard OCI compute shapes (including GPU shapes like VM.GPU.A10.1), and you pay only while the session is active. Model deployments are charged per OCPU-hour for the inference instances. The Always Free tier includes limited compute that can be used for small experiments.

Setting Up Your Data Science Project

Before launching your first notebook, you need to configure IAM policies, create a project, and understand the organizational structure. OCI Data Science uses projects as the top-level organizational unit. Each project contains notebook sessions, models, model deployments, and pipelines. Projects live within compartments, so your existing compartment hierarchy applies.

Required IAM Policies

Data Science requires specific IAM policies for the user group and the service itself. The service needs permission to manage networking, compute, and object storage on your behalf.

bash

# Create a group for data scientists
oci iam group create \
  --name DataScientists \
  --description "Data Science platform users"

# Policy for data scientists to use the service
# Create in the root compartment or target compartment
oci iam policy create \
  --compartment-id <tenancy-ocid> \
  --name DataSciencePolicy \
  --description "Allow data scientists to use OCI Data Science" \
  --statements '[
    "Allow group DataScientists to manage data-science-family in compartment ml-workloads",
    "Allow group DataScientists to use virtual-network-family in compartment ml-workloads",
    "Allow group DataScientists to manage object-family in compartment ml-workloads",
    "Allow group DataScientists to read resource-availability in compartment ml-workloads",
    "Allow service datascience to use virtual-network-family in compartment ml-workloads",
    "Allow group DataScientists to manage log-groups in compartment ml-workloads",
    "Allow group DataScientists to use logging-family in compartment ml-workloads"
  ]'

# Create the Data Science project
oci data-science project create \
  --compartment-id <compartment-ocid> \
  --display-name "fraud-detection-project" \
  --description "ML models for fraud detection pipeline"

Network Configuration

Notebook sessions require a VCN subnet for network access. If your notebooks need to access the internet (for pip install, downloading datasets, or calling external APIs), use a public subnet with an internet gateway or a private subnet with a NAT gateway. For production workloads accessing OCI services, use a service gateway so traffic stays on the Oracle backbone network and does not traverse the public internet.

Notebook Sessions

Notebook sessions are the primary interactive development environment in OCI Data Science. Each session launches a managed JupyterLab instance on the compute shape you select. You can choose from standard CPU shapes, high-memory shapes, and GPU shapes for deep learning workloads. Sessions persist your work on a block storage volume, and you can deactivate (stop) a session to pause compute charges while retaining your files.

Each notebook session comes pre-installed with the OCI SDK, ADS SDK, and common data science libraries. You can install additional packages using conda environments or pip directly in the terminal.

bash

# Create a notebook session
oci data-science notebook-session create \
  --compartment-id <compartment-ocid> \
  --project-id <project-ocid> \
  --display-name "fraud-detection-notebook" \
  --notebook-session-config-details '{
    "shape": "VM.Standard.E4.Flex",
    "notebookSessionShapeConfigDetails": {
      "ocpus": 4,
      "memoryInGBs": 64
    },
    "blockStorageSizeInGBs": 100,
    "subnetId": "<subnet-ocid>"
  }'

# List all notebook sessions in a project
oci data-science notebook-session list \
  --compartment-id <compartment-ocid> \
  --project-id <project-ocid> \
  --lifecycle-state ACTIVE \
  --sort-by timeCreated \
  --sort-order DESC

# Deactivate (stop) a session to save costs
oci data-science notebook-session deactivate \
  --notebook-session-id <session-ocid>

# Reactivate when you need it again
oci data-science notebook-session activate \
  --notebook-session-id <session-ocid>

Conda Environments

OCI Data Science provides pre-built conda environments for common ML frameworks. These environments include optimized versions of TensorFlow, PyTorch, and other libraries tuned for OCI compute shapes. You can also create custom conda environments and publish them to Object Storage for team-wide sharing.

python

# Inside a notebook cell - list available conda environments
import subprocess
result = subprocess.run(['conda', 'env', 'list'], capture_output=True, text=True)
print(result.stdout)

# Install the General Machine Learning conda environment
# Run in terminal:
# odsc conda install -s generalml_p38_cpu_v1

# Activate the environment
# conda activate /home/datascience/conda/generalml_p38_cpu_v1

# ADS SDK is pre-installed in OCI conda environments
import ads
print(f"ADS version: {ads.__version__}")

# Set up authentication for OCI services
ads.set_auth(auth="resource_principal")  # Use resource principal in notebooks
# OR
ads.set_auth(auth="api_key")  # Use API key auth

Feature Engineering with ADS

The Accelerated Data Science (ADS) SDK simplifies common ML tasks including data loading, feature engineering, visualization, model training, and evaluation. ADS provides a high-level API that wraps popular libraries and adds OCI-specific functionality like model catalog integration and deployment utilities.

ADS can load data from OCI Object Storage, Autonomous Database, MySQL HeatWave, local files, and pandas DataFrames. It provides automated feature type detection, data profiling, and feature engineering transformations.

python

import ads
import pandas as pd
from ads.dataset.factory import DatasetFactory
from ads.feature_engineering.feature_type.handler.feature_validator import \
    FeatureValidator

# Load data from Object Storage
ds = DatasetFactory.open(
    "oci://ml-datasets@namespace/fraud_transactions.csv",
    target="is_fraud"
)

# Automatic data profiling
ds.show_in_notebook()  # Interactive profiling report

# Feature summary
print(ds.feature_types)

# Automatic feature engineering suggestions
suggestions = ds.suggest_recommendations()
for col, recs in suggestions.items():
    print(f"\n{col}:")
    for rec in recs:
        print(f"  - {rec}")

# Apply transformations
ds_transformed = ds.auto_transform()

# Split data for training
train, test = ds_transformed.train_test_split(test_size=0.2, random_state=42)
print(f"Training samples: {len(train)}")
print(f"Test samples: {len(test)}")

# Custom feature engineering with pandas
df = ds.to_pandas()
df['hour_of_day'] = pd.to_datetime(df['transaction_time']).dt.hour
df['day_of_week'] = pd.to_datetime(df['transaction_time']).dt.dayofweek
df['amount_log'] = df['amount'].apply(lambda x: max(0, x)).apply(
    lambda x: x if x == 0 else __import__('math').log(x)
)
df['amount_zscore'] = (df['amount'] - df['amount'].mean()) / df['amount'].std()

Use ADSDataset for Large Datasets

For datasets that do not fit in memory, ADS integrates with Dask for distributed dataframe processing. You can also use Oracle Autonomous Database with the oracledb connector for SQL-based feature engineering directly in the database, which is faster for terabyte-scale datasets because the data does not need to move to the notebook.

Model Training and Evaluation

ADS provides an ADSModel wrapper that standardizes the interface across different ML frameworks. It also includes AutoML capabilities through the Oracle AutoML library, which automatically searches for the best algorithm and hyperparameters for your dataset.

python

from ads.automl.provider import OracleAutoMLProvider
from ads.automl.driver import AutoML
from ads.model.framework.sklearn_model import SklearnModel
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report, roc_auc_score
import numpy as np

# Option 1: Use Oracle AutoML for automatic model selection
automl = AutoML(train, provider=OracleAutoMLProvider())
model, baseline = automl.train(
    model_list=[
        'LogisticRegression',
        'RandomForestClassifier',
        'XGBClassifier',
        'LGBMClassifier'
    ],
    time_budget=600  # 10 minutes
)

# View the selected model and hyperparameters
print(f"Best algorithm: {model.selected_model_}")
print(f"Best score: {model.selected_score_}")

# Option 2: Train a specific model manually
clf = GradientBoostingClassifier(
    n_estimators=200,
    max_depth=6,
    learning_rate=0.1,
    subsample=0.8,
    random_state=42
)
clf.fit(train.X, train.y)

# Evaluate the model
y_pred = clf.predict(test.X)
y_proba = clf.predict_proba(test.X)[:, 1]

print(classification_report(test.y, y_pred))
print(f"ROC AUC: {roc_auc_score(test.y, y_proba):.4f}")

# ADS model evaluation with visual reports
from ads.evaluations.evaluator import ADSEvaluator
evaluator = ADSEvaluator(test, models=[clf])
evaluator.show_in_notebook()  # Interactive evaluation dashboard

GPU Training for Deep Learning

For deep learning workloads, select a GPU shape when creating your notebook session. OCI offers NVIDIA A10, A100, and V100 GPU shapes. The TensorFlow and PyTorch conda environments come with CUDA drivers pre-configured.

python

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

# Verify GPU availability
print(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")
    print(f"Memory: {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} GB")

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# Define a simple neural network
class FraudDetector(nn.Module):
    def __init__(self, input_dim):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.network(x)

model = FraudDetector(input_dim=train.X.shape[1]).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.BCELoss()

# Training loop
for epoch in range(50):
    model.train()
    train_loss = 0
    for batch_X, batch_y in train_loader:
        batch_X, batch_y = batch_X.to(device), batch_y.to(device)
        optimizer.zero_grad()
        output = model(batch_X).squeeze()
        loss = criterion(output, batch_y)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()

    if (epoch + 1) % 10 == 0:
        print(f"Epoch {epoch+1}/50, Loss: {train_loss/len(train_loader):.4f}")

Model Catalog and Versioning

The Model Catalog is a centralized repository for storing, versioning, and sharing trained ML models. When you save a model to the catalog, it stores the model artifact (serialized model files), metadata (hyperparameters, training data info), provenance (training notebook, git commit, conda environment), and custom taxonomy tags. This creates a complete audit trail for model governance and compliance.

python

from ads.model.framework.sklearn_model import SklearnModel
from ads.model.model_metadata import (
    UseCaseType, Framework, FrameworkVersion
)
import tempfile
import os

# Prepare the model artifact
sklearn_model = SklearnModel(estimator=clf, artifact_dir=tempfile.mkdtemp())

# Generate the model artifacts (score.py, runtime.yaml, etc.)
sklearn_model.prepare(
    inference_conda_env="generalml_p38_cpu_v1",
    training_conda_env="generalml_p38_cpu_v1",
    use_case_type=UseCaseType.BINARY_CLASSIFICATION,
    X_sample=test.X[:5],  # Sample input for schema generation
    y_sample=test.y[:5],
    force_overwrite=True
)

# Add custom metadata
sklearn_model.metadata_custom["training_dataset"] = \
    "oci://ml-datasets@namespace/fraud_transactions.csv"
sklearn_model.metadata_custom["training_date"] = "2026-03-14"
sklearn_model.metadata_custom["roc_auc"] = "0.9847"

# Verify the artifact locally before saving
sklearn_model.verify(test.X[:5])

# Save to the Model Catalog
model_id = sklearn_model.save(
    display_name="fraud-detector-v2",
    description="GBM fraud detection model trained on Q1 2026 data",
    project_id="<project-ocid>",
    compartment_id="<compartment-ocid>"
)
print(f"Model saved with OCID: {model_id}")

# List models in the catalog
import oci
ds_client = oci.data_science.DataScienceClient(config)
models = ds_client.list_models(
    compartment_id="<compartment-ocid>",
    project_id="<project-ocid>",
    sort_by="timeCreated",
    sort_order="DESC"
).data

for m in models:
    print(f"{m.display_name} | {m.lifecycle_state} | {m.time_created}")

Model Provenance

OCI Data Science automatically records provenance metadata when you save a model from a notebook session. This includes the notebook session OCID, the git repository URL and commit hash (if the notebook is connected to a git repo), the training script path, and the conda environment used. This provenance chain is critical for regulatory compliance in industries like finance and healthcare where you must demonstrate exactly how a model was trained.

Model Deployment

OCI Data Science Model Deployment creates a managed REST endpoint for real-time inference. You specify the model from the catalog, the compute shape, the number of instances, and optional load balancer bandwidth. The service handles provisioning, scaling, health monitoring, and HTTPS termination automatically.

Each deployment creates an HTTP endpoint that accepts JSON payloads and returns predictions. You can deploy multiple models behind different endpoints or use model deployment versioning to perform A/B testing and canary deployments.

python

# Deploy the model from the catalog
from ads.model.deployment import ModelDeployer, ModelDeploymentProperties

deployer = ModelDeployer()

deployment = deployer.deploy(
    model_id=model_id,
    display_name="fraud-detector-prod",
    description="Production fraud detection endpoint",
    deployment_instance_shape="VM.Standard.E4.Flex",
    deployment_ocpus=2,
    deployment_memory_in_gbs=16,
    deployment_instance_count=2,  # 2 instances for HA
    deployment_bandwidth_mbps=10,
    deployment_log_group_id="<log-group-ocid>",
    deployment_access_log_id="<access-log-ocid>",
    deployment_predict_log_id="<predict-log-ocid>"
)

print(f"Deployment OCID: {deployment.model_deployment_id}")
print(f"Endpoint: {deployment.url}")

# Wait for deployment to become active
deployment.wait_for_completion()

# Test the endpoint
import requests
import json

endpoint = deployment.url + "/predict"
payload = {
    "data": test.X[:3].values.tolist(),
    "columns": test.X.columns.tolist()
}

# Use resource principal auth for calls within OCI
auth = oci.auth.signers.get_resource_principals_signer()
response = requests.post(
    endpoint,
    json=payload,
    auth=auth
)
predictions = response.json()
print(f"Predictions: {predictions}")

bash

# Deploy using OCI CLI
oci data-science model-deployment create \
  --compartment-id <compartment-ocid> \
  --project-id <project-ocid> \
  --display-name "fraud-detector-prod" \
  --model-deployment-configuration-details '{
    "deploymentType": "SINGLE_MODEL",
    "modelConfigurationDetails": {
      "modelId": "<model-ocid>",
      "instanceConfiguration": {
        "instanceShapeName": "VM.Standard.E4.Flex",
        "modelDeploymentInstanceShapeConfigDetails": {
          "ocpus": 2,
          "memoryInGBs": 16
        }
      },
      "scalingPolicy": {
        "policyType": "FIXED_SIZE",
        "instanceCount": 2
      },
      "bandwidthMbps": 10
    }
  }'

# Check deployment status
oci data-science model-deployment get \
  --model-deployment-id <deployment-ocid> \
  --query 'data.{"Status": "lifecycle-state", "URL": "model-deployment-url"}' \
  --output table

# Update instance count (scale up)
oci data-science model-deployment update \
  --model-deployment-id <deployment-ocid> \
  --model-deployment-configuration-details '{
    "deploymentType": "SINGLE_MODEL",
    "modelConfigurationDetails": {
      "modelId": "<model-ocid>",
      "scalingPolicy": {
        "policyType": "FIXED_SIZE",
        "instanceCount": 4
      }
    }
  }'

ML Pipelines

OCI Data Science Pipelines lets you orchestrate multi-step ML workflows as directed acyclic graphs (DAGs). Each pipeline consists of steps that can run custom Python scripts, notebook sessions, or container images. Pipelines are ideal for automating repetitive workflows like data preprocessing, model training, evaluation, and conditional deployment.

Pipeline steps can pass data between each other using pipeline parameters and artifacts stored in Object Storage. You can schedule pipelines to run on a cron schedule or trigger them programmatically from events or API calls.

python

from ads.pipeline import Pipeline, PipelineStep, ScriptStep
import tempfile, os

# Define pipeline steps
preprocess_step = (
    ScriptStep("preprocess")
    .with_script("preprocess.py")
    .with_shape_name("VM.Standard.E4.Flex")
    .with_shape_config_details(ocpus=2, memory_in_gbs=32)
    .with_conda("generalml_p38_cpu_v1")
    .with_argument("--input-path", "oci://raw-data@ns/transactions/")
    .with_argument("--output-path", "oci://processed-data@ns/features/")
)

train_step = (
    ScriptStep("train")
    .with_script("train.py")
    .with_shape_name("VM.GPU.A10.1")
    .with_conda("pytorch110_p38_gpu_v1")
    .with_argument("--data-path", "oci://processed-data@ns/features/")
    .with_argument("--epochs", "50")
    .with_argument("--model-output", "oci://models@ns/artifacts/")
)

evaluate_step = (
    ScriptStep("evaluate")
    .with_script("evaluate.py")
    .with_shape_name("VM.Standard.E4.Flex")
    .with_shape_config_details(ocpus=2, memory_in_gbs=16)
    .with_conda("generalml_p38_cpu_v1")
    .with_argument("--model-path", "oci://models@ns/artifacts/")
    .with_argument("--test-data", "oci://processed-data@ns/test/")
)

# Build the pipeline DAG
pipeline = (
    Pipeline("fraud-detection-pipeline")
    .with_compartment_id("<compartment-ocid>")
    .with_project_id("<project-ocid>")
    .with_log_group_id("<log-group-ocid>")
    .with_step_details([preprocess_step, train_step, evaluate_step])
    .with_dag(["preprocess >> train >> evaluate"])
)

# Create and run the pipeline
pipeline.create()
pipeline_run = pipeline.run()
print(f"Pipeline run OCID: {pipeline_run.id}")

# Monitor pipeline execution
pipeline_run.watch()  # Streams logs in real-time

Jobs for Batch Processing

OCI Data Science Jobs provide a way to run Python scripts and notebooks as standalone batch processes without an interactive session. Jobs are ideal for scheduled training runs, batch inference, data preprocessing, and any compute task that does not require interactive development. You define a job once, then create multiple job runs with different parameters.

bash

# Create a job
oci data-science job create \
  --compartment-id <compartment-ocid> \
  --project-id <project-ocid> \
  --display-name "weekly-model-retrain" \
  --job-configuration-details '{
    "jobType": "DEFAULT",
    "environmentVariables": {
      "TRAINING_DATA": "oci://ml-datasets@ns/weekly/",
      "MODEL_OUTPUT": "oci://models@ns/weekly/"
    }
  }' \
  --job-infrastructure-configuration-details '{
    "jobInfrastructureType": "STANDALONE",
    "shapeName": "VM.Standard.E4.Flex",
    "jobShapeConfigDetails": {
      "ocpus": 8,
      "memoryInGBs": 128
    },
    "blockStorageSizeInGBs": 200,
    "subnetId": "<subnet-ocid>"
  }' \
  --job-log-configuration-details '{
    "enableLogging": true,
    "logGroupId": "<log-group-ocid>"
  }'

# Upload the training script as a job artifact
oci data-science job create-job-artifact \
  --job-id <job-ocid> \
  --job-artifact-file train_weekly.py \
  --content-disposition 'attachment; filename="train_weekly.py"'

# Create a job run (execute the job)
oci data-science job-run create \
  --compartment-id <compartment-ocid> \
  --project-id <project-ocid> \
  --job-id <job-ocid> \
  --display-name "weekly-retrain-2026-03-14"

# Monitor the job run
oci data-science job-run get \
  --job-run-id <job-run-ocid> \
  --query 'data.{"Status": "lifecycle-state", "Started": "time-accepted", "Duration": "lifecycle-details"}' \
  --output table

Use Jobs for Cost Optimization

Jobs are more cost-effective than notebook sessions for production workloads because they automatically terminate when the script completes. You do not pay for idle compute time. Combine Jobs with OCI Scheduler or an external cron trigger (via Functions and Events) to run recurring ML tasks like nightly model retraining, weekly data quality checks, or monthly model performance reports.

Model Monitoring and Governance

Deploying a model is not the end of the ML lifecycle. Models degrade over time as the real-world data distribution shifts away from the training data. OCI Data Science provides tools for monitoring model performance in production, detecting data drift, and maintaining an audit trail for governance.

Prediction logs capture every inference request and response, enabling you to analyze model behavior, detect anomalies, and calculate real-time performance metrics when ground truth labels become available. Access logs track who called the endpoint, from which IP, and at what time.

python

import oci
from datetime import datetime, timedelta

# Query prediction logs for model monitoring
logging_search = oci.loggingsearch.LogSearchClient(config)

# Search for prediction logs from the last 24 hours
end_time = datetime.utcnow()
start_time = end_time - timedelta(hours=24)

response = logging_search.search_logs(
    search_logs_details=oci.loggingsearch.models.SearchLogsDetails(
        time_start=start_time,
        time_end=end_time,
        search_query=(
            'search "<log-group-ocid>/<predict-log-ocid>" '
            '| sort by datetime desc'
        ),
        is_return_field_info=False
    )
)

# Analyze predictions
import json
predictions = []
for result in response.data.results:
    log_data = json.loads(result.data)
    predictions.append(log_data)

print(f"Total predictions (24h): {len(predictions)}")

# Calculate prediction distribution
import collections
pred_counts = collections.Counter(
    p.get('prediction', 'unknown') for p in predictions
)
print(f"Prediction distribution: {dict(pred_counts)}")

# Monitor for data drift using statistical tests
from scipy import stats
import numpy as np

training_feature_mean = 150.0  # Known from training data
training_feature_std = 45.0

recent_values = [p.get('feature_amount', 0) for p in predictions[-1000:]]
t_stat, p_value = stats.ttest_1samp(recent_values, training_feature_mean)
if p_value < 0.05:
    print(f"WARNING: Data drift detected (p={p_value:.4f})")
else:
    print(f"No significant drift (p={p_value:.4f})")

Best Practices and Cost Optimization

Running ML workloads efficiently on OCI requires attention to compute selection, storage management, and workflow design. Here are essential practices for production data science workloads.

Compute Shape Selection

Workload	Recommended Shape	Why
Data exploration	VM.Standard.E4.Flex (2-4 OCPU)	Low cost for interactive work
Feature engineering	VM.Standard.E4.Flex (8+ OCPU)	CPU-bound pandas/Dask operations
Classical ML training	VM.Standard.E4.Flex (8-16 OCPU)	scikit-learn, XGBoost use CPU
Deep learning training	VM.GPU.A10.1 or BM.GPU.A100	GPU required for neural networks
Model inference	VM.Standard.E4.Flex (1-2 OCPU)	Low latency, cost-effective
Large-scale training	BM.GPU4.8 (8x A100)	Multi-GPU distributed training

Cost Optimization Tips

Always deactivate notebook sessions when not in use. A VM.Standard.E4.Flex with 4 OCPUs running 24/7 costs roughly $100/month, but if you only use it 8 hours per day on weekdays, the cost drops to about $24/month. Use Jobs instead of persistent notebook sessions for automated workloads. Store large datasets in Object Storage (Standard or Infrequent Access tier) rather than on notebook block storage volumes. Use the smallest compute shape that meets your latency requirements for model deployments.

GPU Cost Management

GPU shapes are significantly more expensive than CPU shapes. A single VM.GPU.A10.1 costs approximately $2.50/hour. Always verify your training code works correctly on a small dataset with a CPU shape before switching to GPU. Use Jobs for GPU training so the instance terminates automatically when training completes. Never leave a GPU notebook session running overnight unless actively training.

Summary and Next Steps

OCI Data Science provides a comprehensive platform for the entire ML lifecycle. You learned how to set up projects and notebook sessions, engineer features with the ADS SDK, train models using both AutoML and custom frameworks, store models in the catalog with provenance metadata, deploy models as REST endpoints, and orchestrate workflows with pipelines.

The platform integrates deeply with other OCI services. Use Autonomous Database for feature stores and large-scale SQL-based feature engineering. Use Object Storage for dataset versioning and model artifact storage. Use OCI Functions to trigger pipeline runs from events. Use OCI Logging and Monitoring for production observability.

As your ML practice matures, explore advanced topics like distributed training across multiple GPU nodes, custom container images for specialized frameworks, A/B testing with multiple model deployments, and integration with Oracle Analytics Cloud for business user self-service ML.

Getting Started with Oracle Cloud OCI IAM, Compartments & Policies Terraform on OCI

Key Takeaways

1OCI Data Science provides managed JupyterLab notebooks with GPU shape support for deep learning.
2The ADS SDK streamlines feature engineering, model training, evaluation, and deployment.
3Model Catalog stores versioned models with provenance metadata for governance and compliance.
4Model Deployment creates managed REST endpoints with auto-scaling for real-time inference.

Frequently Asked Questions

What ML frameworks does OCI Data Science support?

OCI Data Science supports all major ML frameworks through pre-built conda environments including TensorFlow, PyTorch, scikit-learn, XGBoost, LightGBM, and Oracle AutoML. You can also install any Python package via pip or conda. GPU shapes (A10, A100, V100) come with CUDA drivers pre-configured for deep learning workloads.

How does OCI Data Science pricing work?

OCI Data Science charges only for underlying compute and storage. There is no additional charge for notebook sessions, model catalog, or pipeline orchestration. Notebook sessions use standard OCI compute shapes and you pay only while the session is active. Model deployments charge per OCPU-hour for inference instances.

Written by CloudToolStack Team

Cloud engineers and architects with hands-on experience across AWS, Azure, and GCP. We write guides based on real-world production patterns, not just documentation rewrites.

Disclaimer: This guide is for educational purposes. Cloud services change frequently; always refer to official documentation for the latest information. AWS, Azure, and GCP are trademarks of their respective owners.