Demyank's Tlog

[패스트캠퍼스] AI 기술을 활용한 의료 데이터 분석과 바이오 진단 학습후기

데먕 — Wed, 14 May 2025 19:25:20 +0900

전반적으로 강의에서 소개되는 기술들은 현재 서비스나 제품에서 활용되는 최신 기술들이라기보다는 몇 년전까지 사용되던 기술들이라는 인상을 받았다. 다만, 최신 기술들도 결국에는 해당 기술들의 아이디어나 한계점을 개선하기 위한 방법들이기 결국 모두 알아야하는 내용들이라고 판단되었기 때문에 관심을 가지고 수강하게 되었다. 해당 강의에서 절반은 MLP, CNN, RNN, Transformer, GAN 등 주요 Deep Learning 기초들을 다루고 있고 나머지 절반은 의료에서 주로 사용되는 데이터처리, 학습방법, 평가방법, 응용 분야 등을 다루고 있다. 워낙 다루는 범위가 넓다보니 하나의 기술이나 논문에 대해서 짧게는 몇 십초에서 길게는 몇 분정도의 분량을 가지고 있다. 하지만 해당 기술들이나 논문에 대해서 너무 개괄적으로 설명하기 때문에 처음 접하는 내용들에 대해서는 해당 강의만으로는 이해하기 어려웠다. 따라서 해당 강의 내용들을 entry point로 보다 깊은 이해를 위해 NotebookLM, ChatGPT, 그리고 Gemini 등을 통해서 보다 깊은 이해를 할 수 있었다.

NotebookLM

앞서 말한바와 같이 9차시까지는 주로 MLP, Deep Learning의 기초에 관한 내용으로 이미 널리 알려진 내용들을 다루고 있고 해당 내용에 대해서 이미 접한 경험이 있기 때문에 리마인드 차원에서 빠르게 훑어보았다. 이하로는 내가 이 강의를 통해서 주로 관심있게 시청하였던 Object Detection, Instance Segmentation에 관하여 키워드들을 정리해놓았다.

Image Segmentation

ROI 분할

challenges: a lot of noise, hard to acquire a perfect annotation, bias of annotators

Preprocessing

pretrained model, patching, and oversampling

Augmentation

flipping, cropping, rotation, color jitter, cutout, mixup, cutmix

Architecture

UNET

Deep Lab

Atrous convolution: dilate rate를 조절하여 receptive field를 키움

DeepLab - atrous convolution

Astrou spatial pyramid pooling (ASPP): multi-scale kernel에 대해서 다양한 receptive field 얻어 다양한 position에 대하여 학습

DeepLab - astrou spatial pyramid pooling (ASPP)

UENTR

Encoder 부분에 Transformer를 활용하여 기존보다 long range에 대해서 spatial dependency를 개선

Transformer를 사용하여 단일 계층 내에서도 patches의 attention을 통해 전역적인 receptive field를 확보하여 Deep Lab의 locality 연산의 누적의 한계를 극복함.

UENTR

Inference

Test Time Augmentation (TTA)

Ensemble: robustness, generalization, prediction confidence

TTA

Postprocessing

Edge enhancement, Hole filling

Loss

Cross Entropy: pixel-wise classification, weight for class imbalance

Dice Coefficient Loss:

Jaccard/Intersection over Union(IoU) Loss:

Dice Loss vs Jaccard Loss

주요 차이점

감도(Gradient) 분포
- Dice Loss: 낮은 IoU 영역에서 비선형으로 급격한 펄스를 줘 소형 객체나 초기 학습에서 빠른 수렴 유도
- Jaccard Loss: 선형 감소
수치적 안정성
- 두 Loss 모두 0–1 사이지만, Dice 식에 분모가 2 TP+FP+FN2\,\text{TP}+\text{FP}+\text{FN} 이므로 소수 FP/FN 존재 시에도 더 높은 값을 유지
- Jaccard는 FP+FN 에 민감
사용 사례
- Dice Loss: 의료 영상 segmentation, 클래스 불균형 극심할 때
- Jaccard Loss(IoU Loss): 객체 탐지의 위치 회귀(IoU-based), 세그멘테이션에서도 쓰이나 Dice 만큼 보편적이지 않음

Evalution

Annotator에 따라 차이가 큼

TOWARDS A GUIDELINE FOR EVALUATION METRICS IN MEDICAL IMAGE SEGMENTATION

Specificity: Brain - 미세한 cancel region이 모두 matter이기 때문에 유효

Sensitivity: histopathology - 최대한 많은 영역을 segmentation하는 것이 목적이기 때문에 유효

Dice, Jaccard, Mean IoU - 모든 class에 대한 IoU 평, GIoU - region의 거리까지 고, DIoU - gt, predict의 center points 거리까지 고려

pixel-wise evaluation: f1 score, sensitivity, specificity, accuracy

Hausdorff distance: gt, prediction 간의 꼭지점 거리를 계산하여 매칭 계산

Object Detection

Localization and classification

Challenges: Positive and Negative imbalance data, Anchor box, feature map

Preprocessing

Online Hard Negative Mining (OHEM): Top N confidence negative sampling

HEM

OHEM

Multi-scale sample

improving robustness to scale variations, enhancing feature representation, and capturing both local detail and global context

Convolutional Neural Networks for Automated PET/CT Detection of Diseased Lymph Node Burden in Patients with Lymphoma

Augmentation: flip, rotate, cutout, mosaic, mixup, cutmix

Models

Faster-RCNN: Region proposal network. Localization에 대해서 Proposal된 영역에 대해서만 classification하여 기존의 sliding windows 방법 대비 효율적

Cancel Cells detection in Phase-Contrast Microscopy Images Based on Faster RCNN

FPN

YOLO: 1-stage, cell & anchor box, confidence

Fully Convolutional One-stage Object Detection: Anchor-free

End-to-End Object Detection with Transformers (DETR): Hungarian maximum matching algorithm, Transformer, patch

nnUNET

Annotation과 Image만으로 Model 학습. Positive patch, Anchor box, NMS 등 preprocessing, postprocessing의 수고를 줄이기 위함. Fixed parameter, Rule-based parameter, Empirical parameter

AutoML vs NNunet

Fixed parameter - optimizer, loss function, network (ex: UNET), Augmentation, Inference (ex: sliding window), Epoch

Rule-based parameter: depending on the data. normalizing, pixel scaling, batch, patch size, number of gpu

Empirical parameter: Auto

nnDetection

Successor of nnUNET

Hard negative mining: 1/3 positive, 2/3 negative, Classification: CE, Optimizer: SGD, 60 epochs, Architecture: Multi-scale FPN

nnDetection

Generalized IOU used for searching anchor box automatically

시나리오 IoU GIoU 시각적 특징 & 해석

Perfect overlap	1.000	1.000	두 박스가 완전히 일치 → 외접 C = A = B, 빈 공간 0 ⇒ GIoU = IoU = 1
Partial overlap	0.195	0.015	교집합은 작고 외접 C 가 커서 빈 공간 비율 ↑ → GIoU가 IoU보다 더 낮음
No overlap	0.000	–0.263	IoU = 0 이라 gradient 0 이지만, GIoU는 음수 페널티 → 학습 신호 유지

Rule-based parameters: heuristic rules, searching for IOU maximizing an anchor box, differ resampling for each image domain, from full-resolution model to low resolution model when missing context

Empirical parameters: Postprocessing, Sliding windows for NMS, Weighted box clustering

Loss

Focal loss - weighted to too many negatives

Postprocessing

Non-maximum Suppression (NMS) - IOU > Threshold, Sliding window - patch inference for small objects

Evaluation

IOU

Precision-recall curve, MAP, ROC Curve - Sensitivity and specificity, Free-Response ROC Curve (FROC)

Precision-Recall with Threshold

Fully Convolutional One-Stage Object Detection (FPOC)

Anchor box size나 scale을 custom하게 설정하는 것이 아니라 class label classification, bounding box regression, and centerness 등을 prediction함. 또 FPN으로 다양한 scale에 대한 객체 처리.

FPOC

개념 정의 표준 ROC와의 차이

Sensitivity (TPR)	탐지된 병변(Correct Lesions)전체 실제 병변\dfrac{\text{탐지된 병변(Correct Lesions)}}{\text{전체 실제 병변}}	동일
FP / Image	한 이미지당 잘못 탐지된 개수 평균	ROC의 FPR(비율) 대신 절대 개수 사용
FROC Curve	x축 = FP per image, y축 = Sensitivity	한 이미지 안에 복수의 탐지 후보가 있어도 평가 가능

Threshold 0.9 - few detections

threshold 0.5 - balanced

threshold 0.1 - many fp

Instance Segmentation

Preprocessing: Copy and pastes augmentation, Contour mask, Gradient map

ToothNet: Mask-RCNN, 2-stage, Edge map, Region proposal network (RPN), Similarity Matrix

ToothNet

Real-time Instance Segmentation of Surgical Instruments using Attention and Multi-scale Feature Fusion: YOLACT++, 1-stage, FPN, Attention

Real-time Instance Segmentation of Surgical Instruments using Attention and Multi-scale Feature Fusion

Postprocessing: Watershed

Accept-Reject Sampling

