ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ ਏਆਈ ਕਿਵੇਂ ਬਣਾਈਏ

ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ AI ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ। ਪੂਰੀ ਗਾਈਡ।

ਠੀਕ ਹੈ, ਤਾਂ ਤੁਸੀਂ "ਇੱਕ AI" ਬਣਾਉਣ ਬਾਰੇ ਉਤਸੁਕ ਹੋ। ਹਾਲੀਵੁੱਡ ਦੇ ਅਰਥਾਂ ਵਿੱਚ ਨਹੀਂ ਜਿੱਥੇ ਇਹ ਹੋਂਦ ਬਾਰੇ ਵਿਚਾਰ ਕਰਦਾ ਹੈ, ਪਰ ਉਸ ਕਿਸਮ ਦੀ ਜਿਸਨੂੰ ਤੁਸੀਂ ਆਪਣੇ ਲੈਪਟਾਪ 'ਤੇ ਚਲਾ ਸਕਦੇ ਹੋ ਜੋ ਭਵਿੱਖਬਾਣੀਆਂ ਕਰਦਾ ਹੈ, ਚੀਜ਼ਾਂ ਨੂੰ ਛਾਂਟਦਾ ਹੈ, ਸ਼ਾਇਦ ਥੋੜ੍ਹੀ ਜਿਹੀ ਗੱਲਬਾਤ ਵੀ ਕਰਦਾ ਹੈ। ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ AI ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ ਕੁਝ ਵੀ ਨਹੀਂ ਵੱਲ ਖਿੱਚਣ ਦੀ ਮੇਰੀ ਕੋਸ਼ਿਸ਼ ਹੈ ਜੋ ਅਸਲ ਵਿੱਚ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਕੰਮ ਕਰਦੀ ਹੈ । ਸ਼ਾਰਟਕੱਟ, ਸਪੱਸ਼ਟ ਰਾਏ, ਅਤੇ ਕਦੇ-ਕਦਾਈਂ ਪਾਸੇ ਵੱਲ ਜਾਣ ਦੀ ਉਮੀਦ ਕਰੋ ਕਿਉਂਕਿ, ਆਓ ਅਸਲੀ ਬਣੀਏ, ਛੇੜਛਾੜ ਕਦੇ ਵੀ ਸਾਫ਼ ਨਹੀਂ ਹੁੰਦੀ।

ਇਸ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਜੋ ਲੇਖ ਪੜ੍ਹਨਾ ਪਸੰਦ ਕਰ ਸਕਦੇ ਹੋ:

🔗 ਏਆਈ ਮਾਡਲ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ: ਪੂਰੇ ਕਦਮ ਦੱਸੇ ਗਏ
ਸ਼ੁਰੂ ਤੋਂ ਲੈ ਕੇ ਅੰਤ ਤੱਕ AI ਮਾਡਲ ਬਣਾਉਣ ਦਾ ਸਪੱਸ਼ਟ ਵੇਰਵਾ।

🔗 ਪ੍ਰਤੀਕਾਤਮਕ AI ਕੀ ਹੈ: ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇਹ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ
ਪ੍ਰਤੀਕਾਤਮਕ AI ਮੂਲ ਗੱਲਾਂ, ਇਤਿਹਾਸ ਅਤੇ ਆਧੁਨਿਕ ਸਮੇਂ ਦੇ ਉਪਯੋਗ ਸਿੱਖੋ।

🔗 AI ਲਈ ਡਾਟਾ ਸਟੋਰੇਜ ਲੋੜਾਂ: ਤੁਹਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ
ਕੁਸ਼ਲ ਅਤੇ ਸਕੇਲੇਬਲ AI ਸਿਸਟਮਾਂ ਲਈ ਸਟੋਰੇਜ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਨੂੰ ਸਮਝੋ।

ਹੁਣ ਕਿਉਂ ਪਰੇਸ਼ਾਨ? 🧭

ਕਿਉਂਕਿ "ਸਿਰਫ਼ ਗੂਗਲ-ਪੈਮਾਨੇ ਦੀਆਂ ਲੈਬਾਂ ਹੀ AI ਕਰ ਸਕਦੀਆਂ ਹਨ" ਦਾ ਯੁੱਗ ਹੁਣ ਖਤਮ ਹੋ ਗਿਆ ਹੈ। ਇਨ੍ਹੀਂ ਦਿਨੀਂ, ਇੱਕ ਨਿਯਮਤ ਲੈਪਟਾਪ, ਕੁਝ ਓਪਨ-ਸੋਰਸ ਟੂਲਸ ਅਤੇ ਜ਼ਿੱਦ ਨਾਲ, ਤੁਸੀਂ ਛੋਟੇ ਮਾਡਲ ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ ਈਮੇਲਾਂ ਨੂੰ ਵਰਗੀਕ੍ਰਿਤ ਕਰਦੇ ਹਨ, ਟੈਕਸਟ ਦਾ ਸਾਰ ਦਿੰਦੇ ਹਨ, ਜਾਂ ਚਿੱਤਰਾਂ ਨੂੰ ਟੈਗ ਕਰਦੇ ਹਨ। ਕਿਸੇ ਡੇਟਾ ਸੈਂਟਰ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇਹ ਚਾਹੀਦਾ ਹੈ:

  • ਇੱਕ ਯੋਜਨਾ,

  • ਇੱਕ ਸਾਫ਼ ਸੈੱਟਅੱਪ,

  • ਅਤੇ ਇੱਕ ਅਜਿਹਾ ਟੀਚਾ ਜਿਸਨੂੰ ਤੁਸੀਂ ਮਸ਼ੀਨ ਨੂੰ ਖਿੜਕੀ ਤੋਂ ਬਾਹਰ ਸੁੱਟਣ ਦੀ ਇੱਛਾ ਤੋਂ ਬਿਨਾਂ ਪੂਰਾ ਕਰ ਸਕਦੇ ਹੋ।

