Library

Maschinelles Lernen und die französische Revolution

Letztes Jahr wurde ein Paper in „Proceedings of the National Academy of Sciences of the United States of America“ (PNAS) veröffentlicht, welches die Rhetorik der ersten Jahre der französischen Revolution untersucht. Das interessante daran aus Data Science Sicht ist die Nutzung von ML-Algorithmen, um eine große Menge an Reden (40.000) zu analysieren. Soweit ich weiß, ist das eine der ersten Forschungen, welche Maschinelles Lernen verwendet, um historische Daten dieser Größenordnung auszuwerten. Besonders toll finde ich, dass die NLP-Methoden (NLP = Natural Language Processing) eine praktische Anwendung finden.

Ich bin gespannt, ob durch die fortschreitende Digitalisierung und Veröffentlichung historischer Daten die quantitativen Analysen in den Geisteswissenschaften zunehmen. Wie jeder, der mit Datensätzen zu tun hat, sind aber ebenso wichtig wie neue Methoden die richtigen Fragestellen. Daher ist die Zusammenarbeit zwischen Fachexperten (Domain Owner) und Data Scientisten so wertvoll.

Vorgehen

Nach der typischen Aufbereitung, sprich Stop-Word-Removal, wurden die Reden mittels Latent Dirichlet Allocation (LDA) in 100 „Themen“ einsortiert. Das passiert anhand von gemeinsam auftauchenden Wortpaaren. Die Themen wurden dann im zeitlichen Verlauf analysiert und dabei Kennzahlen für Novelty (Abweichung von vorherigen Reden), Transience (Abweichung von folgenden Reden) und Resonance (die Differenz der beiden) quantifiziert.

Links

Hier geht es zu einem Überblicks-Artikel über das Paper des Santa Fe Institute. Das Paper „Individuals, institutions, and innovation in the debates of the French Revolution„ selbst ist bei PNAS zu finden.
Glossar: Maschinelles Lernen

Buchtipp: Bayesian Methods for Hackers

Das kostenlose Ebook „Bayesian Methods for Hackers“ von Cameron Davidson-Pilon erklärt die Bayeschen Algorithmen in Python mittels der Python-Library PyMC. Dabei richtet sich das Buch an „Hacker“. Damit ist gemeint, dass es in erster Linie um die praktische Umsetzung und nicht um die mathematischen Grundlagen geht. Nichtsdestotrotz wird einiges an Mathematik verlangt, das liegt aber in der Natur der Sache.

Bei der Veröffentlichung geht Davidson-Pilon dankenswerterweise den Open-Source-Weg, d.h. das gesamte Buch ist als Jupyter Notebooks aufgebaut, welche auf Github zur Verfügung stehen. Eine gedruckte Version gibt es auch auf Amazon zu kaufen. Zudem gibt es eine Adaption an Tensorflow Probability, wenn man die Tensorflow-Umgebung und TPU/GPUs nutzen will.

Inhalt

Das Buch ist in 7 Kapitel unterteilt, welche jeweils als Jupyter Notebook (ipynp-Datei) zur Verfügung stehen. Am besten klont ihr euch das gesamte Github-Repository und öffnet es mit Jupyter Notebook oder einem anderen Editor, der Notebooks anzeigen kann. So könnt ihr lesen und die Beispiele ausführen und modifizieren. Alternativ könnt ihr euch die Notebooks auch im Browser mit dem nbviewer ansehen. Die einzelnen Kapitel habe ich verlinkt.

Introduction to Bayesian MethodsA little more on PyMCOpening the black box of MCMCThe greatest theorem never toldWould you rather lose an arm or a legGetting our prior-ities rightBayesian Machine Learning (in Arbeit)Das Buch als gedruckte Version

Das Buch gibt es auch in einer gedruckten Version vom Addison-Wesley Verlag (2015). Durch Klick auf das Bild gelangt Ihr zu Amazon.

Hier ist der Link zur Website des Buches und hier der Link zur zugehörigen Github-Seite.

Viel Spaß beim Lesen.
Glossar: Maschinelles Lernen

82.000 freie IT-Jobs. Fachkräftemangel?

Laut Bitcom spitzt sich der IT-Fachkräftemangel zu. In ihrem Pressebericht gibt es einige interessante Details zur Lage der IT-Experten am Arbeitsmarkt.

Aber die Kernaussage: Fachkräftemangel? Richtig ist, dass sich die Zahl der offenen Stellen im Jahr 2018 deutlich erhöht hat. Gleichzeitig wird aber gesagt, dass die Besetzung der Stellen vor allem am Geld scheitert. 76% der Unternehmen beklagt, dass die Bewerber zu hohe Gehaltsvorstellungen haben.

Schaut Euch den Bitcom-Report mal an.
Glossar: Maschinelles Lernen

KI-Support für Schlaganfallpatienten

In dem Artikel „Dr. Data soll Ärzte unterstützen“ auf n-tv.de geht es um eine Studie des Neurochirurgs Dietmar Frey an der Berliner Charité. In dieser Studie geht es um die akute Schlaganfallbehandlung, bei der wenig Zeit für Diagnostik und Therapieentscheidung bleibt. Hier sollen Daten helfen, indem der Algorithmus aus einer Datenbank von Schlaganfallpatienten die zum aktuellen Patienten ähnlichen findet. So bekommt der Arzt Anhaltspunkte für seine Entscheidung. Dabei sollen Verfahren des maschinellen Lernens zum Einsatz kommen.

Das Themenfeld „KI in der Medizin“ ist total spannend und wir werden wohl viele Neuigkeiten über Fortschritte sehen. Man darf aber nicht vergessen, wie komplex das Thema ist. So ist in der Medizin das Abwägen zwischen Risiko und Nutzen besonders heikel. Daneben muss man sich auch mit Datenschutz und zu recht strengen Medizinprodukt-Vorschriften auseinandersetzen.

Ich denke, der Artikel beschreibt kurz und knackig den aktuellen Stand zu „KI und Medizin“ in Deutschland. Es geht aktuell darum, anhand von Datenbanken vergleichbare Fälle herauszusuchen und damit die behandelnde Ärztin zu unterstützen. Das ist schon eine komplexe Angelegenheit, kratzt auf der anderen Seite das maschinelle Lernen nur an der Oberfläche.

Den gesamten Artikel findet Ihr hier bei n-tv.
Glossar: Maschinelles Lernen

Internetseite Data Science Jobs in Deutschland

Auf der Seite datasciencejobs.de werden aktuell einige Stellenangebote rund um das Thema Data Science und Maschinelles Lernen gesammelt. Dabei werden einfach die Jobs als „Blogbeiträge“ aufgelistet. Auf der Detailseite ist dann die Stellenbeschreibung mit Anforderungsprofil und einem Link zur Firma zu sehen.

Der erste Eintag der Seite ist von November 2017, es ist also noch eine relativ neue Seite. Leider gibt es keine Suchfunktion. Auch Filter sind nicht vorhanden, lediglich nach vorgegebenen Tags kann man filtern. Auch fehlt mir, von wann die Stellenausschreibung ist. Dafür gibt es einen RSS-Feed, mit dem Ihr die neuesten Beiträge bequem abonieren könnt.

Insgesamt scheinen die großen allgemeinen Job-Plattformen mit ihren umfangreichen Such- und Filterfunktionen für die Jobsuche im Data-Science-Umfeld allerdings besser geeignet zu sein.

Aber macht Euch selber ein Bild. Hier geht es zu datasciencejobs.de
Glossar: Maschinelles Lernen

5 Alltags-Beispiele für KI

Der leicht verständliche, kurzer Artikel „Wie Künstliche Intelligenz unser Leben berührt“ auf orange by Handelsblatt beschreibt 5 Alltags-Beispiele, in denen künstliche Intelligenz schon heute eingesetzt wird.

Und das sind laut Artikel:

Gesichtserkennung auf Smartphone und PCFacebook-NewsfeedChatbots, insbesondere SprachassistentenEinparkhilfe im AutoDiagnose von KrankheitenJetzt können wir natürlich diskutieren, ob das schon künstliche Intelligenz ist, also ob wirklich Intelligenz dahinter steckt. Und vermutlich sind das eher Beispiele für Maschinelles Lernen, mit dem Trendwort KI versehen. Aber eigentlich geht es ja darum, dass immer mehr komplexe Tätigkeiten von Maschinen erledigt bzw. unterstützt werden.

Hier geht es zum gesamten Artikel …
Glossar: Maschinelles Lernen

20 einflußreiche Deep Learning Paper 2018

In dem Artikel „Most Influential Data Science Research Papers for 2018“ listet Daniel Gutierrez 20 wissenschaftliche Paper zum Themengebiet Deep Learning / neuronale Netze mit jeweils einer kurzen Beschreibung auf. Die Paper liegen alle auf arxiv.org, sind also für jeden frei zugänglich.

Die ersten Paper der Liste sind Überblicksartikel, die gut geeignet sind, sich auf den aktuellen Stand der Forschung bezüglich Neuronaler Netze zu bringen. So zeigt der Artikel On the Origin of Deep Learning die historische Entwicklung der Neuronalen Netze auf.

Besonders interessant für mich als Mathematiker ist der Artikel Deep Learning: An Introduction for Applied Mathematicians, der die Deep Learning zugrundeliegenden Ideen mathematisch erklärt.

Hier findet Ihr die gesamte Liste mit den Papern.

Viel Spaß beim Lesen.
Glossar: Maschinelles Lernen

Install Anaconda – Die Python-Distribution Anaconda

Hej Leute,

ihr wollt als Data Scientist durchstarten, habt euch
vorgenommen, Python zu lernen und wollt nun wissen, wie ihr anfangt. Zuerst
braucht ihr mal eine Python-Distribution, also eine Software, welche Python und
gegebenenfalls noch mehr enhält. Statt einfach nur auf python.org zu gehen und
sich die aktuellste Version für Euer Betriebssystem, also zum Beispiel Python
3.7.1 für Windows, herunterzuladen, empfehle ich Euch die Python-Distribution
Anaconda. Diese enthält nämlich noch einiges Nützliches mehr.

In meine Anleitung
zur Installation von Python findet ihr einen kurzen Abriss über verschieden
Python IDEs und Anaconda, aber alles ziemlich knapp. Hier geht es aber weiter
mit den Tiefen von Anaconda. Natürlich bleiben wir trotzdem an der Oberfläche,
schließlich wollt Ihr kein ganzes Buch über Anaconda lesen.

Was ist Anaconda?

Anaconda ist eine Python-Distribution für Windows, Linux und
MacOS, welche aus IPython, Spyder, Jupyter Notebook und nicht zu vergessen
conda besteht.

IPython:
eine Python-KommandozeileSpyder:
ein Editor für Python-Skripte mit vielen Tools, welche ich hier erkläreJupyter
Notebook: ein browserbasierter Editor für spezielle Skripte (die
sogenannten Notebooks), welche neben dem Code auch formatierten Text und
Grafiken enthaltenConda:
ein Package-Management-System, d.h. mit conda lassen sich Abhängigkeiten
zwischen Package-Versionen gut verwalten und die Packages updatenWenn ihr also noch kein Python installiert habt, dann ist
Anaconda auf jeden Fall das richtige für Euch. Einfach zu installieren und
upzudaten. Auf der Website von Anaconda
gibt es einfach einen Installer, also auf den Download-Bereich gehen,
herunterladen, installieren, Fertig.

IPython

IPython steht für Interactive Python und ist eine interaktive
Python-Shell, welche eng mit Jupyter Notebook verbunden ist. In früheren
Versionen war es eine Einheit, die man dann aber getrennt hat. Deshalb ist es
etwas schwierig, im Netz Informationen nur zu IPython zu bekommen.
Grundsätzlich braucht ihr euch um IPython gar nicht so sehr zu kümmern, denn
unsere Python-Skripte schreiben wir mit Spyder oder in Jupyter Notebook, welche
beide mit IPython kommunizieren. IPython ist sozusagen die zugrundelegende
Python shell, welche einfach mehr Funktionalität bietet als das Standard
Python-Prompt, insbesondere ermöglicht es die grafische Ausgabe. In der offiziellen
Dokumentation findet ihr eine Liste mit Features.

