Przejdź do treści

Jak Stworzyć Pierwszą Sieć Neuronową w Pythonie - Poradnik 2026

Chcesz zbudować pierwszą sieć neuronową w Pythonie? Ten poradnik prowadzi Cię krok po kroku, od instalacji bibliotek po trening modelu i ocenę wyników.

Zespół VITA6 min czytania

Jak stworzyć sieć neuronową w Pythonie? Wystarczą cztery biblioteki, kilkadziesiąt linii kodu i jedno konkretne zadanie do rozwiązania. W tym poradniku budujesz pełny model od zera: instalujesz środowisko, przygotowujesz dane, definiujesz architekturę sieci, trenujesz ją i oceniasz wyniki. Każdy krok jest opisany tak, żebyś rozumiał, co się dzieje pod spodem, a nie tylko kopiował kod. Zaczynamy.

Czym jest sieć neuronowa i dlaczego Python?

Sieć neuronowa to model obliczeniowy zbudowany z warstw węzłów (neuronów), które przetwarzają dane wejściowe i na ich podstawie uczą się rozpoznawać wzorce. Inspiracją jest biologia, ale w praktyce to po prostu zbiór mnożeń macierzowych i nieliniowych funkcji aktywacji.

Python dominuje w tej dziedzinie z trzech powodów. Po pierwsze, biblioteki takie jak TensorFlow, Keras i PyTorch mają API napisane właśnie pod Pythona. Po drugie, ekosystem naukowy (NumPy, Pandas, Matplotlib) ułatwia przygotowanie danych. Po trzecie, społeczność jest ogromna: Stack Overflow, GitHub, Kaggle, arXiv, wszystko ma przykłady w Pythonie.

Według JetBrains Developer Survey 2024, Python jest językiem numer jeden w obszarze machine learningu i data science, używanym przez ponad 70% specjalistów.

TensorFlow czy PyTorch?

Oba frameworki są dojrzałe i produkcyjne. TensorFlow z Keras jest wygodniejszy dla początkujących: wyższy poziom abstrakcji, mniej konfiguracji. PyTorch daje więcej kontroli i dominuje w środowisku badawczym. W tym poradniku używamy Keras (TensorFlow 2.x), bo kod jest czytelniejszy i szybciej daje działający wynik.

Przygotowanie środowiska

Zanim napiszesz pierwszą linię kodu, musisz skonfigurować środowisko. Zalecam wirtualne środowisko (venv lub conda), żeby nie zaśmiecać globalnej instalacji Pythona.

Instalacja krok po kroku

Terminal
# Utwórz i aktywuj wirtualne środowisko
python -m venv neural-env
source neural-env/bin/activate   # Linux / macOS
neural-env\Scripts\activate      # Windows

# Zainstaluj biblioteki
pip install tensorflow numpy pandas scikit-learn matplotlib

Potrzebujesz Pythona w wersji 3.9 lub nowszej. TensorFlow 2.16+ obsługuje Python do 3.12. Sprawdź wersję poleceniem python --version.

Alternatywą bez instalacji jest Google Colab: darmowe środowisko w chmurze z GPU, które ma TensorFlow preinstalowany. Wystarczy konto Google i otwarta przeglądarka.

Wybór zadania i zbioru danych

Pierwsza sieć neuronowa dla początkujących powinna rozwiązywać prosty, dobrze zdefiniowany problem. Klasycznym wyborem jest klasyfikacja cyfr MNIST: 70 000 obrazów odręcznie pisanych cyfr (0-9), każdy o rozmiarze 28x28 pikseli.

MNIST jest dostępny bezpośrednio w Keras:

Python
from tensorflow.keras.datasets import mnist

(X_train, y_train), (X_test, y_test) = mnist.load_data()
print(X_train.shape)  # (60000, 28, 28)
print(y_train.shape)  # (60000,)

