Data science/ML/AI

🧩 Why One-Hot Encoding Exists

Machine learning models don't understand words.
They understand numbers.

So how do you feed a value like:

Color = Red

You can't simply write:

Red = 1
Blue = 2
Green = 3

The model might think Green > Blue > Red, even though colors have no natural order.

Instead, we create separate columns:

Red    1 0 0
Blue   0 1 0
Green  0 0 1

This is called One-Hot Encoding. It represents categories without introducing fake relationships.

🚨 UC Berkeley just open-sourced FreeToken.

It claims 2–4× faster local LLM inference than Ollama, and the wild part is the models it can run:
• Qwen3.6-35B on 8GB VRAM → 39.3 tok/s
• DeepSeek-V4-Flash 284B on 32GB VRAM → 22 tok/s
• GLM-5.2 753B on 96GB VRAM → 14.9 tok/s

How? These are Mixture-of-Experts models. A 35B model doesn't actually use all 35B parameters for every token.

FreeToken keeps the experts in system RAM and intelligently decides whether a missing expert should be sent to the GPU or computed on the CPU.

The good part is the best strategy depends on your exact machine. A 5090 desktop and an 8GB laptop may want completely opposite approaches.

It also checkpoints agent context, so coding agents don't repeatedly prefill thousands of unchanged tokens.

Open weights don't mean much if nobody can afford the hardware to run them. FreeToken is attacking that gap.

📄 Paper: https://arxiv.org/pdf/2608.16157
💻 Repo: https://github.com/FlashML-org/FreeToken

Topic: SQL

🔍 Quick look before the question:

SELECT e.name, e.salary
FROM employees e
WHERE e.salary > (
  SELECT AVG(salary)
  FROM employees
  WHERE department = e.department
);

🐼 One Pandas Function That Can Save You From Ugly if/else

Suppose you want to classify customers:

spending >= 1000 → VIP
spending >= 500  → Regular
otherwise        → Low

You could write a complicated function.
Or:

import numpy as np

df["segment"] = np.select(
    [
        df["spending"] >= 1000,
        df["spending"] >= 500
    ],
    [
        "VIP",
        "Regular"
    ],
    default="Low"
)

Now the rules are visible directly in the code.

This becomes especially useful when you have several conditions.

📚 12 Free Statistics Resources Worth Bookmarking

If your statistics foundation is weak, you'll spend more time memorizing algorithms than understanding them.
Here are 12 resources that are genuinely worth your time.

1. Penn State STAT Online
Complete university-level statistics courses available for free.

2. Seeing Theory
Interactive visualizations that make probability and statistics much easier to grasp.

3. OpenIntro Statistics
A free, beginner-friendly statistics textbook with exercises.

4. Introduction to Statistical Learning (ISLR)
One of the best books for learning statistical learning with practical R and Python examples.

5. Khan Academy Statistics & Probability
Excellent if you're starting from scratch.

6. StatQuest
Probably the clearest explanations of statistics and machine learning on YouTube.

7. Stanford Online (Statistics Courses)
Free lectures covering probability and statistical thinking.

8. Harvard CS109 Data Science
Statistics taught through real-world data analysis.

9. ProbabilityCourse.com
One of the best free references for probability concepts.

10. Statistics by Jim
Straightforward articles explaining common statistical concepts.

11. NIST e-Handbook of Statistical Methods
A comprehensive reference used by engineers, researchers, and analysts.

12. Cross Validated (Stack Exchange)
When you're stuck on a statistics question, chances are it's already been answered here.

⭐️ Bookmark this.

@datascience_bds

RAG vs. Graph RAG vs. Agentic RAG

Standard RAG embeds documents into vectors and retrieves similar chunks.
Effective for direct factual lookups, but fails when queries require connecting facts across multiple documents, as similarity search misses relationships between chunks.

Graph RAG adds a knowledge graph layer. An LLM extracts entities and relationships during indexing; retrieval traverses these connections rather than relying solely on embedding similarity. This enables multi-hop queries.

Example: Vector search retrieves "checkout service uses payments API" and "cluster-3 maintenance Friday" but misses "payments API runs on cluster-3" because the middle fact lacks query keywords. Graph traversal connects these entities, finding the full path in one query.

Agentic RAG uses an LLM agent to dynamically decide which tools to invoke, which sources to query, and in what order, rather than using a fixed pipeline.

The #1 problem with local AI seems to be solved now.

There’s a free tool called canIrun.ai that checks your hardware and tells you which models will actually run well before you download anything.

So instead of guessing and hitting out-of-memory errors…it grades every model against your machine.

What it does (right in your browser, no install):
→ detects your setup (RAM / CPU / GPU / VRAM)
→ scores each model for fit, speed, and context length
→ grades every quantization level (Q4_K_M, Q6_K, Q8_0, etc.)
→ labels what runs great vs okay vs too heavy

It covers most of the open-weight stack, Llama, Qwen, Gemma, Mistral, DeepSeek, Phi and more, pulling requirements from llama.cpp, Ollama, and LM Studio.

And it’s fully opensource.

📈 Mean vs Median

Suppose these are five salaries:

$35k, $38k, $42k, $44k, $2.5M

Mean (average): $531,800
Median (middle value): $42,000