Anacondas IDE Spyder

Spyder ist eine Python IDE und wird bei Anaconda
mitgeliefert, also quasi die offizielle Anaconda IDE, wenn aktuell auch nicht
mehr von Anaconda bezahlt. Aber erstmal ganz langsam: Was ist nun eine IDE und
wofür brauche ich diese? IDE steht für integrated development environment, also
eine integrierte
Entwicklungsumgebung. Diese ist eine Sammlung von Tools, welche uns die
Software-Entwicklung erleichtern. Meistens sind die IDEs auf eine
bestimmte  Programmiersprache
zugeschnitten. Unter Windows ist die bekannteste Visual Studios,  für Mac ist es XCode, aber es gibt
haufenweise IDEs, jede mit ihren Vor- und Nachteilen. Eclipse, ursprünglich für
Java entwickelt und bei Java-Programmierern beliebt, unterstützt auch C++, PHP
und es gibt Plugins, mit denen unter anderem Python oder R angebunden werden.

Spyder besteht aus mehreren Fenstern, die natürlich alle
angepasst werden können. So sind neben dem Skript noch ein Variablen-Explorer
und die Ipython-Konsole zu sehen. Wenn man ein Skript entwickelt, schickt man
die Befehle per Shortcut an die Konsole. Zudem gibt es gute Debugging und
Profiling-Möglichkeiten. Zusätzlich erlaubt ein Plugin für Spyder auch das
Erstellen und Bearbeiten von Jupyter Notebooks. Alles in allem also ein super
Tool, um sofort mit Python loszulegen.

Jupyter Notebook

Jupyter Notebook ist eine Weboberfläche (also per Webbrowser
wie Chrome zu bedienen), welche neben dem Programmcode in mehrere
Programmiersprachen (in unserem Fall Python oder R) auch formatierten Text und
Grafiken. Notebooks sind ein sehr guter Einstieg in die Python-Programmierung
und es gibt viele Tutorials im Notebook-Format, unter anderem bei Kaggle oder in
diesem Guthub-Repository
findet ihr eine Reihe von interessanten Jupyter Notebooks.

Conda

Conda ist ein Package-Management System, welches die
verschiedenen Versionen von Python und den Libraries verwaltet und dafür sorgt,
dass alles stabil läuft. Super nützlich, insbesondere wenn Projekte nicht mehr
reines Hobby sind (und auch dann ist es hilfreich). Zuerst allerdings nicht
ganz einfach zu verstehen, aber im nächsten Kapitel erkläre ich die Grundlagen
von conda.

Anaconda richtig benutzen

Was sind Conda Environments?

In Anaconda besteht die Möglichkeit, mehrere Umgebungen zu
definieren. Diese Umgebungen können unterschiedliche Versionen von Python und
Packages installiert haben. Das macht Sinn, wenn man sauber verschiedene
Projekte trennen will, also zum Beispiel eine Umgebung für Tensor-Flow und eine
andere für PyTorch. Oder ihr wollt testen, ob alles auf dem Produktiv-Server funktionieren
wird, auf dem ihr nicht mal eben ein Update machen könnt.

Um ein Environment zu erzeugen, gebt ihr im Anaconda Prompt
folgendes ein

conda create –name EnvName

Wollt ihr eine andere Python-Version benutzen, geht das
folgendermaßen

conda create -n EnvName python=3.4

1

conda create -n EnvName python=3.4

Und wenn ihr nun noch bestimmte Package-Version benutzen
wollt, könnt ihr diese einfach aufzählen

conda create -n myenv python=3.4 scipy=0.15.0 astroid babel

1

conda create -n myenv python=3.4 scipy=0.15.0 astroid babel

Man kann auch eine Datei schreiben, in der das alles
definiert ist. Aber dazu ein anderes Mal mehr.

Um nun das neue Environment zu nutzen, müsst ihr es
aktivieren. Unter Windows macht ihr das mit activate EnvName, unter
Linux und MacOS mit source activate EnvName. Damit sollte sich die Kommandozeile
geändert haben.

Das Deaktivieren geht einfach über deactivate bzw. source
deactivate

Wollt ihr Spyder oder Jupyter Notebook in einem Environment nutzen,
müsst ihr es zuerst dort installeren. Das geht über conda install -n myenv spyder. Danach dann einfach
das Environment aktivieren und dann spyder oder eben jupyter
notebook eintippen.

Der Anaconda Navigator

Wenn ihr Anaconda installiert, wird auch der Navigator
mitgeliefert. Dieser ist quasi die bequeme Version vom Anaconda Prompt, d.h.
ihr könnt per Mausklick ein neues Environment erzeugen und Packages updaten.

Anaconda updaten

Um immer die neuste Versionen von Python, IPython, Spyder
und all den Packages zu haben, gibt es zwei Befehle, die ihr kennen solltet
bzw. einfach diese Seite bookmarken und dann immer wieder hier rauskopieren.
Zum Updaten öffnet ihr die Anaconda-Prompt und gebt dann zweimal die folgenden
Befehle ein. Der erste Befehl  updated
das conda-Programm

conda update conda

Im Anschluss updated ihr das Anaconda-System

conda update
anaconda

Nach einer kurzen Warterei wird eine Liste mit allen
anstehenden Veränderungen (Upgrades und Downgrades) angezeigt, die ihr noch
bestätigen müsst. Ja, es gibt je nach installierten Versionen der Packages auch
Downgrades. Conda versucht, eine möglichst stabile Umgebung zu erzeugen. Wenn
also ein Packages auf einer älteren Version eines anderen Packages aufbaut,
wird conda den Konflikt auflösen.

Wie gesagt, am besten zwei Mal hintereinander ausführen,
damit auch alle Abhängigkeiten sauber aufgelöst werden. Danach solltet ihr eine
Anaconda-Version haben, wie als hättet ihr sie frisch heruntergeladen und
installiert.

Das solltet ihr unbedingt im Root-Environment machen

Warum ihr nicht conda update –all aufrufen solltet, oder doch?

Wenn ihr ein bisschen im Netz sucht, werdet ihr auch auf den
Befehl

conda update –all

stoßen. Der macht ein bisschen was anderes. Damit
installiert ihr zu jedem Package die neueste Version (unter der Veraussetzung,
dass alle Abhängigkeiten erfüllt sind). Das bringt jedes Package auf den
neusten Stand, denn ein Anaconda-Release kann auch mal einige Monate alt sein. Früher
führte das nicht unbedingt zu einer stabilen Umgebung. Anaconda hat in ihren
Distributionen extra die Package-Versionen so ausgewählt, dass alles gut
zusammenspielt.

Ihr müsst euch also entscheiden, ob ihr eine möglichst
stabile oder eine möglichst aktuelle Umgebung haben wollt.

Pip-Packages und manuelle Installation

Noch ein Wort der Warnung zu mit pip oder manuell per python setup.py install installierten Packages.
Diese werden von conda nicht berücksichtigt, denn woher soll conda wissen, was
ihr da installiert habt. Hier müsst ihr euch selber um das Update kümmern.
Prinzipiell sollte man also immer per conda installieren, sofern es diese Option
gibt.
Glossar: Maschinelles Lernen

Python-Beispiel: Wochentage

Hej Leute,
Python-Bite steht für kleine Beispiel Python-Codehappen, die ein Befehl oder die Anwendung einer Library verdeutlichen. Heute geht es darum, wie Ihr den Wochentag eines Datums herausfindet.
Dafür gehen wir in mehreren Schritten vor. Als ersten setzen wir die lokalen Einstellungen auf deutsch, ansonsten bekommen wir nämlich die englischen Wochentage. Das geht mit dem Befehl

Python

locale.setlocale(locale.LC_ALL, 'deu_deu')

1

locale.setlocale(locale.LC_ALL, 'deu_deu')

Dann sagen wir dem Benutzer, dass er sein Geburtstag eingeben soll. Die Eingabe ist natürlich erstmal ein String, den wir in den Datumstyp umwandeln wollen. Hier bietet es sich an, eine Überprüfung zu machen, ob die Eingabe im richtigen Format ist, der Einfachheit halber lasse ich es aber weg.
Im nächten Schritt wollen wir den eingebenen String in ein Datum umwandeln. Hierzu nutzen wir die Library datetime, denn mit dem folgenden Befehl können wir das erreichen.

Python

datetime.datetime.strptime(birthdate,'%d.%m.%Y').date()

1

datetime.datetime.strptime(birthdate,'%d.%m.%Y').date()

So, nun haben wir also ein Datum und der Typ date liefert auch schon die passende Funktion weekday mit, d.h. mit birthday.weekday() bekommen wir den Wochentag geliefert. Allerdings nur als Zahl, welche wir noch in den Wochentag-Namen umwandeln wollen. Dafür ist die Library „calendar“ geeignet. denn diese enthält das Array day_name. Wir suchen also aus dem Array einfach das Element an der Stelle der Wochentagszahl raus. Und das geht so:

Python

calendar.day_name[birthday.weekday()]

1

calendar.day_name[birthday.weekday()]

 
Hier also nochmal der ganze Code zum direkt ausprobieren.

Python

# -*- coding: utf-8 -*-
"""
Wochentag des Geburtstags

@author: Holger
"""

import datetime
import calendar
import locale

locale.setlocale(locale.LC_ALL, 'deu_deu')

print('Hallo, wie heißt Du?')
name = input()
print('Hallo '+name)
print('Bitte nenne mir Dein Geburtstag (TT.MM.JJJJ):')
birthdate = input()

#in Datumformat konvertieren
birthday = datetime.datetime.strptime(birthdate,'%d.%m.%Y').date()

print('Du bist an einem '+calendar.day_name[birthday.weekday()]+' geboren.')

1234567891011121314151617181920212223

# -*- coding: utf-8 -*-"""Wochentag des Geburtstags @author: Holger""" import datetimeimport calendarimport locale locale.setlocale(locale.LC_ALL, 'deu_deu') print('Hallo, wie heißt Du?')name = input()print('Hallo '+name)print('Bitte nenne mir Dein Geburtstag (TT.MM.JJJJ):')birthdate = input() #in Datumformat konvertierenbirthday = datetime.datetime.strptime(birthdate,'%d.%m.%Y').date() print('Du bist an einem '+calendar.day_name[birthday.weekday()]+' geboren.')

Und jetzt experimentiert ein bisschen selber herum. Kommentiert mal die Zeile mit locale aus, etc.
Happy Coding,
Euer Holger
Glossar: Maschinelles Lernen

Meine 15 nützlichsten RStudio Shortcuts

Hej Leute,
Ihr wollt Profi-RStudio-Nutzer werden? Oder einfach nur schneller in R programmieren? Wie wir das aus anderen Programmen kennen, sind Shortcuts dafür eine Voraussetzung. Jetzt ist es natürlich in R Studio nicht so essentiell wie in Excel, da es ja nicht größtenteils um das Eintippen von Code geht und nicht, die richtigen Buttons anzuklicken, aber dennoch kann man mit den Tastaturkürzeln deutlich effizienter die R Studio Oberfläche nutzen. Daher habe ich für Euch meine 15 wichtigsten RStudio-Shortcuts aufgeschrieben.
 