데먕 — Thu, 14 Jul 2022 13:43:44 +0900

Sample and Sampling

Sample

A sample is an outcome of a random experiment. When we sample a random variable, we obtain one specific value out of the set of its possible values. That particular value is called a sample.

The possible values and the likelihood of each are determined by the random variable's probability distribution.

Sampling

Mathematically performing sampling is the same as performing an inverse function operation of CDF(cumulative density function.

Why sampling is difficult?

Mathematically, sampling is calculating the inverse function of the CDF
Calculating CDF for a given PDF requires an integral operation
Calculating the CDF is not easy to obtain an inverse function
Thus, performing sampling numerically accurately is difficult

Proposal distribution $g(x)$

The proposed distribution utilizes a distribution that allows us to sample easily: such as uniform distribution
If possible, similar distribution to the target distribution is preferable

Sampling Process

$q(x)$ is proposal distribution

$p(x)$ is target distribution

1. Multiply constant M to proposal distribution for $Mq(x)\geq p(x)$

2. Generate $x_{0}$ from q

3. Generate sample $u$ from a uniform distribution between $\left [ 0, Mq(x_{0}) \right ]$

4. If $u$ site within A, reject. Or $u$ site within B, accept.

$$\frac{p(x_{0})}{Mq(x_{0})} > random \ value \ from [0, 1]$$

5. Repeat this accept-reject process numerously, samples from reject sampling follows approximately $p(x)$

Reference

https://mathinsight.org/definition/random_variable_sample

https://www.youtube.com/watch?v=7wtVFfwAps4

https://angeloyeo.github.io/2020/09/16/rejection_sampling.html

Matrix Factorization

데먕 — Tue, 12 Jul 2022 18:58:59 +0900

Introduction

Split the matrix into the product of 2 other matrices
We call it R hat because it only approximates R - it is our model of R
We would like W and U to be very skinny
$W(N \times K)$ - users matrix, $U(M \times K)$ - movie matrix
K somewhere from 10-50

The scale of matrix R, W, and U

Key: $W$ and $U$ should be much smaller than $R$
$R$ is $N \times M$
Generally, we can't store $R$ in memory
We can represent it using a special data structure
- Dict{(u, m) -> r}
If N = 130k, M = 26k
- $N \times M$ = 3.38 billion
- # ratings = 20 million
- Space used: 20 million / 3.38 billion = 0.006
This is called a sparse representation

Scale down to K

If K = 10, N = 130k, M = 26k, then size of W and U: NK + MK = 1.56 million
How much savings? 1.56 million / 3.38 billion = 0.0005
- This takes up less space than the ratings
- This is good, we like # parameters < # of data pts)

Calculate only at i and j

What happens if you try to calculate $WU^{T}$ in code?
Don't do it. The result is $N \times M$, which can't load on memory unless you've selected a small subset of your data

What if I just want one rating, for user i, item j?

Just a dot product between 2 vectors of size K
Unlike calculating all of our $\hat{R}$, this is very fast and takes up a trivial amount of space

$$\hat{r}_{ij}=w_{i}^{T}u_{j}$$

$where \ \hat{r}_{ij}=\hat{R}[i,j],w_{i}=W[i],u_{j}=U[j]$

Singular value decomposition (SVD)

A matrix X can be decomposed into 3 separate matrices multiplied together

$$X=USV^{T}$$

What's the justification for calling matrix factorization SVD?

S can be absorbed into $U$ or $V$, we get an $(N \times K) \times (K \times M) \to (N \times M)$
The model is thus exactly like MF

$$\hat{x}_{ij}=\sum_{k}u_{ik}s_{kk}v_kj=\sum_{k}(u_{ik}s_{kk})v_{kj}=\sum_{k}{u}'_{ik}v_{kj}=u_{i}^{'T}v_{j}$$

Linear algebra

$X(N \times M)$, $U(N \times K)$, $S(K \times K)$, $V(M \times K)$
If I multiply $U$ by $S$, I just get another $N \times K$ matrix
- Then $X$ is a product of 2 matrices, just like matrix factorization
- Or equivalently, I could combine $S$ with $V^{T}$
$R$ (rating matrix) is sparse
- If $U$, $S$, and $V$ can properly approximate a full $X$ matrix, then surely it can approximate a mostly empty $R$ matrix

Interpretation

Each of the K elements in $w_{i}$ and $u_{j}$ is a feature
Let's suppose K=5, and they are:
- Action/adventure
- Comedy
- Romance
- Horror
- Animation
$w_{i}(1)$ is how much user_i likes action
$w_{i}(2)$ is how much user_i likes comedy, etc.
$u_{j}(1)$ is how much movie j contains action
$u_{j}(2)$ is how much movie j contains comedy, etc.

Questions

What happens when we dot $w_{i}^{T}u_{j}$?
How well do user_i's preferences correlate with movie_j's attributes?

$$w_{i}^{T}u_{j}=\left\| w_{i}\right\|\left\| u_{j}\right\|cos\theta \propto sim(i,j)$$

Example

Batman Animation

$w_{i}=(1, 0.8, -1, 0.1, 1)$
$u_{j}=(1, 1.5, -1.3, 0, 1.2)$
result = 1*1 + 0.8*1.5+1*1.3+0.1*0+1*1.2=4.7

THE NOTEBOOK

$w_{i}=(1, 0.8, -1, 0.1, 1)$
$u_{j}=(-1, -1, 1, 0, -1)$
result = -1*1 + -1*0.8 + -1*1 -1*1 = -3.8

Supervised Machine Learning

We could predict how much a user likes an item, by extracting features from both and feeding it into a model like Random Forest or Neural Network
- We might include features about the user like age, gender, location, and so forth
- Some attributes about the item like RAM, Display, etc.
The difference is that MF extracts the features automatically using only ratings
- Only by looking at the patterns between users, items, and the ratings

Dimensionality Reduction

Is exactly equal to X if K=M (assuming N > M and the rank of X is M)
By shrinking U, S, and V, we make it an approximation
Is called Truncated SVD: and yields our best rank-K approximation of X
Similarly, MF reduces the dimensionality of R
We encourage the model to learn the most important features required to generate R

Training

How can we ensure our approximation is good? We would like $R$ and $\hat{R}$ to close together which are rating matrices

$$R\approx \hat{R}=WU^{T}$$

Squared error loss

$$J=\sum_{i,j\in \Omega }(r_{ij}-\hat{r}_{ij})^{2}=\sum_{i,j\in \Omega}(r_{ij}-w_{i}^{T}u_{j})^{2}$$

$\Omega=$set of pairs (i, j) where user_i rated movie_j

Minimize the loss

How? Find the gradient, set it to 0, and solve for the parameters

$$J=\sum_{i,j\in \Omega }(r_{ij}-\hat{r}_{ij})^{2}=\sum_{i,j\in \Omega}(r_{ij}-w_{i}^{T}u_{j})^{2}$$

Solving for $W$

$$J=\sum_{i,j\in \Omega }(r_{ij}-\hat{r}_{ij})^{2}=\sum_{i,j\in \Omega}(r_{ij}-w_{i}^{T}u_{j})^{2}$$

$$\frac{\partial J}{\partial w_{i}}=2\sum_{j\in \Psi_{i} }(r_{ij}-w_{i}^{T}u_{j})(-u_{j})=0$$