Zbiór treningowy zawiera 60 000 próbek, testowy 10 000. To wystarczy, żeby sieć nauczyła się rozpoznawać cyfry z dokładnością przekraczającą 97%.

Przygotowanie danych

Surowe dane rzadko nadają się od razu do treningu. Musisz:

  1. Spłaszczyć obrazy: zamiast macierzy 28x28 (784 piksele) przekazujesz do sieci wektor 784 wartości.
  2. Znormalizować wartości: piksele mają wartości 0-255, dzielisz przez 255, żeby uzyskać zakres 0-1. Sieci uczą się szybciej i stabilniej na małych wartościach.
  3. Zakodować etykiety: zamieniasz liczby 0-9 na wektory one-hot (np. cyfra 3 staje się [0,0,0,1,0,0,0,0,0,0]).
Python
import numpy as np
from tensorflow.keras.utils import to_categorical

# Spłaszczenie i normalizacja
X_train = X_train.reshape(-1, 784).astype("float32") / 255.0
X_test  = X_test.reshape(-1, 784).astype("float32") / 255.0

# Kodowanie etykiet
y_train = to_categorical(y_train, 10)
y_test  = to_categorical(y_test, 10)

Budowanie architektury sieci neuronowej

To serce całego procesu. Definiujesz, ile warstw ma sieć, ile neuronów w każdej z nich i jaką funkcję aktywacji stosować.

Warstwy i neurony

W Keras najwygodniej buduje się modele przez Sequential: dodajesz warstwy jedna po drugiej.

Python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout

model = Sequential([
    Dense(256, activation="relu", input_shape=(784,)),
    Dropout(0.3),
    Dense(128, activation="relu"),
    Dropout(0.3),
    Dense(10, activation="softmax")
])

Co tu się dzieje?

  • Dense(256, activation="relu"): w pełni połączona warstwa z 256 neuronami i funkcją aktywacji ReLU (Rectified Linear Unit). ReLU zwraca zero dla wartości ujemnych i wartość niezmienioną dla dodatnich. To najpopularniejszy wybór w warstwach ukrytych.
  • Dropout(0.3): podczas treningu losowo wyłącza 30% neuronów. Zapobiega przeuczeniu (overfitting), czyli sytuacji, gdy model zapamiętuje dane zamiast uczyć się wzorców.
  • Dense(10, activation="softmax"): wyjście. Softmax zamienia 10 liczb na rozkład prawdopodobieństwa, który sumuje się do 1. Wynik z największym prawdopodobieństwem to predykowana cyfra.

Parametry modelu

Sprawdź, ile parametrów (wag) ma Twoja sieć:

Python
model.summary()

Dla powyższej architektury to około 235 000 parametrów. Każdy z nich jest aktualizowany podczas treningu.

Kompilacja i trening modelu

Zanim zaczniesz trenować, musisz skompilować model: wybrać optymalizator, funkcję straty i metryki.

Python
model.compile(
    optimizer="adam",
    loss="categorical_crossentropy",
    metrics=["accuracy"]
)
  • Adam: adaptacyjny optymalizator gradientowy. W praktyce działa dobrze bez ręcznego dobierania learning rate.
  • categorical_crossentropy: standardowa funkcja straty dla klasyfikacji wieloklasowej z kodowaniem one-hot.
  • accuracy: procent poprawnie sklasyfikowanych próbek.

Uruchomienie treningu

Python
history = model.fit(
    X_train, y_train,
    epochs=20,
    batch_size=128,
    validation_split=0.1,
    verbose=1
)
  • epochs=20: sieć przejdzie przez cały zbiór treningowy 20 razy.
  • batch_size=128: wagi są aktualizowane po każdych 128 próbkach (mini-batch gradient descent).
  • validation_split=0.1: 10% danych treningowych (6 000 próbek) jest używanych do walidacji po każdej epoce.

Na zwykłym laptopie (CPU) trening zajmie kilka minut. Na GPU lub w Google Colab poniżej minuty.

