{/* Trang này được tạo tự động từ SKILL.md của kỹ năng bởi website/scripts/generate-skill-docs.py. Chỉnh sửa nguồn SKILL.md, không phải trang này. */}

Giám tuyển Nemo

Quản lý dữ liệu được tăng tốc GPU cho đào tạo LLM. Hỗ trợ văn bản/hình ảnh/video/âm thanh. Tính năng chống trùng lặp mờ (nhanh hơn 16 lần), lọc chất lượng (hơn 30 phương pháp phỏng đoán), trùng lặp ngữ nghĩa, xử lý PII, phát hiện NSFW. Mở rộng quy mô trên các GPU bằng RAPIDS. Sử dụng để chuẩn bị các tập dữ liệu đào tạo chất lượng cao, làm sạch dữ liệu web hoặc loại bỏ trùng lặp tập hợp lớn.

Siêu dữ liệu kỹ năng

Nguồn	Tùy chọn — cài đặt với
`Hermes skills install official/mlops/nemo-curator
`
Đường dẫn

optional-skills/mlops/nemo-curator ` | | Phiên bản |

1.0.0 ` | | Tác giả | Nghiên cứu dàn nhạc | | Giấy phép | MIT | | Phụ thuộc |

nemo-curator

, `cudf

, `dask

, rAPIds | | Nền tảng | Linux, macOS | | Thẻ |

Data Processing

, `NeMo Curator

, `Data Curation

, `GPU Acceleration

, `Deduplication

, `Quality Filtering

, `NVIDIA

, `RAPIDS

, `PII Redaction

, `Multimodal

, LLM Training Data |

Tham khảo: đầy đủ SKILL.md

thông tin

Sau đây là định nghĩa kỹ năng đầy đủ mà Hermes tải khi kỹ năng này được kích hoạt. Đây là những gì tác nhân coi là hướng dẫn khi kỹ năng được kích hoạt.

NeMo Curator - Quản lý dữ liệu được tăng tốc GPU

Bộ công cụ của NVIDIA để chuẩn bị dữ liệu đào tạo chất lượng cao cho LLM.

Khi nào nên sử dụng NeMo Curator`Sử dụng NeMo Curator khi:

• Chuẩn bị dữ liệu đào tạo LLM từ các mẩu tin lưu niệm trên web (Thu thập thông tin chung)
• Cần chống trùng lặp nhanh (nhanh hơn 16 lần so với CPU)
• Quản lý bộ dữ liệu đa phương thức (văn bản, hình ảnh, video, âm thanh)
• Lọc nội dung chất lượng thấp hoặc độc hại
• Mở rộng xử lý dữ liệu trên cụm GPU`Hiệu suất:
• Nhanh hơn 16× tính năng chống trùng lặp mờ (8TB RedPajama v2)
• TCO thấp hơn 40% so với các lựa chọn thay thế CPU
• Chia tỷ lệ gần tuyến tính trên các nút GPU`Thay vào đó hãy sử dụng các lựa chọn thay thế:
• datatrove: Xử lý dữ liệu nguồn mở, dựa trên CPU
• dolma: Bộ công cụ dữ liệu của Allen AI
• Dữ liệu Ray: Xử lý dữ liệu ML chung (không tập trung vào giám tuyển)

Bắt đầu nhanh

Cài đặt

# Text curation (CUDA 12)
uv pip install "nemo-curator[text_cuda12]"

# All modalities
uv pip install "nemo-curator[all_cuda12]"

# CPU-only (slower)
uv pip install "nemo-curator[cpu]"

`

### Quy trình quản lý văn bản cơ bản

``` python
from nemo_curator import ScoreFilter, Modify
from nemo_curator.datasets import DocumentDataset
 import pandas as pd

# Load data
df = pd.DataFrame(\{"text": ["Good document", "Bad doc", "Excellent text"]})
dataset = DocumentDataset(df)

# Quality filtering
def quality_score(doc):
    return len(doc["text"].split()) > 5  # Filter short docs`filtered = ScoreFilter(quality_score)(dataset)

# Deduplication
from nemo_curator.modules import ExactDuplicates
deduped = ExactDuplicates()(filtered)

# Save
deduped.to_parquet("curated_data/")

`

## Đường dẫn quản lý dữ liệu

### Giai đoạn 1: Lọc chất lượng

`Python
from nemo_curator.filters import (
    WordCountFilter,
    RepeatedLinesFilter,
    UrlRatioFilter,
    NonAlphaNumericFilter
)

# Apply 30+ heuristic filters
from nemo_curator import ScoreFilter

