Sztuczna inteligencja w Twoim codziennym życiu: Przykłady, które Cię zaskoczą

Często myślimy o sztucznej inteligencji (AI) jako o czymś odległym, związanym z robotami przyszłości lub zaawansowanymi badaniami naukowymi. Prawda jest jednak taka, że AI otacza nas już teraz, i to w wielu aspektach życia codziennego w Polsce. Jako programiści, mamy wyjątkową możliwość zrozumienia i wykorzystania tego potencjału. W tym artykule pokażemy Ci kilka zaskakujących przykładów zastosowania AI, które z pewnością spotkałeś w swoim codziennym życiu, a może nawet z nich korzystasz, nie zdając sobie z tego sprawy. Skupimy się na konkretnych, praktycznych przykładach, które możesz spróbować odtworzyć, a także podpowiemy, jak zacząć samodzielnie eksplorować ten fascynujący świat.

Wprowadzenie: AI dla początkujących – co warto wiedzieć?

Zanim przejdziemy do konkretnych przykładów, warto przypomnieć sobie, czym właściwie jest sztuczna inteligencja. Najprościej mówiąc, AI to zdolność maszyn do wykonywania zadań, które zwykle wymagają inteligencji ludzkiej. Mówimy tu o uczeniu się, rozwiązywaniu problemów, rozpoznawaniu wzorców, rozumieniu języka naturalnego i wielu innych.

AI dzieli się na kilka poddziedzin, z których najważniejsze to:

• Uczenie maszynowe (Machine Learning, ML): Algorytmy, które “uczą się” na podstawie danych, bez konieczności bezpośredniego programowania. Dzieli się na uczenie nadzorowane, nienadzorowane i ze wzmocnieniem.
• Przetwarzanie języka naturalnego (Natural Language Processing, NLP): Dziedzina zajmująca się umożliwianiem komputerom rozumienia i generowania ludzkiego języka.
• Widzenie komputerowe (Computer Vision): Technologie pozwalające komputerom “widzieć” i interpretować obrazy oraz filmy.
• Robotyka: Projektowanie, budowa, obsługa i zastosowanie robotów. Często wykorzystuje elementy ML, NLP i Computer Vision.

W dalszej części artykułu zobaczymy, jak te dziedziny znajdują zastosowanie w konkretnych przykładach w Polsce.

1. Inteligentne rekomendacje w e-commerce

Prawdopodobnie każdy z nas korzystał z platform e-commerce, takich jak Allegro, Empik czy Zalando. Czy kiedykolwiek zastanawiałeś się, jak to się dzieje, że po obejrzeniu jednego produktu, platforma natychmiast podsuwa Ci inne, które mogą Cię zainteresować? To zasługa algorytmów rekomendacji, które wykorzystują uczenie maszynowe.

Jak to działa?

Algorytmy te analizują Twoją historię przeglądania, zakupy, oceny produktów, a także dane o innych użytkownikach, którzy zachowywali się podobnie do Ciebie. Na podstawie tych informacji, model ML przewiduje, jakie produkty mają największą szansę Ci się spodobać.

Przykład kodu (uproszczony, w Pythonie z biblioteką scikit-learn):

# Import potrzebnych bibliotek
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import pandas as pd

# Załóżmy, że mamy dane o preferencjach użytkowników
# Dane są reprezentowane jako DataFrame z kolumnami:
# 'uzytkownik_id', 'produkt_id', 'ocena'

# Przykładowe dane (można załadować z pliku CSV)
dane = {'uzytkownik_id': [1, 1, 2, 2, 3, 3, 4, 4],
        'produkt_id': [101, 102, 101, 103, 102, 104, 103, 105],
        'ocena': [5, 4, 3, 5, 2, 4, 1, 5]}

df = pd.DataFrame(dane)

# Przygotowanie danych do modelu
X = df[['uzytkownik_id', 'produkt_id']] # Cechy (features)
y = df['ocena'] # Etykiety (labels)

# Podział danych na zbiór treningowy i testowy
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Wybór modelu (K-Najbliższych Sąsiadów)
model = KNeighborsClassifier(n_neighbors=3)

# Trenowanie modelu na zbiorze treningowym
model.fit(X_train, y_train)

# Przykładowe predykcje dla nowego użytkownika (np. uzytkownik_id=5)
nowy_uzytkownik = pd.DataFrame({'uzytkownik_id': [5, 5, 5], 'produkt_id': [101, 102, 103]})
predykcje = model.predict(nowy_uzytkownik)

