Google Colab (Colaboratory) is a free, cloud-based Jupyter notebook environment hosted by Google that requires no installation, runs entirely in your browser, and provides free access to CPUs, GPUs, and TPUs for machine learning and data science work. It stores notebooks directly in Google Drive, making them instantly shareable and accessible from any device.
Introduction: Data Science Without the Setup Headache
One of the biggest barriers to getting started with data science is the setup process. Installing Python, configuring virtual environments, installing CUDA drivers for GPU support, managing library conflicts, and ensuring everything works across different operating systems can consume hours — sometimes days — before you write a single line of analysis code.
Google Colab eliminates this barrier entirely. Open a browser, navigate to colab.research.google.com, sign in with your Google account, and you are writing Python code in a fully configured data science environment within thirty seconds. No installation. No configuration. No compatibility issues. And crucially — no cost for the core service.
But Google Colab is far more than just a convenient way to avoid setup headaches. It provides access to hardware — GPUs and TPUs — that most individual data scientists and students cannot afford to own. Training a deep learning model that would take hours on a laptop CPU can finish in minutes on a Colab GPU. For students, researchers, and anyone exploring machine learning without an expensive workstation, this is a genuinely transformative resource.
This article gives you a complete understanding of Google Colab from first principles: what it is, what it provides for free, how to use it effectively for real data science work, how to connect it to your data sources, and how to avoid the most common pitfalls that trip up beginners. By the end, you will know whether Colab is the right tool for your current project and exactly how to get the most out of it.
1. What Google Colab Provides
1.1 The Runtime Environment
Every Colab notebook runs in a runtime — a virtual machine hosted on Google’s infrastructure that includes:
- Pre-installed libraries: NumPy, Pandas, Matplotlib, Scikit-learn, TensorFlow, PyTorch, Keras, OpenCV, and dozens of other data science and machine learning libraries come pre-installed. For most projects, you do not need to install anything.
- Python 3: Colab runs Python 3 (currently Python 3.10+). The environment is regularly updated by Google.
- Jupyter-compatible interface: Colab uses the same cell-based notebook format as Jupyter. If you know Jupyter, you know the basic Colab interface. The same
Shift+Enterto run, the same Markdown cells, the same%timeitmagic commands.
1.2 Free Hardware Tiers
Colab’s most impressive feature for beginners is free hardware access:
CPU Runtime (Always Free): A standard compute instance for everyday data processing, analysis, and smaller machine learning tasks. Suitable for most beginner and intermediate work.
GPU Runtime (Free with Limits): Access to NVIDIA GPUs (typically T4 or equivalent) for accelerating machine learning model training. The free tier allows limited GPU time per day/week — Google enforces usage caps to distribute resources fairly.
TPU Runtime (Free with Limits): Access to Google’s Tensor Processing Units, specialized hardware optimized for large-scale TensorFlow workloads.
# Check what hardware you are currently using
import torch
if torch.cuda.is_available():
print(f"GPU: {torch.cuda.get_device_name(0)}")
print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
else:
print("Running on CPU")
# For TensorFlow:
import tensorflow as tf
print("GPUs available:", tf.config.list_physical_devices('GPU'))1.3 Colab Pro and Colab Pro+
Google offers paid tiers that remove limitations:
| Feature | Free | Colab Pro (~$10/mo) | Colab Pro+ (~$50/mo) |
|---|---|---|---|
| GPU access | Limited, shared | Priority, more hours | Background execution |
| GPU type | T4 (shared) | T4/V100 (priority) | A100 access |
| RAM | ~12 GB | ~25 GB | ~52 GB |
| Disk space | ~78 GB | ~166 GB | ~166 GB |
| Session length | ~12 hours max | ~24 hours | ~24 hours + background |
| Idle timeout | ~90 minutes | ~90 minutes | Longer |
For learning and most intermediate projects, the free tier is entirely sufficient. Colab Pro becomes worthwhile when you regularly need more RAM, longer sessions, or faster GPUs for production-scale training.
2. Getting Started: Your First Colab Notebook
2.1 Creating a New Notebook
- Navigate to
colab.research.google.com - Sign in with your Google account
- Click “New notebook” in the welcome dialog, or go to
File → New notebook
You now have a fresh Colab notebook. It looks almost identical to a Jupyter Notebook — cells, a menu bar, and a toolbar — with a few Colab-specific additions.
2.2 Connecting to a Runtime
Before running any code, Colab needs to connect to a runtime (the virtual machine that executes your code). You will see a “Connect” button in the top-right corner. Click it to connect to the default CPU runtime.
Once connected, the button changes to show RAM and disk usage indicators — a live display of how much of the allocated resources you are using.
To switch to a GPU or TPU runtime:
Runtime → Change runtime type → Hardware accelerator → GPU (or TPU)Important: Changing the runtime type disconnects your current session and starts a new one, losing all variables in memory. Connect to GPU before starting your work if you know you will need it.
2.3 Running Your First Cells
# Cell 1: Verify the environment
import sys
import pandas as pd
import numpy as np
import sklearn
print(f"Python: {sys.version.split()[0]}")
print(f"Pandas: {pd.__version__}")
print(f"NumPy: {np.__version__}")
print(f"Scikit: {sklearn.__version__}")
print("Environment ready ✓")# Cell 2: Quick data analysis to confirm everything works
import matplotlib.pyplot as plt
# Generate sample data
np.random.seed(42)
data = np.random.normal(100, 15, 1000)
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.hist(data, bins=30, color='steelblue', edgecolor='white', alpha=0.8)
plt.title('Distribution of Sample Data')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.subplot(1, 2, 2)
plt.boxplot(data, vert=True, patch_artist=True,
boxprops=dict(facecolor='lightblue'))
plt.title('Box Plot')
plt.ylabel('Value')
plt.tight_layout()
plt.show()
print(f"Mean: {data.mean():.2f} | Std: {data.std():.2f}")Charts render directly below cells, exactly as in local Jupyter. No %matplotlib inline configuration required — Colab handles this automatically.
3. Working with Data in Colab
Getting data into Colab is the biggest practical difference from local Jupyter. Since your notebook runs on Google’s servers, not your local machine, files on your computer are not automatically available. There are several ways to bring data into a Colab session.
3.1 Uploading Files Directly
The simplest approach for small files — upload them from your computer directly into the Colab runtime:
from google.colab import files
# Opens a file picker dialog in your browser
uploaded = files.upload()
# uploaded is a dict: {filename: bytes_content}
for filename, content in uploaded.items():
print(f"Uploaded: {filename} ({len(content):,} bytes)")
# Read the uploaded file into Pandas
import io
import pandas as pd
filename = list(uploaded.keys())[0]
df = pd.read_csv(io.BytesIO(uploaded[filename]))
print(df.head())Limitation: Uploaded files are stored in the runtime’s temporary storage and disappear when the session ends. Each time you start a new session, you need to re-upload.
3.2 Mounting Google Drive (Recommended for Regular Work)
For persistent data that survives session restarts, mount your Google Drive directly into the Colab runtime. This gives you seamless access to any file in your Drive:
from google.colab import drive
# Mount Google Drive at /content/drive
drive.mount('/content/drive')
# After authorization, your Drive is accessible at:
# /content/drive/MyDrive/
# Access any file in your Drive
import pandas as pd
df = pd.read_csv('/content/drive/MyDrive/datasets/sales_data.csv')
print(f"Loaded {len(df):,} rows from Google Drive")
# Save results back to Drive
df.to_csv('/content/drive/MyDrive/results/analysis_output.csv', index=False)
print("Results saved to Google Drive ✓")The first time you run drive.mount(), Google prompts you to authorize access. After clicking “Connect to Google Drive” and authorizing, the mount persists for the duration of the session.
Best practice: Create a dedicated folder in your Google Drive for your Colab projects:
My Drive/
├── colab_projects/
│ ├── project_01_sales_analysis/
│ │ ├── data/
│ │ │ └── sales_2024.csv
│ │ └── notebooks/
│ │ └── analysis.ipynb
│ └── project_02_ml_model/
│ ├── data/
│ └── models/3.3 Downloading from URLs
For publicly available datasets, download them directly in the runtime:
import subprocess
# Download from a direct URL
!wget -q https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv
# Or use Python's requests
import requests
url = "https://people.sc.fsu.edu/~jburkardt/data/csv/hw_200.csv"
response = requests.get(url)
with open('height_weight.csv', 'wb') as f:
f.write(response.content)
df = pd.read_csv('height_weight.csv')
print(f"Downloaded {len(df)} rows")3.4 Connecting to Kaggle Datasets
Kaggle datasets can be downloaded directly into Colab using the Kaggle API:
# Step 1: Upload your Kaggle API credentials
# Download kaggle.json from kaggle.com → Account → API → Create New API Token
from google.colab import files
files.upload() # Upload kaggle.json
# Step 2: Configure the credentials
import os
os.makedirs('/root/.config/kaggle', exist_ok=True)
os.rename('kaggle.json', '/root/.config/kaggle/kaggle.json')
os.chmod('/root/.config/kaggle/kaggle.json', 0o600)
# Step 3: Install Kaggle CLI and download dataset
!pip install -q kaggle
!kaggle datasets download -d uciml/iris
!unzip -q iris.zip
# Step 4: Load the dataset
df = pd.read_csv('iris.csv')
print(df.head())3.5 Reading from Cloud Storage (BigQuery, GCS, S3)
For enterprise data science work, Colab has built-in integration with Google Cloud services:
# BigQuery integration (Google Cloud)
from google.colab import auth
auth.authenticate_user()
from google.cloud import bigquery
client = bigquery.Client(project='your-project-id')
query = """
SELECT
product_category,
SUM(revenue) as total_revenue,
COUNT(*) as transactions
FROM `bigquery-public-data.thelook_ecommerce.orders`
WHERE created_at >= '2024-01-01'
GROUP BY product_category
ORDER BY total_revenue DESC
LIMIT 10
"""
df = client.query(query).to_dataframe()
print(df)4. Enabling and Using GPU Acceleration
4.1 Switching to GPU Runtime
Runtime → Change runtime type → Hardware accelerator → GPU → SaveAfter saving, Colab connects to a new runtime with GPU access. Verify:
# Verify GPU availability
import torch
print("CUDA available:", torch.cuda.is_available())
print("GPU:", torch.cuda.get_device_name(0) if torch.cuda.is_available() else "None")
print("GPU Memory:", f"{torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB"
if torch.cuda.is_available() else "N/A")
# For TensorFlow
import tensorflow as tf
gpus = tf.config.list_physical_devices('GPU')
print("TensorFlow GPUs:", gpus)4.2 Training a Neural Network on GPU
Here is a complete example showing the GPU speedup for a neural network training task:
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
import time
# ── Generate synthetic classification data ────────────────────────────────────
torch.manual_seed(42)
n_samples, n_features = 50_000, 100
X = torch.randn(n_samples, n_features)
y = (X[:, 0] + X[:, 1] > 0).long()
# ── Define a neural network ───────────────────────────────────────────────────
class ClassificationNet(nn.Module):
def __init__(self, input_size):
super().__init__()
self.net = nn.Sequential(
nn.Linear(input_size, 256),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(256, 128),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 2)
)
def forward(self, x):
return self.net(x)
# ── Train on CPU first ────────────────────────────────────────────────────────
device_cpu = torch.device('cpu')
model_cpu = ClassificationNet(n_features).to(device_cpu)
optimizer = optim.Adam(model_cpu.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
dataset = TensorDataset(X, y)
loader = DataLoader(dataset, batch_size=512, shuffle=True)
start = time.time()
for epoch in range(5):
for X_batch, y_batch in loader:
X_batch, y_batch = X_batch.to(device_cpu), y_batch.to(device_cpu)
optimizer.zero_grad()
loss = criterion(model_cpu(X_batch), y_batch)
loss.backward()
optimizer.step()
cpu_time = time.time() - start
print(f"CPU training time (5 epochs): {cpu_time:.2f}s")
# ── Train on GPU ──────────────────────────────────────────────────────────────
if torch.cuda.is_available():
device_gpu = torch.device('cuda')
model_gpu = ClassificationNet(n_features).to(device_gpu)
optimizer = optim.Adam(model_gpu.parameters(), lr=0.001)
X_gpu, y_gpu = X.to(device_gpu), y.to(device_gpu)
dataset_gpu = TensorDataset(X_gpu, y_gpu)
loader_gpu = DataLoader(dataset_gpu, batch_size=512, shuffle=True)
start = time.time()
for epoch in range(5):
for X_batch, y_batch in loader_gpu:
optimizer.zero_grad()
loss = criterion(model_gpu(X_batch), y_batch)
loss.backward()
optimizer.step()
gpu_time = time.time() - start
print(f"GPU training time (5 epochs): {gpu_time:.2f}s")
print(f"Speedup: {cpu_time/gpu_time:.1f}x faster on GPU")For larger models and datasets, GPU speedups of 10–50x over CPU are common. For very large models (like BERT or ResNet), the speedup can exceed 100x.
4.3 Installing Libraries Not Pre-Installed
Although Colab comes with most popular libraries, you may need additional packages:
# Install a package for the current session
!pip install -q lightgbm xgboost catboost
# Install a specific version
!pip install -q scikit-learn==1.3.0
# Install from GitHub
!pip install -q git+https://github.com/huggingface/transformers.git
# Verify installation
import lightgbm as lgb
print(f"LightGBM version: {lgb.__version__}")Note: Installed packages are lost when the runtime restarts. Add installation cells at the top of your notebook and they will re-install automatically on each session start.
5. Colab-Specific Features That Go Beyond Jupyter
5.1 Table of Contents
Colab automatically generates a navigable Table of Contents from your Markdown headings, displayed in the left sidebar. Click any heading to jump directly to that section — no extension required.
5.2 Code Snippets
Colab includes a built-in code snippet library accessible from Insert → Code snippet. Search for common operations — loading data from Drive, training a Keras model, creating visualizations — and insert ready-to-run code templates. This is especially helpful for beginners learning new libraries.
5.3 AI-Powered Features (Gemini Integration)
Recent versions of Colab include Google Gemini AI integration:
# Colab AI features (available in the interface):
# - "Generate code" button: describe what you want in natural language
# - "Explain code" button: get an explanation of selected code
# - "Fix error" button: automatically suggest fixes for error messagesThese AI features can significantly accelerate learning and debugging, especially for beginners.
5.4 Forms for Interactive Parameters
Colab supports interactive form elements that let you change parameters without editing code:
# @title Analysis Configuration
# @markdown Set parameters for the analysis:
learning_rate = 0.001 # @param {type:"number"}
num_epochs = 50 # @param {type:"slider", min:10, max:200, step:10}
batch_size = 32 # @param [16, 32, 64, 128] {type:"raw"}
model_type = "Random Forest" # @param ["Linear Regression", "Random Forest", "XGBoost"]
use_gpu = True # @param {type:"boolean"}
print(f"Configuration:")
print(f" Learning rate: {learning_rate}")
print(f" Epochs: {num_epochs}")
print(f" Batch size: {batch_size}")
print(f" Model: {model_type}")
print(f" Use GPU: {use_gpu}")When rendered, these appear as interactive sliders, dropdowns, and checkboxes — making it easy to share configurable notebooks with non-technical users who can adjust parameters without touching code.
5.5 Sharing and Collaboration
Colab notebooks are stored in Google Drive and share the same permission system as Google Docs:
Share → Add people → Choose permission level:
- Viewer: can see the notebook and its outputs
- Commenter: can add comments but not edit
- Editor: can edit the notebookMultiple people can view a notebook simultaneously, and editors can make changes (though real-time collaborative editing is more limited than Google Docs). For sharing read-only analysis results, set the link to “Anyone with the link can view.”
6. Managing Session Time and Preventing Disconnects
6.1 Understanding Session Limits
Colab free tier has important session constraints:
- Idle timeout: ~90 minutes of inactivity disconnects the runtime
- Maximum session length: ~12 hours for free tier
- When disconnected: All runtime variables are lost; files not saved to Drive are gone
6.2 Preventing Idle Disconnects
For long-running computations, Colab may disconnect if the browser tab is idle. Several approaches help:
Option 1: Keep the browser tab active
- Keep the Colab tab in the foreground
- Occasionally interact with the notebook
Option 2: JavaScript workaround (use with awareness)
// Run in browser console (Ctrl+Shift+J) — not a Colab cell
// This clicks the "Connect" button periodically to prevent idle timeout
// Note: This works against Google's resource management policies
// Use only for genuinely important long-running work
function ClickConnect(){
document.querySelector("#top-toolbar > colab-connect-button").shadowRoot
.querySelector("#connect").click()
}
setInterval(ClickConnect, 60000)Option 3: Colab Pro background execution Colab Pro+ offers background execution that keeps notebooks running even when the browser tab is closed.
6.3 Saving Your Work Before Disconnect
# ── Save important results to Google Drive before session ends ─────────────────
from google.colab import drive
import pickle
drive.mount('/content/drive')
base_path = '/content/drive/MyDrive/colab_projects/my_analysis/'
# Save model
import joblib
joblib.dump(trained_model, f'{base_path}models/final_model.pkl')
# Save processed data
processed_df.to_parquet(f'{base_path}data/processed_features.parquet')
# Save results dictionary
with open(f'{base_path}results/metrics.pkl', 'wb') as f:
pickle.dump(results_dict, f)
print("All artifacts saved to Google Drive ✓")Make it a habit to save all important outputs to Google Drive at regular intervals during long sessions, not just at the end.
7. Complete Project Walkthrough: Machine Learning in Colab
Let us walk through a complete machine learning project in Google Colab — from data loading through model training and evaluation:
# ══ Cell 1: Environment Setup ══════════════════════════════════════════════════
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (classification_report, confusion_matrix,
roc_auc_score, RocCurveDisplay)
import warnings
warnings.filterwarnings('ignore')
plt.rcParams['figure.dpi'] = 100
print("Libraries loaded ✓")# ══ Cell 2: Load the Titanic Dataset ══════════════════════════════════════════
!wget -q https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv
df = pd.read_csv('titanic.csv')
print(f"Dataset: {df.shape[0]} rows × {df.shape[1]} columns")
print(f"\nSurvival rate: {df['Survived'].mean():.1%}")
df.head()# ══ Cell 3: Exploratory Data Analysis ═════════════════════════════════════════
fig, axes = plt.subplots(2, 3, figsize=(15, 8))
# Survival by passenger class
df.groupby('Pclass')['Survived'].mean().plot(
kind='bar', ax=axes[0,0], color=['#2196F3','#4CAF50','#FF5722'],
title='Survival Rate by Class')
axes[0,0].set_ylabel('Survival Rate')
axes[0,0].set_xticklabels(['1st', '2nd', '3rd'], rotation=0)
# Survival by sex
df.groupby('Sex')['Survived'].mean().plot(
kind='bar', ax=axes[0,1], color=['#E91E63','#2196F3'],
title='Survival Rate by Sex')
axes[0,1].set_xticklabels(['Female', 'Male'], rotation=0)
# Age distribution
df['Age'].dropna().hist(bins=30, ax=axes[0,2], color='steelblue', edgecolor='white')
axes[0,2].set_title('Age Distribution')
axes[0,2].set_xlabel('Age')
# Fare distribution by class
for pclass in [1, 2, 3]:
df[df['Pclass']==pclass]['Fare'].hist(
bins=20, ax=axes[1,0], alpha=0.6, label=f'Class {pclass}')
axes[1,0].set_title('Fare by Class')
axes[1,0].legend()
# Missing values heatmap
missing_data = df.isnull().sum().sort_values(ascending=False)
missing_data[missing_data > 0].plot(kind='bar', ax=axes[1,1], color='salmon')
axes[1,1].set_title('Missing Values by Column')
axes[1,1].set_ylabel('Count')
# Correlation matrix
corr_cols = ['Survived', 'Pclass', 'Age', 'SibSp', 'Parch', 'Fare']
sns.heatmap(df[corr_cols].corr(), annot=True, fmt='.2f',
cmap='RdBu_r', ax=axes[1,2], center=0)
axes[1,2].set_title('Correlation Matrix')
plt.suptitle('Titanic Dataset — Exploratory Analysis', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()# ══ Cell 4: Feature Engineering ═══════════════════════════════════════════════
df_model = df.copy()
# Extract title from Name
df_model['Title'] = df_model['Name'].str.extract(r',\s*([^\.]+)\.')
df_model['Title'] = df_model['Title'].replace(
['Lady', 'Countess', 'Capt', 'Col', 'Don', 'Dr',
'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
df_model['Title'] = df_model['Title'].replace({'Mlle': 'Miss', 'Ms': 'Miss', 'Mme': 'Mrs'})
# Family size
df_model['FamilySize'] = df_model['SibSp'] + df_model['Parch'] + 1
df_model['IsAlone'] = (df_model['FamilySize'] == 1).astype(int)
# Fill missing values
df_model['Age'].fillna(df_model.groupby(['Pclass', 'Sex'])['Age'].transform('median'), inplace=True)
df_model['Embarked'].fillna(df_model['Embarked'].mode()[0], inplace=True)
df_model['Fare'].fillna(df_model['Fare'].median(), inplace=True)
# Encode categoricals
le = LabelEncoder()
df_model['Sex_enc'] = le.fit_transform(df_model['Sex'])
df_model['Embarked_enc'] = le.fit_transform(df_model['Embarked'])
df_model['Title_enc'] = le.fit_transform(df_model['Title'])
# Select features
feature_cols = ['Pclass', 'Sex_enc', 'Age', 'SibSp', 'Parch',
'Fare', 'Embarked_enc', 'FamilySize', 'IsAlone', 'Title_enc']
X = df_model[feature_cols]
y = df_model['Survived']
print(f"Feature matrix: {X.shape}")
print(f"Missing values remaining: {X.isnull().sum().sum()}")# ══ Cell 5: Model Training and Comparison ════════════════════════════════════
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
models = {
'Logistic Regression': LogisticRegression(max_iter=1000, random_state=42),
'Random Forest': RandomForestClassifier(n_estimators=200, random_state=42),
'Gradient Boosting': GradientBoostingClassifier(n_estimators=200, random_state=42)
}
results = {}
print("Training models...\n")
for name, model in models.items():
X_tr = X_train_scaled if name == 'Logistic Regression' else X_train
X_te = X_test_scaled if name == 'Logistic Regression' else X_test
model.fit(X_tr, y_train)
y_pred = model.predict(X_te)
y_prob = model.predict_proba(X_te)[:, 1]
cv_scores = cross_val_score(model, X_tr, y_train, cv=5, scoring='accuracy')
results[name] = {
'accuracy': (y_pred == y_test).mean(),
'roc_auc': roc_auc_score(y_test, y_prob),
'cv_mean': cv_scores.mean(),
'cv_std': cv_scores.std(),
'model': model,
'X_te': X_te,
'y_prob': y_prob
}
print(f"{name}:")
print(f" Test Accuracy: {results[name]['accuracy']:.3f}")
print(f" ROC-AUC: {results[name]['roc_auc']:.3f}")
print(f" CV Score: {results[name]['cv_mean']:.3f} ± {results[name]['cv_std']:.3f}\n")# ══ Cell 6: Results Visualization ════════════════════════════════════════════
fig, axes = plt.subplots(1, 3, figsize=(16, 5))
# Model comparison bar chart
model_names = list(results.keys())
accuracies = [results[m]['accuracy'] for m in model_names]
roc_aucs = [results[m]['roc_auc'] for m in model_names]
x = np.arange(len(model_names))
width = 0.35
axes[0].bar(x - width/2, accuracies, width, label='Accuracy', color='steelblue')
axes[0].bar(x + width/2, roc_aucs, width, label='ROC-AUC', color='coral')
axes[0].set_xticks(x)
axes[0].set_xticklabels([m.replace(' ','\n') for m in model_names], fontsize=9)
axes[0].set_ylim(0.7, 1.0)
axes[0].set_title('Model Performance Comparison')
axes[0].legend()
axes[0].set_ylabel('Score')
# ROC curves
for name in model_names:
RocCurveDisplay.from_predictions(
y_test, results[name]['y_prob'],
name=f"{name} (AUC={results[name]['roc_auc']:.3f})",
ax=axes[1]
)
axes[1].plot([0,1],[0,1],'k--', alpha=0.5)
axes[1].set_title('ROC Curves')
# Feature importance (Random Forest)
rf_model = results['Random Forest']['model']
importances = pd.Series(rf_model.feature_importances_, index=feature_cols)
importances.sort_values().plot(kind='barh', ax=axes[2], color='steelblue')
axes[2].set_title('Feature Importance\n(Random Forest)')
axes[2].set_xlabel('Importance Score')
plt.suptitle('Model Evaluation Results', fontsize=13, fontweight='bold')
plt.tight_layout()
plt.show()
best_model_name = max(results, key=lambda m: results[m]['roc_auc'])
print(f"\n✓ Best model: {best_model_name}")
print(f" Accuracy: {results[best_model_name]['accuracy']:.3f}")
print(f" ROC-AUC: {results[best_model_name]['roc_auc']:.3f}")# ══ Cell 7: Save Results to Google Drive ═════════════════════════════════════
from google.colab import drive
import joblib, os
drive.mount('/content/drive')
save_path = '/content/drive/MyDrive/colab_projects/titanic_analysis/'
os.makedirs(save_path + 'models', exist_ok=True)
# Save the best model
best_model = results[best_model_name]['model']
joblib.dump(best_model, f"{save_path}models/best_model.pkl")
joblib.dump(scaler, f"{save_path}models/scaler.pkl")
# Save results summary
results_summary = pd.DataFrame({
'model': model_names,
'accuracy': accuracies,
'roc_auc': roc_aucs
})
results_summary.to_csv(f"{save_path}results_summary.csv", index=False)
print("Saved to Google Drive:")
print(f" {save_path}models/best_model.pkl")
print(f" {save_path}models/scaler.pkl")
print(f" {save_path}results_summary.csv")8. Colab vs Local Jupyter: When to Use Each
Understanding when Colab is the right tool — and when local Jupyter is better — helps you make smart workflow decisions:
| Situation | Best Choice | Reason |
|---|---|---|
| Learning data science as a beginner | Colab | Zero setup, instant start |
| Need GPU for deep learning | Colab | Free GPU access |
| Following an online course or tutorial | Colab | Matches course environment |
| Large dataset stored locally | Local Jupyter | Faster local file access |
| Needs persistent files between sessions | Local Jupyter (or Drive) | No session expiry |
| Team collaboration on a notebook | Colab | Google Drive sharing built-in |
| Production pipeline with long runtime | Local or cloud server | No 12-hour session limit |
| Privacy-sensitive data | Local Jupyter | Data stays on your machine |
| Internet-limited environment | Local Jupyter | No internet dependency |
| Sharing interactive results with non-coders | Colab | Shareable link, no install needed |
| Custom environment with specific package versions | Local Jupyter | Full environment control |
| Kaggle competition prototyping | Colab | Quick experiments with GPU |
9. Pro Tips for Getting the Most from Free Colab
9.1 Use GPU Efficiently
The free GPU allocation is limited. Use it wisely:
# Only allocate GPU memory you actually need
import torch
# Enable memory growth instead of allocating all GPU memory at once
# (TensorFlow)
import tensorflow as tf
for gpu in tf.config.list_physical_devices('GPU'):
tf.config.experimental.set_memory_growth(gpu, True)
# Clear GPU cache between experiments (PyTorch)
torch.cuda.empty_cache()
# Monitor GPU usage
!nvidia-smi9.2 Install Packages Once, Import Many Times
# Put all installations in the FIRST cell
# They only need to run once per session
!pip install -q lightgbm xgboost optuna
# Later cells just import — much faster
import lightgbm as lgb
import xgboost as xgb
import optuna9.3 Use Colab’s Secret Manager for API Keys
Never hardcode API keys in notebooks that you share:
# Store secrets in Colab's Secret Manager
# (Left sidebar → 🔑 Secrets → Add a new secret)
from google.colab import userdata
# Retrieve a stored secret
api_key = userdata.get('OPENAI_API_KEY')
kaggle_username = userdata.get('KAGGLE_USERNAME')
# Now use them safely without exposing in code9.4 Check Runtime Resources Before Starting
# Check available RAM
import psutil
ram = psutil.virtual_memory()
print(f"Total RAM: {ram.total / 1e9:.1f} GB")
print(f"Available RAM: {ram.available / 1e9:.1f} GB")
print(f"Used RAM: {ram.used / 1e9:.1f} GB ({ram.percent:.1f}%)")
# Check disk space
!df -h /content
# Check GPU stats
!nvidia-smi --query-gpu=name,memory.total,memory.free --format=csvConclusion: Colab Democratizes Data Science Computing
Google Colab represents one of the most significant democratizing forces in data science education and research. It has made GPU-accelerated computing — previously available only to those with expensive hardware or cloud computing budgets — accessible to anyone with a Google account and an internet connection.
For beginners, Colab removes the most common early barrier: the setup process. You can follow any tutorial, run any notebook, and experiment with any library without spending hours configuring an environment. For intermediate practitioners, Colab provides free GPU access for deep learning experiments that would be impractical on consumer hardware. For educators and researchers, Colab makes it easy to share fully executable notebooks that anyone can run with one click.
In this article, you learned how Colab’s runtime system works and what the free tier provides, multiple methods for getting data into Colab (direct upload, Google Drive, URLs, Kaggle), how to enable GPU acceleration and measure its benefit, Colab-specific features like forms, AI assistance, and the snippet library, how to manage session time and save your work reliably, and a complete machine learning project from data loading through model saving.
Colab is not a replacement for a properly configured local environment for all use cases — privacy-sensitive data, very large local datasets, and long-running production jobs are better handled locally or on dedicated cloud servers. But for learning, experimentation, collaboration, and GPU-accelerated deep learning, it is an extraordinary resource that every data scientist should know how to use.
In the next article, you will explore the trade-offs between running Python scripts and using Jupyter Notebooks — helping you understand which approach is right for which phase of a data science project.
Key Takeaways
- Google Colab is a free, cloud-based Jupyter notebook environment that requires no installation and runs entirely in a browser, with notebooks stored in Google Drive.
- The free tier provides CPU runtimes always, plus limited GPU (T4) and TPU access — enough for most learning and intermediate machine learning projects.
- Change runtime type via
Runtime → Change runtime type → Hardware acceleratorbefore starting work; changing it mid-session resets all variables. - Mount Google Drive with
drive.mount('/content/drive')to get persistent file storage that survives session restarts — the most reliable approach for ongoing projects. - Session idle timeout is ~90 minutes and maximum session length is ~12 hours on the free tier; save important outputs to Drive regularly.
- Pre-installed libraries include Pandas, NumPy, Matplotlib, Scikit-learn, TensorFlow, and PyTorch — for most projects no installation is needed.
- Use
!pip install -q package_nameto install additional packages; add these to the first cell so they reinstall automatically each session. - Colab forms (
# @param) create interactive sliders, dropdowns, and checkboxes for shareable, configurable notebooks. - Use Colab’s Secret Manager (left sidebar → 🔑) to store API keys instead of hardcoding them in notebooks you share.
- Colab is best for learning, GPU-accelerated deep learning, and collaboration; local Jupyter is better for privacy-sensitive data, large local datasets, and long-running production jobs.