Careful about which sets are being summed over
$\Omega$ represents the set of pairs (i,j) where user_i has rated movie_j
$\Psi_{i}$ is the set of all movies that user_i has rated
For $J$, we want to sum over all rating
For a particular user vector $w_{i}$, we only care about movies that user rated (because only those ratings involve $w_{i}$

$$\sum_{j\in \Psi_{i} }(w_{i}^{T}u_{j})(u_{j})=\sum_{j\in \Psi_{i} }r_{ij}u_{j}$$

Try to isolate $w_{i}$
Dot product is commutative

$$\sum_{j\in \Psi_{i} }(u_{j}^{T}w_{i})u_{j}=\sum_{j\in \Psi_{i} }r_{ij}u_{j}$$

Result of dot product is scalar
$scalar \times vector = vector \times scalar$

$$\sum_{j\in \Psi_{i} }u_{j}(u_{j}^{T}w_{i})=\sum_{j\in \Psi_{i} }r_{ij}u_{j}$$

$$\sum_{j\in \Psi_{i} }u_{j}u_{j}^{T}w_{i}=\sum_{j\in \Psi_{i} }r_{ij}u_{j}$$

Summation doesn't actually depend on i
Add more brackets
Do the outer products between $u_{j}$ and itself sum over all values of j

$$\left ( \sum_{j\in \Psi_{i} }u_{j}u_{j}^{T} \right )w_{i}=\sum_{j\in \Psi_{i} }r_{ij}u_{j}$$

Now it's just $Ax = b$, which we know how to solve
x = np.linalg.solve(A, b)

$$w_{i}=\left ( \sum_{j\in \Psi_{i} }u_{j}u_{j}^{T} \right )^{-1}\sum_{j\in \Psi_{i} }r_{ij}u_{j}$$

Solving for $U$

Loss is symmetric in $W$ and $U$, so the steps should be the same
Remember to be careful which set to sum over
Since we only one terms involving $u_{j}$, that means we only want the user_i who rated item_j, that's $\Omega_{j}$

$$J=\sum_{i,j\in \Omega }(r_{ij}-\hat{r}_{ij})^{2}=\sum_{i,j\in \Omega}(r_{ij}-w_{i}^{T}u_{j})^{2}$$

$$\frac{\partial J}{\partial u_{j}}=2\sum_{i\in \Omega_{j} }(r_{ij}-w_{i}^{T}u_{j})(-w_{i})=0$$

Try to isolate $u_{j}$

$$\sum_{i\in \Omega_{j} }(w_{i}^{T}u_{j})w_{i}=\sum_{i\in \Omega_{j} }r_{ij}w_{i}$$

Change order of mulitiplication

$$\sum_{i\in \Omega_{j}}w_{i}w_{i}^{T}u_{j}=\sum_{i\in \Omega_{j}}r_{ij}w_{i}$$

$$\left ( \sum_{i\in \Omega_{j}}w_{i}w_{i}^{T} \right )u_{j}=\sum_{i\in \Omega_{j}}r_{ij}w_{i}$$

$$u_{j}=\left ( \sum_{i\in \Omega_{j}}w_{i}w_{i}^{T} \right )^{-1}\sum_{i\in \Omega_{j}}r_{ij}w_{i}$$

Training algorithm

2-way dependency

Solution for $W$ depends on $U$
Solution for $U$ depends on $W$
The issue is we're going to have two separate steps, but there isn't just one global equation
- This is the nature of our model
Simply apply the equation as is, iteratively
Is called Alternating Least Squares

Algorithm

W = randn(N, K); U = randn(M, K);
for t in range(T):

$$w_{i}=\left ( \sum_{j\in \Psi_{i} }u_{j}u_{j}^{T} \right )^{-1}\sum_{j\in \Psi_{i} }r_{ij}u_{j}$$

$$u_{j}=\left ( \sum_{i\in \Omega_{j}}w_{i}w_{i}^{T} \right )^{-1}\sum_{i\in \Omega_{j}}r_{ij}w_{i}$$

FAQ

Does it matter which order you update in? No
Should you use the old values of $W$ when updating $U$?
- Tends to go faster if you use the new values
- Computationally, if you wanted to use the old values, you'd have to make a copy (very slow)

Bias Terms

The predicted rating, $\hat{r}_{ij}$, is the sum of the product of the user vector multiplied by the movie vector + user bias $b_{i}$, the movie bias $c_{j}$, and the global average $\mu$
Normally, simple linear regression needs only one bias term, but MF would like to have 3

$$\hat{r}_{ij}=w_{i}^{T}u_{j}+b_{i}+c_{j}+\mu$$

$\mu$: Global average. centering the data set. just calculate it directly from train data.
The reason we like both a user bias and a movie bias is that both these dimensions can be biased

Ex: Movie Bias

Consider a universally well-liked movie like James Cameron's Avatar
MF might find latent features, e.g.
- Sci-if
- Aliens
- Humans fighting aliens
Battlefield Earth has these attributes
Widely considered to be the worst sci-fi movie of all time
Thus, a movie-specific bias term makes sense

Training

Solving for $W$

Objective function

$$J=\sum_{i,j\in \Omega}(r_{ij}-\hat{r}_{ij})^2$$

$$\hat{r}_{ij}=w_{i}^{T}u_{j}+b_{i}+c_{j}+\mu$$

Differentiate wrt $w_{i}$

$$\frac{\partial J}{\partial w_{i}}=2\sum_{j\in \Psi_{i} }(r_{ij}-w_{i}^{T}u_{j}-b_{i}-c_{j}-\mu)(-u_{j})=0$$

Move other terms to RHS

$$\sum_{j\in \Psi_{i} }(w_{i}^{T}u_{j})(u_{j})=\sum_{j\in \Psi_{i} }(r_{ij}-b_{i}-c_{j}-\mu)u_{j}$$

Use the same tricks from before to isolate w

$$w_{i}=\left ( \sum_{j\in \Psi_{i} }u_{j}u_{j}^{T} \right )^{-1}\sum_{j\in \Psi_{i} }(r_{ij}-b_{i}-c_{j}-\mu)u_{j}$$

Solving for $U$

$$u_{j}=\left ( \sum_{i\in \Omega_{j}}w_{i}w_{i}^{T} \right )^{-1}\sum_{i\in \Omega_{j}}(r_{ij}-b_{i}-c_{j}-\mu)w_{i}$$

Solving for b

Differentiate wrt b

$$J=\sum_{i,j\in \Omega}(r_{ij}-\hat{r}_{ij})^2$$

$$\hat{r}_{ij}=w_{i}^{T}u_{j}+b_{i}+c_{j}+\mu$$

$$\frac{\partial J}{\partial b_{i}}=2\sum_{j\in \Psi_{i} }(r_{ij}-w_{i}^{T}u_{j}-b_{i}-c_{j}-\mu)(-1)=0$$

Isolate b
Common mistake: moving a variable outside a summation is equal to the variable itself (don't forget to multiply by # of terms being summed)

$$b_{i}=\frac{1}{\left|\Psi_{i} \right|}\sum_{j\in \Psi_{i} }(r_{ij}-w_{i}^{T}u_{j}-c_{j}-\mu)$$

$b_{i}$ is the average deviation between target and modeling prediction, if the prediction did not involve $b_{i}$
i.e. $b_{i}$ is exactly how much you need to add to the model prediction without $b_{i}$

Solving for c

The only difference is what we sum over which is now all the users who rate movie_j

$$J=\sum_{i,j\in \Omega}(r_{ij}-\hat{r}_{ij})^2$$

$$\hat{r}_{ij}=w_{i}^{T}u_{j}+b_{i}+c_{j}+\mu$$

$$\frac{\partial J}{\partial c_{j}}=2\sum_{i\in \Omega_{j} }(r_{ij}-w_{i}^{T}u_{j}-b_{i}-c_{j}-\mu)(-1)=0$$

Again makes sense that $c_{j}$ is the average deviation of a model that doesn't involve $c_{j}$

$$c_{j}=\frac{1}{\left|\Omega_{j} \right|}\sum_{i\in \Omega_{j} }(r_{ij}-w_{i}^{T}u_{j}-b_{i}-\mu)$$

Summary

$$w_{i}=\left ( \sum_{j\in \Psi_{i} }u_{j}u_{j}^{T} \right )^{-1}\sum_{j\in \Psi_{i} }(r_{ij}-b_{i}-c_{j}-\mu)u_{j}$$

$$u_{j}=\left ( \sum_{i\in \Omega_{j}}w_{i}w_{i}^{T} \right )^{-1}\sum_{i\in \Omega_{j}}(r_{ij}-b_{i}-c_{j}-\mu)w_{i}$$

$$b_{i}=\frac{1}{\left|\Psi_{i} \right|}\sum_{j\in \Psi_{i} }(r_{ij}-w_{i}^{T}u_{j}-c_{j}-\mu)$$

$$c_{j}=\frac{1}{\left|\Omega_{j} \right|}\sum_{i\in \Omega_{j} }(r_{ij}-w_{i}^{T}u_{j}-b_{i}-\mu)$$

Regularization

A technique to prevent overfitting and help generalization

In linear regression

Model: $\hat{y}=w^{T}x$
Objective: $J=\sum_{i=1}^{N}(y_{i}-\hat{y}_{i})^{2}+\lambda\left\| w\right\|_{2}^{2}$
Solution: $w=(\lambda I + X^{T}X)^{-1}X^{T}y$

where $\left\| w\right\|_{2}^{2}$ is squared magnitude of the weights themselves which is called penalty term. The idea is if the weights become too large, that's a good sign of overfitting. So large weights are penalized.

Regularization in Matrix Factorization

Same approach, add squared magnitude of each parameter multiplied by regularization constant
$\left\| *\right\|_{F}$ is called the Frobenius norm on a matrix

$$J=\sum_{i,j\in \Omega}(r_{ij}-\hat{r}_{ij})^{2}+\lambda(\left\| W\right\|_{F}^{2}+\left\| U\right\|_{F}^{2}+\left\| b\right\|_{2}^{2}+\left\| c\right\|_{2}^{2})$$

Solve for $W$

Derivatives are additive, we just need to differentiate the 2nd term and add it to the existing derivative

$$\frac{\partial J}{\partial w_{i}}=2\sum_{j\in \Psi_{i} }(r_{ij}-w_{i}^{T}u_{j}-b_{i}-c_{j}-\mu)(-u_{j})+2\lambda w_{i}=0$$

If you can't see how I differentiated $w_{i}$ wrt Frobenius norm, expand it
Now it's just a dot product which we know how to differentiate
The Frobenius norm is just the sum of the magnitudes of each individual element
Therefore, I can also split them up in terms of each row as well
The squared magnitude of a vector is just the dot product of the vector with itself
The derivative of the dot product is just the vector itself

$$\left\| W\right\|_{F}^{2}=\sum_{i=1}^{N}\sum_{k=1}^{K}\left| w_{ik}\right|^{2}=\sum_{i=1}^{N}\left\| w_{i}\right\|_{2}^{2}=\sum_{i=1}^{N}w_{i}^{T}w_{i}$$

Group like-terms

$$\sum_{j\in \Psi_{i}}u_{j}u_{j}^{T}w_{i}+\lambda w_{i}=\sum_{j\in \Psi_{i}}(r_{ij}-b_{i}-c_{j}-\mu)u_{j}$$

Factor out w

$$\left ( \sum_{j\in \Psi_{i}}u_{j}u_{j}^{T} + \lambda I\right )w_{i}=\sum_{j\in \Psi_{i}}(r_{ij}-b_{i}-c_{j}-\mu)u_{j}$$

Apply our usual solution

$$w_{i}=\left ( \sum_{j\in \Psi_{i}}u_{j}u_{j}^{T} + \lambda I\right )^{-1}\sum_{j\in \Psi_{i}}(r_{ij}-b_{i}-c_{j}-\mu)u_{j}$$

Solve for $U$

Use symmetry reasoning

$$u_{j}=\left ( \sum_{i\in \Omega_{j}}w_{i}w_{i}^{T} + \lambda I\right )^{-1}\sum_{i\in \Omega_{j}}(r_{ij}-b_{i}-c_{j}-\mu)w_{i}$$

Solve for b

differentiate

$$J=\sum_{i,j\in \Omega}(r_{ij}-\hat{r}_{ij})^{2}+\lambda(\left\| W\right\|_{F}^{2}+\left\| U\right\|_{F}^{2}+\left\| b\right\|_{2}^{2}+\left\| c\right\|_{2}^{2})$$

$$\frac{\partial J}{\partial b_{i}}=2\sum_{j\in \Psi_{i} }(r_{ij}-w_{i}^{T}u_{j}-b_{i}-c_{j}-\mu)(-1)+2\lambda b_{i}=0$$

Isolate $b_{i}$

$$\sum_{j\in \Psi_{i}}b_{i}+\lambda b_{i}=\sum_{j\in \Psi_{i}}(r_{ij}-w_{i}^{T}u_{j}-c_{j}-\mu)$$

Factor out $b_{i}$

$$b_{i}\left\{ \left ( \sum_{j\in \Psi_{i}}1 \right )+\lambda \right\} =\sum_{j\in \Psi_{i}}(r_{ij}-w_{i}^{T}u_{j}-c_{j}-\mu)$$

Divide by constant

$1+\lambda$ is bigger than 1, so $b_{i}$ become smaller

$$b_{i}=\frac{1}{\left| \Psi_{i} \right| + \lambda}\sum_{j\in \Psi_{i}}(r_{ij}-w_{i}^{T}u_{j}-c_{j}-\mu)$$

Solve for c

Apply symmetry reasoning again

$$c_{j}=\frac{1}{\left| \Omega_{j} \right| + \lambda}\sum_{i\in \Omega_{j}}(r_{ij}-w_{i}^{T}u_{j}-b_{i}-\mu)$$

Summary

$$w_{i}=\left ( \sum_{j\in \Psi_{i}}u_{j}u_{j}^{T} + \lambda I\right )^{-1}\sum_{j\in \Psi_{i}}(r_{ij}-b_{i}-c_{j}-\mu)u_{j}$$

$$u_{j}=\left ( \sum_{i\in \Omega_{j}}w_{i}w_{i}^{T} + \lambda I\right )^{-1}\sum_{i\in \Omega_{j}}(r_{ij}-b_{i}-c_{j}-\mu)w_{i}$$

$$b_{i}=\frac{1}{\left| \Psi_{i} \right| + \lambda}\sum_{j\in \Psi_{i}}(r_{ij}-w_{i}^{T}u_{j}-c_{j}-\mu)$$

$$c_{j}=\frac{1}{\left| \Omega_{j} \right| + \lambda}\sum_{i\in \Omega_{j}}(r_{ij}-w_{i}^{T}u_{j}-b_{i}-\mu)$$

Item-Item Collaborative Filtering

데먕 — Tue, 12 Jul 2022 14:49:29 +0900

Intuition

The correlation between the column vectors is high
If you like Power Rangers, you'll also like Transformers because users give them similar ratings

	Power Rangers	Transformers	Ninja Turtles
User 1	4.5	5	4
User 2	5	5	4.5
User 3	1	2	0.5
User 4	2	2	0.5

User-User Collaborative Filtering

For user-user CF, I want to find "users like me"
The movies that those users have seen, that I haven't seen, become my recommendations
It's intuitive that if they are "like me", I would like movies they've rated highly
Looks row-wise
Each row is a vector
2 users are similar in their row vectors have a small distance between them

Item-Item Collaborative Filtering

What if we looked column-wise instead?
Let's find 2 products that are similar
They are similar if their column vectors' distance is small

Item Correlation

$$w_{ii'}=\frac{\sum_{j\in\Omega_{ii'}}(r_{ij}-\bar{r}_{i})(r_{i'j}-\bar{r}_{i'})}{\sqrt{\sum_{j\in\Omega_{ii'}}(r_{ij}-\bar{r}_{i})^2}\sqrt{\sum_{j\in\Omega_{ii'}}(r_{i'j}-\bar{r}_{i'})^2}}$$

