vaex-dataframes

Vaex DataFrames

概要

Vaex は、RAM に収まらないほど大きなデータセットに対して、遅延評価とアウトオブコアで DataFrame 操作を行う高性能な Python ライブラリです。メモリマップドファイルと遅延評価を使用して毎秒 10 億行以上を処理するため、データをメモリに読み込まずに、対話的な探索や分析ができます。

使用する場面

• 利用可能な RAM より大きな表形式のデータセット（10 GB～数 TB）の処理
• 大規模なデータセットに対する高速な統計集計（10 億行規模での平均、標準偏差、分位数）
• サンプリングせずに大規模なデータセットを可視化（ヒートマップ、ヒストグラム）
• ビッグデータに対する ML 前処理パイプライン（スケーリング、エンコーディング、PCA）の構築
• データ形式の変換（繰り返しの高速アクセスに向けた CSV から HDF5／Arrow への変換）
• メモリを追加で一切消費しない仮想列を使った特徴量エンジニアリング
• 天文カタログ、金融時系列データ、大規模な科学データセットの処理
• インメモリでの速度を重視し、データが RAM に収まる場合は、代わりに polars を使用してください
• 複数ノードの分散コンピューティングには、代わりに dask を使用してください

前提条件

pip install vaex
# Optional extras:
pip install vaex-hdf5          # HDF5 support (recommended)
pip install vaex-arrow          # Apache Arrow support
pip install vaex-ml             # Machine learning transformers
pip install vaex-viz            # Visualization support
pip install vaex-jupyter        # Jupyter widget support
pip install s3fs gcsfs adlfs    # Cloud storage (S3, GCS, Azure)

Python 3.7 以降が必要です。HDF5 および Arrow 形式ではメモリマップド読み込みをすぐに利用できます。CSV は最適なパフォーマンスを得るために変換が必要です。

クイックスタート

import vaex
import numpy as np

df = vaex.from_arrays(
    x=np.random.normal(0, 1, 1_000_000),
    y=np.random.normal(0, 1, 1_000_000),
    category=np.random.choice(['A', 'B', 'C'], 1_000_000),
)

df['radius'] = (df.x**2 + df.y**2).sqrt()  # Virtual column, zero memory
df_inner = df[df.radius < 1.0]              # Filtered view
print(df_inner.radius.mean())               # ~0.48

result = df.groupby('category').agg({'radius': 'mean'})
print(result)  # shape: (3, 2)

df.export_hdf5('/tmp/sample.hdf5')          # Export to efficient format
df2 = vaex.open('/tmp/sample.hdf5')         # Future loads are instant
print(f"Loaded {len(df2):,} rows instantly")

コア API

1. DataFrame の作成と I/O

ファイル、配列、pandas、Arrow テーブルから DataFrame を作成できます。HDF5 および Arrow ファイルはメモリマップされるため、すぐに読み込めます。

import vaex
import numpy as np

# From files (HDF5/Arrow are instant via memory mapping)
df = vaex.open('data.hdf5')       # Recommended: instant, memory-mapped
df = vaex.open('data.arrow')      # Also instant, memory-mapped
df = vaex.open('data.parquet')    # Fast, columnar, compressed
df = vaex.open('data_*.hdf5')     # Wildcards: multiple files as one DataFrame

# From CSV (slow for large files — convert to HDF5)
df = vaex.from_csv('data.csv', convert='data.hdf5')  # Auto-converts

# From Python objects
df = vaex.from_arrays(x=np.arange(100), y=np.random.rand(100))
df = vaex.from_dict({'name': ['Alice', 'Bob'], 'age': [30, 25]})
df = vaex.from_pandas(pd.DataFrame({'a': [1, 2, 3]}), copy_index=False)

# From Arrow table
import pyarrow as pa
df = vaex.from_arrow_table(pa.table({'x': [1, 2, 3]}))

# Inspect
print(df.shape)          # (rows, cols)
print(df.column_names)   # Column names
df.describe()            # Statistical summary