# Word count filter
dataset = dataset.filter(WordCountFilter(min_words=50, max_words=100000))

# Remove repetitive content
dataset = dataset.filter(RepeatedLinesFilter(max_repeated_line_fraction=0.3))

# URL ratio filter
dataset = dataset.filter(UrlRatioFilter(max_url_ratio=0.2))

`

### Giai đoạn 2: Chống trùng lặp`**Loại bỏ trùng lặp chính xác**:

`
`Python
from nemo_curator.modules import ExactDuplicates

# Remove exact duplicates
deduped = ExactDuplicates(id_field="id", text_field="text")(dataset)

`
``**Loại bỏ trùng lặp mờ** (nhanh hơn 16 lần trên GPU):

`
`Python
from nemo_curator.modules import FuzzyDuplicates

# MinHash + LSH deduplication
fuzzy_dedup = FuzzyDuplicates(
    id_field="id",
    text_field="text",
    num_hashes=260,      # MinHash parameters
    num_buckets=20,
    hash_method="md5"
)

deduped = fuzzy_dedup(dataset)

`
``**Trùng lặp ngữ nghĩa**:

`
`Python
from nemo_curator.modules import SemanticDuplicates

# Embedding-based deduplication
semantic_dedup = SemanticDuplicates(
    id_field="id",
    text_field="text",
    embedding_model="sentence-transformers/all-MiniLM-L6-v2",
    threshold=0.8  # Cosine similarity threshold
)

deduped = semantic_dedup(dataset)

`

### Giai đoạn 3: Biên tập PII

`Python
from nemo_curator.modules import Modify
from nemo_curator.modifiers import PIIRedactor

# Redact personally identifiable information
pii_redactor = PIIRedactor(
    supported_entities=["EMAIL_ADDRESS", "PHONE_NUMBER", "PERSON", "LOCATION"],
    anonymize_action="replace"  # or "redact"
)

redacted = Modify(pii_redactor)(dataset)

`

### Giai đoạn 4: Lọc phân loại

`Python
from nemo_curator.classifiers import QualityClassifier

# Quality classification
quality_clf = QualityClassifier(
    model_path="nvidia/quality-classifier-deberta",
    batch_size=256,
    device="cuda"
)

# Filter low-quality documents
high_quality = dataset.filter(lambda doc: quality_clf(doc["text"]) > 0.5)

`

## Tăng tốc GPU

### Hiệu năng GPU và CPU

| Hoạt động | CPU (16 lõi) | GPU (A100) | Tăng tốc |
|----------|-------|-------------|--------|
| Khấu trừ mờ (8TB) | 120 giờ | 7,5 giờ | 16× |
| Khấu trừ chính xác (1TB) | 8 giờ | 0,5 giờ | 16× |
| Lọc chất lượng | 2 giờ | 0,2 giờ | 10× |

### Chia tỷ lệ đa GPU

`Python
from nemo_curator import get_CLIent
 import dask_cuda

# Initialize GPU cluster
CLIent = get_CLIent(cluster_type="gpu", n_workers=8)

# Process with 8 GPUs
deduped = FuzzyDuplicates(...)(dataset)

`

## Giám tuyển đa phương thức`###Sắp xếp hình ảnh

`Python
from nemo_curator.image import (
    AestheticFilter,
    NSFWFilter,
    CLIPEmbedder
)

# Aesthetic scoring
aesthetic_filter = AestheticFilter(threshold=5.0)
filtered_images = aesthetic_filter(image_dataset)

# NSFW detection
nsfw_filter = NSFWFilter(threshold=0.9)
safe_images = nsfw_filter(filtered_images)

# Generate CLIP embeddings
CLIp_embedder = CLIPEmbedder(model="OpenAI/CLIp-vit-base-patch32")
image_embeddings = CLIp_embedder(safe_images)

`

### Biên tập video

`Python
from nemo_curator.video import (
    SceneDetector,
    CLIpExtractor,
    InternVideo2Embedder
)

# Detect scenes
scene_detector = SceneDetector(threshold=27.0)
scenes = scene_detector(video_dataset)

# Extract CLIps
CLIp_extractor = CLIpExtractor(min_duration=2.0, max_duration=10.0)
CLIps = CLIp_extractor(scenes)

# Generate embeddings
video_embedder = InternVideo2Embedder()
video_embeddings = video_embedder(CLIps)

`

### Giám tuyển âm thanh

