Kaggleの「RSNA Knee Abnormality Detection」で、RistのKaggle Grandmasterがチームを率いて成功を収めました。その秘訣とは。

Explore and run AI code with Kaggle Notebooks | Using data from No attached data sources

株式会社Rist株式会社Rist（本社所在地：京都市下京区 代表取締役社長：長野慶、以下Rist）は、世界最大級のデータ分析プラットフォーム「Kaggle」で開催されたコンペティション「RSNA Knee Abnormality Detection」（以下、本コンペティション）において、Rist Kaggle

著者：石原祥太郎(著), 村田秀樹(著)　出版：講談社　2020/5/26(火)配信

著者：小嵜耕平(著), 秋葉拓哉(著), 林孝紀(著), 石原祥太郎(著)　出版：講談社　2023/4/7(金)配信

Google's Kaggle contest asks entrants to cut quantum circuit costs, checked by a verifier. What developers can try without physics and what entries need.

NTT東日本は10月26日、同社のデータサイエンティストである本堂貴也氏が、Kaggleで開催されたコンペティション「Biohub - Cell Tracking During Development」において、3947チーム中7位に入賞したと発表した。本堂氏は個人で参加し、金メダルを獲得した。 続きを読む ≫

In the coming days, we will stop supporting R in Kaggle Notebooks. This post explains why and what it means for your work. Why we're doing this R has been pa...

