Debasis Bhattacharjee

Supervised learning trains on labeled data (input-output pairs). Unsupervised learning finds patterns in unlabeled data with no predefined outputs.

Deep Dive: In supervised learning every training example has a correct answer (label). The algorithm learns to map inputs to outputs by minimizing prediction error. Examples: classification (spam/not spam) regression (predicting house prices). In unsupervised learning data has no labels. The algorithm discovers hidden structure: clustering groups similar items dimensionality reduction compresses features anomaly detection finds outliers. There is also semi-supervised learning (small labeled dataset + large unlabeled dataset) and self-supervised learning (labels generated from the data itself as in language model pretraining). Choosing the right paradigm depends on whether labeled data is available and how expensive it is to obtain.

Real-World: A credit card fraud detection system: training on historical transactions labeled as 'fraud' or 'legitimate' is supervised learning. Discovering clusters of unusual spending behavior without predefined fraud labels is unsupervised (anomaly detection). Real production systems often use both — unsupervised to surface suspicious patterns supervised to classify confirmed cases.

⚠ Common Mistakes: Thinking unsupervised learning is always worse because it has no labels — it is simply solving a different problem. Confusing clustering (unsupervised) with classification (supervised). Underestimating the cost and effort of labeling data for supervised learning at scale.

🏭 Production Scenario: A retail company tried to build a supervised product recommendation model but had insufficient labeled purchase-intent data. Switching to unsupervised collaborative filtering (clustering users by purchase history) produced better recommendations in production without requiring explicit labels.

Follow-up questions: What is semi-supervised learning? What is self-supervised learning as used in GPT? When is unsupervised learning preferred over supervised?

// ID: ML-BEG-001  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

'break' exits the loop entirely. 'continue' skips the current iteration and moves to the next. 'pass' does nothing — it is a placeholder.

Deep Dive: These three keywords control loop flow differently. 'break' immediately terminates the enclosing loop and execution continues after the loop block. 'continue' stops the current iteration and jumps back to the loop condition check. 'pass' is a null operation — it literally does nothing and is used when Python syntax requires a statement but you have no code to put there yet such as in an empty class or function body during development. Misunderstanding these leads to infinite loops or skipped logic in data processing pipelines.

Real-World: In a CSV data cleaning pipeline: 'continue' skips rows with missing values 'break' stops processing if a critical error is found in the data and 'pass' is used in an exception handler that acknowledges an error but intentionally takes no action (though this is usually bad practice in production).

⚠ Common Mistakes: Using 'pass' thinking it skips an iteration (it does not — use 'continue'). Using 'break' inside a nested loop thinking it exits all loops (it only exits the innermost one). Leaving 'pass' in production exception handlers silently swallowing errors.

🏭 Production Scenario: A data ingestion job was silently skipping thousands of records because a developer used 'pass' in an exception handler instead of 'continue' combined with logging. The job appeared to complete successfully but the database was missing 30% of expected records.

Follow-up questions: How do you break out of nested loops in Python? What is the for-else construct in Python? How does 'continue' interact with try-except blocks?

// ID: PY-BEG-004  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

'self' refers to the specific instance of the class that a method is being called on. It gives each instance access to its own attributes and other methods.

Deep Dive: When you define a method inside a class Python does not automatically know which instance the method is operating on. 'self' is the conventional first parameter that receives a reference to the calling instance. When you call instance.method() Python automatically passes the instance as the first argument — you never pass 'self' explicitly when calling. Without 'self' all instances of a class would share the same state which would make OOP impossible. The name 'self' is a convention not a keyword — you could use any name but deviating from convention is considered bad practice.

Real-World: In a User class for a web application self.username and self.email store per-instance data. When the send_email() method is called on a specific user object 'self' ensures the method sends to that user's email address not to some global or shared value.

⚠ Common Mistakes: Forgetting to add 'self' as the first parameter of an instance method causing a TypeError when called. Confusing instance methods (use self) with class methods (use cls) and static methods (use neither). Thinking 'self' is a keyword like 'this' in Java.