# Export
df.export_hdf5('out.hdf5')                             # Recommended
df.export_arrow('out.arrow')                            # Interoperability
df.export_parquet('out.parquet', compression='snappy')   # Compressed
df.export_parquet('s3://bucket/data.parquet')            # Cloud storage

2. フィルタリングと選択

ブール式で行をフィルタリングします。名前付きの選択を使うと、新しい DataFrame を作成せずに複数のサブセットの統計を計算できます。

import vaex
import numpy as np

df = vaex.from_arrays(
    age=np.array([22, 35, 45, 19, 60]),
    salary=np.array([30000, 70000, 90000, 25000, 120000]),
    dept=np.array(['Eng', 'Sales', 'Eng', 'Sales', 'Eng']),
)

# Boolean filtering (creates a view, no copy)
df_eng_high = df[(df.dept == 'Eng') & (df.salary > 50000)]
print(len(df_eng_high))  # 2

# isin, between, string/null checks
df_mid = df[df.age.between(25, 50)]
# df[df.name.str.contains('Ali')], df[df.salary.notna()]

# Named selections (more efficient for multiple aggregations)
df.select(df.age >= 30, name='senior')
df.select(df.dept == 'Eng', name='engineers')
mean_senior = df.salary.mean(selection='senior')
mean_eng = df.salary.mean(selection='engineers')
print(f"Senior avg: {mean_senior}, Eng avg: {mean_eng}")
# Senior avg: 93333.33, Eng avg: 80000.0

3. 仮想列と式

仮想列はメモリを一切追加で消費せず、その場で計算されます。Vaex の効率性を支える中核となる機能です。

import vaex
import numpy as np

df = vaex.from_arrays(
    price=np.array([10.0, 20.0, 30.0, 40.0]),
    quantity=np.array([5, 3, 8, 2]),
    discount=np.array([0.0, 0.1, 0.0, 0.2]),
)

# Arithmetic (virtual columns — no memory used)
df['revenue'] = df.price * df.quantity * (1 - df.discount)
df['log_price'] = df.price.log()

# Conditional logic
df['tier'] = (df.price >= 30).where('premium', 'standard')

# Math: .abs(), .sqrt(), .log(), .log10(), .exp(), .sin(), .cos(),
#        .round(n), .floor(), .ceil(), .astype('float64')

# Check virtual vs materialized
print(df.get_column_names(virtual=False))  # Materialized only

# Materialize when needed (complex expr used repeatedly)
df['revenue_mat'] = df.revenue.values  # Now stored in memory

4. 集計と GroupBy

数十億行にわたる効率的な集計が可能です。delay=True を使うと、複数の操作をまとめて 1 回のデータ走査で実行できます。

import vaex
import numpy as np

np.random.seed(42)
n = 100_000
df = vaex.from_arrays(
    sales=np.random.uniform(10, 500, n),
    quantity=np.random.randint(1, 20, n),
    region=np.random.choice(['East', 'West', 'North'], n),
)

# Single-column aggregations
print(f"Mean: {df.sales.mean():.2f}, Std: {df.sales.std():.2f}")
# Also: .min(), .max(), .minmax(), .sum(), .count(), .nunique(),
#   .quantile(0.5), .median_approx(), .kurtosis(), .skew()
#   .correlation(df.x, df.y), .covar(df.x, df.y)

# Batch aggregations with delay=True (single pass through data)
mean_s = df.sales.mean(delay=True)
std_s = df.sales.std(delay=True)
sum_q = df.quantity.sum(delay=True)
results = vaex.execute([mean_s, std_s, sum_q])
print(f"Mean: {results[0]:.2f}, Std: {results[1]:.2f}, Total qty: {results[2]}")

# GroupBy
grouped = df.groupby('region').agg({'sales': ['sum', 'mean'], 'quantity': 'sum'})
print(grouped)  # shape: (3, 4)

# Multi-dimensional binned aggregation (for heatmap data)
counts = df.count(binby=[df.sales, df.quantity],
                  limits=[[0, 500], [1, 20]], shape=(50, 19))
