Python AI

Ten kurs jest dla osób, które chcą rozwijać praktyczne kompetencje Python AI: od automatyzacji procesów, przez budowanie agentów i systemów RAG, aż po projekty Machine Learning / Deep Learning realizowane end-to-end. Program łączy dużą ilość praktyki, pracę na projektach oraz standardy wykorzystywane komercyjnie, dzięki czemu nauka przekłada się bezpośrednio na portfolio i realne umiejętności rynkowe. Dodatkowo w ramach mentoringu uczysz się świadomej pracy z narzędziami AI (Claude Code, Cursor i inne) — od precyzyjnego promptowania po krytyczną weryfikację sugestii kodu.

Rekomendowana kolejność nauki to: najpierw kurs Python, następnie Python Data Science, a potem ten kurs. Dzięki temu płynnie przechodzisz od fundamentów do zaawansowanych wdrożeń AI.

Jeśli masz już bazę z Pythona i Data Science, możesz od razu wejść w część projektową i budować portfolio oparte na realnych systemach: automatyzacjach, agentach, HITL, RAG oraz modelach ML/DL.

Wybierz ten kurs jeśli:

• Chcesz uczyć się projektowo i budować rozwiązania, które można od razu pokazać w portfolio,
• Chcesz tworzyć agentów AI i systemy RAG z kontrolą jakości i metrykami,
• Chcesz przejść przez pełny proces AI/ML od danych i pipeline’u po dobór modelu i wdrożenie,
• Chcesz pracować na standardach komercyjnych (FastAPI, LangChain/LangGraph, testy, architektura, stabilność),
• Chcesz pisać lepszy kod i efektywnie współpracować z narzędziami AI jako naturalną częścią swojego warsztatu,
• Chcesz budować kompetencje, które realnie zwiększają Twoją wartość na rynku.

To moduł, w którym od razu budujesz przewagę praktyczną: tworzysz zestaw niezależnych aplikacji i bibliotek, które automatyzują realne zadania firmowe — pracę na plikach, Excelu, fakturach, e-mailach, audio oraz integracje z usługami chmurowymi. Rozwijasz komponenty, które możesz wprost wykorzystać w pracy (lub pokazać w portfolio), bo są projektowane w stylu komercyjnym: z czytelną separacją odpowiedzialności, konfiguracją przez zmienne środowiskowe (12-factor), typowaniem oraz testowaniem.

W praktyce przechodzisz przez pełny przekrój automatyzacji: event-driven monitor plików (Watchdog), Excel automation (openpyxl + Pandas), REST API (httpx sync/async), e-mail automation (IMAP + SMTP), audio + AI (STT/ASR: OpenAI Whisper + tłumaczenie przez LLM + TTS: ElevenLabs) oraz Google Drive (OAuth2, permissions, fasada). Wszystko w standardzie komercyjnym: walidacja, typowanie, testy, stabilna konfiguracja.

Budujesz konkretne projekty (portfolio-ready) i z każdego wynosisz gotowe komponenty do ponownego użycia:

• Projekt 1 – Monitor plików CSV: Watchdog (real-time), event-driven, architektura warstwowa, graceful shutdown.
• Projekt 2 – Biblioteka Excel: openpyxl (arkusze/style/formuły/autofit/wykresy) + Pandas (tabele przestawne).
• Projekt 3 – Backoffice kursantów: Excel CRUD + faktury przez REST API (httpx) + e-mail SMTP/TLS (HTML) + APScheduler.
• Projekt 4 – Zarządzanie skrzynką pocztową: IMAPClient, RFC822/multipart, dekodowanie nagłówków, załączniki, flagi (seen/unseen/flagged), archiwizacja, etykiety.
• Projekt 5 – Notatki głosowe z AI: nagrywanie audio (np. sounddevice) + WAV (wave), STT/ASR: Whisper, tłumaczenie LLM, TTS: ElevenLabs, testowanie zależności od sprzętu/API.
• Projekt 6 – Integracja z Google Drive: OAuth2, CRUD na plikach/folderach, rekurencja po drzewach, permissions (reader/writer/commenter).

Efekt modułu (kompetencje + portfolio): Watchdog, CSV, generyki, 12-factor config, openpyxl, Pandas, httpx (sync/async), SMTP/HTML, IMAPClient, APScheduler, Whisper (STT/ASR), ElevenLabs (TTS), Google Drive API (OAuth2, permissions, facade) — czyli automatyzacje gotowe do realnego użycia w firmie.

