پیگیری Rustynum: بینش های تازه و توسعه مداوم

سلام جامعه dev!

به عنوان پیگیری مقدمه قبلی من در مورد Rustynum ، می خواهم یک به روزرسانی با محوریت توسعه دهنده را در مورد آنچه در این چند هفته گذشته کار کرده ام به اشتراک بگذارم. Rustynum ، همانطور که ممکن است به یاد بیاورید ، جایگزین سبک و زنگ زده من برای Numpy است که در GitHub تحت مجوز MIT منتشر شده است. این برنامه از ویژگی های قابل حمل Rust برای محاسبات عددی سریعتر استفاده می کند ، در حالی که کوچک است (در حدود 300 کیلوبایت پوند برای چرخ پایتون). در این پست ، چند بینش به دست آمده در طول توسعه را کشف می کنم ، اشاره می کنم که واقعاً به آن کمک می کند ، و موارد اضافی اخیر در مستندات و آموزش ها را برجسته می کنم.

ضبط مختصر

اگر اعلامیه اولیه را از دست دادید ، Rustynum بر این تمرکز دارد:

• عملکرد بالا با استفاده از Simd Rust
• ایمنی حافظه در زنگ زدگی ، بدون GC سربار
• اندازه توزیع کوچک (بسیار کوچکتر از چرخ های Numpy)
• رابط مانند Numpy برای کاهش اصطکاک برای کاربران پایتون

برای مرور دقیق تر ، به وب سایت رسمی Rustynum بروید یا پست قبلی من را در Dev.to بررسی کنید.

دیدگاه توسعه دهنده: چه خبر است؟

1. کار با عملیات ماتریس

من یک قطعه خوب از زمان را صرف اطمینان از عملیات ماتریس کردم. قادر به انجام کاری مانند ماتریس بردار یا ضرب ماتریس ماتریس با حداقل تغییرات کد از Numpy یک هدف اصلی بود. برجسته است .dot() عملکرد و @ اپراتور ، که هر دو از این عملیات پشتیبانی می کنند.

آموزش اختصاصی را بررسی کنید:
عملیات ماتریس بهتر با Rustynum

در اینجا یک قطعه سریع وجود دارد:

import rustynum as rnp

matrix = rnp.NumArray([i for i in range(16)], dtype=“float32”).reshape([4, 4])
vector = rnp.NumArray([1, 2, 3, 4], dtype=“float32”)

# Use the dot function
result_vec = matrix.dot(vector)
print(“Matrix-Vector Multiplication Result:”, result_vec)

این شسته و رفته است که ببینیم این گردش کار Numpy چقدر نزدیک است. معیارها نشان می دهند که Rustynum اغلب می تواند این کارها را با سرعت قابل مقایسه با و گاهی اوقات سریعتر از NUMPY در مجموعه داده های کوچکتر یا متوسط ​​انجام دهد. برای ماتریس های بسیار بزرگ ، من هنوز رویکرد را بهینه می کنم.

2. سرعت بخشیدن به وظایف تجزیه و تحلیل مشترک

جدا از ضرب ماتریس ، من عملیات پالایش را مانند mean()با min()با max()وت dot()بشر این روشهای ساده کاندیداهای اصلی شتاب SIMD هستند. همچنین یک آموزش در مورد نحوه جایگزینی تماس های خاص NUMPY با Rustynum برای تجزیه و تحلیل وجود دارد ، که اگر توسط حلقه های پایتون تنگنا باشید ، ممکن است مفید باشد.

مثال:

import numpy as np
import rustynum as rnp

# Generate test data

data_np = np.random.rand(1_000_000).astype(np.float32)
data_rn = rnp.NumArray(data_np.tolist(), dtype=“float32”)

# NumPy approach
mean_np = data_np.mean()

# RustyNum approach
mean_rn = data_rn.mean().item()

print(“NumPy mean:”, mean_np)
print(“RustyNum mean:”, mean_rn)

سربار پایتون گاهی اوقات می تواند سرعت زنگ زدگی خام را جبران کند ، اما در بسیاری از موارد ، Rustynum هنوز هم مزایایی را نشان می دهد.

آموزش های جدید: نمونه های دنیای واقعی

یکی از بهترین راه های دیدن Rustynum در عمل ، نمونه های عملی است. من چندین آموزش جدید با سناریوهای برنامه نویسی در دنیای واقعی اضافه کردم:

1. عملیات ماتریس بهتر -روی محصولات نقطه ، ماتریس بردار و کارهای ماتریس ماتریس تمرکز کنید.
2. جایگزینی تماسهای هسته ای Numpy – نحوه تغییر از میانگین Numpy ، حداقل ، نقطه به Rustynum را نشان می دهد.
3. پیش پردازش ML – به بررسی مقیاس بندی ، عادی سازی و مهندسی ویژگی برای یادگیری ماشین می پردازد.

آخرین آموزش مورد علاقه شخصی است. این تحولات داده معمولی را که می خواهید در یک خط لوله یادگیری ماشین انجام دهید ، پوشش می دهد – فقط تماس های Numpy را برای Rustynum تعویض می کند.

یک قطعه از کد مقیاس را از آن راهنما ببینید:

def min_max_scale(array):
    col_mins = []
    col_maxes = []
    for col_idx in range(array.shape[1]):
        col_data = array[:, col_idx]
        col_mins.append(col_data.min())
        col_maxes.append(col_data.max())

    scaled_data = []
    for col_idx in range(array.shape[1]):
        col_data = array[:, col_idx]
        numerator = col_data - col_mins[col_idx]
        denominator = col_maxes[col_idx] - col_mins[col_idx] or 1.0
        scaled_col = numerator / denominator
        scaled_data.append(scaled_col.tolist())

    return rnp.concatenate(
        [rnp.NumArray(col, dtype="float32").reshape([array.shape[0], 1]) for col in scaled_data],
        axis=1
    )