print(f"2D histogram shape: {counts.shape}")  # (50, 19)

5. 文字列と日時の操作

文字列メソッドには .str アクセサーを、日時メソッドには .dt アクセサーを使用します。

import vaex
import numpy as np

# String operations via .str accessor
df = vaex.from_dict({
    'name': ['Alice Smith', 'Bob Jones', 'Charlie Brown'],
    'email': ['[email protected]', '[email protected]', '[email protected]'],
})
df['email_clean'] = df.email.str.lower().str.strip()
df['first_name'] = df.name.str.split(' ')[0]
df['has_test'] = df.email_clean.str.contains('test')
# Also: .upper(), .title(), .startswith(), .endswith(), .len(),
#   .replace(), .pad(), .slice(start, end)

# DateTime operations via .dt accessor
dates = np.array(['2024-01-15', '2024-06-20', '2024-12-01'], dtype='datetime64')
df2 = vaex.from_arrays(timestamp=dates, value=np.array([100, 200, 300]))
df2['year'] = df2.timestamp.dt.year
df2['month'] = df2.timestamp.dt.month
df2['weekday'] = df2.timestamp.dt.dayofweek  # 0=Monday
# Also: .day, .hour, .minute, .second
print(df2[['timestamp', 'year', 'month']].head(3))

6. 可視化

Vaex は効率的なビニングにより、サンプリングせずにすべてのデータを使って、数十億行のデータセットを可視化します。

import vaex
import numpy as np
import matplotlib.pyplot as plt

np.random.seed(0)
df = vaex.from_arrays(
    x=np.random.normal(0, 1, 500_000),
    y=np.random.normal(0, 1, 500_000),
    z=np.random.uniform(0, 10, 500_000),
)

# 1D histogram
df.plot1d(df.x, limits=[-4, 4], shape=80, figsize=(8, 4))
plt.title('X Distribution')
plt.savefig('hist1d.png', dpi=150, bbox_inches='tight')
plt.close()

# 2D density heatmap (core vaex visualization)
df.plot(df.x, df.y, limits='99.7%', shape=(256, 256),
        f='log', colormap='viridis', figsize=(8, 8))
plt.savefig('heatmap2d.png', dpi=150, bbox_inches='tight')
plt.close()

# Aggregation on grid (mean of z over x-y plane)
df.plot(df.x, df.y, what=df.z.mean(),
        limits=[[-3, 3], [-3, 3]], shape=(100, 100))
plt.savefig('mean_grid.png', dpi=150, bbox_inches='tight')
plt.close()
print("Saved: hist1d.png, heatmap2d.png, mean_grid.png")

7. ML との統合

vaex.ml は、前処理、次元削減、クラスタリング、scikit-learn モデルのラッピングに使えるトランスフォーマーを提供します。すべてのトランスフォーマーは仮想列を作成するため、メモリを一切追加で消費しません。

import vaex, vaex.ml
import numpy as np

np.random.seed(42)
n = 10_000
df = vaex.from_arrays(
    age=np.random.randint(18, 70, n).astype(float),
    income=np.random.uniform(20000, 150000, n),
    category=np.random.choice(['A', 'B', 'C'], n),
    target=np.random.randint(0, 2, n),
)

# Feature scaling (creates virtual columns: standard_scaled_age, ...)
scaler = vaex.ml.StandardScaler(features=['age', 'income'])
df = scaler.fit_transform(df)
# Also: MinMaxScaler, MaxAbsScaler, RobustScaler

# Categorical encoding
encoder = vaex.ml.LabelEncoder(features=['category'])
df = encoder.fit_transform(df)
# Also: OneHotEncoder, FrequencyEncoder, TargetEncoder, WeightOfEvidenceEncoder

# PCA
pca = vaex.ml.PCA(features=['standard_scaled_age', 'standard_scaled_income'],
                   n_components=2)
df = pca.fit_transform(df)
print(f"Explained variance: {pca.explained_variance_ratio_}")