print(f"Predykcje ocen dla nowego użytkownika: {predykcje}")

# Wynik: Przykładowo, algorytm może przewidzieć oceny dla produktów 101, 102, 103 dla użytkownika 5.
# Na podstawie tych predykcji, e-commerce może zasugerować produkty z najwyższą przewidywaną oceną.

Opis kodu:

1. Import bibliotek: Importujemy sklearn (scikit-learn) - bibliotekę do uczenia maszynowego, pandas - do pracy z danymi w formie tabelarycznej (DataFrame).
2. Dane: Tworzymy DataFrame z przykładowymi danymi o ocenach produktów przez użytkowników. W realnym scenariuszu, dane pochodziłyby z bazy danych.
3. Przygotowanie danych: Wybieramy kolumny 'uzytkownik_id' i 'produkt_id' jako cechy (X), a kolumnę 'ocena' jako etykiety (y).
4. Podział danych: Dzielimy dane na zbiór treningowy i testowy. Zbiór treningowy służy do “nauczenia” modelu, a zbiór testowy do oceny jego skuteczności.
5. Wybór modelu: Wybieramy model K-Najbliższych Sąsiadów (KNeighborsClassifier). Jest to prosty algorytm, który klasyfikuje dane na podstawie odległości do najbliższych sąsiadów w przestrzeni cech.
6. Trenowanie modelu: Trenujemy model na zbiorze treningowym, czyli algorytm uczy się relacji między użytkownikami, produktami i ocenami.
7. Predykcje: Wykonujemy predykcje dla nowego użytkownika. Na podstawie historii ocen innych użytkowników, algorytm przewiduje, jakie oceny przypisałby nowy użytkownik do różnych produktów.

Eksperymenty:

• Spróbuj zmienić algorytm rekomendacji na inny, np. RandomForestClassifier.
• Eksperymentuj z różnymi wartościami parametru n_neighbors w KNeighborsClassifier. Zobacz, jak zmienia się dokładność modelu.
• Spróbuj dodać więcej cech, np. informacje o produkcie (kategoria, cena).

2. Chatboty obsługi klienta

Coraz częściej, kontaktując się z obsługą klienta różnych firm w Polsce, trafiamy na chatboty. Spotykamy je na stronach internetowych banków (np. PKO BP, mBank), operatorów telekomunikacyjnych (np. Orange, Play) czy sklepów internetowych. Chatboty to programy, które potrafią prowadzić rozmowę z użytkownikiem, odpowiadając na pytania, udzielając informacji i pomagając rozwiązać problemy.

Jak to działa?

Chatboty wykorzystują techniki NLP, takie jak rozpoznawanie intencji (Intent Recognition) i ekstrakcja encji (Entity Extraction). Kiedy użytkownik zadaje pytanie, chatbot analizuje treść wiadomości, identyfikuje intencję użytkownika (np. “chcę sprawdzić stan konta”) i wyodrębnia potrzebne informacje (np. numer konta). Na podstawie tych informacji, chatbot generuje odpowiedź lub kieruje użytkownika do odpowiedniego działu obsługi klienta.

Przykład kodu (uproszczony, z użyciem biblioteki Rasa):

Rasa to popularny framework do tworzenia chatbotów. Wymaga on konfiguracji w plikach YAML.

1. intents.yml: Definiuje intencje (czyli, co użytkownik chce zrobić).

version: "3.1"

intents:
  - greet
  - goodbye
  - ask_balance
  - affirm
  - deny

2. stories.yml: Określa ścieżki konwersacji (czyli, jak chatbot powinien reagować na różne intencje użytkownika).

version: "3.1"

stories:
  - story: Greeting user
    steps:
      - intent: greet
      - action: utter_greet

  - story: Ask for account balance
    steps:
      - intent: ask_balance
      - action: utter_ask_account_number
      - intent: affirm
      - action: utter_show_balance

3. responses.yml: Zawiera definicje odpowiedzi chatbota.

version: "3.1"

responses:
  utter_greet:
  - text: "Cześć! Jak mogę Ci pomóc?"

  utter_ask_account_number:
  - text: "Aby sprawdzić stan konta, podaj numer konta."

  utter_show_balance:
  - text: "Twój stan konta to 1234.56 PLN."

4. config.yml: Konfiguracja pipeline (czyli sekwencja komponentów NLP, które przetwarzają tekst).

language: pl

