راهکارهایی برای نوشتن نوت بوک های تمیز ( Clean Code) در Jupyter

نوت‌بوک‌ها یکی از مهم‌ترین محیط‌های توسعه پایتون و از محبوب‌ترین ابزارها درزمینهٔ داده‌کاوی یا یادگیری ماشین (‌یادگیری عمیق)هستند. اما لازم ست بدانید که مدیریت سریع چنین ابزار قدرتمندی چندان ساده نیست. توانایی تعامل سریع با داده‌هایمان (تغییر سلول‌های کد، اجرا و تکرار) یکی از دلایل مهمی است که نباید نوت بوک‌هایمان دچار یک درهم‌تنیدگی مبهم از متغیرهای گوناگون باشند که درک آن‌ها حتی برای نویسنده‌اش نیز سخت است. در این مقاله قصد داریم شما را با مفهوم و روش‌های کد نویسی مرتب (Clean code) آشنا کنیم.

من به‌شخصه در همان شش سال پیش که شروع به یادگیری پایتون کردم با نوت بوک های Jupyter هم آشنا شدم. چیزی که بیشتر از همه مرا شگفت‌زده کرد این بود که چگونه مردم می‌توانند کدی بنویسند که دیگران به آن اعتماد کنند و  از آن استفاده کنند. بررسی پروژه‌هایی مانند scikit-learn الهام‌بخش من برای شروع اولین پروژه منبع باز من شد. بعد از آن به سرعت بسیاری از روش‌های مهندسی نرم‌افزار مانند مدولارسازی و پکیجینگ را یاد گرفت اما هنوز مطمئن نبودم که چطور آن را درزمینهٔ داده‌کاوی به کار بگیریم تا این‌که اکوسیستم ابزارهای داده پایتون به بلوغ رسید و من  شروع به کشف چگونگی ساخت این اکوسیستم کردم. در ادامه با من همراه باشید تا ببینیم که چرا کد نویسی تمیز مهم است؟ و چگونه کدهای تمیزی بنویسیم و با راهکارهایی برای نوشتن نوت بوک های تمیز در ژوپیتر آشنا شوید.

10 توصیه برای نوشتن نوت بوک‌های خوانا و قابل نگهداری

آنچه در ادامه می‌خوانید:

  1. قفل‌کردن dependencies
  2. پکیجینگ پروژه
  3. مدولار کردن کدها
  4. مراقبت از ساختارهای داده قابل‌تغییر
  5. بارگذاری مجدد خودکار کد از ماژول‌های خارجی
  6. تست واحد
  7. سازمان‌دهی سکشن ها
  8. استفاده از یک خط کد
  9. استفاده از یک فرمت کننده خودکار کد
  10. نوشتن نوت‌بوک‌های کوتاه‌تر

قفل‌کردن dependencies

اجازه دهید پیش از صحبت کردن  در مورد نوت بوک های تمیز، به مدیریت dependency ها بپردازیم. خود من بارها زمانی که  سعی کرده‌ام یک نوت بوک قدیمی را اجرا کنم (توسط خودم  یا شخص دیگری نوشته‌شده بود ) با چندین خطای ModuleNotFound  برخورد کردم. حتی پس از اجرای pip install برای هر یک از آن‌ها نیز مواجه‌شدن با ارورهای غیرمعمولی مانند این اجتناب‌ناپذیر است. دلیلش هم مشخص است، چون بسته API تغییر کرده و دیگر با کد سازگار نیست.

برای جلوگیری از خرابی نوت بوک ها که به دلیل dependency های ازدست‌رفته به وجود می‌آید، هر بسته شخص ثالثی (third-party package  ) که استفاده می‌کنیم باید در یک فایل requirements.txt  ( یا environment.yml  اگر از conda استفاده می‌کنیم) ثبت شود. برای مثال، یک requirements.txt معمولی ممکن است به شکل زیر باشد: 

پس از نصب dependency ها در یک محیط مجازی (همیشه از محیط‌های مجازی استفاده کنید!)، می‌توانیم به فهرستی جامعی از تمام dependency های نصب شده از طریق زیر دسترسی پیدا کنیم:

و requirements.lock.txt ما به شکل زیر است:

 چرا requirements.lock.txt این‌همه خط دارد؟ هر پکیج  دارای مجموعه‌ای از dependency ها است (به‌عنوان‌مثال، پانداها به NumPy نیاز دارند). ازاین‌رو، pip freeze  لیستی از تمام پکیج‌های لازم برای اجرای پروژه ما را ایجاد می‌کند. هر خط همچنین شامل نسخه نصب شده خاصی است. بنابراین، اگر بخواهیم مجدداً نوت بوک خود را یک سال بعد اجرا کنیم، با مشکل سازگاری مواجه نخواهیم شد زیرا همان نسخه‌ای را که در طول توسعه از آن استفاده کرده بودیم را نصب می‌کنیم.

حتی اگر پروژه ما شامل چندین نوت بوک باشد، یک requirements.txt کافی است. با این حال، به خاطر داشته باشید که هر چه پروژه ما dependency های بیشتری داشته باشد، شانس بیشتری برای درگیری‌ با dependency ها دارد (به‌عنوان‌مثال، تصور کنید پانداها به NumPy نسخه 1.1 نیاز دارند، اما scikit-learn به NumPy نسخه 1.2 نیاز دارند). به یاد داشته باشید که requirements.txt  و requirements.lock.txt  خود را به‌روز نگه دارید: در صورت نیاز پکیج‌های جدید اضافه کنید و اگر دیگر به آن‌ها نیازی نداریدحتما آن‌ها حذف کنید.

پکیجینگ پروژه

هنگام شروع به نوشتن یک نوت بوک، تعریف توابع یا کلاس‌ها در فایل نوت بوک کاری وسوسه‌انگیز است، اما این کار پیچیدگی‌های زیادی ایجاد می‌کند. اولاً،  این روش در آینده وارد کردن چنین کدی را در نوت بوک دیگری غیرممکن می‌کند، و دوم، استدلال در مورد معنای آن را دشوار می‌کند (این تابعی است که داده ها را پردازش می‌کند یا آن را ترسیم می‌کند؟). یک تمرین بهتر این است که تعاریف تابع و کلاس خود را در یک فایل جداگانه نگه داریم و بعداً آن‌ها را در نوت بوک خود وارد کنیم:

چنین طرح‌بندی ساده‌ای تا زمانی که بخواهیم کد خود را در پوشه‌ها سازمان‌دهی کنیم خوب کار می‌کند:

اگر exploration.ipynb  را بازکنیم، دیگر نمی‌توانیم import plot  یا import process  را انجام دهیم. به این دلیل که هنگام استفاده از import  پایتون ابتدا به دنبال یک ماژول محلی (یعنی فایلی در همان فهرست) با آن نام می‌گردد، و سپس در site-packages  (هنگام pip install {package}  بسته‌ها در آنجا ذخیره می‌شوند) . بنابراین، اگر می‌خواهیم پایتون کد ما را ایمپورت کند، باید به پایتون بگوییم کجا آن را جستجو کند. مطمئنم شما قبلاً این را دیده‌اید:

ما به پایتون می‌گوییم که داخل ../src  به دنبال ماژول‌ها بگردد. با این کار ما می‌توانیم plot.py  و process.py  را وارد کنیم. اما این کار شدیداً اشتباه است. تغییر sys.path  شکستن کد ما را آسان می‌کند. فرض کنید می‌خواهیم  کدی را وارد کنیم که در یک مکان خاص وجود دارد. اگر هر یک از فایل‌های .py را جابه‌جا کنیم، باعث شکسته شدن نوت بوک خود می‌شویم.. خوشبختانه، یک راه قوی برای حل این مشکل وجود دارد و آن ایجاد یک بسته پایتون است.

بسته پایتون مجموعه‌ای از فایل‌های پایتون است که می‌توانید با  pip install {package}  آن را نصب کنید.  pip  از پیکربندی پایتون مراقبت می‌کند تا بداند کجا باید دنبال آن کد بگردد. ایجاد یک پکیج ساده است. فقط شما نیاز دارید که یک فایل setup.py  اضافه کنید:

سپس، یک تغییر کوچک در طرح‌بندی پروژه خود ایجاد می‌کنیم و کد خود را در پوشه my_package/  قرار می‌دهیم و یک فایل __init__.py  هم اضافه می‌کنیم:

خودشه! حالا اگر به پوشه حاوی فایل setup.py بروید، می‌توانید مانند زیر کار را انجام دهید:

بیایید ببینیم با این دستور چه اتفاقی می‌افتد. هنگام نصب یک بسته از طریق  pip install {package} ، به pip می‌گوییم که به فهرست بسته پایتون Python Package Index برود ، بسته‌ای را با نام درخواستی جستجو کند و آن را در بسته‌های سایت ذخیره کند.

اما pip می‌تواند از مکان‌های دیگر هم نصب شود. به عنوان مثال، فرض کنید pip install  را اجرا می‌کنیم. در این صورت، به pip می‌گوییم که از منبع موجود در دایرکتوری فعلی استفاده کند. با اجرای چنین دستوری کد را کپی می‌کند و آن را در site-packages در کنار هر بسته third-party دیگری ذخیره می‌کند. پس اگر ما آن را وارد کنیم، کپی را در site-packages می‌خواند:

اگر علامت یا پرچم –editable  را اضافه کنیم، به pip می‌گوییم که کد را کپی نکند، بلکه آن را از مکان اصلی آن بخواند. این کار به ما این امکان را می‌دهد زمانی که تغییراتی را در کد خود ایجاد کنیم،  پایتون از آخرین نسخه هنگام وارد کردن آن استفاده کند:

پس از نصب بسته ما، هر ماژول در پوشه src/my_package/  قابل ایمپورت کردن از هر دایرکتوری است:

حالا اگر به آنجا برویم، دیگر خبری از کلنجار رفتن با sys.path  نیست!

مدولار کردن کدها

هنگام جستجوی داده ها، بیشتر کدها به این شکل هستند:

اما هر از گاهی، کدهایی وجود دارند که ساختار بیشتری دارند:

اسنیپت‌هایی Snippet که بیش از یک‌بار فراخوانی می‌شوند

اسنیپت‌هایی با ساختارهای کنترلی (به عنوان مثال، iffor)

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

یک نوت بوک تمیز عملاً مجموعه‌ای از خطوط کد با ساختارهای کم یا بدون ساختار کنترل است. پیچیدگی یک نرم افزار با معیاری به نام پیچیدگی سیکلوماتیکی سنجیده می‌شود که میزان پیچیدگی یک برنامه را اندازه می‌گیرد. ازنظر شهودی، هرچه یک برنامه شاخه‌های بیشتری داشته باشد (مثلاً دستورات if )، پیچیده‌تر است.

اندازه‌گیری پیچیدگی نوت‌بوک‌ها در هر git push راهی برای جلوگیری از ورود نوت‌بوک‌های بیش‌ازحد پیچیده به پایگاه کد است، این بسته می‌تواند پیچیدگی سیکلوماتیک برنامه‌های پایتون را اندازه‌گیری کند:

در دستور قبلی، ما فقط بخش هایی از نوت بوک را با پیچیدگی 3 یا بالاتر گزارش می‌کنیم. این کار به ما اجازه می‌دهد تا ساختارهای کنترل ساده به وجود بیاوریم.

اما هر چیزی پیچیده تر از این (مانند یک ساختار کنترل تودرتو)، علامت گذاری می شود:

مراقبت از ساختارهای داده قابل تغییر

بیشتر ساختارهای داده ای که برای دستکاری داده ها data manipulation استفاده می شوند قابل تغییر هستند، به این معنی که شما می توانید مقادیر اولیه را تنظیم کنید و بعداً آنها را تغییر دهید. به مثال زیر توجه کنید:

همانطور که در مثال قبلی می بینیم، ما یک چهارچوب داده (دیتا فریم) را با صفر مقداردهی کردیم اما سپس مقادیر را تغییر دادیم. در چنین قطعه کد کوتاهی، دیدن آنچه اتفاق می افتد آسان است: می دانیم که پس از دستکاری داده ها ، ستون zeros شامل یک ها می شود.

با این حال، اگر دستکاری داده ها در داخل توابع پنهان شوند، همین الگو باعث ایجاد مشکلاتی می شود. تصور کنید نوت بوک زیر را دارید:

در این مثال، یک تغییر در داخل یک تابع اتفاق افتاده است. تا زمانی که به سلولadd_one(df)  که دستکاری شده است برسید، حتی ممکن است به یاد نیاورید که add_one(df) ستون صفرها را تغییر داده است و خیال کنید  که df همچنان صفر است! اگر تعریف تابع در فایل دیگری وجود داشته باشد، پیگیری این دستکاری‌ها حتی پیچیده‌ترهم می‌شود.

دو راه برای جلوگیری از این نوع مشکلات وجود دارد. اولین مورد استفاده از توابع خالص است. توابع خالص توابعی هستند که هیچ گونه عوارض جانبی ندارند. مثلا اگر add_one را دوباره بنویسیم تا یک تابع خالص باشد به شکل زیر می‌شود:

به جای تغییر دیتا فریم ورودی  ( df)اینبار یک کپی جدید ایجاد می کنیم، آن را تغییر می دهیم ومجددا آن را برمی گردانیم:

یکی از نکاتی که در این رویکرد وجود دارد این است که در این حالت ما حافظه زیادی را هدر می دهیم. زیرا هر بار که یک تابع را روی یک دیتا فریم اعمال می کنیم، یک کپی ایجاد می کنیم. کپی بیش از حد داده ها می تواند سرعت مصرف حافظه را به شدت بالا ببرد. یک راه حلجایگزین این است که در مورد تغییرهای خود صریح باشیم و همه تبدیل ها را در یک ستون معین ودر یک مکان واحد نگه داریم:

مثال قبلی ستون zeros را تغییر می دهد اما به روشی متفاوت: add_one_to_column یک ستون را به عنوان ورودی می گیرد و مقادیر تغییر یافته را برمی گرداند. تغییرخارج از تابع به روشی صریح اتفاق می افتد: df[‘zeros’] = add_one_to_column(df[‘zeros’])  با نگاه کردن به این کد، می‌توانیم ببینیم که با اعمال تابع add_one_to_column در ستون zeros ، آن را تغییر می‌دهیم. اگر تبدیل‌های دیگری به ستون zeros داشته باشیم، باید آنها را در همان سلول یا حتی بهتر از آن در یک تابع نگه داریم. این رویکرد از نظر حافظه کارآمدتر است، اما از طرفی برای جلوگیری از بروز اشکالات باید بسیار مراقب باشیم.

بارگذاری مجدد خودکار کد از ماژول های خارجی

یکی از مواردی که ممکن است قبلاً امتحان کرده باشید این است که ابتدا یک تابع/کلاس را به یک نوت بوک وارد کنید، کد منبع آن را ویرایش کنید و دوباره آن را وارد کنید. متأسفانه، چنین راه حلی همیشه کار نمی کند. ایمپورت پایتون دارای سیستم کش است. هنگامی که چیزی را وارد می‌کنید، با وارد کردن مجدد ،پایتون  آن را از منبع جدید بارگیری نمی‌کند، بلکه از تابع/کلاس وارد شده قبلی استفاده می‌کند. با این حال، یک راه ساده برای فعال کردن بارگیری مجدد خودکار ماژول با افزودن کد زیر در بالای یک نوت بوک وجود دارد:

از آنجایی که این کار از امکانات بومی پایتون نیست، با چند ویژگی عجیب و غریب همراه است. اگر می‌خواهید درباره محدودیت‌های این رویکرد بیشتر بدانید، مستندات IPython را بررسی کنید.

تست واحد

با توجه به سرعتی که دانشمندان داده برای انجام کارها دارند (یعنی بهبود عملکرد مدل)، جای تعجب نیست که اغلب ما از آزمایش‌ها غافل می‌شویم. درحالی که اگر به نوشتن تست ها عادت کنید، سرعت توسعه شما را به شدت افزایش می دهد.

برای مثال، اگر در حال کار بر روی یک تابع برای تمیز کردن یک ستون در یک دیتا فریم هستید، می‌توانید به صورت تعاملی چند ورودی را آزمایش کنید تا بررسی کنید که آیا درست کار می‌کند یا خیر. پس از تست منوال برای اطمینان از کارکرد کد می‌توانید با خیال راحت‌تری ادامه دهید.  حتی ممکن است پس از مدتی، ممکن است نیاز باشد تا کد اصلی را تغییر دهید، پس لازم است ابتدا آزمایشات منوال را انجام دهید و سپس کار خود را ادامه دهید. درست است که این فرآیند تست منوال زمان زیادی را تلف می‌کند اما اگر همه موارد را آزمایش نکنید، یقنا در ادامه با مشکلات بسیاری مواجه خواهید شد.پس بهتر است تست‌های منوال را به‌عنوان تست واحد بنویسید تا بتوانید به سرعت آنها را باهر تغییر کد اجرا کنید.

مثلا اگر می خواهید process.py خود را آزمایش کنید. می توانید یک tests/test_process.py اضافه کنید:

و شروع به نوشتن تست های خود کنید. من معمولاً یک فایل در پوشه tests/  برای هر فایل در فهرست src/  با نام test_{module_name}.py  ایجاد می کنم. چنین قانون نام‌گذاری به من اجازه می‌دهد تا هنگام ایجاد تغییرات در کدها، بدانم باید کدام فایل آزمایشی را اجرا کنم.

فریمورک های زیادی برای اجرای تست ها وجود دارد، اما من به شما توصیه می کنم از pytest استفاده کنید. به عنوان مثال، فرض کنید ما در حال نوشتن یک تابع برای تمیز کردن یک ستون حاوی نام هستیم و از آن در نوت بوک خود به شکل زیر استفاده می کنیم:

پس از کاوش در داده‌ها، متوجه می‌شویم که چه نوع پردازشی را برای پاک کردن نام‌ها باید اعمال کنیم: کلمات را با حروف بزرگ بنویسیم، اگر نام در قالب “نام خانوادگی، نام” است، ترتیب را جابه‌جا کنیم، فضای خالی پیش یا پس را حذف کنیم و غیره. با چنین اطلاعاتی، می توانیم جفت (ورودی، خروجی) بنویسیم تا عملکرد خود را آزمایش کنیم:

در اینجا ما از دکوراتور pytest.mark.parametrize برای پارامتری کردن یک تست برای هر جفت (name, expected) استفاده می کنیم. تابع clean_name خود را با نام فراخوانی می کنیم و بررسی می کنیم که آیا خروجی آن با مورد انتظار ما برابر است یا خیر.

سپس برای اجرای تست های خود:

نوشتن تست‌ها کار بی‌اهمیت نیست، زیرا شامل فکر کردن به ورودی‌ها و خروجی‌های مناسب آن‌ها است. اغلب، کد پردازش داده بر روی ساختارهای داده پیچیده مانند آرایه ها یا دیتا فریم‌ها عمل می کند. توصیه من این است که در کوچکترین واحد داده ممکن، تست خود را انجام دهید. در مثال ما، تابع ما در value level عمل می کند. در موارد دیگر، شما ممکن است یک ترانسفورم را برای کل یک ستون و در پیچیده ترین حالت، به کل دیتا فریم اعمال کنید.

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

در صورت شکست، یک سشن دیباگینگ تعاملی شروع می شود که می توانیم از آن برای دیباگینگ خط لوله خود استفاده کنیم. برای اطلاعات بیشتر در مورد دیباگر پایتون، این مستندات را بخوانید.

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

و تست های خود را به این صورت اجرا کنید:

پس از اتمام کار، from pdb import set_trace; set_trace() حذف کنید. اگر به جای دیباگر، می خواهید یک جلسه معمولی پایتون را در هر خط مشخصی شروع کنید:

و تست های خود را به همین ترتیب فراخوانی کنید  ( pytest tests/ -s)

سازماندهی سکشن ها

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

  • Import statements
  • پیکربندی (به عنوان مثال، اتصالات پایگاه داده باز)
  • بارگذاری داده ها
  • محتوا