# Scikit-learn bridge: wrap any sklearn model
from sklearn.ensemble import RandomForestClassifier
features = ['standard_scaled_age', 'standard_scaled_income',
            'label_encoded_category']
model = vaex.ml.sklearn.Predictor(
    features=features, target='target',
    model=RandomForestClassifier(n_estimators=50, random_state=42),
    prediction_name='rf_prediction',
)
train_df, test_df = df[:8000], df[8000:]
model.fit(train_df)
test_df = model.transform(test_df)  # Predictions as virtual columns
accuracy = (test_df.rf_prediction == test_df.target).mean()
print(f"Accuracy: {accuracy:.3f}")  # ~0.50 (random data)

# Save pipeline state (encoding + scaling + model)
train_df.state_write('pipeline_state.json')
# Deploy: prod_df.state_load('pipeline_state.json')

重要な概念

遅延評価モデル

Vaex の操作は、計算を実行せずに式グラフを構築します。結果にアクセスしたとき（値の表示、.values の呼び出し、エクスポート）にのみ評価が実行されます。

import vaex, numpy as np
df = vaex.from_arrays(x=np.random.rand(1_000_000))

# NOT computed: virtual column, expression, filtered view
df['x_sq'] = df.x ** 2;  expr = df.x_sq.mean();  df_f = df[df.x > 0.5]

# COMPUTED: accessing value, .values, .to_pandas_df(), .export_hdf5()
print(f"Mean: {df.x.mean():.4f}")

仮想列と実体化列

項目	仮想	実体化
メモリ	追加消費なし	配列全体を格納
速度	使用するたびに再計算	即座にアクセス
作成	df['col'] = expr	df['col'] = expr.values
適した用途	単純な式、使用頻度が低い場合	繰り返し使用する複雑な式
確認方法	df.is_local('col') は False を返す	True を返す

目安： 同じ複雑な式を 3 回以上の集計で使用する場合を除き、列は仮想のままにしてください。

メモリマップドファイルのアーキテクチャ

HDF5 および Apache Arrow ファイルはメモリマップされます。OS は必要に応じてファイルのページを仮想メモリにマッピングするため、100 GB のファイルもすぐに開くことができ、RAM の使用量も最小限に抑えられます。データページはアクセスされたときにのみディスクから読み込まれます。

# Opens instantly regardless of file size
df = vaex.open('100gb_dataset.hdf5')  # ~0.001s, minimal RAM
mean = df.column.mean()  # Streams through data, ~RSS stays low

フォーマットの比較

特徴	HDF5	Arrow/Feather	Parquet	CSV
読み込み速度	瞬時	瞬時	高速	低速
メモリマップ	対応	対応	非対応	非対応
圧縮	オプション（gzip、lzf、blosc）	なし	デフォルト（snappy、gzip、brotli）	なし
列指向	対応	対応	対応	非対応
移植性	良好	非常に優れている	非常に優れている	非常に優れている
最適な用途	ローカルの Vaex ワークフロー	言語間の相互運用	分散システム	データ交換

推奨事項： CSV を一度 HDF5 に変換し（vaex.from_csv('data.csv', convert='data.hdf5')）、以降の読み込みには HDF5 を使用します。

一般的なワークフロー

ワークフロー 1：大規模 CSV の探索と変換

import vaex
import matplotlib.pyplot as plt

# Convert CSV to HDF5 (one-time); future loads instant
df = vaex.from_csv('large_data.csv', convert='large_data.hdf5')
print(f"Shape: {df.shape}, Columns: {df.column_names}")

# Feature engineering with virtual columns
df['log_value'] = df.value.log()
df['category_clean'] = df.category.str.lower().str.strip()
df['is_high'] = df.value > df.value.mean()

# Batch statistics (single pass)
delayed = [df.value.mean(delay=True), df.value.std(delay=True),
           df.value.quantile(0.5, delay=True), df.value.quantile(0.99, delay=True)]
results = vaex.execute(delayed)
print(f"Mean: {results[0]:.2f}, Std: {results[1]:.2f}, P99: {results[3]:.2f}")

