NVIDIA Nemotron-Pretraining-Code-v3 — индекс метаданных файлов из GitHub, добавленных к предыдущим версиям корпуса. В этом примере из индекса берут выборку для анализа. Вместо скачивания всего набора объёмом в несколько гигабайт мы загружаем его потоком, изучаем схему и формируем выборку для анализа. Затем рассматриваем языки программирования, расширения файлов, частоту упоминания репозиториев и глубину вложенности каталогов. После этого восстанавливаем исходные URL GitHub по метаданным, пытаемся получить файлы кода и оцениваем количество токенов. В итоге сохраняем отфильтрованную выборку и обработанные данные для дальнейших экспериментов.
Потоковая загрузка набора и изучение его схемы
!pip -q install -U "datasets>=2.19" huggingface_hub tiktoken pyarrow 2>/dev/null
import os, io, time, itertools, collections, textwrap, math
import pandas as pd
import requests
import matplotlib.pyplot as plt
from datasets import load_dataset, get_dataset_config_names
REPO_ID = "nvidia/Nemotron-Pretraining-Code-v3"
pd.set_option("display.max_colwidth", 80)
configs = get_dataset_config_names(REPO_ID)
CONFIG = configs[0]
print(f"Configs available : {configs}")
print(f"Using config : {CONFIG}")
stream = load_dataset(REPO_ID, CONFIG, split="train", streaming=True)
print("\nFeatures / schema:")
print(stream.features)
print("\nFirst raw record:")
print(next(iter(stream)))
Сначала подготовим среду Google Colab: установим необходимые библиотеки и импортируем инструменты для загрузки, анализа и визуализации данных. Укажем идентификатор набора NVIDIA Nemotron-Pretraining-Code-v3, получим список доступных конфигураций и загрузим обучающую часть в потоковом режиме. Перед дальнейшим анализом изучим схему данных и выведем первую запись.
Формирование перемешанной выборки и анализ метаданных
N_SAMPLE = 30_000
shuffled = stream.shuffle(seed=42, buffer_size=20_000)
t0 = time.time()
rows = list(itertools.islice(shuffled, N_SAMPLE))
df = pd.DataFrame(rows)
print(f"\nPulled {len(df):,} rows in {time.time()-t0:,.1f}s")
print(df.head(10))
print("\nColumns:", list(df.columns), "| memory:",
f"{df.memory_usage(deep=True).sum()/1e6:,.1f} MB")
df["ext"] = df["rel_path"].str.extract(r"\.([A-Za-z0-9_]+)$")[0].str.lower()
df["depth"] = df["rel_path"].str.count("/")
df["fname"] = df["rel_path"].str.rsplit("/", n=1).str[-1]
print("\n--- Top 15 languages (sample) ---")
lang_counts = df["language"].value_counts()
print(lang_counts.head(15))
print("\n--- Top 15 file extensions (sample) ---")
print(df["ext"].value_counts().head(15))
print("\n--- Most frequent repositories (sample) ---")
print(df["repo"].value_counts().head(10))
print("\n--- Path-depth summary ---")
print(df["depth"].describe())
print(f"\nUnique repos in sample : {df['repo'].nunique():,}")
print(f"Unique languages : {df['language'].nunique():,}")
Перемешаем поток данных и возьмём выборку, чтобы анализ не ограничивался сгруппированными начальными записями. Преобразуем записи в таблицу Pandas и создадим дополнительные признаки: расширение файла, глубину пути и имя файла. Затем посмотрим, какие языки, расширения и репозитории встречаются чаще всего, и изучим статистику глубины путей.
Визуализация языков, расширений, глубины каталогов и частоты репозиториев
fig, ax = plt.subplots(2, 2, figsize=(14, 9))
lang_counts.head(12).iloc[::-1].plot.barh(ax=ax[0, 0], color="#76b900")
ax[0, 0].set_title("Top 12 languages (sample)"); ax[0, 0].set_xlabel("files")
df["ext"].value_counts().head(12).iloc[::-1].plot.barh(ax=ax[0, 1], color="#5b8def")
ax[0, 1].set_title("Top 12 file extensions (sample)"); ax[0, 1].set_xlabel("files")
df["depth"].clip(upper=12).plot.hist(bins=range(0, 14), ax=ax[1, 0],
color="#f4a261", edgecolor="white")
ax[1, 0].set_title("Directory nesting depth"); ax[1, 0].set_xlabel("'/' count in path")
(df["repo"].value_counts().head(10).iloc[::-1]
.plot.barh(ax=ax[1, 1], color="#9b5de5"))
ax[1, 1].set_title("Most common repos (sample)"); ax[1, 1].set_xlabel("files")
plt.tight_layout(); plt.show()
Построим графики основных закономерностей в выборке: распределения языков и расширений файлов, глубины вложенности каталогов и наиболее часто встречающихся репозиториев. Визуализация помогает быстрее разобраться в структуре индекса метаданных.
Восстановление URL GitHub и загрузка исходных файлов
def raw_url(repo: str, commit_id: str, rel_path: str) -> str:
from urllib.parse import quote
return (f"https://raw.githubusercontent.com/{repo}/{commit_id}/"
f"{quote(rel_path)}")
df["raw_url"] = df.apply(lambda r: raw_url(r.repo, r.commit_id, r.rel_path), axis=1)
print("\nExample reconstructed URLs:")
for u in df["raw_url"].head(5):
print(" ", u)
def fetch_code(url: str, max_bytes: int = 200_000, timeout: int = 10):
try:
with requests.get(url, timeout=timeout, stream=True) as resp:
if resp.status_code != 200:
return None
data = bytearray()
for chunk in resp.iter_content(chunk_size=8192):
if len(data) + len(chunk) > max_bytes:
return None
data.extend(chunk)
return data.decode(resp.encoding or "utf-8", errors="replace")
return None
except requests.RequestException:
return None
print("\n--- Attempting to fetch a few real files ---")
fetched, attempts = [], 0
for _, r in df.sample(n=min(30, len(df)), random_state=1).iterrows():
if len(fetched) >= 5:
break
attempts += 1
code = fetch_code(r["raw_url"])
status = "OK " if code else "MISS"
print(f"[{status}] {r['language']:<12} {r['repo']}/{r['rel_path']}")
if code:
fetched.append({**r.to_dict(), "code": code, "n_chars": len(code)})
print(f"\nFetched {len(fetched)} files in {attempts} attempts "
f"(misses are normal — repos get deleted/renamed).")
if fetched:
ex = fetched[0]
print(f"\n----- PREVIEW: {ex['repo']}/{ex['rel_path']} ({ex['language']}) -----")
print(textwrap.shorten(ex["code"].replace("\n", " "), width=600,
placeholder=" ...[truncated]"))
Восстановим исходные URL GitHub из названия репозитория, идентификатора коммита и относительного пути к файлу. Затем попробуем загрузить несколько исходных файлов. Пример делает не более 30 попыток и читает не более 200 000 байт на файл. Успешных загрузок может быть меньше пяти. Если файлы найдутся, выведем фрагмент одного из них, чтобы увидеть, как метаданные связаны с исходным кодом.
Фильтрация файлов Python, оценка токенов и сохранение результатов
TARGET_LANG = "Python"
py_index = df[df["language"] == TARGET_LANG].copy()
print(f"\n{TARGET_LANG} files in sample: {len(py_index):,}")
try:
import tiktoken
enc = tiktoken.get_encoding("cl100k_base")
tok = lambda s: len(enc.encode(s, disallowed_special=()))
except Exception:
tok = lambda s: max(1, len(s) // 4)
if fetched:
toks = [tok(f["code"]) for f in fetched]
print(f"Fetched-file tokens: total={sum(toks):,} "
f"mean={sum(toks)/len(toks):,.0f}/file")
TOTAL_FILES, TOTAL_TOKENS = 146_323_609, 173e9
print(f"\nFull-dataset scale (per NVIDIA card): "
f"{TOTAL_FILES:,} files ≈ {TOTAL_TOKENS/1e9:.0f}B tokens "
f"(~{TOTAL_TOKENS/TOTAL_FILES:,.0f} tokens/file).")
df.to_parquet("nemotron_code_v3_sample.parquet", index=False)
if fetched:
pd.DataFrame(fetched).to_json("nemotron_fetched_code.jsonl",
orient="records", lines=True)
print("\nSaved: nemotron_code_v3_sample.parquet"
+ (", nemotron_fetched_code.jsonl" if fetched else ""))
print("Done ✅")
Отберём из выборки файлы на Python и оценим количество токенов в успешно загруженных файлах. Если доступна библиотека tiktoken, используем её; в противном случае применим приблизительную оценку по числу символов. Масштаб всего набора в коде указан как 146 323 609 файлов и примерно 173 млрд токенов, или около 1 183 токенов на файл. Сохраним выборку метаданных в формате Parquet, а загруженные файлы кода — в JSONL.
Итоги
Пример показывает, как загрузить выборку индекса, изучить её в Pandas и восстановить ссылки GitHub по репозиторию, пути и коммиту. Количество полученных файлов и оценка токенов зависят от доступности репозиториев и выбранного токенизатора. Обработанные результаты можно сохранить и использовать в дальнейших экспериментах.
