LabHub

Blog

Scale AI and the World of Data Labeling: Complete Guide to AI Training Data Industry and Careers

2026-03-23 · 20 min read · #scale-ai#data-labeling#annotation#rlhf#ai-training-data#career#data-quality#ai-infrastructure#2026-03

한국어English日本語

Introduction

"Data is the new oil." This statement has become increasingly true in the AI era. The performance differences between cutting-edge AI models like GPT-4, Claude, and Gemini ultimately come down to training data quality. No matter how sophisticated the algorithm, it is useless without high-quality data.

At the center of this massive data industry stands Scale AI. Founded in 2016 by Alexandr Wang, who dropped out of MIT at age 19, Scale AI has reached a valuation of $14 billion as of 2024, making Wang a billionaire at 26.

This guide provides a comprehensive view of the AI training data industry. We cover everything from data labeling types and RLHF pipelines, platform comparisons, quality management, auto-labeling and synthetic data, to career paths in this field.

1. AI Training Data Industry Overview

Market Size and Growth

The AI data labeling market is experiencing explosive growth.

YearMarket SizeNotes
2023$2.2BGrand View Research estimate
2025$3.7BCurrent market
2028$8.7BMid-range forecast
2030$17B+CAGR ~35%

The key drivers fueling this growth include:

Scale AI: The Industry Leader

Here is an overview of Scale AI's core business areas:

Scale AI Business Structure
├── Data Engine (Core Business)
│   ├── Image/Video Labeling (Autonomous Driving, Robotics)
│   ├── Text Labeling (NLP, LLM)
│   ├── 3D Point Cloud (LiDAR)
│   └── RLHF Data (LLM Alignment)
├── Government
│   ├── US Department of Defense Contracts
│   ├── Satellite Image Analysis
│   └── Intelligence Analysis Support
├── Generative AI Platform
│   ├── LLM Evaluation (Model Evaluation)
│   ├── Fine-tuning Data
│   └── Safety Data (Toxicity Classification)
└── Enterprise Solutions
    ├── Custom Pipelines
    ├── Quality Management Tools
    └── Analytics Dashboards

Key Clients: US Department of Defense (DoD), OpenAI, Meta, Microsoft, Toyota, General Motors, Samsung

Key Metrics (2024-2025):

2. Complete Guide to Data Labeling Types

2-1. Image Labeling

Image labeling is the foundation of computer vision AI.

Bounding Box

The most basic labeling type. Objects are enclosed in rectangles to mark their location.

{
  "label": "car",
  "bbox": {
    "x_min": 120,
    "y_min": 80,
    "x_max": 350,
    "y_max": 240
  },
  "confidence": 0.95
}

Segmentation

Pixel-level precise labeling. There are three types:

# Panoptic Segmentation label example
panoptic_label = {
    "segments": [
        {"id": 1, "category": "road", "is_thing": False},      # stuff (background)
        {"id": 2, "category": "sky", "is_thing": False},        # stuff
        {"id": 3, "category": "car", "is_thing": True, "instance_id": 1},  # thing
        {"id": 4, "category": "car", "is_thing": True, "instance_id": 2},  # thing
        {"id": 5, "category": "person", "is_thing": True, "instance_id": 1}
    ]
}

Keypoint

Marks key points such as human joints or facial landmarks. Essential for Pose Estimation.

Polygon

An intermediate form that is more precise than bounding boxes but more efficient than segmentation. Suitable for irregularly shaped objects.

2-2. Text Labeling

NER (Named Entity Recognition): Identifies named entities in text.

"[Apple:ORG] CEO [Tim Cook:PERSON] announced a new product
 in [Cupertino:LOC]."

Sentiment Analysis: Positive/Negative/Neutral sentiment classification

Intent Classification: Classifying user intent (order, inquiry, complaint, refund, etc.)

Text Summarization: Writing summaries and evaluating quality

2-3. Audio Labeling

2-4. Video Labeling

2-5. 3D Data Labeling

LiDAR point cloud labeling is critical for autonomous driving.

# 3D Bounding Box label
lidar_annotation = {
    "label": "vehicle",
    "center": {"x": 15.2, "y": -3.4, "z": 0.8},
    "dimensions": {"length": 4.5, "width": 1.8, "height": 1.5},
    "rotation": {"yaw": 0.35, "pitch": 0.0, "roll": 0.0},
    "num_points": 342,
    "tracking_id": "veh_0042",
    "attributes": {
        "vehicle_type": "sedan",
        "occlusion": "partial",
        "truncation": 0.0
    }
}