ਇਸਨੂੰ ਫਾਲੋ ਕਰਨ ਦੇ ਯੋਗ ਕਿਉਂ ਬਣਾਉਂਦਾ ਹੈ ✅

"ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ ਏਆਈ ਕਿਵੇਂ ਬਣਾਈਏ" ਪੁੱਛਣ ਵਾਲੇ ਲੋਕ ਆਮ ਤੌਰ 'ਤੇ ਪੀਐਚਡੀ ਨਹੀਂ ਚਾਹੁੰਦੇ। ਉਹ ਕੁਝ ਅਜਿਹਾ ਚਾਹੁੰਦੇ ਹਨ ਜੋ ਉਹ ਅਸਲ ਵਿੱਚ ਚਲਾ ਸਕਣ। ਇੱਕ ਚੰਗੀ ਯੋਜਨਾ ਕੁਝ ਚੀਜ਼ਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੀ ਹੈ:

  • ਛੋਟੀ ਜਿਹੀ ਸ਼ੁਰੂਆਤ ਕਰੋ : ਭਾਵਨਾ ਨੂੰ ਸ਼੍ਰੇਣੀਬੱਧ ਕਰੋ, "ਬੁੱਧੀ ਨੂੰ ਹੱਲ ਕਰੋ" ਨੂੰ ਨਹੀਂ।

  • ਪ੍ਰਜਨਨਯੋਗਤਾ : ਕੌਂਡਾ ਜਾਂ ਵੇਨਵ ਤਾਂ ਜੋ ਤੁਸੀਂ ਕੱਲ੍ਹ ਨੂੰ ਬਿਨਾਂ ਘਬਰਾਹਟ ਦੇ ਦੁਬਾਰਾ ਬਣਾ ਸਕੋ।

  • ਹਾਰਡਵੇਅਰ ਇਮਾਨਦਾਰੀ : scikit-learn ਲਈ CPU ਠੀਕ ਹਨ, ਡੂੰਘੇ ਨੈੱਟ ਲਈ GPU (ਜੇ ਤੁਸੀਂ ਖੁਸ਼ਕਿਸਮਤ ਹੋ) [2][3]।

  • ਸਾਫ਼ ਡੇਟਾ : ਕੋਈ ਗਲਤ ਲੇਬਲ ਵਾਲਾ ਜੰਕ ਨਹੀਂ; ਹਮੇਸ਼ਾ ਟ੍ਰੇਨ/ਵੈਧ/ਟੈਸਟ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ।

  • ਮੈਟ੍ਰਿਕਸ ਜਿਨ੍ਹਾਂ ਦਾ ਕੁਝ ਮਤਲਬ ਹੈ : ਸ਼ੁੱਧਤਾ, ਸ਼ੁੱਧਤਾ, ਯਾਦ, F1। ਅਸੰਤੁਲਨ ਲਈ, ROC-AUC/PR-AUC [1]।

  • ਸਾਂਝਾ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ : ਇੱਕ ਛੋਟਾ API, CLI, ਜਾਂ ਡੈਮੋ ਐਪ।

  • ਸੁਰੱਖਿਆ : ਕੋਈ ਸ਼ੱਕੀ ਡੇਟਾਸੈੱਟ ਨਹੀਂ, ਕੋਈ ਨਿੱਜੀ ਜਾਣਕਾਰੀ ਲੀਕ ਨਹੀਂ, ਜੋਖਮਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਨੋਟ ਕਰੋ [4]।

ਉਹਨਾਂ ਨੂੰ ਸਹੀ ਕਰੋ, ਅਤੇ ਤੁਹਾਡਾ "ਛੋਟਾ" ਮਾਡਲ ਵੀ ਅਸਲੀ ਹੈ।