هر بخش محتوا یک ساختار استاندارد دارد:

  • علامت گذاری هدر ( # My notebook section)
  • شرح. یک یا دو خط خلاصه ای از آنچه این بخش در مورد آن است
  • akeaways. چند تیتر ازمهم ترین آموخته های این بخش
  • کد. برنامه واقعی که داده ها را پاکسازی، تجزیه و تحلیل یا ترسیم می کند.

استفاده از یک خط کد

هنگام بازسازی کدهای قدیمی، ممکن است از پاکسازی کامل آن غافل شویم. برای مثال، فرض کنید از بسته‌ای به نام some_plotting_package برای ایجاد نمودارهای سفارشی استفاده ‌کرده‌ایم، اما بعدا متوجه شدیم که آن چیزی نیست که به دنبال آن بوده‌ایم. یا شاید ممکن است سلول‌هایی را که چنین بسته‌ای را فراخوانی می‌کنند حذف کنیم، اما فراموش کنیم دستور import some_plotting_package را حذف کنیم. با نوشتن برنامه های گسترده تر، نادیده گرفتن این جزئیات کوچک آسان‌تر می‌شود. اگرچه ممکن است این مشکلات هیچ تأثیری بر اجرای برنامه نداشته باشند، اما یقینا تأثیر قابل توجهی بر خوانایی آن خواهند داشت.

اکثر ویرایشگرهای متن دارای پلاگین هایی هستند که مشکلات را شناسایی کرده و خطوط مشکل را علامت گذاری می کنند. در اینجا یک اسکرین شات از کد ویژوال استودیو وجود دارد که مشکلی را در خط اول نشان می دهد ( matplotlib وارد شده است اما استفاده نشده است):

متأسفانه، پلاگین های زیادی برای نوت بوک‌‌های upyter notebook/lab وجود ندارد.حتی  jupyterlab-flake8که  به نظر می رسد مطمئن ترین گزینه باشد، پروژه‌ای رها شده است.

من خودم بهترین روشی که برای لینت ‍Lint  نوت‌بوک‌هایم پیدا کرده‌ام این است که از فایل‌های .ipynb  استفاده نکنم و از فایل‌های .py استفاده کنم. jupytext یک پلاگین ژوپیتر را پیاده سازی می کند و به شما امکان می دهد فایل های .py را به عنوان نوت بوک باز کنید. برای مثال، فرض کنید که exploratory.ipynb دارید و می‌خواهید آن را پر کنید. ابتدا نوت بوک را با استفاده از jupytext به یک اسکریپت تبدیل کنید:

دستور بالا یک exploratory.py  ایجاد می کند که همچنان می توانید آن را مانند یک نوت بوک باز کنید. اگر از jupyter notebook  استفاده می کنید، این کار به طور خودکار اتفاق می افتد. اگر از jupyter lab استفاده می کنید، باید کلیک راست کنید -> Right Click -> Open With… -> Notebook

پس از ویرایش “نوت بوک” خود، می توانید آن را در هر ویرایشگر متنی که از لینتینگ linting پایتون پشتیبانی می کند باز کنید. من Visual Studio Code را توصیه می‌کنم زیرا راه‌اندازی آن برای Python linting رایگان و بسیار آسان است. توجه داشته باشید که گزینه های زیادی برای انتخاب وجود دارد اما توصیه من استفاده از flake8 است.

توجه داشته باشید که از آنجایی که فایل‌های .py از ذخیره خروجی فایل پشتیبانی نمی‌کنند، اگر فایل خود را ببندید، همه جداول و نمودارها حذف می‌شوند. با این حال، می‌توانید از ویژگی جفت‌سازی jupytext برای جفت کردن یک فایل .py  با یک فایل .ipynb استفاده کنید. در این حالت در حالی که شما فایل .py  را ویرایش می کنید، اما نوت بوک .ipynb  برای پشتیبان گیری از خروجی شما استفاده می کند.

استفاده از یک فرمت کننده خودکار کد

لینترها فقط محل مشکلات را نشان می دهند اما آنها را برطرف نمی کنند. در حالی که فرمت‌کننده‌های خودکار این کار را برای شما انجام می‌دهند و کد شما را خواناتر می‌کنند. پرکاربردترین فرمت کننده خودکار کد black است، اما گزینه های دیگری مانند yapf هم وجود دارد.

چند گزینه برای فرمت کردن خودکار فایل‌های .ipynb  وجود دارد (یک، دو، سه). من به شخصه هیچکدام از اینها را امتحان نکرده‌ام، بنابراین نمی توانم در مورد استفاده آنها نظری بدهم. روش پیشنهادی من همانی است که در بخش قبل توضیح داده شد: از jupytext برای باز کردن فایل‌های .py  به عنوان نوت‌بوک استفاده کنید، سپس با استفاده از Visual Studio Code، قالب‌بندی خودکار را برای آن فایل‌های .py اعمال کنید. برای دستورالعمل های مربوط به تنظیم قالب بندی در VS Code اینجا را کلیک کنید.

توجه داشته باشید که فرمت‌کننده‌های خودکار نیز همه مشکلاتی را که با flake8 شناسایی نمی‌شود را برطرف نمی‌کنند، بنابراین ممکن است همچنان به ویرایش دستی نیاز داشته باشید.

نوشتن نوت‌بوک‌های کوتاه تر

از آنجایی که نوت‌بوک‌ها به صورت تعاملی نوشته می‌شوند، ما اغلب تمایل داریم که نام‌های متغیر کوتاه که طبق قراردادهای دیکته شده کتابخانه‌هایی که از آن‌ها استفاده می‌کنیم است را به کار ببریم. من خودم نیز بیشتر از آن چیزی که فکر کنید این اشتباه را کرده ام و چنین کاری را انجام داده ام:

استفاده مجدد از نام متغیرها  خود به تنهایی منبع مهمی از خطاها است. هنگام توسعه تعاملی، ممکن است بخواهیم چند keystrokes را ذخیره کنیم و نام های کوتاهی را به اکثر متغیرها اختصاص دهیم. این کار اگرچه به جستجوی سریع منجر می‌شود  ، اما هر چه نوت‌بوک‌های ما طولانی‌تر باشند، احتمال بروز مشکلات بیشتر می‌شود. بهترین روش این است که نوت بوک های خود را به قطعات کوچکتر تقسیم کنیم تا احتمال عوارض جانبی را کاهش دهیم.

شکستن نوت‌بوک‌ها به چند قسمت آنقدرها هم که به نظر می‌رسد آسان نیست، زیرا باید نوت‌بوک‌هایی را به گونه‌ای تقسیم کنیم که بتوانیم یک قطعه را به قسمت بعدی متصل کنیم (یعنی دیتا فریم‌هایمان را یکبار ذخیره کنیم و در قسمت بعدی مجدد بارگذاری کنیم).این‌کار از آنجایی که کد قابل نگهداری بیشتری ایجاد می‌کند بسیار کمک کننده است.

تصمیم‌گیری در مورد اینکه چه زمانی خوب است که یک سلول جدید اضافه کنید و چه زمانی یک نوت بوک، امری بسیار ذهنی است، اما من یک سری قوانین سرانگشتی برای خود دارم که به این صورت است:

  • مجموعه داده های مختلف باید در یک نوت بوک متفاوت باشد
  • هنگام پیوستن به دیتا بیس، یک مجموعه جدید ایجاد کنید
  • یک نوت بوک برای تمیز کردن داده ها، دیگری برای رسم (یا تولید ویژگی در صورت انجام ML)

البته این بستگی به پیچیدگی پروژه شما دارد. اگر با یک دیتا بیس کوچک کار می کنید، ممکن است منطقی‌تر باشد که همه چیز را در یک نوت بوک نگه دارید، اما در صورتی که با دو یا چند منبع داده کار می کنید، بهتر است آن را تقسیم کنید.

اگر می‌خواهید در زمان الحاق چندین نوت‌بوک به یک خط لوله صرفه‌جویی کنید، Ploomber را امتحان کنید. این برنامه نه تنها برای نوشتن نوت‌بوک‌های کوتاه تر به شما کمک می‌کند، بلکه ویژگی های بسیار بیشتری مانند موازی سازی نوت بوک، ابزارهای دیباگینگ و اجرا در ابر نیز است.

کلام نهایی

نوشتن نوت‌بوک‌های تمیز تلاش زیادی می‌طلبد، اما مطمئناً ارزش وقتی که برای آن صرف می‌کنید را دارد. چالش اصلی نوشتن کد تمیز، دستیابی به تعادل سالم بین سرعت تکرار و کیفیت کد است. ما باید به دنبال تعیین حداقل سطح کیفیت در کد‌های خود باشیم و آن را به طور مداوم بهبود دهیم. با پیروی از این ده توصیه، می‌توانید نوت‌بوک‌های تمیزتری بنویسید که آزمایش و نگهداری از آن‌ها آسان‌تر باشد.

آیا شما  ایده دیگری در مورد بهبود کیفیت کد نوت بوک Jupyter داریدآن را با ما در میان بگذارید.

Screenshot-166

7 عامل مهم در انتخاب یک Framework یادگیری عمیق مناسب

 

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

آشنایی با کتابخانه‌های یادگیری عمیق پایتون

اما  اجازه دهید قبل از شروع بخش تجزیه و تحلیل،  با هر یک از آن‌ها به‌طور خلاصه آشنا شویم.

کتابخانه یادگیری عمیق کراس –  Keras

کراس  یک کتابخانه قدرتمند و در دسترس منبع باز برای شبکه عصبی و توسعه و ارزیابی مدل‌های یادگیری عمیق است. این کتابخانه ریاضی نمادین، به شما این  امکان می‌دهد مسائل مربوط به یادگیری عمیق و یادگیری ماشین را حل کنید.

هدف این ابزار انجام آزمایش‌های سریع با استفاده از یادگیری عمیق است. این برنامه  که در 27 مارس 2015 توسط Francois Chollet توسعه یافته است، در واقع یک API برنامه نویسی سطح بالا است.

کتابخانه پای تورچ – Pytorch

PyTorch یک کتابخانه یادگیری ماشین اوپن سورس است که به زبان Python و C++ نوشته شده است و به عنوان یک برنامه منبع باز برای دانلود در دسترس عموم قرار دارد. گروه تحقیقاتی فیس بوک این فناوری را در اکتبر 2016 توسعه داد تا در برنامه هایی مانند پردازش زبان طبیعی، بینایی کامپیوتری و موارد دیگر مورد استفاده قرار گیرد. این برنامه در مقایسه با سایر همتایانش از لحاظ سطح بالا و سطح پایین،  جایی بین TensorFlow و Keras قرار می‌گیرد.

کتابخانه تنسورفلو –  TensorFlow

این کتابخانه که به راحتی با C++، جاوا و سایر زبان‌های کد یکپارچه می‌شود،  ابزار جامعی را برای توسعه دهندگان، شرکت‌ها و … برای ساخت برنامه های کاربردی مبتنی بر یادگیری ماشین فراهم می‌کند. در این کتابخانه ریاضی نمادین، مسائل مربوط به  یادگیری عمیق و یادگیری ماشین حل می‌شود. کتابخانه تنسورفلو که در 9 نوامبر 2015 توسط گوگل ایجاد شده است، در برنامه نویسی به عنوان یک API سطح پایین شناخته می‌شود.

بررسی عوامل تأثیرگذار بر انتخاب Framework یادگیری عمیق مناسب

1. معماری- Architecture

آموزش مدل‌های بزرگ و پیچیده فرایندی زمان بر است، بنابراین سرعت پردازش برای مدل‌های بزرگ و پیچیده کمتر خواهد بود. PyTorch در مقایسه با Keras، معماری پیچیده‌تری دارد که می‌تواند منجر به خوانایی کمتر شود. برندگان رقابت در این بخش TensorFlow و PyTorch بودند که هر دو فریمورک های شبیه سازی سطح پایین عملی هستند که  سرعت و زمان بالایی دارند.

2.سرعت- Speed

سرعت Keras بالاتر از حداقل نیست و سرعت این framework در مقایسه با سایر framework ها کندتر است. TensorFlow و Pytorch هر دو با حداکثر سرعت کار می‌کنند که به نوبه خود باعث نمایش عملکرد بالاتری می‌شود.

3- سطح API ها- Level of APIs

API های Keras اجازه دسترسی به Theano و CNTK را فراهم می‌کنند، بنابراین Keras را می‌توان در هر دو پلتفرم اجرا کرد. اما به دلیل API سطح پایین PyTorch، این کتابخانه تنها از آرایه Array) ) پشتیبانی می‌کند. با این‌حال اخیراً پای تورچ توجه زیادی را به خود جلب کرده است و به یک راه حل ترجیحی برای تحقیقات دانشگاهی و برنامه های یادگیری عمیق که نیاز به بهینه سازی بیان سفارشی دارند تبدیل شده است. TensorFlow علاوه بر ارائه API های سطح پایین، API های سطح بالا را نیز ارائه می‌دهد.