1. Strg + Eingabetaste
Das wichtigste Tastenkürzel überhaupt, das vermutlich jeder von Euch kennt. Denn ohne kann man sich die Verwendung von RStudio nicht vorstellen. Mit Strg + Eingabetaste wird der markierte Skript-Teil oder die aktuelle Zeile an die R-Konsole geschickt und damit ausgeführt. Für die Schnellen unter Euch ist der zweite Teil wichtig, denn ich muss gar keinen Code markieren, sondern nur den Cursor an der richtigen Position haben. Um noch eine Schippe Geschwindigkeit draufzulegen, braucht Ihr natürlich noch die Shortcuts für das schnelle Markieren von Codeabschnitten. Und da kommt schon der nächste Shortcut ins Spiel.
2. Alt + Pfeil links/rechts
Damit Ihr schnell im Skript navigieren könnt, braucht Ihr dafür natürlich einen Shortcut. Nach oben und unten ist klar, das geht wie üblich mit den Bild hoch/runter Tasten. Aber um an den Anfang oder das Ende einer Zeile zu springen, und nicht einfach nur auf die Pfeiltasten zu drücken und zu warten, nehmt Ihr einfach die Alt-Taste dazu. Denn mit Alt + Pfeil links/rechts springt der Cursor an den Anfang bzw. Ende einer Zeile. Aber Achtung: Alt + Pfeil hoch/runter schiebt die aktuelle Zeile im Skript nach oben bzw. unten, also nicht aus Versehen diese Tasten drücken. Mit diesem RStudio Shortcut wird das Auswählen von mehreren Zeilen Code schneller, denn wenn der Cursor erstmal am Anfang einer Zeile ist, können dann mit Shift + Pfeil hoch/runter ja dann fix die entsprechenden Zeilen ausgewählt werden.
3. Tab
Autovervollständigung – das Feature schlechthin. Eigentlich hätte ich diesen R Shortcut auf Platz 1 setzen sollen. Denn habt Ihr einen R-Befehl angefangen zu tippen, schlägt Euch RStudio mögliche Vervollständigungen vor. Und dafür müsst Ihr nichts tun, außer vielleicht eine Millisekunde warten. So tippe ich nur agg und drücke dann die Tab-Taste, sobald das Auswahlmenü aufgepoppt ist und schon steht „aggregate(„ da und ich kann die Parameter einsetzen. In dem Auswahlmenü navigiert Ihr übrigens einfach mit Pfeil hoch/runter, kein Grund, die Maus zu benutzen.
4. Alt + –
Wir sind ja alles ordentliche Programmierer und benutzen für die Zuordnung den Pfeil <- und nicht das Gleichheitszeichen, oder? Ok, ertappt. Aber tatsächlich läßt sich der Zuordnungspfeil super schnell erstellen, nämlich mit dem RStudi Tastaturkürzel Alt + – (Minus). Super simpel und in fast jeder R-Code-Zeile zu verwenden.
 
5. Strg + F
Der Klassiker, den Ihr hoffentlich auch schon aus anderen Programmen wie Word oder Excel kennt. Mit Strg + F öffnet sich oberhalb des Skripts die Suchmaske, mit der Ihr ein Wort im Skript finden und auch ersetzen könnt. Interessanterweise funktioniert das Kürzel Strg + H, welches in vielen Programmen den Suchen und Ersetzen-Dialog aufruft, in RStudio nicht. Aber da Suche und Suche und Ersetzen sowieso in der Suchmaske nebeneinander stehen, ist das auch gar nicht nötig. Hier noch ein Power-Tipp zum Ersetzen: Markiert vorher das Wort, welches Ihr ersetzen wollt und benutzt dann den Shortcut Strg+F, dann wird nämlich dieses Wort direkt schon in Find eingetragen.
 
6. F1
Ok, Ihr wisst, wie ein Befehl heißt, aber braucht Details dazu. Schaut in mein R-Glossar – R-Befehle mit knackiger Erklärung und guten Beispielen – oder schreibt ?Befehlsname oder drückt einfach F1, wenn der Cursor auf der Funktion steht.
 
7. Strg + L
Ist die R-Konsole voll von den vorherigen Aufrufen? Dann drückt Strg + L und löscht damit die bisherige Ausgabe aus der Konsole
 
8. Strg + 1, Strg + 2
Ehrlich gesagt braucht man diese Shortcuts gar nicht so häufig, denn das meiste spielt sich doch im Skript ab. Aber wenn ihr schnell mal in die R-Konsole springen wollt, benutzt Strg + 2, um mal eben ein paar Befehle auszuprobieren. Dann mit Strg+2 zurück zum Skript, um mit der eigentlichen Arbeit fortzufahren.
 
9. Strg + Shift + R
Dieser R-Shortcut ist super nützlich. Ihr könnt Eure R-Skripte strukturieren, indem Ihr Abschnitte einfügt. Diese lassen sich dann mit dem folgenden Shortcut ein- bzw. ausblenden. Sobald Euer Code eine gewisse Länge hat, ist das definitiv zu empfehlen. Und es ist auch echt schnell gemacht, einfach Strg + Shift + R drücken, benennen und fertig.
 
10. Alt + L, Alt + Shift + L
Sind mehrere Zeilen markiert oder noch besser ein Abschnitts-Label gesetzt (siehe letzten Shortcut), kann dieser mit Alt+L eingeklappt und mit Alt + Shift+L wieder ausgeklappt werden. So behaltet Ihr und die Leute, die Euren Code blicken müssen, den Überblick.
 
11. Strg + Shift + M
Finger verknotet beim Erzeugt die Pipe %>%, dann schafft das RStudio Tastenkürzel Strg + Shift + M Abhilfe. Auf deutschen Tastaturen ist die Pipe ansonsten wirklich schlecht tippbar, aber so nützlich, wenn Ihr das tidyverse nutzt.
12. Strg + +. Strg + –
Mit diesem Shortcut skaliert Ihr die Größe der Schrift. Ok, zugegeben, ist ein Spezialfall, aber ziemlich praktisch, wenn man zwischen Laptop und Docking-Station mit Monitoren hin und herwechselt. So hat mein Laptop eine ziemlich hohe Auflösung, also muss ich die Schrift ein bisschen vergrößern. Die Monitore sind aber groß genug bzw. haben für die Größe nur Full-HD, also dort ist es besser, die Schrift zu verkleinern.
 
13. Strg + Shift + a
Ihr wollt sauber formatierten Code, habt aber keine Lust, das alles selber zu machen. Markiert den Bereich, den ihr formatieren wollt und drückt Strg + Shift + A und schon ist alles sauber formatiert, wie es sein sollte.
 
14. Strg + Shift + C
Anstatt an den Anfang der Zeile zu gehen (siehe Shortcut Nr. 2) und dann die Raute zu setzen, um die Zeile auszukommentieren, könnt ihr auch einfach Strg+Shift + C drücken und schon ist die Zeile auskommentiert. Und das Ganze unabhängig von der Cursor-Position, was wirklich praktisch ist.
 
15. Strg + F11, Strg + F12
Last but not least ein nützlicher Shortcut, um zwischen mehreren geöffneten Skripten hinu nd her zu springen.Mit Strg + F11 geht ihr zum vorherigen Skript bzw. Tab, der gerade offen ist, mit Strg + F12 zum nächsten Skript bzw. Tab. Damit navigiert ihr schnell zwischen verschiedenen offenen R-Skripten oder zwischen Skript und RMarkdown oder was ihr sonst noch so in RStudio treibt.
 
 
Das waren meine 15 wichtigsten RStudio Shortcuts. Auch wenn ihr schon RStudio-Profis seid, hoffe ich, dass das ein oder andere RStudio-Tastenkürzel noch nicht bekannt war, so dass Ihr Euren Workflow verbessern könnt.
Also, happy RStudioing,
Euer Holger
Glossar: Maschinelles Lernen RStudio

Die Statistik-Software R

R ist eine Programmiersprache, die vor allem für statistische Auswertungen und Datenanalysen benutzt wird. Dabei wächst die Anzahl der Benutzer stetig, insbesondere durch die aktuellen Data Science Trends wie Maschinelles Lernen. Mit der Statistik-Software R kannst Du statistische Simulationen, Datenanalysen, aber auch Datenmanagement oder automatisierte Reports und Dashboards erstellen.
R ist völlig kostenlos und ein GNU-Projekt. Du kannst das Statistikprogramm R auf der offiziellen R-Projekt-Seite herunterladen. Es ist für Windows, MacOS und viele Unix-Varianten – unter anderem debian, redhat, suse und ubuntu – verfügbar.
R ist eine Interpreter-Programmiersprache, d.h. ein R-Skript wird Zeile für Zeile ausgeführt. Das Gegenteil ist eine Compiler-Programmiersprache wie C++, welche das gesamte Skript nimmt und in eine maschinenlesbare Form (exe-Datei) bringt. Mit R ist das nicht möglich, d.h. man benötigt immer eine R-Installation, um ein R-Skript laufen zu lassen.
Was sind R-Packages?
R besitzt umfangreiche Erweiterungen, sogenannte Packages. Diese statten R mit vielen zusätzlichen Fähigkeiten aus, vom Datenmanagement über spezielle statistische Algorithmen bis zu umfangreichen Grafikbibliotheken. Aktuell gibt es über 12.000 Packages zum kostenlosen Herunterladen. In meinem kostenlosen eBook „Powertricks für das Datenmanagement mit R“ beschreibe ich die 10 wichtigsten Packages für das Datenmanagement und gebe einfache Beispiele.
Ein Package wird in R mit dem Befehl install.packages(„paketname“) heruntergeladen und installiert. Das muss man einmalig machen. Danach kann das Package über library(paketname) in das aktuelle Skript eingebunden werden.
Man spricht von Base-R, wenn eine Funktion in der Basisinstallation von R dabei ist.
Statistik mit R
R wurde ja entwickelt, um Statistikprogramme zu schreiben. Insofern gibt es schon in der Basisinstallation von R viele Funktionen, die für statistische Auswertungen verwendet werden können. Hier einige Beispiele:

# erstellt eine normalverteilte Stichprobe mit n=100
x &lt;- rnorm(100)

## einige deskriptive Statistikmethoden
# Mittelwert
mean(x)
# Standardabweichung
sd(x)
# Varianz
var(x)
# Minimum
min(x)
# Maximum
max(x)
# Wertebereich
range(x)
# Median
median(x)

# Lineare Regression
#Stichprobe erstellen
n &lt;- 100
x &lt;- rnorm(n)
y &lt;- 2 + 3*x + rnorm(n,0,0.5)

l &lt;- lm(y ~ x)
l
summary(l)

#statistische Tests
n &lt;- 100
x &lt;- rnorm(n)
y &lt;- rt(n,1)
t.test(x,mu=2) #Test, ob Mittelwert=2
t.test(x,y) #Test, ob Mittelwert von x und y gleich
shapiro.test(y) #Test auf Normalverteilung

12345678910111213141516171819202122232425262728293031323334353637

# erstellt eine normalverteilte Stichprobe mit n=100 x &lt;- rnorm(100) ## einige deskriptive Statistikmethoden# Mittelwertmean(x)# Standardabweichungsd(x)# Varianzvar(x)# Minimummin(x)# Maximummax(x)# Wertebereichrange(x)# Medianmedian(x)  # Lineare Regression#Stichprobe erstellenn &lt;- 100x &lt;- rnorm(n)y &lt;- 2 + 3*x + rnorm(n,0,0.5) l &lt;- lm(y ~ x)lsummary(l) #statistische Testsn &lt;- 100x &lt;- rnorm(n)y &lt;- rt(n,1)t.test(x,mu=2) #Test, ob Mittelwert=2t.test(x,y) #Test, ob Mittelwert von x und y gleichshapiro.test(y) #Test auf Normalverteilung

RStudio –  Die Standard R IDE
Wenn Du R installiert hast, kannst Du eigentlich direkt loslegen. Es lohnt sich aber, zusätzlich eine Entwicklungsumgebung zu installieren. IDE steht übrigens für „integrated development environment“. Vielleicht kennst Du ja schon Visual Studios oder Eclipse. Eine Entwicklungsumgebung hilft Dir beim Programmieren, indem es nützliche Ansichten und Werkzeuge bereitstellt. So bieten IDEs meistens eine Variablenansicht, also eine Tabelle mit allen Variablen, die verwendet wurden. Besonders effizient ist die automatische Vervollständigung, d.h. wie in Google zeigt Dir die IDE Ergänzungsvorschläge an, wenn Du den Anfang eines Befehls getippt hast. Damit wird das Programmieren deutlich schneller.
Die de facto Standard-IDE für R ist RStudio. Mittlerweile gibt es aber auch Visual Studio for R und auch Eclipse StatET
Von RStudio gibt es eine Desktop- und eine Serverversion. Die Desktopversion gibt es für Windows, MacOS und die Standard-Linux-Distributionen (Ubuntu, Debian, Fedora, Redhat, Suse). Neben der OpenSource-Version, die für die meisten von uns in Frage kommt, gibt es noch eine Commercial Licence für 1000$/Jahr, welche Priority Support bietet.
Die Serverversion gibt es nur für Linux. Diese benötigt man, wenn man R auf einem Server laufen lassen möchte und darauf per RStudio IDE über einen Webbrowser zugreifen möchte. Auch von RStudio Server gibt eine eine kostenlose OpenSource-Version und eine kommerzielle Version. Im Gegensatz zur Desktop-Version bietet aber die kommerzielle Version viele zusätzliche Tools wie LoadBalance, Monitoring und viele weitere Admin-Tools. Das hat allerdings auch seinen Preis, dafür sind nämlich 10.000$ im Jahr fällig. Sinnvoll also nur für Firmen, die diese Infrastruktur benötigen.
Aktuell arbeite ich mit einer ganz normalen R Desktop OpenSource-Version, welche auf einem Server läuft, auf den ich ganz simpel per RemoteDesktop zugreife. Ganz simpel, einfach aufzusetzen und genügt für fast alle Anwendungen. Zusammen mit Shiny Server, welcher für die Bereitstellung von Dashboards benötigt wird, ist das schon ein ganz mächtiges System.
Glossar: Maschinelles Lernen RStudio rnorm mean min median

QlikView-Tutorial für Einsteiger – Neugeborenen-Vornamen – Teil 2

Herzlich willkommmen zu Teil 2 meines QlikView-Einsteiger-Tutorial. Ihr habt Euch durch Teil 1 des QlikView-Tutorials für Einsteiger durchgekämpft. Dort ging es um das Datenmodell, genauer gesagt um das Einlesen der csv-Dateien mit den Vornamenhäufigkeiten in Bonn, welche wir von der Seite Offene Daten: Bonn heruntergeladen hatten.
Hier im zweiten Teil geht es also darum, die eingelesenen Daten zu visualisieren. Das geht mit QlikView ziemlich einfach, da man sich die Benutzeroberfläche zusammenklicken kann.

Filterboxen in QlikView
Als ersten bauen wir uns ein paar Filterboxen, d.h. sogenannte Listboxen, welche die Daten auf die entsprechende Auswahl einschränken. Wir bauen uns eine Box für die Jahresauswahl und eine für das Geschlecht. Das tolle daran ist, dass sich automatisch alle Diagramme und Tabellen anpassen, wenn eine Auswahl getroffen wird. Diese dynamische Filterung ist Segen und Fluch zugleich, mit den entsprechenden Set-Formeln kann man aber alle Filterungen ignorieren, wenn man das in einem bestimmten Chart nicht möchte. Doch dazu kommen wir ein einem fortgeschritteneren QlikView-Tutorial.
 
So, also schnell die zwei Boxen erstellt. Rechts auf die Arbeitsfläche klicken, dann neues Objekt auswählen, dann Listbox. Dort wählen wir das entsprechende Feld aus, in der ersten Listbox „Jahr“, in der zweiten „Geschlecht“. Alternativ geht es auch über „Felder hinzufügen“, welches übrigens direkt nach dem Laden eingeblendet wird.
 
Nun machen wir noch zwei Modifikationen. Zum einen stellen wir in der Jahresbox ein, dass wir mehr als eine Spalte zulassen. Das geht in dem Tab Präsentation. Zum anderen wollen wir den Radiergummi statt der Lupe in der Titelleiste anzeigen, also die Auswahl aufheben. Eine Suche (Lupe) ist bei den paar Auswahlmöglichkeiten nicht nötig. Das kann man im Tab Titelleiste einstellen.

Jetzt können wir schon eine Filterung vornehmen. Man sieht aber natürlich noch nichts, denn wir haben ja bisher gar kein Objekt, welches die Daten anzeigt.

Ein Balkendiagramm einfügen
Wir wollen endlich ein Chart sehen. Also schnell mit rechter Maustaste auf die Arbeitsfläche geklickt, Neues Objekt -> Diagramm auswählen.

Wir geben dem Objekt einen Titel, wählen „Diagrammtitel anzeigen“ ab und klicken auf weiter. Im nächsten Fenster wählen wir die Dimensionen aus. In unserem Fall ist das Vorname, der auf der x-Achse erscheinen soll. Übrigens kann man später über Eigenschaften alle Parameter anpassen und verändern.

Nun kommt die Formel, also was der y-Wert sein soll. Wir tippen sum(Anzahl), denn wir wollen die Anzahl darstellen. Summe deshalb, weil wir dem Chart sagen müssen, was es macht, wenn ein Vorname mehrfach auftaucht (z.B. wenn mehr als ein Jahr ausgewählt wurde). Im nächsten Fenster noch die Bezeichnung eingegeben und mit  „Fertig stellen“  beenden.

So richtig schön sieht das noch nicht aus:

Das Balkendiagramm schöner machen
Als ersten entfernen wir die Maximieren- und Minimieren-Icons. Dazu rechts auf das Diagramm klicken, Eigenschaften auswählen und im Tab Titelleiste das Häkchen bei Maximieren und Minimieren entfernen.

Wie wir den Titel benannt haben, wollen wir nur die 10 häufigsten Namen anzeigen, also im Tab „Beschränkungen“ das Häkchen bei „Anzeige beschränken auf“ setzen. Größte 10 ist schon als Standardwert gesetzt, müssen wir als nicht mehr ändern. Noch unten das Häkchen bei „Sonstige anzeigen“ entfernen, sonst würden alle anderen Namensanzahlen unter Sonstige aufsummiert. Könnt ihr aber mal ausprobieren, wie das aussieht.

Im Dimensionstab entferne ich noch die Anzeige der Bezeichnung und im Tab Achsen stelle ich die Breite der Achse auf 1pt, damit die Achsen überhaupt zu sehen sind.

Noch schnell die Farbe angepasst, das Menü erklärt sich eigentlich von selbst.
Und als letztes die Reihenfolge unter Sortierung auf y-Werte absteigend gestellt. Wir wollen ja mit dem häufigsten Vornamen beginnen.

So, geschafft. Nun sehen wir die Auswirkungen der Filter. Wir können auf ein oder mehrere Jahre und auf das Geschlecht filtern.

Einen zeitlicher Verlauf in QlikView anzeigen
Wir wollen noch einen zeitlichen Verlauf für einzelne Vornamen als Chart anzeigen. Dazu kopieren wir das vorhandene Arbeitsblatt, indem wir rechts auf die Arbeitsfläche (wo noch kein Objekt ist) klicken und „Arbeitsblatt kopieren“ auswählen. Wir wechseln zum neuen Arbeitsblatt und benennen es in „Verlauf“ um, was wir in den Eigenschaften des Arbeitsblatts machen können.
Wir erzeugen eine Listbox mit den Vornamen und fügen wieder den Radiergummi hinzu (Auswahl aufheben) und arrangieren diese so, dass es etwas hübscher aussieht.

Formeln in Listboxen
Wir wollen neben den Vornamen in der Listbox noch die Häufigkeit anzeigen. Dazu gehen wir in die Eigenschaften der Listbox, dort in den Reiter Formeln und auf „Einfügen“ klicken. Wir benutzen wieder die Formel sum(Anzahl). Leider reicht das noch nicht ganz, wie wir gleich sehen werden. Wird nämlich jetzt ein Name ausgewählt, dann erscheint bei allen anderen 0. Erstmal komisch, aber eigentlich ganz logisch, denn so arbeitet QlikView. Sobald eine Filterung gemacht wurde (hier also ein Vorname ausgewählt wurde), werden alle Daten auf die Filterung eingeschränkt.

Aber zum Glück können wir das leicht anpassen, nämlich mit Set-Formeln. Statt sum(Anzahl) benutzen wir nun sum({<Vorname=>} Anzahl). Damit sagen wir QlikView, dass wir nur für diese Formel einen etwaigen Filter auf Vorname wieder auflösen wollen. Set-Formeln sind nicht ganz einfach, aber mit ihnen lassen sich sehr viele tolle Dinge machen und wenn man tiefer in QlikView einsteigen möchte, kommt man nicht darum herum. Demnächst gibt es dazu von mir ein eigenes Set-Formel-Tutorial.
Statt der Standard-Sortierung wollen wir die Liste auch nach der Häufigkeit sortieren. Also im Reiter Sortierung nur Formel wählen und absteigend einstellen. Dort benutzen wir genau die gleiche Formel sum({<Vorname=>} Anzahl), so dass auch die Sortierung konsistent bleibt.

Liniendiagramm
Als letzten Schritt wandeln wir noch das Balkendiagramm in ein Linienchart um. Das geht wirklich ganz schnell. Einfach im ersten Reiter „Allgemein“ den Diagrammtyp auf Liniendiagramm umstellen. Dann im zweiten Reiter „Dimension“ Jahr und Vorname als Dimensionen. Wichtig ist die richtige Reihenfolge, also Jahr vor Vorname. Die Formel sum(Anzahl) bleibt bestehen. Bei der Sortierung noch schauen, dass das Jahr nach numerischem Wert sortiert wird.

Und dann sind wir fertig. Wenn wir nun einen oder mehrere Vornamen und kein oder mehrere Jahre ausgewählt haben, sehen wir die Entwicklung. Ein schickes Mouseover gibt es auch noch, den man übrigens auch anpassen kann, aber dazu ein anderes Mal mehr.

Korrekturen im Skript
Im Chart sehen wir, dass die Anzahlen für alle Vornamen 2017 deutlich niedriger sind als die Jahre davor. Anscheinend war unser Vorgehen, dass wir beim Einlesen nur die erste Position genommen haben, nicht so geschickt, denn anscheinend wurden in den Jahren zuvor einfach alle Positionen zusammengeworfen. Das machen wir im Ladeskript für 2017 jetzt auch durch folgende Änderung:
LOAD
vorname
,sum(anzahl) as anzahl
,geschlecht
//    ,position
,2017 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2017.csv]
(txt, utf8, embedded labels, delimiter is ‚;‘, msq)
//where position=1;
group by vorname,geschlecht;
 