🏭 Production Scenario: A production multi-tenant SaaS application had a bug where all tenants were seeing the same configuration because a developer defined tenant settings as class-level attributes instead of instance attributes set via self. Every update to one tenant's config overwrote all others.

Follow-up questions: What is the difference between instance attributes and class attributes? What is @classmethod versus @staticmethod? Can you call a method without an instance using the class directly?

// ID: PY-BEG-005  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

F-strings (formatted string literals) are the modern Python way to embed expressions inside strings using f'text {expression}'. They are faster more readable and less error-prone than % formatting or str.format().

Deep Dive: Introduced in Python 3.6 f-strings evaluate expressions inside curly braces at runtime. The 'f' prefix before the quote tells Python to treat the string as a formatted literal. You can embed any valid Python expression: variables arithmetic function calls method calls conditional expressions. They are the fastest string formatting method in Python — benchmarks show f-strings are 40-70% faster than str.format() and significantly faster than % formatting because the expression evaluation happens at the bytecode level. Python 3.12 added even more f-string capabilities including reusing quote types inside expressions.

Real-World: In a web application logging system f-strings make log messages clear and fast: f'User {user.id} ({user.email}) performed {action} on resource {resource_id} at {timestamp}' — includes no string concatenation and is immediately readable during log review.

⚠ Common Mistakes: Using string concatenation with + instead of f-strings in high-frequency code paths. Forgetting that curly braces must be escaped as {{ and }} if you want literal braces. Using f-strings in logging calls when the string might never be formatted (use lazy % formatting for log messages to avoid building strings that are never logged at the configured log level).

🏭 Production Scenario: A high-throughput data processing service was building millions of formatted strings per hour using str.format(). Profiling showed string formatting as a significant CPU cost. Switching to f-strings reduced the formatting overhead by 45% contributing to a measurable throughput improvement.

Follow-up questions: What are the format specification mini-language options available in f-strings? How do f-strings handle multi-line expressions? What changed in Python 3.12 regarding f-strings?

// ID: PY-BEG-007  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

Classification predicts a category (discrete output). Regression predicts a continuous numerical value.

Deep Dive: In classification the output is one of a fixed set of categories: spam/not spam cat/dog/bird disease/healthy. Binary classification has two classes multiclass has more. The model output is typically a probability for each class and a threshold or argmax converts it to a final prediction. In regression the output is a continuous number: predicting tomorrow's temperature estimating a house price forecasting sales volume. The same algorithms often have both variants — linear regression vs logistic regression (despite the name logistic regression is a classifier) decision tree regressor vs classifier. Evaluation metrics differ: accuracy/F1 for classification RMSE/MAE/R2 for regression.

Real-World: A real estate platform uses regression to estimate property values (continuous output: $425000) and classification to predict whether a property will sell within 30 days (binary output: yes/no). Both models are trained on the same property feature data but with different target variables and evaluation strategies.

⚠ Common Mistakes: Using regression metrics (RMSE) to evaluate a classifier or vice versa. Treating a regression problem as classification by binning the output (losing information). Not recognizing that logistic regression IS a classifier despite the word 'regression' in its name.

🏭 Production Scenario: A demand forecasting system incorrectly used a classifier to predict inventory needs by bucketing demand into Low/Medium/High. The loss of continuous information caused systematic over-ordering. Switching to a regression model that predicted exact units improved inventory efficiency by 23%.

Follow-up questions: What is ordinal regression? How does multi-label classification differ from multiclass? What is the ROC curve and when is it used?

// ID: ML-BEG-003  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

AI is the broad field of making machines intelligent. Machine Learning is a subset of AI where systems learn from data. Deep Learning is a subset of ML using multi-layered neural networks. Each is more specific and powerful but also more data and compute intensive.

Deep Dive: AI (Artificial Intelligence) encompasses any technique that enables machines to simulate human intelligence — including rule-based expert systems search algorithms and ML. Machine Learning is the AI approach where systems improve through experience: instead of explicit programming they learn patterns from data. Traditional ML algorithms (decision trees SVMs linear regression) require manual feature engineering — humans decide what features to extract. Deep Learning uses neural networks with many layers that automatically learn hierarchical features from raw data. DL requires large amounts of data and GPU compute but achieves state-of-the-art performance on images text and audio. In 2025 when people say 'AI' in business contexts they usually mean ML or DL — specifically LLM-based systems.