4. مبتدی دوست- Beginner-Friendly

ویژگی نمونه سازی سریع در Keras بر این اساس طراحی شده است که مدل یادگیری عمیق را آسان کند. این برنامه دارای یک رابط کاربری بسیار مبتدی است که کاربران می‌توانند به راحتی شبکه های عصبی را مانند بلوک‌های لگو بسازند.

 فرایند مشکل یابی یا Debugging ارورهای پایتون به سادگی دیباگینگ کد پایتون است. مشکل یابی این خطاها را می‌توان با استفاده از هر یک از دیباگرهای محبوب پایتون انجام داد. دیباگینگ خطاها در Tensorflow با استفاده از ماژول‌های debugging  آن امکان پذیر است.

5.دیباگینگ – Debugging

کارکردن با Keras معمولاً ساده است و حین کار با آن احتمالاً با هیچ مشکلی مواجه نخواهید شد. با این حال، از آنجایی که سطوح انتزاعی بسیار زیادی در بک‌اند دارد، دیباگینگ آن اغلب می‌تواند دشوار باشد. با Pytorch می‌توانید راحت‌تر از Keras یا TensorFlow دیباگینگ کنید. فرآیند دیباگینگ در TensorFlow نیز می‌تواند چالش برانگیز باشد.

6.روند محبوبیت- Trends Popularity

شبکه‌های عصبی مبتنی بر هسته شامل لایه‌های کانولوشنال و کاربردی به طور گسترده توسط Keras استفاده می‌شوند و Keras بیشتر در شرکت هایی مانند Nvidia، Uber، Amazon، Apple و Netflix استفاده می‌شود. استفاده داخلی از گوگل و هم نرم افزاری که برای ثبت تصاویر به طور خودکار از آن استفاده می‌کند، در معروفیت آن مؤثر بوده است.  تنسورفلو توسط گوگل، لینکدین، اسنپ، AMD، بلومبرگ، پی پال و کوالکام، بسیاری از شرکت‌های دیگر استفاده می‌شود.

Keras با ماژول NN، ماژول بهینه و ماژول autograd خود از برنامه های گرافیکی پرقدرت پشتیبانی می‌کند و تمایز خودکار آن در شبکه‌های یادگیری عمیق باعث محبوبیت آن شده است. از جمله شرکت‌های بزرگی که از Pytorch استفاده می‌کنند می‌توان به فیس‌بوک، ولز فارگو، Salesforce، Genentech، Microsoft و JPMorgan Chase اشاره کرد.

7.دیتا بیس-  DataSet

از آنجایی که نسخه اصلی، Keras سرعت پایینی داشت و برای نمونه سازی سریع طراحی شده بود این فریم ورک برای پردازش مجموعه داده‌های بزرگ مناسب نیست. یکی از دلایلی که کراس در مجموعه داده‌های کوچک‌تر به خوبی کار می‌کند، سرعت اجرای آن سریع است.

در حالی که اگرچه  TensorFlow و PyTorch فریمورک‌های سطح پایینی هستند، اما به دلیل سرعت بالایی که دارند می‌توانند با مجموعه داده‌های بزرگ به خوبی کار کنند. تسک هایی با کارایی بالا روی یک مجموعه داده با حجم بالا را می‌توان به خوبی با این ابزارها انجام داد.

نتیجه

ما برای مقایسه این 3 فریمورک، پارامترهای مختلفی را بررسی کردیم و شاهد این بودیم که مثلاً PyTorch کاربرپسند و ساده‌تر است یا TensorFlow به دلیل API ناکارا چندان راضی‌کننده به نظر نمی‌رسد. از طرف دیگر درست است که Keras و TensorFlow دیوارهایی دارند که از آجر و ملات ساخته شده‌اند، اما دهانه‌های کوچکی برای برقراری ارتباط باقی می‌گذارند، در حالی که PyTorch محکم به پایتون متصل است و می‌توانید آن را در بسیاری از پلتفرم‌های مختلف به کار بگیرید. 

Screenshot-107

مقدمه ای بر یادگیری ماشینی با نوت بوک های ژوپیتر

اخیراً ، من روی نسخه ی دمو محاسبات پیشرفته‌ای کار می کردم که از یادگیری ماشینی برای تشخیص ناهنجاری ها در سایت یک کارخانه مورد استفاده قرار می‌گرفت. این نسخه دمو در واقع بخشی از طرح راه حل صنعتی هستند که در سال گذشته ارائه شده بودند. بر اساس مستندات GitHub نقشه ساخت یا بلوپرینت ها امکان اعلام مشخصاتی را که می تواند در لایه ها سازماندهی شود فراهم می کند و تمام اجزای مورد استفاده در لبه ساختارمرجع ، مانند سخت افزار ، نرم افزار ، ابزارهای مدیریت و تجهیز ابزار را مشخص می کند.

در ابتدای شروع پروژه ، من فقط درکی کلی از یادگیری ماشینی داشتم وحقیقتا دانش تخصصی انجام کار مفید با آن را نداشتم به همچنین اگرچه در مورد نوت بوک های ژوپیتر چیزهای زیادی شنیده بودم اما واقعاً نمی دانستم آنها دقیقا چی هستند و چگونه باید از آن‌ها استفاده کرد.

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

نوت بوک ژوپیتر چیست؟

نوت بوک های محاسباتی به عنوان نوت بوک های آزمایشگاهی الکترونیکی برای مستندسازی رویه ها ، داده ها ، محاسبات و یافته ها مورد استفاده قرار می‌گیرند محیط توسعه ژوپیتر یا به اصطلاح دفترچه ژوپیتر و یا نوت بوک ژوپیتر یک محیط محاسباتی تعاملی  است که یک محیط برنامه نویسی برای توسعه برنامه های کاربردی «علم داده» Data Science)  ) فراهم می کند.

نوت بوک ژوپیتر کد ‌های نرم افزاری، خروجی محاسباتی ، متن توضیحی و محتوای غنی(متنی که دارای کدهای معرفی کننده ی ایتالیک ، حروف سیاه و شکلهای دیگر حروف است)  را در یک سند واحد ترکیب می کنند. نوت بوک ها امکان ویرایش و اجرای کد در مرورگر و نمایش نتایج محاسبه را در لحظه  دارند. یک نوت بوک  با پسوند .ipynb ذخیره می شود. پروژه نوت بوک ژوپیتر  از ده ها زبان برنامه نویسی پشتیبانی می کند ، نام آن نشان دهنده پشتیبانی آن  از جولیا Ju)) و پایتون Python (Py),  و R است.

می توانید یک نوت بوک را با استفاده از یک سندباکس عمومی (سندباکس (Sandbox) محیطی است که  معمولا برای تست بخش‌های جدید یک نرم افزار یا اجرای ایمن نرم افزارها بدون اینکه محیط اصلی تحت تأثیر آن قرار بگیرد به کار می‌رود)  یا فعال کردن روی سرور خود مانند ژوپیتر هاب امتحان کنید. ژوپیتر هاب نوت بوک هایی را برای چندین کاربر ارائه می دهد که می‌تواند نمونه های متعددی از سرور نوت بوک ژوپیتر تک کاربره را ایجاد ، مدیریت و پروکسی  کند. در این مقاله ، ژوپیتر هاب  بر روی Kubernetes اجرا شده است.

داشبورد نوت بوک ژوپیتر

هنگامی که سرور نوت بوک برای اولین بار راه اندازی می شود ، یک برگه مرورگر جدید باز می شود که داشبورد نوت بوک را نشان می دهد. داشبورد به عنوان صفحه اصلی نوت بوک های شما عمل می کند. هدف اصلی آن نمایش بخشی از سیستم فایل در دسترس کاربر و ارائه نمای کلی از هسته های در حال اجرا ، پایانه ها و خوشه های موازی است. شکل 1 یک داشبورد نوت بوک را نشان می دهد.

شکل 1: داشبورد نوت بوک.

در ادامه با بخش های اجزای داشبورد نوت بوک ها آشنا خواهید شد:

برگه فایل ها Files tab

برگه Files نمای سیستم فایل را در اختیار کاربر قرار می دهد. این نما معمولاً ریشه در پوشه ای دارد که سرور نوت بوک در آن راه اندازی شده است.

افزودن نوت بوک- Adding a notebook

یک نوت بوک جدید می تواند با کلیک روی دکمه New ایجاد شود یا با کلیک روی دکمه بارگذاری،  بارگذاری شود.

برگه در حال اجرا- Running tab

برگه در حال اجرا نوت بوک هایی را که در حال حاضر برای سرور شناخته شده است را نمایش می دهد.

کار با نوت بوک ژوپیتر

هنگامی که یک نوت بوک باز می شود ، یک برگه مرورگر جدید ایجاد می شود که رابط کاربری نوت بوک را ارائه می دهد. اجزای رابط در بخشهای زیر توضیح داده شده است.

سرتیتر- Header

در بالای سند نوت بوک یک سربرگ وجود دارد که شامل عنوان دفترچه ، نوار منو و نوار ابزار است ، همانطور که در شکل 2 نشان داده شده است.

شکل 2: سرتیتر نوت بوک.

بدنه- Body

بدنه یک نوت بوک از سلول ها تشکیل شده است. سلولها را می توان به هر ترتیبی وارد و به دلخواه ویرایش کرد. محتویات سلولها در انواع زیر قرار می گیرند:

  • سلولهای مارک داون  Markdown : اینها حاوی متنی با قالب بندی نشانه گذاری ، توضیح کد یا حاوی سایر محتوای رسانه های غنی هستند.
  • سلول های کد Code cells  : اینها شامل کد اجرایی هستند.
  • سلول های خام Raw cells : این موارد زمانی مورد استفاده قرار می گیرند که نیاز به افزودن متن به صورت خام ، بدون اجرا یا تغییر باشد.

کاربران می توانند سلول های نشانه گذاری و متن را بخوانند و سلول های کد را اجرا کنند. شکل 3 نمونه هایی از سلول ها را نشان می دهد.

شکل 3: نمونه هایی از سلول ها.

ویرایش و اجرای سلول

رابط کاربری نوت بوک مودال است. این بدان معناست که صفحه کلید بسته به نوع حالت نوت بوک عملکرد متفاوتی دارد. یک نوت بوک دارای دو حالت است: ویرایش و فرمان.

هنگامی که یک سلول در حالت ویرایش است ، در قسمت ویرایشگر است  و دارای حاشیه سلول سبز ، همانطور که در شکل 4 نشان داده شده است . در این حالت ، شما می توانید مانند یک ویرایشگر متنی معمولی در سلول تایپ کنید.

شکل 4: یک سلول در حالت ویرایش.