3D labeling costs 5-10x more than 2D, but demand is steadily increasing because it is critical for autonomous driving safety.

2-6. RLHF Data

This is the core data for LLM Alignment.

Comparison: Selecting the better response between two AI outputs

Prompt: "Explain quantum mechanics to an elementary school student"

Response A: "Quantum mechanics is about the rules of a very tiny world..."
Response B: "Quantum mechanics deals with particles smaller than atoms..."

Evaluation: A > B (Reason: Uses simpler analogies, age-appropriate vocabulary)

Rating: Scoring on a 1-5 or 1-7 scale

Ranking: Ranking 3 or more responses

Correction: Directly editing AI responses to create "ideal responses"

3. Deep Dive into RLHF Data Pipeline

Overall Flow

RLHF (Reinforcement Learning from Human Feedback) is the key technology for aligning LLMs with human preferences.

RLHF Pipeline: 5 Steps
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Step 1: Prompt Collection
  └─ Ensure diversity (topic, difficulty, language, culture)
  └─ Include safety test prompts
  └─ Include red-teaming prompts

Step 2: AI Response Generation
  └─ Generate multiple responses per prompt (typically 2-4)
  └─ Use different temperature/sampling settings
  └─ Can use different model versions

Step 3: Human Evaluation
  └─ Comparison: Choose A vs B
  └─ Rating: Score helpfulness, accuracy, safety separately
  └─ Correction: Edit directly to create "gold responses"

Step 4: Reward Model Training
  └─ Train reward function on human preference data
  └─ Based on Bradley-Terry model

Step 5: Policy Optimization
  └─ PPO (Proximal Policy Optimization) or
  └─ DPO (Direct Preference Optimization)

Labeler Qualifications and Training

RLHF labeling is not simple work. Here are the requirements from Scale AI and major companies:

Basic Requirements:

Domain Expert Labelers:

Training Process:

  1. Study guidelines (50-100 pages)
  2. Pass qualification exam (85%+ accuracy)
  3. Trial labeling + feedback (1-2 weeks)
  4. Regular retraining and calibration

Cultural Bias Management

Cultural bias management is essential for global AI services:

4. Data Labeling Platform Comparison

Major Platform Overview

PlatformFeaturesPrice RangeKey Clients/Use Cases
Scale AIEnterprise-grade, defense/autonomous drivingPremiumDoD, OpenAI, Meta
LabelboxCollaboration-focused, auto-labelingMid-HighStartups to enterprises
Snorkel AIProgrammatic labelingMid-HighData science teams
Label StudioOpen sourceFree/PaidSmall teams, research
SageMaker GTAWS integrationPay-per-useAWS-based companies
V7 LabsMedical image specialtyMidHealthcare/biotech
ProdigyNLP specialty (spaCy)$490 licenseNLP researchers/teams

Scale AI in Detail

Scale AI Differentiators
━━━━━━━━━━━━━━━━━━━━━━━━

Strengths:
  + Largest network of skilled labelers
  + Government/defense security certification (FedRAMP)
  + Industry-best 3D point cloud labeling
  + Proven RLHF data pipeline
  + Automated quality management system

Weaknesses:
  - High pricing (burdensome for small teams)
  - Minimum contract size requirements
  - Limited self-service options
  - Customization takes time

Labelbox in Detail

Labelbox is a collaboration-focused platform where data science teams can directly manage labeling workflows.

# Labelbox Python SDK example
import labelbox as lb

client = lb.Client(api_key="YOUR_API_KEY")
project = client.create_project(name="Object Detection v2")

# Connect dataset
dataset = client.create_dataset(name="street_images_2025")

# Define ontology (label schema)
ontology_builder = lb.OntologyBuilder(
    tools=[
        lb.Tool(tool=lb.Tool.Type.BBOX, name="Vehicle"),
        lb.Tool(tool=lb.Tool.Type.BBOX, name="Pedestrian"),
        lb.Tool(tool=lb.Tool.Type.POLYGON, name="Road"),
        lb.Tool(tool=lb.Tool.Type.SEGMENTATION, name="Sidewalk"),
    ],
    classifications=[
        lb.Classification(
            class_type=lb.Classification.Type.RADIO,
            name="Weather",
            options=[
                lb.Option(value="sunny"),
                lb.Option(value="rainy"),
                lb.Option(value="cloudy"),
            ]
        )
    ]
)