Real-World: A spam filter using keyword rules is rule-based AI. A spam filter using logistic regression on email features (word counts sender history) is ML. A spam filter using a fine-tuned BERT model on raw email text is Deep Learning. All three are AI each progressively more powerful and data-hungry.

⚠ Common Mistakes: Thinking AI = Deep Learning = LLMs. Missing that many production 'AI' systems are traditional ML (gradient boosting random forests) which are often more interpretable cheaper and more appropriate for tabular data. Assuming more complex (deep learning) is always better — for structured/tabular data gradient boosting typically outperforms neural networks.

🏭 Production Scenario: A hospital wanted to predict patient readmission risk. A vendor proposed a deep learning solution requiring 10M training examples. The hospital had 50000 records. A properly tuned gradient boosting model (traditional ML) achieved 0.82 AUC on the available data while the deep learning approach overfit severely with only 0.68 AUC.

Follow-up questions: What is the difference between narrow AI and AGI? When should you use deep learning versus traditional ML? What is transfer learning?

// ID: AI-BEG-003  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

An LLM is a neural network trained on vast amounts of text to predict and generate language. Unlike traditional software with explicit rules LLMs learn statistical patterns from data and generate probabilistic outputs rather than deterministic ones.

Deep Dive: Traditional software follows explicit if-then rules written by programmers — the same input always produces the same output. LLMs are trained on hundreds of billions of text tokens using self-supervised learning (predicting the next word) developing internal representations of language knowledge and reasoning patterns. At inference time they generate text token by token each token sampled from a probability distribution. This means: the same input can produce different outputs (non-deterministic) the model can generalize to tasks it was never explicitly programmed for it can fail in unpredictable ways unlike traditional software which fails at known edge cases and its 'knowledge' is frozen at training time. Key components: transformer architecture attention mechanism tokenization and the pretraining + fine-tuning paradigm.

Real-World: When you ask a traditional search engine for 'Python list comprehension examples' it retrieves pages containing those exact keywords. When you ask an LLM it understands the intent generates an explanation tailored to apparent context (beginner vs expert) provides examples and can answer follow-up questions — all without having been explicitly programmed for your specific question.

⚠ Common Mistakes: Treating LLMs like databases that return facts reliably (they hallucinate). Expecting deterministic behavior (they are probabilistic). Assuming they have real-time information (they have a training cutoff). Building systems that rely entirely on LLM output without validation or grounding.

🏭 Production Scenario: A legal tech company built a contract review tool that used an LLM to check for specific clause types. In production the LLM occasionally hallucinated that clauses existed when they did not. The fix required adding a verification step that located the actual clause text in the document rather than trusting the LLM's claim.

Follow-up questions: What is the transformer architecture? What is the difference between GPT and BERT? What is fine-tuning versus prompting?

// ID: AI-BEG-001  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

Lists are mutable (changeable); tuples are immutable (fixed). Use tuples for data that should not change.

Deep Dive: In Python, a list is defined with square brackets [] and can be modified after creation — you can append, remove, or change elements. A tuple is defined with parentheses () and cannot be modified after creation. This immutability makes tuples slightly faster and hashable, meaning they can be used as dictionary keys or set members. Python internally optimizes tuple storage so they consume less memory than equivalent lists. The immutability also serves as a signal to other developers that this data is not meant to change.

Real-World: A Django settings file uses tuples for ALLOWED_HOSTS and INSTALLED_APPS because these values should be fixed at configuration time. Using a list there would work but signals the wrong intent to maintainers.

⚠ Common Mistakes: Using a list when the data never changes (wastes memory and loses semantic meaning). Trying to modify a tuple and getting a TypeError without understanding why. Forgetting that a tuple with one element needs a trailing comma: (42,) not (42).