Ocena wyników i wizualizacja

Po treningu sprawdzasz, jak sieć radzi sobie na danych, których nigdy nie widziała.

Python
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
print(f"Dokładność na zbiorze testowym: {test_acc:.4f}")

Dla opisanej architektury spodziewaj się wyników 97-98%. To oznacza, że na 10 000 obrazów sieć popełnia 200-300 błędów.

Wizualizacja krzywych uczenia

Python
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history["accuracy"], label="Trening")
plt.plot(history.history["val_accuracy"], label="Walidacja")
plt.title("Dokładność")
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history["loss"], label="Trening")
plt.plot(history.history["val_loss"], label="Walidacja")
plt.title("Strata")
plt.legend()

plt.tight_layout()
plt.show()

Patrz na rozbieżność między krzywą treningową a walidacyjną. Jeśli model osiąga 99% na treningu, a 90% na walidacji, to sygnał przeuczenia. Zwiększ Dropout lub zmniejsz liczbę neuronów.

Najczęstsze błędy i jak ich unikać

Tworzenie sieci neuronowych krok po kroku wygląda prosto, ale w praktyce napotkasz pułapki. Oto najczęstsze z nich.

Brak normalizacji danych

Jeśli zapomnisz podzielić piksele przez 255, sieć będzie się uczyć znacznie wolniej albo wcale. Gradient będzie miał za duże wartości, a wagi nie będą stabilnie zbiegać.

Zły kształt danych wejściowych

Keras jest precyzyjny co do wymiarów tensorów. Sprawdzaj X_train.shape przed kompilacją. Pomyłka o jeden wymiar powoduje trudne do debugowania błędy.

Zbyt duży learning rate

Domyślny Adam (lr=0.001) działa dobrze dla większości zadań. Jeśli strata oscyluje zamiast maleć, spróbuj lr=0.0001.

Overfitting bez walidacji

Zawsze używaj validation_split lub osobnego zbioru walidacyjnego. Bez niego nie wiesz, czy model generalizuje, czy tylko zapamiętuje dane.

Dobry model to taki, który dobrze radzi sobie z danymi, których nie widział podczas treningu. Wysoka dokładność na zbiorze treningowym bez analogicznego wyniku na walidacji to czerwona flaga.

Co dalej po pierwszej sieci neuronowej?

Skończyłeś klasyfikację MNIST. To dobry punkt startowy, ale sieć neuronowa dla początkujących to dopiero wstęp do rozleglejszego tematu.

Kolejne kroki

  1. Konwolucyjne sieci neuronowe (CNN): lepsze do obrazów. Zamiast spłaszczać macierz 28x28, CNN „przesuwa" filtry po obrazie i wyciąga lokalne cechy. Accuracy na MNIST przekracza 99,5%.
  2. Transfer learning: zamiast trenować od zera, bierzesz wytrenowany model (np. ResNet50, MobileNetV2) i dostosowujesz do swojego zadania. Przydatne, gdy masz mało danych.
  3. Rekurencyjne sieci neuronowe (RNN) i Transformery: do danych sekwencyjnych, takich jak tekst, dźwięk czy szeregi czasowe.
  4. Kaggle: rozwiąż jeden z konkursów dla początkujących (Titanic, House Prices) i porównaj swoje wyniki z innymi.

Jeśli chcesz zrozumieć nie tylko kod, ale też mechanizmy stojące za algorytmami, propagacją wsteczną i tym, jak modele „myślą", kurs Sztuczna Inteligencja: Jak Działa AI od Środka na VITA przeprowadzi Cię przez te zagadnienia od podstaw aż po zaawansowane koncepcje.