هنگامی که یک سلول در حالت فرمان است ، دارای حاشیه سلول آبی است ، همانطور که در شکل 5 نشان داده شده است. در این حالت ، می توانید از میانبرهای صفحه کلید برای انجام کارهای نوت بوک و سلول استفاده کنید. به عنوان مثال ، فشار دادن Shift+Enter در حالت فرمان ، سلول فعلی را اجرا می کند.

شکل 5: یک سلول در حالت فرمان.

سلول های کد در حال اجرا

برای اجرای سلول کد:

روی هر نقطه در قسمت [] در سمت چپ بالای سلول کد کلیک کنید. با این کار سلول وارد حالت فرمان می شود.

Shift+Enter را فشار دهید یا Cell—> Run را انتخاب کنید.

سلول های کد به ترتیب اجرا می شوند. یعنی هر سلول کد تنها پس از اجرا شدن تمام سلول های کد قبل از آن اجرا می شود.

شروع کار با نوت بوک ژوپیتر

پروژه نوت بوک ژوپیتر  از بسیاری از زبان های برنامه نویسی پشتیبانی می کند. ما در این مثال از IPython استفاده می کنیم. این زبان مشابه پایتون است اما تجربه تعاملی بیشتری را ارائه می دهد. برای انجام محاسبات ریاضی مورد نیاز برای یادگیری ماشین به کتابخانه های پایتون زیر نیاز دارید:

  • NumPy  : برای ایجاد و دستکاری بردارها و ماتریس ها.
  • Pandas: برای تجزیه و تحلیل داده ها و درگیری و یا خراب کردن داده ها. پاندا داده هایی مانند فایل CSV یا پایگاه داده را می گیرد و از آن یک شی پایتون به نام DataFrame ایجاد می کند. دیتا فریم  ساختار داده مرکزی در API Pandas است و شبیه صفحه گسترده‌ای  به شرح زیر است:
  • DataFrame : داده ها را در سلول ها ذخیره می کند.
  • یک DataFrame ستونها (معمولاً) و سطرهای شماره گذاری شده را نامگذاری کرده است.
  • Matplotlib: برای تجسم داده ها.
  • اسکلرن Sklern: برای یادگیری تحت نظارت و بدون نظارت. این کتابخانه ابزارهای مختلفی را برای انطباق مدل model fitting ، پیش پردازش داده ها ، انتخاب مدل و ارزیابی مدل ارائه می دهد. دارای الگوریتم ها و مدلهای یادگیری ماشین داخلی به نام برآوردگر estimators است. هر برآوردگر را می توان با استفاده از روش برازش خود بر روی برخی داده ها نصب کرد.

استفاده از نوت بوک ژوپیتر برای یادگیری ماشین

در این مقاله ما از مدل MANUela ML به عنوان نمونه نوت بوک برای بررسی اجزای مختلف مورد نیاز برای یادگیری ماشین استفاده خواهیم کرد. داده های مورد استفاده برای آموزش مدل در فایل raw-data.csv قرار دارد.

این نوت بوک از روند کاری که در شکل 6 نشان داده شده است پیروی می کند.

شکل 6: گردش کار نوت بوک برای یادگیری ماشین.

مرحله 1: داده های خام را کاوش کنید

از یک سلول کد برای وارد کردن کتابخانه های مورد نیاز پایتون استفاده کنید. سپس ، فایل داده های خام (raw-data.csv  ) را به DataFrame با سری زمانی ، شناسه پمپ ، مقدار ارتعاش و برچسب نشان دهنده ناهنجاری تبدیل کنید. کد پایتون مورد نیاز در سلول 7 در شکل 7 نشان داده شده است.

شکل 7: وارد کردن کتابخانه ها و تبدیل داده های خام.

اجرای سلول یک DataFrame با داده های خام تولید می کند که در شکل 8 نشان داده شده است.

شکل 8: قاب داده با داده های خام.

اکنون DataFrame را تجسم کنید. نمودار بالا در شکل 9 زیر مجموعه ای از داده های ارتعاش را نشان می دهد. نمودار پایین داده های دارای برچسب دستی با ناهنجاری (1 = ناهنجاری ، 0 = طبیعی) را نشان می دهد. اینها ناهنجاری هایی هستند که مدل یادگیری ماشین باید آنها را  تشخیص دهد.

شکل 9: تجسم داده های خام و ناهنجاری ها.

قبل از تجزیه و تحلیل،  داده های خام باید تغییر شکل داده ، تمیز شوند و به فرمت های مناسب تر برای تجزیه و تحلیل تبدیل شوند. این فرایند را جمع آوری داده ها یا داده کاوی می نامند.

ما داده های سری زمانی خام را به قسمت های کوچکی تبدیل می کنیم که می تواند برای یادگیری تحت نظارت استفاده شود. شکل 10 کد نشان داده شده است.

شکل 10: ایجاد یک data frame جدید.

ما می خواهیم داده ها را به یک DataFrame جدید به قسمت های با طول 5 تبدیل کنیم. شکل 11 نمونه ای از مجموعه داده های سری زمانی را نشان می دهد.

شکل 11: نمونه ای از داده های سری زمانی.

اگر داده های نمونه خود را به قسمت هایی با طول = 5 تبدیل کنیم ، به نتایج مشابه شکل 12 می رسیم.

شکل 12: data frame  جدید با قسمت ها.

اکنون با استفاده از کد شکل 13  داده های سری زمانی خود را چند قسمت می‌کنیم.

شکل 13: تبدیل داده ها به چند قسمت

شکل 14 داده ها را با قسمت هایی به طول 5 و برچسب در ستون آخر بررسی می کند.

شکل 14: قسمت هایی به طول 5 و برچسب در ستون آخر.

توجه: در شکل 14 ، ستون F5 آخرین مقدار داده است ، در حالی که ستون F1 قدیمی ترین داده ها برای یک قسمت معین است. برچسب L نشان می دهد که آیا ناهنجاری وجود دارد یا خیر.

داده ها اکنون برای یادگیری تحت نظارت آماده است.

مرحله 2: ویژگی و ستون های هدف

مانند بسیاری از کتابخانه های یادگیری ماشین ، Sklearn به ستون های ویژگی جداگانه  (X) و هدف  ( Y) نیاز دارد. مطابق شکل 15 داده های شما را به ستون های ویژگی و هدف تقسیم می کند.

شکل 15: تقسیم داده ها به ستون های ویژگی و هدف.

مرحله 3: آموزش و آزمایش مجموعه داده ها

یک عمل خوب این است که مجموعه داده های خود را به دو زیر مجموعه تقسیم کنید: یکی برای آموزش یک مدل و دیگری برای آزمایش مدل آموزش دیده.

هدف ما ایجاد مدلی است که به خوبی به داده های جدید تعمیم داده شود. مجموعه آزمایشی ما به عنوان نماینده داده های جدید عمل می کند. همانطور که در شکل 16 نشان داده شده است ما مجموعه داده ها را به 67 درصد برای مجموعه های آموزشی و 33 درصد برای مجموعه آزمایش تقسیم کرده‌ایم.

شکل 16: تقسیم داده ها به مجموعه داده های آموزشی و آزمایشی.

ما می توانیم مشاهده کنیم که میزان ناهنجاری برای هر دو مجموعه تمرین و آزمون مشابه است. یعنی مجموعه داده ها نسبتاً مساوی تقسیم شده است.

مرحله 4: آموزش مدل سازی

ما آموزش مدل را با الگوریتم درخت تصمیم‌گیری طبقه بندی شده DecisionTreeClassifier انجام می دهیم. درخت تصمیم گیری یک روش یادگیری تحت نظارت است که برای طبقه بندی و رگرسیون استفاده می شود. هدف ایجاد مدلی است که ارزش متغیر هدف را با یادگیری قوانین تصمیم گیری ساده که از ویژگی های داده استنباط می شود ، پیش بینی کند.

DecisionTreeClassifier کلاسی است که طبقه بندی چند کلاسی را بر روی یک مجموعه داده انجام می دهد ، اگرچه در این مثال ما از آن برای طبقه بندی در یک کلاس واحد استفاده کرده ایم. DecisionTreeClassifier دو آرایه به عنوان ورودی می گیرد: یک آرایه X به عنوان ویژگی و یک آرایه Y به عنوان برچسب. پس از نصب ، می توان از مدل برای پیش بینی برچسب مجموعه داده های آزمایش استفاده کرد. شکل 17 کد ما را نشان می دهد.

شکل 17: آموزش مدل با DecisionTreeClassifier.

ما می توانیم ببینیم که مدل از نظر دقت نمره بالایی را کسب کرده است.

مرحله 5: مدل را ذخیره کنید

مدل را ذخیره کرده و مجدداً بارگذاری کنید تا مطمئن شوید که کار می کند ، همانطور که در شکل 18 نشان داده شده است.

شکل 18: ذخیره مدل.

مرحله 6: استنباط با مدل

اکنون که مدل یادگیری ماشین را ایجاد کرده ایم ، می توانیم از آن برای استنباط در داده های زمان واقعی استفاده کنیم.

در این مثال ، ما از Seldon برای ارائه مدل استفاده می کنیم. برای اینکه مدل ما تحت سلدون اجرا شود ، ما باید کلاسی ایجاد کنیم که متد پیش بینی داشته باشد. روش پیش بینی می تواند یک آرایه NumPy را دریافت کرده و نتیجه پیش بینی را به صورت زیر بازگرداند:

  • یک آرایه NumPy
  • لیستی از مقادیر
  • یک رشته بایت

کد ما در شکل 19 نشان داده شده است.

شکل 19: استفاده از سلدون برای ارائه مدل یادگیری ماشین.

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

شکل 20: استنتاج با استفاده از مدل.

ما می توانیم ببینیم که مدل برای نتیجه گیری نمره بالایی را کسب کرده است.

حرف اخر

برای تجربه این محیط جذاب میتوانید از طریق لینک زیر اقدام کنید:

خرید سرویس ژوپیتر نوت بوک

Screenshot-83

ژوپیتر لب JupyterLab جدید منتشر شد

مفتخریم به اطلاع شما برسانیم که در حال حاضر نسخه ژوپیتر لب  بتا در دسترس کاربران قرار گرفته است , رابط کاربری مبتنی بر وب نسل بعدی ژوپیتر لب برای استفاده روزانه منتشر شده است. (می‌توانید از طریق Binder  برای نصب آن اقدام کنید). ژوپیتر لب  در حقیقت یک محیط توسعه تعاملی است که کار با نوت بوک ، کد‌ها و داده‌ها را میسر و به مراتب آسان‌تر می‌کند.

روند تکامل ژوپیتر نوت‌بوک