Wybierz ten moduł jeśli:

• Chcesz szybko zbudować praktyczne portfolio na projektach, które wyglądają jak realne wdrożenia automatyzacji,
• Chcesz automatyzować pracę na danych i dokumentach (CSV, Excel, raporty, generowanie plików),
• Chcesz integrować się z zewnętrznymi usługami przez REST API (sync i async) oraz budować wzorce pod kolejne integracje,
• Chcesz uporządkować automatyzacje „produkcyjnie” (konfiguracja przez zmienne środowiskowe, typowanie, testy, przewidywalne uruchamianie),
• Chcesz wejść w automatyzację wspieraną AI (przetwarzanie mowy, tłumaczenie, generowanie audio) i łączenie wielu API w jeden pipeline.

Po ukończeniu modułu potrafisz projektować i wdrażać automatyzacje end-to-end (pliki → raport → wysyłka / API / harmonogram / chmura), a Twoje projekty prezentują standardy ze środowiska produkcyjnego: czytelną strukturę, konfigurację, typowanie i testy.

To moduł, w którym przechodzisz od korzystania z narzędzi AI do budowy własnego agenta AI — systemu, który samodzielnie pozyskuje treści, przetwarza je w pipeline i generuje wynik w formacie gotowym do użycia w praktyce. Najważniejsze: robisz to bez gotowych frameworków, więc rozumiesz każdą warstwę (wejście danych → przetwarzanie → modele → kontrola jakości → zapis wyniku) i potrafisz tę architekturę przenieść na dowolny problem: od generowania treści po analizę i przetwarzanie dokumentów.

W praktyce budujesz agenta, który crawluje stronę (Scrapy / BeautifulSoup), czyści i segmentuje treść, a następnie klasyfikuje fragmenty i wybiera tylko to, co powinno trafić do modelu. Dzięki temu ograniczasz koszt i szum kontekstowy, a LLM pracuje na treści, która maksymalizuje jakość odpowiedzi. Na końcu agent generuje wynik (np. uporządkowane dane, treść lub raport) i serializuje go do wielu formatów (CSV/JSON/YAML/HTML/XML) jednym pipeline’em.

Budujesz też warsztat, który daje Ci elastyczność w realnych projektach: jedna warstwa abstrakcji nad LLM pozwala przełączać modele bez zmiany logiki biznesowej (OpenAI, lokalny Ollama, Gemini, Claude, HuggingFace). To oznacza, że możesz optymalizować koszty, prywatność i latencję — a agent nadal działa tak samo.

Co opanujesz w tym module?

• Warstwę abstrakcji nad modelami LLM: jeden interfejs, wielu dostawców (OpenAI / Ollama / Gemini / Claude / HF), łatwe przełączanie pod wymagania projektu.
• Lokalne modele przez Ollama: prywatność danych, praca offline, kontrola kosztów i szybkie iteracje w development.
• Scraper i crawler: różnice, zastosowania oraz pipeline pobierania i czyszczenia treści (Scrapy + BeautifulSoup).
• Pipeline NLP: czyszczenie, segmentacja, klasyfikacja segmentów i routing po etykietach (wybierasz tylko to, co ma sens dla LLM).
• Prompt engineering w YAML: prompty systemowe/użytkownika jako konfiguracja, łatwa wersjonowalność i szybkie eksperymenty.
• Wieloformatowy output: CSV/JSON/YAML/HTML/XML generowane jednym przepływem, gotowe do integracji, publikacji lub dalszego przetwarzania.
• Ewaluacja jakości: metryki klasyfikacji (accuracy, confusion matrix) oraz metryki generowania (BLEU, ROUGE-L) + świadoma interpretacja wyników.

Wybierz ten moduł jeśli:

• Chcesz zbudować własnego agenta AI od podstaw i rozumieć, co dzieje się pod spodem,
• Chcesz umieć optymalizować koszt, prywatność i jakość przez dobór modeli (chmura vs lokalnie),
• Zależy Ci na praktycznym pipeline (crawler → segmentacja/klasyfikacja → generowanie → eksport), który da się przenieść na inne problemy,
• Chcesz mieć portfolio, które pokazuje realną inżynierię AI: dane wejściowe, pipeline przetwarzania, dobór modeli, metryki jakości i eksport wyników.

Po ukończeniu tego modułu masz działającego agenta w portfolio i umiesz projektować systemy oparte na LLM w sposób świadomy: z kontrolą wejścia danych, możliwością podmiany modeli, mierzeniem jakości i eksportem wyników do formatów użytecznych w aplikacjach. To bezpośrednie przygotowanie do kolejnych etapów kursu, w których te same koncepcje wykorzystasz w bardziej rozbudowanych systemach.