$\Omega_{j}=users \ who \ rated \ item \ j$

$\Omega_{jj'}=users \ who \ rated \ item \ j \ and \ item \ j'$

$\bar{r}_{j}=average \ rating \ for \ item \ j$

Item Score

$$s(i,j)=\bar{r}_{i}+\frac{\sum_{i'\in\Psi_{j}}{w_{ii'}(r(i',j)-\bar{r}_{i'})}}{\sum_{i'\in\Psi_{j}}|w_{ii'}|}$$

$\Psi= items \ user \ i \ has \ rated$

Deviation: how much user i likes item j', compared to how much everyone else likes j' (IMO, not as intuitive as user-user CF)
If user i really likes j' (more than other users do) and j is similar to j' ($w_{jj'}$ is high), then user i probably likes j too

Comparison

User-User CF: choose items for a user, because those items have been liked by similar users
Item-Item CF: choose items for a user, because this user has liked similar items in the past
By flipping the ratings matrix sideways, we can convert user-user CF algorithm into an item-item CF algorithm
User-based and Item-based CF are mathematically identical
Item-based CF is more accurate because more data to work with

Practical differences

When comparing 2 items, you have a lot more data than when comparing 2 users
- Each user: up to ~ 20k items to look at
- Each item: up to 100k users to look at
- Thus for item-based CF, weights are calculated based on more data
Item-based CF is faster
- Given a user, calculate scores for each item: $O(M^{2}N)
  - There are $M^{2}$ item-item weights, and each vector is length N
- For user-based CF we saw $O(N^{2}M)$
- N >> M, so $N^{2}$ compared to $M^{2}$ is even worse
Item-based CF is more accurate

Limitation

Item-based CF may be too accurate
It's always suggesting similar products
This leads to a lack of diversity in recommendations - the YouTube problem
Worse MSE might be more desirable

The Cold-Start Problem

We know that if we don't have enough data, we can't calculate correlations
What if we don't have any data at all?
- Add a prior to the average
- The score can be a weighted sum of prediction + prior average
- No data at all -> rely solely on prior
- How to get prior? Scrape from the web or something else

Not necessarily movies/ratings

user-item matrix doesn't have to be ratings at all
Explicit feedback is sparse
# of times user viewed a product
Did they purchase?
Hit like?
Share on social media?

Reference

https://www.cs.umd.edu/~samir/498/Amazon-Recommendations.pdf

https://takuti.github.io/Recommendation.jl/latest/collaborative_filtering/

https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-sims.html

Sigmoid and Softmax

데먕 — Thu, 7 Jul 2022 18:32:36 +0900

1. Softmax

Softmax function calculates the probability distribution of the event over k different events. This function will calculate the probabilities of each target class over all possible target classes.

Equation

$$P(y=j | x) = \frac{e^{x_j}}{\sum_{k=1}^K e^{x_k}}$$

Plot

x = np.arange(-2.0, 6.0, 0.1)
input = np.vstack([x, np.ones_like(x), 0.2 * np.ones_like(x)])

input

Characteristic

It normalizes your data: Outputs a proper probability distribution
It is differentiable
1. A hardmax function such as argmax is not differentiable. The softmax gives at least a minimal amount of probability to all elements in the output vector, and so is nicely differentiable, hence the term “soft” in softmax
It uses the exponential form. The interesting property of the exponential function combined with the normalization in the softmax is that high scores in x become much more probable than low scores

2. Sigmoid

Equation

$$sigmoid(x_{i})=\sigma(x)=\frac{1}{1+e^{-x_{i}}}$$

Plot

Characteristic

Input domain: $(-\infty, +\infty )$

Output range: (0, +1)

$\sigma(0)=0.5$

The function is monotonically increasing

The function is continuous everywhere

The function is differentiable everywhere in its domain

Numerically, it is enough to compute this function’s value over a small range of numbers, e.g., [-10, +10]. For values less than -10, the function’s value is almost zero. For values greater than 10, the function’s values are almost one

Reference

https://datascience.stackexchange.com/questions/23159/in-softmax-classifier-why-use-exp-function-to-do-normalization

https://www.quora.com/How-does-softmax-relate-to-the-true-probability-of-a-sample-being-correctly-classified

https://machinelearningmastery.com/a-gentle-introduction-to-sigmoid-function/

AWS Personalize

데먕 — Thu, 7 Jul 2022 17:59:11 +0900

Built-in Recipe (Model)

Sims

Based on collaborative filtering. SIMS identifies the co-occurrence of the item in user histories in your Interaction dataset to recommend similar items. For example, with SIMS Amazon Personalize could recommend coffee shop items customers frequently bought together or movies that different users also watched. Recommended for improved item searchability and faster performance on detail pages.

HPO tunable hyper-parameter

The process of choosing the best value for a hyper-parameter is called hyper-parameter optimization(HPO).

Name	Description
popularity_discount_factor	It affects the balance between popularity and correlation when you calculate similarity. If you calculate similarities to a specific item, a value of 0 makes the most popular items appear as recommendations regardless of their correlation. A value of 1 makes most items that make co-interactions regardless of their popularity. Using either extreme might create an overly long list of recommended items. For most cases, a value around 0.5 works best. Default: 0.5 Range: [0.0, 1.0] Value type: Float HPO tunable: Yes
min_cointeraction_count	The minimum number of co-interactions you need to calculate the similarity between a pair of items. For example, a value of 3 means that you need 3 or more users who interacted with both items for the algorithm to calculate their similarity Default: 3 Range: [0, 10] Value type: Integer HPO tunable: Yes

HPO tunable

Can the parameter participate in hyperparameter optimization (HPO)?

create_solution_response = personalize.create_solution(
    name = "DEMO-sims-solution-hpo-"+suffix,
    datasetGroupArn = dataset_group_arn,
    recipeArn = recipe_arn,
    performHPO = True,
    solutionConfig={
        'hpoConfig': {
            'hpoResourceConfig': {
                  'maxNumberOfTrainingJobs': '40',
                  'maxParallelTrainingJobs': '10'
              }
        }
    }
)

Featurization hyper-parameter

Choose an appropriate value after you review user history lengths, using a histogram or similar tool. We recommend setting a value that retains the majority of users but removes the edge cases.

Name	Description
min_user_history_length_percentile	The minimum percentile of user history lengths to include in model training. History length is the total amount of available data on a user. Use min_user_history_length_percentile to exclude a percentage of users with short history lengths. Users with a short history often show patterns based on item popularity instead of the user's personal needs or wants. Removing them can train models with more focus on underlying patterns in your data. Default: 0.005 Range: [0.0, 1.0] Value type: Float HPO Tunable: No
max_user_history_length_percentile	The maximum percentile of user history lengths to include in model training. History length is the total amount of available data on a user. Use max_user_history_length_percentile to exclude a percentage of users with long history lengths. Users with a long history tend to contain noise. For example, a robot might have a long list of automated interactions. Removing these users limits noise in training. For example, min_hist_length_percentile = 0.05 and max_hist_length_percentile = 0.95 includes all users except ones with history lengths at the bottom or top 5% Default: 0.995 Range: [0.0, 1.0] Value type: Float HPO tunable: No
min_item_interaction_count_percentile	The minimum percentile of item interaction counts to include in model training. Use min_item_interaction_count_percentile to exclude a percentage of items with a short history of interactions. Items with a short history often are new items. Removing them can train models with more focus on items with a known history.
max_item_interaction_count_percentile	The maximum percentile of item interaction counts to include in model training. Use max_item_interaction_count_percentile to exclude a percentage of items with a long history of interactions. Items with a long history tend to be older and might be out of date. For example, a movie release that is out of print. Removing these items can focus on more relevant items. For example, min_item_interaction_count_percentile = 0.05 and max_item_interaction_count_percentile = 0.95 includes all items except ones with an interaction count at the bottom or top 5% Default: 0.9 Range: [0.0, 1.0] Value type: Float HPO tunale: No

User-Personalize

Based on automatic item exploration. It predicts the items that a user will interact with based on Interactions, Items, and Users datasets. With automatic exploration, Amazon Personalize automatically tests different item recommendations, learns from how users interact with these recommended items, and boost recommendations for items that drive better engagement and conversion. You can balance how much to explore (where items with fewer interactions data or relevance are recommended more frequently) against how much to exploit (where recommendations are based on what we know or relevance). Amazon Personalize automatically adjusts future recommendations based on implicit user feedback.

HPO tunable Hyper-parameter

Name	Description
hidden_dimension	The number of hidden variables used in the model. Hidden variables recreate the user's purchase history and item statistics to generate ranking scores. Specify a greater number of hidden dimensions when your interactions dataset includes more complicated patterns. Using more hidden dimensions requires a larger dataset and more time to process. To decide on the best value, use HPO. To use HPO, set performHPO to true when you call CreateSolution and CreateSolutionVersion operations. Default: 149 Range: [32, 256] Value type: Integer HPO tunable: Yes
bptt	Determines whether to use the back-propagation time technique. Back-propagation through time is a technique that updates weights in recurrent neural network-based algorithms. Use bptt for long-term credits to connect delayed rewards to early events. For example, a delayed reward can be a purchase made after several clicks. An early event can be an initial click. Even within the same event types, such as a click, it's a good idea to consider long-term effects and maximize the total rewards. To consider long-term effects, use larger bptt values. Using a larger bptt value requires larger datasets and more time to process. Default: 32 Range: [2, 32] Value type: Integer HPO tunable: Yes
recency_mask	Determines whether the model should consider the latest popularity trends in the interactions dataset. Latest popularity trends might include sudden changes in the underlying patterns of interaction events. To train a model that places more weight on recent events, set recency_mask to true. To train a model that equally weights all past interactions, set recency_mask to false. To get good recommendations using an equal weight, you might need a larger training dataset. Default: True Range: True or False Value type: Boolean HPO tunable: Yes

Featurization hyper-parameter

Name	Description
min_user_history_length_percentile	The minimum percentile of user history lengths to include in model training.
max_user_history_length_percentile	The maximum percentile of user history lengths to include in model training.

Item exploration campaign configuration hyper-parameter

Name	Description
exploration_weight	Determines how frequently recommendations include items with fewer interactions data or relevance. The closer the value is to 1.0, the more exploration. At 0, no exploration occurs and recommendations are based on current data (relevance). Default: 0.3 Range: [0.0, 1.0] Value type: Float HPO tunable: No
exploration_item_age_cut_off	Determine items to be explored based on the time frame since the latest interaction. Provide the maximum item age, in days since the latest interaction, to define the scope of item exploration. The larger the value, the more items are considered during exploration. Default: 30.0 Range: Positive Floats Value type: Float HPO tunale: No

Datasets and schemas

Users

Required fields

USER_ID (string)
1 metadata field (categorical string or numerical)

This dataset stores metadata about your users. This might include information such as age, gender, or loyalty membership, which can be important signals in personalization systems

Categorical metadata

With some recipes and both VIDEO_ON_DEMAND and ECOMMERCE domains, Amazon Personalize uses categorical metadata, such as a user's gender or membership status, when identifying underlying patterns that reveal the most relevant items for your users. You define your own range of values based on your use case. Categorical metadata can be in any language.

User metadata schema example

{
  "type": "record",
  "name": "Users",
  "namespace": "com.amazonaws.personalize.schema",
  "fields": [
      {
          "name": "USER_ID",
          "type": "string"
      },
      {
          "name": "AGE",
          "type": "int"
      },
      {
          "name": "GENDER",
          "type": "string",
          "categorical": true
      }
  ],
  "version": "1.0"
}

Items

This dataset stores metadata about your items. This might include information such as price, SKU type, or availability.

Required Fields

ITEM_ID (string)
1 metadata field (categorical or textual string field or numerical field)

Reserved keywords

CREATION_TIMESTAMP: For item datasets with a timestamp for each item's creation date, use the CREATION_TIMESTAMP field with a type long. Amazon Personalize uses CREATION_TIMESTAMP data to calculate the age of an item and adjust recommendations accordingly.

Categorical metadata

With certain recipes and domains, Amazon Personalize uses categorical metadata, such as an item's genre or color, when identifying underlying patterns that reveal the most relevant items for your users. You define your own range of values based on your use case. Categorical metadata can be in any language.

Categorical values can have a maximum of 1000 characters. If you have an item with a categorical value of more than 1000 characters, your dataset import job will fail.

For Domain dataset groups, both VIDEO_ON_DEMAND and ECOMMERCE domains use categorical metadata. For Custom dataset groups and custom solutions, recipes that use categorical metadata include the following:

User-Personalization
Personalized-Ranking
Similar-Items
Item-Affinity
Item-Attribute-Affinity

Unstructured text metadata

With certain recipes and domains, Amazon Personalize can extract meaningful information from unstructured text metadata, such as product descriptions, product reviews, or movie synopses. Amazon Personalize uses unstructured text to identify relevant items for your users, particularly when items are new or have fewer interactions data. Include unstructured text data in your Items dataset to increase click-through rates and conversation rates for new items in your catalog.

To use unstructured data, add a field with a type string to your Items schema and set the field's textual attribute to true. Then include the text data in your bulk CSV file and incremental item imports. For bulk CSV files, wrap the text in double-quotes. Use the \ character to escape any double quotes or \ characters in your data.

Text can be in the following languages:

Chinese (Simplified)
Chinese (Traditional)
English
French
German
Japanese
Portuguese
Spanish

Item metadata schema example

{
  "type": "record",
  "name": "Items",
  "namespace": "com.amazonaws.personalize.schema",
  "fields": [
    {
      "name": "ITEM_ID",
      "type": "string"
    },
    {
      "name": "GENRES",
      "type": [
        "null",
        "string"
      ],
      "categorical": true
    },
    {
      "name": "CREATION_TIMESTAMP",
      "type": "long"
    },
    {
      "name": "DESCRIPTION",
      "type": [
        "null",
        "string"
      ],
      "textual": true
    },
  ],
  "version": "1.0"
}

Interactions

This dataset stores historical and real-time data from interactions between users and items. In Amazon Personalize, interaction is an event that you record and then import as training data. For both Domain dataset groups and Custom dataset groups, you must at minimum create an Interaction dataset.

Required Fields

USER_ID (string)
ITEM_ID (string)
TIMESTAMP (long)

Reserved keywords

EVENT_TYPE (string): For Interactions datasets with one or more event types, such as both click and download, use an EVENT_TYPE field. You must define an EVENT_TYPE field as a string and can't be set as categorical.
EVENT_VALUE (float, null): For interactions datasets that include value data for events, such as the percentage of a video a user watched, use an EVENT_VALUE field with type float and optionally null.
IMPRESSION (string, null): For interaction datasets with explicit impressions data, use an IMPRESSIONS field with type String and optionally type null. Impressions are lists of items that were visible to a user when they interacted with (for example, clicked or watched) a particular item.
RECOMMENDATION_ID (string, null): For interactions datasets that user previous recommendations as implicit impressions data, optionally use a RECOMMENDATION_ID field with type String and optionally type null.

Contextual metadata

With certain recipes and recommender use cases, Amazon Personalize can use contextual metadata when identifying underlying patterns that reveal the most relevant items for your users. Contextual metadata is interaction data you collect on the user's environment at the time of an event, such as their location or device type.

Including contextual metadata allows you to provide a more personalized experience for existing users. For example, if customers shop differently when accessing your catalog from a phone compared to a computer, include contextual metadata about the user's device. Recommendations will then be more relevant based on how they are browsing.

Additionally, contextual metadata helps decrease the cold-start phase for new or unidentified users. The cold-start phase refers to the period when your recommendation engine provides less relevant recommendations due to the lack of historical information regarding that user.

For Domain dataset groups, the following recommender use cases can use contextual metadata:

Recommended for you (ECOMMERCE domain)
Top picks for you (VIDEO_ON_DEMAND domain)

For Custom dataset groups and custom solutions, recipes that use contextual metadata include the following:

Impressions data

Impressions are lists of items that were visible to a user when they interacted with (for example, clicked or watched) a particular item. Amazon Personalize uses impression data to determine what items to include in exploration. Exploration is where recommendations include new items with fewer interactions data or relevance. The more frequently an item occurs in impressions data, the less likely it is that Amazon Personalize includes the item in exploration.

Implicit impressions

Implicit impressions are the recommendations, retrieved from Amazon Personalize, that you show the user. You can integrate them into your recommendation workflow by including the RecommendationId (returned by the GetRecommendations and GetPersonalizedRanking operations) as input for future PutEvents requests. Amazon Personalize derives the implicit impressions based on your recommendation data.

For example, you might have an application that provides recommendations for streaming video. Your recommendation workflow using implicit impressions might be as follows:

You request video recommendations for one of your users using the Amazon Personalize GetRecommendations API operation.
Amazon Personalize generates recommendations for the user using your model (solution version) and returns them with a recommendationId in the API response.
You show the video recommendations to your user in your application.
When your user interacts with (for example, clicks) a video, record the choice in a call to the PutEvents API and include the recommendationId as a parameter. For a code, sample see Recording impressions data.
Amazon Personalize uses the recommendationId to derive the impression data from the previous video recommendations and then uses the impression data to guide exploration, where future recommendations include new videos with fewer interactions data or relevance.

Explicit impressions

Explicit impressions are impressions that you manually record and send to Amazon Personalize. Use explicit impressions to manipulate results from Amazon Personalize. The order of the items has no impact.

For example, you might have a shopping application that provides recommendations for shoes. If you only recommend shoes that are currently in stock, you can specify these items using explicit impressions. Your recommendation workflow using explicit impressions might be as follows:

You request recommendations for one of your users using the Amazon Personalize GetRecommendations API.
Amazon Personalize generates recommendations for the user using your model (solution version) and returns them in the API response.
You show the user only the recommended shoes that are in stock.
For real-time incremental data import, when your user interacts with (for example, clicks) a pair of shoes, you record the choice in a call to the PutEvents API and list the recommended items that are in stock in the impression parameter. For a code, sample see Recording impressions data.
For importing impressions in historical interactions data, you can list explicit impressions in your csv file and separate each item with a '|' character. See Formatting explicit impressions.
Amazon Personalize uses impression data to guide exploration, where future recommendations include new shoes with fewer interactions data or relevance.

Impression feedback Example

import boto3
            
personalize_events.put_events(
     trackingId = 'event tracking id',
     userId= 'user id',
     sessionId = '1',
     eventList = [{
     'sentAt': datetime.now().timestamp(),
     'eventType' : 'click',
     'itemId' : rec_response['itemList'][0]['itemId'],        
     'recommendationId': rec_response['recommendationId'],
     'impression': [item['itemId'] for item in rec_response['itemList']],
     }]
)

Interaction metadata schema example

{
  "type": "record",
  "name": "Interactions",
  "namespace": "com.amazonaws.personalize.schema",
  "fields": [
      {
          "name": "USER_ID",
          "type": "string"
      },
      {
          "name": "ITEM_ID",
          "type": "string"
      },
      {
          "name": "EVENT_TYPE",
          "type": "string"
      },
      {
          "name": "EVENT_VALUE",
          "type": [
             "float",
             "null"
          ]
      },
      {
          "name": "LOCATION",
          "type": "string",
          "categorical": true
      },
      {
          "name": "DEVICE",
          "type": [
              "string",
              "null"
          ],
          "categorical": true
      },
      {
          "name": "TIMESTAMP",
          "type": "long"
      },
      {
          "name": "IMPRESSION",
          "type": "string"
      }
  ],
  "version": "1.0"
}

Evaluation of a solution with metrics

You can evaluate the performance of your solution version through offline and online metrics. Online metrics are the empirical results you observe in your users' interactions with real-time recommendations. For example, you might record your users' click-through rate as they browse your catalog. You are responsible for generating and recording any online metrics.

Offline metrics are the metrics Amazon Personalize generates when you train a solution version. You can use offline metrics to evaluate the performance of the model before you create a campaign and provide recommendations. Offline metrics allow you to view the effects of modifying a solution's hyperparameters or compare results from models trained with the same data. For the rest of this section, the term metrics refers to offline metrics.

To get performance metrics, Amazon Personalize splits the input interactions data into a training set and a testing set. The split depends on the type of recipe you choose:

For USER_SEGMENTATION recipes, the training set consists of 80% of each user's interactions data and the testing set consists of 20% of each user's interactions data.
For all other recipe types, the training set consists of 90% of your users and their interaction data. The testing set consists of the remaining 10% of users and their interaction data.

Amazon Personalize then creates the solution version using the training set. After training completes, Amazon Personalize gives the new solution version the oldest 90% of each user’s data from the testing set as input. Amazon Personalize then calculates metrics by comparing the recommendations the solution version generates to the actual interactions in the newest 10% of each user’s data from the testing set.

Retrieving Metrics

Coverage

An evaluation metric that tells you the proportion of unique items that Amazon Personalize might recommend using your model out of the total number of unique items in Interactions and Items datasets. To make sure Amazon Personalize recommends more of your items, use a model with a higher coverage score. Recipes that feature item exploration, such as User-Personalization, have higher coverage than those that don’t, such as popularity count.

Mean reciprocal rank at 25

An evaluation metric that assesses the relevance of a model’s highest-ranked recommendation. Amazon Personalize calculates this metric using the average accuracy of the model when ranking the most relevant recommendation out of the top 25 recommendations over all requests for recommendations.

This metric is useful if you're interested in the single highest-ranked recommendation.

For example, searching for Dog and available answers are {dog, dogs, puppy} and results are below:

rank	item
1	hotdog
2	dogs
3	puppy
4	cat

RR is 1/2 since the highest possible answer ranked at second position.

$$RR=\frac{1}{Rank}$$

Additionally, searching for Cat and available answers are {cat, cats, kitty} then results are below:

rank	item
1	car
2	mouse
3	cats
4	kitty

RR is 1/3

MRR is the mean RR

$$MRR=\frac{1}{\left| \Omega \right|}\sum_{i=1}^{\left| \Omega \right|}\frac{1}{Rank_{i}}$$

So MRR of examples, $\frac{1}{2}\times(\frac{1}{2}+\frac{1}{3})\cong 0.417$

MRR is simple evaluation, but only care about highest ranked relevant item.

Normalized discounted cumulative gain (NDCG) at K (5/10/25)

Unlike MRR, DCG considers all ranked item in metrics.

DCG assumptions

Highly relevant documents are more useful, when appearing earlier in a search engine result list (have higher ranks)
Highly relevant documents are more useful than marginally relevant documents, which are in turn more useful than non-relevant documents.

$$DCG_{p}=\sum_{i=1}^{p}\frac{rel_{i}}{log_{2}(i+1)}$$

Example

When search for Dog, results come out below:

rank	item	relevance	$log_{2}(i+1)$	$\frac{rel_{i}}{log_{2}(i+1)}$
1	hotdog	0	1	0
2	dogs	2	1.585	1.26
3	puppy	1	2	0.5
4	cat	0	2.322	0

$DCG_{4}=0+1.26+0.5+0=1.76$

An evaluation metric that tells you about the relevance of your model’s highly ranked recommendations, where K is a sample size of 5, 10, or 25 recommendations. Amazon Personalize calculates this by assigning weight to recommendations based on their position in a ranked list, where each recommendation is discounted (given a lower weight) by a factor dependent on its position. The normalized discounted cumulative gain at K assumes that recommendations that are lower on a list are less relevant than recommendations higher on the list.

$weighting \ factor = \frac{1}{log(1+position)}$

Precision at K

An evaluation metric that tells you how relevant your model's recommendations are based on a sample size of K (5, 10, or 25) recommendations. Amazon Personalize calculates this metric based on the number of relevant recommendations out of the top K recommendations, divided by K, where K is 5, 10, or 25.

This metric rewards precise recommendations of the relevant items.

average_rewards_at_k

When you create a solution version (train a model) for a solution with an optimization objective, Amazon Personalize generates an average_rewards_at_k metric. The score for average_rewards_at_k tells you how well the solution version performs in achieving your objective. To calculate this metric, Amazon Personalize calculates the rewards for each user as follows:

rewards_per_user = total rewards from the user's interactions with their top 25 reward-generating recommendations / total rewards from the user's interactions with recommendations

The final average_rewards_at_k is the average of all rewards_per_user normalized to be a decimal value less than or equal to 1 and greater than 0. The closer the value is to 1, the more gains on average per user you can expect from recommendations.

For example, if your objective is to maximize revenue from clicks, Amazon Personalize calculates each user score by dividing total revenue generated by the items the user clicked from their top 25 most expensive recommendations by the revenue from all of the recommended items the user clicked. Amazon Personalize then returns a normalized average of all user scores. The closer the average_rewards_at_k is to 1, the more revenue on average you can expect to gain per user from recommendations.

hit (hit at K)

If you trained the solution version with a USER_SEGMENTATION recipe, the average number of users in the predicted top relevant K results that match the actual users. Actual users are who actually interacted with the items in the test set. K is in the top 1% of the most relevant user. The higher the value the more accurate the predictions.

recall (recall at K)

If you trained the solution version with a USER_SEGMENTATION recipe, the average percentage of predicted users in the predicted top relevant K results that match the actual users. Actual users are the users who actually interacted with the items in the test set. K is the top 1% of the most relevant users. The higher the value, the more accurate the predictions.

Example

precision_at_5

Calculation: 2/5, result: 0.4

Reference

https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-sims.html

https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-new-item-USER_PERSONALIZATION.html

https://ieeexplore.ieee.org/document/1167344

https://arxiv.org/pdf/2007.11808.pdf

https://github.com/aws-samples/amazon-personalize-samples/blob/master/next_steps/core_use_cases/related_items/personalize_sims_example.ipynb

https://github.com/aws-samples/amazon-personalize-samples/blob/master/next_steps/core_use_cases/user_personalization/user-personalization-with-exploration.ipynb

https://docs.aws.amazon.com/personalize/latest/dg/how-it-works-dataset-schema.html

https://docs.aws.amazon.com/personalize/latest/dg/working-with-training-metrics.html

https://docs.aws.amazon.com/personalize/latest/dg/optimizing-solution-for-objective.html

https://www.youtube.com/watch?v=givCgC_RIFs

User-User Collaborative Filtering

데먕 — Thu, 7 Jul 2022 17:41:30 +0900

	Batman	X-Men	Star Wars	The Notebook	Bridget Jones' Diary
Alice	5	4.5	5	2	1
Bob	4.5	4		2	2
Carol	2	3	1	5	5

Intuitively, we see that Bob’s ratings are similar to Alice’s, thus he is likely to also like Star Wars. In math-speak, Alice’s and Bob’s ratings are highly correlated.

Average Rating

Limitations

It treats everyone’s rating of the movie. equally.
Bob’s s(i, j) equally depends on Alice’s rating and Carol’s rating, even though he doesn’t agree with Carol

$$s(i,j)=\frac{\sum_{i'\in\Omega_{j}}r_{i'j}}{|\Omega_{j}|}$$

One of the Solutions

Intuitively, I want to be small for users I don't agree with, large for users I do agree with

$$s(i,j)=\frac{\sum_{i\acute{}\in \Omega _{j}} w_{ii\acute{}}r_{i\acute{}j}}{\sum_{i\acute{}\in \Omega _{j}}w_{ii\acute{}}}$$

Another issue with average rating: Bias

Your interpretation of a rating is different from mine
Users can be biased to be optimistic or pessimistic
E.g. optimistic: most movies are a 5, a bad movie is a 3
E.g. pessimistic: most movies are 1 or 2, a good movie is a 4

Deviation (without weighting)

We don’t care about your absolute rating, we care how much it deviates from your own average

If your average is 2.5, but you rate something a 5, it must be really great
If you rate everything a 5, it’s difficult to know how those items compare

$$dev(i,j)=r(i,j)-\bar{r}, for \ a \ known \ rating$$

The deviation is your rating - average rating, in other words, rating - bias.

My predicted deviation is the average deviation for a movie

Then my predicted rating is my own average + predicted deviation

$$\hat{dev}(i,j)=\frac{\sum_{i'\in\Omega_{j}}{r(i',j)-\bar{r}_{i'}}}{|\Omega_{j}|}, for \ a \ prediction \ from \ known \ ratings$$

$$s(i,j)=\bar{r}_{i}+\frac{\sum_{i'\in\Omega_{j}}{r(i',j)-\bar{r}_{i'}}}{|\Omega_{j}|}=\bar{r}_{i}+\hat{dev}(i,j)$$

Combine (Weighting Rating + Deviation)

Combine the idea of deviations with the idea of weighting to get our final formula
Note: absolute value since weights can be negative
Looking at this equation, we can see that it's just linear regression.

Intuitively, I want it to be small for users I don’t agree with, large for users I do agree with

$$s(i,j)=\bar{r}_{i}+\frac{\sum_{i'\in\Omega_{j}}{w_{ii'}(r(i',j)-\bar{r}_{i'})}}{\sum_{i'\in\Omega_{j}}|w_{ii'}|}$$

Hot to calculate weights? Pearson Correlation Coefficient

$$\rho_{xy}=\frac{\sum^N_{i=1}(x_{i}-\bar{x})(y_{i}-\bar{y})}{\sqrt{\sum^{N}_{i=1}(x_{i}-\bar{x})^2}\sqrt{\sum^{N}_{i=1}(y_{i}-\bar{y})^2}}$$

Problem: Our matrix is sparse

Solution: Just use the data we have

$$w_{ii'}=\frac{\sum_{j\in\psi_{ii'}}(r_{ij}-\bar{r}_{i})(r_{i'j}-\bar{r}_{i'})}{\sqrt{\sum_{j\in\psi_{ii'}}(r_{ij}-\bar{r}_{i})^2}\sqrt{\sum_{j\in\psi_{ii'}}(r_{i'j}-\bar{r}_{i'})^2}}$$

$\psi_{i}=set \ of \ movies \ that \ user \ i \ has \ rated$

$\psi_{ii'}=set \ of \ movies \ both \ user \ i \ and \ i' \ have \ rated$

$\psi_{ii'}=\psi_{i}\cap\psi_{i'}$

What if 2 users have zero movies in common, or just a few?
If zero, don’t consider i’ in user i’s calculation - it can’t be calculated
If few (e.g. < 5) then don’t use the weight, since not enough data to be accurate

Cosine Similarity

Pearson correlation is “old-school statistics”
These days, when you want to compare two vectors, it seems more fashionable to use the cosine similarity

$$cos\theta=\frac{x^Ty}{|x||y|}=\frac{\sum^N_{i=1}x_iy_i}{\sqrt{\sum^N_{i=1}x^2_i}\sqrt{\sum^N_{i=1}y^2_i}}$$

Cosine Similarity vs. Pearson Correlation

They are the same except Pearson is centered
We want to center them anyway because we’re working with deviations not absolute ratings
If working with deviations rather than average, the cosine similarity is equivalent to the Pearson Correlation

Problem

What if 2 users have 0 movies in common, or just a few?
If 0, don't consider i' in user i's calculation - it can't be calculated
If few (e.g. < 5) then don't use the weight, since not enough data to be accurate

Neighborhood

In practice, don’t sum over all users who rated movie j (takes too long)
It can help to precompute weights beforehand
Non-trivial: instead of summing over all users, take the ones with the highest weight (called neighbors)
- E.g. use K nearest neighbors, K = 25 up to 50

Is it useful to keep a negative weight? Yes

A strong correlation is very negative, but no correlation is 0
Thus, you might want to keep neighbors sorted on absolute correlation

Big Data

Suppose we have 100k = 100,000 users

$$Then\ we\ need\ 10^{10} \ weights$$

10 billion
32-bit float = 4 bytes
~ 40 GB
- Most modern computers have 4~32 GB RAM, 128 GB on the high end
- We are reaching the limit of capacity
Not just size, but the time required to calculate

$$O(N^2)\ is \ slow$$

Possible Issues

N users, M items then R is NxM
How long does it take to calculate the similarity between 2 users, w(i, i')? O(M)
For a single rating prediction, we have to find the weights against all other users
Even if we just keep the top K neighbors, we still need to calculate them all, since they must be sorted to find the top K
O(N) users, O(M) calculations each time -> O(NM)
If you're a company building a recommendation engine, you need to make recommendations for all N users
We need w(i,i') for i...N and i'=1...N -> $O(N^{2})$
Including the time to calculate each correlation -> $O(N^{2}M)$

Computation Complexity Scenario

Work on a subset of data

Take top n users and top m movies (n < N, m < M)
Top user = user who has rated the most movies
Top movie = movie that has been rated the most times
Yield a more dense matrix
Experiment to determine a workable value for n and m

Recommendation for a single user

Calculate weights between this use and all others: O(MN)
Calculate scores s(i, j) for all items: also O(MN)
- M items
- Sum over N terms for each item
Sort the scores: O(MlogM)
Total: O(MN) + O(MlogM)
This is theoretical - practically, you can make things faster
- Precomputing user-user weights, but not real-time
- For the score, only sum using users similar to me - if top K, then O(MK)
- Sorting - if keep only L items, then O(MlogL)

Precomputing

Precompute recommendations using (possibly) big data technologies as offline jobs
You don’t want to do an O(MlogM) sort in real-time - even O(M) would be bad
Use a “cronjob” to run your task every day at some time, e.g. 3 am
Your API can simply retrieve items already stored in a database

Desired Output

Since we are doing regression, we want MSE
Outline
- Split data into train and test
- Calculate weights using a train set
- Make a predict function, e.g. score ← predict(i, j)
- Output MSE for train and test sets

Association Analysis

데먕 — Thu, 7 Jul 2022 17:31:12 +0900

Definition

As a role-based model, it is an algorithm that finds out how an item relates to another item. This association exists in two forms.

How often are they purchased together? (Frequent)
If someone bought item A, will he also buy item B?

It is also expressed as a shopping Market basket analysis because it is similar to looking at which products are contained in one shopping basket.

Ex) Famous anecdote is that when purchasing beer at Walmart, there is a high tendency to buy diapers together, so he also set up a strategy to display the two together.

Minsup

$$s(X)=\frac{\sigma(X)}{N}$$

An itemset X is called frequent if $s(X)$ is greater than some user-defined threshold, minsup.

Association Rule

Frequent Itemset Generation, whose objective is to find all the itemsets that satisfy the minsup threshold.

An association rule is an implication expression of the form X→Y, where X and Y are disjoint itemsets (X∩Y=∅).

The strength of an association rule can be measured in terms of its support and confidence. A rule that has very low support may occur simply by chance. Confidence measures the reliability of the inference made by a rule.

Support

For the rule A → B,

$$support(A)=P(A, B)$$

$$\sigma(X) \ is \ the \ support \ count \ of \ X \\ N \ is \ the \ count \ of \ the \ transactions \ set \ T \\ s(X \rightarrow \ Y)=\frac{\sigma(X\cup Y)}{N}$$

Confidence

$$confidence(A \rightarrow B)=\frac{P(A,B)}{P(A)}$$

Lift

Measure how frequently events occur at the same time or independent

$$lift(A\rightarrow B)=\frac{P(A,B)}{P(A)\times P(B) }$$

$$lift(A, B)\left\{\begin{matrix}
= 1, if \ A \ and \ B \ are \ independent \\
> 1, if \ A \ and \ B \ are \ positively \ related \\
< 1, if \ A \ and \ B \ are \ negatively \ related \end{matrix}\right.$$

Rule Generation

Rule generation, whose objective is to extract all the high confidence rules from the frequent itemsets found in the Frequent Itemset Generation. These rules are called strong rules.

Extract all rules from the itemsets

Problem

The number of rules increases exponentially as items increase

Example

TID	Items
1	{Bread, Milk}
2	{Bread, Diapers, Beer, Eggs}
3	{Milk, Diapers, Beer, Cola}
4	{Bread, Milk, Diapers, Beer}
5	{Bread, Milk, Diapers, Cola}

{Beer, Diaspers, Milk} Support = $\frac{\sigma(X \cup Y)}{N}$ = $\frac{2}{5}$

{Milk, Diapers} -> {Beer} Confidence = $\frac{\sigma(X \cup Y)}{\sigma (X)}$ = $\frac{2}{3}$

Reference

https://chih-ling-hsu.github.io/2017/03/25/Data-Mining-Association-Analysis

https://livebook.manning.com/book/machine-learning-in-action/chapter-11/33

https://www.youtube.com/watch?v=43gb7WK56Sk

https://www-users.cse.umn.edu/~kumar001/dmbook/ch5_association_analysis.pdf

AWS MSK

데먕 — Fri, 1 Jul 2022 20:05:05 +0900

Overview

Alternative to Kinesis (Kafka vs Kinesis next lecture)
Fully managed Apache Kafka on AWS
- Allow you to create, update, delete clusters
- MSK create & manages Kafka brokers nodes & Zookeeper nodes for you
- Deploy the MSK cluster in your VPC, multi-AZ (up to 3 for HA)
- Automatic recovery from common Apache Kafka failures
- Data is stored on EBS volumes
You can build producers and consumers for your clusters
- Default message size of 1 MB
- Possibilities of sending large message (ex: 10 MB) into Kafka after custom configuration

Configuration

Choose the number of AZ (3 - recommended, or 2)
Choose the VPC & Subnets
The broker instance type (ex: kafka.m5.large)
The number of brokers per AZ (can add brokers later)
Size of your EBS volumes (1 GB - 16 TB)

Security

Encryption

Optional in-flight using TLS between the brokers
Optional in-flight with TLS between the clients and brokers
At rest for your EBS volumes using KMS

Network Security

Authorize specific security groups for your Apache Kafka clients

Authentication & Authorization (important)

Define who can read/write to which topics
MutualTLS (AuthN) + Kafka ACLs (AuthZ)
SASL/SCRAM (AuthN) + Kafka ACLs (AuthZ)
IAM Access Control (AuthN + AuthZ)

Monitoring

CloudWatch Metrics

Basic monitoring (cluster and broker metrics)
Enhanced monitoring (++enhanced broker metrics)
Topic-level monitoring (++enhanced topic-level metrics)

Prometheus (Open-Source Monitoring)

Opens a port on the broker to export cluster, broker and topic-level metrics
Setup the JMX Exporter (metrics) or Node Exporter (CPU and disk metrics)

Broker Log Delivery

Delivery to CloudWatch Logs
Delivery to Amazon S3
Delivery to Kinesis Data Streams

MSK Connect

Managed Kafka Connect workers on AWS
Auto-scaling capabilities for workers
You can deploy any Kafka Connect connectors to MSK Connect as a plugin
- S3, RedShift, OpenSearch, Debezium, and etc.
Example pricing: Pay $ 0.11 per worker per hour

MSK Serverless

Run Apache Kafka on MSK without managing the capacity
MSK automatically provisions resources and scales compute & storage
You just define your topics and your partitions and you’re good to go
Security: IAM Access Control for all clusters
Example Pricing:
- $0.75 per cluster per hour = $558 monthly per cluster
- $0.0015 per partition per hour = $1.08 monthly per partition
- $0.10 per GB of storage each month
- $0.10 per GB in
- $0.10 per GB out

Kinesis Data Streams vs Amazon MSK

	Kinesis Data Streams	Amazon MSK
Message Size Limit	1 MB message size limit	1 MB default, configure for higher (ex: 10MB)
Distribution	Data Streams with Shards	Kafka Topics with Partitions
Sizing	Shard Splitting & Merging	Can only add partitions to a topic
In-flight Security	TLS In-flight encryption	PLAINTEXT or TLS In-flight Encryption
Rest Security	KMS At-rest encryption	KMS At-rest encryption
Auth	IAM policies for AuthN/AuthZ	Mutual TLS (AuthN) + Kafka ACLs (AuthZ) SASL/SCRAM (AuthN) + Kafka ACLs (AuthZ) IAM Access Control (AuthN + AuthZ)

Collection Introduction

데먕 — Wed, 29 Jun 2022 19:37:47 +0900

Real Time - Immediate actions

Kinesis Data Streams (KDS)
Simple Queue Service (SQS)
Internet of Things (IoT)

Near-real time - Reactive actions

Kinesis Data Firehose (KDF)
Database Migration Service (DMS)

Batch - Historical Analysis

Snowball
Data Pipeline