ਇੱਕ ਰੋਡਮੈਪ ਜੋ ਡਰਾਉਣਾ ਨਹੀਂ ਲੱਗਦਾ 🗺️

  1. ਇੱਕ ਛੋਟੀ ਸਮੱਸਿਆ + ਇੱਕ ਮਾਪਕ ਚੁਣੋ।

  2. ਪਾਈਥਨ ਅਤੇ ਕੁਝ ਮੁੱਖ ਲਾਇਬ੍ਰੇਰੀਆਂ ਸਥਾਪਿਤ ਕਰੋ।

  3. ਇੱਕ ਸਾਫ਼ ਵਾਤਾਵਰਣ ਬਣਾਓ (ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਆਪਣਾ ਧੰਨਵਾਦ ਕਰੋਗੇ)।

  4. ਆਪਣਾ ਡੇਟਾਸੈਟ ਲੋਡ ਕਰੋ, ਸਹੀ ਢੰਗ ਨਾਲ ਵੰਡੋ।

  5. ਇੱਕ ਮੂਰਖ ਪਰ ਇਮਾਨਦਾਰ ਆਧਾਰਲਾਈਨ ਸਿਖਾਓ।

  6. ਜੇਕਰ ਇਹ ਮੁੱਲ ਜੋੜਦਾ ਹੈ ਤਾਂ ਹੀ ਨਿਊਰਲ ਨੈੱਟ ਅਜ਼ਮਾਓ।

  7. ਇੱਕ ਡੈਮੋ ਪੈਕ ਕਰੋ।

  8. ਕੁਝ ਨੋਟਸ ਰੱਖੋ, ਭਵਿੱਖ ਵਿੱਚ - ਤੁਸੀਂ ਤੁਹਾਡਾ ਧੰਨਵਾਦ ਕਰੋਗੇ।

ਘੱਟੋ-ਘੱਟ ਕਿੱਟ: ਜ਼ਿਆਦਾ ਗੁੰਝਲਦਾਰ ਨਾ ਬਣਾਓ 🧰

  • ਪਾਈਥਨ : python.org ਤੋਂ ਲਓ।

  • ਵਾਤਾਵਰਣ ਪਿੱਪ ਦੇ ਨਾਲ ਕੌਂਡਾ ਜਾਂ ਵੈਨਵ

  • ਨੋਟਬੁੱਕ : ਖੇਡਣ ਲਈ ਜੁਪੀਟਰ।

  • ਸੰਪਾਦਕ : VS ਕੋਡ, ਦੋਸਤਾਨਾ ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ।

  • ਕੋਰ ਲਿਬਸ

    • ਪਾਂਡਾ + ਨਮਪੀ (ਡੇਟਾ ਰੈਂਗਲਿੰਗ)

    • ਸਾਈਕਿਟ-ਲਰਨ (ਕਲਾਸੀਕਲ ਐਮਐਲ)

    • ਪਾਈਟੋਰਚ ਜਾਂ ਟੈਂਸਰਫਲੋ (ਡੂੰਘੀ ਸਿਖਲਾਈ, GPU ਮੈਟਰ ਬਣਾਉਂਦਾ ਹੈ) [2][3]

    • ਹੱਗਿੰਗ ਫੇਸ ਟ੍ਰਾਂਸਫਾਰਮਰ, ਸਪੇਸ, ਓਪਨਸੀਵੀ (ਐਨਐਲਪੀ + ਵਿਜ਼ਨ)

  • ਪ੍ਰਵੇਗ (ਵਿਕਲਪਿਕ)

    • NVIDIA → CUDA ਬਿਲਡ [2]

    • AMD → ROCm ਬਿਲਡ [2]

    • ਐਪਲ → ਪਾਈਟੋਰਚ ਮੈਟਲ ਬੈਕਐਂਡ (MPS) ਦੇ ਨਾਲ [2]

⚡ ਸਾਈਡ ਨੋਟ: ਜ਼ਿਆਦਾਤਰ "ਇੰਸਟਾਲੇਸ਼ਨ ਦਰਦ" ਅਲੋਪ ਹੋ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਅਧਿਕਾਰਤ ਇੰਸਟਾਲਰਾਂ ਨੂੰ ਸਹੀ ਕਮਾਂਡ ਦੇਣ ਦਿੰਦੇ ਹੋ। ਕਾਪੀ ਕਰੋ, ਪੇਸਟ ਕਰੋ, ਹੋ ਗਿਆ [2][3]।

ਨਿਯਮ: ਪਹਿਲਾਂ CPU 'ਤੇ ਘੁੰਮੋ, ਬਾਅਦ ਵਿੱਚ GPU ਨਾਲ ਦੌੜੋ।

ਆਪਣਾ ਸਟੈਕ ਚੁਣਨਾ: ਚਮਕਦਾਰ ਚੀਜ਼ਾਂ ਦਾ ਵਿਰੋਧ ਕਰੋ 🧪

  • ਸਾਰਣੀ ਡੇਟਾ → ਵਿਗਿਆਨ-ਸਿੱਖੋ। ਲੌਜਿਸਟਿਕ ਰਿਗਰੈਸ਼ਨ, ਬੇਤਰਤੀਬ ਜੰਗਲ, ਗਰੇਡੀਐਂਟ ਬੂਸਟਿੰਗ।

  • ਟੈਕਸਟ ਜਾਂ ਤਸਵੀਰਾਂ → ਪਾਈਟੋਰਚ ਜਾਂ ਟੈਂਸਰਫਲੋ। ਟੈਕਸਟ ਲਈ, ਇੱਕ ਛੋਟੇ ਟ੍ਰਾਂਸਫਾਰਮਰ ਨੂੰ ਵਧੀਆ ਬਣਾਉਣਾ ਇੱਕ ਵੱਡੀ ਜਿੱਤ ਹੈ।

  • ਚੈਟਬੋਟ-ਇਸ਼ → llama.cpp ਲੈਪਟਾਪਾਂ 'ਤੇ ਛੋਟੇ LLM ਚਲਾ ਸਕਦਾ ਹੈ। ਜਾਦੂ ਦੀ ਉਮੀਦ ਨਾ ਕਰੋ, ਪਰ ਇਹ ਨੋਟਸ ਅਤੇ ਸੰਖੇਪਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ [5]।