# Visualize
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
df.plot1d(df.value, ax=axes[0], show=False)
axes[0].set_title('Value Distribution')
df.plot1d(df.log_value, ax=axes[1], show=False)
axes[1].set_title('Log Value Distribution')
plt.tight_layout()
plt.savefig('exploration.png', dpi=150, bbox_inches='tight')
plt.close()

ワークフロー 2：状態デプロイメントを伴う ML パイプライン

import vaex, vaex.ml
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier

np.random.seed(42)
n = 50_000
df = vaex.from_arrays(
    age=np.random.randint(18, 70, n).astype(float),
    income=np.random.uniform(20000, 150000, n),
    region=np.random.choice(['East', 'West', 'Central'], n),
    target=np.random.randint(0, 2, n),
)
train, test = df[:40_000], df[40_000:]

# Preprocessing pipeline
train = vaex.ml.LabelEncoder(features=['region']).fit_transform(train)
train = vaex.ml.StandardScaler(features=['age', 'income']).fit_transform(train)

# Train model
features = ['standard_scaled_age', 'standard_scaled_income', 'label_encoded_region']
model = vaex.ml.sklearn.Predictor(
    features=features, target='target',
    model=GradientBoostingClassifier(n_estimators=50, random_state=42),
    prediction_name='prediction',
)
model.fit(train)

# Save pipeline state (encoding + scaling + model in one file)
train.state_write('ml_pipeline.json')

# Deploy: apply saved state to new data
test.state_load('ml_pipeline.json')
accuracy = (test.prediction == test.target).mean()
print(f"Test accuracy: {accuracy:.3f}")  # ~0.50 (random data)
# Production: prod_df = vaex.open('new_batch.hdf5'); prod_df.state_load('ml_pipeline.json')

主なパラメーター

パラメーター	モジュール	デフォルト	範囲／オプション	効果
shape	plot、plot1d	64（1D）、（256,256）（2D）	32-2048	ヒストグラムのビン数／ヒートマップの解像度
limits	plot、plot1d	'minmax'	'99%'、'99.7%'、[min,max]	軸の範囲。外れ値の処理にはパーセンタイルベースを使用
f	plot	'identity'	'log'、'log10'、'sqrt'	密度プロットの色スケール変換
delay	集計	False	True/False	複数の集計を単一パスにまとめる
convert	from_csv	None	ファイルパス文字列	読み込み時に CSV を自動的に HDF5 に変換
chunk_size	from_csv	5,000,000	100K-50M	CSV 処理時のチャンクあたりの行数
n_components	PCA	2	1-n_features	主成分の数
n_clusters	KMeans	8	2-100+	クラスターの数
features	すべての ML トランスフォーマー	必須	列名のリスト	変換する列
compression	export_hdf5	None	'gzip'、'lzf'、'blosc'	ファイルサイズと I/O 速度のトレードオフ

ベストプラクティス

1. CSV に繰り返しアクセスする場合は、必ず HDF5 または Arrow に変換してください。 一度変換すれば、最初の再読み込み時に元が取れます：vaex.from_csv('data.csv', convert='data.hdf5')。

2. 実体化が必要になるまで、列を仮想のままにしてください。 仮想列のメモリコストはゼロです。複雑な式を 3 回以上の集計で再利用する場合にのみ実体化します。

3. delay=True で集計をまとめてください。 集計を個別に呼び出すたびに、データセット全体がスキャンされます。vaex.execute([df.x.mean(delay=True), df.x.std(delay=True)]) のようにまとめると、N 回のパスを 1 回に減らせます。

4. 複数のサブセットの統計量を計算する場合は、フィルター済み DataFrame を作成する代わりに、選択を使用してください。df.select(df.age > 30, name='senior') の後に df.salary.mean(selection='senior') を実行する方が、df_senior = df[df.age > 30] を作成するより効率的です。

5. 大規模データに対して .values や .to_pandas_df() を使用しないでください。 これらはデータを RAM に読み込むため、Vaex の目的を損ないます。小さなサブセットまたはサンプルに対してのみ使用してください。