Wenn wir das Skript jetzt laufen lassen, sehen wir im Anschluss im Dashboard, dass nun alles passt.

 
 
Das war es erstmal. Ich hoffe, ihr konntet etwas für euch mitnehmen und habt Lust, selber weiter das Dashboard zu erweitern.
 
Happy Qliking,
Euer Holger
Glossar: Maschinelles Lernen RStudio rnorm mean min median

QlikView-Tutorial für Einsteiger – Neugeborenen-Vornamen – Teil 1

Hej Leute,
hier kommt mein erstes QlikView-Tutorial für Euch. Bei meiner Arbeit als Data Scientist für die Schön Kliniken benutze ich QlikView nun seit 2,5 Jahren für die verschiedensten Dashboards und Anwendungen. Das reicht von einfachen Kontroll-Charts, die die Ladekette überwachen, bis hin zu komplexen Anwendungen für den Endnutzer, welche sich generisch über Steuertabellen konfigurieren lassen, so dass sie sich die entsprechenden Daten holen und passende Dashboards dazu darstellen.
In Teil 1 von diesem Tutorial geht es um das Ladeskript, also wie bekommt man die Daten aus den Datenquellen nach QlikView. In Teil 2 des QlikView-Tutorials für Einsteiger machen wir uns dann an die Datenvisualisierung bzw. das Dashboard. Ich habe alles Schritt für Schritt erklärt, also sollte jeder eigentlich mitkommen. Sonst schreibt mir einfach, wo ihr Probleme habt.
 