ਸਾਫ਼ ਵਾਤਾਵਰਣ ਸੈੱਟਅੱਪ 🧼

# ਕੋਂਡਾ ਵੇ ਕੋਂਡਾ ਬਣਾਓ -n ਲੋਕਲਾਈ ਪਾਈਥਨ=3.11 ਕੰਡਾ ਐਕਟੀਵੇਟ ਲੋਕਲਾਈ # ਜਾਂ venv python -m venv .venv ਸਰੋਤ .venv/bin/activate # ਵਿੰਡੋਜ਼: .venv\Scripts\activate

ਫਿਰ ਜ਼ਰੂਰੀ ਚੀਜ਼ਾਂ ਸਥਾਪਿਤ ਕਰੋ:

ਪਾਈਪ ਇੰਸਟਾਲ ਨਮਪੀ ਪਾਂਡਾ ਸਾਈਕਿਟ-ਲਰਨ ਜੁਪੀਟਰ ਪਾਈਪ ਇੰਸਟਾਲ ਟਾਰਚ ਟਾਰਚਵਿਜ਼ਨ ਟਾਰਚਆਡੀਓ # ਜਾਂ ਟੈਂਸਰਫਲੋ ਪਾਈਪ ਇੰਸਟਾਲ ਟ੍ਰਾਂਸਫਾਰਮਰ ਡੇਟਾਸੈੱਟ

(ਜੀਪੀਯੂ ਬਿਲਡ ਲਈ, ਗੰਭੀਰਤਾ ਨਾਲ, ਸਿਰਫ਼ ਅਧਿਕਾਰਤ ਚੋਣਕਾਰ [2][3] ਦੀ ਵਰਤੋਂ ਕਰੋ।)

ਪਹਿਲਾ ਕੰਮ ਕਰਨ ਵਾਲਾ ਮਾਡਲ: ਇਸਨੂੰ ਛੋਟਾ ਰੱਖੋ 🏁

ਪਹਿਲਾਂ ਬੇਸਲਾਈਨ। CSV → ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ + ਲੇਬਲ → ਲੌਜਿਸਟਿਕ ਰਿਗਰੈਸ਼ਨ।

sklearn.linear_model ਤੋਂ ਆਯਾਤ LogisticRegression ... ਪ੍ਰਿੰਟ ("ਸ਼ੁੱਧਤਾ:", accuracy_score (y_test, preds)) ਪ੍ਰਿੰਟ (ਵਰਗੀਕਰਣ_ਰਿਪੋਰਟ (y_test, preds))

ਜੇਕਰ ਇਹ ਬੇਤਰਤੀਬ ਤੋਂ ਵਧੀਆ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਜਸ਼ਨ ਮਨਾਉਂਦੇ ਹੋ। ਕੌਫੀ ਜਾਂ ਕੂਕੀ, ਤੁਹਾਡੀ ਕਾਲ ☕।
ਅਸੰਤੁਲਿਤ ਕਲਾਸਾਂ ਲਈ, ਕੱਚੀ ਸ਼ੁੱਧਤਾ [1] ਦੀ ਬਜਾਏ ਸ਼ੁੱਧਤਾ/ਯਾਦ + ROC/PR ਕਰਵ ਦੇਖੋ।

ਨਿਊਰਲ ਜਾਲ (ਸਿਰਫ਼ ਜੇਕਰ ਉਹ ਮਦਦ ਕਰਦੇ ਹਨ) 🧠

ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਟੈਕਸਟ ਹੈ ਅਤੇ ਤੁਸੀਂ ਭਾਵਨਾ ਵਰਗੀਕਰਣ ਚਾਹੁੰਦੇ ਹੋ? ਇੱਕ ਛੋਟੇ ਜਿਹੇ ਪਹਿਲਾਂ ਤੋਂ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਟ੍ਰਾਂਸਫਾਰਮਰ ਨੂੰ ਵਧੀਆ ਬਣਾਓ। ਤੇਜ਼, ਸਾਫ਼-ਸੁਥਰਾ, ਤੁਹਾਡੀ ਮਸ਼ੀਨ ਨੂੰ ਫ੍ਰਾਈ ਨਹੀਂ ਕਰਦਾ।

ਟ੍ਰਾਂਸਫਾਰਮਰਾਂ ਤੋਂ ਆਯਾਤ AutoModelForSequenceClassification ... trainer.train() print(trainer.evaluate())

ਪੇਸ਼ੇਵਰ ਸੁਝਾਅ: ਛੋਟੇ ਸੈਂਪਲਾਂ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੋ। 1% ਡੇਟਾ 'ਤੇ ਡੀਬੱਗ ਕਰਨ ਨਾਲ ਘੰਟੇ ਬਚਦੇ ਹਨ।

