vectorphile

pip install vectorphile

# Optional scientific backends
pip install "vectorphile[full]"    # adds scipy, pyarrow

# Development + testing
pip install "vectorphile[dev]"     # adds pytest, pytest-cov

import vectorphile as vp
from vectorphile.utils.data import TensorDataset, DataLoader

X = vp.randn(1000, 20)
y = (X[:, 0] + X[:, 1] > 0).astype('int32')

loader = DataLoader(TensorDataset(X, y), batch_size=64, shuffle=True)

model     = vp.nn.Sequential(
    vp.nn.Linear(20, 64),
    vp.nn.BatchNorm1d(64),
    vp.nn.GELU(),
    vp.nn.Dropout(0.3),
    vp.nn.Linear(64, 2),
)
criterion = vp.nn.CrossEntropyLoss()
optimizer = vp.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
scheduler = vp.optim.CosineAnnealingLR(optimizer, T_max=20)

for epoch in range(20):
    for X_b, y_b in loader:
        optimizer.zero_grad()
        loss = criterion(model(X_b), y_b)
        loss.backward()
        optimizer.step()
    scheduler.step()
    print(f"Epoch {epoch+1:02d}  loss={loss.item():.4f}")

import vectorphile as vp

x = vp.tensor([1.0, 2.0, 3.0])
y = vp.randn(3, 4)
z = vp.zeros(5, 5)
e = vp.eye(4)
r = vp.arange(0, 10, step=2)

a = vp.randn(6, 8)
b = a.reshape(2, 3, 8)
c = a.T
d = a.unsqueeze(0)

x = vp.randn(3, 1)
y = vp.randn(1, 4)
z = x + y                              # (3, 4) via broadcasting

m = z.mean()
s = z.sum(axis=1, keepdims=True)
mx, idx = z.max(axis=0)

x = vp.tensor([2.0, 3.0], requires_grad=True)
w = vp.tensor([[1.0, 0.5], [0.5, 1.0]])

h = x @ w
y = (h ** 2 + vp.log(h.abs() + 1)).sum()
y.backward()

print(x.grad)

with vp.no_grad():
    logits = model(X_test)

model = vp.nn.Sequential(
    vp.nn.Linear(784, 512),
    vp.nn.BatchNorm1d(512),
    vp.nn.GELU(),
    vp.nn.Dropout(p=0.3),
    vp.nn.Linear(512, 256),
    vp.nn.LayerNorm(256),
    vp.nn.SiLU(),
    vp.nn.Linear(256, 10),
)

total_params = sum(p.numel() for p in model.parameters())
print(f"Parameters: {total_params:,}")

X = vp.randn(32, 784)
logits = model(X)

criterion = vp.nn.CrossEntropyLoss()
loss = criterion(logits, y)

model.train()
model.eval()

opt_sgd   = vp.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, nesterov=True)
opt_adam  = vp.optim.Adam(model.parameters(), lr=1e-3)
opt_adamw = vp.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-2)

sched_cosine  = vp.optim.CosineAnnealingLR(optimizer, T_max=100, eta_min=1e-6)
sched_plateau = vp.optim.ReduceLROnPlateau(optimizer, patience=10, factor=0.5)
sched_onecycle = vp.optim.OneCycleLR(optimizer, max_lr=0.01, total_steps=1000)

optimizer.zero_grad()
loss = criterion(model(X), y)
loss.backward()
optimizer.step()
scheduler.step()

from vectorphile.utils.data import TensorDataset, DataLoader

dataset = TensorDataset(X_train, y_train)
loader  = DataLoader(dataset, batch_size=64, shuffle=True, drop_last=False)

for X_batch, y_batch in loader:
    logits = model(X_batch)
    loss   = criterion(logits, y_batch)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()

from vectorphile import ml

X_tr, X_te, y_tr, y_te = ml.train_test_split(X, y, test_size=0.2, random_state=42)
scaler = ml.StandardScaler()
X_tr   = scaler.fit_transform(X_tr)
X_te   = scaler.transform(X_te)

clf = ml.RandomForestClassifier(n_estimators=200)
clf.fit(X_tr, y_tr)
print(ml.accuracy_score(y_te, clf.predict(X_te)))

scores = ml.cross_val_score(clf, X, y, cv=5, scoring='f1_weighted')
print(f"CV F1: {scores.mean():.3f} ± {scores.std():.3f}")

from vectorphile.ml.boost import XGBClassifier

clf = XGBClassifier(
    n_estimators=300,
    learning_rate=0.05,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_lambda=1.0,
)
clf.fit(X_tr, y_tr)
print(clf.score(X_te, y_te))

df = vp.read_csv('dataset.csv')

active = df[df['status'] == 'active']
df['margin'] = (df['revenue'] - df['cost']) / df['revenue']

monthly = df.groupby(['year', 'month']).agg({'revenue': 'sum', 'margin': 'mean'})
result  = df.merge(metadata, on='product_id', how='left')
wide    = df.pivot(index='date', columns='region', values='sales')
long    = wide.melt(id_vars=['date'], var_name='region', value_name='sales')

df[['revenue', 'margin']].describe()
df.to_csv('output.csv', index=False)

A = vp.randn(50, 50)
B = A.T @ A

U, S, Vt   = vp.linalg.svd(A)
vals, vecs  = vp.linalg.eig(A)
L           = vp.linalg.cholesky(B + 0.01 * vp.eye(50))
Q, R        = vp.linalg.qr(A)

x     = vp.linalg.solve(B, b)
x_ls  = vp.linalg.lstsq(A, b)
A_inv = vp.linalg.inv(B)
A_pin = vp.linalg.pinv(A)

print(vp.linalg.det(B))
print(vp.linalg.norm(A, ord='fro'))

from vectorphile import stats

print(stats.mean(x), stats.std(x), stats.var(x))
r_p, p_p = stats.pearsonr(x, y)
r_s, p_s = stats.spearmanr(x, y)

t, p  = stats.ttest_ind(group_a, group_b, equal_var=False)
chi2, p, dof, expected = stats.chi2_contingency(table)
f, p  = stats.f_oneway(g1, g2, g3)
z     = stats.zscore(x)

from vectorphile import fft, signal

X       = fft.fft(x)
freqs   = fft.fftfreq(len(x), d=1/fs)
X2d     = fft.fft2(image)

b, a     = signal.butter(order=4, cutoff=0.1, btype='low')
filtered = signal.filtfilt(b, a, noisy)

f, t, Zxx = signal.stft(x, fs=fs, nperseg=256)
out       = signal.convolve(sig, kernel, mode='same')