When we talk about Artificial Intelligence in healthcare, the first thing that comes to mind is usually accuracy. We want the model to predict correctly, whether it’s diagnosing eye diseases, classifying scans, or detecting early signs of Alzheimer’s.But here’s the truth I learned in my project is accuracy alone is not enough.


The Challenge I Faced
In my Alzheimer’s early detection project, the model was performing well on paper. ⛶Laporan Klasifikasi (Classification Report):

precision recall f1-score support

Mild Impairment 0.97 0.99 0.98 179
Moderate Impairment 1.00 0.92 0.96 12
No Impairment 0.99 1.00 0.99 640
Very Mild Impairment 0.99 0.98 0.98 448

accuracy 0.99 1279
macro avg 0.99 0.97 0.98 1279
weighted avg 0.99 0.99 0.99 1279

------------------------------------------------------
Matthew's Correlation Coefficient (MCC): 0.9781
------------------------------------------------------The numbers looked impressive, but there was still one big question:
How can we trust what the AI sees?
Doctors won’t just accept a probability score. Patients and their families won’t feel reassured just by a number. They need to know why the model made that decision.


Discovering Explainability with Grad-CAM
That’s where I explored Grad-CAM (Gradient-weighted Class Activation Mapping).Don’t worry, it’s not as complicated as it sounds. Grad-CAM creates a heatmap that highlights the regions of an image the model focuses on when making a prediction.In other words, it turns the “black box” into something more transparent and human-readable.


Before and After Grad-CAM
In my Alzheimer’s project, the difference was clear:


Before
The model predicted “Mild Demented” with high confidence, but I had no way to explain why.


After Grad-CAM
The heatmap showed exactly which parts of the brain scan the AI considered most important. And more importantly they were the medically relevant regions linked to early Alzheimer’s symptoms.That small shift made a big difference. Suddenly, the model wasn’t just a silent judge giving out labels. It became a tool that doctors could actually discuss, question, and trust.


What I Learned
This project taught me a valuable lesson:
Accuracy is powerful, but explainability is what builds trust.
In sensitive areas like healthcare, trust matters as much as performance.
Tools like Grad-CAM are not just technical tricks, they are bridges between AI researchers and medical professionals.



Final Thoughts
Working on this project reminded me why I got into AI research in the first place: not just to build models, but to build models that people can trust and use.Explainable AI is not optional anymore. It’s the key to making AI truly impactful in real life especially in areas that touch human health.See the full notebook of Alzheimer Detection here: https://www.kaggle.com/code/hafizabdiel/alzheimer-classification-with-swin-efficient-netIf you’re curious about my other AI projects, you can find them here: http://abdielz.tech/

The Subsets Pattern is widely used in combinatorial problems where we need to explore all combinations, subsets, or decisions (take/not take).
Amazon often uses this to test recursion + backtracking + BFS/DFS skills.


? When to Use Subsets Pattern?

Generate all subsets / combinations of a set
Handle decision-based recursion (pick or not pick)
Solve problems with combinatorial explosion (powerset, permutations, combination sums)
Explore feature toggles / inclusion-exclusion




? Problem 1: Generate All Subsets
? Amazon-style phrasing:
Given a set of distinct integers nums, return all possible subsets (the power set).


Java Solution (Backtracking)
⛶import java.util.*;

public class Subsets {
public static ListListInteger subsets(int[] nums) {
ListListInteger result = new ArrayList();
backtrack(nums, 0, new ArrayList(), result);
return result;
}

private static void backtrack(int[] nums, int index, ListInteger current, ListListInteger result) {
result.add(new ArrayList(current)); // add current subset

for (int i = index; i nums.length; i++) {
current.add(nums[i]); // include nums[i]
backtrack(nums, i + 1, current, result);
current.remove(current.size() - 1); // backtrack
}
}

public static void main(String[] args) {
int[] nums = {1, 2, 3};
System.out.println(subsets(nums));
}
}✅ Time Complexity: O(2^n)
✅ Space Complexity: O(n) recursion depth


? Problem 2: Subsets With Duplicates
? Amazon-style phrasing:
Given a collection of integers nums that might contain duplicates, return all possible subsets without duplicates.