pipeline:
  - name: WhitespaceTokenizer
  - name: RegexFeaturizer
  - name: LexicalSyntacticFeaturizer
  - name: CountVectorsFeaturizer
  - name: CountVectorsFeaturizer
    analyzer: "char_wb"
    min_ngram: 1
    max_ngram: 4
  - name: DIETClassifier
    epochs: 100
  - name: EntitySynonymMapper
  - name: ResponseSelector
    epochs: 100
  - name: FallbackClassifier
    threshold: 0.3
    ambiguity_threshold: 0.1

policies:
  - name: MemoizationPolicy
  - name: RulePolicy
  - name: UnfeaturizedSlotPolicy
  - name: TEDPolicy
    max_history: 5
    epochs: 100
    constrain_similarities: true

Opis:

• Rasa: Jest to framework do tworzenia chatbotów konwersacyjnych.
• intents.yml: Definiuje, jakie intencje użytkowników chatbot może rozumieć (np. powitanie, zapytanie o stan konta).
• stories.yml: Opisuje, jak chatbot powinien reagować na różne intencje użytkowników i jak powinna przebiegać konwersacja.
• responses.yml: Zawiera gotowe odpowiedzi, które chatbot może używać w odpowiedzi na intencje użytkowników.
• config.yml: Konfiguruje pipeline przetwarzania języka naturalnego, który analizuje tekst wprowadzony przez użytkownika i określa jego intencję.

Eksperymenty:

• Dodaj nowe intencje i odpowiedzi do chatbota.
• Spróbuj zintegrować chatbot z bazą danych, aby mógł pobierać informacje o użytkownikach (np. stan konta).
• Wykorzystaj biblioteki takie jak Spacy dla języka polskiego do lepszej analizy tekstu.

3. Rozpoznawanie mowy i tłumaczenie w aplikacjach

Czy kiedykolwiek korzystałeś z Asystenta Google po polsku, dyktowałeś wiadomości w telefonie lub używałeś tłumacza Google do tłumaczenia stron internetowych na język polski? To wszystko możliwe dzięki AI, a konkretnie dzięki technologiom rozpoznawania mowy (Speech Recognition) i tłumaczenia maszynowego (Machine Translation).

Jak to działa?

• Rozpoznawanie mowy: Algorytmy przetwarzają sygnał audio, analizują dźwięki, dopasowują je do fonemów i na podstawie modeli językowych (czyli wiedzy o prawdopodobieństwie występowania poszczególnych słów i fraz w danym języku) transkrybują mowę na tekst.
• Tłumaczenie maszynowe: Algorytmy analizują strukturę i znaczenie tekstu w jednym języku, a następnie generują tekst w innym języku, zachowując sens i gramatyczną poprawność. Nowoczesne systemy tłumaczenia maszynowego wykorzystują sieci neuronowe (tzw. Transformer Networks), które są bardzo skuteczne w przetwarzaniu sekwencji danych (takich jak tekst).

Przykład kodu (uproszczony, wykorzystanie biblioteki SpeechRecognition w Pythonie):

import speech_recognition as sr

# Inicjalizacja recognizera
r = sr.Recognizer()

# Użycie mikrofonu jako źródła dźwięku
with sr.Microphone() as source:
    print("Powiedz coś!")
    audio = r.listen(source)

try:
    # Rozpoznawanie mowy przy użyciu Google Speech Recognition
    tekst = r.recognize_google(audio, language="pl-PL")
    print("Powiedziałeś: " + tekst)

except sr.UnknownValueError:
    print("Nie mogłem zrozumieć audio")
except sr.RequestError as e:
    print("Nie mogłem połączyć się z Google Speech Recognition service; {0}".format(e))

# Wynik: Program nagrywa dźwięk z mikrofonu i wyświetla rozpoznany tekst.

Opis kodu:

1. Import biblioteki: Importujemy bibliotekę speech_recognition.
2. Inicjalizacja recognizera: Tworzymy obiekt Recognizer, który będzie odpowiedzialny za rozpoznawanie mowy.
3. Użycie mikrofonu: Otwieramy połączenie z mikrofonem i nagrywamy dźwięk.
4. Rozpoznawanie mowy: Korzystamy z funkcji recognize_google do rozpoznawania mowy przy użyciu serwisu Google Speech Recognition. Parametr language określa język, w jakim mówimy.
5. Obsługa błędów: Obsługujemy wyjątki, które mogą wystąpić podczas rozpoznawania mowy (np. brak połączenia z internetem, nierozpoznany dźwięk).

Eksperymenty:

