DEV Community: Lini Abraham

Destructuring in TypeScript: Arrays & Objects

Lini Abraham — Sun, 01 Jun 2025 06:56:48 +0000

Destructuring is a powerful feature in JavaScript (and TypeScript) that lets you unpack values from arrays or extract properties from objects into distinct variables.

1. Array (List) Destructuring

Basic Example

const nums = [10, 20, 30];

const [first, second] = nums;

console.log(first);  // 10
console.log(second); // 20

Skipping values

const [ , , third] = nums;
console.log(third); // 30

Default values

const [a = 1, b = 2, c = 3] = [undefined, undefined];
console.log(a, b, c); // 1 2 3

2. Object Destructuring

Basic Example

const user = { name: "Alice", age: 25 };

const { name, age } = user;

console.log(name); // "Alice"
console.log(age);  // 25

Renaming variables

const { name: fullName } = user;
console.log(fullName); // "Alice"

Default values

const { city = "Unknown" } = user;
console.log(city); // "Unknown"

3. Nested Destructuring

const data = {
  user: {
    profile: {
      username: "bob123",
      email: "bob@example.com"
    }
  }
};

const {
  user: {
    profile: { username }
  }
} = data;

console.log(username); // "bob123"

4. Destructuring in Function Parameters

With objects

function greet({ name, age }: { name: string; age: number }) {
  console.log(`Hello ${name}, age ${age}`);
}

greet({ name: "Charlie", age: 30 });

With arrays

function sum([a, b]: [number, number]) {
  return a + b;
}

console.log(sum([5, 7])); // 12

5. Combining with Rest (...)

Arrays

const [head, ...tail] = [1, 2, 3, 4];
console.log(head); // 1
console.log(tail); // [2, 3, 4]

Objects

const { a, ...rest } = { a: 1, b: 2, c: 3 };
console.log(a);    // 1
console.log(rest); // { b: 2, c: 3 }

Destructuring with TypeScript Types

type User = {
  id: number;
  name: string;
  email?: string;
};

const user: User = { id: 1, name: "Dana" };

const { id, name, email = "N/A" } = user;

TypeScript: Record vs Map — What’s the Difference and When to Use Each?

Lini Abraham — Sun, 01 Jun 2025 00:35:00 +0000

In TypeScript, both Record and Map allow you to store key-value pairs. But they’re not the same, and choosing the right one can improve readability, performance, and type safety in your code.

What is a Record in TypeScript?

A Record is a TypeScript utility type that defines an object with keys of type K and values of type V.

It compiles to a plain JavaScript object.

const links: Record<string, string> = {
  home: "/",
  about: "/about",
  contact: "/contact"
};

console.log(links["about"]); // "/about"

• Keys must be string or number

How to iterate over a record

Option 1: using object.entries

const links = {
  home: "/",
  about: "/about",
  contact: "/contact"
};

type LinkKeys = keyof typeof links;

(Object.entries(links) as [LinkKeys, string][]).forEach(([key, value]) => {
  console.log(`${key.toUpperCase()} => ${value}`);
});

Option 2: Using for...in loop


const links = {
  home: "/",
  about: "/about",
  contact: "/contact"
};

// Step 1: Infer the type of the object
type Links = typeof links;

// Step 2: Extract keys as a union type: "home" | "about" | "contact"
type LinkKey = keyof Links;

for (const key in links) {
  // Step 3: Guard against prototype pollution
  if (Object.prototype.hasOwnProperty.call(links, key)) {
    // Step 4: Narrow `key` to LinkKey so it's not just `string`
    const typedKey = key as LinkKey;

    // Now you have full type safety
    const path = links[typedKey];
    console.log(`${typedKey} → ${path}`);
  }
}

What is a Map?

A Map is an ES6 built-in object that allows you to store key-value pairs with:
•Any key type (not just strings)
•Guaranteed insertion order
•Built-in iteration and utility methods


const linkMap = new Map<string, string>();
linkMap.set("home", "/");
linkMap.set("about", "/about");
linkMap.set("contact", "/contact");

console.log(linkMap.get("about")); // "/about"

How to iterate over a Map

Define links as a Map

const links = new Map([
  ["home", "/"],
  ["about", "/about"],
  ["contact", "/contact"],
]);