ਡਾਟਾ: ਮੂਲ ਗੱਲਾਂ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਛੱਡ ਨਹੀਂ ਸਕਦੇ 📦

  • ਜਨਤਕ ਡੇਟਾਸੈੱਟ: ਕੈਗਲ, ਹੱਗਿੰਗ ਫੇਸ, ਅਕਾਦਮਿਕ ਰਿਪੋ (ਲਾਇਸੰਸਾਂ ਦੀ ਜਾਂਚ ਕਰੋ)।

  • ਨੈਤਿਕਤਾ: ਨਿੱਜੀ ਜਾਣਕਾਰੀ ਨੂੰ ਸਾਫ਼ ਕਰੋ, ਅਧਿਕਾਰਾਂ ਦਾ ਸਤਿਕਾਰ ਕਰੋ।

  • ਵੰਡ: ਟ੍ਰੇਨ, ਪ੍ਰਮਾਣਿਕਤਾ, ਟੈਸਟ। ਕਦੇ ਵੀ ਨਾ ਝਾਕੋ।

  • ਲੇਬਲ: ਇਕਸਾਰਤਾ ਫੈਂਸੀ ਮਾਡਲਾਂ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਮਾਇਨੇ ਰੱਖਦੀ ਹੈ।

ਸੱਚਾਈ ਦਾ ਬੰਬ: 60% ਨਤੀਜੇ ਸਾਫ਼ ਲੇਬਲਾਂ ਤੋਂ ਹਨ, ਨਾ ਕਿ ਆਰਕੀਟੈਕਚਰ ਦੇ ਜਾਦੂ ਤੋਂ।

ਮਾਪਦੰਡ ਜੋ ਤੁਹਾਨੂੰ ਇਮਾਨਦਾਰ ਰੱਖਦੇ ਹਨ 🎯

  • ਵਰਗੀਕਰਨ → ਸ਼ੁੱਧਤਾ, ਸ਼ੁੱਧਤਾ, ਯਾਦ, F1।

  • ਅਸੰਤੁਲਿਤ ਸੈੱਟ → ROC-AUC, PR-AUC ਜ਼ਿਆਦਾ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ।

  • ਰਿਗਰੈਸ਼ਨ → MAE, RMSE, R²।

  • ਹਕੀਕਤ ਦੀ ਜਾਂਚ → ਕੁਝ ਨਤੀਜਿਆਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰੋ; ਅੰਕੜੇ ਝੂਠ ਬੋਲ ਸਕਦੇ ਹਨ।

ਸੌਖਾ ਹਵਾਲਾ: ਵਿਗਿਆਨ-ਸਿੱਖਣ ਮੈਟ੍ਰਿਕਸ ਗਾਈਡ [1]।

ਪ੍ਰਵੇਗ ਸੁਝਾਅ 🚀

  • NVIDIA → PyTorch CUDA ਬਿਲਡ [2]

  • ਏਐਮਡੀ → ਆਰਓਸੀਐਮ [2]

  • ਐਪਲ → MPS ਬੈਕਐਂਡ [2]

  • ਟੈਂਸਰਫਲੋ → ਅਧਿਕਾਰਤ GPU ਇੰਸਟਾਲ ਦੀ ਪਾਲਣਾ ਕਰੋ + ਪੁਸ਼ਟੀ ਕਰੋ [3]

ਪਰ ਆਪਣੀ ਬੇਸਲਾਈਨ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਅਨੁਕੂਲ ਨਾ ਬਣਾਓ। ਇਹ ਕਾਰ ਦੇ ਪਹੀਏ ਲੱਗਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਰਿਮਾਂ ਨੂੰ ਪਾਲਿਸ਼ ਕਰਨ ਵਾਂਗ ਹੈ।

ਸਥਾਨਕ ਜਨਰੇਟਿਵ ਮਾਡਲ: ਬੇਬੀ ਡਰੈਗਨ 🐉

  • ਭਾਸ਼ਾ llama.cpp [5] ਰਾਹੀਂ ਕੁਆਂਟਾਈਜ਼ਡ LLM

  • ਤਸਵੀਰਾਂ → ਸਥਿਰ ਪ੍ਰਸਾਰ ਰੂਪ ਮੌਜੂਦ ਹਨ; ਲਾਇਸੈਂਸਾਂ ਨੂੰ ਧਿਆਨ ਨਾਲ ਪੜ੍ਹੋ।

ਕਈ ਵਾਰ ਇੱਕ ਟਾਸਕ-ਵਿਸ਼ੇਸ਼ ਫਾਈਨ-ਟਿਊਨਡ ਟ੍ਰਾਂਸਫਾਰਮਰ ਛੋਟੇ ਹਾਰਡਵੇਅਰ 'ਤੇ ਇੱਕ ਫੁੱਲੇ ਹੋਏ LLM ਨੂੰ ਮਾਤ ਦਿੰਦਾ ਹੈ।

ਪੈਕੇਜਿੰਗ ਡੈਮੋ: ਲੋਕਾਂ ਨੂੰ ਕਲਿੱਕ ਕਰਨ ਦਿਓ 🖥️

  • ਗ੍ਰੇਡੀਓ → ਸਭ ਤੋਂ ਆਸਾਨ UI।

  • ਫਾਸਟਏਪੀਆਈ → ਸਾਫ਼ ਏਪੀਆਈ।

  • ਫਲਾਸਕ → ਤੇਜ਼ ਸਕ੍ਰਿਪਟਾਂ।