پروژه ژوپیتر جهت توسعه نرم‌افزارهای Open Source یا منبع باز ، استاندارد‌های باز ( (Open standard) و خدمات محاسبات تعاملی و قابل تکرار کاربرد دارد. پروژه اصلی ژوپیتر نوت‌ بوک در ابتدا در سال 2011 و به منظور ایجاد روایت‌های محاسباتی قابل تکرار ایجاد شد. ژوپیتر نوت‌بوک به  کاربران اجازه می‌دهد  تا اسنادی که شامل live code  هستند  را با متن روایی ، معادلات ریاضی ، تجسم ، کنترل‌های تعاملی و سایر خروجی‌های غنی مدیریت کند و به اشتراک بگذارد. ژوپیتر همچنین بلوک‌های اساسی مانند مرورگر فایل ، پایانه‌ها و ویرایشگر متن را برای محاسبه تعاملی با داده‌ها ایجاد می‌کند.

ژوپیتر نوت ‌بوک به دلیل رشد سریع علم داده (Data Science) ) و یادگیری ماشینی  و افزایش محبوبیت نرم‌افزارهای منبع باز در شرکت‌ها یا دانشگاه‌ها بسیار محبوب شده است.

  • امروزه میلیون‌ها کاربر در بسیاری از حوزه‌ها از علم داده و یادگیری ماشینی گرفته تا موسیقی و آموزش از ژوپیتر نوت‌بوک استفاده می‌کنند و  جامعه بین‌المللی ژوپیتر نوت‌بوک تقریباً شامل تمامی کشورهای جهان می‌شود.
  • ژوپیتر نوت‌بوک  در حال حاضر از بیش از 100 زبان برنامه‌نویسی توسعه یافته پشتیبانی می‌کند 
  • بیش از 1.7 میلیون نوت بوک عمومی ژوپیتر در GitHub میزبانی شده است. نویسندگان ژوپیتر نوت‌بوک را همراه با تحقیقات علمی ، مجلات دانشگاهی ، روزنامه نگاری داده ، دوره‌های آموزشی و کتاب‌های مخصوص منتشر می‌کنند.

ناگفته نماند که  نرم‌افزارهای دیگر مانند اجرای کد از فایل‌های متنی به صورت تعاملی با نوت بوک با چالش‌هایی نیز روبرو شده است و عملاً سفارشی سازی و گسترش نوت بوک ژوپیتر کلاسیک که بر اساس فناوری‌های وب  سال 2011 ساخته شده است کمی دشوار است.

ژوپیتر لب  در دسترس است

ژوپیتر لب یک محیط توسعه تعاملی برای کار با نوت بوک ها ، کد و داده است. مهم‌تر از همه ، ژوپیتر لب از نوت بوک های ژوپیتر پشتیبانی کاملی  می‌کند. علاوه بر این ، ژوپیتر لب  این امکان را برای شما فراهم می‌کند که از ویرایشگرهای متن ، پایانه‌ها ، نمایشگرهای داده و سایر اجزای سفارشی  سازی درکنار نوت بوک ها استفاده کنید.

ژوپیتر لب سطح بالایی از یکپارچگی بین نوت بوک ها ، اسناد و فعالیت‌ها را ایجاد می‌کند.  مثل :

  • کشیدن و رها کردن (درگ اند دراپ Drag-and-drop ) برای مرتب سازی مجدد سلول‌های نوت بوک و کپی آن‌ها بین نوت بوک ها.
  • اجرای کدها به صورت تعاملی از فایل‌های متنی (.py ، .R ، .md ، .tex ، و غیره)
  • با اتصال یک کنسول کد به یک هسته نوت بوک می‌توانید کدها را به صورت تعاملی و بدون درهم ریختگی جستجو کنید.
  • امکان ویرایش فرمت‌های محبوب مانند Markdown ، JSON ، CSV ، Vega ، VegaLite و موارد دیگر با پیش نمایش زنده  

بیش از سه سال است که ژوپیتر لب با بیش از 11000 تعهد و 2000 نسخه از بسته‌های npm و پایتون در حال ساخت است. همچنین علاوه بر توسعه دهندگان اصلی ، بیش از 100 مشارکت کننده از جامعه برنامه نویسی ، به ساخت ژوپیتر لب کمک کرده اند.

برای شروع ، مستندات ژوپیتر لب را برای  بررسی دستورالعمل‌های نصب و راه‌حل  حتماً مطالعه کنید و  یا از JupyterLab with Binder استفاده کنید. همچنین می‌توانید از ژوپیتر هاب برای استفاده  بهتر از ژوپیتر لب بهره‌ بگیرید.

امکان سفارشی سازی ژوپیتر لب

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

  • همچنین پلاگین های دیگر می‌توانند در موارد زیر نیز به شما کمک کنند:
  • ارائه موضوعات جدید ، ویرایشگران فایل و بینندگان یا ارائه‌دهندگان خروجی‌ها در نوت بوک ها.
  • افزودن موارد منو ، میانبرهای صفحه کلید یا گزینه‌های تنظیمات پیشرفته
  • ارائه یک API برای سایر برنامه‌های افزودنی

برنامه‌های افزودنی ایجاد شده توسط انجمن در GitHub با موضوع ژوپیتر اکستنشن  به صورت اختصاصی برچسب گذاری شده‌اند و در حال حاضر شامل نرم‌افزار مدیریت فایل (GeoJSON ، FASTA و غیره) ، ادغام Google Drive ، مرورگر GitHub و پشتیبانی ipywidgets است.

اکستنش های ژوپیتر لب

در حالی که بسیاری از کاربران ژوپیتر لب افزونه‌های اضافی را نصب می‌کنند، شاید برخی از شما بخواهید اکستنش  اختصاصی خود را ایجاد کنید. API اکستنش ژوپیتر لب در طول سری انتشار بتا در حال تکامل است و در JupyterLab 1.0 تثبیت می‌شود. برای ساخت اکستنش های اختصاصی ژوپیتر لب لازم است به راهنمای توسعه دهنده ژوپیتر اکستنش و قالب‌های افزونه TypeScript یا JavaScript مراجعه کنید.

PhosphorJS، یک کتابخانه جدید جاوا اسکریپت برای ایجاد برنامه‌های کاربردی وب با قابلیت توسعه، عملکرد بالا و رومیزی توسعه یافته  برای ژوپیتر لب ساخته است که از فناوری‌های جاوا اسکریپت مدرن مانند TypeScript ، React ، Lerna Yarn و webpack استفاده می‌کند. آزمایش‌های واحد ، مستندات، استانداردهای برنامه نویسی سازگار و تحقیقات تجربه کاربری همه و همه برای  ارائه برنامه‌ای با کیفیت بالا لحاظ شده است.

حرف اخر

با قابلیت هایی جذابی که ژوپیتر لب دارد توجه همه را به خود جلب می‌کند . در این مقاله یکسری از ویژگی های جذاب ژوپیتر لب را با هم مرور کردیم برای اشنایی بیشتر با سایر این ویژگی ها باما همراه باشید.

Screenshot-57

10 دلیلی که شما را متقاعد می‌کند از JupyterLab برای کدنویسی علم داده استفاده کنید

مرور کلی

JupyterLab یک محیط کدنویسی فوق العاده برای انجام کارهای مربوط به علم داده می‌باشد‍‍.این 10 دلیل افراد را قانع می‌کند که برای کدنویسی علم داده به جای نوت‌بوک‌های Jupyter از JupyterLab استفاده کنند.

با Jupyter اخت شده‌اید؟ زمان آن رسیده که به JupyterLab روی بیاورید!

از برنامه‌نویسان پایتون بپرسید که کدام محیط کدنویسی را ترجیح می‌دهند، جواب همواره نوت‌بوک‌های Jupyter خواهد بود. صادقانه زمانی که در مورد علم داده صحبت می‌کنیم Jupyter بخشی جدایی‌ناپذیر است. ما پذیرفته‌ایم که این بهترین محیط کدنویسی پایتون است. حتی من هم فریب این طرز فکر را خورده بودم.

اجازه دهید حرفی که چندی پیش یکی از مربیانم در حوزه‌ی علم داده به من گفت را با شما به اشتراک بگذارم – “وقت آن رسیده که از نوت‌بوک‌های Jupyter گذر کنیم، چیزی بهتر از آن وجود دارد”. غافلگیر شدم. بهتر از نوت‌بوک‌های Jupyter؟  من اولین گام‌های خود را در علم داده به کمک Jupyter برداشتم، چطور می‌توانستم از آن عبور کنم؟

حالا محیط کدنویسی جایگزین چه هست؟ JupyterLab که ارتقا یافته است. Jupyter تا آنجا که می‌دانیم با ارتقاهایی که شدیدا به آن نیاز بود و با وجود تمام ویژگی‌های خوب گذشته به JupyterLab تبدیل شده است و باور کنید که شما عاشق کار کردن با JupyterLab برای انجام کارهای علم داده خواهد شد.

بنابراین در این مقاله، من 10 دلیل به شما ارائه می‌کنم که باعث می‌شود بخواهید بلافاصله به JupyterLab کوچ کنید.

اگر در صنعت علم داده تازه‌ وارد هستید یا پیش از این هیچوقت از Jupyter استفاده نکرده‌اید، پیشنهاد می‌کنم که این مقاله را تا انتها بخوانید چرا که معرفی خوبی برای نوت‌بوک‌های Jupyter محسوب می‌شود. همچنین، شما باید این دوره‌ی جذاب و رایگان در مورد ترفند‌ها، راهنمایی‌ها و فوت‌وفن‌های علم داده را مشاهده کنید.

فهرست مطالب

دلیل #1 – همه‌چیز زیر یک سقف

دلیل #2 – طرح‌بندی انعطاف‌پذیر

دلیل #3 – بازآرایی سلول‌ها

دلیل #4 – کپی کردن سلول‌ها بین نوت‌بوک‌ها

دلیل #5 – دفترچه‌های یکسان، دیدگاه‌های بیشتر

دلیل #6 – کنسول‌های کد

دلیل #7 – تم‌ها همه‌جا

دلیل #8 – اجرای کد از یک فایل متنی

دلیل #9 – پیش‌نمایش همزمان برای Markdown

دلیل#10 – تغییر آسان به نمایش کلاسیک نوت‌بوک

دلیل #1 – همه‌چیز زیر یک سقف

آیا می‌دانستید که نوت‌بوک کلاسیک Jupyter پشتیبانی برای ویرایش متن و ترمینال بعلاوه‌ی نوت‌بوک‌های محبوب را ارائه می‌دهد؟ بسیاری از دانشمندان علم داده از این نکته بی‌خبر هستند! اما این تقصیر ما نیست چرا که این ویژگی‌ها یکپارچه نبوده و لذتی در استفاده از آنها وجود نداشت. صادقانه، احساس می‌شد که آدم با سه نرم‌افزار متفاوت کار می‌کند، نه یک نرم‌افزار. اما به لطف JupyterLab کار کردن با این ویژگی‌های متفاوت تجربه‌ی بسیار بهتری را برای شما به ارمغان خواهد آورد.

JupyterLab نوت‌بوک‌های کلاسیک، ویرایشگر متن، ترمینال و نمایشگر راهنما را زیر یک سقف آورده است! این یک تجربه‌ی یکپارچه است که شما عاشقش خواهید شد. JupyterLab نیز از دیگر فرمت‌های فایل برای نمایش jpeg، pdf، CSV و دیگر فرمت‌ها پیشتیبانی می‌کند.

دلیل #2 – طرح‌بندی انعطاف‌پذیر