*Use typeof + keyof for key constraints to restrict the keys (home, about, contact) *

const linkObj = {
  home: "/",
  about: "/about",
  contact: "/contact"
};

type LinkKeys = keyof typeof linkObj;         // "home" | "about" | "contact"
type LinkMap = Map<LinkKeys, string>;

const links = new Map<LinkKeys, string>(Object.entries(linkObj) as [LinkKeys, string][]);

Iteration Method 1: for...of

for (const [key, value] of links) {
  // key is strongly typed as "home" | "about" | "contact"
  console.log(`${key.toUpperCase()} => ${value}`);
}

Iteration Method 2: .forEach()

links.forEach((value, key) => {
  console.log(`${key} => ${value}`);
});

Iteration Method 3: Array.from() with map()

Array.from(links.entries()).map(([key, value]) => {
  console.log(`${key}: ${value}`);
});

NOTE: How does Array.from work

const links = new Map([
  ["home", "/"],
  ["about", "/about"],
]);

const linkArray = Array.from(links); 
// => [ ["home", "/"], ["about", "/about"] ]

linkArray.forEach(([key, value]) => {
  console.log(`${key} => ${value}`);
});

Record vs Map — Comparison Table

Feature	`Record`	`Map`
Key Types	Only `string` or `number`	Any type (`string`, `object`, etc.)
Insertion Order	Not guaranteed	Preserved
Iteration	Use `Object.entries()`	Directly iterable
Serialization	Easy with `JSON.stringify()`	Requires `Object.fromEntries()`
Utility methods	None	`.get()`, `.set()`, `.has()`, etc.
Use Case	Static config/data	Dynamic keys, complex structures
Example	`{ home: "/", about: "/about" }`	`new Map([["home", "/"], ["about", "/about"]])`

When Should You Use Which?

💡 Use Case	Choose
Static data, config, known string keys	`Record`
Dynamic key-value data, insertion order needed	`Map`
You need methods like `.has()` or `.delete()`	`Map`
Easy serialization (e.g., API responses)	`Record`

Prompt Response Tuning with Temperature, Top-p, and Top-k

Lini Abraham — Sat, 31 May 2025 02:40:03 +0000

Language models like GPT don’t “think” in full sentences — they predict one token at a time, where a token is a chunk of text (often a word or part of a word) created through a process called tokenization. At each step, the model chooses the next token based on probabilities — and decoding parameters like temperature, top-k, and top-p control how predictable, random, or creative those token choices are.

Temperature

Temperature controls how random or focused the model’s word choices are.

A low temperature (e.g., 0.2) makes the output more predictable — the model sticks to the most likely words.
A high temperature (e.g., 1.0 or more) makes the output more creative, possibly even risky or unusual.

Temperature	Behavior
0.0	Deterministic, safest
0.3 – 0.7	Predictable, less risky
1.0	Balanced randomness (default for GPT)
>1.0	Creative, more surprising, possibly noisy
>1.5	Often too chaotic or nonsensical

Temperature is usually in the range of 0.0 to 2.0.

Top-k Sampling

Top-k limits the model to the top k most likely tokens, then picks one randomly from that group.

Top-k = 1 → Always picks the most probable word (like greedy decoding).
Top-k = 40 → Picks from the 40 best guesses, adding variety without going off-topic.

Top-k Value	Behavior
1	Safe but repetitive
10–50	Good diversity, still smart
100+	More variety, more risk

Top-k value ranges from a minimum of 1 up to a maximum of the total vocabulary size (which can be ~50,000 tokens for GPT models)

Top-p Sampling (Nucleus Sampling)

Top-p chooses from the smallest set of tokens whose total probability adds up to at least p.
If Top-p = 0.9, the model picks from the most likely words that together make up 90% of the probability mass.
Unlike top-k, this list can grow or shrink dynamically depending on the situation.

Top-k Value	Behavior
0.7	Very conservative
0.9	Balanced, avoids outliers
1.0	Like no filter — all options allowed

Top-p value ranges from 0 to 1

Top-p sampling (short for “probability sampling”) is also known as Nucleus sampling. It works in the following way:

Sorts the tokens from most to least likely
Selects the smallest group of tokens whose cumulative probabilities add up to at least p (like 0.9)
Randomly picks one token from that set This selected group is what we call the nucleus.