To moduł, w którym uczysz się budować agentów AI w sposób inżynierski: jako konkretne wzorce architektoniczne, które da się utrzymać, testować i rozwijać. To Twoje pierwsze, uporządkowane wejście w temat agentów — fundament, na którym w kolejnych sekcjach dołożysz bardziej zaawansowane elementy, takie jak Human-in-the-Loop oraz RAG. Poznajesz dwa podejścia spotykane w projektach: ReAct Agent (model wybiera narzędzia i iteruje) oraz Sequential Agent (deterministyczny graf kroków), a następnie budujesz oba warianty w wersji synchronicznej i asynchronicznej. Dzięki temu wiesz, kiedy potrzebujesz elastyczności, a kiedy przewidywalności, testowalności i kontroli.

Pracujesz na praktycznym przykładzie agenta, który realizuje proces wieloetapowy: pobiera dane, tworzy streszczenie i wykonuje krok analizy/kompresji wyniku. W ReAct model korzysta z narzędzi, a Ty sterujesz zachowaniem przez system prompt, a w Sequential budujesz StateGraph i zarządzasz przepływem stanu przez jawnie zdefiniowane kroki. To fundament pod każdy bardziej złożony system agentowy: od agentów z narzędziami po przepływy typu human-in-the-loop i aplikacje produkcyjne.

W module kładziesz nacisk na jakość inżynierską: fabryka modeli sterowana zmienną środowiskową (OpenAI/Anthropic), spójny format wyniku, obsługa streamingu odpowiedzi, a także testy jednostkowe i asynchroniczne (pytest, pytest-asyncio) oraz statyczna analiza (mypy) i pokrycie kodu (pytest-cov).

Co opanujesz w tym module?

• LangChain fundamentals: łańcuchy prompt → model, kontrola temperatury, spójne prompt templates i praca w trybie sync/async.
• ReAct Agent: praca agenta z narzędziami, reguły działania w system prompt oraz uruchamianie w trybie invoke/stream (w tym wersje async).
• LangGraph / StateGraph: deterministyczne grafy kroków, przepływ stanu i kontrolowany workflow — czyli agent jako uporządkowany proces.
• Stan i kontrakt danych: czytelna struktura informacji przekazywanych między krokami oraz bezpieczne „doklejanie” wejścia do stanu.
• Sync i async w praktyce: ten sam wzorzec agenta w wersji synchronicznej i asynchronicznej (httpx, aiofiles, asyncio) — gotowe pod aplikacje webowe i zadania w tle.
• Model factory: wybór providera przez zmienne środowiskowe (OpenAI/Anthropic), spójna konfiguracja i łatwa podmiana modeli bez zmiany logiki.
• Jakość i testowalność: DummyModel, testy agent factories, testy narzędzi, testy kroków pipeline oraz raporty coverage.

Wybierz ten moduł jeśli:

• Chcesz rozumieć różnicę między agentem a pipeline’em i dobierać architekturę do problemu,
• Chcesz budować agentów w podejściu produkcyjnym: testy, typowanie, powtarzalność, kontrola zachowania przez prompt i graf,
• Potrzebujesz wariantów sync/async pod realne aplikacje, integracje i przetwarzanie równoległe,
• Chcesz mieć portfolio oparte o LangChain i LangGraph, które pokazuje zarówno elastyczność (ReAct), jak i deterministyczne workflow (Sequential).

Po ukończeniu modułu potrafisz projektować agentów w LangChain i LangGraph, świadomie wybierać między ReAct i Sequential, budować wersje synchroniczne i asynchroniczne oraz wdrażać standardy jakości (testy, typowanie, konfiguracja). Masz gotowy fundament pod kolejne, bardziej zaawansowane systemy agentowe — w tym moduły rozwijające agentów o Human-in-the-Loop i RAG.

To moduł, w którym uczysz się ważnej cechy agentów produkcyjnych: kontrolowanego zatrzymania i wznowienia pracy z decyzją człowieka w środku procesu. Całość realizujesz w oparciu o LangChain (warstwa LLM) i LangGraph (kontrolowany przepływ i stan agenta). Human-in-the-Loop (HITL) pozwala budować systemy, które są jednocześnie automatyczne i bezpieczne: agent wykonuje research i planowanie, ale kluczowy moment (np. akceptacja planu) zawsze przechodzi przez człowieka. Dzięki temu ograniczasz ryzyko błędów, trzymasz jakość, a jednocześnie nie rezygnujesz z przewagi automatyzacji.