• Spróbuj użyć innych serwisów rozpoznawania mowy, np. Sphinx.
• Zintegruj rozpoznawanie mowy z chatbotem, aby użytkownicy mogli rozmawiać z chatbotem głosowo.
• Wypróbuj różne języki w parametrze language.

4. Systemy rekomendacji filmów i muzyki

Serwisy streamingowe, takie jak Netflix, Spotify czy YouTube, korzystają z zaawansowanych systemów rekomendacji, które analizują Twoje preferencje muzyczne i filmowe, sugerując Ci nowe utwory i filmy, które mogą Ci się spodobać.

Jak to działa?

Systemy te wykorzystują różne techniki, w tym:

• Filtrowanie kolaboratywne: Analizuje preferencje użytkowników o podobnych gustach do Twojego i rekomenduje Ci filmy/muzykę, które im się podobały.
• Filtrowanie oparte na treści: Analizuje cechy filmów/muzyki (np. gatunek, aktorzy, reżyser, instrumenty) i rekomenduje Ci te, które są podobne do tych, które lubisz.
• Hybrydowe podejście: Łączy filtrowanie kolaboratywne i oparte na treści, aby uzyskać lepsze wyniki.

Przykład kodu (uproszczony, filtrowanie kolaboratywne w Pythonie):

import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

# Dane (uproszczone, użytkownicy i ich oceny filmów)
dane = {'uzytkownik_id': [1, 1, 1, 2, 2, 3, 3, 3],
        'film_id': [101, 102, 103, 101, 104, 102, 103, 104],
        'ocena': [5, 3, 4, 4, 5, 2, 5, 1]}

df = pd.DataFrame(dane)

# Tworzenie macierzy użytkownik-film (user-item matrix)
macierz = df.pivot_table(index='uzytkownik_id', columns='film_id', values='ocena').fillna(0)

# Obliczanie podobieństwa użytkowników (cosine similarity)
podobieństwo_uzytkownikow = cosine_similarity(macierz)

# Funkcja rekomendująca filmy dla danego użytkownika
def rekomenduj_filmy(uzytkownik_id, liczba_rekomendacji=3):
    # Pobranie podobieństwa do innych użytkowników
    podobieństwa = podobieństwo_uzytkownikow[uzytkownik_id - 1] # indeksowanie od 0

    # Sortowanie użytkowników według podobieństwa (oprócz samego siebie)
    indeksy_podobnych_uzytkownikow = podobieństwa.argsort()[::-1][1:]

    # Filmy ocenione przez podobnych użytkowników, których dany użytkownik nie widział
    filmy_do_rekomendacji = set()
    for indeks in indeksy_podobnych_uzytkownikow:
        filmy_podobnego_uzytkownika = macierz.iloc[indeks][macierz.iloc[indeks] > 0].index
        filmy_do_rekomendacji.update(filmy_podobnego_uzytkownika)

    filmy_obejrzane_przez_uzytkownika = macierz.iloc[uzytkownik_id - 1][macierz.iloc[uzytkownik_id - 1] > 0].index
    filmy_do_rekomendacji = filmy_do_rekomendacji - set(filmy_obejrzane_przez_uzytkownika)

    # Zwracanie kilku najbardziej popularnych filmów
    return list(filmy_do_rekomendacji)[:liczba_rekomendacji]

# Przykładowe rekomendacje dla użytkownika 1
rekomendacje = rekomenduj_filmy(1)
print(f"Rekomendowane filmy dla użytkownika 1: {rekomendacje}")

Opis kodu:

1. Import bibliotek: Importujemy pandas do pracy z danymi i cosine_similarity z sklearn do obliczania podobieństwa między użytkownikami.
2. Dane: Tworzymy DataFrame z danymi o ocenach filmów przez użytkowników.
3. Macierz użytkownik-film: Przekształcamy dane w macierz, w której wiersze reprezentują użytkowników, kolumny reprezentują filmy, a wartości reprezentują oceny. Puste komórki uzupełniamy zerami.
4. Podobieństwo użytkowników: Obliczamy podobieństwo między użytkownikami przy użyciu metryki cosine similarity.
5. Funkcja rekomendująca filmy: Funkcja rekomenduj_filmy przyjmuje identyfikator użytkownika i zwraca listę filmów, które są rekomendowane dla tego użytkownika. Funkcja ta analizuje podobieństwo użytkownika do innych użytkowników, znajduje filmy, które oglądali podobni użytkownicy, a których dany użytkownik jeszcze nie widział, i zwraca kilka najbardziej popularnych filmów.

