DEV Community: Sreehari S J

Building a Heart Risk Detector from Scratch with NumPy - Lessons in Overfitting & Neural Networks

Sreehari S J — Sat, 06 Sep 2025 15:59:41 +0000

As part of my journey into neural networks, I recently built a Heart Risk Detector from scratch using NumPy, no TensorFlow, no PyTorch. The goal was to predict the risk of heart disease using structured clinical data. Here’s a version of my experience, the technical choices I made, and the challenges I tackled.

The Project Overview

The model is a binary classifier trained on a dataset of numeric and categorical features. I implemented everything from scratch: data preprocessing, forward and backward passes, and training with regularization. Key highlights:

Data split: 70% train, 15% validation, 15% test (randomized but reproducible).
Preprocessing: Min-max normalization of numeric features, one-hot encoding for categorical features.
Model architecture:


  Input → Dense(16, ReLU) → Dropout → Dense(8, ReLU) → Dropout → Dense(1, Sigmoid)

Optimization: Mini-batch SGD with learning rate 0.01.
Regularization: L2 weight decay + Dropout.
Early stopping: Tracks validation loss to prevent overfitting.

Overfitting Struggles

At first, my model overfit quickly—training accuracy shot up, but validation stagnated. I realized that my network was memorizing the training data rather than learning patterns.

The method by which I solved it

Dropout: Applied 30% inverted dropout in hidden layers during training to prevent co-adaptation of neurons.
L2 Regularization: Penalized large weights, which helped reduce model complexity.
Early Stopping: Monitored validation loss and restored the best weights when no improvement was observed for 50 epochs.
Proper Data Preprocessing: Normalizing numeric features using only training stats and aligning categorical features across splits prevented subtle data leakage.

by doing this training and validation accuracies became much closer, and the model generalized better on unseen test data

Technical Insights From This

Forward & Backward Pass: Implemented ReLU and Sigmoid activations, and manually derived gradients for backpropagation.
Parameter Initialization: Used He/Xavier scaling to stabilize gradients.
Reproducibility: Fixed random seeds for data splits and dropout masks, ensuring consistent results across runs.

Lessons Learned

Building a neural network from scratch is valuable for understanding the math and mechanics behind high-level libraries.
Overfitting is inevitable with small datasets, but simple tools like dropout, L2, and early stopping can save the day.
Proper preprocessing and careful handling of categorical features can significantly affect model performance.

Next Steps

Experiment with Adam optimizer and learning rate schedules.
Implement Batch Normalization to mitigate internal covariate shifts.
Explore imbalanced datasets handling with class weighting or focal loss.

This project was not just a technical work taught me patience, debugging, and how subtle design choices impact model performance.

If you’ve ever stucked with overfitting or any experience I’d love to hear your experience!

Check out my linkedin post about this

Give me a star on github if you like it

Building My First AI Project: Tic Tac Toe with Minimax (No ML Libraries)

Sreehari S J — Wed, 03 Sep 2025 10:43:26 +0000

I recently started exploring AI through Harvard CS50’s AI course, and I decided to implement my first AI project from scratch in Python: a Tic Tac Toe AI using the Minimax algorithm.

The goal wasn’t just to make a working game—but to understand AI concepts deeply by implementing them myself. Here’s a breakdown of what I learned and applied.

What I Learned from CS50 AI

The course covers a broad spectrum of AI topics:

Search – How to find solutions to problems, like navigating from point A to B or making optimal moves in a game.
Knowledge & Inference – Representing information and drawing conclusions from it.
Uncertainty – Using probability to make decisions under uncertain conditions.
Optimization – Not just finding any solution, but the best solution.
Learning – Improving performance from experience, like distinguishing spam emails.
Neural Networks & Language Processing – For more complex AI tasks beyond search and strategy.

I focused on search and adversarial search, which are foundational for game AI.

Core Concepts Applied

Before coding, I had to understand a few key AI concepts:

Agent – The “decision-maker” in the system (our AI player).
State – A snapshot of the environment (board configuration).
Actions – Possible moves from a state.
Transition Model – What happens when an action is applied.
State Space – All possible states reachable from the initial state.
Goal Test & Utility – Checking if the game is over and assigning value (+1 win, -1 loss, 0 tie).

This framework helped me reason about the game in a structured, AI-centric way rather than just coding moves randomly.

Why Minimax?

Tic Tac Toe is a small, adversarial game, which makes it perfect to experiment with Minimax:

Maximizer vs Minimizer – The AI tries to maximize its score while assuming the opponent tries to minimize it.
Recursion – For each move, the algorithm simulates all possible future moves to decide the best one.
Depth-Limited Search – Useful for bigger games (like Chess) to avoid exploring an intractable number of states.
Alpha-Beta Pruning – Skips obviously bad moves to optimize computation.

By implementing Minimax, I could see firsthand how the AI anticipates every possible opponent move—something that reading theory alone can’t fully convey.

Implementation Insights

I built functions like:

Actions(state) – Returns all valid moves.
Result(state, action) – Returns the board after a move.
Terminal(state) – Checks if the game is over.
Utility(state) – Evaluates the outcome of terminal states.

Then, using recursive Max-Value and Min-Value functions, the AI evaluates each move:

def max_value(state):
    if terminal(state):
        return utility(state)
    v = -float('inf')
    for action in actions(state):
        v = max(v, min_value(result(state, action)))
    return v