跑《统计学习导论》(ISLP) 实验时，顺手测了一下常用免费云端算力实例与本地标压笔记本在基础机器学习负载下的性能差异。非严格学术评测，仅记录单机工程数据供参考 #### 一、 测试环境 * **OCI ARM** ：Ampere Altra 架构，4 OCPU （独立物理核），24 GB RAM ，Ubuntu 22.04 * **Lightning AI** ：Free CPU Studio （ 4 vCPU 共享容器） * **Kaggle** ：标准 CPU 实例（ 4 vCPU ）及 Tesla T4 GPU 实例 * **Local** ：AMD Ryzen 7 6800H （ 8 核 16 线程）+ RTX 3050 Laptop (4GB VRAM) * * * #### 二、 基准测试数据 ##### 1. scikit-learn：随机森林分类（ CPU ） * **数据规格** ：合成二分类数据集，40,000 样本，40 特征，200 棵树（ 32k 训练 / 8k 测试），`random_state=42`。全平台测试集准确率均为 95.59% 并行任务数 (`n_jobs`) | OCI ARM (Ampere) | Lightning CPU | Kaggle CPU | Ryzen 7 6800H (本地) ---|---|---|---|--- 1 | 34.12 s | | | | 28.34 s | 70.88 s | **27.63 s** | | 2 | 17.74 s | 15.54 s | 36.97 s | **14.12 s** | | 4 | 9.50 s | 11.13 s | 24.79 s | **7.43 s** | | 8 | — | — | — | 4.50 s | | 16 | — | — | — | **3.04 s** | 注：Kaggle CPU 在 4 线程时表现出较明显的扩展瓶颈，耗时为本地 6800H 的 3.3 倍； OCI ARM 在 1 核至 4 核间表现出接近线性的加速比（约 3.59x ） ##### 2. PyTorch：CPU 矩阵乘法（ 4096×4096 ，float32 ） * **测试逻辑** ：`torch.set_num_interop_threads(1)`，显式预热，多次采样取中位数耗时 线程数 (`threads`) | OCI ARM (Ampere) | Lightning CPU | Kaggle CPU | Ryzen 7 6800H (本地) ---|---|---|---|--- 1 | 3.66 s (37.5 GFLOP/s) | | | | 0.90 s | 2.03 s | 1.20 s | | 2 | 1.85 s (74.3 GFLOP/s) | 0.48 s | 1.05 s | 0.64 s | | 4 | 1.06 s (129.9 GFLOP/s) | 0.93 s | 1.02 s | **0.44 s** | | 8 | — | — | — | 0.27 s | | 16 | — | — | — | **0.24 s** | 注：Lightning CPU 在 1~2 线程下受益于 x86 高级矢量扩展(AVX)及底层优化的数学库，单核吞吐占优，但打满 4 线程时收益见顶； OCI ARM 多核扩展曲线相对平稳 ##### 3. GPU 单算子基准参照（ 4096×4096 Matmul ） * **参数设定** ：PyTorch float32 ，显式关闭 TF32 ，包含 `torch.cuda.synchronize()` 同步 硬件平台 | 单次中位数耗时 | 计算吞吐 ---|---|--- Ryzen 7 6800H (16 线程 CPU) | 236.80 ms | | ~580 GFLOP/s | | Kaggle Tesla T4 (16GB VRAM) | 40.86 ms | ~3363 GFLOP/s | | **本地 RTX 3050 Laptop (4GB VRAM)** | **36.91 ms** | **~3723 GFLOP/s** | 注：纯单算子吞吐下移动端 3050 略胜 T4 ，但 4GB 显存无法承载大规模上下文与 Batch Size ，仅适用于小模型原型快速验证 * * * #### 三、 观察与局限 1. **物理核 vs 容器超卖** ： Kaggle 与 Lightning 的 4 vCPU 在高并发下扩展性衰减，推测主要受宿主机多租户超卖导致的上下文切换(Context Switch)及 CPU 配额(Quota)节流限制； OCI ARM 绑定的为独立物理核心，扩展曲线受多租户干扰相对较小 2. **测试局限** ： 各实例未强制对齐底层线性代数库与依赖环境（如 OpenBLAS / MKL 编译后端差异），随机森林单次采样可能存在瞬态扰动 #### 四、源码 import importlib.metadata as metadata import os import platform import statistics import sys import time import numpy as np import sklearn import torch from joblib import cpu_count from sklearn.datasets import make_classification from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split ORACLE_RF_SECONDS = {1: 34.124, 2: 17.737, 4: 9.503} ORACLE_TORCH_CPU_SECONDS = { 1024: {1: 0.0571, 2: 0.0293, 4: 0.0158}, 2048: {1: 0.4531, 2: 0.2266, 4: 0.1237}, 4096: {1: 3.6563, 2: 1.8504, 4: 1.0573}, } OFFICIAL_TARGETS = { "numpy": "2.3.5", "scipy": "1.16.3", "scikit-learn": "1.8.0", "ISLP": "0.4.1", "torch": "2.10.0", } def installed_version(name): try: return metadata.version(name) except metadata.PackageNotFoundError: return "未安装" def environment_report(): print("=" * 72) print("环境检查") print("=" * 72) print(f"OS / 架构 : {platform.platform()} / {platform.machine()}") print(f"Python : {sys.version.split()[0]}") print(f"逻辑 CPU （ OS ） : {os.cpu_count()}") print(f"可用 CPU （ joblib ） : {cpu_count()}") print(f"PyTorch : {torch.**version**}") print(f"PyTorch 默认线程数 : {torch.get_num_threads()}") print(f"CUDA 可用 : {torch.cuda.is_available()}") if torch.cuda.is_available(): print(f"GPU : {torch.cuda.get_device_name(0)}") print("\nISLP_labs v2.2.2 官方 requirements 相关目标版本：") for package, target in OFFICIAL_TARGETS.items(): actual = installed_version(package) print(f" {package:16} 当前={actual:18} 目标={target}") print("提示：先记录平台预装版本。不要只为版本号相同就替换 Kaggle 预装的 PyTorch ；这可能影响 GPU/CUDA 配置。") print("线程数 1/2/4 用于与 Oracle 的结果横向比较；若平台可用 CPU 少于 4 ，4 线程结果可能受资源限制。") def random_forest_benchmark(): print("\n" + "=" * 72) print("任务 A：scikit-learn 随机森林（ CPU ）") print("=" * 72) print("数据：40,000 个样本、40 个特征；训练集 32,000 ，测试集 8,000 ； 200 棵树。") data_start = time.perf_counter() X, y = make_classification( n_samples=40_000, n_features=40, n_informative=20, n_redundant=10, n_classes=2, random_state=42, ) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42, stratify=y ) print(f"数据准备耗时：{time.perf_counter() - data_start:.3f} 秒") results = [] for n_jobs in (1, 2, 4): model = RandomForestClassifier( n_estimators=200, max_features="sqrt", random_state=42, n_jobs=n_jobs ) t0 = time.perf_counter() model.fit(X_train, y_train) train_seconds = time.perf_counter() - t0 t0 = time.perf_counter() pred = model.predict(X_test) predict_seconds = time.perf_counter() - t0 accuracy = accuracy_score(y_test, pred) results.append((n_jobs, train_seconds, predict_seconds, accuracy)) print(f"\nn_jobs={n_jobs}: 训练 {train_seconds:.3f}s | 预测 {predict_seconds:.3f}s | 准确率 {accuracy:.4%}") baseline = results[0][1] print("\n 与 Oracle 同一任务实测对比（训练时间）：") for n_jobs, seconds, predict_seconds, accuracy in results: oracle = ORACLE_RF_SECONDS[n_jobs] if seconds > 0: ratio = oracle / seconds label = f"Kaggle 约快 {ratio:.2f} 倍" if ratio > 1.01 else (f"Oracle 约快 {1/ratio:.2f} 倍" if ratio < 0.99 else "两者接近") else: label = "无法计算比例" print(f"{n_jobs} 线程 | Kaggle {seconds:.3f}s | Oracle {oracle:.3f}s | {label} | 加速 {baseline/seconds:.2f}x") return results def pytorch_cpu_benchmark(): print("\n" + "=" * 72) print("任务 B：PyTorch CPU 矩阵乘法（与 Oracle 使用相同矩阵规模）") print("=" * 72) print("dtype=float32 ；只测 CPU ；每轮使用中位数，包含一次预热但不计入耗时。") torch.manual_seed(42) torch.set_num_interop_threads(1) all_results = {} for n in (1024, 2048, 4096): print(f"\n 矩阵：{n} × {n}") a = torch.randn(n, n, dtype=torch.float32, device="cpu") b = torch.randn(n, n, dtype=torch.float32, device="cpu") repeats = 5 if n == 1024 else (3 if n == 2048 else 2) all_results[n] = {} for threads in (1, 2, 4): torch.set_num_threads(threads) _ = a @ b # 预热 samples = [] for _ in range(repeats): t0 = time.perf_counter() c = a @ b samples.append(time.perf_counter() - t0) del c seconds = statistics.median(samples) gflops = (2 * n**3) / seconds / 1e9 all_results[n][threads] = seconds oracle = ORACLE_TORCH_CPU_SECONDS[n][threads] if seconds > 0: ratio = oracle / seconds label = f"Kaggle 约快 {ratio:.2f} 倍" if ratio > 1.01 else (f"Oracle 约快 {1/ratio:.2f} 倍" if ratio < 0.99 else "两者接近") else: label = "无法计算比例" print(f"threads={threads} | 中位数 {seconds _1000:.1f} ms | {gflops:.2f} GFLOP/s | Oracle {oracle_ 1000:.1f} ms | {label}") del a, b return all_results def pytorch_gpu_benchmark(): print("\n" + "=" * 72) print("任务 C：PyTorch GPU 矩阵乘法（仅当 CUDA 可用时运行）") print("=" * 72) if not torch.cuda.is_available(): print("跳过：torch.cuda.is_available() 为 False 。若想测试 Kaggle GPU ，请在 Notebook 的 Settings / Accelerator 中选择 GPU 后重启会话。") return device = torch.device("cuda") print(f"GPU：{torch.cuda.get_device_name(0)}") torch.manual_seed(42) for n in (1024, 2048, 4096): a = torch.randn(n, n, dtype=torch.float32, device=device) b = torch.randn(n, n, dtype=torch.float32, device=device) repeats = 10 if n == 1024 else (5 if n == 2048 else 3) _ = a @ b torch.cuda.synchronize() samples = [] for _ in range(repeats): torch.cuda.synchronize() t0 = time.perf_counter() c = a @ b torch.cuda.synchronize() # GPU 是异步执行的，计时前后要同步 samples.append(time.perf_counter() - t0) del c seconds = statistics.median(samples) gflops = (2 * n**3) / seconds / 1e9 print(f"{n} × {n} | GPU 中位数 {seconds*1000:.2f} ms | {gflops:.2f} GFLOP/s") del a, b torch.cuda.empty_cache() def main(): total_start = time.perf_counter() environment_report() random_forest_benchmark() pytorch_cpu_benchmark() pytorch_gpu_benchmark() print("\n" + "=" * 72) print(f"全部测试结束（不含安装依赖）：{time.perf_counter() - total_start:.2f} 秒") print("随机森林是 CPU 任务； PyTorch CPU 测试可与 Oracle 的 CPU 数据直接比较。GPU 结果是单独的可选测试。") print("环境、库版本、可用 CPU 和后台负载都可能影响成绩；请将它们作为实测参考，而不是绝对硬件排名。") if **name** == "**main** ": main()

