Semi-Supervised Learning (준지도 학습)
메타 정보
| 항목 |
내용 |
| 분류 |
Data-Efficient Learning / Label-Efficient Learning |
| 핵심 논문 |
"Pseudo-Label" (Lee, ICML Workshop 2013), "Temporal Ensembling for Semi-Supervised Learning" (Laine & Aila, ICLR 2017), "MixMatch" (Berthelot et al., NeurIPS 2019), "FixMatch" (Sohn et al., NeurIPS 2020), "FlexMatch" (Zhang et al., NeurIPS 2021), "FreeMatch" (Wang et al., ICLR 2023), "SoftMatch" (Chen et al., ICLR 2023) |
| 주요 저자 |
Kihyuk Sohn (FixMatch), David Berthelot (MixMatch/ReMixMatch), Bowen Zhang (FlexMatch/USB), Yidong Wang (FreeMatch/USB), Hao Chen (SoftMatch), Antti Tarvainen (Mean Teacher) |
| 핵심 개념 |
소량의 레이블 데이터와 대량의 비레이블 데이터를 동시에 활용하여 모델 성능을 향상시키는 학습 패러다임 |
| 관련 분야 |
Active Learning, Self-Supervised Learning, Contrastive Learning, Data-Centric AI, Transfer Learning |
정의
Semi-Supervised Learning (SSL)은 소량의 레이블 데이터 (labeled)와 대량의 비레이블 데이터 (unlabeled)를 함께 사용하여 학습하는 방법론이다. 현실 세계에서 레이블링 비용이 높기 때문에, 비레이블 데이터의 구조적 정보를 활용하여 지도학습의 성능 한계를 돌파하는 것이 목표다.
문제 설정:
D_l = {(x_1, y_1), ..., (x_n, y_n)} 소량 레이블 데이터 (n개)
D_u = {u_1, u_2, ..., u_m} 대량 비레이블 데이터 (m개, m >> n)
목표: D_l + D_u를 모두 활용하여 학습한 f_theta의 성능이
D_l만 사용한 경우보다 유의미하게 높은 것
전체 손실 함수:
L = L_s + lambda * L_u
L_s: 지도 학습 손실 (레이블 데이터)
= (1/n) * sum_i CE(f_theta(x_i), y_i)
L_u: 비지도 학습 손실 (비레이블 데이터)
= 방법론에 따라 다름 (일관성 정규화, 의사 레이블 등)
lambda: 비지도 손실의 가중치 (학습 진행에 따라 조절)
핵심 가정 (SSL Assumptions)
Semi-Supervised Learning이 효과적으로 작동하기 위해서는 데이터 분포에 대한 가정이 필요하다.
1. Smoothness Assumption (평활성 가정)
- 입력 공간에서 가까운 두 점 x_1, x_2는 같은 레이블을 가질 확률이 높다
- 결정 경계(decision boundary)는 고밀도 영역을 피해야 한다
2. Low-Density Separation (저밀도 분리 가정)
- 결정 경계는 입력 분포의 저밀도 영역을 통과해야 한다
- 고밀도 클러스터 내부를 가르지 않아야 한다
- -> Entropy Minimization, Pseudo-Label의 이론적 근거
3. Manifold Assumption (매니폴드 가정)
- 고차원 데이터가 저차원 매니폴드 위에 존재한다
- 같은 매니폴드 위의 점들은 같은 레이블을 공유할 가능성이 높다
- -> Graph-Based SSL, Manifold Regularization의 근거
4. Cluster Assumption (클러스터 가정)
- 같은 클러스터에 속한 데이터는 같은 레이블을 가진다
- Smoothness + Low-Density Separation의 결합
가정이 위반되면:
- 비레이블 데이터가 오히려 성능을 저하시킬 수 있음 (Confirmation Bias)
- 클래스 분포가 불균형하면 다수 클래스로 편향
- 매니폴드 구조가 복잡하면 일관성 정규화 실패
방법론 계보
1세대: 고전적 방법 (2000s)
Self-Training (자기 학습)
가장 단순한 형태의 SSL
반복:
1. D_l로 모델 학습
2. D_u에 대해 예측 수행
3. 높은 신뢰도의 예측을 의사 레이블(pseudo-label)로 채택
4. 의사 레이블 데이터를 D_l에 추가
5. 1로 돌아가 반복
문제점:
- 초기 모델이 약하면 오류가 누적 (Confirmation Bias)
- 신뢰도 임계값 설정이 어려움
Co-Training (Blum & Mitchell, 1998)
- 두 개의 독립적인 특성 뷰(view)로 각각 분류기를 학습
- 한 분류기의 높은 신뢰도 예측을 다른 분류기의 학습 데이터로 사용
- 조건: 두 뷰가 조건부 독립이고 각각 충분한 정보를 가져야 함
Graph-Based SSL
- 데이터 포인트를 노드, 유사도를 엣지로 하는 그래프 구성
- 레이블 전파(Label Propagation)로 비레이블 노드에 레이블 할당
- 대규모 데이터에 확장성 문제
2세대: 일관성 정규화 (2016-2019)
핵심 아이디어:
"같은 입력에 대한 작은 변형(perturbation)은 같은 출력을 내야 한다"
f_theta(x) ~= f_theta(augment(x))
Pi-Model (Laine & Aila, ICLR 2017)
L_u = ||f_theta(aug_1(u)) - f_theta(aug_2(u))||^2
- 같은 입력의 두 번의 확률적 augmentation 결과가 일치하도록 학습
- 드롭아웃의 확률적 성질도 변형으로 활용
Temporal Ensembling (Laine & Aila, ICLR 2017)
- Pi-Model의 개선: 각 에폭 끝에 예측을 EMA로 누적
- 타겟이 더 안정적이지만, 에폭 단위로만 업데이트 가능
Mean Teacher (Tarvainen & Valpola, NeurIPS 2017)
핵심 구조:
Student 모델 (theta) -------- 예측 --------> p_s = f_theta(aug_s(u))
| |
| EMA 업데이트 | 일관성 손실
v v
Teacher 모델 (theta') ------- 예측 --------> p_t = f_theta'(aug_w(u))
theta'_t = alpha * theta'_{t-1} + (1 - alpha) * theta_t
(alpha = 0.999, EMA decay rate)
- Teacher가 Student의 EMA -> 더 안정적인 타겟 제공
- 매 스텝 업데이트 가능 (Temporal Ensembling 대비 이점)
- 이후 거의 모든 SSL 방법의 기본 구조가 됨
Virtual Adversarial Training (VAT, Miyato et al., IEEE TPAMI 2018)
L_vat = max_{||r||<=eps} KL(f_theta(x) || f_theta(x + r))
- 모델 출력을 가장 크게 바꾸는 방향의 perturbation을 찾고
- 그 방향으로도 출력이 일관되도록 학습
- Adversarial 방식이라 augmentation 설계 불필요
3세대: Holistic 접근법 (2019-2020)
MixMatch (Berthelot et al., NeurIPS 2019)
SSL의 여러 기법을 하나로 통합한 전환점적 논문
핵심 구성요소:
1. Consistency Regularization: K번 augmentation 후 예측 평균
2. Entropy Minimization: 평균 예측을 sharpening
3. MixUp: 레이블/비레이블 데이터 간 보간
처리 과정:
비레이블 u에 대해:
1. K개 augmentation 생성: aug_1(u), ..., aug_K(u)
2. 각각 모델 예측: p_1, ..., p_K
3. 평균 예측: p_bar = (1/K) * sum(p_k)
4. Sharpening: q = Sharpen(p_bar, T)
q_c = p_bar_c^(1/T) / sum_j p_bar_j^(1/T) (T < 1이면 분포가 뾰족해짐)
5. MixUp으로 레이블/비레이블 데이터 혼합
CIFAR-10 (250 labels): 88.95% 정확도
ReMixMatch (Berthelot et al., 2019)
MixMatch + Distribution Alignment + Augmentation Anchoring
- 비레이블 의사 레이블의 클래스 분포를 레이블 데이터 분포에 맞춤
- 강한 augmentation 도입 (CTAugment)
UDA (Unsupervised Data Augmentation, Xie et al., NeurIPS 2020)
핵심 통찰: 강한 augmentation이 SSL의 핵심
L_u = (1/m) * sum_j 1[max(p_j) >= tau] * CE(p_j, f_theta(Aug_strong(u_j)))
- 약한 augmentation으로 의사 레이블 생성
- 강한 augmentation (RandAugment, Back-Translation)에 대해 일관성 학습
- NLP에서도 Back-Translation으로 적용 가능
4세대: FixMatch 패밀리 (2020-)
FixMatch (Sohn et al., NeurIPS 2020)
현대 SSL의 사실상 표준 프레임워크. 놀라울 정도로 단순하면서도 강력.
핵심 아이디어: Consistency Regularization + Pseudo-Labeling
알고리즘:
각 비레이블 샘플 u에 대해:
1. 약한 augmentation 적용 -> p = f_theta(aug_weak(u))
2. 신뢰도 확인: max(p) >= tau (고정 임계값, 기본 0.95)
3. 의사 레이블 생성: y_hat = argmax(p)
4. 강한 augmentation 적용 -> q = f_theta(aug_strong(u))
5. 의사 레이블로 학습: CE(y_hat, q)
L_u = (1/mu*B) * sum_j 1[max(p_j) >= tau] * CE(y_hat_j, f_theta(aug_strong(u_j)))
약한 augmentation: flip + crop
강한 augmentation: RandAugment 또는 CTAugment
성능:
CIFAR-10 (40 labels): 94.93%
CIFAR-10 (250 labels): 95.74%
STL-10 (1000 labels): 94.91%
한계:
- 고정 임계값 tau = 0.95가 모든 클래스에 동일하게 적용
- 학습 초기에 임계값을 넘는 샘플이 적어 비레이블 활용률 낮음
- 쉬운 클래스는 빨리 임계값을 넘지만, 어려운 클래스는 오래 무시됨
FlexMatch (Zhang et al., NeurIPS 2021)
FixMatch의 고정 임계값 문제를 해결: 클래스별 적응형 임계값
핵심: Curriculum Pseudo Labeling (CPL)
클래스별 학습 상태 추정:
sigma_c(t) = (1/m) * sum_j 1[max(f_theta(u_j)) >= tau AND argmax(f_theta(u_j)) == c]
적응형 임계값:
tau_c(t) = beta(sigma_c(t)) * tau
beta(x) = x / max_c(sigma_c) (정규화 함수)
효과:
- 쉬운 클래스(높은 sigma_c): 임계값 상승 -> 더 엄격한 필터링
- 어려운 클래스(낮은 sigma_c): 임계값 하락 -> 더 많은 샘플 활용
- 커리큘럼 학습 효과: 쉬운 것부터 어려운 것으로 점진적 학습
FreeMatch (Wang et al., ICLR 2023)
자기 적응형(Self-Adaptive) 임계값 + 클래스별 조정
글로벌 임계값 (EMA):
tau_t = lambda * tau_{t-1} + (1 - lambda) * (1/mu*B) * sum_j max(p_j)
클래스별 조정:
tau_c(t) = MaxNorm(p_bar_c(t)) * tau_t
p_bar_c(t) = EMA of class-c predictions
Self-Adaptive Fairness (SAF):
비레이블 예측 분포를 균등화하여 클래스 편향 방지
SoftMatch (Chen et al., ICLR 2023)
Hard thresholding 대신 Soft weighting으로 양(quantity)-질(quality) 트레이드오프 해결
통합 가중치 함수:
w(x) = quality(x) * quantity(x)
Truncated Gaussian:
w(s) = exp(-(s - 1)^2 / (2 * sigma^2)) * 1[s >= tau]
s = max(p): 의사 레이블의 최대 확률
- 매우 높은 신뢰도(s -> 1): 높은 가중치 (고품질)
- 중간 신뢰도(s ~= tau): 중간 가중치 (양 확보)
- 낮은 신뢰도(s < tau): 가중치 0 (노이즈 배제)
Hard thresholding(FixMatch) vs Soft weighting(SoftMatch):
FixMatch: w(s) = 1 if s >= tau, 0 otherwise (이진)
SoftMatch: w(s) = smooth function (연속)
SimMatch (Zheng et al., CVPR 2022)
Semantic similarity + Instance similarity를 동시에 활용
- Semantic: 클래스 레벨의 의사 레이블 일관성
- Instance: 인스턴스 레벨의 유사도 기반 전파
- Memory bank으로 레이블 데이터의 표현 저장
- 두 레벨의 일관성을 상호 보완적으로 학습
핵심 기법 비교
+----------------+------------------+-----------------+------------------+----------+
| 방법 | 임계값 전략 | Augmentation | 핵심 기여 | 연도 |
+----------------+------------------+-----------------+------------------+----------+
| Pi-Model | 없음 | 확률적 변형 | 일관성 정규화 | 2017 |
| Mean Teacher | 없음 | 확률적 변형 | EMA Teacher | 2017 |
| MixMatch | 없음 (Sharpening)| 약한 (K회) | 기법 통합+MixUp | 2019 |
| UDA | 고정 (tau) | 강한 (RA/BT) | 강한 augmentation| 2020 |
| FixMatch | 고정 (0.95) | 약한+강한 | 단순한 통합 | 2020 |
| FlexMatch | 클래스별 적응 | 약한+강한 | CPL | 2021 |
| SimMatch | 고정 + 유사도 | 약한+강한 | 이중 유사도 | 2022 |
| FreeMatch | 자기 적응 + EMA | 약한+강한 | SAF | 2023 |
| SoftMatch | Soft weighting | 약한+강한 | 가중치 함수 통합 | 2023 |
+----------------+------------------+-----------------+------------------+----------+
벤치마크 성능
CIFAR-10 정확도 (%) - 레이블 수별
방법 | 40 labels | 250 labels | 4000 labels
--------------+-----------+------------+------------
Supervised | ~52 | ~80 | ~93
Pi-Model | - | 54.26 | 87.17
Mean Teacher | - | 67.68 | 90.81
MixMatch | 63.81 | 88.95 | 93.58
UDA | 89.38 | 94.84 | 95.71
FixMatch | 94.93 | 95.74 | 95.69
FlexMatch | 95.03 | 95.02 | 95.82
FreeMatch | 95.14 | 95.08 | -
SoftMatch | 95.22 | 95.15 | -
SimMatch | 94.40 | 95.16 | -
CIFAR-100 정확도 (%) - 레이블 수별
방법 | 400 labels | 2500 labels | 10000 labels
--------------+------------+-------------+-------------
FixMatch | 51.15 | 71.71 | 77.40
FlexMatch | 60.06 | 73.51 | 78.10
FreeMatch | 60.52 | 73.82 | -
SoftMatch | 61.28 | 74.15 | -
참고: USB (Unified SSL Benchmark, NeurIPS 2022 Datasets Track)에서 표준화된 벤치마크 제공
실전 고려사항
1. 데이터 불균형 (Class Imbalance)
문제: 다수 클래스의 의사 레이블이 지배적 -> 소수 클래스 무시
해결:
- Distribution Alignment (ReMixMatch): 의사 레이블 분포를 레이블 분포에 맞춤
- DARP (Kim et al., NeurIPS 2020): 의사 레이블 분포를 명시적으로 리밸런싱
- ABC (Lee et al., NeurIPS 2021): Auxiliary Balanced Classifier
2. Confirmation Bias (확증 편향)
문제: 잘못된 의사 레이블 -> 모델이 오류를 반복 학습 -> 오류 누적
해결:
- 높은 임계값 (FixMatch: 0.95)
- 적응형 임계값 (FlexMatch, FreeMatch)
- Soft weighting (SoftMatch)
- Temporal Ensembling / Mean Teacher (안정적 타겟)
3. Open-Set / Out-of-Distribution
문제: 비레이블 데이터에 학습 클래스에 없는 샘플이 포함
해결:
- OpenMatch (Saito et al., NeurIPS 2021): OOD 탐지 + SSL 통합
- MOOD (Li et al., CVPR 2023): Multi-granularity OOD 감지
- IOMatch (Li et al., ICLR 2024): OOD 감지를 임계값에 통합
4. 도메인/분포 시프트
문제: 레이블/비레이블 데이터의 분포가 다른 경우
해결:
- CDMAD (Guo et al., AAAI 2022): Cross-Domain SSL
- Semi-Supervised Domain Adaptation 기법 활용
5. 실무 가이드라인
- 레이블 비율: 전체 데이터의 1-10%면 SSL이 효과적
- 비레이블 양: 많을수록 좋지만, 품질(도메인 일치)이 더 중요
- 강한 augmentation: RandAugment(M=10, N=2)가 표준
- 학습 길이: 지도학습보다 2-5배 긴 학습 필요 (2^20 스텝 일반적)
- 모델 선택: 검증 세트가 작으므로 early stopping 대신 마지막 체크포인트 사용
Python 구현 예시
FixMatch 핵심 루프 (PyTorch)
import torch
import torch.nn.functional as F
from torchvision import transforms
# FixMatch 핵심 학습 루프
class FixMatch:
def __init__(self, model, optimizer, tau=0.95, lambda_u=1.0, mu=7):
"""
Args:
model: 분류 모델
tau: 의사 레이블 신뢰도 임계값 (기본 0.95)
lambda_u: 비지도 손실 가중치
mu: 비레이블 배치 비율 (비레이블 배치 = mu * 레이블 배치)
"""
self.model = model
self.optimizer = optimizer
self.tau = tau
self.lambda_u = lambda_u
self.mu = mu
def train_step(self, x_lb, y_lb, x_ulb):
"""
Args:
x_lb: 레이블 데이터 (B, C, H, W)
y_lb: 레이블 (B,)
x_ulb: 비레이블 데이터 (mu*B, C, H, W)
"""
batch_size = x_lb.shape[0]
# 1. 지도 학습 손실
logits_lb = self.model(x_lb)
loss_s = F.cross_entropy(logits_lb, y_lb)
# 2. 비레이블 데이터 처리
# 약한 augmentation -> 의사 레이블 생성
x_ulb_weak = weak_augment(x_ulb) # flip + crop
x_ulb_strong = strong_augment(x_ulb) # RandAugment
with torch.no_grad():
logits_weak = self.model(x_ulb_weak)
probs = torch.softmax(logits_weak, dim=-1)
max_probs, pseudo_labels = probs.max(dim=-1)
# 신뢰도 임계값 필터링
mask = max_probs.ge(self.tau).float() # (mu*B,)
# 3. 강한 augmentation에 대한 의사 레이블 학습
logits_strong = self.model(x_ulb_strong)
loss_u = (F.cross_entropy(logits_strong, pseudo_labels, reduction='none')
* mask).mean()
# 4. 전체 손실
loss = loss_s + self.lambda_u * loss_u
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
return {
'loss': loss.item(),
'loss_s': loss_s.item(),
'loss_u': loss_u.item(),
'mask_ratio': mask.mean().item(), # 임계값을 넘는 비율
}
def weak_augment(x):
"""약한 augmentation: RandomHorizontalFlip + RandomCrop"""
return transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomCrop(32, padding=4),
])(x)
def strong_augment(x):
"""강한 augmentation: RandAugment"""
return transforms.Compose([
transforms.RandAugment(num_ops=2, magnitude=10),
transforms.RandomCrop(32, padding=4),
])(x)
FlexMatch 적응형 임계값 (PyTorch)
import torch
import numpy as np
class FlexMatchThreshold:
"""FlexMatch의 Curriculum Pseudo Labeling (CPL) 구현"""
def __init__(self, num_classes, tau=0.95, n_ulb=50000):
self.num_classes = num_classes
self.tau = tau
self.n_ulb = n_ulb
# 클래스별 학습 상태 카운터
self.classwise_acc = torch.zeros(num_classes)
def update(self, pseudo_labels, max_probs):
"""클래스별 학습 상태 업데이트"""
mask = max_probs.ge(self.tau)
for c in range(self.num_classes):
class_mask = (pseudo_labels == c)
if class_mask.sum() > 0:
# 클래스 c의 의사 레이블 중 임계값을 넘는 비율
self.classwise_acc[c] = (
(mask & class_mask).float().sum() /
class_mask.float().sum()
)
def get_threshold(self):
"""클래스별 적응형 임계값 반환"""
max_acc = self.classwise_acc.max()
if max_acc > 0:
# 정규화: 가장 잘 학습된 클래스 기준으로 상대적 비율
beta = self.classwise_acc / max_acc
else:
beta = torch.ones(self.num_classes)
# 적응형 임계값 = beta * 고정 임계값
adaptive_tau = beta * self.tau
return adaptive_tau # (num_classes,)
def apply_mask(self, probs, pseudo_labels):
"""적응형 임계값으로 마스크 생성"""
max_probs, _ = probs.max(dim=-1)
adaptive_tau = self.get_threshold()
# 각 샘플의 의사 레이블 클래스에 해당하는 임계값 적용
thresholds = adaptive_tau[pseudo_labels]
mask = max_probs.ge(thresholds).float()
return mask
USB (Unified SSL Benchmark) 사용 예시
# USB: 다양한 SSL 알고리즘을 통합한 벤치마크
# pip install semilearn
from semilearn import get_algorithm, get_config, get_dataset, Trainer
# 설정
config = get_config({
'algorithm': 'fixmatch', # fixmatch, flexmatch, freematch, softmatch 등
'dataset': 'cifar10',
'num_labels': 40, # 레이블 수
'net': 'wrn_28_2', # Wide ResNet-28-2
'batch_size': 64,
'uratio': 7, # 비레이블 배치 비율
'num_train_iter': 1048576, # 2^20
'hard_label': True, # Hard pseudo-label 사용
'T': 0.5, # Sharpening temperature
'p_cutoff': 0.95, # 신뢰도 임계값
})
# 데이터셋 준비
dataset = get_dataset(config)
# 알고리즘 초기화
algorithm = get_algorithm(config, dataset)
# 학습
trainer = Trainer(config, algorithm)
trainer.fit()
# 평가
trainer.evaluate()
scikit-learn Label Propagation 예시
import numpy as np
from sklearn.semi_supervised import LabelPropagation, LabelSpreading
from sklearn.datasets import make_moons
from sklearn.metrics import accuracy_score
# 데이터 생성
X, y_true = make_moons(n_samples=1000, noise=0.1, random_state=42)
# 90%를 비레이블로 설정 (레이블 = -1)
rng = np.random.RandomState(42)
mask = rng.rand(len(y_true)) < 0.9
y_partial = y_true.copy()
y_partial[mask] = -1 # -1 = 비레이블
print(f"레이블 데이터: {(~mask).sum()}, 비레이블 데이터: {mask.sum()}")
# Label Propagation
lp = LabelPropagation(kernel='rbf', gamma=20, max_iter=1000)
lp.fit(X, y_partial)
y_pred_lp = lp.predict(X)
print(f"Label Propagation 정확도: {accuracy_score(y_true, y_pred_lp):.4f}")
# Label Spreading (더 부드러운 확산, 노이즈에 강건)
ls = LabelSpreading(kernel='rbf', gamma=20, alpha=0.2, max_iter=100)
ls.fit(X, y_partial)
y_pred_ls = ls.predict(X)
print(f"Label Spreading 정확도: {accuracy_score(y_true, y_pred_ls):.4f}")
주요 라이브러리 및 도구
| 라이브러리 |
설명 |
알고리즘 |
| USB (semilearn) |
NeurIPS 2022 벤치마크, 14+ SSL 알고리즘 통합 |
FixMatch, FlexMatch, FreeMatch, SoftMatch 등 |
| TorchSSL |
USB의 전신, PyTorch 기반 SSL 프레임워크 |
FixMatch, FlexMatch, SimMatch |
| scikit-learn |
Label Propagation/Spreading 제공 |
Graph-based SSL |
| semi-supervised-pytorch |
교육용 구현 |
Ladder Network, VAT, Pi-Model |
| OpenMatch |
Open-set SSL |
ORCA, OpenMatch |
최근 동향 (2024-2025)
1. Foundation Model + SSL
- CLIP, DINOv2 등 대규모 사전학습 모델의 표현을 SSL에 활용
- Semi-supervised fine-tuning: FM 위에 소량 레이블로 적응
- 기존 SSL 기법 대비 데이터 효율이 크게 향상
2. Open-World SSL
- 비레이블 데이터에 새로운 클래스가 포함된 현실적 시나리오
- Novel Class Discovery (NCD)와 SSL의 통합
- IOMatch (ICLR 2024): ID/OOD를 동시에 다루는 프레임워크
3. Federated SSL
- 분산 환경에서의 SSL: 각 클라이언트가 소량 레이블 보유
- (FL)2 (NeurIPS 2024): Federated Semi-Supervised Learning 확장
- 프라이버시 보존 + 레이블 효율성 동시 달성
4. NLP/Multimodal SSL
- ST (Self-Training) + LLM pseudo-labeling
- 멀티모달 데이터에서의 cross-modal SSL
- Instruction tuning과 SSL의 결합
5. 이론적 발전
- SSL의 수렴 보장 및 일반화 바운드 연구
- Confirmation bias의 정량적 분석
- 가정 위반 시의 성능 저하 메커니즘 규명
참고 문헌
| 논문 |
저자 |
학회 |
연도 |
| Semi-Supervised Learning Literature Survey |
Zhu |
- |
2005 |
| Pseudo-Label |
Lee |
ICML Workshop |
2013 |
| Temporal Ensembling / Pi-Model |
Laine, Aila |
ICLR |
2017 |
| Mean Teacher |
Tarvainen, Valpola |
NeurIPS |
2017 |
| VAT |
Miyato et al. |
IEEE TPAMI |
2018 |
| MixMatch |
Berthelot et al. |
NeurIPS |
2019 |
| ReMixMatch |
Berthelot et al. |
ICLR |
2020 |
| UDA |
Xie et al. |
NeurIPS |
2020 |
| FixMatch |
Sohn et al. |
NeurIPS |
2020 |
| FlexMatch |
Zhang et al. |
NeurIPS |
2021 |
| USB (Unified SSL Benchmark) |
Wang et al. |
NeurIPS Datasets |
2022 |
| SimMatch |
Zheng et al. |
CVPR |
2022 |
| FreeMatch |
Wang et al. |
ICLR |
2023 |
| SoftMatch |
Chen et al. |
ICLR |
2023 |