The nucleus is the tight cluster of highest-probability tokens — the model’s most confident guesses.

Instead of sampling from all possible tokens (many of which are low-probability and often nonsensical), we focus on the most meaningful subset — the nucleus of the probability mass.

What is RAG (Retrieval- Augumented Generation)

Lini Abraham — Tue, 27 May 2025 11:46:30 +0000

RAG allows the AI model to look things up before answering a question.

RAG is an AI technique that combines two powerful components:

1.  A retriever that searches for relevant information from external sources
2.  A generator (like GPT or Claude or any other AI model) that uses that information to craft accurate, grounded responses

RAG is used in scenarios such as:

Recent data or information is required to answer a question
Information needs to be retrieved from private documents

How does RAG work?

Let’s say you ask an AI assistant:

“What’s our company’s refund policy?”

The question is converted into a vector (a list of numbers that captures the meaning)
It searches a vector database of your documents (like PDFs, FAQs, or manuals)
It retrieves the most relevant chunks of text
It inserts those chunks into the prompt sent to the language model
The model then generates an answer based on both your question and the retrieved info

RAG processing step by step

1.Split Documents into Chunks (Document Chunking)
•Your company's HR policy PDF is split into small, readable chunks (e.g., 200–500 words each).

Example Chunk:

“Employees are eligible for health benefits after 90 days of full-time employment…”

2.Generate Embeddings (Using Embedding Model)
•Each chunk is passed through an embedding model (e.g., Amazon Titan Embeddings).
•Output: a vector (a list of numbers) representing the meaning of the text.
•A high dimensional vector can capture complex meaning, relationships and semantic context in:
• Words and sentences (via embeddings)
• Images
• User behavior

The more dimensions, the more nuance the vector can represent — like tone, topic, or context.

Example

Chunk vector → 0.21, -0.64, 0.48, …, 0.02

3.Store in Vector Database
•All vectors are stored in a vector DB (e.g., Amazon OpenSearch, Kendra, Pinecone).
•Each vector is linked to its original text chunk.

Now your database can search by meaning, not just keywords.

⸻

RUNTIME (When User Asks a Question)

⸻

4.User Asks a Question

“When do I qualify for health benefits?”

5.Convert Question to a Vector (Query Embedding)
•The question is passed through the same embedding model.
•Result: a query vector that captures the semantic meaning of the question.

6.Semantic Search in Vector DB
•The query vector is compared to all stored vectors using cosine similarity (or similar metric).
•The most relevant document chunks are retrieved — even if the wording doesn’t match exactly.

Retrieved chunk:

“Employees are eligible for health benefits after 90 days…”

7.Augment the Prompt
•The retrieved chunks are inserted into the prompt along with the user’s question:

Prompt to the foundation model:

Context:
"Employees are eligible for health benefits after 90 days of full-time employment."

Question:
"When do I qualify for health benefits?"

8.Foundation Model Generates Answer

“You qualify for health benefits after 90 days of full-time employment, according to company policy.”

Benefits of Using RAG

No fine-tuning needed: You don’t have to retrain the model
Up-to-date answers: Pull from the latest documents
Custom knowledge: Use your own files, policies, or FAQs
Fewer hallucinations: Grounded responses using real data

Precision v/s Recall in Machine Learning

Lini Abraham — Sat, 24 May 2025 06:03:03 +0000

Precision and recall are two core metrics used in evaluating the performance of a binary or multi-class classification model. Both focus on how well the model handles positive cases

Precision

Precision indicates how many of the items your model predicted as positive were actually correct.

• Measures the correctness of positive predictions
• Focuses on being accurate when saying “positive”
• When your model says “Yes” or “Positive,” how often is it right?
• Penalizes False Positives (FP). Precision score is higher when there are fewer false positives.
• Higher when the model is conservative (fewer false alarms)

Precision = True Positive / True Positives (TP) + False Positives (FP)

Use Cases :

•     Spam detection: You want to avoid flagging legitimate emails as spam.

•     Medical diagnostics: Sometimes, you want to avoid false alarms that could cause stress or unnecessary tests.

Recall

Recall indicates how many of the actual positives your model was able to find. Of all the real positive cases, how many did the model catch?

• Measures the coverage of actual positives
• Focuses on finding all real positives
• When your model says “Yes” or “Positive,” how often is it right?
• Penalizes False Positives (FP). Precision score is higher when there are fewer false positives.