`Python
from nemo_curator.audio import (
    ASRInference,
    WERFilter,
    DurationFilter
)

# ASR transcription
asr = ASRInference(model="nvidia/stt_en_fastconformer_hybrid_large_pc")
transcribed = asr(audio_dataset)

# Filter by WER (word error rate)
wer_filter = WERFilter(max_wer=0.3)
high_quality_audio = wer_filter(transcribed)

# Duration filtering
duration_filter = DurationFilter(min_duration=1.0, max_duration=30.0)
filtered_audio = duration_filter(high_quality_audio)

`

## Các mẫu phổ biến

### Quản lý web Scrap (Thu thập thông tin chung)

`Python
from nemo_curator import ScoreFilter, Modify
from nemo_curator.filters import *
from nemo_curator.modules import *
from nemo_curator.datasets import DocumentDataset

# Load Common Crawl data
dataset = DocumentDataset.read_parquet("common_crawl/*.parquet")

# pipeline
pipeline = [

    # 1. Quality filtering
    WordCountFilter(min_words=100, max_words=50000),
    RepeatedLinesFilter(max_repeated_line_fraction=0.2),
    SymbolToWordRatioFilter(max_symbol_to_word_ratio=0.3),
    UrlRatioFilter(max_url_ratio=0.3),

# 2. Language filtering
    LanguageIdentificationFilter(target_languages=["en"]),

# 3. Deduplication
    ExactDuplicates(id_field="id", text_field="text"),
    FuzzyDuplicates(id_field="id", text_field="text", num_hashes=260),

# 4. PII redaction
    PIIRedactor(),

# 5. NSFW filtering
    NSFWClassifier(threshold=0.8)
]

# Execute
for stage in pipeline:
    dataset = stage(dataset)

# Save
dataset.to_parquet("curated_common_crawl/")

`

### Xử lý phân tán

``` python
from nemo_curator import get_CLIent
from dask_cuda import LocalCUDACluster

# Multi-GPU cluster
cluster = LocalCUDACluster(n_workers=8)
CLIent = get_CLIent(cluster=cluster)

# Process large dataset
dataset = DocumentDataset.read_parquet("s3://large_dataset/*.parquet")
deduped = FuzzyDuplicates(...)(dataset)

# Cleanup
CLIent.close()
cluster.close()

`

## Điểm chuẩn hiệu suất

### Chống trùng lặp mờ (8TB RedPajama v2)
- **CPU (256 lõi)**: 120 giờ

- **GPU (8× A100)**: 7,5 giờ
- **Tăng tốc**: 16×

### Chống trùng lặp chính xác (1TB)
- **CPU (64 lõi)**: 8 giờ
- **GPU (4× A100)**: 0,5 giờ
- **Tăng tốc**: 16×

### Lọc chất lượng (100GB)
- **CPU (32 lõi)**: 2 giờ
- **GPU (2× A100)**: 0,2 giờ
- **Tăng tốc**: 10×

## So sánh chi phí`**Sắp xếp dựa trên CPU** (AWS c5.18xlarge × 10):
- Chi phí: 3,60$/giờ × 10 = 36$/giờ
- Thời gian cho 8TB: 120 giờ
- **Tổng cộng**: $4.320`**Sắp xếp dựa trên GPU** (AWS p4d.24xlarge × 2):
- Chi phí: 32,77 USD/giờ × 2 = 65,54 USD/giờ
- Thời gian cho 8TB: 7,5 giờ
- **Tổng cộng**: $491,55`**Tiết kiệm**: Giảm 89% ($3,828 tiết kiệm)

## Các định dạng dữ liệu được hỗ trợ
- **Đầu vào**: Sàn gỗ, JSONL, CSV
- **Đầu ra**: Sàn gỗ (được khuyến nghị), JSONL
- **WebDataset**: Lưu trữ TAR cho đa phương thức

## Các trường hợp sử dụng`**Triển khai sản xuất**:
- NVIDIA sử dụng NeMo Curator để chuẩn bị dữ liệu huấn luyện Nemotron-4
- Bộ dữ liệu nguồn mở được quản lý: RedPajama v2, The Pile

## Tài liệu tham khảo
- **[Filtering Guide](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/nemo-curator/references/filtering.md)** - Hơn 30 bộ lọc chất lượng, chẩn đoán
- **[Deduplication Guide](https://GitHub.com/NousResearch/Hermes-agent/blob/main/optional-skills/mlops/nemo-curator/references/deduplication.md)** - Phương pháp chính xác, mờ, ngữ nghĩa

## Tài nguyên- **GitHub**: https://GitHub.com/NVIDIA/NeMo-Curator ⭐ 500+
- **Tài liệu**: https://docs.nvidia.com/nemo-framework/user-guide/latest/datacuration/
- **Phiên bản**: 0.4.0+
- **Giấy phép**: Apache 2.0