The average suggests everyone is wealthy.
The median tells a completely different story.

👉 Whenever your data contains extreme values (called outliers), the median often represents the data much better than the mean.

That's why you'll often see median house prices and median income reported in the news.

📉 Why We Split Data

If you train and evaluate a model using the exact same dataset, you're only testing how well it remembers.

That's why datasets are usually split into:
👉 Training set → The model learns from this.
👉 Validation set → Used to tune model settings.
👉 Test set → Used only once at the end to measure real performance.

Think of it like studying for an exam.
Reading the textbook is training. Practice questions are validation. The final exam is the test set.

🐼 Pandas: The Dangerous Difference Between loc and iloc

Both select data. That's why beginners mix them up.

The simplest way to remember is:
loc → labels
iloc → positions

df.loc[5]

means:

Give me the row whose label is 5.

On the other hand:

df.iloc[5]

means:

Give me the 6th row.

Those are not necessarily the same row. Especially after filtering.
If your DataFrame index looks like:

0
1
4
7
9

then:

df.iloc[2]

returns the row at position 2. That's index label 4.

This tiny distinction causes a surprising number of bugs.

📊 10 Websites Every Data Scientist Should Bookmark
Whether you're learning data science or building production models, they'll save you a lot of time.

Google Dataset Search
Find millions of public datasets from universities, governments, and research organizations.

Our World in Data
High quality datasets with well-researched visualizations on health, climate, economics, energy, education, and more.

UCI Machine Learning Repository
One of the most widely used collections of datasets for machine learning practice and research.

Papers with Code
Research papers linked with official implementations, datasets, and benchmark leaderboards.

OpenML
A platform for sharing datasets, experiments, and reproducible machine learning workflows.

Data.gov
Over 300,000 public datasets published by the U.S. government.

Awesome Public Datasets
A massive GitHub repository of datasets organized by category.

Google Colab
Run Python notebooks in the cloud with free GPU access for many workloads.

Hugging Face Datasets
Thousands of ready-to-use datasets for NLP, computer vision, audio, and more.

Kaggle Datasets
Millions of datasets shared by the data science community.

⭐️ Save this post. You'll probably use these throughout your data science journey.

📘 R for Data Science

✍️ Authors: Garrett Grolemund, Hadley Wickham

🔗 Read Online

#Datascience #R
────────────────────
👉 @free_programming_books_bds 👈

✅ SQL Essentials for Data Science 🗄

👉 SQL remains an absolute must-have skill for anyone working in Data Science or Analytics.

Virtually every organization manages its core information inside databases, and SQL is the key to extracting, transforming, and analyzing that data.

🔹 1. What is SQL?

SQL = Structured Query Language

👉 Used to:

✔️ Query data
✔️ Filter records
✔️ Perform calculations
✔️ Uncover business insights

🔥 2. Popular Database Engines

✔️ PostgreSQL
✔️ MySQL
✔️ Snowflake
✔️ Google BigQuery

🔹 3. Basic SQL Query

✅ The SELECT Clause

Used to fetch records from a table.

SELECT * FROM customers;

👉 * retrieves every single column.

🔹 4. Fetch Specific Columns

SELECT full_name, total_spent FROM customers;

🔹 5. WHERE Clause

Used to apply filters to your data.

SELECT * FROM customers WHERE age >= 25;

🔹 6. ORDER BY

Sort your results.

SELECT * FROM customers ORDER BY total_spent DESC;

✔️ ASC → Ascending (Lowest to Highest)
✔️ DESC → Descending (Highest to Lowest)

🔹 7. Aggregate Functions

Used for summary statistics.

Function: COUNT()
Purpose: Counts the number of rows

Function: SUM()
Purpose: Adds values together

Function: AVG()
Purpose: Finds the mean value

Function: MAX()
Purpose: Finds the highest value

Function: MIN()
Purpose: Finds the lowest value

✅ Example

SELECT AVG(total_spent) FROM customers;

🔹 8. GROUP BY

Used to categorize data into buckets.

SELECT country, SUM(total_spent) FROM customers GROUP BY country;

🔹 9. Why SQL is Critical?

✔️ #1 requested technical skill in job descriptions
✔️ Used daily by analysts, data engineers, & data scientists
✔️ Scales seamlessly with massive enterprise datasets

❌ Cross Entropy Isn't Measuring Accuracy

Here's something that surprises a lot of people. These two predictions are both correct.

Prediction A

Cat: 51%
Dog: 49%

Prediction B

Cat: 99.9%
Dog: 0.1%

Accuracy treats them exactly the same. Cross Entropy doesn't. It rewards confidence only when the model is correct.

If the true class is "Cat":
Prediction A gets a relatively high loss. Prediction B gets a very small loss.

Now flip the prediction.

Cat: 0.1%
Dog: 99.9%

The loss explodes. That's because Cross Entropy isn't asking:

Did you get it right?

It's asking:

How confident were you in the correct answer?

That's why neural networks optimize Cross Entropy instead of accuracy.
Accuracy is too coarse to guide learning.

📍If Your Model Suddenly Gets Worse, Check These First

Before retraining everything, inspect:

• Data drift
• Missing values
• Feature distribution changes
• New categories
• Pipeline failures
• Label quality

Production issues are often data problems, not algorithm problems.