🧠 ML Studio

Interactive ML notebooks — Python via Pyodide · TensorFlow.js · All in-browser

[1] Markdown

🧠 Introduction to Machine Learning

Machine learning is the science of getting computers to act without being explicitly programmed. This notebook walks you through core concepts using Python libraries running entirely in your browser.

numpy — numerical arrays
pandas — data tables
sklearn — ML algorithms
matplotlib — plotting

[2] Python Imports & Setup

import numpy as np
import pandas as pd
from sklearn.datasets import make_classification, make_regression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

print("✓ NumPy:", np.__version__)
print("✓ Pandas:", pd.__version__)
print("✓ scikit-learn: loaded")
print("\n📦 All ML libraries ready! Let's build models.")

[3] Python Linear Regression

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Generate linear data: y = 3x + 5 + noise
np.random.seed(42)
X = np.random.rand(150, 1) * 10
y = 3 * X.flatten() + 5 + np.random.randn(150) * 1.5

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)

# Train
model = LinearRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

print("=== Linear Regression Results ===")
print(f"Coefficient:  {model.coef_[0]:.4f}  (true: 3.0)")
print(f"Intercept:    {model.intercept_:.4f}  (true: 5.0)")
print(f"R² Score:     {r2_score(y_test, y_pred):.4f}")
print(f"MSE:          {mean_squared_error(y_test, y_pred):.4f}")
print(f"RMSE:         {mean_squared_error(y_test, y_pred, squared=False):.4f}")

[4] Python Classification

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report
import numpy as np

# Dataset
X, y = make_classification(n_samples=600, n_features=8,
                             n_informative=5, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
scaler = StandardScaler()
Xs_train = scaler.fit_transform(X_train)
Xs_test  = scaler.transform(X_test)

# Compare models
models = {
    "Decision Tree":       DecisionTreeClassifier(max_depth=5),
    "Random Forest":       RandomForestClassifier(n_estimators=50, random_state=42),
    "Gradient Boosting":   GradientBoostingClassifier(n_estimators=50, random_state=42),
    "SVM (RBF)":           SVC(kernel='rbf', probability=True),
}
print("=== Model Comparison ===")
print(f"{'Model':<22} {'Accuracy':>10}")
print("-" * 34)
for name, clf in models.items():
    clf.fit(Xs_train, y_train)
    acc = accuracy_score(y_test, clf.predict(Xs_test))
    print(f"{name:<22} {acc*100:>9.1f}%")

[5] Python Clustering (K-Means)

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
from sklearn.metrics import silhouette_score
import numpy as np

# Generate cluster data
X, true_labels = make_blobs(n_samples=300, centers=4,
                             cluster_std=0.8, random_state=42)

# Find optimal K using silhouette score
best_k, best_score = 2, -1
for k in range(2, 8):
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = km.fit_predict(X)
    score = silhouette_score(X, labels)
    if score > best_score:
        best_k, best_score = k, score
    print(f"  k={k}: silhouette={score:.4f}")

print(f"\n✓ Best k: {best_k} (silhouette={best_score:.4f})")
print(f"✓ True clusters: 4")

# Final model
km_final = KMeans(n_clusters=best_k, random_state=42, n_init=10)
km_final.fit(X)
print(f"✓ Inertia: {km_final.inertia_:.2f}")
print(f"✓ Cluster centers shape: {km_final.cluster_centers_.shape}")

[1] Markdown

⚙️ scikit-learn Deep Dive

Pipelines, cross-validation, hyperparameter tuning, and feature engineering — the production ML workflow.

[2] Python Pipeline + GridSearchCV

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.datasets import make_regression
import numpy as np

# Data
X, y = make_regression(n_samples=400, n_features=5, noise=10, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Pipeline
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('poly',   PolynomialFeatures()),
    ('ridge',  Ridge()),
])

# Grid search
params = {
    'poly__degree': [1, 2],
    'ridge__alpha': [0.01, 0.1, 1.0, 10.0],
}
grid = GridSearchCV(pipe, params, cv=5, scoring='r2', n_jobs=-1)
grid.fit(X_train, y_train)

print("=== Pipeline + GridSearchCV ===")
print(f"Best params:  {grid.best_params_}")
print(f"Best CV R²:   {grid.best_score_:.4f}")
print(f"Test R²:      {grid.score(X_test, y_test):.4f}")