Eksperymenty:

• Zaimplementuj filtrowanie oparte na treści.
• Połącz filtrowanie kolaboratywne i oparte na treści w hybrydowy system rekomendacji.
• Wykorzystaj biblioteki takie jak Surprise do budowy bardziej zaawansowanych systemów rekomendacji.

5. Analiza sentymentu w mediach społecznościowych

Wiele firm w Polsce monitoruje media społecznościowe, aby śledzić opinie o swoich produktach i usługach. Analiza sentymentu, czyli automatyczne rozpoznawanie emocji wyrażonych w tekście (pozytywne, negatywne, neutralne), jest kluczowym elementem tego procesu.

Jak to działa?

Algorytmy analizy sentymentu wykorzystują techniki NLP, takie jak:

• Leksykony sentymentów: Bazy danych słów i wyrażeń z przypisanymi wartościami sentymentu (np. “świetny” = pozytywny, “okropny” = negatywny).
• Uczenie maszynowe: Modele ML trenowane na zbiorach danych tekstów z oznaczonym sentymentem.

Przykład kodu (uproszczony, z użyciem biblioteki TextBlob):

from textblob import TextBlob

# Tekst do analizy
tekst = "Ten produkt jest naprawdę świetny! Polecam go wszystkim."

# Utworzenie obiektu TextBlob
analiza = TextBlob(tekst)

# Obliczenie polaryzacji (sentymentu)
polaryzacja = analiza.sentiment.polarity

# Interpretacja wyniku
if polaryzacja > 0:
    print("Sentyment pozytywny")
elif polaryzacja < 0:
    print("Sentyment negatywny")
else:
    print("Sentyment neutralny")

print(f"Polaryzacja: {polaryzacja}")

# Wynik: Program analizuje tekst i określa, czy sentyment jest pozytywny, negatywny czy neutralny.

Opis kodu:

1. Import biblioteki: Importujemy bibliotekę TextBlob.
2. Tekst do analizy: Definiujemy tekst, który chcemy przeanalizować.
3. Utworzenie obiektu TextBlob: Tworzymy obiekt TextBlob z tekstu.
4. Obliczenie polaryzacji: Obliczamy polaryzację tekstu przy użyciu atrybutu sentiment.polarity. Polaryzacja przyjmuje wartości od -1 (sentyment negatywny) do 1 (sentyment pozytywny).
5. Interpretacja wyniku: Interpretujemy wynik polaryzacji i wyświetlamy odpowiedni komunikat.

Eksperymenty:

• Spróbuj użyć innych bibliotek do analizy sentymentu, np. VADER.
• Stwórz własny leksykon sentymentów dla języka polskiego.
• Wykorzystaj uczenie maszynowe do trenowania własnego modelu analizy sentymentu.

Podsumowanie i dalsze kroki

W tym artykule pokazaliśmy Ci tylko kilka przykładów zastosowania sztucznej inteligencji w Twoim codziennym życiu w Polsce. AI jest obecna w e-commerce, obsłudze klienta, aplikacjach mobilnych, serwisach streamingowych i mediach społecznościowych. Jako programiści, mamy możliwość nie tylko korzystać z tych technologii, ale także je tworzyć i rozwijać.

Zachęcamy Cię do dalszego eksperymentowania z AI. Spróbuj odtworzyć opisane przykłady kodu, modyfikować je i dostosowywać do własnych potrzeb. Wykorzystaj dostępne biblioteki i frameworki, takie jak scikit-learn, Rasa, SpeechRecognition i TextBlob. Pamiętaj, że nauka AI to proces ciągłego uczenia się i eksperymentowania.

Przydatne linki:

• scikit-learn: https://scikit-learn.org/stable/
• Rasa: https://rasa.com/
• SpeechRecognition: https://pypi.org/project/SpeechRecognition/
• TextBlob: https://textblob.readthedocs.io/en/dev/
• Dokumentacja Python: https://docs.python.org/3/
• Kursy online (Coursera, Udemy, edX): Wyszukaj kursy dotyczące uczenia maszynowego, przetwarzania języka naturalnego i widzenia komputerowego.

Pamiętaj, że to dopiero początek Twojej przygody z AI. Im więcej będziesz się uczyć i eksperymentować, tym lepiej zrozumiesz potencjał tej technologii i będziesz mógł wykorzystać ją do rozwiązywania realnych problemów. Powodzenia!