ਗ੍ਰੇਡੀਓ ਨੂੰ gr clf = ਪਾਈਪਲਾਈਨ ("ਭਾਵਨਾ-ਵਿਸ਼ਲੇਸ਼ਣ") ਦੇ ਰੂਪ ਵਿੱਚ ਆਯਾਤ ਕਰੋ ... demo.launch()

ਜਦੋਂ ਤੁਹਾਡਾ ਬ੍ਰਾਊਜ਼ਰ ਇਸਨੂੰ ਦਿਖਾਉਂਦਾ ਹੈ ਤਾਂ ਜਾਦੂ ਵਰਗਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ।

ਆਦਤਾਂ ਜੋ ਸਮਝਦਾਰੀ ਨੂੰ ਬਚਾਉਂਦੀਆਂ ਹਨ 🧠

  • ਵਰਜਨ ਕੰਟਰੋਲ ਲਈ Git।

  • ਪ੍ਰਯੋਗਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ MLflow ਜਾਂ ਨੋਟਬੁੱਕ।

  • DVC ਜਾਂ ਹੈਸ਼ਾਂ ਨਾਲ ਡਾਟਾ ਵਰਜਨਿੰਗ।

  • ਜੇ ਦੂਜਿਆਂ ਨੂੰ ਤੁਹਾਡਾ ਸਮਾਨ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੋਵੇ ਤਾਂ ਡੌਕਰ ਕਰੋ।

  • ਪਿੰਨ ਨਿਰਭਰਤਾਵਾਂ ( requirements.txt )।

ਮੇਰੇ ਤੇ ਵਿਸ਼ਵਾਸ ਕਰੋ, ਭਵਿੱਖ - ਤੁਸੀਂ ਧੰਨਵਾਦੀ ਹੋਵੋਗੇ।

ਸਮੱਸਿਆ ਨਿਪਟਾਰਾ: ਆਮ "ਉਫ਼" ਪਲ 🧯

  • ਕੀ ਇੰਸਟਾਲ ਵਿੱਚ ਗਲਤੀਆਂ ਹਨ? ਬਸ env ਨੂੰ ਪੂੰਝੋ ਅਤੇ ਦੁਬਾਰਾ ਬਣਾਓ।

  • GPU ਨਹੀਂ ਮਿਲਿਆ? ਡਰਾਈਵਰ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ, ਵਰਜਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ [2][3]।

  • ਕੀ ਮਾਡਲ ਸਿੱਖ ਨਹੀਂ ਰਿਹਾ? ਸਿੱਖਣ ਦੀ ਦਰ ਘਟਾਓ, ਸਰਲ ਬਣਾਓ, ਜਾਂ ਲੇਬਲ ਸਾਫ਼ ਕਰੋ।

  • ਕੀ ਤੁਸੀਂ ਜ਼ਿਆਦਾ ਫਿਟਿੰਗ ਕਰ ਰਹੇ ਹੋ? ਨਿਯਮਤ ਕਰੋ, ਛੱਡ ਦਿਓ, ਜਾਂ ਸਿਰਫ਼ ਹੋਰ ਡਾਟਾ।

  • ਕੀ ਮੈਟ੍ਰਿਕਸ ਬਹੁਤ ਵਧੀਆ ਹਨ? ਤੁਸੀਂ ਟੈਸਟ ਸੈੱਟ ਲੀਕ ਕਰ ਦਿੱਤਾ (ਇਹ ਤੁਹਾਡੇ ਸੋਚਣ ਨਾਲੋਂ ਕਿਤੇ ਜ਼ਿਆਦਾ ਹੁੰਦਾ ਹੈ)।

ਸੁਰੱਖਿਆ + ਜ਼ਿੰਮੇਵਾਰੀ 🛡️

  • ਸਟ੍ਰਿਪ PII।

  • ਲਾਇਸੈਂਸਾਂ ਦਾ ਸਤਿਕਾਰ ਕਰੋ।

  • ਲੋਕਲ-ਫਸਟ = ਗੋਪਨੀਯਤਾ + ਕੰਟਰੋਲ, ਪਰ ਗਣਨਾ ਸੀਮਾਵਾਂ ਦੇ ਨਾਲ।

  • ਦਸਤਾਵੇਜ਼ ਜੋਖਮ (ਨਿਰਪੱਖਤਾ, ਸੁਰੱਖਿਆ, ਲਚਕੀਲਾਪਣ, ਆਦਿ) [4]।

ਸੌਖਾ ਤੁਲਨਾ ਸਾਰਣੀ 📊