Snorkel AI: Programmatic Labeling

Snorkel AI's core idea is to write labeling functions in code.

from snorkel.labeling import labeling_function, PandasLFApplier
from snorkel.labeling.model import LabelModel

# Define labeling functions
@labeling_function()
def lf_keyword_positive(record):
    """Return POSITIVE if positive keywords are found"""
    positive_words = ["great", "excellent", "amazing", "love"]
    if any(w in record.text.lower() for w in positive_words):
        return 1  # POSITIVE
    return -1  # ABSTAIN

@labeling_function()
def lf_keyword_negative(record):
    """Return NEGATIVE if negative keywords are found"""
    negative_words = ["terrible", "awful", "hate", "worst"]
    if any(w in record.text.lower() for w in negative_words):
        return 0  # NEGATIVE
    return -1  # ABSTAIN

@labeling_function()
def lf_short_review(record):
    """Short reviews tend to be negative"""
    if len(record.text.split()) < 5:
        return 0  # NEGATIVE
    return -1  # ABSTAIN

# Combine noisy labels with Label Model
applier = PandasLFApplier(lfs=[
    lf_keyword_positive,
    lf_keyword_negative,
    lf_short_review
])
L_train = applier.apply(df_train)

label_model = LabelModel(cardinality=2, verbose=True)
label_model.fit(L_train, n_epochs=500, seed=42)
predictions = label_model.predict(L_train)

Label Studio: The Power of Open Source

# Installation and launch
pip install label-studio
label-studio start

# Run with Docker
docker run -it -p 8080:8080 \
  -v label-studio-data:/label-studio/data \
  heartexlabs/label-studio:latest

Label Studio is free yet supports various data types (image, text, audio, video, time series). You can also connect an ML Backend for pre-labeling (automated pre-annotation).

5. Data Quality Management

Golden Set

A Golden Set is validation data with confirmed ground truth labels. It is used to measure labeler accuracy in real-time.

class QualityMonitor:
    """Labeling quality monitoring system"""

    def __init__(self, golden_set_ratio=0.05):
        self.golden_set_ratio = golden_set_ratio
        self.annotator_scores = {}

    def inject_golden_items(self, task_batch, golden_items):
        """Randomly insert golden items into task batch"""
        import random
        n_golden = max(1, int(len(task_batch) * self.golden_set_ratio))
        selected_golden = random.sample(golden_items, min(n_golden, len(golden_items)))

        mixed_batch = task_batch.copy()
        for item in selected_golden:
            pos = random.randint(0, len(mixed_batch))
            mixed_batch.insert(pos, {**item, "_is_golden": True})
        return mixed_batch

    def evaluate_annotator(self, annotator_id, submissions):
        """Evaluate labeler accuracy on golden items"""
        golden_results = [s for s in submissions if s.get("_is_golden")]
        if not golden_results:
            return None

        correct = sum(
            1 for s in golden_results
            if s["submitted_label"] == s["golden_label"]
        )
        accuracy = correct / len(golden_results)
        self.annotator_scores[annotator_id] = accuracy

        if accuracy < 0.80:
            self._flag_for_retraining(annotator_id)
        return accuracy

Inter-Annotator Agreement (IAA)

Measures how consistently multiple labelers assign labels to the same data.

from sklearn.metrics import cohen_kappa_score
import numpy as np

def compute_cohens_kappa(annotator1_labels, annotator2_labels):
    """Compute Cohen's Kappa between two annotators"""
    kappa = cohen_kappa_score(annotator1_labels, annotator2_labels)
    # Interpretation:
    # < 0.20: Poor/Slight agreement
    # 0.21-0.40: Fair agreement
    # 0.41-0.60: Moderate agreement
    # 0.61-0.80: Substantial agreement
    # 0.81-1.00: Almost Perfect agreement
    return kappa

def compute_fleiss_kappa(rating_matrix):
    """Compute Fleiss' Kappa for 3+ annotators"""
    n_items, n_categories = rating_matrix.shape
    n_raters = rating_matrix.sum(axis=1)[0]

    # Agreement per item
    p_i = (np.sum(rating_matrix ** 2, axis=1) - n_raters) / (n_raters * (n_raters - 1))
    p_bar = np.mean(p_i)

    # Chance agreement
    p_j = np.sum(rating_matrix, axis=0) / (n_items * n_raters)
    p_e = np.sum(p_j ** 2)

    # Fleiss' Kappa
    kappa = (p_bar - p_e) / (1 - p_e)
    return kappa