6. 再現性のため、パイプラインの状態を保存してください。 df.state_write('state.json') は、仮想列、選択、ML トランスフォーマーを記録し、デプロイメントに利用できます。

7. アンチパターン -- 行の反復処理。 Vaex で行を反復処理しないでください。代わりにベクトル化された式と集計を使用してください。

よく使うレシピ

レシピ：複数ソースのデータ統合

import vaex

# Load from multiple sources and formats
df_csv = vaex.from_csv('data_2022.csv')
df_hdf = vaex.open('data_2023.hdf5')
df_pq = vaex.open('data_2024.parquet')

# Concatenate vertically
df_all = vaex.concat([df_csv, df_hdf, df_pq])
print(f"Combined: {len(df_all):,} rows")

# Export as unified HDF5
df_all.export_hdf5('unified_data.hdf5')
# Future: vaex.open('unified_data.hdf5')

レシピ：欠損データの処理

import vaex
import numpy as np

df = vaex.from_arrays(
    x=np.array([1.0, np.nan, 3.0, np.nan, 5.0]),
    y=np.array([10, 20, 30, 40, 50]),
)

# Detect missing
missing_pct = df.x.isna().mean() * 100
print(f"Missing: {missing_pct:.0f}%")
# Missing: 40%

# Fill with value or column mean
df['x_filled'] = df.x.fillna(df.x.mean())

# Filter out missing
df_clean = df[df.x.notna()]
print(f"Clean rows: {len(df_clean)}")
# Clean rows: 3

レシピ：選択を使った比較の可視化

import vaex
import numpy as np
import matplotlib.pyplot as plt

df = vaex.from_arrays(
    value=np.concatenate([
        np.random.normal(50, 10, 200_000),
        np.random.normal(70, 15, 200_000),
    ]),
    group=np.array(['Control'] * 200_000 + ['Treatment'] * 200_000),
)

# Named selections for efficient comparison
df.select(df.group == 'Control', name='ctrl')
df.select(df.group == 'Treatment', name='treat')

plt.figure(figsize=(10, 5))
df.plot1d(df.value, selection='ctrl', label='Control', show=False)
df.plot1d(df.value, selection='treat', label='Treatment', show=False)
plt.legend()
plt.title('Distribution Comparison')
plt.savefig('comparison.png', dpi=150, bbox_inches='tight')
plt.close()
print("Saved comparison.png")

トラブルシューティング

問題	原因	解決策
CSV の読み込みが極端に遅い	CSV はメモリマップできず、行ごとに解析されます	一度だけ変換します：vaex.from_csv('data.csv', convert='data.hdf5')。以降の読み込みには HDF5 を使用します
簡単な操作で MemoryError が発生する	データセット全体に対して .values または .to_pandas_df() を呼び出しています	遅延評価を維持します。確認には .sample(n=1000).to_pandas_df() を使用します
2D プロットが空、または真っ白になる	軸の範囲がデータの範囲と一致していません	手動で範囲を指定する代わりに、limits='99.7%' または limits='minmax' を使用します
ヒートマップに明るい点が 1 つだけ表示される	高密度領域の影響で線形カラースケールが飽和しています	対数カラースケールには f='log' を使用します
ループ内で仮想列の再計算が遅い	複雑な式がアクセスのたびに再計算されています	実体化します：df['col'] = df.complex_expr.values
クラウドパスで FileNotFoundError が発生する	ファイルシステムライブラリが不足しています	s3fs（S3）、gcsfs（GCS）、または adlfs（Azure）をインストールします
仮想列が多いとエクスポートが遅い	エクスポート中に各仮想列が再計算されています	先に実体化します：df.materialize().export_hdf5('out.hdf5')
数値を想定している列が文字列として表示される	CSV の自動判定で誤った型が選択されました	型を変換します：df['col_num'] = df.col.astype('float64')
新しいデータで state_load が失敗する	state 内の列名が新しい DataFrame と一致していません	新しいデータの列名が学習データと同一であることを確認します