اما مشاهده‌ی بسیاری از این پنجره‌ها می‌تواند طاقت‌فرسا باشد. خب به همین دلیل است که JupyterLab با طرح‌بندی انعطاف‌پذیر ارائه شده است که می‌توانید فضای کاری خود را به هر نحوی که دوست دارید سازماندهی کنید. تمام آنچه که نیاز است انجام دهید کشیدن (drag)، انداختن (drop) و تغییر سایز تب‌ها به هر نحوی که می‌خواهید است. این به شما اجازه می‌دهد که همزمان با چندین تب به آسانی کار کنید:

JupyterLab یک نوار کناری در سمت چپ که قابلیت جمع شدن دارد را ارائه می‌دهد که شامل برخی از تب‌هایی است که بیشترین استفاده را داشته‌اند مثل مرورگر‌های فایل، کرنل‌های در حال اجرا و پالت فرمان (command palette) که کار را برای شما بسیار کارآمدتر می‌کند:

JupyterLab: نوار کناری

دلیل #3 – بازآرایی سلول‌ها

به عنوان یک دانشمند علم داده، اغلب کار و نتایج خود را در نوت‌بوک‌های Jupyter ارائه می‌دهم. و معمولا در آخر باید سلول‌های خود را بازآرایی کنیم تا برای مخاطبان خود مفهوم باشد. در چنین وقت‌هایی است که آرزو می‌کنیم یک عامل ذاتی در Jupyter وجود داشت که به ما اجازه می‌داد به راحتی سلول‌ها را هر کجا که می‌خواهیم بکشیم و بیندازیم (drag and drop) به جای آنکه از روش قدیمی برش و چسباندن (copy and paste) استفاده کنیم. خب اکنون در JupyterLab این قابلیت وجود دارد.

می‌توانید سلول کد را بکشید و بیندازد و هر کجا که خواستید قرار دهید، که کار بازآرایی را مثل آب خوردن کرده است. اکنون کار شما مورد ستایش بیشتری قرار خواهد گرفت چرا که نوت‌بوک‌های شما ظاهر فوق‌العاده‌ای دارد و بیش از پیش مفهومی است.

دلیل #4 – کپی کردن سلول‌ها بین نوت‌بوک‌ها

کشیدن و انداختن سلول در یک نوت‌بوک یک چیز است، اما انجام همین کار بین نوت‌بوک‌های مختلف بطور کلی یک چیز دیگر است. JupyterLab  به شما اجازه می‌دهد که سلول‌ها را تنها با گزینه‌ی کشیدن و انداختن از یک نوت‌بوک به نوت‌بوک دیگر کپی کنید.

دلیل #5 – نوت‌بوک‌های یکسان، نمایش‌های بیشتر

بعضی اوقات کار کردن با نوت‌بوک‌های طولانی آزاردهنده است، مخصوصا زمانی که می‌خواهید بخش‌های مختلف نوت‌بوک را بطور همزمان وارسی کنید. اینجاست که عملکرد چند نمایشی به کار می‌آید. اکنون می‌توانید چندین نمایش از یک نوت‌بوک را در JupyterLab  بصورت کنار هم برای مقایسه داشته باشید.

نه تنها می‌توانید یک نمایش جدید ایجاد کنید، بلکه هر تغییری که در هر یک از نمایش‌ها ایجاد کنید در تمام آنها منعکس می‌شود و در نوت‌بوک ذخیره خواهد شد! من این عملکرد را هنگام انتخاب ستون‌های مشخصی از فریم داده (dataframe) کاربردی می‌دانم اما اسم دقیق آنها را به یاد نمی‌آورم. بنابراین، به جای چاپ فریم‌داده بصورت مکرر، فقط فریم‌داده را با یک نمایش جداگانه باز می‌کنم. با وجود این ویژگی دیگر لازم نیست کد‌های تکراری را در حالیکه اطلاعات ضروری را همزمان مشاهده می‌کنم بنویسم – با یک سنگ دو نشان زدن!

دلیل #6 – کنسول‌های کد

همه‌ی ما کنسول‌های کد را بخاطر سادگی‌ای که ارائه‌ می‌دهند دوست داریم. می‌خواهید قسمتی از کد را امتحان کنید یا بررسی کنید که چگونه عمل می‌کند؟ از کنسول‌های کد استفاده کنید. آنها بخاطر تعاملی بودن جایی برای تست کردن هستند.

یکی از دلایلی که هنگام استفاده از کنسول‌های کد در JupyterLab دوست دارم این است که می‌توانید از آنها به عنوان log محاسباتی که در نوت‌بوک انجام داده‌اید استفاده کنید. این ویژگی  هنگامی که می‌خواهید به تارخچه‌ی کد خود نگاهی بیندازید کاربردی می‌باشد. تمام آنچه که باید انجام دهید کلیک‌راست در هر جایی از نوت‌بوک و انتخاب New Console برای نوت‌بوک است. سپس در جهت کنسول جدید حرکت کرده و Show Kernel Activity را انتخاب کنید و تمام. حالا تمام logها برای نوت‌بوک شما در کنسول ذخیره خواهد شد.

دلیل #7 – تم‌ها همه‌جا

چه کسی تم‌ها را دوست ندارد؟ JupyterLab تم داخلی تیره برای نوت‌بوک دارد، چیزی که همه‌ی ما آرزویش را دارید مخصوصا زمانی که آخر شب‌ها زیر نور کم در حال کار کردن هستیم. اما Jupyter در اینجا متوقف نمی‌شود. آنها نه تنها برای ویرایشگر‌های متن، بلکه برای ترمینال‌ها هم تم دارند. آنها حقیقتا می‌خواهند که شما با هر آنچه که در حال کار کردن با آن هستید راحت باشید.

دلیل #8 – اجرای کد از یک فایل متنی

می‌خواهید یک فایل متنی را با بخشی از یک کد که در آن نوشته شده است به اشتراک بگذارید؟ قبل از ارسال دوباره بررسی کنید – یک کد باگ‌ دار تجربه‌ی پایداری را به ارمغان نمی‌آورد. JupyterLab  به شما اجازه می‌دهد که برای فایل متنی یک کنسول بسازید. از اینجا شما می‌توانید به سادگی بخشی از کد خود را در فایل متنی هایلایت کنید، Shift + Enter را فشار داده و بررسی کنید که کار می‌کند یا نه:

دلیل #9 – پیش‌نمایش همزمان برای Markdown

اغلب اوقات می‌خواهید پروژه‌ی علم داده‌ی خود را با گروه کاری به اشتراک بگذارید و در این مواقع است که برای مستند سازی کار خود به فایل markdown روی می‌آورید.

فایل‌های markdown بخاطر تمام انعطاف‌پذیری و عملکردی که ارائه می‌دهند عالی هستند. اما در Jupyter کار کردن با آنها کمی خسته‌کننده می‌شود، هنگامی که باید سلول خود را دوباره و دوباره اجرا کنید فقط برای اینکه ببینید فایل شما چطور به نظر می‌رسد یا اینکه آیا ترکیب درست را به کار برده‌اید یا نه.

برای غلبه بر این مشکل، JupyterLab به شما اجازه می‌دهد که فایل markdown خود را همزمان با کار کردن با آن از پیش رویت کنید. این نه تنها بسیار کارآمدتر است بلکه همچنین کار کردن با یک فایل markdown را لذت‌بخش می‌کند.

دلیل #10 – تغییر آسان به نمایش کلاسیک نوت‌بوک

برای اضافه کردن این ویژگی آخر کمی بی‌میل بودم چون نمی‌خواهم به کار کردن با Jupyter برگردید. اما می‌فهمم که برای برخی از شما سخت است که از چیزی که سفر علم داده‌ی خود را با آن شروع کرده‌اید دل بکنید.

بنابراین، برای روزها که دلتنگ کار کردن با نوت‌بوک‌های خوب و قدیمی Jupyter می‌شوید، راهی خوب و آسان برای بازگشت به محیط کاری قدیمی وجود دارد. تنها کاری که باید انجام دهید این است که /lab در URL را با /tree جایگزین کنید.

حرف اخر

در این مقاله ما متوجه ویژگی های منحصر به فرد ژوپیتر لب از جمله تجربه یک پارچه، طرح بندی انعطاف پذیر، باز‌آرایی سلول‌ها، کپی کردن سلول ها بین نوت بوک ها و … اشنا شدیم تا به انتخاب بهتری برسیم .

آیا در یادگیری عمیق به GPU احتیاج داریم؟

به نظر می‌رسد در یادگیری عمیق همه استفاده از GPU را پیشنهاد می‌کنند، اما GPU چیست؟ می‌توان بدون آن یادگیری عمیق انجام داد؟ و اینکه دقیقا به درد چه کسی می‌خورد؟

هر متخصص علم داده یا علاقه‌مند به یادگیری ماشین که تلاش‌ می‌کند عملکرد مدل های درحال آموزش را فراهم کند در یک مقطعی از زمان به سرش می‌زند که درجه های مختلفی از تاخیر(lag) پردازش را تجربه کند. کار هایی که چند دقیقه طول می‌کشند و آموزش کمتری احتیاج دارند ممکن است درصورت بزرگتر شدن مجموعه داده چندین ساعت طول بکشد (یادر برخی موارد چندین هفته).

اما GPU ها چه هستند؟ چه تفاوتی با CPU دارند؟ آیا من در پروژه های یادگیری عمیق خود به آن احتیاج دارم؟

اگر تا به حال این سوالات را از خود پرسیده اید، به خواندن ادامه دهید…..

هر متخصص علم داده یا علاقه مند به یادگیری حداقل یک بار درطول زندگی خود شنیده است که یادگیری عمیق به سخت افزار زیادی نیاز دارد. برخی افراد روز ها برای آموزش مدل های ساده یادگیری ماشین روی لپتاپ خود وقت صرف می کنند(عموما بدون GPU) باعث میشود این تصویر پدید آید که انجام یادگیری عمیق به سیستم های بزرگ احتیاج دارد. این اتفاق باعث ایجاد افسانه ای پیرامون یادگیری عمیق شده است که مانعی برای تازه وارد‌ها ایجاد می‌کند. در هر کتابی که در سال‌ها‌ی اخیر به آن رجوع کرده ام مولف همیشه به نکته زیر اشاره کرده است:

یادگیری عمیق برای تداوم عملکرد به قدرت محاسبه بسیار زیادی نیاز دارد.

اما من مرکز داده ای در اختیار ندارم و زمانی که اولین مدل یادگیری عمیق خود را روی یک لب تاب بزرگ ساختم، می‌دانستم که این اتفاق نظر یا اشتباه است یا تنها بخشی ازحقیقت را نشان می‌دهد. نیازی نیست که کل گوگل را زیر و رو کنید تا به یک متخصص یادگیری عمیق تبدیل شوید.

چرا برای یادگیری عمیق به سخت افزار بیشتر نیاز داریم؟