Consensus Methods

Combining majority voting with expert arbitration:

Quality Management Workflow
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Assign same data to 3 labelers
2. All 3 agree -> Adopt that label
3. 2 agree, 1 disagrees -> Adopt majority + review dissenter
4. All 3 disagree -> Escalate to expert arbitrator
5. Repeated disagreement -> Signal to update guidelines

Anomalous Labeler Detection

class AnomalyDetector:
    """System for detecting abnormal labeling patterns"""

    def detect_speed_anomaly(self, annotator_id, task_times):
        """Detect abnormally fast labeling (suspected random clicking)"""
        median_time = np.median(task_times)
        threshold = median_time * 0.3  # Less than 30% of median is suspicious

        suspicious_count = sum(1 for t in task_times if t < threshold)
        if suspicious_count / len(task_times) > 0.2:
            return {"status": "flagged", "reason": "speed_anomaly"}
        return {"status": "ok"}

    def detect_pattern_anomaly(self, annotator_id, labels):
        """Detect repeated same-label patterns"""
        from collections import Counter
        counter = Counter(labels)
        most_common_ratio = counter.most_common(1)[0][1] / len(labels)

        if most_common_ratio > 0.85:  # Over 85% same label
            return {"status": "flagged", "reason": "pattern_anomaly"}
        return {"status": "ok"}

6. Auto-Labeling and Synthetic Data

Pre-labeling

A model performs first-pass labeling, then humans review and correct. Improves labeling efficiency by 3-5x.

class PreLabelingPipeline:
    """Pre-labeling pipeline"""

    def __init__(self, model, confidence_threshold=0.85):
        self.model = model
        self.confidence_threshold = confidence_threshold

    def pre_label(self, data_batch):
        """First-pass labeling with model, then route by confidence"""
        results = []
        for item in data_batch:
            prediction = self.model.predict(item)
            confidence = prediction["confidence"]

            if confidence >= self.confidence_threshold:
                # High confidence: auto-approve with sampling review
                results.append({
                    "item": item,
                    "label": prediction["label"],
                    "route": "auto_approve",
                    "confidence": confidence
                })
            elif confidence >= 0.5:
                # Medium confidence: human review (with pre-label reference)
                results.append({
                    "item": item,
                    "suggested_label": prediction["label"],
                    "route": "human_review",
                    "confidence": confidence
                })
            else:
                # Low confidence: human labels from scratch
                results.append({
                    "item": item,
                    "route": "human_label",
                    "confidence": confidence
                })
        return results

Active Learning

A strategy where the model selects only the most uncertain samples for labeling.

import numpy as np

class ActiveLearningSelector:
    """Active learning sample selector"""

    def uncertainty_sampling(self, model, unlabeled_pool, n_select=100):
        """Uncertainty-based sampling"""
        predictions = model.predict_proba(unlabeled_pool)
        # High entropy samples = most uncertain samples
        entropies = -np.sum(predictions * np.log(predictions + 1e-10), axis=1)
        top_indices = np.argsort(entropies)[-n_select:]
        return unlabeled_pool[top_indices]

    def diversity_sampling(self, embeddings, n_select=100):
        """Diversity-based sampling (samples far from cluster centers)"""
        from sklearn.cluster import KMeans
        kmeans = KMeans(n_clusters=n_select, random_state=42)
        kmeans.fit(embeddings)
        # Select the sample closest to each cluster center
        selected = []
        for i in range(n_select):
            cluster_mask = kmeans.labels_ == i
            cluster_points = embeddings[cluster_mask]
            distances = np.linalg.norm(
                cluster_points - kmeans.cluster_centers_[i], axis=1
            )
            selected.append(np.where(cluster_mask)[0][np.argmin(distances)])
        return selected

    def badge_sampling(self, model, unlabeled_pool, n_select=100):
        """BADGE: Combining uncertainty + diversity"""
        # Compute gradient embeddings, then select diverse samples via K-Means++
        gradients = self._compute_gradient_embeddings(model, unlabeled_pool)
        return self.diversity_sampling(gradients, n_select)

Synthetic Data

An approach where AI generates training data directly.

Image Synthetic Data:

Text Synthetic Data:

Limitations of Synthetic Data:

Data Flywheel

Data Flywheel Cycle
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  More Data ──────→ Better Model
       ↑                    │
       │                    ↓
  More Users ←──── Better Service

Key: The more this cycle spins, the higher the barrier to entry (competitive moat)

Tesla's autonomous driving is a prime example. Driving data collected from millions of vehicles improves the model, better autonomous driving attracts more customers, and more data is collected.

7. Career Opportunities

7-1. Data Annotation Specialist

Overview: A role that directly creates training data for AI models.

Required Skills:

7-2. Data Quality Manager

Overview: A role managing labeling teams and designing/operating quality standards.

Required Skills:

7-3. ML Data Engineer

Overview: An engineer who builds and automates data labeling pipelines.

# Example of an ML Data Engineer's daily work
# Automating labeling pipeline with Airflow DAG

from airflow import DAG
from airflow.operators.python import PythonOperator
from datetime import datetime, timedelta

default_args = {
    "owner": "ml-data-team",
    "retries": 2,
    "retry_delay": timedelta(minutes=5),
}

dag = DAG(
    "labeling_pipeline_v2",
    default_args=default_args,
    schedule_interval="@daily",
    start_date=datetime(2025, 1, 1),
    catchup=False,
)

def extract_raw_data(**kwargs):
    """Extract unlabeled data from S3"""
    pass

def run_pre_labeling(**kwargs):
    """Run pre-labeling with model"""
    pass

def distribute_to_annotators(**kwargs):
    """Distribute tasks to labeling platform"""
    pass

def quality_check(**kwargs):
    """Quality verification of completed labels"""
    pass

def export_training_data(**kwargs):
    """Export verified data as training dataset"""
    pass

extract = PythonOperator(task_id="extract", python_callable=extract_raw_data, dag=dag)
pre_label = PythonOperator(task_id="pre_label", python_callable=run_pre_labeling, dag=dag)
distribute = PythonOperator(task_id="distribute", python_callable=distribute_to_annotators, dag=dag)
qa = PythonOperator(task_id="quality_check", python_callable=quality_check, dag=dag)
export = PythonOperator(task_id="export", python_callable=export_training_data, dag=dag)

extract >> pre_label >> distribute >> qa >> export

Required Skills:

7-4. Annotation Platform Engineer

Overview: A software engineer who develops the labeling tools themselves.

Required Skills:

7-5. RLHF Data Specialist

Overview: An expert who evaluates LLM responses and generates Reward Model training data.

Required Skills:

Career Roadmap

Data Labeling Career Paths
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[Entry Level]
  Annotation Specialist ($15-25/hr)
  │
  ├──→ Quality Reviewer ($25-40/hr)
  │     │
  │     └──→ Data Quality Manager ($70K-$120K)
  │           │
  │           └──→ Head of Data Operations ($150K+)
  │
  ├──→ RLHF Specialist ($80K-$150K)
  │     │
  │     └──→ AI Safety Researcher ($150K-$250K)
  │
  └──→ [Technical Transition]
        │
        ├──→ ML Data Engineer ($120K-$180K)
        │     │
        │     └──→ Senior ML Engineer ($180K-$250K)
        │
        └──→ Annotation Platform Engineer ($130K-$200K)
              │
              └──→ Engineering Manager ($200K+)

8. The Data Labeling Industry in South Korea

Major Companies

CrowdWorks:

Selectstar:

Testworks:

Government Support Programs

Data Voucher Program:

AI Hub Datasets:

Characteristics of the Korean Market

9. Future Outlook

Short-Term Outlook (2025-2027)

  1. Auto-labeling Expansion: 70-80% of simple labeling expected to be automated
  2. RLHF Demand Surge: LLM competition driving increased demand for high-quality human evaluation data
  3. Domain Specialization: Rising premiums for specialized labeling in healthcare, legal, finance
  4. Multimodal Labeling: Increasing demand for text+image+audio combined data

Medium to Long-Term Outlook (2027-2030)

  1. RLAIF Transition: Acceleration of RLAIF (Reinforcement Learning from AI Feedback) where AI evaluates AI
  2. Increasing Synthetic Data Share: 30-50% of training data expected to be synthetic
  3. Regulatory Tightening: EU AI Act and similar requiring proof of data provenance/quality
  4. Competitive Landscape Shift: Scale AI vs Google (in-house labeling) vs open-source ecosystem