QlikView herunterladen und installieren
Ok, der erste Schritt gestaltet sich schon als nicht ganz einfach. Qliktech hat die Download-Seite für die kostenlose QlikView Personal Edition etwas versteckt, aber mit etwas Suche findet man sie (oder klickt auf meinen Link). Die Personal Edition hat die Einschränkung, dass man nur eigene QlikView-Applikationen öffnen kann. Also mal eben ein schönes Beispiel aus dem Internet ansehen oder mit anderen Leuten teilen, die auch nur die Personal Edition haben, geht leider nicht.

Ok,zurück zum Download. Leider dann noch viele persönliche Daten eingeben, naja, kommt man wohl nicht drum herum. Und schon kann die Software installiert werden. Die Installation ist easy und einfach immer auf weiter klicken führt einen durch.
 
Erste Schritte – das Filmbeispiel
Als Beispiel-Anwendung hat QlikTech eine Filmdatenbank in QlikView geladen und eine kleine Oberfläche dazu gebastelt. Schaut einfach selber rein und klickt euch durch.

 
Jetzt wollen wir aber selber laufen lernen und eigene Anwendungen entwickeln …
 
QlikView-Tutorial: Neugeborenen-Vornamen in Bonn
 
Daten
Zuerst brauchen wir Daten. Dafür habe ich mal in den Datensätzen von Bonn: Offene Daten gestöbert und bin auf die Daten zu den Vornamen von Neugeborenen von 2010 bis 2017 gestoßen. Diese gibt es jahresweise als csv- oder json-, z.T. auch als xls-Datei, zum Herunterladen. Für QlikView bieten sich die csv-Dateien an. Komischerweise gibt es die 2014-Daten nicht als csv, sondern nur als Excel. Prinzipiell wäre das kein Problem, da QlikView natürlich beide Formate einlesen. Aber ich habe meine Daten gerne ordentlich für eventuell spätere Verwendung. Also schnell in Excel geöffnet und als csv abgespeichert.
 
Das QlikView-Ladeskript
QlikView hat, grob gesagt, zwei Bereiche. Zum einen das Ladeskript, welches für den Import der Daten sorgt und bei jeder Aktualisierung durchläuft. Zum anderen die grafische Oberfläche. Die Skriptsprache ist relativ intuitiv, wenn sie auch ihre Eigenarten hat, und kann eine ganze Menge. Für die komfortable Bedienung gibt es Assistenten, welche Euch beim Einlesen der Datenquellen unterstützen.
 
Ok, zuerst erstellen wir eine neue Datei (Überraschung, Datei -> Neu) und speichern diese direkt ab. Das Speichern ist wichtig, damit beim Einlesen der Daten die Pfade richtig gesetzt werden. Die Endung von QlikView-Applikationen ist qvw.
 
Nun öffnen wir das Ladeskript durch Klick auf den entsprechenden Button (Shortcut STRG + E).

Dort gibt es schon einige Einträge, die uns aber erstmal nicht groß interessieren müssen. Es werden nur die Standardformate für Deutschland gesetzt.

Das Ladeskript kann man der Übersicht halber in verschiedene Tabs auftrennen, die nacheinander ausgeführt werden.
 
Csv-Dateien einlesen
Wir erstellen also ein neues Registerblatt (Registerblatt -> Neues Registerblatt) und geben ihm den Namen „Einlesen“. Ich empfehle, noch die Checkbox Relative Pfade anzuklicken. Diese sorgt dafür, dass eben nicht der absolute Laufwerkpfad verwendet wird, sondern eben der zum Speicherort der qvw relative.

Jetzt nutzen wir den Assistenten, indem wir auf Tabelle klicken. Dort wählt ihr alle Vornamen-Dateien aus, im nächsten Fenster noch sagen, dass der Spaltennamen mitgeliefert wird und dann auf Fertig klicken. Das macht ihr jetzt für jede der Dateien.

Fertig ist das erste Ladeskript und ihr könnt es mit Skript ausführen auch direkt mal laufen lassen.
Achtung: Bitte immer abspeichern, bevor ihr ein Skript laufen lasst. Sind Fehler in dem Skript, kann man nur so einem Verlust der Arbeit seit dem letzten Speichern entgehen.
 
Nachdem das Skript durchgelaufen ist, gehen wir in die Tabellenstruktur-Ansicht. Im Skripteditor der zweite Button von rechts oder per Shortcut Strg+T (für den Shortcut müsst ihr nicht extra in den Skripteditor).

Hier sehen wir schon, dass etwas nicht ganz so ist, wie es sein sollte. QlikView hat also eine Tabelle „Vornamen 2010“ und eine Tabelle „Vornamen 2017“ angelegt und diese mittels einer Zwischentabelle Syn$1 verknüpft. Zu synthetischen Keys gibt es eine ganze Menge zu sagen, das würde aber das Tutorial hier sprengen. Nur soviel: In den meisten Fällen sind synthetische Tables nicht gewünscht.
Aber was ist eigentlich passiert. Da die csv-Dateien von 2010 bis 2016 genau gleich aufgebaut sind, packt er diese alle in eine Tabelle und da wir mit 2010 angefangen haben und nicht extra benannt haben, heißt sie eben wie die Datei. In 2017 ändert sich die Datenstruktur der csv-Datei. Es kommt noch die Spalte position dazu, die angibt, ob der Vorname an erster, zweiter, … Stelle vorkommt.
 
Ladeskript reparieren
Zuerst geben wir der ersten Tabelle den Namen „Vornamen“. Dann modifizieren wir noch das Einlesen der 2017-Daten, indem wir position auskommentieren, aber das Einlesen nur auf die Namen beschränken, die an erster Stelle vorkommen (also position=1). Das macht man wie in SQL mit einem where
 

LOAD
vorname
,anzahl
,geschlecht
// ,position
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2017.csv]
(txt, utf8, embedded labels, delimiter is ';', msq)
where position=1;

12345678

LOAD   vorname ,anzahl ,geschlecht // ,position FROM [..\..\Daten\Vornamen Bonn\Vornamen 2017.csv] (txt, utf8, embedded labels, delimiter is ';', msq) where position=1;

 
Jetzt können wir das Skript laufen lassen und es wird alles schön in eine Tabelle geschrieben. Aber Moment, wir haben etwas vergessen. Es gibt nur die Felder vorname, anzahl und geschlecht, aber keine Jahreszahl. Die ergänzen wir jetzt noch, in dem wir das hart in jeden load-Befehl einfügen.
 
Es geht natürlich auch eleganter, indem wir eine Schleife über alle Dateien bauen, aber das ist etwas für ein nächstes Tutorial.
 
Damit wir später in der Anzeige nicht jedesmal den Feldnamen für die Ansicht anpassen müssen (von kleinem auf großen Anfangsbuchstaben), nennen wir am Ende vom Skript noch schnell die Felder mittels RENAME FIELD um.

RENAME FIELD vorname TO Vorname;

1

RENAME FIELD vorname TO Vorname;

 
 
Die fertige Tabellenstruktur (Shortcut Strg+T nicht vergessen) sieht dann so aus. Das komplette Ladeskript gibt es am Ende.

 
 
Und das war Teil 1 des Tutorials. Daran denken, erst dafür sorgen, dass das Ladeskript soweit wie möglich aufgebaut ist und sauber durchläuft. Dann geht es an die Visualisierung in Teil 2 des QlikView-Tutorials für Einsteiger.
 
Happy Qliking,
Euer Holger
 
Das fertige Ladeskript
Hier gibt es das (fast) komplette Ladeskript. Die Standardeinstellungen aus dem ersten Tab habe ich nicht reinkopiert. Beim Kopieren müsst ihr noch die Pfade anpassen.

Vornamen:
LOAD
vorname
,anzahl
,geschlecht
,2010 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2010.csv]
(txt, utf8, embedded labels, delimiter is ';', msq);

LOAD
vorname
,anzahl
,geschlecht
,2011 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2011.csv]
(txt, utf8, embedded labels, delimiter is ';', msq);

LOAD
vorname
,anzahl
,geschlecht
,2012 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2012.csv]
(txt, utf8, embedded labels, delimiter is ';', msq);

LOAD
vorname
,anzahl
,geschlecht
,2013 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2013.csv]
(txt, utf8, embedded labels, delimiter is ';', msq);

LOAD
vorname
,anzahl
,geschlecht
,2014 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2014.csv]
(txt, utf8, embedded labels, delimiter is ';', msq);

LOAD
vorname
,anzahl
,geschlecht
,2015 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2015.csv]
(txt, utf8, embedded labels, delimiter is ';', msq);

LOAD
vorname
,anzahl
,geschlecht
,2016 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2016.csv]
(txt, utf8, embedded labels, delimiter is ';', msq);

LOAD
vorname
,anzahl
,geschlecht
// ,position
,2017 as Jahr
FROM [..\..\Daten\Vornamen Bonn\Vornamen 2017.csv]
(txt, utf8, embedded labels, delimiter is ';', msq)
where position=1;

RENAME FIELD vorname TO Vorname;
RENAME FIELD anzahl TO Anzahl;
RENAME FIELD geschlecht TO Geschlecht;

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

Vornamen:LOAD   vorname  ,anzahl  ,geschlecht  ,2010 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2010.csv](txt, utf8, embedded labels, delimiter is ';', msq); LOAD   vorname  ,anzahl  ,geschlecht  ,2011 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2011.csv](txt, utf8, embedded labels, delimiter is ';', msq); LOAD   vorname  ,anzahl  ,geschlecht  ,2012 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2012.csv](txt, utf8, embedded labels, delimiter is ';', msq); LOAD   vorname  ,anzahl  ,geschlecht  ,2013 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2013.csv](txt, utf8, embedded labels, delimiter is ';', msq); LOAD   vorname  ,anzahl  ,geschlecht  ,2014 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2014.csv](txt, utf8, embedded labels, delimiter is ';', msq); LOAD   vorname  ,anzahl  ,geschlecht  ,2015 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2015.csv](txt, utf8, embedded labels, delimiter is ';', msq); LOAD   vorname  ,anzahl  ,geschlecht  ,2016 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2016.csv](txt, utf8, embedded labels, delimiter is ';', msq); LOAD   vorname  ,anzahl  ,geschlecht// ,position  ,2017 as JahrFROM [..\..\Daten\Vornamen Bonn\Vornamen 2017.csv](txt, utf8, embedded labels, delimiter is ';', msq)where position=1; RENAME FIELD vorname TO Vorname;RENAME FIELD anzahl TO Anzahl;RENAME FIELD geschlecht TO Geschlecht;

Glossar: Maschinelles Lernen RStudio rnorm mean min median

Python-Beispiel: Die Würfel sind gefallen

Hej Leute,
heute gibt es Schlangenhappen zum Abendbrot. Ich habe für euch ein kleines Python-Skript geschrieben, um anhand einer Würfelsimulation ein paar Konzepte zu demonstrieren.
Ok, wir fangen langsam an. Eine zufällige Zahl erzeugen geht ganz einfach mit der Library random über die Funktion randint, welche auch alle möglichen weiteren Wahrscheinlichkeitsverteilungen, z.B Normal-, Beta- oder Binomialverteilung.

Python

# ganz einfach den Zufallsgenerator von Python benutzt
import random
for i in range(15):
print(random.randint(1,6))

def wuerfeln():
return(random.randint(1,6))
wuerfeln()

12345678