Zaczynasz od wersji niewebowej (CLI), gdzie poznajesz mechanikę HITL od środka: graf LangGraph dochodzi do węzła recenzji, zatrzymuje się w kontrolowanym punkcie i czeka na decyzję. Ty wznawiasz pracę grafu decyzją człowieka i widzisz, jak działa pętla approve/revise oraz jak można wrócić do tego samego wątku po przerwie.

Następnie przechodzisz do wersji webowej w FastAPI, gdzie HITL działa jak w realnej aplikacji: klient wysyła żądanie utworzenia zadania, agent uruchamia się w tle, a API pozwala pollować status i przesłać decyzję człowieka w osobnym request’cie. Stan agenta jest zapisywany w MongoDB, a dodatkowa kolekcja metadanych pozwala szybko listować zadania bez kosztownego odpytywania stanu per rekord.

Co opanujesz w tym module?

• Kontrolowane zatrzymanie i wznowienie: wstrzymanie pracy agenta na etapie recenzji oraz bezpieczne wznowienie po decyzji człowieka.
• StateGraph jako FSM: agent jako wstrzymywalna maszyna stanów (research → plan → review → write → publish) z pętlą rewizji.
• Persystencja stanu: checkpointer w MongoDB zapisujący AgentState po krokach oraz wznawianie pracy po przerwie.
• FastAPI workflow: start zadania w tle, decyzja człowieka oraz pobranie wyniku jako pliku.
• Bezpieczna współbieżność: uruchamianie blokującego LangGraph w sposób bezpieczny wątkowo przy równoległych decyzjach.
• Stabilność operacyjna: porządek w shutdown (anulowanie background tasków, kontrola zasobów), czytelne statusy i walidacja requestów.

Wybierz ten moduł jeśli:

• Chcesz budować agentów, którym można zaufać w procesach wymagających akceptacji i kontroli jakości,
• Chcesz przenieść agenta z notebooka do aplikacji (API, statusy, persystencja, współbieżność),
• Potrzebujesz HITL w dwóch wariantach: prosty CLI do zrozumienia mechaniki i FastAPI do wdrożenia,
• Chcesz nauczyć się architektury start → review → resume, która potem świetnie łączy się z RAG i bardziej złożonymi agentami.

Po ukończeniu modułu potrafisz zaprojektować i wdrożyć Human-in-the-Loop zarówno w aplikacji lokalnej, jak i jako usługę webową: umiesz zatrzymać graf w kontrolowanym punkcie, zapisać stan, zebrać decyzję człowieka i bezpiecznie wznowić pracę. Masz gotowy wzorzec, który przenosi agentów na poziom procesów biznesowych, gdzie liczy się jakość, kontrola i przewidywalność.

To moduł, w którym budujesz system, który realnie robi różnicę w firmie: asystenta wiedzy, który odpowiada na pytania na podstawie Twoich dokumentów — szybko, tanio i z możliwością weryfikacji źródeł. Zamiast liczyć na pamięć modelu i ryzykować halucynacje, uczysz się architektury, która daje przewidywalny efekt: model generuje odpowiedź dopiero po wyszukaniu właściwych fragmentów i potrafi wskazać, skąd dokładnie bierze informacje.

W praktyce budujesz Voice-Powered Knowledge Assistant: uploadujesz dokumenty (np. PDF/DOCX/TXT/Markdown), uruchamiasz indeksowanie w tle, a potem zadajesz pytania tekstem lub głosem. System wyszukuje fragmenty w bazie wektorowej Qdrant, układa kontekst, generuje odpowiedź i zwraca ją z cytatami (plik/strona/fragment) — opcjonalnie także jako audio (STT/ASR + TTS). To jest RAG, który wygląda jak produkt: API, historia zapytań, kontrola współbieżności i uruchamianie (np. Docker Compose).

Co opanujesz w tym module?