• Higher when the model is conservative (fewer false alarms)

Recall = True Positive / True Positives (TP) + False Negatives (FN)

Use Cases:
• Disease detection: You don’t want to miss any sick patients, even if it means a few healthy ones get flagged.
• Fraud detection: Better to investigate more cases than miss a real fraud.

Summary

NLP Evaluation Matrices

Lini Abraham — Sat, 24 May 2025 03:28:37 +0000

ROUGE - Recall-Oriented Understudy for Gisting Evaluation

Compares the overlap of words or phrases between the generated and reference texts.
• Focuses on recall — did the model capture the key ideas?
• Best for summarization and information(content) coverage.

Reference Summary:

“The quick brown fox jumps over the lazy dog.”

Generated Summary:

“The brown fox leaps over a lazy dog.”

ROUGE-1 = unigram overlap

Compares single-word overlaps.
Matching Words:
    • the, brown, fox, over, lazy, dog → 6 matches

Not Matching:
    • quick, jumps (in reference)
    • leaps, a (in generated)

ROUGE-1 Score =
Overlapping unigrams/Total unigrams in reference = 6/9 = 0.667

ROUGE-2 = bigram overlap

Compares 2-word sequences that appear in order.

Matching Bigrams:
    • “brown fox”
    • “over the”
    • “lazy dog” → 3 matches

Not Matching:
    • “quick brown”, “fox jumps”, etc. (not in generated)

ROUGE-2 Score =
3/8 = 0.375

ROUGE-S = Skip-Bigram Overlap

Compares skip-bigrams — word pairs that occur in the same order but not necessarily adjacent.

Examples of Matching Skip-Bigrams:
    • (“the”, “fox”)
    • (“brown”, “dog”)
    • (“fox”, “over”)
    • (“the”, “dog”)
These words appear in order in both sentences, though not next to each other.

Skip-bigrams in reference: 36 possible
Matched skip-bigrams: ~12 (depending on allowed skips)

ROUGE-S Score (approximate) =
12/36 = approx 0.33

ROUGE-L = longest common subsequence

Finds the longest sequence of words that appear in order (not necessarily adjacent) in both texts.

LCS:
    • “the brown fox over the lazy dog” (but “quick” and “jumps” are missing)

Length of LCS = 7 words

ROUGE-L Score =
7/9 = approx 0.778

ROUGE Variants - Summary

BLEU - Bilingual Evaluation Understudy

• Looks at n-gram precision — how much of the generated text matches the reference exactly.
• Originally designed for machine translation.
• Focuses on precision — are the predicted words correct?

Includes a brevity penalty to discourage overly short translations.

Example:

Reference sentence:

“The quick brown fox jumps over the lazy dog”

Model output:

“The fox”

It matches 2 words, but the answer is way too short.
Brevity Penalty reduces the BLEU score.

BERT Score

BERTScore measures how similar two pieces of text are in meaning using BERT, a powerful language model.

Unlike ROUGE and BLEU, which compare words exactly,
**BERTScore compares the meanings of words — even if the exact words are different.

BERTScore checks whether the words in the generated sentence mean the same thing as in the reference sentence

It uses word embeddings (like word meanings in number form) to do this.

Example:

Reference:

“The dog barked loudly.”

Generated:

“The canine made noise.”

    • BLEU/ROUGE = low (few exact matches)
    • BERTScore = high (words mean similar things: dog = canine, barked = made noise)

How Does It Work?
• Turns each word in both sentences into vectors using BERT (context-aware).
• For each word in one sentence, it finds the most similar word in the other.
• Calculates precision, recall, and F1 score based on semantic similarity.

Playwright Useful Resources

Lini Abraham — Wed, 07 May 2025 00:48:10 +0000

https://playwrightsolutions.com/playwright-resources/

https://playwright.tech/

https://dev.to/t/playwright

https://medium.com/@lucgagan/mastering-playwright-best-practices-for-web-automation-with-the-page-object-model-3541412b03d1

https://playwrightsolutions.com/the-definitive-guide-to-api-test-automation-with-playwright-part-8-adding-eslint-prettier-and-husky/

https://playwrightsolutions.com/how-to-run-a-specific-spec-file-playwright-tests-sequentially/