ਔਜ਼ਾਰ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਇਸਨੂੰ ਕਿਉਂ ਵਰਤਣਾ ਹੈ?
ਵਿਗਿਆਨ-ਸਿੱਖੋ ਸਾਰਣੀ ਡੇਟਾ ਤੇਜ਼ ਜਿੱਤਾਂ, ਸਾਫ਼ API 🙂
ਪਾਈਟੋਰਚ ਕਸਟਮ ਡੂੰਘੇ ਜਾਲ ਲਚਕਦਾਰ, ਵਿਸ਼ਾਲ ਭਾਈਚਾਰਾ
ਟੈਂਸਰਫਲੋ ਉਤਪਾਦਨ ਪਾਈਪਲਾਈਨਾਂ ਈਕੋਸਿਸਟਮ + ਸਰਵਿੰਗ ਵਿਕਲਪ
ਟ੍ਰਾਂਸਫਾਰਮਰ ਟੈਕਸਟ ਕਾਰਜ ਪਹਿਲਾਂ ਤੋਂ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਮਾਡਲ ਗਣਨਾ ਨੂੰ ਬਚਾਉਂਦੇ ਹਨ
ਸਪੇਸੀ NLP ਪਾਈਪਲਾਈਨਾਂ ਉਦਯੋਗਿਕ-ਸ਼ਕਤੀ, ਵਿਹਾਰਕ
ਗ੍ਰੇਡੀਓ ਡੈਮੋ/UI 1 ਫ਼ਾਈਲ → UI
ਫਾਸਟਏਪੀਆਈ ਏਪੀਆਈ ਸਪੀਡ + ਆਟੋ ਡੌਕਸ
ONNX ਰਨਟਾਈਮ ਕਰਾਸ-ਫਰੇਮਵਰਕ ਵਰਤੋਂ ਪੋਰਟੇਬਲ + ਕੁਸ਼ਲ
ਲਾਮਾ.ਸੀਪੀਪੀ ਛੋਟੇ ਸਥਾਨਕ ਐਲਐਲਐਮ CPU-ਅਨੁਕੂਲ ਕੁਆਂਟਾਈਜ਼ੇਸ਼ਨ [5]
ਡੌਕਰ ਸਾਂਝਾਕਰਨ envs "ਇਹ ਹਰ ਜਗ੍ਹਾ ਕੰਮ ਕਰਦਾ ਹੈ"

ਤਿੰਨ ਡੂੰਘੇ ਡੁਬਕੀ (ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਵਰਤੋਗੇ) 🏊

  1. ਟੇਬਲਾਂ ਲਈ ਵਿਸ਼ੇਸ਼ਤਾ ਇੰਜੀਨੀਅਰਿੰਗ → ਸਧਾਰਣ, ਇੱਕ-ਗਰਮ, ਟ੍ਰੀ ਮਾਡਲਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਕਰਾਸ-ਵੈਲੀਡੇਟ [1]।

  2. ਟੈਕਸਟ ਲਈ ਟ੍ਰਾਂਸਫਰ ਲਰਨਿੰਗ → ਛੋਟੇ ਟ੍ਰਾਂਸਫਾਰਮਰਾਂ ਨੂੰ ਵਧੀਆ ਬਣਾਓ, seq ਲੰਬਾਈ ਨੂੰ ਸਾਧਾਰਨ ਰੱਖੋ, ਦੁਰਲੱਭ ਕਲਾਸਾਂ ਲਈ F1 [1]।

  3. → ਕੁਆਂਟਾਈਜ਼, ਐਕਸਪੋਰਟ ONNX, ਕੈਸ਼ ਟੋਕਨਾਈਜ਼ਰ ਲਈ ਅਨੁਕੂਲਤਾ

ਕਲਾਸਿਕ ਮੁਸ਼ਕਲਾਂ 🪤

  • ਬਹੁਤ ਵੱਡੀ ਇਮਾਰਤ, ਬਹੁਤ ਜਲਦੀ।

  • ਡਾਟਾ ਗੁਣਵੱਤਾ ਨੂੰ ਅਣਡਿੱਠਾ ਕਰਨਾ।

  • ਟੈਸਟ ਸਪਲਿਟ ਛੱਡਿਆ ਜਾ ਰਿਹਾ ਹੈ।

  • ਅੰਨ੍ਹੀ ਕਾਪੀ-ਪੇਸਟ ਕੋਡਿੰਗ।

  • ਕੁਝ ਵੀ ਦਸਤਾਵੇਜ਼ੀ ਨਹੀਂ ਬਣਾ ਰਿਹਾ।

ਇੱਕ README ਵੀ ਘੰਟਿਆਂ ਬਾਅਦ ਬਚਾਉਂਦਾ ਹੈ।

ਸਮੇਂ ਦੇ ਯੋਗ ਸਿੱਖਣ ਦੇ ਸਰੋਤ 📚

  • ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼ (ਪਾਈਟੋਰਚ, ਟੈਂਸਰਫਲੋ, ਸਾਇੰਸਿਟ-ਲਰਨ, ਟ੍ਰਾਂਸਫਾਰਮਰ)।

  • ਗੂਗਲ ਐਮਐਲ ਕਰੈਸ਼ ਕੋਰਸ, ਡੀਪਲਰਨਿੰਗ.ਏਆਈ।

  • ਦ੍ਰਿਸ਼ਟੀ ਦੀ ਮੂਲ ਗੱਲਾਂ ਲਈ ਓਪਨਸੀਵੀ ਦਸਤਾਵੇਜ਼।

  • NLP ਪਾਈਪਲਾਈਨਾਂ ਲਈ ਸਪੇਸੀ ਵਰਤੋਂ ਗਾਈਡ।