# ganz einfach den Zufallsgenerator von Python benutztimport randomfor i in range(15):    print(random.randint(1,6))   def wuerfeln():    return(random.randint(1,6))wuerfeln()    

Klassen in Python
Klassen kennt ihr vielleicht aus anderen objektorientierten Programmiersprachen (OOP). Eine Klasse ist im Prinzip der Datentyp eines Objekts und besteht aus Attributen und Methoden. Unsere Klasse heißt Wuerfel und soll – Überraschung – einen Würfel widerspiegeln. Ich erzeuge einen Würfel, indem ich ein neues Objekt der Klasse erzeuge. Das ruft nun den Konstruktor auf. Dabei gebe ich entweder nur die Anzahl Seiten an – die Wahrscheinlichkeit ist dann eine Gleichverteilung, d.h. jede Seite ist gleich wahrscheinlich – oder ich gebe explizit die Wahrscheinlichkeiten der einzelnen Seiten an.
Mit den get- und set-Funktionen können die Attribute, sprich Variablen, der Klasse abgerufen oder gesetzt werden.
Und natürlich soll der Würfel auch etwas machen, nämlich gewürfelt werden. Die Funktion wuerfeln erzeugt eine Zufallsstichprobe der Größe n.
Ist der Würfel fair?
Man spricht von einem fairen Würfel, wenn alle Seiten auf lange Sicht gleich häufig auftreten. Es muss also eine Gleichverteilung vorliegen. Um das statistisch zu testen, benötigen wir zuerst eine Stichprobe, die wir ja schnell mit unserer Funktion wuerfeln erzeugen können. Nun werden die absoluten Häufigkeiten der einzelnen Zahlen mit der Funktion unique aus der library numpy ermittelt. Numpy ist übrigens eine super wichtige Bibliothek, die effeziente Berechnungen ermöglicht und die man als Data Scientist unbedingt gut kennen sollte.
Auf die Häufigkeiten lassen wir nun einen Chi²-Test los. Die Nullhypothese geht von einer Gleichverteilung aus. Ist es sehr unwahrscheinlich, dass die Stichprobe – gegeben die Nullhypthese – gezogen wird, bekommen wir einen kleinen p-Wert. Liegt der p-Wert nun unter einer vorher festgelegten Grenze alpha, z.B. alpha =0,01, wird die Nullhypothese abgelehnt. In unserem Fall heißt das, dass der Würfel also nicht fair ist.
 
Der Python-Code für die Würfelsimulation
Und nun endlich der Code

Python

# so, ab jetzt wird es interessant
import numpy as np
from scipy.stats import chisquare

# Definition der Klasse Wuerfel
class Wuerfel(object):
#Konstruktor
#entweder nur die Anzahl Seiten angeben oder
#die Anzahl Seiten und die zugehörigen Wahrscheinlichkeiten
def __init__(self,seiten=6,wahrscheinlichkeiten=None):
self.seiten = seiten
if wahrscheinlichkeiten is None:
self.wahrscheinlichkeiten = np.repeat(1/seiten,seiten)
else:
self.wahrscheinlichkeiten = wahrscheinlichkeiten

def getSeiten(self):
return self.seiten
def setSeiten(self,seiten):
self.seiten=seiten
def getWahrscheinlichkeiten(self):
return self.wahrscheinlichkeiten
def setWahrscheinlichkeiten(self,wahrscheinlichkeiten):
self.seiten = wahrscheinlichkeiten.size
self.wahrscheinlichkeiten=wahrscheinlichkeiten

#die Funktion wuerfeln erzeugt ein Array der Länge n
def wuerfeln(self,n=1):
return(np.random.choice(np.arange(1, self.seiten+1),
size=n,p=self.wahrscheinlichkeiten))

# Wir erzeugen einen regulären 6-seitigen Würfel
W6 = Wuerfel(seiten=6)
# nun würfeln wir 100 Mal
sample1 = W6.wuerfeln(100)
# und zählen, wie häufig jede Zahl vorkommt
haeufigkeiten = np.unique(sample1, return_counts=True)[1]
# Der Chi²-Test prüft auf Gleichverteilung
chisquare(haeufigkeiten)

# Jetzt erzeugen wir einen gezinkten 6-seitigen Würfel,
# der viel zu häufig eine 6 würfelt
W6gezinkt = Wuerfel(seiten=6,wahrscheinlichkeiten=[0.1,0.1,0.1,0.1,0.1,0.5])
# und werfen diesen wieder 100 Mal
sample2 = W6gezinkt.wuerfeln(100)
haeufigkeiten = np.unique(sample2, return_counts=True)[1]
# hier sollte der Chi²-Test die Nullhypothese verwerfen
chisquare(haeufigkeiten)

# und noch schnell ein Histogramm gezeichnet
import matplotlib.pyplot as plt
plt.hist(sample1, density=True, bins=6)
plt.hist(sample2, density=True, bins=6)

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354

# so, ab jetzt wird es interessantimport numpy as npfrom scipy.stats import chisquare # Definition der Klasse Wuerfelclass Wuerfel(object):            #Konstruktor     #entweder nur die Anzahl Seiten angeben oder    #die Anzahl Seiten und die zugehörigen Wahrscheinlichkeiten    def __init__(self,seiten=6,wahrscheinlichkeiten=None):        self.seiten = seiten        if wahrscheinlichkeiten is None:            self.wahrscheinlichkeiten = np.repeat(1/seiten,seiten)        else:             self.wahrscheinlichkeiten = wahrscheinlichkeiten        def getSeiten(self):        return self.seiten    def setSeiten(self,seiten):        self.seiten=seiten    def getWahrscheinlichkeiten(self):        return self.wahrscheinlichkeiten    def setWahrscheinlichkeiten(self,wahrscheinlichkeiten):        self.seiten = wahrscheinlichkeiten.size        self.wahrscheinlichkeiten=wahrscheinlichkeiten            #die Funktion wuerfeln erzeugt ein Array der Länge n        def wuerfeln(self,n=1):        return(np.random.choice(np.arange(1, self.seiten+1),                                 size=n,p=self.wahrscheinlichkeiten))          # Wir erzeugen einen regulären 6-seitigen Würfel            W6 = Wuerfel(seiten=6) # nun würfeln wir 100 Mal       sample1 = W6.wuerfeln(100)# und zählen, wie häufig jede Zahl vorkommthaeufigkeiten = np.unique(sample1, return_counts=True)[1]# Der Chi²-Test prüft auf Gleichverteilungchisquare(haeufigkeiten) # Jetzt erzeugen wir einen gezinkten 6-seitigen Würfel,# der viel zu häufig eine 6 würfelt W6gezinkt = Wuerfel(seiten=6,wahrscheinlichkeiten=[0.1,0.1,0.1,0.1,0.1,0.5])# und werfen diesen wieder 100 Malsample2 = W6gezinkt.wuerfeln(100)haeufigkeiten = np.unique(sample2, return_counts=True)[1]# hier sollte der Chi²-Test die Nullhypothese verwerfenchisquare(haeufigkeiten) # und noch schnell ein Histogramm gezeichnetimport matplotlib.pyplot as pltplt.hist(sample1, density=True, bins=6)plt.hist(sample2, density=True, bins=6)

Happy coding,
Euer Holger
Glossar: Maschinelles Lernen RStudio rnorm mean min median

Was ist QlikView?

QlikView ist ein Produkt der Firma QlikTech, welches vor allem für das Erstellen von interaktiven Dashboards geeignet ist. Man kann relativ leicht sogenannte „Analyse-Apps“ erstellen, die dem Nutzer die Möglichkeit geben, tiefe Einblicke in die zugrundeliegenden Daten zu gewinnen. Dabei kontrolliert man, wie viele Freiheiten man dem Nutzer lässt – Stichwort self-service – bzw. wie restriktiv und statisch die Oberfläche sein soll. QlikTech selber nennt das „guided analytics“.
Neben dem Oberflächen-Design biete QlikView aber auch Rechtesteuerung, genügen Anbindungsmöglichkeiten von Datenquellen und eine ziemlich flexible Programmiersprache im Ladeskript. Das Ladeskript sorgt übrigens für die Aktualisierung der Daten.
 
Was kostet QlikView?
Die Personal Edition ist kostenlos, aber auch ziemlich eingeschränkt. Ich würde es eher als Testversion bezeichnen. Damit kann man nämlich nur eigene Applikationen öffnen. Mal eben ein Beispiel aus dem Hilfeforum öffnen oder die Applikation an jemand anderen mit der Personal Edition weiterzugeben funktioniert also nicht.
Um QlikView ernsthaft für mehr als Datenexploration (wofür es übrigens sehr gut geeignet ist) zu nutzen, kann man es leider nicht direkt kaufen, sondern muss über den Vertrieb oder Drittanbieter-Consultants gehen. Das macht irgendwie auch Sinn, denn für eine Business-Lösung braucht man einen Server, der die Applikationen via QlikView Access Point dem Nutzer über den Webbrowser zur Verfügung stellt und die Datenupdates koordiniert. Ok, theoretisch ginge es auch mit der qvw-Datei, die dann jeder in seiner Desktop-Installation öffnen würde. Hinzu kommen verschiedene Lizenzmodelle, also wenn man als Unternehmen QlikView nutzen will, empfiehlt es sich wirklich, Beratung in Anspruch zu nehmen.
 
Wie veröffentliche ich eine QlikView-Applikation?
Das kommt ein bisschen darauf an, was man zur Verfügung hat. Der einfachste Weg ist, die Datei mit Endung qvw jemand anderem zu geben, der auch QlikView auf seinem Desktop hat.
Der meiner Meinung nach besser, aber natürlich auch deutlich komplexere und teurere, Weg ist aber, die Applikation auf den AccessPoint zu stellen, so dass sie mit dem Webbrowser geöffnet werden kann. Ist erstmal der QlikView-Server eingerichtet, ist das Veröffentlichen einer Applikation per Management Console ziemlich einfach und komfortabel. Einstellungen wie Reload-Zeitpunkte und Nutzerkontrolle sind darin sehr komfortabel gelöst.
Glossar: Maschinelles Lernen RStudio rnorm mean min median

Was ist maschinelles Lernen

Hej Leute,
heute gibt es mal keinen Programmcode, sondern Grundsätzlicheres. Was ist denn eigentlich maschinelles Lernen und was hat das mit künstlicher Intelligenz zu tun, welche ja heutzutage das Buzzwort ist.
Wie der Name schon sagt, soll eine Maschine etwas lernen. Aber was und wie bringt man einem Computer etwas bei?
 
Allgemein gesagt verbergen sich hinter Maschinellem Lernen (engl. machine learning, Abkürzung ML) eine Reihe von Algorithmen, die zuerst mit Beispielen gefüttert werden – das bezeichnet man als Trainingsphase – und dann auf neue Daten losgelassen werden.
 
Beispiele für maschinelles Lernen
Handschriftliche Ziffern-Erkennung
Ein aktuell sehr beliebtes Beispiel ist das Erkennen von Ziffern. Der Rechner soll also ein Bild von einer per Hand geschriebenen Ziffer korrekt erkennen. Wie allgemein für die Bilderkennung haben sich auch hier Neuronale Netze als gute Algorithmen, d.h. mit einer hohen Trefferquote (engl. accuracy) bzw. niedrige Fehlerquote, herausgestellt. State of the art ist eine Fehlerquote von 0,21%. Das Beispiel ist so beliebt, weil es dazu den schönen Trainingsdatensatz MNIST mit 70.000 Bildern von Ziffern der Auflösung 28×28 Pixel gibt. Zudem kann der Aufbau von Neuronalen Netzen gut an dem Beispiel erklärt werden, aber natürlich eignen sich auch andere ML-Algorithmen wie Support Vector Machines für diese Art der Klassifizierung.
 