🏭 Production Scenario: A production API was returning inconsistent responses because a developer accidentally appended to what should have been a fixed configuration list. Switching to a tuple made the bug immediately visible as a TypeError on the next attempted modification.

Follow-up questions: Can a tuple contain mutable objects? What is the performance difference between list and tuple iteration? When would you use a named tuple?

// ID: PY-BEG-001  ·  DIFFICULTY: 2/10  ·  ★★☆☆☆☆☆☆☆☆

Prompt engineering is the practice of designing inputs to LLMs to reliably produce desired outputs. It matters in production because the same model with different prompts can produce dramatically different quality format and accuracy of responses.

Deep Dive: LLMs are extremely sensitive to how questions and instructions are phrased. A vague prompt produces vague output. A well-structured prompt with context constraints examples and a clear output format produces consistent usable output. Key techniques: zero-shot prompting (just the instruction) few-shot prompting (instruction + examples) chain-of-thought prompting (asking the model to reason step by step) system prompts (persistent instructions that frame all interactions) output format specification (JSON markdown specific structure) role prompting (giving the model a persona) and constraint specification (word limits forbidden content required elements). In production prompts are version-controlled tested and iterated on like code.

Real-World: A customer intent classification system was achieving 67% accuracy with a simple prompt. Adding three labeled examples (few-shot) specifying the output as a JSON object with confidence scores and adding a chain-of-thought instruction to 'explain your reasoning before giving the final category' raised accuracy to 89% on the same model.

⚠ Common Mistakes: Writing prompts that work once and assuming they will always work — LLMs are sensitive to small wording changes. Not version-controlling prompts making production debugging impossible. Using prompts that work on GPT-4 and assuming they work identically on GPT-3.5 or other models. Ignoring prompt injection vulnerabilities when building user-facing systems.

🏭 Production Scenario: A content moderation system was incorrectly flagging safe content as harmful at a rate of 12%. Prompt analysis revealed the system prompt was ambiguous about edge cases. Adding 10 examples of borderline-safe content with explicit reasoning reduced false positive rate to 3% without model retraining.

Follow-up questions: What is chain-of-thought prompting? What is the difference between system and user prompts? How do you evaluate and A/B test prompts?

// ID: AI-BEG-002  ·  DIFFICULTY: 3/10  ·  ★★★☆☆☆☆☆☆☆

Overfitting is when a model learns the training data too well — including its noise — and performs poorly on new data. Detect it by comparing training and validation accuracy. Prevent it with regularization dropout more data or simpler models.

Deep Dive: A model overfits when it memorizes training examples rather than learning generalizable patterns. The tell-tale sign is high training accuracy but significantly lower validation/test accuracy — the gap between them is your overfitting signal. Prevention techniques: regularization (L1/L2 add penalty terms for large weights) dropout (randomly deactivating neurons during training) early stopping (halt training when validation loss stops improving) data augmentation (artificially expand training data) cross-validation (use all data for both training and validation) and reducing model complexity. The bias-variance tradeoff is the theoretical framework: overfitting is high variance underfitting is high bias.

Real-World: An image classification model for medical diagnostics achieved 99% training accuracy but only 71% on the validation set. Analysis showed it was memorizing specific image artifacts from the training hospital's scanner. Fixing required data augmentation (random crops flips brightness changes) and L2 regularization bringing validation accuracy to 89%.

⚠ Common Mistakes: Evaluating model performance only on training data and reporting those numbers. Not setting aside a test set that is never touched during development. Using the validation set for hyperparameter tuning and then reporting validation accuracy as if it were test accuracy (data leakage).

🏭 Production Scenario: A production churn prediction model was deployed with 94% training accuracy. In production it performed at 61% barely better than always predicting 'no churn'. Investigation revealed no validation split was used and the model had memorized customer IDs that leaked into the feature set.

Follow-up questions: What is the bias-variance tradeoff? How does cross-validation work? What is regularization and what is the difference between L1 and L2?

// ID: ML-BEG-002  ·  DIFFICULTY: 3/10  ·  ★★★☆☆☆☆☆☆☆