ਛੋਟਾ ਜਿਹਾ ਲਾਈਫ-ਹੈਕ: ਤੁਹਾਡੇ GPU ਇੰਸਟਾਲ ਕਮਾਂਡ ਨੂੰ ਤਿਆਰ ਕਰਨ ਵਾਲੇ ਅਧਿਕਾਰਤ ਇੰਸਟਾਲਰ ਜੀਵਨ ਬਚਾਉਣ ਵਾਲੇ ਹਨ [2][3]।

ਸਭ ਕੁਝ ਇਕੱਠਾ ਕਰਨਾ 🧩

  1. ਟੀਚਾ → ਸਹਾਇਤਾ ਟਿਕਟਾਂ ਨੂੰ 3 ਕਿਸਮਾਂ ਵਿੱਚ ਸ਼੍ਰੇਣੀਬੱਧ ਕਰੋ।

  2. ਡਾਟਾ → CSV ਨਿਰਯਾਤ, ਗੁਮਨਾਮ, ਵੰਡਿਆ ਗਿਆ।

  3. ਬੇਸਲਾਈਨ → ਵਿਗਿਆਨ-ਸਿੱਖਣ TF-IDF + ਲੌਜਿਸਟਿਕ ਰਿਗਰੈਸ਼ਨ।

  4. ਅੱਪਗ੍ਰੇਡ ਕਰੋ → ਜੇਕਰ ਬੇਸਲਾਈਨ ਰੁਕ ਜਾਂਦੀ ਹੈ ਤਾਂ ਟ੍ਰਾਂਸਫਾਰਮਰ ਨੂੰ ਠੀਕ ਕਰੋ।

  5. ਡੈਮੋ → ਗ੍ਰੇਡੀਓ ਟੈਕਸਟਬਾਕਸ ਐਪ।

  6. ਜਹਾਜ਼ → ਡੌਕਰ + README।

  7. ਦੁਹਰਾਓ → ਗਲਤੀਆਂ ਠੀਕ ਕਰੋ, ਦੁਬਾਰਾ ਲੇਬਲ ਕਰੋ, ਦੁਹਰਾਓ।

  8. ਸੇਫਗਾਰਡ → ਦਸਤਾਵੇਜ਼ ਜੋਖਮ [4]।

ਇਹ ਬੋਰਿੰਗ ਤੌਰ 'ਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ।

TL;DR 🎂

ਆਪਣੇ ਕੰਪਿਊਟਰ 'ਤੇ AI ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ ਸਿੱਖਣਾ = ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਸਮੱਸਿਆ ਚੁਣੋ, ਇੱਕ ਬੇਸਲਾਈਨ ਬਣਾਓ, ਸਿਰਫ਼ ਉਦੋਂ ਹੀ ਵਧਾਓ ਜਦੋਂ ਇਹ ਮਦਦ ਕਰੇ, ਅਤੇ ਆਪਣੇ ਸੈੱਟਅੱਪ ਨੂੰ ਦੁਬਾਰਾ ਪੈਦਾ ਕਰਨ ਯੋਗ ਰੱਖੋ। ਇਸਨੂੰ ਦੋ ਵਾਰ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਸਮਰੱਥ ਮਹਿਸੂਸ ਕਰੋਗੇ। ਇਸਨੂੰ ਪੰਜ ਵਾਰ ਕਰੋ ਅਤੇ ਲੋਕ ਤੁਹਾਡੇ ਤੋਂ ਮਦਦ ਮੰਗਣਾ ਸ਼ੁਰੂ ਕਰ ਦੇਣਗੇ, ਜੋ ਕਿ ਗੁਪਤ ਤੌਰ 'ਤੇ ਮਜ਼ੇਦਾਰ ਹਿੱਸਾ ਹੈ।

ਅਤੇ ਹਾਂ, ਕਈ ਵਾਰ ਇਹ ਇੱਕ ਟੋਸਟਰ ਨੂੰ ਕਵਿਤਾ ਲਿਖਣਾ ਸਿਖਾਉਣ ਵਰਗਾ ਲੱਗਦਾ ਹੈ। ਕੋਈ ਗੱਲ ਨਹੀਂ। ਛੇੜਛਾੜ ਕਰਦੇ ਰਹੋ। 🔌📝

ਹਵਾਲੇ

[1] scikit-learn — ਮੈਟ੍ਰਿਕਸ ਅਤੇ ਮਾਡਲ ਮੁਲਾਂਕਣ: ਲਿੰਕ
[2] PyTorch — ਸਥਾਨਕ ਇੰਸਟਾਲ ਚੋਣਕਾਰ (CUDA/ROCm/Mac MPS): ਲਿੰਕ
[3] TensorFlow — ਇੰਸਟਾਲ + GPU ਤਸਦੀਕ: ਲਿੰਕ
[4] NIST — AI ਜੋਖਮ ਪ੍ਰਬੰਧਨ ਫਰੇਮਵਰਕ: ਲਿੰਕ
[5] llama.cpp — ਸਥਾਨਕ LLM ਰੈਪੋ: ਲਿੰਕ

ਅਧਿਕਾਰਤ AI ਸਹਾਇਕ ਸਟੋਰ 'ਤੇ ਨਵੀਨਤਮ AI ਲੱਭੋ

ਸਾਡੇ ਬਾਰੇ

ਬਲੌਗ ਤੇ ਵਾਪਸ ਜਾਓ