Recommendation Engine – Kunden kauften auch
Eine Recommendation Engine (auch recommender system) kennt eigentlich jeder, der schon mal in einem Online-Shop bestellt hat. Diese soll Produkte vorschlagen, welche ich hoffentlich auch noch kaufen möchte. Allgemeiner sollen anhand der über den Nutzer bekannten Daten die Objekte identifiziert werden, für die der Nutzer das größte Interesse hat.
Lineare Regression
Ein Klassiker in der Statistik ist die lineare Regression. Dabei geht es darum, eine Gerade so zu bestimmen, dass der quadratische Fehler minimiert wird. Und auch dieser Algorithmus lernt anhand von einem Beispieldatensatz, welches die optimale Gerade ist.
 
Trainings- und Testdatensatz
Nachdem man einen Algorithmus mit Hilfe des Trainingsdatensatzes angelernt hat, möchte man natürlich wissen, wie gut der Algorithmus nun abschneidet, bevor man ihn auf die „echte“ Welt loslässt. Dafür ist der Testdatensatz da. In der Praxis sieht es so aus, dass man den Datensatz, den man zur Verfügung hat, zuerst in einen Trainings- und einen Testdatensatz aufteilt, dann mit Hilfe des Trainingsdatensatzes lernt und am Testdatensatz die Güte überprüft. Wichtig dabei ist, dass der Testdatensatz nicht schon zum Lernen benutzt wurde, ansonsten droht Overfitting, also das zu starke Anpassen an den speziellen Datensatz.
Wer es noch komplizierter mag, der unterteilt den Trainingsdatensatz nochmal in einen Trainings- und einen Validierungsdatensatz. Der Validierungsdatensatz ist dafür da, die Hyperparameter eines Algorithmus zu optimieren, also zum Beispiel die Struktur eines neuronalen Netzes.
 
Güte eines Modells
Die Güte eines Modells wird häufig mit der Genauigkeit (engl. accuracy) angegeben. Bei einem binären Klassifikationsproblem, also einer Einteilung von Beobachtungen in zwei Klassen, wird die Genauigkeit mit Hilfe des Testdatensatzs bestimmt. Dazu wird gezählt, wie häufig der Algorithmus richtig lag, d.h. ob der Algorithmus die gleiche Klasse wie im Testdatensatz prognostiziert hat. Diese Anzahl wird dann durch die Anzahl Beobachtungen geteilt.
Anders herum kann man auch die Fehlerrate bestimmen, also die Anzahl, bei denen der Algorithmus falsch lag. Ist die Klassifikation ein ja oder nein, kann man noch die Fehler in Falsch-Positiv und  Falsch-Negativ unterteilen (ebenso natürlich auch die korrekten Vorhersagen in Richtig-Positiv und Richtig-Negativ). Dabei bedeutet Falsch-Positiv, dass der Algorithmus ja vorhersagt, obwohl nein richtig wäre. Falsch-Negativ heißt dementsprechend andersherum, dass der Algorithmus nein vorhersagt, obwohl ja richtig wäre.
Glossar: Maschinelles Lernen RStudio rnorm mean min median

Reguläre Ausdrücke in R erklärt

Hej Leute,
reguläre Ausdrücke sind super praktisch, um ein Muster in einem Text oder Vektor zu finden und ggf. zu ersetzen. Z.B. kann man ziemlich einfach überprüfen, ob eine Eingabe einer normalen Email-Adresse entspricht. In R sieht das dann so aus:

emails &lt;- c("max@fax.net","fax","1x1@1","max.mustermann@fax","max_mustermann@fax.de")
grepl("[A-Za-z0-9\\._%+-]+@[A-Za-z0-9\\.-]+\\.[A-Za-z]{2,}",emails)

12

emails &lt;- c("max@fax.net","fax","1x1@1","max.mustermann@fax","max_mustermann@fax.de")grepl("[A-Za-z0-9\\._%+-]+@[A-Za-z0-9\\.-]+\\.[A-Za-z]{2,}",emails)

 
Aber ganz langsam und der Reihe nach. Ihr seht schon, so ganz trivial sieht so ein regulärer Ausdruck nicht aus. Im Grunde ist er aber ganz logisch aufgebaut und gar nicht so schwer.
 
Aufbau eines regulären Ausdrucks
Grundsätzlich ist ein regulärer Ausdruck einfach ein String, also eine Zeichenkette. Dabei kommt die Power aber von den Steuerzeichen. Diese erlauben es, komplexe Abfragen wie die obige, ob es sich um eine gültige Email-Adresse handelt, zu generieren.
 
Am besten lernt man anhand von Beispielen. Also los geht’s:

# Wir erzeugen uns einen Beispieltext
text &lt;- "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet."

# Wörter aus String anhand Leerzeichen herausziehen
woerter &lt;- strsplit(text,' ')[[1]]

12345

# Wir erzeugen uns einen Beispieltexttext &lt;- "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet." # Wörter aus String anhand Leerzeichen herausziehenwoerter &lt;- strsplit(text,' ')[[1]]

Das war im Prinzip schon der erste reguläre Ausdruck nämlich ‚ ‚. Ok, nicht sonderlich spektakulär, gebe ich zu. Aber der einfachste Fall ist einfach eine ganz normale Zeichenkette:

# Befindet sich mindestens ein a in dem String?
grepl("a",text)
# Befindet sich mindestens ein a in den Wörtern?
grepl("a",woerter)
# Gib die Wörter aus, welche mindestens ein a enthalten
woerter[grepl("a",woerter)]

123456

# Befindet sich mindestens ein a in dem String?grepl("a",text)# Befindet sich mindestens ein a in den Wörtern?grepl("a",woerter)# Gib die Wörter aus, welche mindestens ein a enthaltenwoerter[grepl("a",woerter)]

Jetzt kommt die Power der Steuerungszeichen:
Mit dem senkrechten Strich (pipe=’|‘) lassen sich Oder-Abfragen erzeugen
Mit runden Klammern () bildet man Gruppen
Mit eckigen Klammern [] gibt man Mengen an
Der Punkt steht für ein beliebiges Zeichen

# Der senkrechte Strich (pipe) | bedeutet 'ODER'
# Gib TRUE aus, falls das Wort ein a oder b enthält
grepl("a|b",woerter)
# Gib nur die Wörter aus, welche ab oder ba enthalten
woerter[grepl("ab|ba",woerter)]

# Mit runden Klammern () bildet man Gruppen
# Wieviele Wörter enthalten ein l und danach ein a oder o?
sum(grepl("l(a|o)",woerter))

# Mit eckigen Klammern [] gibt man Mengen an
# Ersetze alle Vorkommen von a, e oder i durch ö
gsub("[aei]","ö",woerter)
# Der Bindestrich gibt einen Bereich an
# Alle Großbuchstaben durch eine 9 ersetzen
gsub("[A-Z]","9",woerter)
# Mit ^ innerhalb der eckigen Klammer negiert man den Ausdruck
# Achtung, der folgende Ausdruck gibt nicht die Anzahl Wörter zurück, welche kein e enthalten,
# sondern die Anzahl Wörter, welche mindestens einen Buchstaben enthalten, der kein e ist,
# also alle Wörter, die nicht nur aus e bestehen
sum(grepl("[^e]",woerter))

# Der Punkt . steht für ein beliebiges Zeichen
woerter[grepl("do.or",woerter)]

123456789101112131415161718192021222324

# Der senkrechte Strich (pipe) | bedeutet 'ODER'# Gib TRUE aus, falls das Wort ein a oder b enthältgrepl("a|b",woerter)# Gib nur die Wörter aus, welche ab oder ba enthaltenwoerter[grepl("ab|ba",woerter)] # Mit runden Klammern () bildet man Gruppen# Wieviele Wörter enthalten ein l und danach ein a oder o?sum(grepl("l(a|o)",woerter)) # Mit eckigen Klammern [] gibt man Mengen an# Ersetze alle Vorkommen von a, e oder i durch ögsub("[aei]","ö",woerter)# Der Bindestrich gibt einen Bereich an# Alle Großbuchstaben durch eine 9 ersetzengsub("[A-Z]","9",woerter)# Mit ^ innerhalb der eckigen Klammer negiert man den Ausdruck# Achtung, der folgende Ausdruck gibt nicht die Anzahl Wörter zurück, welche kein e enthalten,# sondern die Anzahl Wörter, welche mindestens einen Buchstaben enthalten, der kein e ist,# also alle Wörter, die nicht nur aus e bestehensum(grepl("[^e]",woerter)) # Der Punkt . steht für ein beliebiges Zeichenwoerter[grepl("do.or",woerter)]

Jetzt wird es komplexer. Mit Quantifizierern kann man angeben, wie häufig eine Gruppe/ein Ausdruck vorkommen darf. Man kann dabei Mindestvorkommen und Maximalvorkommen definieren.

# *,+,?,{}
# Diese Quantifizierer kommen nach einem Zeichen oder Gruppe und bedeuten folgendes:
# * 0 oder mehrfaches Vorkommen
# + 1 oder mehrfaches Vorkommen
# ? 0 oder 1-faches Vorkommen
# {n} n-faches Vorkommen, wobei n eine Zahl ist
# {m,} mindestens m Vorkommen
# {n,m} zwischen n und m-fachem Vorkommen

# großes A mit optional folgenden beliebig vielen b und dann ein c
grepl("Ab*c",c("Abc","Ac","b","Abbbc"))
# großes A mit mindestens einem folgenden b und dann ein c
grepl("Ab+c",c("Abc","Ac","b","Abbbc"))
# großes A mit höchstens einem b und dann ein c
grepl("Ab?c",c("Abc","Ac","b","Abbbc"))
# großes A mit genau 3 b und dann ein c
grepl("Ab{3}c",c("Abc","Ac","b","Abbbc"))
# großes A mit mindestens einem b und dann ein c (wie +)
grepl("Ab{1,}c",c("Abc","Ac","b","Abbbc"))
# großes A mit einem bis drei b und dann ein c
grepl("Ab{1,3}c",c("Abc","Ac","b","Abbbc"))

123456789101112131415161718192021

# *,+,?,{}# Diese Quantifizierer kommen nach einem Zeichen oder Gruppe und bedeuten folgendes:# * 0 oder mehrfaches Vorkommen# + 1 oder mehrfaches Vorkommen# ? 0 oder 1-faches Vorkommen# {n} n-faches Vorkommen, wobei n eine Zahl ist# {m,} mindestens m Vorkommen# {n,m} zwischen n und m-fachem Vorkommen # großes A mit optional folgenden beliebig vielen b und dann ein cgrepl("Ab*c",c("Abc","Ac","b","Abbbc"))# großes A mit mindestens einem folgenden b und dann ein cgrepl("Ab+c",c("Abc","Ac","b","Abbbc"))# großes A mit höchstens einem b und dann ein cgrepl("Ab?c",c("Abc","Ac","b","Abbbc"))# großes A mit genau 3 b und dann ein cgrepl("Ab{3}c",c("Abc","Ac","b","Abbbc"))# großes A mit mindestens einem b und dann ein c (wie +)grepl("Ab{1,}c",c("Abc","Ac","b","Abbbc"))# großes A mit einem bis drei b und dann ein cgrepl("Ab{1,3}c",c("Abc","Ac","b","Abbbc"))

Willst Du den Anfang oder Ende eines Strings überprüfen, brauchst Du die Steuerzeichen „Dach“ und „Dollar“. Damit kannst Du Abfragen machen wie „Fängt die Zeichenkette mit dem folgenden Buchstaben/Wort/… an“

# ^ und $ = # Anfang und Ende des Strings
# Welche Wörter fangen mit großem oder kleinem d an
woerter[grepl("^[Dd]",woerter)]
# Welche Wörter enden mit einem t
woerter[grepl("t$",woerter)]

12345

# ^ und $ = # Anfang und Ende des Strings# Welche Wörter fangen mit großem oder kleinem d anwoerter[grepl("^[Dd]",woerter)]# Welche Wörter enden mit einem twoerter[grepl("t$",woerter)]

 
 