Java Solution
⛶public class SubsetsWithDup {
public static ListListInteger subsetsWithDup(int[] nums) {
Arrays.sort(nums); // sort to handle duplicates
ListListInteger result = new ArrayList();
backtrack(nums, 0, new ArrayList(), result);
return result;
}

private static void backtrack(int[] nums, int index, ListInteger current, ListListInteger result) {
result.add(new ArrayList(current));

for (int i = index; i nums.length; i++) {
if (i index nums[i] == nums[i - 1]) continue; // skip duplicates
current.add(nums[i]);
backtrack(nums, i + 1, current, result);
current.remove(current.size() - 1);
}
}
}✅ Amazon Insight:
Tests your ability to handle duplicates gracefully with sorting + skipping.


? Problem 3: Letter Case Permutation
? Amazon-style phrasing:
Given a string s, return all possible strings after toggling case of each letter.


Java Solution
⛶public class LetterCasePermutation {
public static ListString letterCasePermutation(String s) {
ListString result = new ArrayList();
backtrack(s.toCharArray(), 0, new StringBuilder(), result);
return result;
}

private static void backtrack(char[] chars, int index, StringBuilder current, ListString result) {
if (index == chars.length) {
result.add(current.toString());
return;
}

char c = chars[index];
if (Character.isLetter(c)) {
current.append(Character.toLowerCase(c));
backtrack(chars, index + 1, current, result);
current.deleteCharAt(current.length() - 1);

current.append(Character.toUpperCase(c));
backtrack(chars, index + 1, current, result);
current.deleteCharAt(current.length() - 1);
} else {
current.append(c);
backtrack(chars, index + 1, current, result);
current.deleteCharAt(current.length() - 1);
}
}
}✅ Amazon Insight:
Tests creativity — it’s still a subsets problem but disguised with characters instead of numbers.


? Problem 4: Generate Balanced Parentheses
? Amazon-style phrasing:
Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.


Java Solution
⛶public class GenerateParentheses {
public static ListString generateParenthesis(int n) {
ListString result = new ArrayList();
backtrack(result, "", 0, 0, n);
return result;
}

private static void backtrack(ListString result, String current, int open, int close, int max) {
if (current.length() == max * 2) {
result.add(current);
return;
}

if (open max) backtrack(result, current + "(", open + 1, close, max);
if (close open) backtrack(result, current + ")", open, close + 1, max);
}
}✅ Amazon Insight:
Tests recursion depth + constraints (open ≤ close).


? Extended Problem List (Amazon Patterns)

Combination Sum (LeetCode 39)

Combination Sum II (LeetCode 40) – with duplicates
Permutations (LeetCode 46)

Permutations II (LeetCode 47) – with duplicates
Word Search II (Backtracking in Grid)
Sudoku Solver (Hard Backtracking)



? Key Takeaways

Subsets pattern = decision making (take / skip).
Natural recursion fits these problems well.
Amazon loves duplicates handling (sorting + skipping).
Expect parentheses, toggling, or string variants.
? Next in the series (Day 11):
? Modified Binary Search Pattern – super popular in Amazon interviews for rotated arrays, searching in infinite arrays, and tricky conditions.

If you use Windows daily, chances are you rely on screenshots more than you realize. Microsoft’s built-in Snipping Tool works in a pinch, but when you need speed, polish, and flexibility, it starts to fall short.That’s why I built Snipper — a lightweight screenshot app for Windows designed for developers, creators, and anyone who wants more control over their captures.


⚡ Key Features of Snipper
Snipper is a lean Windows Snipping Tool alternative whose focus is to take screenshots fast and make them look 10X more beautiful. All that in seconds!Below is a quick list of features that make Snipper a better alternative to any Windows screenshot tool out there currently.

Simple, fast UI → no clutter, no distractions.

Customizable backgrounds padding → make screenshots presentation-ready in seconds.

Watermark support → add your brand or name without extra editing tools.
*Lightweight build *→ unlike many third-party tools, Snipper won’t hog your system resources.



? Who is Snipper for?
Snipper fits perfectly in the workflow of different types of content creators, testing and QA people, managers, among many others. Here's a quick list of people who appreciate beautiful (and faster) screenshots to 10X their work and productivity.

Developers writing technical blog posts or docs.

Founders marketers creating quick product shots.
Anyone looking for a Snipping Tool alternative that feels modern.
Snipper is available for Windows now: Download hereIf you’ve been searching for the best screenshot tool for Windows that’s minimal, fast, and actually fun to use — give Snipper a spin.