同梱リソース

このエントリーには、references/ 内に2つのリファレンスファイルが含まれています。

• references/io_performance.md -- 元の io_operations.md（704行）と performance.md（572行）を統合したものです。 対象：形式固有のI/Oの詳細（HDF5の圧縮オプション、Parquetの圧縮、Arrowとの統合、FITS）、チャンク単位のI/O処理、クラウドストレージ（認証情報を使用したS3/GCS/Azure）、Vaexサーバー（リモートデータ）、データベースとの統合（pandasブリッジを使用したSQLの読み書き）、状態ファイル（パイプライン状態の保存／読み込み）、メモリ管理、並列計算（マルチスレッド、Daskとの統合）、NumbaによるJITコンパイル、非同期操作、詳細なプロファイリング／ベンチマークのパターン。 インラインに移動：形式比較表、CSVからHDF5への変換パターン、delay=True によるバッチ処理、メモリマップアーキテクチャの説明、基本的なエクスポート方法。 省略：メインファイル内の既存の内容と重複する「ベストプラクティス」のリスト、「関連リソース」の相互リンク（同梱リソースのセクションに置き換え）。

• references/ml_visualization.md -- 元の machine_learning.md（729行）と visualization.md（614行）を統合したものです。 対象：MLトランスフォーマーの全カタログ（MinMaxScaler、MaxAbsScaler、RobustScaler、FrequencyEncoder、TargetEncoder、WeightOfEvidenceEncoder、CycleTransformer、Discretizer、RandomProjection）、KMeansクラスタリング、外部ライブラリとの統合（XGBoost、LightGBM、CatBoost、Keras）、交差検証、特徴量選択、不均衡データの処理、高度な可視化（等高線プロット、ベクトル場オーバーレイ、インタラクティブなJupyterウィジェット、ファセットプロット、一括プロット、Plotly/seabornとの統合）。 インラインに移動：StandardScaler、LabelEncoder、OneHotEncoder、PCA、scikit-learn Predictorラッパー、基本的なplot1d/plot/whatのパターン、選択ベースの可視化。 省略：モデル評価指標のセクション（標準的なsklearnの指標であり、Vaex固有ではありません。scikit-learnを直接使用してください）、「関連リソース」の相互リンク。

元のリファレンスファイルの扱い：

• core_dataframes.md（368行） -- コアAPIモジュール1（DataFrameの作成とI/O）および主要概念に完全に統合しました。内容を合わせて、すべての作成方法（open、from_csv、from_arrays、from_dict、from_pandas、from_arrow_table）、データの確認、エクスポート、式の基本について、インラインで約65行をカバーしています。省略：行／列の詳細な操作パターン（モジュール2～4で扱います）、コピー／連結のパターン（レシピで扱います）。
• data_processing.md（556行） -- コアAPIモジュール2～5に完全に統合しました。フィルタリング、仮想列、式、集計、groupby、文字列操作、日時操作、欠損データ、結合、列管理をすべてインラインで扱っています。省略：高度なビニング（searchsortedのパターン、統計的なビニングの詳細） -- 使用場面が限られるため、公式ドキュメントを参照してください。

関連スキル

• polars-dataframes -- インメモリのDataFrameライブラリ。データがRAMに収まる場合に使用すると、処理が10～100倍高速になります
• dask-parallel-computing -- マルチノードクラスターでの分散コンピューティングと、pandas/NumPyの並列処理
• pandas（予定） -- 標準的なPython DataFrameライブラリ。Vaexは from_pandas/to_pandas_df を介して相互運用できます

リファレンス

• Vaexのドキュメント：https://vaex.io/docs/latest/
• VaexのGitHubリポジトリ：https://github.com/vaexio/vaex
• VaexのPyPI：https://pypi.org/project/vaex/
• Breddels & Veljanoski（2018）、「Vaex: Gaia時代のビッグデータ探索」、Astronomy & Astrophysics、https://doi.org/10.1051/0004-6361/201732493