• Dwie niezależne ścieżki RAG: indeksowanie dokumentów w tle (parse → chunk → embedding → zapis) oraz odpowiadanie na pytania w czasie rzeczywistym.
• Qdrant: szybkie wyszukiwanie semantyczne, filtrowanie po użytkowniku/dokumentach, metadane (źródła, strony, identyfikatory) i gotowość pod hybrid search.
• Chunking, embeddingi i kontrola kosztów: dzielenie treści tak, żeby retrieval był trafny, a kontekst dla LLM zwięzły i skuteczny (tokenizacja, batchowanie, stabilne parametry).
• Reranking dla jakości odpowiedzi: dodatkowa warstwa selekcji fragmentów (Cohere), która poprawia trafność bez zwiększania kontekstu i kosztów.
• LangChain + LangGraph w RAG: uporządkowany pipeline, w którym retrieval, selekcja kontekstu i generowanie odpowiedzi są częścią kontrolowanego workflow.
• Tryb voice: pytanie głosowe → transkrypcja (Whisper) → odpowiedź oparta o źródła → synteza mowy (ElevenLabs) jako gotowy asystent głosowy pod produkt.
• Ewaluacja jakości przez RAGAs: mierzysz system liczbami (m.in. faithfulness, answer relevancy, context precision/recall), żeby świadomie poprawiać retrieval i ograniczać halucynacje.

Wybierz ten moduł jeśli:

• Chcesz, żeby AI odpowiadało na podstawie Twoich danych, a nie na podstawie ogólnej wiedzy modelu,
• Potrzebujesz odpowiedzi z weryfikowalnymi źródłami (compliance, audyt, zaufanie użytkownika),
• Chcesz zbudować RAG produktowo: API, historia, stabilne uruchomienie, kontrola współbieżności i kosztów,
• Chcesz umieć mierzyć jakość RAG i iterować na metrykach — dlatego w module jest też RAGAs.

Po ukończeniu modułu masz w portfolio kompletną usługę RAG: od indeksowania dokumentów, przez wyszukiwanie i generowanie odpowiedzi z cytatami, po voice mode i twardą ewaluację jakości. Co ważne: potrafisz nie tylko uruchomić RAG, ale świadomie go stroić i bronić jakości metrykami — czyli podejściem, którego oczekuje rynek.

To moduł, w którym przechodzisz przez cały proces tworzenia modelu ML/DL tak, jak wygląda to w realnych projektach: od analizy problemu i danych, przez przygotowanie i uczenie, aż po gotowy artefakt modelu oraz plik uruchomieniowy, który pozwala odpalić predykcję na nowych danych. Zamiast trenować w notebooku, budujesz workflow, który da się powtarzać, rozwijać i uruchamiać na żądanie — dokładnie tak, jak pracuje się z modelami w praktyce.

Zaczynasz od środowiska: porównujesz podejścia (np. Google Colab, GitHub Codespaces, Anaconda) i rozumiesz, kiedy ma sens CPU, GPU lub TPU. Następnie pracujesz na danych tablicowych (m.in. klasyczny dataset housing) i uczysz się budować rozwiązania, które nie rozpadają się po pierwszej zmianie danych: preprocessing, transformatory, ColumnTransformer i Pipelines w Scikit-Learn. Finalnie zapisujesz model/pipeline i przygotowujesz prosty, powtarzalny sposób uruchomienia inferencji (wejście → predykcja → wynik) na nowych rekordach.

Co opanujesz w tym module?

• Analiza problemu i selekcja danych: jak przełożyć problem biznesowy na zadanie ML i jak rozpoznać, czego naprawdę potrzebujesz w danych.
• Podział danych i walidacja: train/test split (w tym podział warstwowy), kontrola losowości i unikanie typowych pułapek, które fałszują wyniki.
• Preprocessing i transformatory: czyszczenie, skalowanie, kodowanie cech oraz budowanie własnych transformatorów pod specyfikę danych.
• Pipelines + ColumnTransformer: jeden, spójny potok „dane → cechy → model”, który eliminuje błędy, skraca iteracje i jest gotowy do produkcyjnego uruchomienia.
• Ewaluacja i diagnostyka: metryki jakości, analiza błędów i interpretacja wyników, żebyś wiedział nie tylko „ile wyszło”, ale dlaczego.
• Strojenie hiperparametrów: szybkie i praktyczne tuningowanie modeli (np. RandomizedSearchCV) oraz wybór finalnego wariantu pod wymagania projektu.
• Wdrożenie modelu: zapis wytrenowanego modelu/pipeline jako artefaktu oraz przygotowanie pliku uruchomieniowego do predykcji na nowych danych.

Wybierz ten moduł jeśli:

• Chcesz budować modele, które da się wdrażać, a nie tylko uruchamiać lokalnie w notebooku,
• Chcesz mieć „szablon” procesu ML do dowolnego problemu: dane → pipeline → model → tuning → uruchomienie,
• Chcesz wzmocnić portfolio o praktyczny projekt end-to-end (przygotowanie danych + pipeline + wdrożenie),
• Chcesz rozumieć ML i DL od fundamentów i podejmować dobre decyzje techniczne (środowisko, zasoby obliczeniowe, metryki, jakość).