The minimizing player works similarly, ensuring optimal play from both sides. The result? An AI that never loses.

Lessons Learned

Minimax is ideal for small, perfect-information games.
Real-world games require heuristics and pruning strategies to handle enormous state spaces.
Coding the algorithm reinforced my understanding of state spaces, goal tests, and recursive evaluation far better than studying theory alone.

This project gave me a solid foundation in adversarial search, and I’m now excited to tackle larger games and explore heuristic-based AI.

Next Steps

Apply depth-limited Minimax to Chess or Connect Four.
Explore heuristics and evaluation functions for faster decision-making.
Experiment with reinforcement learning for more complex AI.

Share your thoughts on my post here : Linkedin Post

Check out the code here: Tic Tac Toe Minimax Python

Tags:
#AI #Python #GameAI #Algorithms #Minimax #AdversarialSearch #CS50 #Programming #LearningByDoing

Credit:
Images and course content referenced in this post are from Harvard CS50’s Introduction to Artificial Intelligence with Python.

Encypher : Secure Your React State with Encrypted localStorage and sessionStorage

Sreehari S J — Mon, 01 Sep 2025 15:42:16 +0000

As developers, we often store user preferences, tokens, and other sensitive data in the browser. But how secure is your localStorage or sessionStorage? Enter Encypher – a lightweight React hook that brings AES-GCM encryption to your front-end state management with an easy useState-like API. Let’s dive in!

Why You Need Encrypted Storage in React

React makes state management easy, but storing data directly in the browser can be risky:

Tokens and session info are vulnerable to XSS attacks.
localStorage/sessionStorage is plaintext by default.
Legacy fallback mechanisms often sacrifice security.

Encypher solves this by encrypting data with AES-GCM and providing optional XOR fallback for legacy browsers. You can also set a time-to-live (TTL) for auto-expiring storage.

Key Features of Encypher

AES-GCM encryption using the Web Crypto API.
Custom secret per hook or global via EncryptedStorageProvider.
Optional TTL for expiring sensitive data.
Works with localStorage, sessionStorage, or custom storage.
Syncs across tabs/windows.
XOR fallback for legacy browsers (not secure).
Simple API: [value, setValue, remove, reencrypt].
Tested with React 17/18.

Installation

npm install encypher
# or
yarn add encypher

Then import the hook into your React component:

import { useEncryptedStorage } from "encypher";

Basic Usage Example

import { useEncryptedStorage } from "encypher";

function MyComponent() {
  const [user, setUser, removeUser] = useEncryptedStorage("user", null, {
    secret: "my-strong-secret",
    storage: "local", // "session" is also supported
    ttl: 3600 * 1000, // 1 hour TTL
  });

  return (
    <div>
      <button onClick={() => setUser({ name: "John Doe" })}>
        Store User
      </button>
      <button onClick={removeUser}>Remove User</button>
      <pre>{JSON.stringify(user, null, 2)}</pre>
    </div>
  );
}

Tip: Treat useEncryptedStorage like useState, but with encryption built-in.

Using a Global Secret with Provider

import { EncryptedStorageProvider, useEncryptedStorage } from "encypher";

function App() {
  return (
    <EncryptedStorageProvider secret="my-global-secret">
      <MyComponent />
    </EncryptedStorageProvider>
  );
}

Custom Storage

const customStorage = {
  getItem: (key) => window.localStorage.getItem(key),
  setItem: (key, value) => window.localStorage.setItem(key, value),
  removeItem: (key) => window.localStorage.removeItem(key),
};

const [data, setData] = useEncryptedStorage("key", {}, {
  secret: "my-secret",
  storage: customStorage
});

API Overview

useEncryptedStorage(key, initialValue, options) returns:

[value, setValue, remove, reencrypt]

value: current decrypted value
setValue(val): asynchronously encrypt and store
remove(): remove stored value
reencrypt(newSecret): re-encrypt existing data

Options object includes:

{
  secret,          // Required encryption key
  storage,         // "local", "session", or custom
  ttl,             // Optional expiration time
  fallback,        // "xor" for legacy fallback
  onFallback,      // Callback if fallback is used
  onError,         // Callback on error
  onReencrypt      // Callback after re-encryption
}

Security Notes

Always use a strong, unique secret.
XOR fallback is insecure, only for non-sensitive data.
AES-256 keys are derived via PBKDF2.
Not suitable for highly sensitive or regulated data.

Encypher Demo Website

Test all features live on the Encypher Demo Website.

Demo Highlights:

Encryption & decryption with custom secrets
TTL-based expiry testing
Debug view of encrypted data
Real-time interactive testing

Why Encypher is Developer-Friendly

Easy to adopt: useState-like API means zero learning curve.
Flexible: Use localStorage, sessionStorage, or custom storage.
Secure by default: AES-GCM ensures modern encryption standards.
Reactive: Works seamlessly with React state updates.

Conclusion

Secure your React state in style! Whether you’re storing user tokens, preferences, or other sensitive data, Encypher makes encryption effortless.

Pro Tip: Combine Encypher with your existing state management to add a security layer without changing your workflow.

Get started today:

NPM Package: encypher
GitHub Repo: sjsreehari/encypher
Demo: encypher-demo-website.netlify.app

Follow me for more tips and tools on React and front-end development!