The Ultimate Bottleneck: Data Quality

Determinants of AI Performance (Post-2025)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Algorithm differences:   ████░░░░░░ Diminishing
Computing power:         ██████░░░░ Can be solved with money
Data quantity:           ██████████ Nearly saturated (internet data limits)
Data quality:            ██████████ <- Ultimate bottleneck, requires human labor

Conclusion: Companies that can secure high-quality data will win the AI competition

Quiz

Q1. What is the core task performed by human evaluators in RLHF?

Show Answer

Comparing multiple AI responses to select the better one (Comparison), scoring responses (Rating), or directly editing them (Correction).

This data is used to train a Reward Model, which then optimizes the LLM using PPO/DPO algorithms. The key is converting "human preferences" into numerical signals that the model can learn from.

Q2. How do you interpret a Cohen's Kappa value of 0.45 in Inter-Annotator Agreement (IAA)?

Show Answer

This indicates Moderate Agreement.

Cohen's Kappa interpretation:

  • Below 0.00: Worse than chance
  • 0.01-0.20: Poor/Slight agreement
  • 0.21-0.40: Fair agreement
  • 0.41-0.60: Moderate agreement
  • 0.61-0.80: Substantial agreement
  • 0.81-1.00: Almost Perfect agreement

A value of 0.45 suggests that labeling guidelines may need improvement or labelers may need retraining.

Q3. Why is Active Learning's Uncertainty Sampling more efficient than random sampling?

Show Answer

Because it selects only the most uncertain samples (highest entropy) for human labeling.

Random sampling includes easy samples that the model already classifies well, while Uncertainty Sampling focuses on difficult samples near the model's decision boundary. This achieves greater model performance improvement with the same labeling budget. It is typically 2-5x more efficient than random sampling.

Q4. What is the key difference between Snorkel AI's Programmatic Labeling and traditional manual labeling?

Show Answer

Instead of humans labeling individual data points one by one, "Labeling Functions" are written in code and applied to large-scale data in bulk.

Each labeling function may be noisy, but the Label Model statistically combines outputs from multiple functions to generate final labels. This approach is 10-100x faster than manual labeling, but is not suitable for tasks requiring complex judgment (such as RLHF).

Q5. Explain how Data Flywheel creates a competitive moat for companies.

Show Answer

The Data Flywheel is a virtuous cycle of "more data - better model - more users - more data".

When this cycle operates:

  1. First movers accumulate more data
  2. Better models deliver superior services
  3. More users generate more data
  4. The gap with late entrants widens over time

Tesla's autonomous driving is a prime example. Real-time driving data collected from millions of vehicles improves the model, which in turn attracts more customers and generates even more data.

References

  1. Scale AI Official Site — https://scale.com
  2. Labelbox Official Site — https://labelbox.com
  3. Snorkel AI Official Site — https://snorkel.ai
  4. Label Studio Open Source — https://labelstud.io
  5. Grand View Research, "Data Annotation Tools Market Report" (2024)
  6. Ouyang et al., "Training language models to follow instructions with human feedback" (2022) — InstructGPT paper
  7. Rafailov et al., "Direct Preference Optimization" (2023) — DPO paper
  8. Ratner et al., "Data Programming: Creating Large Training Sets, Quickly" (2016) — Original Snorkel paper
  9. Settles, "Active Learning Literature Survey" (2009) — Active Learning survey
  10. Christiano et al., "Deep reinforcement learning from human preferences" (2017) — Foundational RLHF paper
  11. Touvron et al., "LLaMA 2: Open Foundation and Fine-Tuned Chat Models" (2023) — RLHF application example
  12. Wang et al., "Self-Instruct: Aligning Language Models with Self-Generated Instructions" (2023)
  13. Xu et al., "WizardLM: Empowering Large Language Models to Follow Complex Instructions" (2023) — Evol-Instruct
  14. AI Hub Datasets — https://aihub.or.kr
  15. Korea Data Agency Data Voucher — https://www.kdata.or.kr
  16. Anthropic, "Constitutional AI: Harmlessness from AI Feedback" (2022) — RLAIF related
  17. Shumailov et al., "The Curse of Recursion: Training on Generated Data Makes Models Forget" (2023) — Model Collapse
  18. Scale AI Remote Tasks — https://remotasks.com

Comments

No comments yet.

Sign in to leave a comment