Po ukończeniu modułu potrafisz przeprowadzić projekt ML/DL od zera do uruchomienia: umiesz dobrać dane, zbudować powtarzalny pipeline, porównać i dostroić modele, a następnie przygotować artefakt i plik uruchomieniowy, który daje predykcje na nowych danych. To kompetencja, która odróżnia „kogoś, kto zna algorytmy” od osoby, która potrafi dowieźć model do użycia.

To moduł, który daje Ci mapę decyzyjną po świecie modeli. Zamiast uczyć się „kolejnych algorytmów”, uczysz się jak wybierać właściwy model, jak rozumieć kompromisy (bias/variance, interpretowalność, koszt uczenia i inferencji) i jak oceniać jakość tak, żeby nie oszukiwać samego siebie metrykami.

Szczegółowo poznajesz podejścia, które najczęściej wygrywają w praktyce: klasyczne modele Scikit-Learn (klasyfikacja i regresja), SVM, drzewa i ensemble (Random Forest, boosting) oraz wątki „poza etykietami” — uczenie nienadzorowane i wykrywanie anomalii. Na końcu domykasz obraz w świecie Deep Learning: fundamenty sieci neuronowych i praktyka w TensorFlow/Keras (MLP, monitoring uczenia, tuning hiperparametrów, stabilizacja treningu).

Co opanujesz w tym module?

• Klasyfikacja: binarna, wieloklasowa, wieloetykietowa i wielowyjściowa + dobór metryk i czytanie wyników.
• Regresja i uczenie modeli: od prostych modeli po techniki regularyzacji, uczenie iteracyjne (SGD/mini-batch) i praktyczne pułapki.
• SVM: kiedy ma sens, jak działa klasyfikacja nieliniowa i na co uważać w doborze ustawień.
• Drzewa i lasy: drzewa dla klasyfikacji i regresji, problemy wariancji oraz dlaczego lasy losowe są często „bezpiecznym” wyborem.
• Ensemble i boosting: AdaBoost, Gradient Boosting i histogram-based gradient boosting — czyli jak wyciskać jakość bez magii, tylko świadomą konstrukcją modeli.
• Redukcja wymiarów: PCA i metody nieliniowe — po co się je stosuje i jak wspierają model (szybkość, stabilność, wizualizacja).
• Uczenie nienadzorowane: grupowanie i praca bez etykiet + DBSCAN w praktyce.
• Wykrywanie anomalii: podejścia praktyczne (m.in. mieszaniny gaussowskie) i kiedy to jest lepsze niż „klasyczna klasyfikacja”.
• Deep Learning w pigułce (Keras): MLP w TensorFlow/Keras, monitoring treningu (np. TensorBoard), tuning hiperparametrów (Keras Tuner) oraz techniki poprawy jakości i stabilności (learning rate, optymalizatory, dropout, batch normalization, gradient clipping).

Wybierz ten moduł jeśli:

• Chcesz wiedzieć, jaki model wybrać i dlaczego — zamiast losowo testować algorytmy,
• Chcesz umieć porównywać modele uczciwie (metryki, analiza błędów, interpretacja),
• Chcesz poznać przekrój podejść od ML do DL i rozumieć ich mocne/słabe strony,
• Zależy Ci na praktycznych „heurystykach”, które przyspieszają dowożenie jakości w projekcie.

Po ukończeniu modułu umiesz świadomie dobrać model do problemu, danych i ograniczeń projektu — i umiesz uzasadnić ten wybór. To Twój „kompas” na kolejne wdrożenia: wiesz, kiedy wystarczy prosty model liniowy, kiedy warto wejść w ensemble, a kiedy dopiero sieci neuronowe mają sens.

Po ukończeniu kursu Python AI potrafisz projektować i rozwijać nowoczesne systemy oparte o sztuczną inteligencję: od automatyzacji i agentów, przez Human-in-the-Loop i RAG, po pełne pipeline’y Machine Learning / Deep Learning.

Masz gotowe portfolio projektów, które pokazuje nie tylko znajomość narzędzi, ale przede wszystkim umiejętność dowożenia rozwiązań end-to-end w standardzie produkcyjnym.

Rekomendowana ścieżka rozwoju to: Python → Python Data Science → Python AI.