[3] Python Feature Importance

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
import numpy as np

# Load real dataset
data = load_breast_cancer()
X, y = data.data, data.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

acc = rf.score(X_test, y_test)
print(f"✓ Breast Cancer Dataset: {X.shape[0]} samples, {X.shape[1]} features")
print(f"✓ Test Accuracy: {acc*100:.1f}%\n")

# Top 10 features
importances = rf.feature_importances_
indices = np.argsort(importances)[::-1][:10]
print("Top 10 Feature Importances:")
for rank, i in enumerate(indices, 1):
    bar = "█" * int(importances[i]*50)
    print(f"  {rank:2}. {data.feature_names[i]:<30} {bar} {importances[i]:.4f}")

[1] Markdown

🔷 Neural Networks with TensorFlow.js

Deep learning right in your browser — no GPU server needed. TF.js uses WebGL to accelerate training via your graphics card.

Automatic differentiation (backpropagation)
Dense, Conv2D, LSTM layers
Real-time training loss chart

[2] TF.js Check TF.js

// TF.js runs in the browser — click Run to check
const tf = window.tf;
console.log("TF version:", tf?.version.tfjs || "Loading...");
console.log("Backend:", tf?.getBackend() || "N/A");

[3] TF.js Train XOR Neural Network

// XOR problem — can't be solved by linear models
// A 2-layer neural net solves it perfectly
// Architecture: [2] → Dense(8, relu) → Dense(1, sigmoid)

[4] TF.js MNIST Digit Classifier (Mini)

// Synthetic digit-like dataset, 1000 samples
// CNN-like architecture via Dense layers
// Shows training progress epoch by epoch

[1] Markdown

📝 NLP with Python

Natural Language Processing basics — text classification, TF-IDF, word frequencies, and sentiment analysis.

[2] Python Text Classification (TF-IDF)

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score

# Sample text dataset
docs_train = [
    "Python is great for machine learning",
    "Deep learning uses neural networks",
    "Data science requires statistics and programming",
    "I love playing football and cricket",
    "The match was exciting and thrilling",
    "Sports keep us healthy and fit",
    "AI is transforming every industry",
    "Basketball and tennis are my favorites",
]
labels_train = ["tech","tech","tech","sports","sports","sports","tech","sports"]

docs_test = [
    "Neural networks are used in AI",
    "Cricket is played with a bat and ball",
    "scikit-learn is a Python library",
    "Football World Cup is happening soon",
]
labels_test = ["tech","sports","tech","sports"]

# Pipeline: TF-IDF → Naive Bayes
pipe = Pipeline([
    ('tfidf', TfidfVectorizer(ngram_range=(1,2))),
    ('clf',   MultinomialNB()),
])
pipe.fit(docs_train, labels_train)
preds = pipe.predict(docs_test)

print("=== Text Classification Results ===")
for doc, pred, true in zip(docs_test, preds, labels_test):
    icon = "✓" if pred == true else "✗"
    print(f"{icon} [{pred:>6}] {doc[:45]}")
print(f"\nAccuracy: {accuracy_score(labels_test, preds)*100:.0f}%")

[3] Python Word Frequency & Basic NLP

import re
from collections import Counter

text = """
Machine learning is a subset of artificial intelligence. 
Artificial intelligence enables machines to learn from data.
Deep learning is a subset of machine learning that uses neural networks.
Neural networks are inspired by the human brain. The brain learns from experience.
Data is the fuel of machine learning. More data means better learning.
"""

# Tokenize and clean
words = re.findall(r'\b[a-z]{3,}\b', text.lower())
stop  = {'the','and','is','a','of','that','from','are','by','in','to','more','means'}
words = [w for w in words if w not in stop]

freq = Counter(words).most_common(12)
print("=== Top 12 Words ===")
for word, count in freq:
    bar = "█" * (count * 3)
    print(f"  {word:<15} {bar} {count}")

print(f"\nTotal words: {len(words)} | Unique: {len(set(words))}")

[1] Markdown

✏️ Custom Notebook

Your blank notebook. Add cells, write code, experiment freely.

[1] Python

import numpy as np
import pandas as pd

# Start coding your ML experiment here!
print("✓ Remesys ML Studio — Custom Notebook")
print("✓ NumPy, Pandas, scikit-learn available")
print("\n# Try your own code below:")