Sonderzeichen in regulären Ausdrücken in R
Die Frage, wie man denn nun einen Punkt, eine Klammer oder ein Fragezeichen in einem pattern vergleichen kann, stellt sich häufig. In R ist die Lösung ganz einfach, ein doppelter Backslash, also z.B. \\. für einen Punkt, \\? für ein Fragezeichen usw.

# Aufsplitten des Textes anhand .
saetze &lt;- strsplit(text,'\\.')[[1]]

12

# Aufsplitten des Textes anhand .saetze &lt;- strsplit(text,'\\.')[[1]]

String-Suche und Ersetzen in R
Eigentlich sind die im Beispiel vorgekommen R-Befehle schon die wichtigsten zu den regulären Ausdrücken.
Mit den Befehlen grep und grepl wird ein Pattern in einem String-Vektor gesucht. Dabei gibt grep die Indizes mit einem match zurück, grepl gibt einen Vektor mit TRUE/FALSE-Werten zurück.
Mit den R-Befehlen sub und gsub lassen sich solche Pattern ersetzen. Dabei ersetzt sub das erste Vorkommen, gsub alle Vorkommen des Patterns. Meistens verwende ich gsub.
Mit strsplit könnt Ihr einen oder mehrere String anhand von Trennzeichen aufsplitten. Meistens genügt hier das Trennzeichen, aber die Funktion nimmt auch reguläre Ausdrücke an. Sehr nützlich, wenn man eine unsaubere csv-Datei hat, die mehrere Trennzeichen als Spaltentrenner enthält.
Es gibt noch mehr Funktionen, nämlich regmatches, regexpr, gregexpr und regexec, aber ehrlich gesagt benutze ich diese fast nie.
Fazit also: Merkt Euch die Befehle grepl, gsub und strsplit, mehr braucht Ihr normalerweise nicht.
 
 
Dateien eines Verzeichnisses in R anzeigen lassen
Der Befehl list.files zeigt alle Dateien und Unterordner eines Verzeichnisses an. Dabei kann man mittels des Parameters pattern die Dateinamen mittels regulärer Ausdrücke filtern. Im Databraineo R-Glossar findet Ihr einen Eintrag zu list.files mit Erklärung und Beispielen.
 
Online RegEx-Tools
Wer ein bisschen mit regulären Ausdrücken experimentieren will oder mal eben schnell checken, ob , der eingegebene String funktioniert, findet auf https://regexr.com/ oder https://regex101.com/ Online-Tools zum Nachschauen und Testen.
Viel Spaß beim Ausprobieren,
Euer Holger
Glossar: Maschinelles Lernen RStudio rnorm mean min median list.files

R Performance: Funktionale Programmierung statt for-Schleife

Hej Leute,
hier geht es um die Vorteile funktionaler Programmierung, denn diese sind so groß, dass jeder R-Programmierer diese kennen sollte. Und keine Angst, das ist gar nicht so schwer.
 
Was ist denn funktionale Programmierung?
Fangen wir mit der iterativen Programmierung an, also dem schrittweise Vorgehen. Damit sind im Wesentlichen Schleifen (for, while) gemeint. Diese sind – vor allem in R – nicht sonderlich effizient, weil jeder Schritt eben nacheinander abgearbeitet werden muss, und das dauern dann bei großen Datensätzen ziemlich lang.
Hier ein ganz einfaches Beispiel, welches zu jedem Element eines Vektors eins addiert.

x = rnorm(1000)
for (i in 1:length(x)) x[i]<-x[i]+1

12

x = rnorm(1000)for (i in 1:length(x)) x[i]<-x[i]+1

 
Ok, die kürzere und viel schnellere Variante kennt ihr natürlich alle:

x <- x+1

1

x <- x+1

Und das ist schon simples funktionales Vorgehen. Prinzipiell gibt es Funktionen, die eine Funktion auf alle Elemente eines Vektors bzw. Zeilen oder Spalten eines Data.frames  anwenden, was hochgradig parallelisierbar und dementsprechend schnell ist. Natürlich gibt es Situationen, da kommt man um Schleifen nicht herum, aber man kann erstaunlich viele vermeiden.
 
lapply, sapply, vapply
R selber bietet für die funktionale Programmierung die apply-Funktionen:
lapply(x, funktion) wendet die angegebene Funktion auf x an und gibt eine Liste zurück
sapply (x, funktion) macht das gleiche, gibt aber einen Vektor oder eine Matrix zurück
vapply (x, funktion, typ) macht ebenfalls das gleiche, gibt aber den Vektor oder Matrix von dem angegebenen Typ zurück.
tapply(x, y, funktion) gruppiert x nach den Ausprägungen von y und wendet auf jede Gruppe die angegebene Funktion an
 
Was können wir damit alles anstellen? Hier ein paar Beispiele

# berechnet den Mittelwert pro Spalte (wie colMeans)
sapply(iris[,-5],mean)

# berechnet die Differenz zwischen Maximum und Minimum pro Spalte
vapply(iris[,-5],function(x) max(x)-min(x),double(1))

# gruppiert den Datensatz mtcars nach cyl (Anzahl Zylinder) und
# berechnet dann für jede Gruppe den Mittelwert von mpg (Miles per Gallon)
tapply(mtcars$mpg,mtcars$cyl,mean)

123456789

# berechnet den Mittelwert pro Spalte (wie colMeans)sapply(iris[,-5],mean) # berechnet die Differenz zwischen Maximum und Minimum pro Spaltevapply(iris[,-5],function(x) max(x)-min(x),double(1)) # gruppiert den Datensatz mtcars nach cyl (Anzahl Zylinder) und# berechnet dann für jede Gruppe den Mittelwert von mpg (Miles per Gallon)tapply(mtcars$mpg,mtcars$cyl,mean)

 
Und zum Schluss noch der Tipp, vapply zu verwenden, sofern möglich, da der Rückgabetyp klar definiert ist, wie folgendes Beispiel zeigt:

#gibt eine Liste zurück
lapply(1:5, identity)
#gibt einen Integer-Vektor zurück
sapply(1:5, identity)
#gibt eine leere Liste zurück
sapply(integer(), identity)
#gibt einen Integer-Vektor zurück
vapply(1:5, identity,integer(1))
#gibt einen leeren Integer-Vektor zurück
vapply(integer(), identity,integer(1))

12345678910

#gibt eine Liste zurücklapply(1:5, identity)#gibt einen Integer-Vektor zurücksapply(1:5, identity)#gibt eine leere Liste zurücksapply(integer(), identity)#gibt einen Integer-Vektor zurückvapply(1:5, identity,integer(1))#gibt einen leeren Integer-Vektor zurückvapply(integer(), identity,integer(1))

Noch etwas eleganter geht es mit dem Package purrr aus dem tidyverse. Dazu aber ein andernmal mehr.
 
Happy coding,
Euer Holger
Glossar: Maschinelles Lernen RStudio rnorm mean min median list.files colMeans

R-Bite: Spalten auswählen – Entdecke die Möglichkeiten

Hej Leute,
heute trage ich im R-Bite mal zusammen, wie ihr in R Spalten eines data.frames auswählen könnt. Es gibt nämlich eine ganze Menge davon. Eigentlich ist die Vielfalt ja toll und man hat selbst sowieso eine Lieblingsmethode. Auf der anderen Seite macht es das Lesen von R-Code von anderen manchmal ganz schön schwer. Aber schaut selbst:
Indizes

#erste Spalte
iris[,1]
#erste bis dritte Spalte
iris[,1:3]
#erste und fünfte Spalte
iris[,c(1,5)]

123456

#erste Spalteiris[,1]#erste bis dritte Spalteiris[,1:3]#erste und fünfte Spalteiris[,c(1,5)]

Spaltennamen

colnames(iris)
#die Spalte Sepal.Length. Praktisch, weil Ergänzung mit TAB
iris$Sepal.Length
#das gleiche
iris[,"Sepal.Length"]
#zwei Spalten per Name auswählen
iris[,c("Sepal.Length","Sepal.Width")]

1234567

colnames(iris)#die Spalte Sepal.Length. Praktisch, weil Ergänzung mit TABiris$Sepal.Length#das gleicheiris[,"Sepal.Length"]#zwei Spalten per Name auswähleniris[,c("Sepal.Length","Sepal.Width")]

Bedingungen

iris[,grepl("Sepal",colnames(iris))]

1

iris[,grepl("Sepal",colnames(iris))]

Subset

subset(iris,select=c(Sepal.Length))

1

subset(iris,select=c(Sepal.Length))

Dplyr: select
Die Syntax aus dem Tidyverse

library(dplyr)
select(iris, Sepal.Length,Sepal.Width)
#oder mit pipe-Schreibweise
iris %&gt;% select(Sepal.Length,Sepal.Width)

1234

library(dplyr)select(iris, Sepal.Length,Sepal.Width)#oder mit pipe-Schreibweiseiris %&gt;% select(Sepal.Length,Sepal.Width)

Data.Table
Das Package Data.Table ist ziemlich schnell, wenn es um größere Datenmengen geht.

library(data.table)
#in data.table konvertieren
dt &lt;- as.data.table(iris)
dt[ , .(Sepal.Length,Sepal.Width)]

1234

library(data.table)#in data.table konvertieren dt &lt;- as.data.table(iris)dt[ , .(Sepal.Length,Sepal.Width)]

Viel Spaß beim Coden!
Glossar: Maschinelles Lernen RStudio rnorm mean min median list.files colMeans

R-Package: sqldf – SQL-Befehle in R

Hej Leute,
hier kommt für euch das nächste R-Häppchen:
Kennt ihr schon das Package sqldf? Das ist für alle SQL-Jünger unter uns. Damit können wir R um SQL-Fähigkeiten erweitern. Genauer gesagt können wir SQL-Statements auf dataframes anwenden.
Wie macht sqldf das? Es erstellt eine temporäre Datenbank, importiert den dataframe in die Datenbank, führt das sqlite-Statement aus und gibt den Output zurück. Und das geht erstaunlich schnell, zum Teil schneller als direkt in R zu rechnen.
Und das beste ist, dass wir uns darum überhaupt nicht kümmern müssen, sondern einfach das SQL-Statement aufrufen können.
Also wie jedes CRAN-Package installieren

install.packages("sqldf")

1

install.packages("sqldf")

 
Ich liebe die schnellen Aggregierungsmöglichkeiten mit der group by-Funktionalität:

library(sqldf)
# Zählt die Anzahl Einträge und berechnet die Sepal-Mittelwerte
sqldf("select
Species,
count(1) as n,
avg([Sepal.Length]) as MW_SepalLength,
avg([Sepal.Width]) as MW_SepalWidth
from iris
group by Species
order by Species")

12345678910

library(sqldf)# Zählt die Anzahl Einträge und berechnet die Sepal-Mittelwerte sqldf("select        Species,        count(1) as n,        avg([Sepal.Length]) as MW_SepalLength,        avg([Sepal.Width]) as MW_SepalWidth        from iris        group by Species        order by Species")

Wer mehr wissen will, schaut einfach mal auf die Github-Seite zu sqldf, dort gibt es noch einen Haufen weiterer Beispiele.
Lasst den SQL-Geek in euch raus und habt Spaß dabei,
Euer Holger
Glossar: Maschinelles Lernen RStudio rnorm mean min median list.files colMeans

Loading

Newsletter

Immer informiert

Melde Dich zu meinem Newsletter an, der News, Angeboten und Eventeinladungen aus dem deutschen Data Science-Universum enthält.

Du erhältst mit dem Eintrag als DANKESCHÖN mein E-Book „Power-Tricks für das Datenmanagement in R“.

Du bist noch einen Schritt vom Ebook entfernt. Ich habe Dir soeben eine Email geschickt. Bitte klicke auf den dort hinterlegten Link.