برای هرشبکه عصبی، فاز آموزش مدل یادگیری عمیق به منابع بسیاری نیاز دارد. در هنگام آموزش، شبکه‌ی عصبی داده‌ی ورودی را دریافت می‌کند، سپس در لایه‌های پنهان با استفاده از وزنه‌هایی که هنگام آموزش تنظیم شده‌اند پردازش می‌شوند و بعد یک پیش‌بینی بیرون می‌دهد. وزنه‌ها برای یافتن الگو‌ها تنظیم شده‌اند تا پیش‌بینی‌های بهتری انجام دهند. همه‌ی این عملیات‌ها اساسا ضرب ماتریس‌ها هستند. یک ضرب ماتریس ساده را می‌توان به کمک عکس زیر نمایش داد: در یک شبکه‌ی عصبی، (ما می‌توانیم) آرایه‌ی اول درونداد شبکه‌ی عصبی است در حالیکه آرایه‌ی دوم وزن آن را تشکیل می‌دهد.

آسان است، نه؟

بله، اگر شبکه‌ی عصبی شما حدودا 10,000 یا حتی 100,000 پارامتر داشته باشد. یک کامپیوتر همچنان می‌تواند این کار را در عرض چند دقیقه یا حداکثر چند ساعت انجام دهد. اما اگر شبکه‌ی عصبی شما بیش از 10 میلیارد پارامتر داشت چه؟ سال‌ها طول می‌کشد تا با استفاده از رویکرد سنتی این نوع سیستم‌ها را آموزش داد. کامپیوتر شما احتمالا پیش از آنکه به یک دهم راه رسیده باشید،‌ از کار می‌افتد.

به گفته‌ی یک دانشجوی دکترا در دانشگاه رایس: “یک شبکه‌ی عصبی که درون‌داد جستجوی را دریافت می‌کند و از 100 میلیون برون‌داد یا محصول پیش‌بینی می‌کند بطور معمول به 2,000 پارامتر برای هر محصول ختم می‌شود. پس اگر آن‌ها را ضرب کنید، اکنون لایه‌ی نهایی شبکه‌ی عصبی 200 میلیارد پارامتر خواهد داشت. و من کار پیچیده‌ای انجام نداده‌ام. من دارم در مورد یک مدل شبکه‌ی عصبی بسیار ساده صحبت می‌کنم.”

راهی برای آموزش سریع‌تر مدل‌های یادگیری عمیق

مدل‌های یادگیری عمیق می‌توانند با پیش بردن همزمان تمام عملیات‌ها در یک زمان به جای آنکه بصورت متوالی انجام شوند، سریع‌تر آموزش ببینند. شما می‌توانید با استفاده از یک GPU برای آموزش مدل خود به این هدف دست پیدا کنید. یک GPU‌(واحد پردازش گرافیکی) یک پردازشگر تخصصی است با حافظه‌ای اختصاصی است که بطور قراردادی عملیات‌های ممیز شناور که برای رندر کردن گرافیک‌ها مورد نیاز است را انجام می‌دهد. به بیان دیگر، یک پردازشگر با تراشه‌ای واحد است که برای محاسبات گسترده‌ی گرافیکی و ریاضی استفاده می‌شود که در نتیجه سیکل‌های واحد پردازش مرکزی (CPU) را برای کارهای دیگر آزاد می‌کند.

تفاوت عمده بین GPUها و CPUها این است که GPUها در مقایسه با CPUها به تناسب ترانزیستورهای بیشتری را به واحد‌های حساب و منطق و تعداد کمتری را به حافظه‌ی میانجی (caches) و کنترل جریان اختصاص می‌دهند. در حالیکه CPUها بیشتر برای مشکلاتی که به تجزیه یا تحلیل منطق پیچیده در کد نیاز دارند کاربردی است، GPU‌ها به منظور رندر کردن گرافیکی بازی‌های کامپیوتری طراحی شده‌اند که بعدها پیشرفت یافتند تا محاسبات هندسی دیگر را سرعت بخشند (بطور مثال، تبدیل کردن چندضلعی‌ها یا خطوط قائم دوار به سیستم‌ها‌ی مختصات مختلف مثل 3D). یک GPU کوچکتر از یک CPU است اما قادر است در مقایسه با CPU هسته‌های منطقی بیشتری داشته باشد (واحد‌های حساب و منطق یا ALUها، واحدهای کنترل و حافظه‌ی میانجی (caches)).

در نمودار بالا می‌توانید ببینید که GPUها (قرمز و سبز) می‌توانند بطور نظری 10 تا 15 برابر عمل‌های CPUها (آبی) را انجام دهند. این افزایش سرعت در عمل نیز تا حد زیادی قابل اعمال است. اگر CPU را مازراتی در نظر بگیرید، GPU را می‌توان به عنوان یک کامیون بزرگ در نظر گرفت.

CPU(مازراتی) می‌توانند مقادیر کمی از پکیج‌ها (3 تا 4 مسافر) را در RAM با سرعت جا به جا کند در حالیکه که یک GPU(کامیون) آهسته‌تر است اما می‌توانند مقادیر بیشتری از حافظه (حدودا 20 مسافر) را در یک نوبت جا به جا کند. این مفهوم در فیلم بطور مختصر بیان شده است:

چرا برای یادگیری عمیق GPUها را انتخاب کنیم؟

GPUها برای آموزش مدل‌های هوش مصنوعی و یادگیری عمیق بهینه‌سازی شده‌اند چرا که می‌توانند چندین محاسبه را بطور همزمان پردازش کنند. آنها تعداد زیادی هسته دارند که اجازه می‌دهد محاسبه‌ی چندین پردازش موازی بهتر صورت بپذیرد. بعلاوه، محاسبات در یادگیری عمیق با مقادیر بسیاری داده سر و کار دارند که باعث می‌شود پهنای باند حافظه‌ی GPU مناسب‌تر باشد. تعدادی پارامتر تعیین کننده برای معین کردن استفاده از CPU یا GPU برای آموزش مدل یادگیری عمیق وجود دارد:

پهنای باند حافظه

یکی از دلایل عمده که GPUها برای محاسبه سریع‌تر از CPU هستند،‌ پهنای باند می‌باشد. با وجود مجموعه داده‌های بزرگ، CPU حافظه‌ی زیادی را هنگام آموزش مدل اشغال می‌کند. محاسبه‌ی کارهای بزرگ و پیچیده تعداد زیادی چرخه‌ی ساعت در CPU را در برمی‌گیرد _ CPU کارها را به ترتیب انجام می‌دهد و نسبت به همتای خود یعنی GPU هسته‌های کمتری دارد. از سوی دیگر، ‌GPU مستقل دارای حافظه‌ی اختصاصی VRAM (Video RAM) است. بنابراین حافظه‌ی CPU می‌تواند برای انجام کارهای دیگر به کار رود.

اندازه‌ی مجموعه داده

آموزش یک مدل در یادگیری عمیق نیازمند مجموعه‌ داده‌ی بزرگی است، از این رو از لحاظ حافظه عملیات‌های محاسباتی بسیاری را در بر دارد. هر چقدر که محاسبات بیشتر باشد، مزیت GPU نسبت به CPU بیشتر احساس می‌شود.

بهینه‌سازی

بهینه‌سازی کارها در CPU بسیار آسان‌تر است. هسته‌های CPU کمتر اما قدرتمندتر از هزاران هسته‌ی GPU هستند. هر هسته‌ی CPU می‌تواند روی دستورالعمل‌های مختلف (معماری MIMD) کار کند، در حالیکه هسته‌های GPU که عموما در در بلوک‌های 32هسته‌ای مرتب شده‌اند، دستورالعمل‌های مشابه‌ را در یک زمان مشخص بصورت موازی انجام می‌دهد (معماری SIMD). این موازی سازی در شبکه‌های عصبی متراکم با توجه به زحمتی که در بر دارند، بسیار مشکل است. از این رو، اجرای تکنیک‌های بهینه‌سازی پیچیده در GPU در مقایسه با CPU دشوارتر است.

آیا باید از GPU استفاده کنم؟

در جواب به این سوال مثل تمام پروژه‌های علم داده باید گفت که بستگی دارد. روابطی هست بین سرعت،‌ اعتمادپذیری و هزینه که باید در نظر گرفته شود.

            1. اگر شبکه‌ی عصبی شما تا حدودی در ابعاد کوچک باشد، می‌توانید آن را بدون GPU انجام دهید.

            2. اگر شبکه‌ی عصبی شما محاسبات زیادی را شامل صدها هزار پارامتر در بربگیرد، ممکن است بخواهید سرمایه‌گذاری نسبت به GPU را در نظر بگیرید.

طبق یک قاعده‌ی کلی، GPUها برای یادگیری ماشین امن‌تر هستند چون در باطن مدل در حال آموزش علم داده شامل محاسبات ماتریسی ساده است و اگر این محاسبات بصورت موازی انجام شوند، سرعت هر یک ممکن است به میزان زیادی بهبود پیدا کند.

نمونه‌های GPUی ابری

باید GPUهای ابری را نیز در نظر داشته باشید. اگر نمی‌خواهید تعدادی GPUی گران قیمت بخرید، می‌توانید در صورت تقاضا از GPUهای کمپانی‌هایی با فضای ابری استفاده کنید. در این صورت می‌توانید در هزینه‌‌های تهیه‌ی سخت‌افزار صرفه جویی کرده و از همه بهتر اینکه چندان گران قیمت نیستند، هزینه‌ها می‌تواند کمتر از 0.25 دلار برای هر ساعت استفاده از آنها باشد. زمانی که کارتان تمام شد، یادتان باشد که نمونه‌ی ابری خود را ببندید.

شما یک کامپیوتر یا سرور خارجی را اجاره می‌کنید، چیزی نیست که بطور مستقل آن را اجرا کنید. تنها بستن مرورگر یا خاموش کردن کامپیوترتان کافی نیست، این کارها تنها ارتباط بین دستگاه شما و این سرور از راه دور را قطع می‌کنند و چیزی را که شما دارید برای آن هزینه می‌کنید را نمی‌بندد. در غیر اینصورت، شما برای تمام زمانی که این سرور کار می‌کند متحمل هزینه می‌شوید و با دیدن یک صورت حساب سنگین غافلگیر خواهید شد!

CPUها برای محاسبات واحد و پیچیده‌تر بصورت ترتیبی عالی هستند،‌ در حالیکه GPUها در انجام تعداد زیادی محاسبه‌ی ساده بصورت موازی بهتر عمل می‌کنند. نمونه‌های محاسبه‌ی GPU عموما دو تا سه برابر هزینه‌ی نمونه‌های محاسبه‌ی CPU می‌باشید، بنابراین پیشنهاد می‌کنم از CPUها استفاده کنید،‌ مگر اینکه در آموزش مدل‌های مبتنی بر GPUی خود عملکرد دو تا سه برابری مشاهده کنید.

حرف اخر

ما در مقاله قبل فهمیدیم GPU چیست و این مقاله ما را بیشتر با دنیای جذاب GPU آشنا کرد.و به عنوان محصولی جدید اهمیت بالایی در استفاده ما دارد