_A field note from the autonomous Claude Code agent I run every day on one Windows PC. The numbers come from its own ledgers, not from memory._ **Free to read first:** a PDF sample of the book behind this setup — its first 3 chapters: https://dbsoul.gumroad.com/l/autonomous-ai-agents-claude-code-free-sample Every morning at 08:30 my agent runs a list of checks on things it has put out in public. One line asks whether my writeup for a Kaggle competition is still marked as submitted. The check opens the competition's writeup page, reads the page text, and looks for the word SUBMITTED. ## The red line From October 1 to October 11 that line passed every day. On October 12 and 13 the page did not load in time, so the line said it could not check. October 14 passed. October 15 and 16 did not load again. On October 17 the page loaded, and the line turned red: no submitted marker. A red line on that check would mean my writeup was no longer marked as submitted. Before changing anything, a session opened the same page with the same browser profile and read the text again. My writeup was there, marked Submitted. Capital S, then lower case. The page used to show SUBMITTED in capitals. The check matched the word with its capitals exactly, so it no longer matched. My writeup had not changed. The spelling on the page had. The last day the old spelling was seen is October 14, and the next run that loaded the page was October 17, so I do not know which day it changed. ## The hole behind it The old check looked for the word anywhere on the page. That page also lists other people's writeups. In the first 3,000 characters of the page text saved that morning, the word appeared 13 times: once for my writeup and 12 times for other people's. So while the old spelling was in use, the check would have passed on any other writeup carrying it, even if mine had been only a draft. The red line was false. The green lines before it were weaker than they looked. ## The fix The new check reads only my own section of the page, from the Your Work heading to the New Writeup button, and finds the word there in any mix of capitals. If it cannot find my section at all, it does not say red. It waits 90 seconds and reads once more, and if it still cannot find the section, the line says it could not check. Against the page text read that morning, the old check said no and the new check said yes. The next morning, October 18, the line passed with the new check. ## The rules * **Read the source again before acting on a red line.** Here the source said the opposite of the alarm. * **Search only where your item is.** A word that also appears next to everyone else's items tells you nothing about yours. * **Not found is not the same as not submitted.** When my section is missing, the check reports that it could not check, not a failure. **Where this comes from.** Every post here comes from one setup I run daily: a CLAUDE.md, memory files the agent reads before it touches anything, and a separate auditor agent that returns PASS or FAIL. The first 3 chapters of the book that walks through it are free as a PDF: https://dbsoul.gumroad.com/l/autonomous-ai-agents-claude-code-free-sample The full edition is 11 chapters plus 4 ready-to-use templates (CLAUDE.md starter, memory files, auditor checklist, measurement guide) and a hands-on section for every chapter, $19 as a PDF: https://dbsoul.gumroad.com/l/autonomous-ai-agents-claude-code Questions about the setup are welcome in the comments — I'll answer with what actually happened, not theory.

Join Google Quantum AI's Kaggle competition: use AI and open source kickmix in Qualtran to compile smaller, verified quantum circuits.

In the coming days, we will stop supporting R in Kaggle Notebooks. This post explains why and what it means for your work. Why we're doing this R has been pa...

NTT東日本のデータサイエンティストが世界最大級のコンペで金メダルを獲得。地域支援とデータサイエンスが融合する取り組みを紹介します。

Google Quantum AI lanza una competición en Kaggle con 150.000 dólares en premios para optimizar circuitos cuánticos con inteligencia artificial en fusión, química y matemáticas.

Google Quantum AI lança competição no Kaggle com US$ 150 mil em prêmios para usar inteligência artificial na otimização de circuitos quânticos para fusão, química e matemática.