https://debbie.codes/blog/tags/playwright

https://dev.to/jsfez/why-playwright-visual-testing-doesnt-scale-1ole

AI Terms

Lini Abraham — Sun, 04 May 2025 02:05:01 +0000

Weights

A number that says how important an input is.

High weight = input is very important.
Low weight = input barely matters.

Biases

A number that shifts the output up or down, no matter what the inputs are.

A default setting.
Even if the input is zero, the neuron can still produce something.

Activation functions

A function that decides if a neuron should “fire” or how strong its signal should be.

It`s like a gatekeeper.
Only lets important signals through.

Feed-forward propagation

The process where the input goes through the network and creates an output.

Information moves forward only.

Back propagation

The process where the network learns from mistakes by adjusting weights and biases.

It`s similar to a correction loop where you make a mistake, figure out what went wrong, and adjust your thinking.

L1 and L2 Regularisation

Tricks to stop the model from memorizing too much (overfitting).

It`s a discipline rule to keep the model simple and focused.

L1: Can make the model ignore useless inputs completely.
L2: Smooths out the model’s focus to avoid extreme values.

Gradients

A slope that tells the network how to change the weights and biases to get better.

The gradient shows the direction and size of the correction needed.

Gradient Descent	Gradient Ascent
Moves in the direction that reduces the output (minimizes loss)	Moves in the direction that reduces the output (minimizes loss).
Goal: Find the lowest point (minimum)	Goal: Find the highest point (maximum)
Used for: Minimizing error/loss	Used for: Maximizing likelihood, rewards (like in reinforcement learning to maximize rewards)

Cost/Loss Function

A Cost Function is a formula that tells you how wrong your model’s predictions are.
It compares the actual value and the expected value

The goal of training an AI model is to reduce costs so that predictions get closer to the true answers.

Hyperparameters

The settings you choose before training the model.

For example, how fast to learn (learning rate), how many neurons to use, etc.

k6

Lini Abraham — Sun, 04 May 2025 02:03:49 +0000

Jmeter

Lini Abraham — Sun, 04 May 2025 02:03:37 +0000

Jmeter, InfluxDB and, Grafana resources

https://community.ibm.com/community/user/blogs/gaurav-dangaich/2024/02/07/jmeter-integration-with-influxdbv2-and-grafana

https://www.blazemeter.com/blog/jmeter-grafana

https://shrihariharidas73.medium.com/ultimate-guide-to-load-testing-and-performance-monitoring-with-jmeter-influxdb-and-grafana-1c208a9c8434

Other useful resources

https://www.blazemeter.com/author/yuri-bushnev

Courses

https://university.blazemeter.com/learn/courses/485/apache-jmeter-intro/lessons/1543:164/apache-jmeter-intro

https://university.blazemeter.com/learn/courses/491/apache-jmeter-pro/lessons/1582:172/apache-jmeter-pro

AI Classification and Regression Model Metrics

Lini Abraham — Wed, 30 Apr 2025 12:15:01 +0000

Classification Metrics (used when predicting categories):

A confusion matrix is a table used to evaluate the performance of a classification model by showing the true and predicted classifications for a set of test data. It helps in visualizing and analyzing how well the model is performing, especially for multi-class classification problems. The confusion matrix provides a detailed breakdown of the correct and incorrect predictions, making it easier to understand the types of errors the model is making.

Accuracy: The proportion of correct predictions (both true positives and true negatives) out of all predictions.

Accuracy = (TP + TN) / (TP + TN + FP + FN)
Precision: The proportion of true positive predictions out of all positive predictions made by the model.

Precision (Positive Predictive Value) = TP / TP + FP
Recall (Sensitivity, True Positive Rate): The proportion of actual positives correctly identified by the model. Recall represents from all the positive classes how many we predicted correctly.
Recall should be as high as possible.The term “recall” reflects the model’s ability to “recall” or recognize as many true positive instances as possible from the actual positive cases in the dataset. It focuses on minimizing the number of false negatives, ensuring that the model identifies the majority of relevant instances.

Recall = (TP) / (TP + FN)
F1 Score: The harmonic mean of precision and recall, providing a single metric that balances both.

F1 Score = 2 * (Precision * Recall) / (Precision + Recall)
Specificity (True Negative Rate): The proportion of actual negatives correctly identified by the model.

Specificity = TN / (TN + FP)
ROC-AUC (Receiver Operating Characteristic - Area Under the Curve)
The ROC curve plots the true positive rate (recall) against the false positive rate at various threshold settings. The AUC (Area Under the Curve) represents the likelihood that the model will rank a randomly chosen positive instance higher than a randomly chosen negative one.
https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc
PR-AUC (Precision-Recall Area Under the Curve): The Precision-Recall curve plots precision against recall at various threshold settings. The AUC represents the balance between precision and recall across different thresholds.
Logarithmic Loss (Log Loss): Log Loss measures the performance of a classification model where the output is a probability value between 0 and 1. It penalizes incorrect classifications with more confidence more than those with less confidence.

Regression Metrics (used when predicting numbers):

Mean Absolute Error (MAE): MAE measures the average absolute difference between the predicted values and the actual values. It provides a straightforward interpretation of the error magnitude.
Mean Squared Error (MSE): MSE measures the average squared difference between the predicted values and the actual values. It penalizes larger errors more heavily than MAE, due to the squaring of the differences.

AWS SageMaker

Lini Abraham — Wed, 30 Apr 2025 12:08:04 +0000

AWS SageMaker is a fully managed service that allows data scientists and developers to build, train, and deploy machine learning models at scale. It simplifies the process of developing and deploying machine learning models by offering tools and capabilities to perform each step of the machine learning workflow, from preparing data to monitoring deployed models.

Key Features of AWS SageMaker:

1. Data Preparation and Labeling:
•SageMaker Data Wrangler: Helps prepare and clean data without writing much code.
•SageMaker Ground Truth: Enables automated data labeling for training datasets, using human labelers and machine learning models to improve labeling efficiency.

2. Model Building:

•SageMaker Studio: An integrated development environment (IDE) that offers tools to build, train, and deploy machine learning models. It’s a web-based interface that supports Jupyter notebooks and various integrations.
•Built-in Algorithms: Offers many pre-built algorithms optimized for performance and scalability, such as XGBoost, linear regression, k-means, and more.
•Custom Algorithms: Users can also bring their own custom algorithms written in popular frameworks like TensorFlow, PyTorch, Scikit-learn, etc.
•Amazon SageMaker Autopilot: Automatically trains and tunes the best machine learning models without requiring the user to know much about machine learning (AutoML).

3. Model Training:

•Distributed Training: SageMaker allows training on large datasets by automatically distributing the training job across multiple instances.
•Spot Training: Reduces cost by using Amazon EC2 Spot Instances for model training.
•Hyperparameter Optimization (HPO): Automates the process of tuning a model’s hyperparameters to improve accuracy.

4. Model Deployment and Hosting:

•Real-time Inference: Deploy trained models as endpoints for real-time predictions.
•Batch Transform: For batch inference, where the predictions are done in bulk for datasets that don’t require real-time predictions.
•SageMaker Model Monitor: Provides continuous monitoring of deployed models to ensure their quality over time.

5. Model Explainability and Debugging:

•SageMaker Clarify: Provides insights into model fairness and explainability by analyzing bias in data and providing explanations for model predictions.
•SageMaker Debugger: Automatically captures and analyzes model training metrics in real time to help debug and improve models.

6. MLOps and Pipelines:

•SageMaker Pipelines: Supports MLOps by helping build, manage, and automate end-to-end machine learning workflows, making it easier to retrain and deploy models in production.
•SageMaker Projects: Helps set up CI/CD pipelines for model deployment, making it easier to integrate machine learning models into existing DevOps workflows.

How to Use SageMaker:

1. Preparing Data: Use SageMaker Data Wrangler or Ground Truth to clean, prepare, and label the data.

2. Building Models: Use SageMaker Studio to write code, explore data, and build models using pre-built or custom algorithms.

3. Training Models: Train models at scale, optimize hyperparameters, and utilize distributed computing or EC2 Spot Instances for cost efficiency.

4. Deploying Models: Deploy models for real-time or batch inference, and monitor performance using SageMaker Model Monitor.

5. Managing Workflows: Use SageMaker Pipelines for continuous integration and deployment (CI/CD) of models into production.

AWS SageMaker Algorithms:

1. Supervised Learning Algorithms:

•Linear Learner: For binary and multiclass classification or regression problems. It uses stochastic gradient descent (SGD) for fast model training.

•XGBoost: An optimized distributed gradient boosting library designed for speed and performance. Great for classification and regression tasks.

•K-Nearest Neighbors (k-NN): A simple, non-parametric algorithm used for classification and regression. It predicts the label of an unseen data point by calculating the distance between the data points.

•Factorization Machines: Suitable for recommendation systems and tasks involving sparse datasets like click prediction.
•Image Classification: A pre-built algorithm based on ResNet that is used for image classification tasks.
•Object Detection: Helps detect objects in images, based on the Single Shot Multibox Detector (SSD) algorithm.
•Semantic Segmentation: A deep learning algorithm that helps segment parts of an image (e.g., identifying specific objects in an image).

2. Unsupervised Learning Algorithms:

•K-Means: A clustering algorithm that partitions data into a set number of clusters, widely used in exploratory data analysis.

•Principal Component Analysis (PCA): A dimensionality reduction algorithm, used to reduce the number of features while retaining variance in the data.

•Anomaly Detection with Random Cut Forest (RCF): Used to detect anomalous data points in a dataset, commonly used for fraud detection or anomaly detection in time-series data.

3. Time Series Forecasting:

•DeepAR: A forecasting algorithm that uses recurrent neural networks (RNNs) to predict future values in a time series, ideal for forecasting demand, financial markets, or energy consumption.

4. Natural Language Processing (NLP) Algorithms:

•BlazingText: A highly optimized implementation of Word2Vec for text classification or word embeddings.

•Seq2Seq: Sequence-to-sequence models used for machine translation, text summarization, and other NLP tasks.

•Latent Dirichlet Allocation (LDA): A topic modeling algorithm that helps identify themes or topics in large collections of text.

5. Reinforcement Learning (RL):

•Reinforcement Learning with Ray: A toolkit that helps set up reinforcement learning tasks, integrating easily with Ray RLlib for distributed reinforcement learning.
•Coach: SageMaker RL allows users to work with Coach, a toolkit for distributed RL training, used for applications like robotic control, game AI, and more.

6. Generative AI and Variational Autoencoders (VAE):

•VAE: Used to generate new data similar to training data, for applications like anomaly detection, data synthesis, or generative modeling.

7. Other Algorithms:

•IP Insights: Used for identifying suspicious or anomalous IP addresses based on previous behavior, commonly used in cybersecurity.
•Neural Topic Model (NTM): Another approach for topic modeling, using deep learning to model topics in textual data.

What is SageMaker Automatic Model Tuning?

Automatic Model Tuning in SageMaker, also called Hyperparameter Optimization (HPO), is a managed service that automates the process of finding the optimal hyperparameters for your machine learning models. Hyperparameters are settings like learning rate, batch size, or number of layers in a neural network, which need to be adjusted for a model to perform well.

Instead of manually tuning these hyperparameters (which can be very time-consuming), SageMaker automates the search by training multiple models with different hyperparameter combinations and selecting the one that performs best based on a chosen metric.

How SageMaker Automatic Model Tuning Works:

Define the Hyperparameters: You define a set of hyperparameters and their ranges or values to explore during the tuning process. For example, you might define that the learning rate can be between 0.001 and 0.1.
Objective Metric: You specify an objective metric, such as validation accuracy, log loss, F1 score, RMSE. You can use built-in metrics (like Validation:Accuracy) or define your own custom metrics.
Search/Tuning Strategy:

• SageMaker uses techniques like Bayesian Optimization to intelligently search the hyperparameter space rather than trying every possible combination (which would be inefficient).

Training Jobs: SageMaker runs multiple training jobs, each with different hyperparameter combinations, in parallel. These jobs evaluate the model’s performance on the chosen objective metric.
Training Ranges:

• For continuous hyperparameters (like learning rate), you define a range (e.g., from 0.001 to 0.1).

• For categorical hyperparameters (like optimizer type), you define specific values to explore (e.g., [“Adam”, “SGD”, “RMSprop”]).

Optimal Hyperparameters: After all the jobs are complete, SageMaker identifies the hyperparameter combination that produced the best-performing model.
Stopping Conditions:

• You can set a limit for how many training jobs to run and how long each job can last. This prevents overly long or expensive training sessions.