diff --git a/.github/actions/spelling/allow/code_blocks.txt b/.github/actions/spelling/allow/code_blocks.txt index 5958c627..6c8185ad 100644 --- a/.github/actions/spelling/allow/code_blocks.txt +++ b/.github/actions/spelling/allow/code_blocks.txt @@ -1,12 +1,33 @@ baf +bücher dht +dropna +dtype +dtypes +elektronik +ent +fillna honkable IDurable IHonk IHonkable +iloc ILogger IQuack IQuackable IStrategy ITable +kategorie +kleidung +Metascore +monts +ner +nlp +produkt +PROPN +pysqlite quackable +sklearn +stopwords +toarray +vectorizer \ No newline at end of file diff --git a/.github/actions/spelling/allow/general.txt b/.github/actions/spelling/allow/general.txt index 8b929b9a..05a43d9b 100644 --- a/.github/actions/spelling/allow/general.txt +++ b/.github/actions/spelling/allow/general.txt @@ -32,6 +32,7 @@ computerunterstützt Controllings dadaistischen daß +datenintensiven Datenverarbeitungsprogrammen Davidsohn Degenerationsphase @@ -46,6 +47,7 @@ einschläft Elegoo emoji Entitäten +Entitätenverknüpfung Entscheidungs Epik Epiker @@ -96,9 +98,11 @@ hypotaktisch Hypotaxen Iaa imma +insgesamte Jandl Kapitalaufbringung Kierkegaards +Klassifikationsalgorithmen Kontrahierungspolitik kraxelt Kriechens @@ -108,6 +112,7 @@ Lautgedichte lcdc lcdh LCDs +Lemmatization Lesertäuschung Lichtensteins LTO @@ -144,6 +149,7 @@ parataktisch Passivkonstruktionen patreon paypal +persistieren persistiert Personalzufriendenheit Phrasendreschertums @@ -172,11 +178,13 @@ Redaktionsteam rehype Reifephase Rilkes +Rossum Rühm Saa Schriftstellerbewegung screenshots Segmentierungskriterien +Sentimentanalyse simultanistisches Sinnabschnitte situationsbezogen @@ -187,17 +195,20 @@ Stakeholdern standörtlich Stilfiguren Stimulans +Stoppwörter Storetest Stramms suggestiert summarises Symbolismus Synology +tabellenähnliche tagline Teammitgliedern Terzinen Testung Threadsicheres +Tokenisierung tragischerweise Trastan Traumen @@ -217,6 +228,7 @@ Vock Vorübergehn vorzuladen Wilderöm +Wissensgraphenaufbau withastro Xen Xigma diff --git a/starlight/astro.config.mjs b/starlight/astro.config.mjs index 68826f5c..9edd32e7 100644 --- a/starlight/astro.config.mjs +++ b/starlight/astro.config.mjs @@ -93,6 +93,14 @@ export default defineConfig({ }, autogenerate: { directory: "system_integration_and_infrastructure" }, }, + { + label: "Künstliche Intelligenz", + collapsed: true, + translations: { + en: "Artificial Intelligence", + }, + autogenerate: { directory: "artificial_intelligence" }, + }, { label: "Projektmanagement", collapsed: true, diff --git a/starlight/src/assets/artificial_intelligence/series-and-dataframe.png b/starlight/src/assets/artificial_intelligence/series-and-dataframe.png new file mode 100644 index 00000000..00da3fb8 Binary files /dev/null and b/starlight/src/assets/artificial_intelligence/series-and-dataframe.png differ diff --git a/starlight/src/content/docs/de/artificial_intelligence/pandas.md b/starlight/src/content/docs/de/artificial_intelligence/pandas.md new file mode 100644 index 00000000..48162dca --- /dev/null +++ b/starlight/src/content/docs/de/artificial_intelligence/pandas.md @@ -0,0 +1,234 @@ +--- +title: Pandas +sidebar: + order: 1 +--- + +Pandas ist eine leistungsstarke und weit verbreitete Bibliothek für Datenanalyse und -manipulation in der Programmiersprache Python. Entwickelt auf Basis von NumPy bietet Pandas Datenstrukturen, die ideal für die Verarbeitung und Analyse von strukturierten Daten wie Tabellen oder CSV-Dateien geeignet sind. Diese Bibliothek erleichtert das Arbeiten mit großen Datensätzen und ermöglicht es, komplexe Operationen auf Daten schnell und effizient durchzuführen. Pandas wird in den Bereichen Datenwissenschaft, Finanzanalyse, Machine Learning und anderen datenintensiven Anwendungen eingesetzt. In dieser Einführung werden wir einen Blick auf die Schlüsselfunktionen und -konzepte von Pandas werfen, um ein Verständnis für die Vielseitigkeit dieser Bibliothek zu entwickeln. + +```bash title="Installing pandas" +pip install pandas +``` + +```python +import pandas as pd +``` + +## Theorie + +Pandas führt zwei grundlegende Datenstrukturen ein: Dataframes und Series. Ein Dataframe kann als eine zweidimensionale Datenstruktur betrachtet werden, die in Form einer Tabelle organisiert ist. Diese Tabelle besteht aus Zeilen und Spalten, wobei jede Spalte einen bestimmten Datentyp repräsentiert. Einzelne Spalten in einem Dataframe werden als Series bezeichnet. Series hingegen kann als eindimensionales Array oder eine Liste betrachtet werden und enthält Daten eines bestimmten Datentyps. + +![Series and Dataframe](../../../../assets/artificial_intelligence/series-and-dataframe.png) + +### Dataframe + +Ein Dataframe ist die Hauptdatenstruktur in Pandas und kann als eine zweidimensionale, tabellenähnliche Datenstruktur betrachtet werden. Es organisiert Daten in Zeilen und Spalten, wobei jede Spalte eine Series darstellt. Dataframes sind äußerst vielseitig und ermöglichen die effiziente Verarbeitung und Analyse von strukturierten Daten. Sie können aus verschiedenen Datentypen bestehen und erleichtern den Zugriff, die Filterung und die Transformation von Daten. Dataframes werden häufig für die Darstellung von Tabellen in CSV-Dateien, Excel-Tabellen oder SQL-Abfragen verwendet. Die Operationen auf Dataframes können sowohl auf Zeilen als auch auf Spalten angewendet werden, was eine umfassende Datenmanipulation ermöglicht. + +### Series + +Eine Series ist eine grundlegende Datenstruktur in Pandas und kann als eindimensionales Array oder Liste betrachtet werden. Jede Spalte in einem Dataframe ist eine Series. Series können Daten unterschiedlichen Datentyps enthalten, einschließlich numerischer Werte, Zeichenketten oder Zeitstempel. Sie ermöglichen den Zugriff auf Daten durch einen Index und unterstützen zahlreiche Funktionen zur Datenmanipulation. Durch die Verwendung von Series können bestimmte Datenpunkte in einem Dataframe isoliert und spezifische Operationen auf einzelnen Spalten durchgeführt werden. Dies macht Series zu einem wichtigen Baustein für die Arbeit mit strukturierten Daten in Pandas. + +## Code + +### Dataframe erstellen + +Man kann ein Dataframe auf mehrere Arten erstellen: + +- aus einem Dictionary + +```python +data = { + 'apples': [3, 2, 0, 1], + 'oranges': [0, 3, 7, 2] +} +``` + +```python + +purchases = pd.DataFrame(data) +``` + +- aus einer CSV-Datei + +```csv +// purchases.csv +,apples,oranges +June,3,0 +Robert,2,3 +Lily,0,7 +David,1,2 +``` + +```python +df = pd.read_csv('purchases.csv', index_col=0) +``` + +- aus einer JSON-Datei + +```json +// purchases.json +{ + "apples": { "June": 3, "Robert": 2, "Lily": 0, "David": 1 }, + "oranges": { "June": 0, "Robert": 3, "Lily": 7, "David": 2 } +} +``` + +```python +df = pd.read_json('purchases.json') +``` + +- oder auch einer SQL-Datenbank + +```bash title="Installing sqlite3" +pip install pysqlite3 +``` + +```python +import sqlite3 +con = sqlite3.connect("database.db") + +df = pd.read_sql_query("SELECT * FROM purchases", con) +``` + +### Daten in Datei persistieren + +Man kann ein Dataframe genauso wieder in eine Datei schreiben, wie es aus einer Datei gelesen wurde. + +- in eine CSV-Datei + +```python +df.to_csv('new_purchases.csv') +``` + +- in eine JSON-Datei + +```python +df.to_json('new_purchases.json') +``` + +- mittels SQL + +```python +df.to_sql('new_purchases.sql', con) +``` + +### Operation mit Dataframes + +#### Ausgaben + +Ein logisches Verständnis über die Konstellation der Daten zu haben ist besonders wichtig, wenn man mit Pandas arbeitet. Die Ausgabe von Dataframes kann auf verschiedene Arten erfolgen. + +```python +df.head(5) # fünf ersten Zeilen ausgeben +df.tail(3) # letzten drei Zeilen ausgeben +``` + +Zeilen und Spalten spezifisch ausgeben, jeweils mit Index und Namen: + +```python +df['oranges'] # Series 'oranges' ausgeben +df[['oranges']] # 'oranges' als Dataframe ausgeben +df[['apples', 'oranges']] # Dataframe ausgeben + +df.iloc[11] # Zeile mit Index 11 ausgeben +df.iloc[11:13] # Zeilen 11 bis 13 ausgeben +df.loc['December'] # Zeile 'December' ausgeben +df.loc['October':'December'] # Zeilen von 'October' bis 'December' ausgeben +``` + +Metadaten der Tabelle herausfinden: + +```python +df.shape # Anzahl der Zeilen und Spalten (Beispiel: (1000, 11)) +df.columns # Spaltennamen +df.info() +``` + +```txt +// df.info_output + +Index: 1000 entries, Guardians of the Galaxy to Nine Lives +Data columns (total 11 columns): + # Column Non-Null Count Dtype +--- ------ -------------- ----- + 0 Rank 1000 non-null int64 + 1 Genre 1000 non-null object + 2 Description 1000 non-null object + 3 Director 1000 non-null object + 4 Actors 1000 non-null object + 5 Year 1000 non-null int64 + 6 Runtime (Minutes) 1000 non-null int64 + 7 Rating 1000 non-null float64 + 8 Votes 1000 non-null int64 + 9 Revenue (Millions) 872 non-null float64 + 10 Metascore 936 non-null float64 +dtypes: float64(3), int64(4), object(4) +memory usage: 93.8+ KB +``` + +Nullwerte herausfinden: + +```python +df.isnull() # Gibt ein Dataframe zurück, wo alle Zellen True sind, falls die Werte null sind +df.isnull().sum() # Gibt die Anzahl der Nullwerte in jeder Series zurück +df.isnull().sum().sum() # Gibt die insgesamte Anzahl der Nullwerte zurück +``` + +Statistiken eines Dataframes herausfinden (Anzahl, Mittelwert, Standardabweichung, Minimum, Maximum, etc.). + +```python +df.describe() +df.corr() # Korrelationen zwischen den Spalten +``` + +```python +df['apples'].value_counts() # Gruppierte Werte und Anzahl der Vorkommen +``` + +#### Datenmanipulationen + +Bei den meisten Veränderungen von Daten gibt es einen Parameter namens `inplace`, welcher angibt, ob die Änderungen direkt auf das Dataframe angewendet werden sollen oder ob die Änderungen in einem neuen Dataframe gespeichert werden sollen. Standardmäßig ist `inplace` auf `False` gesetzt, was bedeutet, dass die Änderungen in einem neuen Dataframe gespeichert werden. + +Der Codeblock zeigt verschiedene Methoden zum Entfernen von Duplikaten aus einem Pandas-Dataframe. Die Funktion `drop_duplicates()` wird verwendet, um Duplikate zu entfernen. + +```python +df = df.drop_duplicates() +df.drop_duplicates(inplace=True) + +df.drop_duplicates(inplace=True, keep='first') # nur erste Duplikate behalten +df.drop_duplicates(inplace=True, keep='last') # nur letzte Duplikate behalten +df.drop_duplicates(inplace=True, keep='False') # alle Duplikate löschen +``` + +Die Methode `append()` wird verwendet, um zwei Dataframes (df und df2) zu verketten. Dies führt zu einem neuen Dataframe df3, das alle Zeilen von df und df2 enthält. + +```python +df3 = df.append(df2) +``` + +Die Methode `rename()` wird verwendet, um bestimmte Spalten im Dataframe df umzubenennen, indem ein Dictionary mit den alten und neuen Spaltennamen bereitgestellt wird. + +```python +df.columns = ['Amount of Fruits (Apple)', 'Amount of Fruits (Orange)'] +``` + +```python +df.rename(columns={ + 'Amount of Fruits (Apple)': 'apple_amount', + 'Amount of Fruits (Orange)': 'orange_amount' +}, inplace=True) +``` + +Aufgrund der Aneinanderreihung solcher Methoden können Spaltennamen auch automatisch bearbeitet werden. Die Methode `replace()` wird verwendet, um bestimmte Werte in einer Spalte zu ersetzen. + +```python +df.columns = [col.lower().replace("(", "").replace(")", "").replace(" ", "_") for col in df] +``` + +Die Methode `dropna()` wird verwendet, um Zeilen oder Spalten mit NaN-Werten zu entfernen, während `fillna()` genutzt wird, um fehlende Werte durch einen bestimmten Wert, wie den Mittelwert, zu ersetzen. + +```python +df.dropna() # Löscht Zeilen, in denen alle Werte null sind +df.dropna(axis=1) # Löscht Spalten, in denen alle Werte null sind +df['apples'].fillna(df['apples'].mean(), inplace=True) # Füllt fehlende Werte mit dem Mittelwert der Spalte 'apples' aus +``` diff --git a/starlight/src/content/docs/de/artificial_intelligence/python.md b/starlight/src/content/docs/de/artificial_intelligence/python.md new file mode 100644 index 00000000..ad07e0f0 --- /dev/null +++ b/starlight/src/content/docs/de/artificial_intelligence/python.md @@ -0,0 +1,401 @@ +--- +title: Python +sidebar: + order: 0 +--- + +Python ist eine weit verbreitete, benutzerfreundliche Programmiersprache, entwickelt von Guido van Rossum. Mit klarer Syntax und hoher Lesbarkeit ist sie für Anfänger und erfahrene Entwickler gleichermaßen attraktiv. Python wird in Webentwicklung, Datenanalyse, künstlicher Intelligenz und anderen Bereichen eingesetzt. Die Sprache zeichnet sich durch Einfachheit und Flexibilität aus. Ein charakteristisches Merkmal ist, dass Python eine interpretierte Sprache ist, was bedeutet, dass ein Interpreter verwendet wird, um den Code direkt auszuführen, ohne ihn vorher zu kompilieren. Mit einer umfangreichen Standardbibliothek und einer aktiven Entwicklergemeinschaft bietet Python eine robuste Plattform für verschiedene Projekte. + +## Grundlegende Syntax + +### Variablen + +In Python können verschiedene Datentypen für die Speicherung von Informationen verwendet werden. + +```python +# Booleans repräsentieren Wahrheitswerte, die entweder True (wahr) oder False (falsch) sind. +im_cool = True # oder False + +# Strings sind Zeichenketten, die Text repräsentieren. +name = "trueberryless" + +# Integers sind ganze Zahlen ohne Dezimalstellen. +age = 38 + +# Floats sind Zahlen mit Dezimalstellen. +book_price = 15.80 + +# Listen sind geordnete Sammlungen von Elementen. +numbers = [1, 2, 3, 4, 5] +numbers.append(6) +print(numbers[2]) # Gibt das dritte Element der Liste aus, in diesem Fall 3. + +# Dictionaries sind Sammlungen von Schlüssel-Wert-Paaren. +person = { + "name": name, # Der Schlüssel "name" hat den Wert "trueberryless". + "age": age # Der Schlüssel "age" hat den Wert 38. +} +person["favourite_numbers"] = numbers +print(person["name"]) # Gibt den Wert des Schlüssels "name" im Dictionary aus. +``` + +### Ablaufsteuerung + +Die Ablaufsteuerung ermöglicht die Kontrolle über den Programmfluss. + +```python +# Die if-Anweisung ermöglicht die Ausführung von Code basierend auf einer Bedingung. +if False: + print("Never gonna give you up") + +# Die elif-Anweisung ermöglicht das Überprüfen weiterer Bedingungen. +if 1 > 2: + print("1 is greater than 2") +elif 2 > 1: + print("1 is not greater than 2") +else: + print("1 is equal to 2") + +# Die for-Schleife wird verwendet, um über eine Sequenz von Elementen zu iterieren. +for i in range(1, 100): + print(i) + +# Die for-Schleife kann auch über Elemente einer Liste iterieren. +for number in numbers: + print(number) + +# Die for-Schleife kann auch über Schlüssel-Wert-Paare eines Dictionaries iterieren. +for key, value in person.items(): + print("My %s is %s" % (key, value)) # Gibt formatierten Text aus. + +# Die while-Schleife wird wiederholt, solange eine Bedingung wahr ist. +while age < 66: + print("You are still young") + age += 1 +``` + +### Klassen + +Klassen ermöglichen die Definition von benutzerdefinierten Datentypen (Eigenschaften realer Objekte) und Methoden (Verhalten realer Objekte). + +```python +# Eine grundlegende Klasse "Vehicle" mit einem Konstruktor und Getter/Setter-Methoden. +class Vehicle: + def __init__(self, number_of_wheels, maximum_velocity): + self.number_of_wheels = number_of_wheels + self.maximum_velocity = maximum_velocity + + @property + def number_of_wheels(self): + return self.number_of_wheels + + @number_of_wheels.setter + def number_of_wheels(self, number): + self.number_of_wheels = number + +# Die Klasse "Car" erbt von "Vehicle" und ruft den Konstruktor der Elternklasse auf. +class Car(Vehicle): + def __init__(self, number_of_wheels, maximum_velocity): + super().__init__(number_of_wheels, maximum_velocity) + +# Die Klasse "SpaceShip" erbt ebenfalls von "Vehicle" und hat keine eigenen Änderungen. +class SpaceShip(Vehicle): + pass + +# Ein Objekt der Klasse "Car" wird erstellt. +tesla_model_s = Car(4, 300) +``` + +## Natural Language Processing + +Natürliche Sprachverarbeitung (Natural Language Processing, NLP) ist ein interdisziplinäres Forschungsfeld, das sich mit der Wechselwirkung zwischen Computern und menschlicher Sprache befasst. Das Hauptziel von NLP ist es, Computern die Fähigkeit zu verleihen, menschliche Sprache in all ihren Nuancen zu verstehen, zu interpretieren und darauf zu reagieren. Dies beinhaltet nicht nur die Erkennung von Wörtern und Grammatik, sondern auch die Analyse von Bedeutung, Kontext und sogar Emotionen, die in der menschlichen Sprache enthalten sein können. + +NLP nutzt Methoden aus verschiedenen Bereichen wie Linguistik, Informatik und künstliche Intelligenz, um Modelle und Algorithmen zu entwickeln, die es Computern ermöglichen, natürliche Sprache effektiv zu verarbeiten. Zu den grundlegenden Aufgaben von NLP gehören die Textklassifikation, Named Entity Recognition (NER), maschinelles Übersetzen, Textgenerierung und Sentimentanalyse. + +### Text Processing + +Im ersten Schritt der Natural Language Processing muss der Text so bearbeitet werden, dass Merkmale (Wörter, Features) des Textes von der Maschine besser verarbeitet werden können. + +1. **Reinigung** + Der erste Schritt in der Textverarbeitungspipeline beinhaltet die Reinigung des Texts, um unnötige Zeichen, Symbole oder Formatierungen zu entfernen. Dies erleichtert die folgenden Verarbeitungsschritte und verbessert die Konsistenz der Daten. + +2. **Normalisierung** + Normalisierung beinhaltet die Umwandlung von Text in eine einheitliche Form, z.B. die Umwandlung von Groß- und Kleinschreibung oder die Entfernung von Akzenten. Dies stellt sicher, dass der Text konsistent und vergleichbar ist. + +3. **Tokenisierung** + Tokenisierung teilt den Text in einzelne Wörter oder Token auf. Jedes Token repräsentiert eine bedeutungsvolle Einheit, was die spätere Analyse erleichtert. + +4. **Stoppwörter entfernen** + Stoppwörter wie "und", "oder" oder "das" tragen oft wenig zur Bedeutung bei und werden entfernt, um den Fokus auf relevantere Inhalte zu legen. + +5. **Part of Speech Tagging (POS)** + In diesem Schritt werden den einzelnen Wörtern grammatische Kategorien zugeordnet, wie Substantive, Verben oder Adjektive. Dies hilft bei der Analyse der syntaktischen Struktur. + +6. **Named Entity Recognition (NER)** + Benannte Entitäten wie Personen, Orte oder Organisationen werden identifiziert und markiert, um wichtige Informationen im Text zu extrahieren. + +7. **Stemming und Lemmatisierung** + Der letzte Schritt ist das Stemming (fortgeschrittener: Lemmatisierung (mit Wörterbuch)), bei dem Wörter auf ihren Stamm zurückgeführt werden. Dies hilft, Varianten eines Wortes zu vereinheitlichen und die Analyse zu erleichtern. + +#### Normalisierung + +Als Normalisierung bezeichnet man die Konvertierung von Text in Kleinbuchstaben. Dies ist in den meisten Fällen der Textverarbeitung sinnvoll, muss jedoch nicht unbedingt geschehen. Außerdem kann auch die Entfernung der Satzzeichen unter der Normalisierung erfolgen. + +```python +# Konvertierung in Kleinbuchstaben +df = pd.DataFrame({'tweets': [col.lower() for col in ['I am a dog', 'I am a cat', 'I am a fish']]}). + +# Entfernung der Satzzeichen +import re +df.tweets = [re.sub("[^a-z0-9 .]", '', col) for col in df.tweets] +``` + +#### Tokenisierung + +Als Tokenisierung bezeichnet man die Aufteilung eines Textes in einzelne Wörter. Diese Wörter werden als Tokens bezeichnet. + +```python +import spacy +nlp = spacy.load("de_core_news_sm") # en_core_web_sm +doc = nlp("Steve Jobs, CEO von Apple, erwägt den Kauf eines österreichischen Startups um 6 Mio. Euro.") + +for token in doc: + print(f"{token.text:{20}}", f"{token.pos_:{10}}", f"{token.ent_type_:{10}}", f"{str(token.is_stop):{10}}", f"{token.lemma_:{20}}") +``` + +```python +// token.output +Text POS ENT_TYPE IS_STOP Lemma +-------------------------------------------------------------------------- +Steve PROPN PER False Steve +Jobs PROPN PER False Jobs +, PUNCT False -- +CEO PROPN False CEO +von ADP True von +Apple PROPN ORG False Apple +, PUNCT False -- +erwägt VERB False erwägen +den DET True der +Kauf NOUN False Kauf +eines DET True ein +österreichischen ADJ MISC False österreichisch +Startups NOUN False Startup +um ADP True um +6 NUM False 6 +Mio. NOUN False Mio. +Euro NOUN False Euro +. PUNCT False -- +``` + +#### Stoppwörter entfernen + +Vieler Wörter jeder Sprache haben eine geringen Einfluss auf die Aussagekraft eines Textes. Diese Wörter werden als Stoppwörter bezeichnet. Im Normalfall können KI-Modelle besser trainiert werden, wenn die Stoppwörter aus dem Text entfernt werden. + +```python +import spacy +nlp = spacy.load("en_core_web_sm") # de_core_news_sm + +class NLP: + def __init__(self, text): + self.text = text + + def remove_stopwords(self): + doc = nlp(self.text) + self.text = " ".join([token for token in doc if not token.is_stop]) + return self.text + +text = "How to develop a chatbot using Python" +text = NLP(text).remove_stopwords() +print(text) # develop chatbot Python +``` + +#### Parts of Speech Tagging + +Part-of-Speech-Tagging ist eine NLP-Technik, die jedem Wort in einem Text grammatikalische Kategorien zuweist, wie Nomen, Verben oder Adjektive. Diese Markierungen helfen bei der Analyse der Satzstruktur und unterstützen Aufgaben wie Textanalyse und Sentimentanalyse. + +```python +import spacy +nlp = spacy.load("de_core_news_sm") # en_core_web_sm +doc = nlp("Ich habe immer Hunger.") + +for token in doc: + print(f"{token.text:{20}}", f"{token.pos_:{10}}") +``` + +```python +// pos.output +Text POS +-------------------------------- +Ich PRON +habe AUX +immer ADV +Hunger NOUN +. PUNCT +``` + +#### Named Entity Recognition + +NER identifiziert und klassifiziert spezifische Entitäten wie Personen, Orte und Organisationen in einem Text. Diese Informationsextraktion ist entscheidend für Anwendungen wie Entitätenverknüpfung und Wissensgraphenaufbau. + +```python +import spacy +nlp = spacy.load("de_core_news_sm") # en_core_web_sm +doc = nlp("Marie Curie besuchte das Louvre-Museum in Paris.") + +for token in doc: + print(f"{token.text:{20}}", f"{token.ent_type_:{10}}") +``` + +```python +// ner.output +Text ENT_TYPE +-------------------------------- +Marie PER +Curie PER +besuchte +das +Louvre-Museum LOC +in +Paris LOC +. +``` + +#### Stemming & Lemmatisierung + +Stemming und Lemmatisierung sind Techniken zur Textnormalisierung in der NLP. Sie reduzieren Wörter auf ihre Basisformen (Stammwörter), was die Effizienz von Such- und Klassifikationsalgorithmen verbessert. Lemmatisierung hat hierbei den Vorteil gegenüber Stemming, ein Wörterbuch zu verwenden, das die Wortformen auf ihre Stammebene normalisiert. + +```python +import spacy +nlp = spacy.load("de_core_news_sm") # en_core_web_sm +doc = nlp("Michael Jordan erwägt den Kauf eines Autos.") + +for token in doc: + print(f"{token.text:{20}}", f"{token.lemma_:{20}}") +``` + +```python +// lemma.output +Text Lemma +------------------------------------------ +Michael Michael +Jordan Jordan +erwägt erwägen +den der +Kauf Kauf +eines ein +Autos Auto +. -- +``` + +### Feature Engineering + +Machine Learning Algorithmen können mit Text nicht viel anfangen. Diese bevorzugen numerische Eingaben. Besteht nun die Notwendigkeit, Text zu verarbeiten, ist dessen Umwandlung in eine numerische Darstellungsform unumgänglich. Dieser Vorgang ist Teil des sogenannten `Feature Engineerings`. Unter Feature Engineering bei Texten versteht man den Prozess der Auswahl, Erstellung und Transformation von Merkmalen (Features). + +Methoden zur Umwandlung von Text in numerische Darstellungen sind beispielsweise `One-Hot Encoding`, `N-Gramme` und `TF-IDF` (Term Frequency-Inverse Document Frequency). N-Gramme werden oft in leichtgewichtigen Shallow-Learning-Modellen wie Random Forest und logistischer Regression verwendet. TF-IDF hingegen finden eher Anwendung in Deep Learning Modellen. + +#### One-Hot Encoding + +One-Hot Encoding ist eine Methode, bei der jedes Wort in einem Text in eine binäre Vektorform umgewandelt wird. Jedes Wort wird durch eine Spalte repräsentiert, und wenn das Wort im Text vorkommt, wird die entsprechende Spalte auf 1 gesetzt, sonst auf 0. + +```python +import spacy +from sklearn.feature_extraction.text import CountVectorizer +nlp = spacy.load('en_core_web_sm') # de_core_news_sm + +text="Jim loves NLP. He will learn NLP in two monts. NLP is Jim's future." + +def get_spacy_tokens(text): + doc = nlp(text) + return [token.text for token in doc] +text_tokens = get_spacy_tokens(text) +vectorizer = CountVectorizer(tokenizer=get_spacy_tokens, lowercase=False, token_pattern=None) + +vectorizer.fit(text_tokens) +print("Vocabulary:\n", vectorizer.vocabulary_) + +vector = vectorizer.transform(text_tokens) +print("Encoded Document is:\n", vector.toarray()) +``` + +```python +// one-hot.output +Vocabulary: + {'Jim': 3, 'loves': 9, 'NLP': 4, '.': 1, 'He': 2, 'will': 12, 'learn': 8, 'in': 6, 'two': 11, 'monts': 10, 'is': 7, "'s": 0, 'future': 5} +Encoded Document is: + [[0 0 0 1 0 0 0 0 0 0 0 0 0] + [0 0 0 0 0 0 0 0 0 1 0 0 0] + [0 0 0 0 1 0 0 0 0 0 0 0 0] + [0 1 0 0 0 0 0 0 0 0 0 0 0] + [0 0 1 0 0 0 0 0 0 0 0 0 0] + [0 0 0 0 0 0 0 0 0 0 0 0 1] + [0 0 0 0 0 0 0 0 1 0 0 0 0] + [0 0 0 0 1 0 0 0 0 0 0 0 0] + [0 0 0 0 0 0 1 0 0 0 0 0 0] + [0 0 0 0 0 0 0 0 0 0 0 1 0] + [0 0 0 0 0 0 0 0 0 0 1 0 0] + [0 1 0 0 0 0 0 0 0 0 0 0 0] + [0 0 0 0 1 0 0 0 0 0 0 0 0] + [0 0 0 0 0 0 0 1 0 0 0 0 0] + [0 0 0 1 0 0 0 0 0 0 0 0 0] + [1 0 0 0 0 0 0 0 0 0 0 0 0] + [0 0 0 0 0 1 0 0 0 0 0 0 0] + [0 1 0 0 0 0 0 0 0 0 0 0 0]] +``` + +##### mit Pandas + +Mittels der verwirrend benannten Methode `get_dummies()` kann man One-Hot Encoding auch mit Pandas durchführen. + +```txt +// products.csv +produkt_id,kategorie +1,Elektronik +2,Kleidung +3,Bücher +4,Elektronik +5,Elektronik +6,Bücher +7,Kleidung +8,Bücher +9,Elektronik +10,Kleidung +11,Bücher +12,Elektronik +13,Bücher +14,Elektronik +15,Kleidung +16,Kleidung +``` + +```python +import pandas as pd +df = pd.read_csv('products.csv') +df = pd.get_dummies(df, columns=["kategorie"], dtype=int) +df.columns = map(str.lower, df.columns) +print(df) +``` + +```python +// one-hot_pandas.output + produkt_id kategorie_bücher kategorie_elektronik kategorie_kleidung +0 1 0 1 0 +1 2 0 0 1 +2 3 1 0 0 +3 4 0 1 0 +4 5 0 1 0 +5 6 1 0 0 +6 7 0 0 1 +7 8 1 0 0 +8 9 0 1 0 +9 10 0 0 1 +10 11 1 0 0 +11 12 0 1 0 +12 13 1 0 0 +13 14 0 1 0 +14 15 0 0 1 +15 16 0 0 1 +``` + +#### Bag-of-words (BOW) + +### Modeling