Wypróbuj VITA przez 3 dni za 0 zł. Podajesz kartę, zyskujesz pełny dostęp do wszystkich kursów w abonamencie, w tym do kursu Sztuczna Inteligencja: Jak Działa AI od Środka. Jeśli kurs ma egzamin końcowy, możesz go zdać już w trakcie okresu próbnego, a certyfikat otrzymasz po pierwszej płatności, którą możesz zlecić od razu z poziomu panelu. Anulujesz jednym kliknięciem przed końcem trzeciego dnia i nie płacisz nic. Potem abonament to 79 zł miesięcznie albo 590 zł rocznie. Zacznij teraz na vita.edu.pl/abonament.

Zasoby i narzędzia, które warto znać

Ucząc się tworzenia sieci neuronowych w Pythonie, korzystaj ze sprawdzonych źródeł:

  • Oficjalna dokumentacja Keras: keras.io z gotowymi przykładami i API reference.
  • TensorFlow Playground: interaktywna wizualizacja sieci neuronowej w przeglądarce, bez pisania kodu. Adres: playground.tensorflow.org.
  • Fast.ai: praktyczny kurs deep learningu, darmowy, skupiony na wynikach, nie na teorii.
  • Papers with Code: paperswithcode.com, jeśli chcesz śledzić najnowsze wyniki benchmarków.
  • Google Colab: darmowe GPU, gotowe środowisko Python, integracja z Drive.

Zapisuj eksperymenty. MLflow i Weights & Biases to narzędzia do śledzenia parametrów, wyników i artefaktów modeli. Nawet dla projektów edukacyjnych warto wyrobić ten nawyk wcześnie.

Najczęściej zadawane pytania

Ile czasu zajmuje nauka budowania sieci neuronowych w Pythonie od zera?

Pierwszą działającą sieć neuronową możesz zbudować w ciągu jednego dnia, znając podstawy Pythona. Zrozumienie mechanizmów takich jak propagacja wsteczna, funkcje aktywacji czy regularyzacja wymaga kilku tygodni regularnej nauki i praktyki na różnych zbiorach danych.

Czy potrzebuję GPU, żeby trenować sieć neuronową w Pythonie?

Nie. Proste sieci do klasyfikacji obrazów MNIST czy danych tabelarycznych działają sprawnie na zwykłym procesorze i trenują się w kilka minut. GPU przyspiesza trening dużych modeli i sieci konwolucyjnych. Darmową alternatywą jest Google Colab z bezpłatnym dostępem do GPU.

Keras czy PyTorch dla początkujących?

Keras (TensorFlow 2.x) jest lepszym wyborem na start: ma wyższy poziom abstrakcji, mniej kodu i czytelniejsze API. PyTorch daje więcej elastyczności i dominuje w badaniach naukowych, ale wymaga głębszej wiedzy o operacjach na tensorach. Po opanowaniu Keras przejście na PyTorch jest znacznie prostsze.

Co to jest overfitting i jak go uniknąć?

Overfitting (przeuczenie) to sytuacja, gdy sieć zapamiętuje dane treningowe zamiast uczyć się ogólnych wzorców. Objawia się wysoką dokładnością na treningu i niską na zbiorze testowym. Zapobiega mu Dropout, regularyzacja L2, augmentacja danych oraz wczesne zatrzymanie treningu (EarlyStopping w Keras).

Jaka dokładność jest dobra dla sieci neuronowej na MNIST?

Prosta sieć w pełni połączona (Dense) osiąga 97-98% dokładności na zbiorze testowym MNIST. Konwolucyjne sieci neuronowe (CNN) przekraczają 99,5%. Ludzki poziom błędów na tym zbiorze szacuje się na około 0,2%, więc głębokie sieci są w praktyce lepsze od człowieka.

Czy Python 3.12 działa z TensorFlow?

Tak. Od TensorFlow 2.16 oficjalnie obsługiwany jest Python 3.12. Zawsze sprawdzaj aktualną tabelę kompatybilności na stronie tensorflow.org przed instalacją, bo wymogi mogą się zmieniać między wersjami biblioteki.

Udostępnij artykuł

FacebookLinkedInX

Polecane kursy

Powiązane artykuły