این یک قطعه کوچک است ، اما نشان می دهد که چگونه Rustynum می تواند دستکاری های ردیف/ستون را کاملاً مؤثر انجام دهد. پس از مقیاس گذاری ، هنوز هم می توانید داده ها را در چارچوب های یادگیری ماشین مورد علاقه خود تغذیه کنید. سربار تبدیل آرایه های Rustynum به آرایه های Numpy یا Direct در مقایسه با هزینه مراحل آموزش مدل بزرگ حداقل است.

کار مداوم

1. بهینه سازی های بزرگ ماتریس

من متوجه شده ام که برای ماتریس های بسیار بزرگ (مانند 10k × 10k) ، مسیرهای کد فعلی Rustynum در مقایسه با Numpy کاملاً بهینه نشده اند. این منطقه یک پروژه فعال است. Rustynum هنوز جوان است ، و من امیدوارم که برای عملکرد بهتر در مقیاس بزرگ ، موازی سازی بیشتر یا تکنیک های ضرب مبتنی بر بلوک را معرفی کنم.

2. انواع داده های گسترش یافته

Rustynum از Float32 و Float64 خوب پشتیبانی می کند ، به علاوه برخی از انواع عدد صحیح. من در نظر دارم پشتیبانی عدد صحیح تری را برای کارهای علوم داده مانند نمایه سازی خاص یا تحولات کوچک اضافه کنم. در همین حال ، اگر جامعه به آنها احتیاج داشته باشد ، انواع داده های پیشرفته (به عنوان مثال ، اعداد پیچیده) ممکن است در پایین خط ظاهر شوند.

3. مستندات و پیشرفتهای API

سایت Docs در Rustynum.com دارای یک مرجع API و نقشه راه است. من به طور مداوم به آن اضافه می کنم. اگر هر چیزی را که از دست رفته است یا اگر مورد استفاده خاصی در ذهن دارید ، مشاهده کنید ، احساس راحتی کنید که یک مسئله GitHub را باز کنید یا درخواست کشش را ارسال کنید.

4. هدف بزرگ Rustynum

Rustynum صرفاً یک تمرین یادگیری برای من است که زنگ زدگی و پایتون را ترکیب کنم. از آنجا که من هر روز در اطراف یادگیری ماشین می گذرانم ، دوست دارم Rustynum بخشی از کارهای روزمره Numpy خود را جایگزین کنم. و ما به آرامی در حال رسیدن به آنجا هستیم. من شروع به اضافه کردن روش های بیشتر و بیشتر در مورد موضوع نحوه ادغام Rustynum در خطوط لوله ML کردم.

مثال کد سریع: ادغام ML

برای نشان دادن اینکه چگونه Rustynum در یک خط لوله داده قرار می گیرد ، در اینجا یک مثال چگالش وجود دارد:

import numpy as np
import rustynum as rnp
from sklearn.linear_model import LogisticRegression

# 1) Create synthetic data in NumPy
train_np = np.random.rand(1000, 10).astype(np.float32)
labels_np = np.random.randint(0, 2, size=1000)

# 2) Convert to RustyNum for fast scaling
train_rn = rnp.NumArray(train_np.flatten().tolist(), dtype="float32").reshape([1000, 10])

# Basic scaling (compute min and max per column)
scaled_rn = []
for col_idx in range(train_rn.shape[1]):
    col_data = train_rn[:, col_idx]
    mn = col_data.min()
    mx = col_data.max()
    rng = mx - mn if (mx != mn) else 1.0
    scaled_col = (col_data - mn) / rng
    scaled_rn.append(scaled_col.tolist())

train_scaled_rn = rnp.concatenate(
    [rnp.NumArray(col, dtype="float32").reshape([1000, 1]) for col in scaled_rn],
    axis=1
)

# 3) Convert back to NumPy for scikit-learn
train_scaled_np = np.array(train_scaled_rn.tolist(), dtype=np.float32)

# 4) Train a logistic regression model
model = LogisticRegression()
model.fit(train_scaled_np, labels_np)

print("Model Coefficients:", model.coef_)

این اسکریپت برجسته می کند که Rustynum می تواند با یک احساس پایتونیک تحولات داده را اداره کند ، پس از آن می توانید آرایه ها را به سایر کتابخانه ها منتقل کنید.

افکار نهایی

این جالب است که ویژگی های Rustynum را گسترش داده و ببینید که چقدر زنگ زدگی می تواند با پایتون برای کارهای با کارایی بالا ادغام شود. آموزش های اخیر پنجره ای است که چگونه Rustynum ممکن است بخش هایی از NUMPY را در علوم داده یا کارهای ML جایگزین کند ، به خصوص هنگامی که اندازه آرایه های کوچکتر یا کارهای میان رده درگیر باشد.

• آموزش های Rustynum.com را بررسی کنید
• مشارکت یا گزارش مسائل مربوط به GitHub
• اگر ویژگی ای وجود دارد که دوست دارید آن را ببینید ، بازخورد را به اشتراک بگذارید

با تشکر از شما برای تنظیم این به روزرسانی با محوریت توسعه دهنده ، و من مشتاقانه منتظر شنیدن چگونگی Rustynum در پروژه های خود هستید!

برنامه نویسی مبارک!
ایگور